From f7f1b604443c030afe29d1059b90f72c69afe081 Mon Sep 17 00:00:00 2001 From: Colin McDonnell Date: Wed, 9 Nov 2022 15:40:40 -0800 Subject: [PATCH] Add bun-types, add typechecking, add `child_process` types (#1475) * Add bun-types to packages * Improve typing * Fix types in tests * Fix dts tests * Run formatter * Fix all type errors * Add strict mode, fix type errors * Add ffi changes * Move workflows to root * Add workflows * Remove labeler * Add child_process types * Fix synthetic defaults issue * Remove docs * Move scripts * Run prettier * Include examples in typechecking * captureStackTrace types * moved captureStackTrace types to globals * Address reviews Co-authored-by: Colin McDonnell Co-authored-by: Dylan Conway --- .github/workflows/bun-types-release.yml | 137 + .github/workflows/bun-types-tests.yml | 39 + .prettierignore | 9 + .prettierrc | 7 + .vscode/settings.json | 10 +- Makefile | 17 +- README.md | 634 ++- bench/bun.lockb | Bin 0 -> 35685 bytes bench/ffi/src/bun.lockb | Bin 1643 -> 1903 bytes .../css-stress-test/bun.lockb | Bin 0 -> 337189 bytes .../css-stress-test/pages/_app.tsx | 1 + .../css-stress-test/pages/index.tsx | 1 + .../css-stress-test/src/main.tsx | 8 +- .../css-stress-test/tsconfig.json | 4 +- bench/scanner/bun.lockb | Bin 6186 -> 8640 bytes bench/websocket-server/bun.lockb | Bin 0 -> 2466 bytes bench/websocket-server/package.json | 3 - bench/websocket-server/tsconfig.json | 16 +- bun.lockb | Bin 31313 -> 77408 bytes examples/bun-hot-websockets.js | 2 +- examples/cat.ts | 4 +- examples/html-rewriter.ts | 9 +- examples/http-file.ts | 2 +- examples/http-request-body.ts | 3 +- examples/lambda.ts | 24 +- examples/macros/bun.lockb | Bin 0 -> 5816 bytes examples/macros/components/covid19.tsx | 2 +- examples/macros/components/example.jsx | 2 +- examples/macros/mystery-box.ts | 9 +- examples/react-fast-refresh-test/bun.lockb | Bin 0 -> 352211 bytes .../react-fast-refresh-test/tsconfig.json | 18 +- examples/spawn.ts | 15 +- examples/tsconfig.json | 8 - misctools/gen-unicode-table.js | 12 +- misctools/headers-cleaner.js | 8 +- misctools/mime.js | 2 +- misctools/publish-examples.js | 16 +- package.json | 18 +- packages/bun-error/index.tsx | 56 +- packages/bun-error/markdown.ts | 6 +- packages/bun-error/runtime-error.ts | 6 +- packages/bun-error/sourcemap.ts | 2 +- packages/bun-error/tsconfig.json | 7 +- packages/bun-framework-next/bun.lockb | Bin 0 -> 13859 bytes .../bun-framework-next/client.development.tsx | 36 +- .../fallback.development.tsx | 8 +- packages/bun-framework-next/page-loader.ts | 4 +- .../bun-framework-next/renderDocument.tsx | 50 +- .../bun-framework-next/server.development.tsx | 4 +- packages/bun-framework-next/tsconfig.json | 27 +- packages/bun-landing/bun.lockb | Bin 12479 -> 15854 bytes packages/bun-landing/components/CodeBlock.tsx | 2 +- packages/bun-landing/components/dataURI.ts | 2 +- packages/bun-landing/next.config.js | 2 +- packages/bun-landing/pages/_app.tsx | 8 +- packages/bun-landing/pages/index.tsx | 12 +- packages/bun-landing/tsconfig.json | 16 +- packages/bun-macro-relay/bun-macro-relay.tsx | 2 +- packages/bun-macro-relay/bun.lockb | Bin 0 -> 1190 bytes packages/bun-types/.eslintignore | 5 + packages/bun-types/.eslintrc.cjs | 23 + packages/bun-types/.gitignore | 2 + packages/bun-types/.prettierignore | 1 + packages/bun-types/README.md | 55 + packages/bun-types/assert.d.ts | 968 ++++ packages/bun-types/buffer.d.ts | 2089 +++++++++ packages/bun-types/bun-test.d.ts | 44 + packages/bun-types/bun.d.ts | 2768 ++++++++++++ packages/bun-types/bun.lockb | Bin 0 -> 76065 bytes packages/bun-types/child_process.d.ts | 1702 +++++++ packages/bun-types/constants.d.ts | 18 + packages/bun-types/crypto.d.ts | 3918 ++++++++++++++++ packages/bun-types/domain.d.ts | 170 + packages/bun-types/events.d.ts | 647 +++ packages/bun-types/ffi.d.ts | 813 ++++ packages/bun-types/fs.d.ts | 3935 +++++++++++++++++ packages/bun-types/fs/promises.d.ts | 677 +++ packages/bun-types/globals.d.ts | 2562 +++++++++++ packages/bun-types/header.txt | 8 + packages/bun-types/html-rewriter.d.ts | 113 + packages/bun-types/http.d.ts | 902 ++++ packages/bun-types/images/README.md | 15 + packages/bun-types/index.d.ts | 36 + packages/bun-types/index.js | 0 packages/bun-types/jsc.d.ts | 60 + packages/bun-types/module.d.ts | 16 + packages/bun-types/os.d.ts | 437 ++ packages/bun-types/package.json | 18 + packages/bun-types/path.d.ts | 204 + packages/bun-types/punycode.d.ts | 113 + packages/bun-types/querystring.d.ts | 148 + packages/bun-types/scripts/bundle.ts | 72 + packages/bun-types/scripts/gpr.ts | 11 + .../bun-types/scripts/utils/getDotTsFiles.ts | 25 + packages/bun-types/sqlite.d.ts | 747 ++++ packages/bun-types/stream.d.ts | 1482 +++++++ packages/bun-types/string_decoder.d.ts | 65 + packages/bun-types/supports-color.d.ts | 55 + packages/bun-types/tests/index.d.ts | 5 + packages/bun-types/tests/index.test-d.ts | 71 + packages/bun-types/tests/tcp.test-d.ts | 132 + packages/bun-types/timers.d.ts | 24 + packages/bun-types/tsconfig.docs.json | 25 + packages/bun-types/tsconfig.json | 21 + packages/bun-types/tty.d.ts | 17 + packages/bun-types/typedoc.json | 8 + packages/bun-types/url.d.ts | 347 ++ packages/bun-types/util.d.ts | 1183 +++++ packages/bun-types/zlib.d.ts | 554 +++ packages/bun-wasm/bun.lockb | Bin 6328 -> 7597 bytes packages/bun-wasm/index.ts | 15 +- src/.prettierignore | 1 - src/api/bun.lockb | Bin 5938 -> 7147 bytes src/api/demo/bun.lockb | Bin 63276 -> 76858 bytes src/api/demo/lib/api.ts | 12 +- src/api/demo/lib/run.ts | 4 +- src/api/demo/lib/scan.ts | 2 +- src/api/demo/next-env.d.ts | 5 +- src/api/demo/package-lock.json | 273 ++ src/api/demo/package.json | 3 +- src/api/demo/pages/_app.js | 6 +- src/api/demo/pages/api/hello.js | 4 +- src/api/demo/pages/index.tsx | 15 +- src/api/demo/pages/scan.tsx | 16 +- src/api/demo/pages/two.tsx | 1 + src/api/demo/schema.d.ts | 144 +- src/api/demo/schema.js | 54 +- src/api/demo/tsconfig.json | 13 +- src/api/package.json | 2 +- src/api/schema.d.ts | 144 +- src/api/schema.js | 56 +- src/bun.js/assert.exports.js | 150 +- src/bun.js/bindings/sqlite/sqlite.exports.js | 26 +- src/bun.js/child_process.exports.js | 34 +- src/bun.js/depd.exports.js | 2 +- src/bun.js/ffi.exports.js | 18 +- src/bun.js/fs.exports.js | 12 +- src/bun.js/http.exports.js | 10 +- src/bun.js/net.exports.js | 2 +- src/bun.js/perf_hooks.exports.js | 2 +- src/bun.js/scripts/class-definitions.ts | 9 +- src/bun.js/scripts/generate-classes.ts | 243 +- src/bun.js/scripts/generate-jssink.js | 22 +- src/bun.js/streams.exports.js | 188 +- src/bun.js/url.exports.js | 454 +- src/bun.js/ws.exports.js | 2 +- src/cli/tsconfig-for-init.json | 9 +- src/fallback.ts | 3 +- src/node-fallbacks/@vercel_fetch.js | 2 +- src/node-fallbacks/assert.js | 2 +- src/node-fallbacks/events.js | 22 +- src/node-fallbacks/net.js | 28 +- src/react-refresh.js | 343 +- src/runtime.footer.node.js | 4 +- src/runtime.js | 24 +- src/runtime/errors.ts | 1 + src/runtime/hmr.ts | 97 +- src/runtime/index-with-refresh.ts | 3 +- src/runtime/index-without-hmr.ts | 1 + src/runtime/index.ts | 1 + src/runtime/regenerator.ts | 15 +- src/test/fixtures/browsermap-false.ts | 1 + .../fixtures/cannot-assign-to-import-bug.js | 110 +- src/test/fixtures/class-with-property.ts | 1 + .../default_export_hmr_identifier_ref.tsx | 1 + src/test/fixtures/exports-bug.js | 122 +- .../fixtures/json-parser-in-typescript.js | 3 +- .../fixtures/json-parser-in-typescript.ts | 28 +- src/test/fixtures/main-field.ts | 1 + src/test/fixtures/namespaced-validators.ts | 2 +- src/test/fixtures/out.esbuild.js | 3 +- src/test/fixtures/simple-150x.jsx | 4 +- src/test/fixtures/simple.jsx | 4 +- src/test/fixtures/tsconfig.json | 8 +- src/test/fixtures/type-only-import.ts | 3 +- .../fixtures/typescript-is-turing-complete.ts | 7 +- test/bun.js/arraybuffersink.test.ts | 17 +- test/bun.js/bigint.test.js | 12 +- test/bun.js/body-mixin-errors.test.ts | 2 +- test/bun.js/body-stream.test.ts | 90 +- test/bun.js/buffer.test.js | 26 +- test/bun.js/bun-write.test.js | 30 +- test/bun.js/bundled/tsconfig.json | 4 +- test/bun.js/child_process-node.test.js | 46 +- test/bun.js/child_process.test.ts | 21 +- test/bun.js/concat.test.js | 6 +- test/bun.js/console-log.js | 6 +- test/bun.js/decorators.test.ts | 5 +- test/bun.js/escapeHTML.test.js | 38 +- test/bun.js/event-emitter.test.ts | 1 + test/bun.js/fetch.test.js | 28 +- test/bun.js/ffi.test.fixture.callback.c | 3 - test/bun.js/ffi.test.js | 36 +- test/bun.js/fileUrl.test.js | 4 +- test/bun.js/filesink.test.ts | 12 +- test/bun.js/fs-stream.js | 2 +- test/bun.js/fs.test.js | 36 +- test/bun.js/html-rewriter.test.js | 42 +- test/bun.js/import-meta.test.js | 4 +- test/bun.js/inspect.test.js | 40 +- test/bun.js/log-test.test.ts | 4 +- test/bun.js/microtask.test.js | 4 +- test/bun.js/node-test-helpers.test.js | 2 +- test/bun.js/oniguruma-regexp.test.ts | 227 +- test/bun.js/os.test.js | 10 +- test/bun.js/path.test.js | 20 +- test/bun.js/peek.test.ts | 11 +- test/bun.js/performance.test.js | 2 +- test/bun.js/plugins.d.ts | 11 + test/bun.js/plugins.test.ts | 24 +- test/bun.js/print-process-args.js | 4 +- test/bun.js/process-args.test.js | 56 +- test/bun.js/process-nexttick.js | 6 +- test/bun.js/process-nexttick.test.js | 6 +- test/bun.js/process.test.js | 4 +- test/bun.js/react-dom-server.bun.cjs | 3122 ++++++++++++- test/bun.js/react-dom.test.tsx | 20 +- test/bun.js/resolve-error.test.ts | 2 +- test/bun.js/resolve.test.js | 58 +- test/bun.js/serve.test.ts | 28 +- test/bun.js/snapshots.debug.js | 9 +- test/bun.js/snapshots.js | 9 +- test/bun.js/solid-dom-fixtures/SVG/code.js | 2 +- .../attributeExpressions/code.js | 2 +- .../solid-dom-fixtures/customElements/code.js | 2 +- test/bun.js/some-fs.js | 6 +- test/bun.js/spawn.test.ts | 36 +- test/bun.js/sql-raw.test.js | 26 +- test/bun.js/sqlite.test.js | 46 +- test/bun.js/streams.test.js | 2 +- test/bun.js/string-decoder.test.js | 88 +- test/bun.js/tcp-server.test.ts | 8 +- test/bun.js/test_scope_debug.ts | 27 +- test/bun.js/text-decoder.test.js | 2 +- test/bun.js/text-encoder.test.js | 6 +- test/bun.js/toml.test.js | 4 +- test/bun.js/transpiler.test.js | 280 +- test/bun.js/tsconfig.json | 23 +- test/bun.js/url.test.ts | 31 +- test/bun.js/util/util-promisify.test.js | 147 +- test/bun.js/util/util.test.js | 10 +- test/bun.js/web-crypto.test.ts | 12 +- test/bun.js/web-globals.test.js | 6 +- test/bun.js/websocket-server.test.ts | 57 +- test/bun.js/which.test.ts | 8 +- test/macro/fetchSync.tsx | 1 + test/macro/macro.d.ts | 1 + test/scripts/browser.js | 8 +- test/snippets/bun.lockb | Bin 27153 -> 36836 bytes test/snippets/caught-require.js | 4 +- .../code-simplification-neql-define.js | 8 +- test/snippets/export.js | 2 +- test/snippets/jsx-entities.jsx | 2 +- test/snippets/jsx-spacing.js | 41 +- test/snippets/jsx-spacing.jsx | 6 +- test/snippets/jsx-top-level.tsx | 1 + test/snippets/latin1-chars-in-regexp.js | 8 +- .../inexact/browser/dir/foo.js | 2 +- .../_node_modules_copy/inexact/browser/foo.js | 2 +- .../inexact/browser/index.js | 2 +- .../_node_modules_copy/inexact/default/foo.js | 2 +- .../_node_modules_copy/inexact/node/foo.js | 2 +- .../js-only-exports/browser/dir/foo.js | 2 +- .../js-only-exports/browser/foo.js | 2 +- .../js-only-exports/browser/index.js | 2 +- .../js-only-exports/default/foo.js | 2 +- .../js-only-exports/node/foo.js | 2 +- test/snippets/react-context-value-func.tsx | 1 + test/snippets/simple-lit-example.ts | 3 +- test/snippets/spread_with_key.tsx | 1 + test/snippets/styledcomponents-output.js | 6 +- test/snippets/template-literal.js | 4 +- test/snippets/ts-fallback-rewrite-works.ts | 1 + test/snippets/tsx-fallback-rewrite-works.tsx | 1 + test/snippets/type-only-imports.ts | 1 + tsconfig.base.json | 24 + tsconfig.json | 30 +- 277 files changed, 34091 insertions(+), 2462 deletions(-) create mode 100644 .github/workflows/bun-types-release.yml create mode 100644 .github/workflows/bun-types-tests.yml create mode 100644 .prettierignore create mode 100644 .prettierrc create mode 100755 bench/bun.lockb create mode 100755 bench/hot-module-reloading/css-stress-test/bun.lockb create mode 100755 bench/websocket-server/bun.lockb create mode 100755 examples/macros/bun.lockb create mode 100755 examples/react-fast-refresh-test/bun.lockb delete mode 100644 examples/tsconfig.json create mode 100755 packages/bun-framework-next/bun.lockb create mode 100755 packages/bun-macro-relay/bun.lockb create mode 100644 packages/bun-types/.eslintignore create mode 100644 packages/bun-types/.eslintrc.cjs create mode 100644 packages/bun-types/.gitignore create mode 100644 packages/bun-types/.prettierignore create mode 100644 packages/bun-types/README.md create mode 100644 packages/bun-types/assert.d.ts create mode 100644 packages/bun-types/buffer.d.ts create mode 100644 packages/bun-types/bun-test.d.ts create mode 100644 packages/bun-types/bun.d.ts create mode 100755 packages/bun-types/bun.lockb create mode 100644 packages/bun-types/child_process.d.ts create mode 100644 packages/bun-types/constants.d.ts create mode 100644 packages/bun-types/crypto.d.ts create mode 100644 packages/bun-types/domain.d.ts create mode 100644 packages/bun-types/events.d.ts create mode 100644 packages/bun-types/ffi.d.ts create mode 100644 packages/bun-types/fs.d.ts create mode 100644 packages/bun-types/fs/promises.d.ts create mode 100644 packages/bun-types/globals.d.ts create mode 100644 packages/bun-types/header.txt create mode 100644 packages/bun-types/html-rewriter.d.ts create mode 100644 packages/bun-types/http.d.ts create mode 100644 packages/bun-types/images/README.md create mode 100644 packages/bun-types/index.d.ts create mode 100644 packages/bun-types/index.js create mode 100644 packages/bun-types/jsc.d.ts create mode 100644 packages/bun-types/module.d.ts create mode 100644 packages/bun-types/os.d.ts create mode 100644 packages/bun-types/package.json create mode 100644 packages/bun-types/path.d.ts create mode 100644 packages/bun-types/punycode.d.ts create mode 100644 packages/bun-types/querystring.d.ts create mode 100644 packages/bun-types/scripts/bundle.ts create mode 100644 packages/bun-types/scripts/gpr.ts create mode 100644 packages/bun-types/scripts/utils/getDotTsFiles.ts create mode 100644 packages/bun-types/sqlite.d.ts create mode 100644 packages/bun-types/stream.d.ts create mode 100644 packages/bun-types/string_decoder.d.ts create mode 100644 packages/bun-types/supports-color.d.ts create mode 100644 packages/bun-types/tests/index.d.ts create mode 100644 packages/bun-types/tests/index.test-d.ts create mode 100644 packages/bun-types/tests/tcp.test-d.ts create mode 100644 packages/bun-types/timers.d.ts create mode 100644 packages/bun-types/tsconfig.docs.json create mode 100644 packages/bun-types/tsconfig.json create mode 100644 packages/bun-types/tty.d.ts create mode 100644 packages/bun-types/typedoc.json create mode 100644 packages/bun-types/url.d.ts create mode 100644 packages/bun-types/util.d.ts create mode 100644 packages/bun-types/zlib.d.ts delete mode 100644 src/.prettierignore create mode 100644 test/bun.js/plugins.d.ts create mode 100644 test/macro/macro.d.ts create mode 100644 tsconfig.base.json diff --git a/.github/workflows/bun-types-release.yml b/.github/workflows/bun-types-release.yml new file mode 100644 index 0000000000..ebbe085861 --- /dev/null +++ b/.github/workflows/bun-types-release.yml @@ -0,0 +1,137 @@ +name: Release +on: + workflow_dispatch: + +jobs: + test-build: + name: Test & Build + runs-on: ubuntu-latest + if: github.repository_owner == 'oven-sh' + defaults: + run: + working-directory: packages/bun-types + steps: + - uses: actions/checkout@v3 + + - name: Install bun + uses: xhyrom/setup-bun@v0.1.6 + with: + bun-version: latest + github-token: ${{ secrets.GITHUB_TOKEN }} + + - name: Install node + uses: actions/setup-node@v3 + with: + node-version: latest + + - name: Install dependencies + run: bun install + + - name: ESLint + run: bun run lint + + - name: Build package + run: bun run build + + - name: Upload artifact + uses: actions/upload-artifact@v3 + with: + name: bun-types + path: packages/bun-types/dist/* + if-no-files-found: error + + publish-npm: + name: Publish on NPM + runs-on: ubuntu-latest + needs: [test-build] + if: github.repository_owner == 'oven-sh' + defaults: + run: + working-directory: packages/bun-types + + steps: + - uses: actions/checkout@v3 + - name: Install node + uses: actions/setup-node@v3 + with: + node-version: latest + registry-url: 'https://registry.npmjs.org' + + - name: Download all artifacts + uses: actions/download-artifact@v3 + with: + name: bun-types + path: packages/bun-types/dist + + - name: Publish on NPM + run: cd packages/bun-types/dist/ && npm publish --access public + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + + publish-gpr: + name: Publish on GPR + runs-on: ubuntu-latest + needs: [test-build] + if: github.repository_owner == 'oven-sh' + defaults: + run: + working-directory: packages/bun-types + + steps: + - uses: actions/checkout@v3 + - name: Install node + uses: actions/setup-node@v3 + with: + node-version: latest + registry-url: 'https://npm.pkg.github.com/' + scope: '@oven-sh' + + - name: Install bun + uses: xhyrom/setup-bun@v0.1.6 + with: + bun-version: latest + github-token: ${{ secrets.GITHUB_TOKEN }} + + - name: Download all artifacts + uses: actions/download-artifact@v3 + with: + name: bun-types + path: dist + + - name: Add scope to name + run: bun scripts/gpr.ts + + - name: Publish on GPR + run: cd dist/ && npm publish --access public + env: + NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + # no need for separate releases now + # create-release: + # name: Create Release + # runs-on: ubuntu-latest + # needs: [test-build] + # defaults: + # run: + # working-directory: packages/bun-types + # if: github.repository_owner == 'oven-sh' + + # steps: + # - name: Download all artifacts + # uses: actions/download-artifact@v3 + # with: + # name: bun-types + # path: packages/bun-types/dist + + # - name: Set version + # run: echo "version=$(jq --raw-output '.version' dist/package.json)" >> $GITHUB_ENV + + # - name: Create Release + # uses: softprops/action-gh-release@v0.1.14 + # with: + # tag_name: "v${{ env.version }}" + # body: "This is the release of bun-types that corresponds to the commit [${{ github.sha }}]" + # token: ${{ secrets.GITHUB_TOKEN }} + # files: | + # dist/* diff --git a/.github/workflows/bun-types-tests.yml b/.github/workflows/bun-types-tests.yml new file mode 100644 index 0000000000..fad84a1150 --- /dev/null +++ b/.github/workflows/bun-types-tests.yml @@ -0,0 +1,39 @@ +name: Tests +on: + push: + pull_request: + +jobs: + tests: + name: Tests + runs-on: ubuntu-latest + defaults: + run: + working-directory: packages/bun-types + + steps: + - name: Checkout repo + uses: actions/checkout@v2 + + - name: Install bun + uses: xhyrom/setup-bun@v0.1.6 + with: + bun-version: latest + github-token: ${{ secrets.GITHUB_TOKEN }} + + - name: Install node + uses: actions/setup-node@v3 + with: + node-version: latest + + - name: Install dependencies + run: bun install + + - name: Generate package + run: bun run build + + - name: ESLint + run: bun run lint + + - name: Tests + run: bun run test \ No newline at end of file diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000000..ebb14dfbd0 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,9 @@ +src/fallback.html +# src/test +bench +test/bun.js/solid-dom-fixtures +test/bun.js/bundled +src/bun.js/builtins +# src/api/demo +test/snapshots +test/snapshots-no-hmr \ No newline at end of file diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 0000000000..495a80fd77 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,7 @@ +{ + "tabWidth": 2, + "useTabs": false, + "singleQuote": false, + "bracketSpacing": true, + "trailingComma": "all" +} diff --git a/.vscode/settings.json b/.vscode/settings.json index 0e0f09688f..3dcd4ca35c 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -31,7 +31,6 @@ }, "zig.beforeDebugCmd": "make build-unit ${file} ${filter} ${bin}", "zig.testCmd": "make test ${file} ${filter} ${bin}", - "lldb.verboseLogging": false, "files.exclude": { "**/.git": true, @@ -44,8 +43,6 @@ "**/*.xcscheme": true, "**/*.pem": true, "**/*.xcodeproj": true, - "packages/bun-types/*.d.ts": true, - "test/snapshots": true, "test/snapshots-no-hmr": true, "src/bun.js/WebKit": true, @@ -183,5 +180,8 @@ "queue": "cpp" }, "cmake.configureOnOpen": false, - "C_Cpp.errorSquiggles": "Enabled" -} + "C_Cpp.errorSquiggles": "Enabled", + "eslint.workingDirectories": [ + "packages/bun-types" + ] +} \ No newline at end of file diff --git a/Makefile b/Makefile index b45e12327d..b06c88827a 100644 --- a/Makefile +++ b/Makefile @@ -455,6 +455,8 @@ bun: npm-install: $(NPM_CLIENT) install +print-% : ; @echo $* = $($*) + @@ -497,11 +499,15 @@ generate-builtins: builtins .PHONY: vendor-without-check vendor-without-check: npm-install node-fallbacks runtime_js fallback_decoder bun_error mimalloc picohttp zlib boringssl libarchive libbacktrace lolhtml usockets uws tinycc oniguruma -BUN_TYPES_REPO_PATH ?= $(realpath ../bun-types) +BUN_TYPES_REPO_PATH ?= $(realpath packages/bun-types) + +ifeq ($(DEBUG),true) +BUN_RELEASE_BIN = bun +endif .PHONY: prepare-types prepare-types: - BUN_VERSION=$(PACKAGE_JSON_VERSION) $(BUN_RELEASE_BIN) $(BUN_TYPES_REPO_PATH)/bundle.ts $(BUN_TYPES_REPO_PATH)/dist + BUN_VERSION=$(PACKAGE_JSON_VERSION) $(BUN_RELEASE_BIN) $(BUN_TYPES_REPO_PATH)/scripts/bundle.ts $(BUN_TYPES_REPO_PATH)/dist echo "Generated types for $(PACKAGE_JSON_VERSION) in $(BUN_TYPES_REPO_PATH)/dist" cp $(BUN_TYPES_REPO_PATH)/dist/types.d.ts /tmp/bun-types.d.ts cd /tmp && $(PACKAGE_DIR)/../../node_modules/.bin/tsc /tmp/bun-types.d.ts @@ -509,12 +515,13 @@ prepare-types: release-types: # can be removed when/if "bun publish" is implemented @npm --version >/dev/null 2>&1 || (echo -e "ERROR: npm is required."; exit 1) - cd $(BUN_TYPES_REPO_PATH)/dist && npm publish + cd $(BUN_TYPES_REPO_PATH)/dist && npm publish --dry-run .PHONY: format format: ## to format the code - $(PRETTIER) --write test/bun.js/*.js - $(PRETTIER) --write test/bun.js/solid-dom-fixtures/**/*.js + -$(PRETTIER) --write 'test/bun.js/*.{js,jsx,ts,tsx}' + -$(PRETTIER) --write 'test/bun.js/solid-dom-fixtures/**/*.{js,jsx,ts,tsx}' + .PHONY: lolhtml lolhtml: diff --git a/README.md b/README.md index 5f4811944d..731d05864b 100644 --- a/README.md +++ b/README.md @@ -197,7 +197,7 @@ bun.js focuses on performance, developer experience and compatibility with the J export default { port: 3000, fetch(request: Request) { - return new Response("Hello World"); + return new Response('Hello World'); }, }; @@ -237,8 +237,8 @@ The runtime uses JavaScriptCore, the JavaScript engine powering WebKit and Safar ```js // cat.js -import { resolve } from "path"; -import { write, stdout, file, argv } from "bun"; +import {resolve} from 'path'; +import {write, stdout, file, argv} from 'bun'; const path = resolve(argv.at(-1)); @@ -257,7 +257,7 @@ Server-side render React: ```js // requires Bun v0.1.0 or later // react-ssr.tsx -import { renderToReadableStream } from "react-dom/server"; +import {renderToReadableStream} from 'react-dom/server'; const dt = new Intl.DateTimeFormat(); @@ -289,7 +289,7 @@ PRs adding more examples are very welcome! ### Types for bun.js (editor autocomplete) -The best docs right now are the TypeScript types in the [`bun-types`](https://github.com/oven-sh/bun-types) npm package. A docs site is coming soon. +The best docs right now are the TypeScript types in the [`bun-types`](https://github.com/oven-sh/bun/tree/main/packages/bun-types) npm package. A docs site is coming soon. To get autocomplete for bun.js types in your editor, @@ -328,8 +328,8 @@ bun.js has fast paths for common use cases that make Web APIs live up to the per When you pass a file blob to `Bun.write`, Bun automatically uses a faster system call: ```js -const blob = Bun.file("input.txt"); -await Bun.write("output.txt", blob); +const blob = Bun.file('input.txt'); +await Bun.write('output.txt', blob); ``` On Linux, this uses the [`copy_file_range`](https://man7.org/linux/man-pages/man2/copy_file_range.2.html) syscall and on macOS, this becomes `clonefile` (or [`fcopyfile`](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/copyfile.3.html)). @@ -338,7 +338,7 @@ On Linux, this uses the [`copy_file_range`](https://man7.org/linux/man-pages/man ```js // Eventually, this will stream the response to disk but today it buffers -await Bun.write("index.html", await fetch("https://example.com")); +await Bun.write('index.html', await fetch('https://example.com')); ``` ## Using bun as a package manager @@ -714,15 +714,15 @@ When importing CSS in JavaScript-like loaders, CSS is treated special. By default, bun will transform a statement like this: ```js -import "../styles/global.css"; +import '../styles/global.css'; ``` ##### When `platform` is `browser` ```js globalThis.document?.dispatchEvent( - new CustomEvent("onimportcss", { - detail: "http://localhost:3000/styles/globals.css", + new CustomEvent('onimportcss', { + detail: 'http://localhost:3000/styles/globals.css', }) ); ``` @@ -742,9 +742,9 @@ Additionally, bun exposes an API for SSR/SSG that returns a flat list of URLs to // This API needs to be changed somewhat to work more generally with Bun.js // Initially, you could only use bun.js through `bun dev` // and this API was created at that time -addEventListener("fetch", async (event: FetchEvent) => { +addEventListener('fetch', async (event: FetchEvent) => { let route = Bun.match(event); - const App = await import("pages/_app"); + const App = await import('pages/_app'); // This returns all .css files that were imported in the line above. // It’s recursive, so any file that imports a CSS file will be included. @@ -763,9 +763,9 @@ bun bundles `.css` files imported via `@import` into a single file. It doesn’t This input: ```css -@import url("./hi.css"); -@import url("./hello.css"); -@import url("./yo.css"); +@import url('./hi.css'); +@import url('./hello.css'); +@import url('./yo.css'); ``` Becomes: @@ -881,7 +881,7 @@ type Framework = Environment & { // If the framework does routing, you may want to handle CSS manually // "facade" removes CSS imports from JavaScript files, // and replaces an imported object with a proxy that mimics CSS module support without doing any class renaming. - css?: "onimportcss" | "facade"; + css?: 'onimportcss' | 'facade'; // bun’s filesystem router router?: Router; @@ -893,7 +893,7 @@ type Define = { // When "*", all environment variables will be automatically injected into the JavaScript loader // When a string like "NEXT_PUBLIC_", only environment variables starting with that prefix will be injected - ".env": string | "*"; + '.env': string | '*'; // These environment variables will be injected into the JavaScript loader // These are the equivalent of Webpack’s resolve.alias and esbuild’s --define. @@ -1117,7 +1117,7 @@ export interface Install { globalBinDir: string; cache: Cache; lockfile: Lockfile; - logLevel: "debug" | "error" | "warn"; + logLevel: 'debug' | 'error' | 'warn'; } type Registry = @@ -1138,7 +1138,7 @@ export interface Cache { } export interface Lockfile { - print?: "yarn"; + print?: 'yarn'; path: string; savePath: string; save: boolean; @@ -1371,7 +1371,7 @@ globalThis.reloadCount = reloadCount + 1; export default { fetch(req: Request) { return new Response(`Code reloaded ${reloadCount} times`, { - headers: { "content-type": "text/plain" }, + headers: {'content-type': 'text/plain'}, }); }, }; @@ -1413,7 +1413,7 @@ const reloadServer = (globalThis.reloadServer ||= (() => { const handler = { fetch(req: Request) { return new Response(`Code reloaded ${reloadCount} times`, { - headers: { "content-type": "text/plain" }, + headers: {'content-type': 'text/plain'}, }); }, }; @@ -1825,18 +1825,18 @@ This is an `"object"` loader. `object` loaders let you return a JS object that B Plugin implementation (`my-yaml-plugin.js`) ```js -import { plugin } from "bun"; +import {plugin} from 'bun'; plugin({ - name: "YAML", + name: 'YAML', setup(builder) { - const { load } = require("js-yaml"); - const { readFileSync } = require("fs"); + const {load} = require('js-yaml'); + const {readFileSync} = require('fs'); // Run this function on any import that ends with .yaml or .yml - builder.onLoad({ filter: /\.(yaml|yml)$/ }, (args) => { + builder.onLoad({filter: /\.(yaml|yml)$/}, (args) => { // Read the YAML file from disk - const text = readFileSync(args.path, "utf8"); + const text = readFileSync(args.path, 'utf8'); // parse the YAML file with js-yaml const exports = load(text); @@ -1846,7 +1846,7 @@ plugin({ exports, // we're returning an object - loader: "object", + loader: 'object', }; }); }, @@ -1856,8 +1856,8 @@ plugin({ Plugin usage: ```js -import "./my-yaml-plugin.js"; -import { hello } from "./myfile.yaml"; +import './my-yaml-plugin.js'; +import {hello} from './myfile.yaml'; console.log(hello); // "world" ``` @@ -1869,25 +1869,25 @@ This is a `"js"` loader, which lets you return a JS string or `ArrayBufferView` Plugin implementation (`myplugin.js`) ```js -import { plugin } from "bun"; +import {plugin} from 'bun'; await plugin({ - name: "svelte loader", + name: 'svelte loader', async setup(builder) { - const { compile } = await import("svelte/compiler"); - const { readFileSync } = await import("fs"); + const {compile} = await import('svelte/compiler'); + const {readFileSync} = await import('fs'); // Register a loader for .svelte files - builder.onLoad({ filter: /\.svelte$/ }, ({ path }) => ({ + builder.onLoad({filter: /\.svelte$/}, ({path}) => ({ // Run the Svelte compiler on the import path - contents: compile(readFileSync(path, "utf8"), { + contents: compile(readFileSync(path, 'utf8'), { filename: path, - generate: "ssr", + generate: 'ssr', }).js.code, // Set the loader to "js" // This runs it through Bun's transpiler - loader: "js", + loader: 'js', })); }, }); @@ -1898,8 +1898,8 @@ Note: in a production implementation, you'd want to cache the compiled output an Plugin usage: ```js -import "./myplugin.js"; -import MySvelteComponent from "./component.svelte"; +import './myplugin.js'; +import MySvelteComponent from './component.svelte'; console.log(mySvelteComponent.render()); ``` @@ -1911,15 +1911,15 @@ Bun's loader API interface is loosely based on [esbuild](https://esbuild.github. MDX: ```jsx -import { plugin } from "bun"; -import { renderToStaticMarkup } from "react-dom/server"; +import {plugin} from 'bun'; +import {renderToStaticMarkup} from 'react-dom/server'; // it's the esbuild plugin, but it works using Bun's transpiler. -import mdx from "@mdx-js/esbuild"; +import mdx from '@mdx-js/esbuild'; plugin(mdx()); -import Foo from "./bar.mdx"; +import Foo from './bar.mdx'; console.log(renderToStaticMarkup()); ``` @@ -1932,11 +1932,11 @@ At the top-level, a `plugin` function exported from `"bun"` expects a `"name"` s For plugins to automatically activate, the `plugin` function must be from an import statement like this: ```js -import { plugin } from "bun"; +import {plugin} from 'bun'; // This automatically activates on import plugin({ - name: "my plugin", + name: 'my plugin', setup(builder) {}, }); @@ -2007,8 +2007,8 @@ Bun.serve({ Node: ```ts -require("http") - .createServer((req, res) => res.end("bun!")) +require('http') + .createServer((req, res) => res.end('bun!')) .listen(8080); ``` @@ -2028,7 +2028,7 @@ If the file used to start bun has a default export with a `fetch` function, it w // hi.js export default { fetch(req) { - return new Response("HI!"); + return new Response('HI!'); }, }; @@ -2042,7 +2042,7 @@ export default { ```ts Bun.serve({ fetch(req) { - return new Response("HI!"); + return new Response('HI!'); }, }); ``` @@ -2062,10 +2062,10 @@ It will hopefully make it easier to debug issues with bun until bun gets debugge ```js Bun.serve({ fetch(req) { - throw new Error("woops!"); + throw new Error('woops!'); }, error(error: Error) { - return new Response("Uh oh!!\n" + error.toString(), { status: 500 }); + return new Response('Uh oh!!\n' + error.toString(), {status: 500}); }, }); ``` @@ -2077,7 +2077,7 @@ To stop the server, call `server.stop()`: ```ts const server = Bun.serve({ fetch() { - return new Response("HI!"); + return new Response('HI!'); }, }); @@ -2093,20 +2093,20 @@ Example: ```ts Bun.serve({ fetch(req) { - return new Response("Hello!!!"); + return new Response('Hello!!!'); }, /** * File path to a TLS key * * To enable TLS, this option is required. */ - keyFile: "./key.pem", + keyFile: './key.pem', /** * File path to a TLS certificate * * To enable TLS, this option is required. */ - certFile: "./cert.pem", + certFile: './cert.pem', /** * Optional SSL options @@ -2153,7 +2153,7 @@ Bun.serve({ // When upgrading, we return undefined since we don't want to send a Response return; - return new Response("Regular HTTP response"); + return new Response('Regular HTTP response'); }, }); ``` @@ -2167,45 +2167,45 @@ type User = { Bun.serve({ fetch(req, server) { - if (req.url === "/chat") { + if (req.url === '/chat') { if ( server.upgrade(req, { // This User object becomes ws.data data: { - name: new URL(req.url).searchParams.get("name") || "Friend", + name: new URL(req.url).searchParams.get('name') || 'Friend', }, // Pass along some headers to the client headers: { - "Set-Cookie": "name=" + new URL(req.url).searchParams.get("name"), + 'Set-Cookie': 'name=' + new URL(req.url).searchParams.get('name'), }, }) ) return; } - return new Response("Expected a websocket connection", { status: 400 }); + return new Response('Expected a websocket connection', {status: 400}); }, websocket: { open(ws) { - console.log("WebSocket opened"); + console.log('WebSocket opened'); // subscribe to "the-group-chat" topic - ws.subscribe("the-group-chat"); + ws.subscribe('the-group-chat'); }, message(ws, message) { // In a group chat, we want to broadcast to everyone // so we use publish() - ws.publish("the-group-chat", `${ws.data.name}: ${message}`); + ws.publish('the-group-chat', `${ws.data.name}: ${message}`); }, close(ws, code, reason) { - ws.publish("the-group-chat", `${ws.data.name} left the chat`); + ws.publish('the-group-chat', `${ws.data.name} left the chat`); }, drain(ws) { - console.log("Please send me data. I am ready to receive it."); + console.log('Please send me data. I am ready to receive it.'); }, // enable compression @@ -2277,9 +2277,7 @@ For server websocket connections, Bun exposes a `ServerWebSocket` class which is ```ts Bun.serve({ fetch(req, server) { - if ( - server.upgrade(req, { headers: { "Set-Cookie": "name=HiThereMyNameIs" } }) - ) + if (server.upgrade(req, {headers: {'Set-Cookie': 'name=HiThereMyNameIs'}})) return; }, websocket: { @@ -2297,7 +2295,7 @@ The web-standard `WebSocket` API does not let you specify headers. `ServerWebSocket` has `publish()`, `subscribe()`, and `unsubscribe` methods which let you broadcast the same message to all clients connected to a topic in one line of code. ```ts -ws.publish("stock-prices/GOOG", `${price}`); +ws.publish('stock-prices/GOOG', `${price}`); ``` ##### Backpressure @@ -2314,7 +2312,7 @@ You can also enable/disable compression per message with the `compress` option: ```ts // this will compress -ws.send("Hello".repeat(1000), true); +ws.send('Hello'.repeat(1000), true); ``` `WebSocket.send` returns `undefined` and does not indicate backpressure, which can cause issues if you are sending a lot of data. @@ -2348,11 +2346,11 @@ The HTTP server and server-side websockets are based on [uWebSockets](https://gi `Bun.spawn` lets you quickly spawn a process. Available as of Bun v0.2.0. ```ts -import { spawn } from "bun"; +import {spawn} from 'bun'; -const { stdout } = spawn(["esbuild"], { +const {stdout} = spawn(['esbuild'], { stdin: await fetch( - "https://raw.githubusercontent.com/oven-sh/bun/main/examples/hashing.js" + 'https://raw.githubusercontent.com/oven-sh/bun/main/examples/hashing.js' ), }); @@ -2383,9 +2381,9 @@ spawnSync echo hi 1.47 ms/iter (1.14 ms … 2.64 ms) 1.57 ms 2.37 ms Synchronous example: ```ts -import { spawnSync } from "bun"; +import {spawnSync} from 'bun'; -const { stdout } = spawnSync(["echo", "hi"]); +const {stdout} = spawnSync(['echo', 'hi']); // When using spawnSync, stdout is a Buffer // this lets you read from it synchronously @@ -2397,24 +2395,24 @@ console.log(text); // "hi\n" You can pass an object as the second argument to customize the process: ```ts -import { spawn } from "bun"; +import {spawn} from 'bun'; -const { stdout } = spawn(["printenv", "FOO"], { - cwd: "/tmp", +const {stdout} = spawn(['printenv', 'FOO'], { + cwd: '/tmp', env: { ...process.env, - FOO: "bar", + FOO: 'bar', }, // Disable stdin stdin: null, // Allow us to read from stdout - stdout: "pipe", + stdout: 'pipe', // Point stderr to write to "/tmp/stderr.log" - stderr: Bun.file("/tmp/stderr.log"), + stderr: Bun.file('/tmp/stderr.log'), }); const text = await new Response(stdout).text(); @@ -2424,12 +2422,12 @@ console.log(text); // "bar\n" You can also pass a `Bun.file` for `stdin`: ```ts -import { spawn, file, write } from "bun"; +import {spawn, file, write} from 'bun'; -await write("/tmp/foo.txt", "hi"); -const { stdout } = spawn(["cat"], { +await write('/tmp/foo.txt', 'hi'); +const {stdout} = spawn(['cat'], { // Set /tmp/foo.txt as stdin - stdin: file("/tmp/foo.txt"), + stdin: file('/tmp/foo.txt'), }); const text = await new Response(stdout).text(); @@ -2439,11 +2437,11 @@ console.log(text); // "hi\n" `stdin` also accepts a TypedArray: ```ts -import { spawn } from "bun"; +import {spawn} from 'bun'; -const { stdout } = spawn(["cat"], { - stdin: new TextEncoder().encode("hi"), - stdout: "pipe", +const {stdout} = spawn(['cat'], { + stdin: new TextEncoder().encode('hi'), + stdout: 'pipe', }); const text = await new Response(stdout).text(); @@ -2455,16 +2453,16 @@ console.log(text); // "hi\n" > :warning: **This API is a little buggy right now** ```ts -import { spawn } from "bun"; +import {spawn} from 'bun'; -const { stdin, stdout } = spawn(["cat"], { - stdin: "pipe", - stdout: "pipe", +const {stdin, stdout} = spawn(['cat'], { + stdin: 'pipe', + stdout: 'pipe', }); // You can pass it strings or TypedArrays // Write "hi" to stdin -stdin.write("hi"); +stdin.write('hi'); // By default, stdin is buffered so you need to call flush() to send it stdin.flush(true); @@ -2551,15 +2549,15 @@ interface Subprocess { Find the path to an executable, similar to typing `which` in your terminal. ```ts -const ls = Bun.which("ls"); +const ls = Bun.which('ls'); console.log(ls); // "/usr/bin/ls" ``` `Bun.which` defaults the `PATH` to the current `PATH` environment variable, but you can customize it ```ts -const ls = Bun.which("ls", { - PATH: "/usr/local/bin:/usr/bin:/bin", +const ls = Bun.which('ls', { + PATH: '/usr/local/bin:/usr/bin:/bin', }); console.log(ls); // "/usr/bin/ls" ``` @@ -2567,9 +2565,9 @@ console.log(ls); // "/usr/bin/ls" `Bun.which` also accepts a `cwd` option to search for the binary in a specific directory. ```ts -const ls = Bun.which("ls", { - cwd: "/tmp", - PATH: "", +const ls = Bun.which('ls', { + cwd: '/tmp', + PATH: '', }); console.log(ls); // null @@ -2584,20 +2582,20 @@ Start a TCP server with `Bun.listen`: ```ts // The server Bun.listen({ - hostname: "localhost", + hostname: 'localhost', port: 8080, socket: { open(socket) { - socket.write("hello world"); + socket.write('hello world'); }, data(socket, data) { console.log(data instanceof Uint8Array); // true }, drain(socket) { - console.log("gimme more data"); + console.log('gimme more data'); }, close(socket) { - console.log("goodbye!"); + console.log('goodbye!'); }, }, // This is a TLS socket @@ -2611,7 +2609,7 @@ Bun.listen({ ```ts // The client Bun.connect({ - hostname: "localhost", + hostname: 'localhost', port: 8080, socket: { @@ -2619,21 +2617,21 @@ Bun.connect({ socket.write("hello server, i'm the client!"); }, data(socket, message) { - socket.write("thanks for the message! Sincerely, " + socket.data.name); + socket.write('thanks for the message! Sincerely, ' + socket.data.name); }, drain(socket) { - console.log("my socket is ready for more data"); + console.log('my socket is ready for more data'); }, close(socket) { - console.log(""); + console.log(''); }, timeout(socket) { - console.log("socket timed out"); + console.log('socket timed out'); }, }, data: { - name: "Clienty McClientface", + name: 'Clienty McClientface', }, }); ``` @@ -2655,7 +2653,7 @@ Bun.listen({ close(socket) {}, error(socket, error) {}, }, - hostname: "localhost", + hostname: 'localhost', port: 8080, }); ``` @@ -2667,7 +2665,7 @@ How do you pass per-socket data to each socket object? `**data**` is a property on the `TCPSocket` & `TLSSocket` object that you can use to store per-socket data. ```ts -socket.data = { name: "Clienty McClientface" }; +socket.data = {name: 'Clienty McClientface'}; ``` You can assign a default value to `data` in the `connect` or `listen` options. @@ -2680,7 +2678,7 @@ Bun.listen({ }, }, data: { - name: "Servery McServerface", + name: 'Servery McServerface', }, }); ``` @@ -2691,16 +2689,16 @@ Bun.listen({ ```ts const socket = Bun.connect({ - hostname: "localhost", + hostname: 'localhost', port: 8080, socket: { data(socket, msg) { - console.log("wow i got a message!"); + console.log('wow i got a message!'); // this will be called the next time the server sends a message socket.reload({ data(socket) { - console.log("okay, not so surprising this time"); + console.log('okay, not so surprising this time'); }, }); }, @@ -2717,29 +2715,29 @@ Your TCP client/server will have abysmal performance if you don't consider buffe For example, this: ```ts -socket.write("h"); -socket.write("e"); -socket.write("l"); -socket.write("l"); -socket.write("o"); +socket.write('h'); +socket.write('e'); +socket.write('l'); +socket.write('l'); +socket.write('o'); ``` Performs significantly worse than: ```ts -socket.write("hello"); +socket.write('hello'); ``` To simplify this for now, consider using `ArrayBufferSink` with the `{stream: true}` option: ```ts -const sink = new ArrayBufferSink({ stream: true, highWaterMark: 1024 }); +const sink = new ArrayBufferSink({stream: true, highWaterMark: 1024}); -sink.write("h"); -sink.write("e"); -sink.write("l"); -sink.write("l"); -sink.write("o"); +sink.write('h'); +sink.write('e'); +sink.write('l'); +sink.write('l'); +sink.write('o'); queueMicrotask(() => { var data = sink.flush(); @@ -2759,9 +2757,9 @@ Builtin buffering is planned in a future version of Bun. This function was added in Bun v0.2.2. ```ts -import { peek } from "bun"; +import {peek} from 'bun'; -const promise = Promise.resolve("hi"); +const promise = Promise.resolve('hi'); // no await! const result = peek(promise); @@ -2772,10 +2770,10 @@ console.log(result); // "hi" `Bun.peek` is useful for performance-sensitive code that wants to reduce the number of extra microticks. It's an advanced API and you probably shouldn't use it unless you know what you're doing. ```ts -import { peek } from "bun"; -import { expect, test } from "bun:test"; +import {peek} from 'bun'; +import {expect, test} from 'bun:test'; -test("peek", () => { +test('peek', () => { const promise = Promise.resolve(true); // no await necessary! @@ -2797,27 +2795,27 @@ test("peek", () => { // - returns the error // - does not mark the promise as handled const rejected = Promise.reject( - new Error("Succesfully tested promise rejection") + new Error('Succesfully tested promise rejection') ); - expect(peek(rejected).message).toBe("Succesfully tested promise rejection"); + expect(peek(rejected).message).toBe('Succesfully tested promise rejection'); }); ``` `peek.status` lets you read the status of a promise without resolving it. ```ts -import { peek } from "bun"; -import { expect, test } from "bun:test"; +import {peek} from 'bun'; +import {expect, test} from 'bun:test'; -test("peek.status", () => { +test('peek.status', () => { const promise = Promise.resolve(true); - expect(peek.status(promise)).toBe("fulfilled"); + expect(peek.status(promise)).toBe('fulfilled'); const pending = new Promise(() => {}); - expect(peek.status(pending)).toBe("pending"); + expect(peek.status(pending)).toBe('pending'); - const rejected = Promise.reject(new Error("oh nooo")); - expect(peek.status(rejected)).toBe("rejected"); + const rejected = Promise.reject(new Error('oh nooo')); + expect(peek.status(rejected)).toBe('rejected'); }); ``` @@ -2851,24 +2849,24 @@ All this complexity is handled by a single function. ```ts // Write "Hello World" to output.txt -await Bun.write("output.txt", "Hello World"); +await Bun.write('output.txt', 'Hello World'); ``` ```ts // log a file to stdout -await Bun.write(Bun.stdout, Bun.file("input.txt")); +await Bun.write(Bun.stdout, Bun.file('input.txt')); ``` ```ts // write the HTTP response body to disk -await Bun.write("index.html", await fetch("http://example.com")); +await Bun.write('index.html', await fetch('http://example.com')); // this does the same thing -await Bun.write(Bun.file("index.html"), await fetch("http://example.com")); +await Bun.write(Bun.file('index.html'), await fetch('http://example.com')); ``` ```ts // copy input.txt to output.txt -await Bun.write("output.txt", Bun.file("input.txt")); +await Bun.write('output.txt', Bun.file('input.txt')); ``` ## bun:sqlite (SQLite3 module) @@ -2892,35 +2890,35 @@ Installation: Example: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; -const db = new Database("mydb.sqlite"); +const db = new Database('mydb.sqlite'); db.run( - "CREATE TABLE IF NOT EXISTS foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE IF NOT EXISTS foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); -db.run("INSERT INTO foo (greeting) VALUES (?)", "Welcome to bun!"); -db.run("INSERT INTO foo (greeting) VALUES (?)", "Hello World!"); +db.run('INSERT INTO foo (greeting) VALUES (?)', 'Welcome to bun!'); +db.run('INSERT INTO foo (greeting) VALUES (?)', 'Hello World!'); // get the first row -db.query("SELECT * FROM foo").get(); +db.query('SELECT * FROM foo').get(); // { id: 1, greeting: "Welcome to bun!" } // get all rows -db.query("SELECT * FROM foo").all(); +db.query('SELECT * FROM foo').all(); // [ // { id: 1, greeting: "Welcome to bun!" }, // { id: 2, greeting: "Hello World!" }, // ] // get all rows matching a condition -db.query("SELECT * FROM foo WHERE greeting = ?").all("Welcome to bun!"); +db.query('SELECT * FROM foo WHERE greeting = ?').all('Welcome to bun!'); // [ // { id: 1, greeting: "Welcome to bun!" }, // ] // get first row matching a named condition -db.query("SELECT * FROM foo WHERE greeting = $greeting").get({ - $greeting: "Welcome to bun!", +db.query('SELECT * FROM foo WHERE greeting = $greeting').get({ + $greeting: 'Welcome to bun!', }); // [ // { id: 1, greeting: "Welcome to bun!" }, @@ -3007,52 +3005,52 @@ constructor( To open or create a SQLite3 database: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; -const db = new Database("mydb.sqlite"); +const db = new Database('mydb.sqlite'); ``` Open an in-memory database: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // all of these do the same thing -let db = new Database(":memory:"); +let db = new Database(':memory:'); let db = new Database(); -let db = new Database(""); +let db = new Database(''); ``` Open read-write and throw if the database doesn't exist: ```ts -import { Database } from "bun:sqlite"; -const db = new Database("mydb.sqlite", { readwrite: true }); +import {Database} from 'bun:sqlite'; +const db = new Database('mydb.sqlite', {readwrite: true}); ``` Open read-only and throw if the database doesn't exist: ```ts -import { Database } from "bun:sqlite"; -const db = new Database("mydb.sqlite", { readonly: true }); +import {Database} from 'bun:sqlite'; +const db = new Database('mydb.sqlite', {readonly: true}); ``` Open read-write, don't throw if new file: ```ts -import { Database } from "bun:sqlite"; -const db = new Database("mydb.sqlite", { readonly: true, create: true }); +import {Database} from 'bun:sqlite'; +const db = new Database('mydb.sqlite', {readonly: true, create: true}); ``` Open a database from a `Uint8Array`: ```ts -import { Database } from "bun:sqlite"; -import { readFileSync } from "fs"; +import {Database} from 'bun:sqlite'; +import {readFileSync} from 'fs'; // unlike passing a filepath, this will not persist any changes to disk // it will be read-write but not persistent -const db = new Database(readFileSync("mydb.sqlite")); +const db = new Database(readFileSync('mydb.sqlite')); ``` Close a database: @@ -3086,24 +3084,24 @@ This intended to make it easier for `bun:sqlite` to be fast by default. Calling You can bind parameters on any call to a statement. ```js -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // generate some data let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); -db.run("INSERT INTO foo (greeting) VALUES ($greeting)", { - $greeting: "Welcome to bun", +db.run('INSERT INTO foo (greeting) VALUES ($greeting)', { + $greeting: 'Welcome to bun', }); // get the query -const stmt = db.query("SELECT * FROM foo WHERE greeting = ?"); +const stmt = db.query('SELECT * FROM foo WHERE greeting = ?'); // run the query -stmt.all("Welcome to bun!"); -stmt.get("Welcome to bun!"); -stmt.run("Welcome to bun!"); +stmt.all('Welcome to bun!'); +stmt.get('Welcome to bun!'); +stmt.run('Welcome to bun!'); ``` #### Database.prototype.prepare @@ -3113,19 +3111,19 @@ stmt.run("Welcome to bun!"); Unlike `query()`, this does not cache the compiled query. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // generate some data let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); // compile the prepared statement -const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); +const stmt = db.prepare('SELECT * FROM foo WHERE bar = ?'); // run the prepared statement -stmt.all("baz"); +stmt.all('baz'); ``` Internally, this calls [`sqlite3_prepare_v3`](https://www.sqlite.org/c3ref/prepare.html). @@ -3148,27 +3146,27 @@ This is useful for things like Creating a table: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; let db = new Database(); db.exec( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); ``` Inserting one row: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; let db = new Database(); db.exec( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); // insert one row -db.exec("INSERT INTO foo (greeting) VALUES ($greeting)", { - $greeting: "Welcome to bun", +db.exec('INSERT INTO foo (greeting) VALUES ($greeting)', { + $greeting: 'Welcome to bun', }); ``` @@ -3182,21 +3180,21 @@ Creates a function that always runs inside a transaction. When the function is i ```ts // setup -import { Database } from "bun:sqlite"; -const db = Database.open(":memory:"); +import {Database} from 'bun:sqlite'; +const db = Database.open(':memory:'); db.exec( - "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)" + 'CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)' ); -const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)"); +const insert = db.prepare('INSERT INTO cats (name, age) VALUES ($name, $age)'); const insertMany = db.transaction((cats) => { for (const cat of cats) insert.run(cat); }); insertMany([ - { $name: "Joey", $age: 2 }, - { $name: "Sally", $age: 4 }, - { $name: "Junior", $age: 1 }, + {$name: 'Joey', $age: 2}, + {$name: 'Sally', $age: 4}, + {$name: 'Junior', $age: 1}, ]); ``` @@ -3204,31 +3202,31 @@ Transaction functions can be called from inside other transaction functions. Whe ```ts // setup -import { Database } from "bun:sqlite"; -const db = Database.open(":memory:"); +import {Database} from 'bun:sqlite'; +const db = Database.open(':memory:'); db.exec( - "CREATE TABLE expenses (id INTEGER PRIMARY KEY AUTOINCREMENT, note TEXT, dollars INTEGER);" + 'CREATE TABLE expenses (id INTEGER PRIMARY KEY AUTOINCREMENT, note TEXT, dollars INTEGER);' ); db.exec( - "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)" + 'CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)' ); const newExpense = db.prepare( - "INSERT INTO expenses (note, dollars) VALUES (?, ?)" + 'INSERT INTO expenses (note, dollars) VALUES (?, ?)' ); -const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)"); +const insert = db.prepare('INSERT INTO cats (name, age) VALUES ($name, $age)'); const insertMany = db.transaction((cats) => { for (const cat of cats) insert.run(cat); }); const adopt = db.transaction((cats) => { - newExpense.run("adoption fees", 20); + newExpense.run('adoption fees', 20); insertMany(cats); // nested transaction }); adopt([ - { $name: "Joey", $age: 2 }, - { $name: "Sally", $age: 4 }, - { $name: "Junior", $age: 1 }, + {$name: 'Joey', $age: 2}, + {$name: 'Sally', $age: 4}, + {$name: 'Junior', $age: 1}, ]); ``` @@ -3256,16 +3254,16 @@ let db = new Database(); // write some data db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); -db.run("INSERT INTO foo VALUES (?)", "Welcome to bun!"); -db.run("INSERT INTO foo VALUES (?)", "Hello World!"); +db.run('INSERT INTO foo VALUES (?)', 'Welcome to bun!'); +db.run('INSERT INTO foo VALUES (?)', 'Hello World!'); const copy = db.serialize(); // => Uint8Array const db2 = new Database(copy); -db2.query("SELECT * FROM foo").all(); +db2.query('SELECT * FROM foo').all(); // => [ // { id: 1, greeting: "Welcome to bun!" }, // { id: 2, greeting: "Hello World!" }, @@ -3283,26 +3281,26 @@ Internally, it calls [`sqlite3_serialize`](https://www.sqlite.org/c3ref/serializ To load a SQLite extension, call `Database.prototype.loadExtension(name)`: ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; let db = new Database(); -db.loadExtension("myext"); +db.loadExtension('myext'); ``` If you're on macOS, you will need to first use a custom SQLite install (you can install with homebrew). By default, bun uses Apple's proprietary build of SQLite because it benchmarks about 50% faster. However, they disabled extension support, so you will need to have a custom build of SQLite to use extensions on macOS. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // on macOS, this must be run before any other calls to `Database` // if called on linux, it will return true and do nothing // on linux it will still check that a string was passed -Database.setCustomSQLite("/path/to/sqlite.dylib"); +Database.setCustomSQLite('/path/to/sqlite.dylib'); let db = new Database(); -db.loadExtension("myext"); +db.loadExtension('myext'); ``` To install sqlite with homebrew: @@ -3329,18 +3327,18 @@ TLDR: You can bind parameters on any call to a statement. Named parameters and positional parameters are supported. Bound parameters are remembered between calls and reset the next time you pass parameters to bind. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT)' ); -db.run("INSERT INTO foo VALUES (?)", "Welcome to bun!"); -db.run("INSERT INTO foo VALUES (?)", "Hello World!"); +db.run('INSERT INTO foo VALUES (?)', 'Welcome to bun!'); +db.run('INSERT INTO foo VALUES (?)', 'Hello World!'); // Statement object -let statement = db.query("SELECT * FROM foo"); +let statement = db.query('SELECT * FROM foo'); // returns all the rows statement.all(); @@ -3357,23 +3355,23 @@ statement.run(); Calling `all()` on a `Statement` instance runs the query and returns the rows as an array of objects. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object -let statement = db.query("SELECT * FROM foo WHERE count = ?"); +let statement = db.query('SELECT * FROM foo WHERE count = ?'); // return all the query results, binding 2 to the count parameter statement.all(2); @@ -3390,23 +3388,23 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq Calling `values()` on a `Statement` instance runs the query and returns the rows as an array of arrays. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object -let statement = db.query("SELECT * FROM foo WHERE count = ?"); +let statement = db.query('SELECT * FROM foo WHERE count = ?'); // return all the query results as an array of arrays, binding 2 to "count" statement.values(2); @@ -3416,10 +3414,10 @@ statement.values(2); // ] // Statement object, but with named parameters -let statement = db.query("SELECT * FROM foo WHERE count = $count"); +let statement = db.query('SELECT * FROM foo WHERE count = $count'); // return all the query results as an array of arrays, binding 2 to "count" -statement.values({ $count: 2 }); +statement.values({$count: 2}); // => [ // [ 1, "Welcome to bun!", 2 ], // [ 3, "Welcome to bun!!!!", 2 ], @@ -3433,33 +3431,33 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq Calling `get()` on a `Statement` instance runs the query and returns the first result as an object. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object -let statement = db.query("SELECT * FROM foo WHERE count = ?"); +let statement = db.query('SELECT * FROM foo WHERE count = ?'); // return the first row as an object, binding 2 to the count parameter statement.get(2); // => { id: 1, greeting: "Welcome to bun!", count: 2 } // Statement object, but with named parameters -let statement = db.query("SELECT * FROM foo WHERE count = $count"); +let statement = db.query('SELECT * FROM foo WHERE count = $count'); // return the first row as an object, binding 2 to the count parameter -statement.get({ $count: 2 }); +statement.get({$count: 2}); // => { id: 1, greeting: "Welcome to bun!", count: 2 } ``` @@ -3472,23 +3470,23 @@ Calling `run()` on a `Statement` instance runs the query and returns nothing. This is useful if you want to repeatedly run a query, but don't care about the results. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object (TODO: use a better example query) -let statement = db.query("SELECT * FROM foo"); +let statement = db.query('SELECT * FROM foo'); // run the query, returning nothing statement.run(); @@ -3505,23 +3503,23 @@ After a statement has been finalized, it cannot be used for any further queries. It is a good idea to finalize a statement when you are done with it, but the garbage collector will do it for you if you don't. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object -let statement = db.query("SELECT * FROM foo WHERE count = ?"); +let statement = db.query('SELECT * FROM foo WHERE count = ?'); statement.finalize(); @@ -3534,23 +3532,23 @@ statement.run(); Calling `toString()` on a `Statement` instance prints the expanded SQL query. This is useful for debugging. ```ts -import { Database } from "bun:sqlite"; +import {Database} from 'bun:sqlite'; // setup let db = new Database(); db.run( - "CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)" + 'CREATE TABLE foo (id INTEGER PRIMARY KEY AUTOINCREMENT, greeting TEXT, count INTEGER)' ); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Welcome to bun!", 2); -db.run("INSERT INTO foo (greeting, count) VALUES (?, ?)", "Hello World!", 0); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Welcome to bun!', 2); +db.run('INSERT INTO foo (greeting, count) VALUES (?, ?)', 'Hello World!', 0); db.run( - "INSERT INTO foo (greeting, count) VALUES (?, ?)", - "Welcome to bun!!!!", + 'INSERT INTO foo (greeting, count) VALUES (?, ?)', + 'Welcome to bun!!!!', 2 ); // Statement object -const statement = db.query("SELECT * FROM foo WHERE count = ?"); +const statement = db.query('SELECT * FROM foo WHERE count = ?'); console.log(statement.toString()); // => "SELECT * FROM foo WHERE count = NULL" @@ -3582,7 +3580,7 @@ Internally, this calls [`sqlite3_expanded_sql`](https://www.sqlite.org/capi3ref. This snippet prints sqlite3's version number: ```ts -import { dlopen, FFIType, suffix } from "bun:ffi"; +import {dlopen, FFIType, suffix} from 'bun:ffi'; // `suffix` is either "dylib", "so", or "dll" depending on the platform // you don't have to use "suffix", it's just there for convenience @@ -3651,7 +3649,7 @@ zig build-lib add.zig -dynamic -OReleaseFast Pass `dlopen` the path to the shared library and the list of symbols you want to import. ```ts -import { dlopen, FFIType, suffix } from "bun:ffi"; +import {dlopen, FFIType, suffix} from 'bun:ffi'; const path = `libadd.${suffix}`; @@ -3793,7 +3791,7 @@ getVersion(); If you have multiple function pointers, you can define them all at once with `linkSymbols`: ```ts -import { linkSymbols } from "bun:ffi"; +import {linkSymbols} from 'bun:ffi'; // getVersionPtrs defined elsewhere const [majorPtr, minorPtr, patchPtr] = getVersionPtrs(); @@ -3801,7 +3799,7 @@ const [majorPtr, minorPtr, patchPtr] = getVersionPtrs(); const lib = linkSymbols({ // Unlike with dlopen(), the names here can be whatever you want getMajor: { - returns: "cstring", + returns: 'cstring', args: [], // Since this doesn't use dlsym(), you have to provide a valid ptr @@ -3810,12 +3808,12 @@ const lib = linkSymbols({ ptr: majorPtr, }, getMinor: { - returns: "cstring", + returns: 'cstring', args: [], ptr: minorPtr, }, getPatch: { - returns: "cstring", + returns: 'cstring', args: [], ptr: patchPtr, }, @@ -3833,27 +3831,27 @@ const [major, minor, patch] = [ Bun v0.2.3 added `JSCallback` which lets you create JavaScript callback functions that you can pass to C/FFI functions. The C/FFI function can call into the JavaScript/TypeScript code. This is useful for asynchronous code or otherwise when you want to call into JavaScript code from C. ```ts -import { dlopen, JSCallback, ptr, CString } from "bun:ffi"; +import {dlopen, JSCallback, ptr, CString} from 'bun:ffi'; const { - symbols: { search }, + symbols: {search}, close, -} = dlopen("libmylib", { +} = dlopen('libmylib', { search: { - returns: "usize", - args: ["cstring", "callback"], + returns: 'usize', + args: ['cstring', 'callback'], }, }); const searchIterator = new JSCallback( (ptr, length) => /hello/.test(new CString(ptr, length)), { - returns: "bool", - args: ["ptr", "usize"], + returns: 'bool', + args: ['ptr', 'usize'], } ); -const str = Buffer.from("wwutwutwutwutwutwutwutwutwutwutut\0", "utf8"); +const str = Buffer.from('wwutwutwutwutwutwutwutwutwutwutut\0', 'utf8'); if (search(ptr(str), searchIterator)) { // found a match! } @@ -3871,12 +3869,12 @@ For a slight performance boost, directly pass `JSCallback.prototype.ptr` instead ```ts const onResolve = new JSCallback((arg) => arg === 42, { - returns: "bool", - args: ["i32"], + returns: 'bool', + args: ['i32'], }); const setOnResolve = new CFunction({ - returns: "bool", - args: ["function"], + returns: 'bool', + args: ['function'], ptr: myNativeLibrarySetOnResolve, }); @@ -3910,7 +3908,7 @@ If you pass a `BigInt` to a function, it will be converted to a `number` **To convert from a TypedArray to a pointer**: ```ts -import { ptr } from "bun:ffi"; +import {ptr} from 'bun:ffi'; let myTypedArray = new Uint8Array(32); const myPtr = ptr(myTypedArray); ``` @@ -3918,7 +3916,7 @@ const myPtr = ptr(myTypedArray); **To convert from a pointer to an ArrayBuffer**: ```ts -import { ptr, toArrayBuffer } from "bun:ffi"; +import {ptr, toArrayBuffer} from 'bun:ffi'; let myTypedArray = new Uint8Array(32); const myPtr = ptr(myTypedArray); @@ -3934,7 +3932,7 @@ You have two options. For long-lived pointers, a `DataView` is the fastest option: ```ts -import { toArrayBuffer } from "bun:ffi"; +import {toArrayBuffer} from 'bun:ffi'; let myDataView = new DataView(toArrayBuffer(myPtr, 0, 32)); console.log( @@ -3950,7 +3948,7 @@ For short-lived pointers, `read` is the fastest option: _Available in Bun v0.1.12+_ ```ts -import { read } from "bun:ffi"; +import {read} from 'bun:ffi'; console.log( // ptr, byteOffset @@ -3998,7 +3996,7 @@ typedef void (*JSTypedArrayBytesDeallocator)(void *bytes, void *deallocatorConte ``` ```ts -import { toArrayBuffer } from "bun:ffi"; +import {toArrayBuffer} from 'bun:ffi'; // with a deallocatorContext: toArrayBuffer( @@ -4045,14 +4043,14 @@ Where FFI functions expect a pointer, pass a TypedArray of equivalent size Easymode: ```ts -import { dlopen, FFIType } from "bun:ffi"; +import {dlopen, FFIType} from 'bun:ffi'; const { - symbols: { encode_png }, + symbols: {encode_png}, } = dlopen(myLibraryPath, { encode_png: { // FFIType's can be specified as strings too - args: ["ptr", "u32", "u32"], + args: ['ptr', 'u32', 'u32'], returns: FFIType.ptr, }, }); @@ -4079,14 +4077,14 @@ The [auto-generated wrapper](https://github.com/oven-sh/bun/blob/6a65631cbdcae75 If you don't want the automatic conversion or you want a pointer to a specific byte offset within the TypedArray, you can also directly get the pointer to the TypedArray: ```ts -import { dlopen, FFIType, ptr } from "bun:ffi"; +import {dlopen, FFIType, ptr} from 'bun:ffi'; const { - symbols: { encode_png }, + symbols: {encode_png}, } = dlopen(myLibraryPath, { encode_png: { // FFIType's can be specified as strings too - args: ["ptr", "u32", "u32"], + args: ['ptr', 'u32', 'u32'], returns: FFIType.ptr, }, }); @@ -4124,7 +4122,7 @@ const out = encode_png( let png = new Uint8Array(toArrayBuffer(out)); // save it to disk: -await Bun.write("out.png", png); +await Bun.write('out.png', png); ``` ##### Not implemented yet @@ -4143,14 +4141,14 @@ You can see the status of [this here](https://github.com/oven-sh/bun/issues/158) Loading Node-API modules in Bun.js works the same as in Node.js: ```js -const napi = require("./my-node-module.node"); +const napi = require('./my-node-module.node'); ``` You can also use `process.dlopen`: ```js -let mod = { exports: {} }; -process.dlopen(mod, "./my-node-module.node"); +let mod = {exports: {}}; +process.dlopen(mod, './my-node-module.node'); ``` As part of that work, Bun.js also polyfills the [`detect-libc`](https://npmjs.com/package/detect-libc) package, which is used by many Node-API modules to detect which `.node` binding to `require`. @@ -4163,10 +4161,10 @@ When requiring a `*.node` module, Bun's JavaScript transpiler transforms the `re ```js // this is the input -require("./my-node-module.node"); +require('./my-node-module.node'); // this is the output -import.meta.require("./my-node-module.node"); +import.meta.require('./my-node-module.node'); ``` Bun doesn't currently support dynamic requires, but `import.meta.require` is an escape hatch for that. It uses a [JavaScriptCore built-in function](https://github.com/oven-sh/bun/blob/aa87d40f4b7fdfb52575f44d151906ddba6a82d0/src/javascript/jsc/bindings/builtins/js/JSZigGlobalObject.js#L26). @@ -4258,19 +4256,19 @@ This lets you transpile JavaScript, TypeScript, TSX, and JSX using Bun's transpi It is synchronous and runs in the same thread as other JavaScript code. ```js -const transpiler = new Bun.Transpiler({ loader: "jsx" }); -transpiler.transformSync("
hi!
"); +const transpiler = new Bun.Transpiler({loader: 'jsx'}); +transpiler.transformSync('
hi!
'); ``` ```js -import { __require as require } from "bun:wrap"; -import * as JSX from "react/jsx-dev-runtime"; +import {__require as require} from 'bun:wrap'; +import * as JSX from 'react/jsx-dev-runtime'; var jsx = require(JSX).jsxDEV; export default jsx( - "div", + 'div', { - children: "hi!", + children: 'hi!', }, undefined, false, @@ -4292,19 +4290,19 @@ If code uses a macro, it will potentially spawn a new copy of Bun.js' JavaScript Unless you're transpiling _many_ large files, you should probably use `Bun.Transpiler.transformSync`. The cost of the threadpool will often take longer than actually transpiling code. ```js -const transpiler = new Bun.Transpiler({ loader: "jsx" }); -await transpiler.transform("
hi!
"); +const transpiler = new Bun.Transpiler({loader: 'jsx'}); +await transpiler.transform('
hi!
'); ``` ```js -import { __require as require } from "bun:wrap"; -import * as JSX from "react/jsx-dev-runtime"; +import {__require as require} from 'bun:wrap'; +import * as JSX from 'react/jsx-dev-runtime'; var jsx = require(JSX).jsxDEV; export default jsx( - "div", + 'div', { - children: "hi!", + children: 'hi!', }, undefined, false, @@ -4316,7 +4314,7 @@ export default jsx( You can also pass a `Loader` as a string ```js -await transpiler.transform("
hi!
", "tsx"); +await transpiler.transform('
hi!
', 'tsx'); ``` #### `Bun.Transpiler.scan` @@ -4326,7 +4324,7 @@ This is a fast way to get a list of imports & exports used in a JavaScript/jsx o This function is synchronous. ```ts -const transpiler = new Bun.Transpiler({ loader: "ts" }); +const transpiler = new Bun.Transpiler({loader: 'ts'}); transpiler.scan(` import React from 'react'; @@ -4367,7 +4365,7 @@ This is a fast path for getting a list of imports used in a JavaScript/jsx or Ty This function is synchronous. ```ts -const transpiler = new Bun.Transpiler({ loader: "ts" }); +const transpiler = new Bun.Transpiler({loader: 'ts'}); transpiler.scanImports(` import React from 'react'; diff --git a/bench/bun.lockb b/bench/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..14530a5ec0b6b9d80218445423eed797296eed1f GIT binary patch literal 35685 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 literal 0 HcmV?d00001 diff --git a/bench/ffi/src/bun.lockb b/bench/ffi/src/bun.lockb index 184cb439cf493510a91647a6348fce0e56512fd3..28144fc51d96955f5a91c8e80010f6acb0eb35d4 100755 GIT binary patch delta 769 zcmaFO^PX>lmKqZS1H(a&8@}QD9sXr@FWX$GRZ_M(HSjIh#>^{Wuf1nYVm>T%oo!-( zn)C){pi(eMO3h2o0J3<1n4f{6A!6c0a}S6V0|OtF!3d=<$*7N4n z_E_c3zm&xzv$C^jabdICJ4W^Pv$xml-G1rGv2Es5;TrQTw;q2FKPT|1IVVK&jVpIe zbX_Jx^s1}ut7q|^1)2r}1{n}%!@L0!Z>XvRdnIGdid>jFWHD!ubMg`kGC`8dfmi^j z=La;{3Rpm*3=CX0#YM?_nR&$}i8(oXIr+)iX_+~xdLc!rsdfrR29pC=Bqr}?uAE%L zqBA*#MS$}LRNs@yjx5TP7qIYfO0YsqN}IfuCEh*)$N|}-cEH;1s_EoMOpI}cdWL!i z3=A8f>R>dg&Bdv?WvNAalO0%9xgJ1Oo@bk!&#DNvaB@GZOnpX4NkOrdzJ5_^dS-D+ zQKep9L2g#DUVc%!zC&JqN~&&Av3^EsPC;sszAluZYp7=ogeB=!4xo?#sVFJREXYYM z#%ma=QlM!dO`$+tK=Xi}0hw2v3=}FU*3ZmKNv+V!BFenvoJ^ouKvLI8&(H{B&g6@% KvnDGrvH<`^{?0}K delta 473 zcmaFQ_nK#dmKq}i1H*mIh2K}7W%}KW@9GfWm>G-QXd0~if?pll|f4z9_8jK-T!ForVLyB*hVcJO<^ zv`VygndW__*GCuLwG@)AYQ6C-^VjRp1zYQEP1GfW4P>9^Dip+sb!}C$J@Hsk*odXo z^Mc^7sJfp}7l5b+2GbBD76t~8*I}SQ&WH)b*RVgGk4;Psf0#=+GoV5xlPg(_Cl|2jOuoUw!}$OzsyF#9OFX0WWM5WEp;T6g zW*7}Lq?=WhYXVgGH0$JDtcsH#uu3a9fb7>TD%LM4$}Gr9EiO(5(j~?EnRzLx6?$34 LlP|K(13D7`$-;DA diff --git a/bench/hot-module-reloading/css-stress-test/bun.lockb b/bench/hot-module-reloading/css-stress-test/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..9cad009bbab60b8f5ab3b44bf19d3cbb5119db3e GIT binary patch literal 337189 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⪚4R~)m){TG^7}K% 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
ycg($wHU;sLx#?i5~ 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

tR= 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 diff --git a/bench/hot-module-reloading/css-stress-test/src/main.tsx b/bench/hot-module-reloading/css-stress-test/src/main.tsx index 3b67cd111b..2093d924f5 100644 --- a/bench/hot-module-reloading/css-stress-test/src/main.tsx +++ b/bench/hot-module-reloading/css-stress-test/src/main.tsx @@ -1,11 +1,11 @@ -export const Main = ({ productName, cssInJS }) => { +export const Main = (props: { productName: string; cssInJS?: string }) => { return ( <>

CSS HMR Stress Test!

This page visually tests how quickly a bundler can update{" "} - {cssInJS ? "CSS-in-JS" : "CSS"} over Hot Module Reloading. + {props.cssInJS ? "CSS-in-JS" : "CSS"} over Hot Module Reloading.

@@ -53,9 +53,9 @@ export const Main = ({ productName, cssInJS }) => {
-
{productName}
+
{props.productName}
- {cssInJS ? "CSS-in-JS framework: " + cssInJS : ""} + {props.cssInJS ? "CSS-in-JS framework: " + props.cssInJS : ""}
diff --git a/bench/hot-module-reloading/css-stress-test/tsconfig.json b/bench/hot-module-reloading/css-stress-test/tsconfig.json index 19d4ac2e6f..289c8f710e 100644 --- a/bench/hot-module-reloading/css-stress-test/tsconfig.json +++ b/bench/hot-module-reloading/css-stress-test/tsconfig.json @@ -1,6 +1,8 @@ { + "extends": "../../../tsconfig.base.json", "compilerOptions": { "baseUrl": ".", + "jsx": "react-jsx", "paths": {} } -} +} \ No newline at end of file diff --git a/bench/scanner/bun.lockb b/bench/scanner/bun.lockb index 90bb789963e5a67c014f5c3cf2df72a6237c05c6..24eec21f4f1bb7cea0e54412edc0b33564de9c88 100755 GIT binary patch literal 8640 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 literal 6186 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 a=zZBCTnV?4X3}w_5qgSd8t&>Z>Gv;xE|2X1 diff --git a/bench/websocket-server/bun.lockb b/bench/websocket-server/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..8bf2ac8e6e083ca1134dae9d1517fd5acbb37de0 GIT binary patch literal 2466 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 literal 0 HcmV?d00001 diff --git a/examples/macros/components/covid19.tsx b/examples/macros/components/covid19.tsx index 52fee2ff35..330661c829 100644 --- a/examples/macros/components/covid19.tsx +++ b/examples/macros/components/covid19.tsx @@ -6,7 +6,7 @@ export const Covid19 = () => { { last: 100, columns: ["New_cases", "Date_reported", "Country"], - } + }, ); return ( diff --git a/examples/macros/components/example.jsx b/examples/macros/components/example.jsx index ad80ce9e1a..84d2d92e9f 100644 --- a/examples/macros/components/example.jsx +++ b/examples/macros/components/example.jsx @@ -10,7 +10,7 @@ export const IPAddresses = () => (
{ipAddress}
- ) + ), )} diff --git a/examples/macros/mystery-box.ts b/examples/macros/mystery-box.ts index 4dff5d0039..6583c98689 100644 --- a/examples/macros/mystery-box.ts +++ b/examples/macros/mystery-box.ts @@ -1,13 +1,16 @@ export function mysteryBox(callExpression) { console.log(callExpression.log); // get arguments - const [ countNode ] = callExpression.arguments; + const [countNode] = callExpression.arguments; const countString: string = countNode.get(); const count: number = parseInt(countString, 10); // validate - if(!(count >= 1 && count <= 1000)) return new Error(`Argument ${countString} is expected to be between 1 and 1000`); + if (!(count >= 1 && count <= 1000)) + return new Error( + `Argument ${countString} is expected to be between 1 and 1000`, + ); // return a value - return (Math.random() * count)|0; + return (Math.random() * count) | 0; } diff --git a/examples/react-fast-refresh-test/bun.lockb b/examples/react-fast-refresh-test/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..a3cf88405819e8522f80a70c08e8c5ac1f4b504c GIT binary patch literal 352211 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�@%`t0dl>t|4}m~8?f=vM{tdf{3v9XipPC1MEelRgCQe4sefP)zs)vkj8001f z(0cOUI1gaC`|oo61y&YY16w-_V+f?>DFgyNtl8qy zj&(OfpA$fz|HELPal`)WG59-&{;K{Ulh7MBz_!g`F}3`=O8jrbVBh1PZTV4ye;rG^ zVK;Gs<@5hddGJ@=>1<~R``#9||JsK&xM7f+7(mynH+gUq18CiFlLt33fUP5L^5DN7 zgTJ;r%?D4===KZ*HU{gf ze-{QT7j!%8e<|O8H}-#eJq-=X|FYhPeTLHuGdtL8PoNhw{j*NKVK;Gs<;1^p9>8+f z(&>SlfsHkUwfSG?>2BD+Ph4QXk-dwfnF)0F0ImIBZPjkrOT zV*pzR*qXRH!@grK^hQ3IzmI|5u$#ERa^fZr{=H)WTYk+=V87H~?eAItdH&BBdZy^# zj={>I;;3f}lV(?cQ+|-FT z%ferY@IQ6k2-_BLG;y-CeqjQ!!iW2h>t=7*{~8zAxi;v1GyXc)2FB`thw&W3A`O91 z|L*7zUBJoFh{eLz$=Sf#n#J1A$ja2h+Jr^T(ZocEnuCqn$->>l&Xk#&liI-A!pzpr z6ne7ipW*uV0Go#OFZ<6lZ2aduH|+1|+{EQ3H*S`Nn`Pne2;3|SH_O7!vT(C3{1btj z`rxKMxTz2RSsHG(m2c{UoBH6UKDen5{)xa%eQ;AB+|&pEEDbl?2RHS>O?_}vAN+T# z51_rsLBRe)VD*>;l!1Mfz?dYIf&JFOm=u)#)3+h)oC|akA`N|b3iKNSn@Z|2p$z)>p9Uo;fPFu3P=-!}{hz>IQ-LzDFEJQXg)*?8H5gNaGO%wu7<&q3V1I%z zrVeFb--R%y0cBwSi!i1MWnkZwFs21%VE>vhrVV9a-=i?517*9(<+U zzMEmp1j@jEqG8Mw%D_IUVayE5!2Yjc%pA%r{`g!ADAWCeSwb1uCpYZ9R!|1^{|#f- zQ0Dl@du^Z$?B5+WpDmQx|1qB(lo|cO?4bOYiP^JoHu=?Yl!58{m>5uvRpiJ~P6M~MRZO$S7P$u%nd;w4fdmS7C zp==HM4;y5mufd)MK_6Crv%g+|KD>fX^Z)VQU?}7JgM~mD^6&S`{q}`Iryu??Ul^2q z{ypD6pAin7X8&Wp*HFgt2aA9*x<6PXl+pabqM(fG4;Bq&0{KtHWP=@#iOM)`^-wc)y&`C%#^x^V%MXvRm zr9j!)ZwAXH*nFwbhtuB-mUA$c27SnZj=>=v%65Lw2de{M>zNEF`w0C9hfL`7_V4-r z;aO0&^#{v_vW-7j4wS+Ag8P4ndkZkDs<-|BfFRN#jgo@o&@C<9C8&T-0RzJ@%nV&a zcOxO)-O{Om5+X>qf+&rY2&nM?-21Hko&7zWt-sgnz25)2xM!_>KP#T~tlVqwvvIol za7PRgM7er*VgX!BXC%T4;Wqkki{L)+;TFR!HJrvLm!2j38D}_+<3xm)!s#3EPPYuM zpdmD;DBg0oJos9NZMTB3?BjGR;j%jk!mHpi`EaY@H13>k4O~_yL3k}3{|(E3xpi>* zJ-O4Zhtqo{a$QY*H^Axtz?IWH&86oH{$#M2xIY`=-i*7nLTYcvD9)YB zt()aOdDk`=mV&SHUOV z1vu@mo$eys72tH2xc<>_+GimZ#nG^6}-wH^$(}} ziEH&OIrSR_uklBH(CL2WT7A{&e&Mf<{++a1OKta@ z@Dm^I54hiaxIf_@!O0CpPi65Jf9@O367c5*oYn!Sd i~n+@)B5Oi@!%HvaPi@O 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 literal 0 HcmV?d00001 diff --git a/examples/react-fast-refresh-test/tsconfig.json b/examples/react-fast-refresh-test/tsconfig.json index 401ede3446..d543b64724 100644 --- a/examples/react-fast-refresh-test/tsconfig.json +++ b/examples/react-fast-refresh-test/tsconfig.json @@ -1,7 +1,11 @@ { "compilerOptions": { "target": "esnext", - "lib": ["dom", "dom.iterable", "esnext"], + "lib": [ + "dom", + "dom.iterable", + "esnext" + ], "allowJs": true, "skipLibCheck": true, "strict": false, @@ -14,6 +18,12 @@ "isolatedModules": true, "jsx": "preserve" }, - "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"], - "exclude": ["node_modules"] -} + "include": [ + "next-env.d.ts", + "**/*.ts", + "**/*.tsx" + ], + "exclude": [ + "node_modules" + ] +} \ No newline at end of file diff --git a/examples/spawn.ts b/examples/spawn.ts index a590a94f33..d72a118b92 100644 --- a/examples/spawn.ts +++ b/examples/spawn.ts @@ -8,7 +8,7 @@ const target = basename(repo) + "-main"; console.log("Downloading", repo, "to", "/tmp/" + target); const archive = await fetch( - `https://github.com/${repo}/archive/refs/heads/main.tar.gz` + `https://github.com/${repo}/archive/refs/heads/main.tar.gz`, ); // remove the directory if it already exists locally @@ -29,14 +29,11 @@ await tar.exited; if (!which("vercel")) { console.log("Installing vercel..."); - const installer = spawn( - { cmd: ["bun", "install", "-g", "vercel"] }, - { - stderr: "inherit", - stdout: "inherit", - stdin: "inherit", - } - ); + const installer = spawn(["bun", "install", "-g", "vercel"], { + stderr: "inherit", + stdout: "inherit", + stdin: "inherit", + }); await installer.exited; if (!which("vercel")) { diff --git a/examples/tsconfig.json b/examples/tsconfig.json deleted file mode 100644 index 404c353e6a..0000000000 --- a/examples/tsconfig.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "compilerOptions": { - "lib": ["ESNext"], - "module": "esnext", - "target": "esnext", - "typeRoots": ["../types"] - } -} diff --git a/misctools/gen-unicode-table.js b/misctools/gen-unicode-table.js index cd46ac31cd..ad38a0ec5b 100644 --- a/misctools/gen-unicode-table.js +++ b/misctools/gen-unicode-table.js @@ -19,7 +19,7 @@ const idStartES5 = [] require("@unicode/unicode-3.0.0/General_Category/Lowercase_Letter/code-points"), require("@unicode/unicode-3.0.0/General_Category/Titlecase_Letter/code-points"), require("@unicode/unicode-3.0.0/General_Category/Modifier_Letter/code-points"), - require("@unicode/unicode-3.0.0/General_Category/Other_Letter/code-points") + require("@unicode/unicode-3.0.0/General_Category/Other_Letter/code-points"), // The "letter number" category is not included because old versions of Safari // had a bug where they didn't include it. This means it does not match ES5. @@ -38,7 +38,7 @@ const idContinueES5 = idStartES5 require("@unicode/unicode-3.0.0/General_Category/Nonspacing_Mark/code-points"), require("@unicode/unicode-3.0.0/General_Category/Spacing_Mark/code-points"), require("@unicode/unicode-3.0.0/General_Category/Decimal_Number/code-points"), - require("@unicode/unicode-3.0.0/General_Category/Connector_Punctuation/code-points") + require("@unicode/unicode-3.0.0/General_Category/Connector_Punctuation/code-points"), ) .sort((a, b) => a - b); @@ -60,12 +60,12 @@ const idContinueESNextSet = new Set(idContinueESNext); // These identifiers are valid in both ES5 and ES6+ (i.e. an intersection of both) const idStartES5AndESNext = idStartES5.filter((n) => idStartESNextSet.has(n)); const idContinueES5AndESNext = idContinueES5.filter((n) => - idContinueESNextSet.has(n) + idContinueESNextSet.has(n), ); // These identifiers are valid in either ES5 or ES6+ (i.e. a union of both) const idStartES5OrESNext = [...new Set(idStartES5.concat(idStartESNext))].sort( - (a, b) => a - b + (a, b) => a - b, ); const idContinueES5OrESNext = [ ...new Set(idContinueES5.concat(idContinueESNext)), @@ -166,7 +166,7 @@ function generateBigSwitchStatement(codePoints) { fs.writeFileSync( path.join(__dirname, "..", "src", "js_lexer", "unicode.zig"), `// This file was automatically generated by ${path.basename( - __filename + __filename, )}. Do not edit. const RangeTable = @import("./range_table.zig"); @@ -190,5 +190,5 @@ pub fn isIdentifierContinue(comptime Codepoint: type, codepoint: Codepoint) bool } -` +`, ); diff --git a/misctools/headers-cleaner.js b/misctools/headers-cleaner.js index 10824d9167..850cc3196b 100644 --- a/misctools/headers-cleaner.js +++ b/misctools/headers-cleaner.js @@ -5,7 +5,7 @@ var { join } = require("path"); const destination = join(__dirname, "../src/bun.js/bindings/headers.zig"); const replacements = join( __dirname, - "../src/bun.js/bindings/headers-replacements.zig" + "../src/bun.js/bindings/headers-replacements.zig", ); console.log("Writing to", destination); @@ -24,7 +24,7 @@ const keep = ( (a) => /const (JSC|WTF|Web)_/gi.test(a) && !a.includes("JSValue") && - !a.includes("CatchScope") + !a.includes("CatchScope"), ) .join("\n") .trim(); @@ -36,7 +36,7 @@ input = input.replaceAll("[*c] JSC__", "[*c]bindings."); input = input.replaceAll("[*c] const JSC__", "[*c]const bindings."); input = input.replaceAll( "[*c]Inspector__ScriptArguments", - "[*c]bindings.ScriptArguments" + "[*c]bindings.ScriptArguments", ); input = input @@ -98,5 +98,5 @@ writeFileSync( readFileSync(replacements, "utf8").trim() + "\n" + input.trim() + - "\n" + "\n", ); diff --git a/misctools/mime.js b/misctools/mime.js index 74f9773e77..6f46a711fa 100644 --- a/misctools/mime.js +++ b/misctools/mime.js @@ -10,7 +10,7 @@ json["application/javascript"].extensions.push( `cts`, `cjs`, `mjs`, - `js` + `js`, ); delete json["application/node"]; diff --git a/misctools/publish-examples.js b/misctools/publish-examples.js index d84466e15a..4124d0785f 100644 --- a/misctools/publish-examples.js +++ b/misctools/publish-examples.js @@ -16,7 +16,7 @@ var count = 0; const examplesFolderEntries = fs.readdirSync( path.join(process.cwd(), "examples"), - { withFileTypes: true } + { withFileTypes: true }, ); const packageNames = []; @@ -30,7 +30,7 @@ for (let folder of examplesFolderEntries) { try { packageJSONText = fs.readFileSync( path.join(absolute, "package.json"), - "utf8" + "utf8", ); } catch { continue; @@ -72,7 +72,7 @@ for (let folder of examplesFolderEntries) { try { fs.copyFileSync( path.join(absolute, ".gitignore"), - path.join(absolute, "gitignore") + path.join(absolute, "gitignore"), ); } catch (exception) {} @@ -87,7 +87,7 @@ for (let folder of examplesFolderEntries) { fs.writeFileSync( path.join(absolute, "package.json"), - JSON.stringify(packageJSON, null, 2) + JSON.stringify(packageJSON, null, 2), ); try { exec(`npm version patch --force --no-commit-hooks --no-git-tag-version`, { @@ -95,7 +95,7 @@ for (let folder of examplesFolderEntries) { }); packageJSON = JSON.parse( - fs.readFileSync(path.join(absolute, "package.json"), "utf8") + fs.readFileSync(path.join(absolute, "package.json"), "utf8"), ); version = packageJSON.version; } catch (e) { @@ -109,7 +109,7 @@ for (let folder of examplesFolderEntries) { `npm publish ${ DRY_RUN ? "--dry-run" : "" } --access public --registry https://registry.npmjs.org/`, - { cwd: absolute } + { cwd: absolute }, ); packageNames.push([ packageJSON.name, @@ -149,13 +149,13 @@ if (packageNames.length > 0) { } catch (exception) {} fs.writeFileSync( path.join(dir, "package.json"), - JSON.stringify(packageJSON, null, 2) + JSON.stringify(packageJSON, null, 2), ); exec( `npm publish ${ DRY_RUN ? "--dry-run" : "" } --access public --registry https://registry.npmjs.org/`, - { cwd: dir } + { cwd: dir }, ); } diff --git a/package.json b/package.json index 59a6b16cc2..12d3e822f2 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,5 @@ { "dependencies": { - "bun-types": "latest", "express": "^4.18.2", "mitata": "^0.1.3", "peechy": "0.4.32", @@ -10,14 +9,23 @@ "private": true, "scripts": { "build-runtime": "esbuild --target=esnext --bundle src/runtime/index.ts --format=iife --platform=browser --global-name=BUN_RUNTIME > src/runtime.out.js; cat src/runtime.footer.js >> src/runtime.out.js", - "build-fallback": "esbuild --target=esnext --bundle src/fallback.ts --format=iife --platform=browser --minify > src/fallback.out.js" + "build-fallback": "esbuild --target=esnext --bundle src/fallback.ts --format=iife --platform=browser --minify > src/fallback.out.js", + "typecheck": "tsc", + "fmt": "prettier --write './**/*.{ts,tsx,js,jsx}'", + "lint": "eslint './**/*.d.ts'", + "lint:fix": "eslint './**/*.d.ts' --fix" }, "devDependencies": { + "@types/react": "^18.0.25", + "@typescript-eslint/eslint-plugin": "^5.31.0", + "@typescript-eslint/parser": "^5.31.0", + "eslint": "^8.20.0", + "eslint-config-prettier": "^8.5.0", "he": "^1.2.0", "html-entities": "^2.3.3", "prettier": "^2.4.1", - "svelte": "^3.50.0", - "typescript": "4.6.3" + "svelte": "^3.52.0", + "typescript": "latest" }, "version": "0.0.0" -} \ No newline at end of file +} diff --git a/packages/bun-error/index.tsx b/packages/bun-error/index.tsx index cf0aaaf682..5c64fe8073 100644 --- a/packages/bun-error/index.tsx +++ b/packages/bun-error/index.tsx @@ -16,11 +16,7 @@ import { problemsToMarkdown, withBunInfo, } from "./markdown"; -import { - fetchAllMappings, - remapPosition, - sourceMappings, -} from "./sourcemap"; +import { fetchAllMappings, remapPosition, sourceMappings } from "./sourcemap"; export enum StackFrameScope { Eval = 1, @@ -140,7 +136,7 @@ function hasColumnOrLine(filename: string) { function appendLineColumnIfNeeded( base: string, line?: number, - column?: number + column?: number, ) { if (hasColumnOrLine(base)) return base; @@ -162,7 +158,7 @@ function appendLineColumn(base: string, line?: number, column?: number) { const blobFileURL = ( filename: string, line?: number, - column?: number + column?: number, ): string => { var base = `/blob:${filename}`; @@ -174,7 +170,7 @@ const blobFileURL = ( const maybeBlobFileURL = ( filename: string, line?: number, - column?: number + column?: number, ): string => { if (filename.includes(".bun")) { return blobFileURL(filename, line, column); @@ -187,7 +183,9 @@ const maybeBlobFileURL = ( return srcFileURL(filename, line, column); }; -const openWithoutFlashOfNewTab: React.MouseEventHandler = (event) => { +const openWithoutFlashOfNewTab: React.MouseEventHandler = ( + event, +) => { const target = event.currentTarget; const href = target.getAttribute("href"); if (!href || event.button !== 0) { @@ -218,7 +216,7 @@ const openWithoutFlashOfNewTab: React.MouseEventHandler = (ev }) .then( () => {}, - (er) => {} + (er) => {}, ); return false; }; @@ -226,7 +224,7 @@ const openWithoutFlashOfNewTab: React.MouseEventHandler = (ev const srcFileURL = ( filename: string, line?: number, - column?: number + column?: number, ): string => { if (filename.startsWith("http://") || filename.startsWith("https://")) return appendLineColumnIfNeeded(filename); @@ -255,7 +253,7 @@ class FancyTypeError { constructor(exception: JSException) { this.runtimeType = exception.runtime_type || 0; this.runtimeTypeName = RuntimeType[this.runtimeType] || "undefined"; - this.message = exception.message || ''; + this.message = exception.message || ""; this.explain = ""; this.normalize(exception); @@ -276,7 +274,7 @@ class FancyTypeError { this.runtimeTypeName = nextWord[0]; this.runtimeTypeName = this.runtimeTypeName.substring( 0, - this.runtimeTypeName.length - 1 + this.runtimeTypeName.length - 1, ); switch (this.runtimeTypeName.toLowerCase()) { case "undefined": { @@ -316,7 +314,7 @@ class FancyTypeError { this.message = exception.message.substring(0, i); this.message = this.message.substring( 0, - this.message.lastIndexOf("(In ") + this.message.lastIndexOf("(In "), ); } } @@ -380,11 +378,11 @@ const AsyncSourceLines = ({ const lines = text.split("\n"); const startLineNumber = Math.max( Math.min(Math.max(highlight - 4, 0), lines.length - 1), - 0 + 0, ); const endLineNumber = Math.min(startLineNumber + 8, lines.length); const sourceLines: SourceLine[] = new Array( - endLineNumber - startLineNumber + endLineNumber - startLineNumber, ); var index = 0; for (let i = startLineNumber; i < endLineNumber; i++) { @@ -399,7 +397,7 @@ const AsyncSourceLines = ({ setSourceLines( index !== sourceLines.length ? sourceLines.slice(0, index) - : sourceLines + : sourceLines, ); setLoadState(LoadState.loaded); }) @@ -524,7 +522,7 @@ const SourceLines = ({ title={`Open line ${line} in editor`} href={buildURL( line, - classes.highlight ? highlightColumnStart : dedent + classes.highlight ? highlightColumnStart : dedent, )} onClickCapture={openWithoutFlashOfNewTab} key={"highlight-number-" + line} @@ -572,7 +570,7 @@ const BuildErrorSourceLines = ({ const sourceLines: SourceLine[] = [{ line, text: line_text }]; const buildURL = React.useCallback( (line, column) => srcFileURL(filename, line, column), - [srcFileURL, filename] + [srcFileURL, filename], ); return ( { const { cwd } = useContext(ErrorGroupContext); const { @@ -718,7 +716,7 @@ const NativeStackFrames = ({ frames, urlBuilder }) => { for (let i = 0; i < frames.length; i++) { maxLength = Math.max( getNativeStackFrameIdentifier(frames[i]).length, - maxLength + maxLength, ); } @@ -760,7 +758,7 @@ const NativeStackTrace = ({ const ref = React.useRef(null); const buildURL = React.useCallback( (line, column) => urlBuilder(file, line, column), - [file, urlBuilder] + [file, urlBuilder], ); return ( @@ -825,7 +823,7 @@ const JSException = ({ }) => { const tag = isClient ? ErrorTagType.client : ErrorTagType.server; const [sourceLines, _setSourceLines] = React.useState( - value?.stack?.source_lines ?? [] + value?.stack?.source_lines ?? [], ); var message = value.message || ""; var name = value.name || ""; @@ -1054,7 +1052,9 @@ const OverlayMessageContainer = ({ reason, isClient = false, }: FallbackMessageContainer & { isClient: boolean }) => { - const errorCount = problems ? problems.exceptions.length + problems.build.errors : 0; + const errorCount = problems + ? problems.exceptions.length + problems.build.errors + : 0; return (
@@ -1149,7 +1149,7 @@ function renderWithFunc(func) { reactRoot.id = BUN_ERROR_CONTAINER_ID; const fallbackStyleSheet = document.querySelector( - "style[data-has-bun-fallback-style]" + "style[data-has-bun-fallback-style]", ); if (!fallbackStyleSheet) { reactRoot.style.visibility = "hidden"; @@ -1309,9 +1309,9 @@ export function renderRuntimeError(error: Error) { // and don't fetch them again const framePromises = fetchAllMappings( exception.stack.frames.map((frame) => - normalizedFilename(frame.file, thisCwd) + normalizedFilename(frame.file, thisCwd), ), - signal + signal, ) .map((frame, i) => { if (stopThis.stopped) return null; @@ -1393,7 +1393,7 @@ export function dismissError() { export const renderBuildFailure = ( failure: WebsocketMessageBuildFailure, - cwd: string + cwd: string, ) => { thisCwd = cwd; renderWithFunc(() => ( diff --git a/packages/bun-error/markdown.ts b/packages/bun-error/markdown.ts index 8b27fc8cbb..d6bbbf30c6 100644 --- a/packages/bun-error/markdown.ts +++ b/packages/bun-error/markdown.ts @@ -123,7 +123,7 @@ function exceptionToMarkdown(exception: JSException): string { // but it may not be var prefix = "".padStart( lineText.length - lineText.trimStart().length, - " " + " ", ); prefix += @@ -159,7 +159,7 @@ function exceptionToMarkdown(exception: JSException): string { scope, functionName: function_name, markdown: true, - }).length + }).length, ); } @@ -268,7 +268,7 @@ export const withBunInfo = (text) => { const markdown = bunInfoToMarkdown(info).trim(); return trimmed + "\n" + markdown + "\n"; }, - () => trimmed + "\n" + () => trimmed + "\n", ); } diff --git a/packages/bun-error/runtime-error.ts b/packages/bun-error/runtime-error.ts index 713bfb7c0d..5341e0bc89 100644 --- a/packages/bun-error/runtime-error.ts +++ b/packages/bun-error/runtime-error.ts @@ -107,7 +107,7 @@ export default class RuntimeError { var tokens = sanitizedLine.split(/\s+/).slice(1); // if a location was matched, pass it to extractLocation() otherwise pop the last token var locationParts = this.extractLocation( - location ? location[1] : tokens.pop() + location ? location[1] : tokens.pop(), ); var functionName = tokens.join(" ") || undefined; var fileName = @@ -135,7 +135,7 @@ export default class RuntimeError { if (line.indexOf(" > eval") > -1) { line = line.replace( / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, - ":$1" + ":$1", ); } @@ -149,7 +149,7 @@ export default class RuntimeError { var matches = line.match(functionNameRegex); var functionName = matches && matches[1] ? matches[1] : undefined; var locationParts = this.extractLocation( - line.replace(functionNameRegex, "") + line.replace(functionNameRegex, ""), ); return new StackFrame({ diff --git a/packages/bun-error/sourcemap.ts b/packages/bun-error/sourcemap.ts index bee83f559c..115ff69f13 100644 --- a/packages/bun-error/sourcemap.ts +++ b/packages/bun-error/sourcemap.ts @@ -214,7 +214,7 @@ export function decodeMappings(mappings, sourcesCount) { export function remapPosition( decodedMappings: Int32Array, line: number, - column: number + column: number, ) { if (!(decodedMappings instanceof Int32Array)) { throw new Error("decodedMappings must be an Int32Array"); diff --git a/packages/bun-error/tsconfig.json b/packages/bun-error/tsconfig.json index c125976f1f..ddf84fcae7 100644 --- a/packages/bun-error/tsconfig.json +++ b/packages/bun-error/tsconfig.json @@ -1,10 +1,13 @@ { "compilerOptions": { "jsx": "react", - "lib": ["ESNext", "DOM"], + "lib": [ + "ESNext", + "DOM" + ], "module": "esnext", "target": "esnext", "moduleResolution": "node", "allowSyntheticDefaultImports": true, } -} +} \ No newline at end of file diff --git a/packages/bun-framework-next/bun.lockb b/packages/bun-framework-next/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..df7b3ae9478cc7c0e266ef23a70fb0a7fb62aaa2 GIT binary patch literal 13859 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 literal 0 HcmV?d00001 diff --git a/packages/bun-framework-next/client.development.tsx b/packages/bun-framework-next/client.development.tsx index 4b51966c91..470dd20858 100644 --- a/packages/bun-framework-next/client.development.tsx +++ b/packages/bun-framework-next/client.development.tsx @@ -64,7 +64,7 @@ function nextDataFromBunData() { for (let i = 0; i < paramsList.keys.length; i++) { paramsMap.set( decodeURIComponent(paramsList.keys[i]), - decodeURIComponent(paramsList.values[i]) + decodeURIComponent(paramsList.values[i]), ); } @@ -134,31 +134,31 @@ setConfig({ }); let asPath: string = getURL(); -const basePath = (process.env.__NEXT_ROUTER_BASEPATH as string) || '' +const basePath = (process.env.__NEXT_ROUTER_BASEPATH as string) || ""; function pathNoQueryHash(path: string) { - const queryIndex = path.indexOf('?') - const hashIndex = path.indexOf('#') + const queryIndex = path.indexOf("?"); + const hashIndex = path.indexOf("#"); if (queryIndex > -1 || hashIndex > -1) { - path = path.substring(0, queryIndex > -1 ? queryIndex : hashIndex) + path = path.substring(0, queryIndex > -1 ? queryIndex : hashIndex); } - return path + return path; } function hasBasePath(path: string): boolean { - path = pathNoQueryHash(path) - return path === prefix || path.startsWith(prefix + '/') + path = pathNoQueryHash(path); + return path === prefix || path.startsWith(prefix + "/"); } function delBasePath(path: string): string { - path = path.slice(basePath.length) - if (!path.startsWith('/')) path = `/${path}` - return path + path = path.slice(basePath.length); + if (!path.startsWith("/")) path = `/${path}`; + return path; } // make sure not to attempt stripping basePath for 404s -if (hasBasePath(asPath)) { +if (hasBasePath(asPath)) { asPath = delBasePath(asPath); } @@ -214,8 +214,8 @@ class Container extends React.Component<{ String( assign( urlQueryToSearchParams(router.query), - new URLSearchParams(location.search) - ) + new URLSearchParams(location.search), + ), ), asPath, { @@ -229,7 +229,7 @@ class Container extends React.Component<{ // Other pages (strictly updating query) happens shallowly, as data // requirements would already be present. shallow: !isFallback, - } + }, ); } } @@ -326,7 +326,7 @@ export async function _boot(EntryPointNamespace, isError) { console.assert( AppModule.default, - appSrc + " must have a default export'd React component" + appSrc + " must have a default export'd React component", ); if ("default" in AppModule) { @@ -355,7 +355,7 @@ export async function _boot(EntryPointNamespace, isError) { Component: info.Component || CachedComponent, App, scroll, - }) + }), ); }, locale, @@ -431,7 +431,7 @@ export function render(props) { } else { ReactDOM.render( , - document.getElementById("__next") + document.getElementById("__next"), ); } } diff --git a/packages/bun-framework-next/fallback.development.tsx b/packages/bun-framework-next/fallback.development.tsx index 4db94e5d54..6e3ff00ff7 100644 --- a/packages/bun-framework-next/fallback.development.tsx +++ b/packages/bun-framework-next/fallback.development.tsx @@ -12,7 +12,7 @@ function insertGlobalStyleSheet({ detail: url }) { link.onabort = reject; link.onerror = reject; document.head.appendChild(link); - }) + }), ); } @@ -27,7 +27,7 @@ function insertNextHeadCount() { if (!once) { document.head.insertAdjacentHTML( "beforeend", - `` + ``, ); once = true; } @@ -43,7 +43,7 @@ globalThis.__BUN_APP_STYLES = [...globalThis["__BUN"].allImportedStyles].map( } return style; - } + }, ); import { _boot, pageLoader } from "./client.development"; @@ -96,7 +96,7 @@ export default function render(props: FallbackMessageContainer) { Promise.all(pageLoader.cssQueue).finally(() => { renderFallbackError(props); }); - } + }, ); }); } diff --git a/packages/bun-framework-next/page-loader.ts b/packages/bun-framework-next/page-loader.ts index 08919cb39e..c74b22fbf5 100644 --- a/packages/bun-framework-next/page-loader.ts +++ b/packages/bun-framework-next/page-loader.ts @@ -76,8 +76,8 @@ export default class PageLoader extends NextPageLoader { this.cssQueue.push( insertStyleSheet(event.detail).then( () => {}, - () => {} - ) + () => {}, + ), ); }; diff --git a/packages/bun-framework-next/renderDocument.tsx b/packages/bun-framework-next/renderDocument.tsx index 3dac375629..5eae9ebf1d 100644 --- a/packages/bun-framework-next/renderDocument.tsx +++ b/packages/bun-framework-next/renderDocument.tsx @@ -41,18 +41,18 @@ function appendNextBody(documentHTML: string, pageContent: string) { documentHTML.substring(0, bodyRenderIdx) + pageContent + documentHTML.substring( - bodyRenderIdx + NEXT_12_0_BODY_RENDER_TARGET.length + bodyRenderIdx + NEXT_12_0_BODY_RENDER_TARGET.length, ) ); } else { var [renderTargetPrefix, renderTargetSuffix] = documentHTML.split( - "" + "", ); if (!renderTargetPrefix || !renderTargetSuffix) { throw new Error( "Can't find where your starts or where the ends. \nThis is probably a version incompatibility. Please mention this error in Bun's discord\n\n" + - documentHTML + documentHTML, ); } @@ -114,7 +114,7 @@ function getScripts(files: DocumentFiles) { type="module" /> ); - } + }, ); // if (entryPointIndex > 0) { // const entry = scripts.splice(entryPointIndex, 1); @@ -200,7 +200,7 @@ function renderDocument( scriptLoader: any; isPreview?: boolean; autoExport?: boolean; - } + }, ): string { const htmlProps = { __NEXT_DATA__: { @@ -259,7 +259,7 @@ function renderDocument( {/* @ts-expect-error */} - + , ); } @@ -291,18 +291,18 @@ class ServerRouter implements NextRouter { defaultLocale?: string, domainLocales?: DomainLocale[], isPreview?: boolean, - isLocaleDomain?: boolean + isLocaleDomain?: boolean, ) { this.route = pathname.replace(/\/$/, "") || "/"; this.pathname = new URL( pathname || "/", - Bun.origin || "http://localhost:3000" + Bun.origin || "http://localhost:3000", ).href; this.query = query; this.asPath = new URL( as || "/", - Bun.origin || "http://localhost:3000" + Bun.origin || "http://localhost:3000", ).href; this.isFallback = isFallback; this.basePath = basePath; @@ -344,7 +344,7 @@ function noRouter() { function enhanceComponents( options: ComponentsEnhancer, App: AppType, - Component: NextComponentType + Component: NextComponentType, ): { App: AppType; Component: NextComponentType; @@ -374,13 +374,13 @@ Object.defineProperty(NextDocument.Head.prototype, "getScripts", scriptsGetter); Object.defineProperty( NextDocument.NextScript.prototype, "getScripts", - scriptsGetter + scriptsGetter, ); try { Object.defineProperty( NextDocument.default.prototype, "getScripts", - scriptsGetter + scriptsGetter, ); } catch {} try { @@ -475,19 +475,19 @@ export async function render({ throw new Error( `\"export default\" missing in ${ route.filePath - }.\nTry exporting one of ${reactComponents.join(", ")}\n` + }.\nTry exporting one of ${reactComponents.join(", ")}\n`, ); } else if (reactComponents.length === 2) { throw new Error( - `\"export default\" missing in ${route.filePath}.\n\nTry exporting <${reactComponents[0]} /> or <${reactComponents[1]} />\n` + `\"export default\" missing in ${route.filePath}.\n\nTry exporting <${reactComponents[0]} /> or <${reactComponents[1]} />\n`, ); } else if (reactComponents.length == 1) { throw new Error( - `\"export default\" missing in ${route.filePath}. Try adding this to the bottom of the file:\n\n export default ${reactComponents[0]};\n` + `\"export default\" missing in ${route.filePath}. Try adding this to the bottom of the file:\n\n export default ${reactComponents[0]};\n`, ); } else if (reactComponents.length == 0) { throw new Error( - `\"export default\" missing in ${route.filePath}. Try exporting a React component.\n` + `\"export default\" missing in ${route.filePath}. Try exporting a React component.\n`, ); } } @@ -572,7 +572,7 @@ export async function render({ null, //renderOpts.defaultLocale, [], // renderOpts.domainLocales, false, - false + false, ); const ctx = { @@ -593,7 +593,7 @@ export async function render({ ); }, defaultGetInitialProps: async ( - docCtx: NextDocument.DocumentContext + docCtx: NextDocument.DocumentContext, ): Promise => { const enhanceApp = (AppComp: any) => { return (props: any) => ; @@ -643,7 +643,7 @@ export async function render({ has(target, name) { return request.headers.has(name as string); }, - } + }, ), }, res: { @@ -715,7 +715,7 @@ export async function render({ props.pageProps = pageProps; const renderPage: RenderPage = ( - options: ComponentsEnhancer = {} + options: ComponentsEnhancer = {}, ): RenderPageResult | Promise => { if (ctx.err && ErrorDebug) { const htmlOrPromise = renderToString(); @@ -724,7 +724,7 @@ export async function render({ if (dev && (props.router || props.Component)) { throw new Error( - `'router' and 'Component' can not be returned in getInitialProps from _app.js https://nextjs.org/docs/messages/cant-override-next-props` + `'router' and 'Component' can not be returned in getInitialProps from _app.js https://nextjs.org/docs/messages/cant-override-next-props`, ); } @@ -741,7 +741,7 @@ export async function render({ {...props} pageProps={pageProps} /> - + , ); return { html: htmlOrPromise, head }; @@ -750,12 +750,12 @@ export async function render({ const documentCtx = { ...ctx, renderPage }; const docProps: DocumentInitialProps = await loadGetInitialProps( Document, - documentCtx + documentCtx, ); if (!docProps || typeof docProps.html !== "string") { const message = `"${getDisplayName( - Document + Document, )}.getInitialProps()" should resolve to an object with a "html" prop set with a valid html string`; throw new Error(message); } @@ -829,7 +829,7 @@ export async function render({ export function useMaybeDeferContent( _name: string, - contentFn: () => JSX.Element + contentFn: () => JSX.Element, ): [boolean, JSX.Element] { return [false, contentFn()]; } diff --git a/packages/bun-framework-next/server.development.tsx b/packages/bun-framework-next/server.development.tsx index d59e4cbfca..a19ffd1491 100644 --- a/packages/bun-framework-next/server.development.tsx +++ b/packages/bun-framework-next/server.development.tsx @@ -7,7 +7,7 @@ if (!version.startsWith("12.2")) { console.warn( "Possibly incompatible Next.js version: ", version, - ". Please upgrade to Next.js 12.2.0+.\n" + ". Please upgrade to Next.js 12.2.0+.\n", ); } @@ -29,7 +29,7 @@ import(Bun.routesDir + "_document").then( } else { console.error(err); } - } + }, ); addEventListener("fetch", async (event: FetchEvent) => { diff --git a/packages/bun-framework-next/tsconfig.json b/packages/bun-framework-next/tsconfig.json index 09f55d73cb..96e13d1ebf 100644 --- a/packages/bun-framework-next/tsconfig.json +++ b/packages/bun-framework-next/tsconfig.json @@ -1,21 +1,28 @@ { + "extends": "../../tsconfig.base.json", "compilerOptions": { "target": "esnext", - "lib": ["dom", "dom.iterable", "esnext", "WebWorker"], - "allowJs": true, - "skipLibCheck": true, + "lib": [ + "dom", + "dom.iterable", + "esnext", + "WebWorker" + ], "strict": false, "forceConsistentCasingInFileNames": true, "noEmit": true, "esModuleInterop": true, - "module": "esnext", - "moduleResolution": "Node", "resolveJsonModule": true, "isolatedModules": true, "jsx": "preserve", - "baseUrl": ".", - "paths": {} }, - "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", "empty.js"], - "exclude": ["node_modules"] -} + "include": [ + "next-env.d.ts", + "**/*.ts", + "**/*.tsx", + "empty.js" + ], + "exclude": [ + "node_modules" + ], +} \ No newline at end of file diff --git a/packages/bun-landing/bun.lockb b/packages/bun-landing/bun.lockb index c6b3744c9688ca15f958aa4b4cd630445b6ecd6f..5bcc1309d683036e37bd392f2a8185bfd3b9fad1 100755 GIT binary patch literal 15854 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 delta 3564 zcmd5<3s93+7XJUA1R*>HT0(#jk(Y#oJgkGuqp<`_6|1ziKwBRef&^KJ1Sk|}f}_?^ zoC0?NtKtJ~i=Y;$u&a^wTt~;}5`1#H~ zum7HN|9kJro$_OuHIWjUqNt1K8&0*w=|z88xX@*OVBOHjwb)&E44V#Yemku`_Kf3^ za2Xf@Mb@STiCaV#-tM0vN4HD|<8*jDD9V%!=m{8CyWQ7lfPpg%mIAs0R$Iq~+DuIm z@cG(O1j?JCC_deE@?2pQk9J z$psj6ybCYEfR_Mq+zrSB)E5|vGzJ5;6(-;Y<9a}p=V#^@=&~s4B-r7^KeJ+yAy2mi z_-1%8u_=IP4>2h(Ko>x?hnPiWdRHyg2LZ7h?Tq;}J&h(#4pUwP8>H|tpkRs?>OL%R zu=1)JE=B1*DGO4ZF+C%b%HfY9CI|ThmOpOe>o{^(tJncNXi~)$JK3B#awn_Si=1$f zu@UOHwqPnd-o*VKd&hD6y8jQBO^e2~*a4SRacnvA#&dzHaK??WMB_%}I8W|vtq{8; zS2|9iO^B_GDwpw444Gl`hFY-2$K{#;I$QBU>B-i9Y%M7d2pjIkuFh|)m&$Ft&cx*Q zguf%iaKP0yr+7rr<`9p0GzswtGdFu0XqB7q{g>O zyq(b0^V&}3b1So7e54Ocf2P`Z)@;OA7DB4NfFY{(9BBt*`D>UEL>Hq0N|^DBp4<$XChqJn)ZV+CN;J@|Nn%hJ7ji zBZ13*X&ULh@Nu5+o5I72q4S^47w!&D@;BEHrII-TdX-C3&D>;RXZfCi3F+T;?f53~ z=oS9eZo|l|If(~Khd)e})jDLf>P6ohdKra0A@w%Dn<&CS#Bk#@R510ONO^eWPHT9UkM*eQw?vp8bI}UXGs_C24blueR ziuZBhKW`6w^6JtVmrZ+GbQ0W7)TqZOd>5hC1w`Pii$Agd$eP8K`5Bj^Z*wn}2$ZW^ z9-KEld|Woo^+Lzi4DP<%%5T4|^iv5}ZGO0@_NxUKA97+YS0=t=EITAye|Po{@_8UX ziFROg{z@|s1)ONEACpuvo$q~AdF5zq=o=z-rZZ+?6za&^}PWY*x%k#Px zcpVysJXP#@_D{ILJnOnE_huHl$-5c-ppIa6;R9$j9zLM7&@zX&z z5TJhl*h$516IAK9cv?;`r=-DrtEus~g#S|+9JUmD*J$#LI%zK6Ku-vNUxv=?g;Wnb z-Uk3rFEjo(&d5#B8l`1VB6TF-IC20XC=oh34RKvMK_C)d-14Sw#70lQupc)j;5N@Dltw(RK zqn@EFK!OdQ)x4P^qmg_m+drOpv!Uz!cPkb#v`jixss!7U@Zf}$b(;51G;OP7=r)R| z#iD?2P+)7xd@^`CJLfAg&O|0vfbT=?up{q4A^eIX0WAmW=ZE{o2H*8TcY^MZ2P}-eQ{59ZH~!i z!2Uq^eq^Yf_xJ0oY?@g3jBo`wtuB6v>)y}vp~VatjZy@tL4m&ou*hgo&W|0|eK0@U zlU6e%MWSHR8Df&~nPP@)l!%ymh8%^_R)+LS)MRjq6A6|In0AIFNcl`3L(-)RUI*?T zASVg=le8%OFuVbmZe`31oph=DXbf&7pdkEQfOv7mF$p3$@topElB45DTeLVfub{x7 zm1y%zblGJFO^!CJI8R$R_6dqADntvX;>Vb4kQ5ax)8-qpbcUknCA$1*yqC ); -}; \ No newline at end of file +} diff --git a/packages/bun-landing/components/dataURI.ts b/packages/bun-landing/components/dataURI.ts index 8bfc93714c..559a9a89b9 100644 --- a/packages/bun-landing/components/dataURI.ts +++ b/packages/bun-landing/components/dataURI.ts @@ -10,7 +10,7 @@ export function dataURI(expr) { const data = readFileSync(toLoad); return `data:${Bun.file(toLoad).type};base64, ${btoa( - String.fromCharCode(...new Uint8Array(data.buffer)) + String.fromCharCode(...new Uint8Array(data.buffer)), )}`; } catch (e) { console.error(e); diff --git a/packages/bun-landing/next.config.js b/packages/bun-landing/next.config.js index 5a8ff89b2c..7cd57f4396 100644 --- a/packages/bun-landing/next.config.js +++ b/packages/bun-landing/next.config.js @@ -5,7 +5,7 @@ module.exports = { }, webpack: (config) => { // support shiki top level await - config.experiments = { ...config.experiments, ...{ topLevelAwait: true }}; + config.experiments = { ...config.experiments, ...{ topLevelAwait: true } }; return config; }, }; diff --git a/packages/bun-landing/pages/_app.tsx b/packages/bun-landing/pages/_app.tsx index 4167789490..2896467a58 100644 --- a/packages/bun-landing/pages/_app.tsx +++ b/packages/bun-landing/pages/_app.tsx @@ -2,5 +2,9 @@ import Layout from "../components/Layout"; import "../styles/global.css"; export default function MyApp({ Component, pageProps }) { - return ; -} \ No newline at end of file + return ( + + + + ); +} diff --git a/packages/bun-landing/pages/index.tsx b/packages/bun-landing/pages/index.tsx index 6e1434c315..096b32cb86 100644 --- a/packages/bun-landing/pages/index.tsx +++ b/packages/bun-landing/pages/index.tsx @@ -52,7 +52,7 @@ const BarGraphItem = ({ type, amount = 0, label, max = 0 }) => ( style={{ "--amount": amount, "--max": max }} >
{`${type}: ${fmt.format( - amount + amount, )} ${label}`}
(
-
curl -fsSL https://bun.sh/install | bash
+
+ curl -fsSL https://bun.sh/install | bash +
@@ -369,7 +371,7 @@ export default function LandingPage() { amount={(1000 / 14.22).toFixed(2)} label="queries per second" max={Math.ceil( - Math.max(1000 / 14.22, 1000 / 42.96, 1000 / 27.37) * 1.25 + Math.max(1000 / 14.22, 1000 / 42.96, 1000 / 27.37) * 1.25, )} /> diff --git a/packages/bun-landing/tsconfig.json b/packages/bun-landing/tsconfig.json index 54b36a1e78..c1e94dd709 100644 --- a/packages/bun-landing/tsconfig.json +++ b/packages/bun-landing/tsconfig.json @@ -1,7 +1,11 @@ { "compilerOptions": { "target": "es5", - "lib": ["dom", "dom.iterable", "esnext"], + "lib": [ + "dom", + "dom.iterable", + "esnext" + ], "allowJs": true, "skipLibCheck": true, "strict": true, @@ -15,6 +19,12 @@ "jsx": "preserve", "incremental": true }, - "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"], - "exclude": ["node_modules"] + "include": [ + "next-env.d.ts", + "**/*.ts", + "**/*.tsx" + ], + "exclude": [ + "node_modules" + ] } \ No newline at end of file diff --git a/packages/bun-macro-relay/bun-macro-relay.tsx b/packages/bun-macro-relay/bun-macro-relay.tsx index b2ae22225b..f7899698d8 100644 --- a/packages/bun-macro-relay/bun-macro-relay.tsx +++ b/packages/bun-macro-relay/bun-macro-relay.tsx @@ -50,7 +50,7 @@ export function graphql(node) { definition.kind !== "OperationDefinition" ) { throw new Error( - `BunMacroRelay: Expected a fragment, mutation, query, or subscription, got "${definition.kind}"` + `BunMacroRelay: Expected a fragment, mutation, query, or subscription, got "${definition.kind}"`, ); } diff --git a/packages/bun-macro-relay/bun.lockb b/packages/bun-macro-relay/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..2f64dc3192bfac9ea88f58db5c598aae10eec4ad GIT binary patch literal 1190 zcmY#Z)GsYA(of3F(@)JSQ%EY!;{sycoc!eMw9K4T-L(9o+{6;yG6OCq1_p-jQgdGK zncQ&Wr)0)PUhPerm!;Z@N=fNnikp1Vt?0$__k1isML+;j3j!Pvih&(UH$Z6#m;x}L zpMjwvy(qCDqcDfzLF?ZO-=QbotFRD@36Au+tF~wl&Bs*<5zY!9_&rkek^e0ab4nGNBaduKNS2~x1L9`6J~C} zqD{~^0|w5no->^~HML_p@l_#hgl3S30_004P7^Xl?fzhZT zR-Bq!mRh9eT2Yc(l$V$jTvC*omu{zEh_J{4ZqWg#No>%V;j#g_$q=iPK$$f+F}WyT zw_T^LIj=x_@?1HF>;Dp-gQ GRvG|Fzus2> literal 0 HcmV?d00001 diff --git a/packages/bun-types/.eslintignore b/packages/bun-types/.eslintignore new file mode 100644 index 0000000000..9bb9443850 --- /dev/null +++ b/packages/bun-types/.eslintignore @@ -0,0 +1,5 @@ +*.cjs +dist/** +tests/** +scripts/** +docs/** \ No newline at end of file diff --git a/packages/bun-types/.eslintrc.cjs b/packages/bun-types/.eslintrc.cjs new file mode 100644 index 0000000000..d38b920f4e --- /dev/null +++ b/packages/bun-types/.eslintrc.cjs @@ -0,0 +1,23 @@ +module.exports = { + root: true, + parser: "@typescript-eslint/parser", + parserOptions: { + tsconfigRootDir: __dirname, + project: ["./tsconfig.json"], + }, + plugins: ["@typescript-eslint"], + extends: [ + "eslint:recommended", + "plugin:@typescript-eslint/recommended", + "plugin:@typescript-eslint/recommended-requiring-type-checking", + "prettier", + ], + rules: { + "no-var": "off", // global variables + "@typescript-eslint/ban-types": "off", + "@typescript-eslint/no-explicit-any": "off", + "@typescript-eslint/no-empty-interface": "off", + "@typescript-eslint/no-empty-function": "off", + "@typescript-eslint/no-non-null-assertion": "off", + }, +}; diff --git a/packages/bun-types/.gitignore b/packages/bun-types/.gitignore new file mode 100644 index 0000000000..04c01ba7ba --- /dev/null +++ b/packages/bun-types/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +dist/ \ No newline at end of file diff --git a/packages/bun-types/.prettierignore b/packages/bun-types/.prettierignore new file mode 100644 index 0000000000..849ddff3b7 --- /dev/null +++ b/packages/bun-types/.prettierignore @@ -0,0 +1 @@ +dist/ diff --git a/packages/bun-types/README.md b/packages/bun-types/README.md new file mode 100644 index 0000000000..7985ccd986 --- /dev/null +++ b/packages/bun-types/README.md @@ -0,0 +1,55 @@ +# Bun TypeScript type definitions + +

+ Logo +

+ +These are the type definitions for Bun's JavaScript runtime APIs. + +# Installation + +Install the `bun-types` npm package: + +```bash +# yarn/npm/pnpm work too, "bun-types" is an ordinary npm package +bun add bun-types +``` + +# Usage + +Add this to your `tsconfig.json` or `jsconfig.json`: + +```jsonc +{ + "compilerOptions": { + "lib": ["esnext"], + "module": "esnext", + "target": "esnext", + "moduleResolution": "node", + // "bun-types" is the important part + "types": ["bun-types"] + } +} +``` + +# Contributing + +`bun-types` is generated via [./bundle.ts](./scripts/bundle.ts). + +## Adding a new file + +1. Add it to [./index.d.ts](./index.d.ts) + +## How to generate types.d.ts + +[`./bundle.ts`](./bundle.ts) merges the types in this folder into a single file. + +To run it: + +```bash +bun build +``` + +# Generated docs + +**[📚 See here for docs](https://oven-sh.github.io/bun-types/)** diff --git a/packages/bun-types/assert.d.ts b/packages/bun-types/assert.d.ts new file mode 100644 index 0000000000..ae3b54ff2a --- /dev/null +++ b/packages/bun-types/assert.d.ts @@ -0,0 +1,968 @@ +/** + * The `assert` module provides a set of assertion functions for verifying + * invariants. + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/assert.js) + */ +declare module "assert" { + /** + * An alias of {@link ok}. + * @param value The input that is checked for being truthy. + */ + function assert(value: unknown, message?: string | Error): asserts value; + namespace assert { + /** + * Indicates the failure of an assertion. All errors thrown by the `assert` module + * will be instances of the `AssertionError` class. + */ + class AssertionError extends Error { + actual: unknown; + expected: unknown; + operator: string; + generatedMessage: boolean; + code: "ERR_ASSERTION"; + constructor(options?: { + /** If provided, the error message is set to this value. */ + message?: string | undefined; + /** The `actual` property on the error instance. */ + actual?: unknown | undefined; + /** The `expected` property on the error instance. */ + expected?: unknown | undefined; + /** The `operator` property on the error instance. */ + operator?: string | undefined; + /** If provided, the generated stack trace omits frames before this function. */ + // tslint:disable-next-line:ban-types + stackStartFn?: Function | undefined; + }); + } + /** + * This feature is currently experimental and behavior might still change. + * @experimental + */ + class CallTracker { + /** + * The wrapper function is expected to be called exactly `exact` times. If the + * function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an + * error. + * + * ```js + * import assert from 'assert'; + * + * // Creates call tracker. + * const tracker = new assert.CallTracker(); + * + * function func() {} + * + * // Returns a function that wraps func() that must be called exact times + * // before tracker.verify(). + * const callsfunc = tracker.calls(func); + * ``` + * @param [fn='A no-op function'] + * @param [exact=1] + * @return that wraps `fn`. + */ + calls(exact?: number): () => void; + calls any>( + fn?: Func, + exact?: number, + ): Func; + /** + * The arrays contains information about the expected and actual number of calls of + * the functions that have not been called the expected number of times. + * + * ```js + * import assert from 'assert'; + * + * // Creates call tracker. + * const tracker = new assert.CallTracker(); + * + * function func() {} + * + * function foo() {} + * + * // Returns a function that wraps func() that must be called exact times + * // before tracker.verify(). + * const callsfunc = tracker.calls(func, 2); + * + * // Returns an array containing information on callsfunc() + * tracker.report(); + * // [ + * // { + * // message: 'Expected the func function to be executed 2 time(s) but was + * // executed 0 time(s).', + * // actual: 0, + * // expected: 2, + * // operator: 'func', + * // stack: stack trace + * // } + * // ] + * ``` + * @return of objects containing information about the wrapper functions returned by `calls`. + */ + report(): CallTrackerReportInformation[]; + /** + * Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that + * have not been called the expected number of times. + * + * ```js + * import assert from 'assert'; + * + * // Creates call tracker. + * const tracker = new assert.CallTracker(); + * + * function func() {} + * + * // Returns a function that wraps func() that must be called exact times + * // before tracker.verify(). + * const callsfunc = tracker.calls(func, 2); + * + * callsfunc(); + * + * // Will throw an error since callsfunc() was only called once. + * tracker.verify(); + * ``` + */ + verify(): void; + } + interface CallTrackerReportInformation { + message: string; + /** The actual number of times the function was called. */ + actual: number; + /** The number of times the function was expected to be called. */ + expected: number; + /** The name of the function that is wrapped. */ + operator: string; + /** A stack trace of the function. */ + stack: object; + } + type AssertPredicate = + | RegExp + | (new () => object) + | ((thrown: unknown) => boolean) + | object + | Error; + /** + * Throws an `AssertionError` with the provided error message or a default + * error message. If the `message` parameter is an instance of an `Error` then + * it will be thrown instead of the `AssertionError`. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.fail(); + * // AssertionError [ERR_ASSERTION]: Failed + * + * assert.fail('boom'); + * // AssertionError [ERR_ASSERTION]: boom + * + * assert.fail(new TypeError('need array')); + * // TypeError: need array + * ``` + * + * Using `assert.fail()` with more than two arguments is possible but deprecated. + * See below for further details. + * @param [message='Failed'] + */ + function fail(message?: string | Error): never; + /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */ + function fail( + actual: unknown, + expected: unknown, + message?: string | Error, + operator?: string, + // tslint:disable-next-line:ban-types + stackStartFn?: Function, + ): never; + /** + * Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`. + * + * If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default + * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`. + * If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``. + * + * Be aware that in the `repl` the error message will be different to the one + * thrown in a file! See below for further details. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.ok(true); + * // OK + * assert.ok(1); + * // OK + * + * assert.ok(); + * // AssertionError: No value argument passed to `assert.ok()` + * + * assert.ok(false, 'it\'s false'); + * // AssertionError: it's false + * + * // In the repl: + * assert.ok(typeof 123 === 'string'); + * // AssertionError: false == true + * + * // In a file (e.g. test.js): + * assert.ok(typeof 123 === 'string'); + * // AssertionError: The expression evaluated to a falsy value: + * // + * // assert.ok(typeof 123 === 'string') + * + * assert.ok(false); + * // AssertionError: The expression evaluated to a falsy value: + * // + * // assert.ok(false) + * + * assert.ok(0); + * // AssertionError: The expression evaluated to a falsy value: + * // + * // assert.ok(0) + * ``` + * + * ```js + * import assert from 'assert/strict'; + * + * // Using `assert()` works the same: + * assert(0); + * // AssertionError: The expression evaluated to a falsy value: + * // + * // assert(0) + * ``` + */ + function ok(value: unknown, message?: string | Error): asserts value; + /** + * **Strict assertion mode** + * + * An alias of {@link strictEqual}. + * + * **Legacy assertion mode** + * + * > Stability: 3 - Legacy: Use {@link strictEqual} instead. + * + * Tests shallow, coercive equality between the `actual` and `expected` parameters + * using the [`==` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality). `NaN` is specially handled + * and treated as being identical if both sides are `NaN`. + * + * ```js + * import assert from 'assert'; + * + * assert.equal(1, 1); + * // OK, 1 == 1 + * assert.equal(1, '1'); + * // OK, 1 == '1' + * assert.equal(NaN, NaN); + * // OK + * + * assert.equal(1, 2); + * // AssertionError: 1 == 2 + * assert.equal({ a: { b: 1 } }, { a: { b: 1 } }); + * // AssertionError: { a: { b: 1 } } == { a: { b: 1 } } + * ``` + * + * If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default + * error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`. + */ + function equal( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * **Strict assertion mode** + * + * An alias of {@link notStrictEqual}. + * + * **Legacy assertion mode** + * + * > Stability: 3 - Legacy: Use {@link notStrictEqual} instead. + * + * Tests shallow, coercive inequality with the [`!=` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality). `NaN` is + * specially handled and treated as being identical if both sides are `NaN`. + * + * ```js + * import assert from 'assert'; + * + * assert.notEqual(1, 2); + * // OK + * + * assert.notEqual(1, 1); + * // AssertionError: 1 != 1 + * + * assert.notEqual(1, '1'); + * // AssertionError: 1 != '1' + * ``` + * + * If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error + * message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`. + */ + function notEqual( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * **Strict assertion mode** + * + * An alias of {@link deepStrictEqual}. + * + * **Legacy assertion mode** + * + * > Stability: 3 - Legacy: Use {@link deepStrictEqual} instead. + * + * Tests for deep equality between the `actual` and `expected` parameters. Consider + * using {@link deepStrictEqual} instead. {@link deepEqual} can have + * surprising results. + * + * _Deep equality_ means that the enumerable "own" properties of child objects + * are also recursively evaluated by the following rules. + */ + function deepEqual( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * **Strict assertion mode** + * + * An alias of {@link notDeepStrictEqual}. + * + * **Legacy assertion mode** + * + * > Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead. + * + * Tests for any deep inequality. Opposite of {@link deepEqual}. + * + * ```js + * import assert from 'assert'; + * + * const obj1 = { + * a: { + * b: 1 + * } + * }; + * const obj2 = { + * a: { + * b: 2 + * } + * }; + * const obj3 = { + * a: { + * b: 1 + * } + * }; + * const obj4 = Object.create(obj1); + * + * assert.notDeepEqual(obj1, obj1); + * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } } + * + * assert.notDeepEqual(obj1, obj2); + * // OK + * + * assert.notDeepEqual(obj1, obj3); + * // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } } + * + * assert.notDeepEqual(obj1, obj4); + * // OK + * ``` + * + * If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default + * error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown + * instead of the `AssertionError`. + */ + function notDeepEqual( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * Tests strict equality between the `actual` and `expected` parameters as + * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). + * + * ```js + * import assert from 'assert/strict'; + * + * assert.strictEqual(1, 2); + * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal: + * // + * // 1 !== 2 + * + * assert.strictEqual(1, 1); + * // OK + * + * assert.strictEqual('Hello foobar', 'Hello World!'); + * // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal: + * // + actual - expected + * // + * // + 'Hello foobar' + * // - 'Hello World!' + * // ^ + * + * const apples = 1; + * const oranges = 2; + * assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`); + * // AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2 + * + * assert.strictEqual(1, '1', new TypeError('Inputs are not identical')); + * // TypeError: Inputs are not identical + * ``` + * + * If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a + * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown + * instead of the `AssertionError`. + */ + function strictEqual( + actual: unknown, + expected: T, + message?: string | Error, + ): asserts actual is T; + /** + * Tests strict inequality between the `actual` and `expected` parameters as + * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). + * + * ```js + * import assert from 'assert/strict'; + * + * assert.notStrictEqual(1, 2); + * // OK + * + * assert.notStrictEqual(1, 1); + * // AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to: + * // + * // 1 + * + * assert.notStrictEqual(1, '1'); + * // OK + * ``` + * + * If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a + * default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown + * instead of the `AssertionError`. + */ + function notStrictEqual( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * Tests for deep equality between the `actual` and `expected` parameters. + * "Deep" equality means that the enumerable "own" properties of child objects + * are recursively evaluated also by the following rules. + */ + function deepStrictEqual( + actual: unknown, + expected: T, + message?: string | Error, + ): asserts actual is T; + /** + * Tests for deep strict inequality. Opposite of {@link deepStrictEqual}. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.notDeepStrictEqual({ a: 1 }, { a: '1' }); + * // OK + * ``` + * + * If the values are deeply and strictly equal, an `AssertionError` is thrown + * with a `message` property set equal to the value of the `message` parameter. If + * the `message` parameter is undefined, a default error message is assigned. If + * the `message` parameter is an instance of an `Error` then it will be thrown + * instead of the `AssertionError`. + */ + function notDeepStrictEqual( + actual: unknown, + expected: unknown, + message?: string | Error, + ): void; + /** + * Expects the function `fn` to throw an error. + * + * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), + * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function, + * a validation object where each property will be tested for strict deep equality, + * or an instance of error where each property will be tested for strict deep + * equality including the non-enumerable `message` and `name` properties. When + * using an object, it is also possible to use a regular expression, when + * validating against a string property. See below for examples. + * + * If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation + * fails. + * + * Custom validation object/error instance: + * + * ```js + * import assert from 'assert/strict'; + * + * const err = new TypeError('Wrong value'); + * err.code = 404; + * err.foo = 'bar'; + * err.info = { + * nested: true, + * baz: 'text' + * }; + * err.reg = /abc/i; + * + * assert.throws( + * () => { + * throw err; + * }, + * { + * name: 'TypeError', + * message: 'Wrong value', + * info: { + * nested: true, + * baz: 'text' + * } + * // Only properties on the validation object will be tested for. + * // Using nested objects requires all properties to be present. Otherwise + * // the validation is going to fail. + * } + * ); + * + * // Using regular expressions to validate error properties: + * throws( + * () => { + * throw err; + * }, + * { + * // The `name` and `message` properties are strings and using regular + * // expressions on those will match against the string. If they fail, an + * // error is thrown. + * name: /^TypeError$/, + * message: /Wrong/, + * foo: 'bar', + * info: { + * nested: true, + * // It is not possible to use regular expressions for nested properties! + * baz: 'text' + * }, + * // The `reg` property contains a regular expression and only if the + * // validation object contains an identical regular expression, it is going + * // to pass. + * reg: /abc/i + * } + * ); + * + * // Fails due to the different `message` and `name` properties: + * throws( + * () => { + * const otherErr = new Error('Not found'); + * // Copy all enumerable properties from `err` to `otherErr`. + * for (const [key, value] of Object.entries(err)) { + * otherErr[key] = value; + * } + * throw otherErr; + * }, + * // The error's `message` and `name` properties will also be checked when using + * // an error as validation object. + * err + * ); + * ``` + * + * Validate instanceof using constructor: + * + * ```js + * import assert from 'assert/strict'; + * + * assert.throws( + * () => { + * throw new Error('Wrong value'); + * }, + * Error + * ); + * ``` + * + * Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions): + * + * Using a regular expression runs `.toString` on the error object, and will + * therefore also include the error name. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.throws( + * () => { + * throw new Error('Wrong value'); + * }, + * /^Error: Wrong value$/ + * ); + * ``` + * + * Custom error validation: + * + * The function must return `true` to indicate all internal validations passed. + * It will otherwise fail with an `AssertionError`. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.throws( + * () => { + * throw new Error('Wrong value'); + * }, + * (err) => { + * assert(err instanceof Error); + * assert(/value/.test(err)); + * // Avoid returning anything from validation functions besides `true`. + * // Otherwise, it's not clear what part of the validation failed. Instead, + * // throw an error about the specific validation that failed (as done in this + * // example) and add as much helpful debugging information to that error as + * // possible. + * return true; + * }, + * 'unexpected error' + * ); + * ``` + * + * `error` cannot be a string. If a string is provided as the second + * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same + * message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using + * a string as the second argument gets considered: + * + * ```js + * import assert from 'assert/strict'; + * + * function throwingFirst() { + * throw new Error('First'); + * } + * + * function throwingSecond() { + * throw new Error('Second'); + * } + * + * function notThrowing() {} + * + * // The second argument is a string and the input function threw an Error. + * // The first case will not throw as it does not match for the error message + * // thrown by the input function! + * assert.throws(throwingFirst, 'Second'); + * // In the next example the message has no benefit over the message from the + * // error and since it is not clear if the user intended to actually match + * // against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error. + * assert.throws(throwingSecond, 'Second'); + * // TypeError [ERR_AMBIGUOUS_ARGUMENT] + * + * // The string is only used (as message) in case the function does not throw: + * assert.throws(notThrowing, 'Second'); + * // AssertionError [ERR_ASSERTION]: Missing expected exception: Second + * + * // If it was intended to match for the error message do this instead: + * // It does not throw because the error messages match. + * assert.throws(throwingSecond, /Second$/); + * + * // If the error message does not match, an AssertionError is thrown. + * assert.throws(throwingFirst, /Second$/); + * // AssertionError [ERR_ASSERTION] + * ``` + * + * Due to the confusing error-prone notation, avoid a string as the second + * argument. + */ + function throws(block: () => unknown, message?: string | Error): void; + function throws( + block: () => unknown, + error: AssertPredicate, + message?: string | Error, + ): void; + /** + * Asserts that the function `fn` does not throw an error. + * + * Using `assert.doesNotThrow()` is actually not useful because there + * is no benefit in catching an error and then rethrowing it. Instead, consider + * adding a comment next to the specific code path that should not throw and keep + * error messages as expressive as possible. + * + * When `assert.doesNotThrow()` is called, it will immediately call the `fn`function. + * + * If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a + * different type, or if the `error` parameter is undefined, the error is + * propagated back to the caller. + * + * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), + * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation + * function. See {@link throws} for more details. + * + * The following, for instance, will throw the `TypeError` because there is no + * matching error type in the assertion: + * + * ```js + * import assert from 'assert/strict'; + * + * assert.doesNotThrow( + * () => { + * throw new TypeError('Wrong value'); + * }, + * SyntaxError + * ); + * ``` + * + * However, the following will result in an `AssertionError` with the message + * 'Got unwanted exception...': + * + * ```js + * import assert from 'assert/strict'; + * + * assert.doesNotThrow( + * () => { + * throw new TypeError('Wrong value'); + * }, + * TypeError + * ); + * ``` + * + * If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message: + * + * ```js + * import assert from 'assert/strict'; + * + * assert.doesNotThrow( + * () => { + * throw new TypeError('Wrong value'); + * }, + * /Wrong value/, + * 'Whoops' + * ); + * // Throws: AssertionError: Got unwanted exception: Whoops + * ``` + */ + function doesNotThrow(block: () => unknown, message?: string | Error): void; + function doesNotThrow( + block: () => unknown, + error: AssertPredicate, + message?: string | Error, + ): void; + /** + * Throws `value` if `value` is not `undefined` or `null`. This is useful when + * testing the `error` argument in callbacks. The stack trace contains all frames + * from the error passed to `ifError()` including the potential new frames for`ifError()` itself. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.ifError(null); + * // OK + * assert.ifError(0); + * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0 + * assert.ifError('error'); + * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error' + * assert.ifError(new Error()); + * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error + * + * // Create some random error frames. + * let err; + * (function errorFrame() { + * err = new Error('test error'); + * })(); + * + * (function ifErrorFrame() { + * assert.ifError(err); + * })(); + * // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error + * // at ifErrorFrame + * // at errorFrame + * ``` + */ + function ifError(value: unknown): asserts value is null | undefined; + /** + * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately + * calls the function and awaits the returned promise to complete. It will then + * check that the promise is rejected. + * + * If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the + * function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error + * handler is skipped. + * + * Besides the async nature to await the completion behaves identically to {@link throws}. + * + * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), + * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function, + * an object where each property will be tested for, or an instance of error where + * each property will be tested for including the non-enumerable `message` and`name` properties. + * + * If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject. + * + * ```js + * import assert from 'assert/strict'; + * + * await assert.rejects( + * async () => { + * throw new TypeError('Wrong value'); + * }, + * { + * name: 'TypeError', + * message: 'Wrong value' + * } + * ); + * ``` + * + * ```js + * import assert from 'assert/strict'; + * + * await assert.rejects( + * async () => { + * throw new TypeError('Wrong value'); + * }, + * (err) => { + * assert.strictEqual(err.name, 'TypeError'); + * assert.strictEqual(err.message, 'Wrong value'); + * return true; + * } + * ); + * ``` + * + * ```js + * import assert from 'assert/strict'; + * + * assert.rejects( + * Promise.reject(new Error('Wrong value')), + * Error + * ).then(() => { + * // ... + * }); + * ``` + * + * `error` cannot be a string. If a string is provided as the second + * argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the + * example in {@link throws} carefully if using a string as the second + * argument gets considered. + */ + function rejects( + block: (() => Promise) | Promise, + message?: string | Error, + ): Promise; + function rejects( + block: (() => Promise) | Promise, + error: AssertPredicate, + message?: string | Error, + ): Promise; + /** + * Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately + * calls the function and awaits the returned promise to complete. It will then + * check that the promise is not rejected. + * + * If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If + * the function does not return a promise, `assert.doesNotReject()` will return a + * rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases + * the error handler is skipped. + * + * Using `assert.doesNotReject()` is actually not useful because there is little + * benefit in catching a rejection and then rejecting it again. Instead, consider + * adding a comment next to the specific code path that should not reject and keep + * error messages as expressive as possible. + * + * If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), + * [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation + * function. See {@link throws} for more details. + * + * Besides the async nature to await the completion behaves identically to {@link doesNotThrow}. + * + * ```js + * import assert from 'assert/strict'; + * + * await assert.doesNotReject( + * async () => { + * throw new TypeError('Wrong value'); + * }, + * SyntaxError + * ); + * ``` + * + * ```js + * import assert from 'assert/strict'; + * + * assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))) + * .then(() => { + * // ... + * }); + * ``` + */ + function doesNotReject( + block: (() => Promise) | Promise, + message?: string | Error, + ): Promise; + function doesNotReject( + block: (() => Promise) | Promise, + error: AssertPredicate, + message?: string | Error, + ): Promise; + /** + * Expects the `string` input to match the regular expression. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.match('I will fail', /pass/); + * // AssertionError [ERR_ASSERTION]: The input did not match the regular ... + * + * assert.match(123, /pass/); + * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string. + * + * assert.match('I will pass', /pass/); + * // OK + * ``` + * + * If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal + * to the value of the `message` parameter. If the `message` parameter is + * undefined, a default error message is assigned. If the `message` parameter is an + * instance of an `Error` then it will be thrown instead of the `AssertionError`. + */ + function match( + value: string, + regExp: RegExp, + message?: string | Error, + ): void; + /** + * Expects the `string` input not to match the regular expression. + * + * ```js + * import assert from 'assert/strict'; + * + * assert.doesNotMatch('I will fail', /fail/); + * // AssertionError [ERR_ASSERTION]: The input was expected to not match the ... + * + * assert.doesNotMatch(123, /pass/); + * // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string. + * + * assert.doesNotMatch('I will pass', /different/); + * // OK + * ``` + * + * If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal + * to the value of the `message` parameter. If the `message` parameter is + * undefined, a default error message is assigned. If the `message` parameter is an + * instance of an `Error` then it will be thrown instead of the `AssertionError`. + */ + // FIXME: assert.doesNotMatch is typed, but not in the browserify polyfill? + // function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void; + + const strict: Omit< + typeof assert, + | "equal" + | "notEqual" + | "deepEqual" + | "notDeepEqual" + | "ok" + | "strictEqual" + | "deepStrictEqual" + | "ifError" + | "strict" + > & { + (value: unknown, message?: string | Error): asserts value; + equal: typeof strictEqual; + notEqual: typeof notStrictEqual; + deepEqual: typeof deepStrictEqual; + notDeepEqual: typeof notDeepStrictEqual; + // Mapped types and assertion functions are incompatible? + // TS2775: Assertions require every name in the call target + // to be declared with an explicit type annotation. + ok: typeof ok; + strictEqual: typeof strictEqual; + deepStrictEqual: typeof deepStrictEqual; + ifError: typeof ifError; + strict: typeof strict; + }; + } + export = assert; +} +declare module "node:assert" { + import assert = require("assert"); + export = assert; +} diff --git a/packages/bun-types/buffer.d.ts b/packages/bun-types/buffer.d.ts new file mode 100644 index 0000000000..a7de0cfe4b --- /dev/null +++ b/packages/bun-types/buffer.d.ts @@ -0,0 +1,2089 @@ +/** + * `Buffer` objects are used to represent a fixed-length sequence of bytes. Many + * Node.js APIs support `Buffer`s. + * + * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and + * extends it with methods that cover additional use cases. Node.js APIs accept + * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well. + * + * While the `Buffer` class is available within the global scope, it is still + * recommended to explicitly reference it via an import or require statement. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Creates a zero-filled Buffer of length 10. + * const buf1 = Buffer.alloc(10); + * + * // Creates a Buffer of length 10, + * // filled with bytes which all have the value `1`. + * const buf2 = Buffer.alloc(10, 1); + * + * // Creates an uninitialized buffer of length 10. + * // This is faster than calling Buffer.alloc() but the returned + * // Buffer instance might contain old data that needs to be + * // overwritten using fill(), write(), or other functions that fill the Buffer's + * // contents. + * const buf3 = Buffer.allocUnsafe(10); + * + * // Creates a Buffer containing the bytes [1, 2, 3]. + * const buf4 = Buffer.from([1, 2, 3]); + * + * // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries + * // are all truncated using `(value & 255)` to fit into the range 0–255. + * const buf5 = Buffer.from([257, 257.5, -255, '1']); + * + * // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést': + * // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation) + * // [116, 195, 169, 115, 116] (in decimal notation) + * const buf6 = Buffer.from('tést'); + * + * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74]. + * const buf7 = Buffer.from('tést', 'latin1'); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/buffer.js) + */ +declare module "buffer" { + export const INSPECT_MAX_BYTES: number; + export const kMaxLength: number; + export type TranscodeEncoding = + | "ascii" + | "utf8" + | "utf16le" + | "ucs2" + | "latin1" + | "binary"; + export const SlowBuffer: { + /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */ + new (size: number): Buffer; + prototype: Buffer; + }; + export { Buffer }; + /** + * @experimental + */ + export interface BlobOptions { + /** + * @default 'utf8' + */ + encoding?: BufferEncoding | undefined; + /** + * The Blob content-type. The intent is for `type` to convey + * the MIME media type of the data, however no validation of the type format + * is performed. + */ + type?: string | undefined; + } + global { + // Buffer class + type WithImplicitCoercion = + | T + | { + valueOf(): T; + }; + /** + * Raw data is stored in instances of the Buffer class. + * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized. + * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex' + */ + interface BufferConstructor { + /** + * Allocates a new buffer containing the given {str}. + * + * @param str String to store in buffer. + * @param encoding encoding to use, optional. Default is 'utf8' + * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead. + */ + new (str: string, encoding?: BufferEncoding): Buffer; + /** + * Allocates a new buffer of {size} octets. + * + * @param size count of octets to allocate. + * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`). + */ + new (size: number): Buffer; + /** + * Allocates a new buffer containing the given {array} of octets. + * + * @param array The octets to store. + * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead. + */ + new (array: Uint8Array): Buffer; + /** + * Produces a Buffer backed by the same allocated memory as + * the given {ArrayBuffer}/{SharedArrayBuffer}. + * + * + * @param arrayBuffer The ArrayBuffer with which to share memory. + * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead. + */ + new (arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer; + /** + * Allocates a new buffer containing the given {array} of octets. + * + * @param array The octets to store. + * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead. + */ + new (array: ReadonlyArray): Buffer; + /** + * Copies the passed {buffer} data onto a new {Buffer} instance. + * + * @param buffer The buffer to copy. + * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead. + */ + new (buffer: Buffer): Buffer; + /** + * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`. + * Array entries outside that range will be truncated to fit into it. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'. + * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); + * ``` + * + * A `TypeError` will be thrown if `array` is not an `Array` or another type + * appropriate for `Buffer.from()` variants. + * + * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does. + */ + from( + arrayBuffer: WithImplicitCoercion, + byteOffset?: number, + length?: number, + ): Buffer; + /** + * Creates a new Buffer using the passed {data} + * @param data data to create a new Buffer + */ + from(data: Uint8Array | ReadonlyArray): Buffer; + from( + data: WithImplicitCoercion | string>, + ): Buffer; + /** + * Creates a new Buffer containing the given JavaScript string {str}. + * If provided, the {encoding} parameter identifies the character encoding. + * If not provided, {encoding} defaults to 'utf8'. + */ + from( + str: + | WithImplicitCoercion + | { + [Symbol.toPrimitive](hint: "string"): string; + }, + encoding?: BufferEncoding, + ): Buffer; + /** + * Creates a new Buffer using the passed {data} + * @param values to create a new Buffer + */ + of(...items: number[]): Buffer; + /** + * Returns `true` if `obj` is a `Buffer`, `false` otherwise. + * + * ```js + * import { Buffer } from 'buffer'; + * + * Buffer.isBuffer(Buffer.alloc(10)); // true + * Buffer.isBuffer(Buffer.from('foo')); // true + * Buffer.isBuffer('a string'); // false + * Buffer.isBuffer([]); // false + * Buffer.isBuffer(new Uint8Array(1024)); // false + * ``` + */ + isBuffer(obj: any): obj is Buffer; + /** + * Returns `true` if `encoding` is the name of a supported character encoding, + * or `false` otherwise. + * + * ```js + * import { Buffer } from 'buffer'; + * + * console.log(Buffer.isEncoding('utf8')); + * // Prints: true + * + * console.log(Buffer.isEncoding('hex')); + * // Prints: true + * + * console.log(Buffer.isEncoding('utf/8')); + * // Prints: false + * + * console.log(Buffer.isEncoding('')); + * // Prints: false + * ``` + * @param encoding A character encoding name to check. + */ + isEncoding(encoding: string): encoding is BufferEncoding; + /** + * Returns the byte length of a string when encoded using `encoding`. + * This is not the same as [`String.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length), which does not account + * for the encoding that is used to convert the string into bytes. + * + * For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input. + * For strings that contain non-base64/hex-encoded data (e.g. whitespace), the + * return value might be greater than the length of a `Buffer` created from the + * string. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const str = '\u00bd + \u00bc = \u00be'; + * + * console.log(`${str}: ${str.length} characters, ` + + * `${Buffer.byteLength(str, 'utf8')} bytes`); + * // Prints: ½ + ¼ = ¾: 9 characters, 12 bytes + * ``` + * + * When `string` is a + * `Buffer`/[`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)/[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/- + * Reference/Global_Objects/TypedArray)/[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)/[`SharedArrayBuffer`](https://develop- + * er.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer), the byte length as reported by `.byteLength`is returned. + * @param string A value to calculate the length of. + * @param [encoding='utf8'] If `string` is a string, this is its encoding. + * @return The number of bytes contained within `string`. + */ + byteLength( + string: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, + encoding?: BufferEncoding, + ): number; + /** + * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together. + * + * If the list has no items, or if the `totalLength` is 0, then a new zero-length`Buffer` is returned. + * + * If `totalLength` is not provided, it is calculated from the `Buffer` instances + * in `list` by adding their lengths. + * + * If `totalLength` is provided, it is coerced to an unsigned integer. If the + * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is + * truncated to `totalLength`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Create a single `Buffer` from a list of three `Buffer` instances. + * + * const buf1 = Buffer.alloc(10); + * const buf2 = Buffer.alloc(14); + * const buf3 = Buffer.alloc(18); + * const totalLength = buf1.length + buf2.length + buf3.length; + * + * console.log(totalLength); + * // Prints: 42 + * + * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength); + * + * console.log(bufA); + * // Prints: + * console.log(bufA.length); + * // Prints: 42 + * ``` + * + * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does. + * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate. + * @param totalLength Total length of the `Buffer` instances in `list` when concatenated. + */ + concat(list: ReadonlyArray, totalLength?: number): Buffer; + /** + * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of`Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from('1234'); + * const buf2 = Buffer.from('0123'); + * const arr = [buf1, buf2]; + * + * console.log(arr.sort(Buffer.compare)); + * // Prints: [ , ] + * // (This result is equal to: [buf2, buf1].) + * ``` + * @return Either `-1`, `0`, or `1`, depending on the result of the comparison. See `compare` for details. + */ + compare(buf1: Uint8Array, buf2: Uint8Array): -1 | 0 | 1; + /** + * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.alloc(5); + * + * console.log(buf); + * // Prints: + * ``` + * + * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. + * + * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.alloc(5, 'a'); + * + * console.log(buf); + * // Prints: + * ``` + * + * If both `fill` and `encoding` are specified, the allocated `Buffer` will be + * initialized by calling `buf.fill(fill, encoding)`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64'); + * + * console.log(buf); + * // Prints: + * ``` + * + * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance + * contents will never contain sensitive data from previous allocations, including + * data that might not have been allocated for `Buffer`s. + * + * A `TypeError` will be thrown if `size` is not a number. + * @param size The desired length of the new `Buffer`. + * @param [fill=0] A value to pre-fill the new `Buffer` with. + * @param [encoding='utf8'] If `fill` is a string, this is its encoding. + */ + alloc( + size: number, + fill?: string | Buffer | number, + encoding?: BufferEncoding, + ): Buffer; + /** + * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. + * + * The underlying memory for `Buffer` instances created in this way is _not_ + * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(10); + * + * console.log(buf); + * // Prints (contents may vary): + * + * buf.fill(0); + * + * console.log(buf); + * // Prints: + * ``` + * + * A `TypeError` will be thrown if `size` is not a number. + * + * The `Buffer` module pre-allocates an internal `Buffer` instance of + * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`,`Buffer.from(array)`, `Buffer.concat()`, and the + * deprecated`new Buffer(size)` constructor only when `size` is less than or equal + * to `Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two). + * + * Use of this pre-allocated internal memory pool is a key difference between + * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`. + * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less + * than or equal to half `Buffer.poolSize`. The + * difference is subtle but can be important when an application requires the + * additional performance that `Buffer.allocUnsafe()` provides. + * @param size The desired length of the new `Buffer`. + */ + allocUnsafe(size: number): Buffer; + /** + * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. A zero-length `Buffer` is created + * if `size` is 0. + * + * The underlying memory for `Buffer` instances created in this way is _not_ + * _initialized_. The contents of the newly created `Buffer` are unknown and_may contain sensitive data_. Use `buf.fill(0)` to initialize + * such `Buffer` instances with zeroes. + * + * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances, + * allocations under 4 KB are sliced from a single pre-allocated `Buffer`. This + * allows applications to avoid the garbage collection overhead of creating many + * individually allocated `Buffer` instances. This approach improves both + * performance and memory usage by eliminating the need to track and clean up as + * many individual `ArrayBuffer` objects. + * + * However, in the case where a developer may need to retain a small chunk of + * memory from a pool for an indeterminate amount of time, it may be appropriate + * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and + * then copying out the relevant bits. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Need to keep around a few small chunks of memory. + * const store = []; + * + * socket.on('readable', () => { + * let data; + * while (null !== (data = readable.read())) { + * // Allocate for retained data. + * const sb = Buffer.allocUnsafeSlow(10); + * + * // Copy the data into the new allocation. + * data.copy(sb, 0, 0, 10); + * + * store.push(sb); + * } + * }); + * ``` + * + * A `TypeError` will be thrown if `size` is not a number. + * @param size The desired length of the new `Buffer`. + */ + allocUnsafeSlow(size: number): Buffer; + /** + * This is the size (in bytes) of pre-allocated internal `Buffer` instances used + * for pooling. This value may be modified. + */ + poolSize: number; + } + interface Buffer extends Uint8Array { + /** + * Writes `string` to `buf` at `offset` according to the character encoding in`encoding`. The `length` parameter is the number of bytes to write. If `buf` did + * not contain enough space to fit the entire string, only part of `string` will be + * written. However, partially encoded characters will not be written. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.alloc(256); + * + * const len = buf.write('\u00bd + \u00bc = \u00be', 0); + * + * console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`); + * // Prints: 12 bytes: ½ + ¼ = ¾ + * + * const buffer = Buffer.alloc(10); + * + * const length = buffer.write('abcd', 8); + * + * console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`); + * // Prints: 2 bytes : ab + * ``` + * @param string String to write to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write `string`. + * @param [length=buf.length - offset] Maximum number of bytes to write (written bytes will not exceed `buf.length - offset`). + * @param [encoding='utf8'] The character encoding of `string`. + * @return Number of bytes written. + */ + write(string: string, encoding?: BufferEncoding): number; + write(string: string, offset: number, encoding?: BufferEncoding): number; + write( + string: string, + offset: number, + length: number, + encoding?: BufferEncoding, + ): number; + /** + * Decodes `buf` to a string according to the specified character encoding in`encoding`. `start` and `end` may be passed to decode only a subset of `buf`. + * + * If `encoding` is `'utf8'` and a byte sequence in the input is not valid UTF-8, + * then each invalid byte is replaced with the replacement character `U+FFFD`. + * + * The maximum length of a string instance (in UTF-16 code units) is available + * as {@link constants.MAX_STRING_LENGTH}. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.allocUnsafe(26); + * + * for (let i = 0; i < 26; i++) { + * // 97 is the decimal ASCII value for 'a'. + * buf1[i] = i + 97; + * } + * + * console.log(buf1.toString('utf8')); + * // Prints: abcdefghijklmnopqrstuvwxyz + * console.log(buf1.toString('utf8', 0, 5)); + * // Prints: abcde + * + * const buf2 = Buffer.from('tést'); + * + * console.log(buf2.toString('hex')); + * // Prints: 74c3a97374 + * console.log(buf2.toString('utf8', 0, 3)); + * // Prints: té + * console.log(buf2.toString(undefined, 0, 3)); + * // Prints: té + * ``` + * @param [encoding='utf8'] The character encoding to use. + * @param [start=0] The byte offset to start decoding at. + * @param [end=buf.length] The byte offset to stop decoding at (not inclusive). + */ + toString(encoding?: BufferEncoding, start?: number, end?: number): string; + /** + * Returns a JSON representation of `buf`. [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) implicitly calls + * this function when stringifying a `Buffer` instance. + * + * `Buffer.from()` accepts objects in the format returned from this method. + * In particular, `Buffer.from(buf.toJSON())` works like `Buffer.from(buf)`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]); + * const json = JSON.stringify(buf); + * + * console.log(json); + * // Prints: {"type":"Buffer","data":[1,2,3,4,5]} + * + * const copy = JSON.parse(json, (key, value) => { + * return value && value.type === 'Buffer' ? + * Buffer.from(value) : + * value; + * }); + * + * console.log(copy); + * // Prints: + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + */ + toJSON(): { + type: "Buffer"; + data: number[]; + }; + /** + * Returns `true` if both `buf` and `otherBuffer` have exactly the same bytes,`false` otherwise. Equivalent to `buf.compare(otherBuffer) === 0`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from('ABC'); + * const buf2 = Buffer.from('414243', 'hex'); + * const buf3 = Buffer.from('ABCD'); + * + * console.log(buf1.equals(buf2)); + * // Prints: true + * console.log(buf1.equals(buf3)); + * // Prints: false + * ``` + * @param otherBuffer A `Buffer` or {@link Uint8Array} with which to compare `buf`. + */ + equals(otherBuffer: Uint8Array): boolean; + /** + * Compares `buf` with `target` and returns a number indicating whether `buf`comes before, after, or is the same as `target` in sort order. + * Comparison is based on the actual sequence of bytes in each `Buffer`. + * + * * `0` is returned if `target` is the same as `buf` + * * `1` is returned if `target` should come _before_`buf` when sorted. + * * `-1` is returned if `target` should come _after_`buf` when sorted. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from('ABC'); + * const buf2 = Buffer.from('BCD'); + * const buf3 = Buffer.from('ABCD'); + * + * console.log(buf1.compare(buf1)); + * // Prints: 0 + * console.log(buf1.compare(buf2)); + * // Prints: -1 + * console.log(buf1.compare(buf3)); + * // Prints: -1 + * console.log(buf2.compare(buf1)); + * // Prints: 1 + * console.log(buf2.compare(buf3)); + * // Prints: 1 + * console.log([buf1, buf2, buf3].sort(Buffer.compare)); + * // Prints: [ , , ] + * // (This result is equal to: [buf1, buf3, buf2].) + * ``` + * + * The optional `targetStart`, `targetEnd`, `sourceStart`, and `sourceEnd`arguments can be used to limit the comparison to specific ranges within `target`and `buf` respectively. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]); + * const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]); + * + * console.log(buf1.compare(buf2, 5, 9, 0, 4)); + * // Prints: 0 + * console.log(buf1.compare(buf2, 0, 6, 4)); + * // Prints: -1 + * console.log(buf1.compare(buf2, 5, 6, 5)); + * // Prints: 1 + * ``` + * + * `ERR_OUT_OF_RANGE` is thrown if `targetStart < 0`, `sourceStart < 0`,`targetEnd > target.byteLength`, or `sourceEnd > source.byteLength`. + * @param target A `Buffer` or {@link Uint8Array} with which to compare `buf`. + * @param [targetStart=0] The offset within `target` at which to begin comparison. + * @param [targetEnd=target.length] The offset within `target` at which to end comparison (not inclusive). + * @param [sourceStart=0] The offset within `buf` at which to begin comparison. + * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive). + */ + compare( + target: Uint8Array, + targetStart?: number, + targetEnd?: number, + sourceStart?: number, + sourceEnd?: number, + ): -1 | 0 | 1; + /** + * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`. + * + * [`TypedArray.prototype.set()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) performs the same operation, and is available + * for all TypedArrays, including Node.js `Buffer`s, although it takes + * different function arguments. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Create two `Buffer` instances. + * const buf1 = Buffer.allocUnsafe(26); + * const buf2 = Buffer.allocUnsafe(26).fill('!'); + * + * for (let i = 0; i < 26; i++) { + * // 97 is the decimal ASCII value for 'a'. + * buf1[i] = i + 97; + * } + * + * // Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`. + * buf1.copy(buf2, 8, 16, 20); + * // This is equivalent to: + * // buf2.set(buf1.subarray(16, 20), 8); + * + * console.log(buf2.toString('ascii', 0, 25)); + * // Prints: !!!!!!!!qrst!!!!!!!!!!!!! + * ``` + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Create a `Buffer` and copy data from one region to an overlapping region + * // within the same `Buffer`. + * + * const buf = Buffer.allocUnsafe(26); + * + * for (let i = 0; i < 26; i++) { + * // 97 is the decimal ASCII value for 'a'. + * buf[i] = i + 97; + * } + * + * buf.copy(buf, 0, 4, 10); + * + * console.log(buf.toString()); + * // Prints: efghijghijklmnopqrstuvwxyz + * ``` + * @param target A `Buffer` or {@link Uint8Array} to copy into. + * @param [targetStart=0] The offset within `target` at which to begin writing. + * @param [sourceStart=0] The offset within `buf` from which to begin copying. + * @param [sourceEnd=buf.length] The offset within `buf` at which to stop copying (not inclusive). + * @return The number of bytes copied. + */ + copy( + target: Uint8Array, + targetStart?: number, + sourceStart?: number, + sourceEnd?: number, + ): number; + /** + * Returns a new `Buffer` that references the same memory as the original, but + * offset and cropped by the `start` and `end` indices. + * + * This method is not compatible with the `Uint8Array.prototype.slice()`, + * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('buffer'); + * + * const copiedBuf = Uint8Array.prototype.slice.call(buf); + * copiedBuf[0]++; + * console.log(copiedBuf.toString()); + * // Prints: cuffer + * + * console.log(buf.toString()); + * // Prints: buffer + * + * // With buf.slice(), the original buffer is modified. + * const notReallyCopiedBuf = buf.slice(); + * notReallyCopiedBuf[0]++; + * console.log(notReallyCopiedBuf.toString()); + * // Prints: cuffer + * console.log(buf.toString()); + * // Also prints: cuffer (!) + * ``` + * @deprecated Use `subarray` instead. + * @param [start=0] Where the new `Buffer` will start. + * @param [end=buf.length] Where the new `Buffer` will end (not inclusive). + */ + slice(start?: number, end?: number): Buffer; + /** + * Returns a new `Buffer` that references the same memory as the original, but + * offset and cropped by the `start` and `end` indices. + * + * Specifying `end` greater than `buf.length` will return the same result as + * that of `end` equal to `buf.length`. + * + * This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray). + * + * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte + * // from the original `Buffer`. + * + * const buf1 = Buffer.allocUnsafe(26); + * + * for (let i = 0; i < 26; i++) { + * // 97 is the decimal ASCII value for 'a'. + * buf1[i] = i + 97; + * } + * + * const buf2 = buf1.subarray(0, 3); + * + * console.log(buf2.toString('ascii', 0, buf2.length)); + * // Prints: abc + * + * buf1[0] = 33; + * + * console.log(buf2.toString('ascii', 0, buf2.length)); + * // Prints: !bc + * ``` + * + * Specifying negative indexes causes the slice to be generated relative to the + * end of `buf` rather than the beginning. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('buffer'); + * + * console.log(buf.subarray(-6, -1).toString()); + * // Prints: buffe + * // (Equivalent to buf.subarray(0, 5).) + * + * console.log(buf.subarray(-6, -2).toString()); + * // Prints: buff + * // (Equivalent to buf.subarray(0, 4).) + * + * console.log(buf.subarray(-5, -2).toString()); + * // Prints: uff + * // (Equivalent to buf.subarray(1, 4).) + * ``` + * @param [start=0] Where the new `Buffer` will start. + * @param [end=buf.length] Where the new `Buffer` will end (not inclusive). + */ + subarray(start?: number, end?: number): Buffer; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. + * + * `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeBigInt64BE(0x0102030405060708n, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeBigInt64BE(value: bigint, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. + * + * `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeBigInt64LE(0x0102030405060708n, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeBigInt64LE(value: bigint, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. + * + * This function is also available under the `writeBigUint64BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeBigUInt64BE(value: bigint, offset?: number): number; + /** + * @alias Buffer.writeBigUInt64BE + */ + writeBigUint64BE(value: bigint, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeBigUInt64LE(0xdecafafecacefaden, 0); + * + * console.log(buf); + * // Prints: + * ``` + * + * This function is also available under the `writeBigUint64LE` alias. + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeBigUInt64LE(value: bigint, offset?: number): number; + /** + * @alias Buffer.writeBigUInt64LE + */ + writeBigUint64LE(value: bigint, offset?: number): number; + /** + * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined + * when `value` is anything other than an unsigned integer. + * + * This function is also available under the `writeUintLE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(6); + * + * buf.writeUIntLE(0x1234567890ab, 0, 6); + * + * console.log(buf); + * // Prints: + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param value Number to be written to `buf`. + * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. + * @return `offset` plus the number of bytes written. + */ + writeUIntLE(value: number, offset: number, byteLength: number): number; + /** + * @alias Buffer.writeUIntLE + */ + writeUintLE(value: number, offset: number, byteLength: number): number; + /** + * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined + * when `value` is anything other than an unsigned integer. + * + * This function is also available under the `writeUintBE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(6); + * + * buf.writeUIntBE(0x1234567890ab, 0, 6); + * + * console.log(buf); + * // Prints: + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param value Number to be written to `buf`. + * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. + * @return `offset` plus the number of bytes written. + */ + writeUIntBE(value: number, offset: number, byteLength: number): number; + /** + * @alias Buffer.writeUIntBE + */ + writeUintBE(value: number, offset: number, byteLength: number): number; + /** + * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined + * when `value` is anything other than a signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(6); + * + * buf.writeIntLE(0x1234567890ab, 0, 6); + * + * console.log(buf); + * // Prints: + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param value Number to be written to `buf`. + * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. + * @return `offset` plus the number of bytes written. + */ + writeIntLE(value: number, offset: number, byteLength: number): number; + /** + * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when`value` is anything other than a + * signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(6); + * + * buf.writeIntBE(0x1234567890ab, 0, 6); + * + * console.log(buf); + * // Prints: + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param value Number to be written to `buf`. + * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. + * @return `offset` plus the number of bytes written. + */ + writeIntBE(value: number, offset: number, byteLength: number): number; + /** + * Reads an unsigned, big-endian 64-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readBigUint64BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]); + * + * console.log(buf.readBigUInt64BE(0)); + * // Prints: 4294967295n + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. + */ + readBigUInt64BE(offset?: number): bigint; + /** + * @alias Buffer.readBigUInt64BE + */ + readBigUint64BE(offset?: number): bigint; + /** + * Reads an unsigned, little-endian 64-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readBigUint64LE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]); + * + * console.log(buf.readBigUInt64LE(0)); + * // Prints: 18446744069414584320n + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. + */ + readBigUInt64LE(offset?: number): bigint; + /** + * @alias Buffer.readBigUInt64LE + */ + readBigUint64LE(offset?: number): bigint; + /** + * Reads a signed, big-endian 64-bit integer from `buf` at the specified `offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed + * values. + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. + */ + readBigInt64BE(offset?: number): bigint; + /** + * Reads a signed, little-endian 64-bit integer from `buf` at the specified`offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed + * values. + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. + */ + readBigInt64LE(offset?: number): bigint; + /** + * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned, little-endian integer supporting + * up to 48 bits of accuracy. + * + * This function is also available under the `readUintLE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); + * + * console.log(buf.readUIntLE(0, 6).toString(16)); + * // Prints: ab9078563412 + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. + */ + readUIntLE(offset: number, byteLength: number): number; + /** + * @alias Buffer.readUIntLE + */ + readUintLE(offset: number, byteLength: number): number; + /** + * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned big-endian integer supporting + * up to 48 bits of accuracy. + * + * This function is also available under the `readUintBE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); + * + * console.log(buf.readUIntBE(0, 6).toString(16)); + * // Prints: 1234567890ab + * console.log(buf.readUIntBE(1, 6).toString(16)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. + */ + readUIntBE(offset: number, byteLength: number): number; + /** + * @alias Buffer.readUIntBE + */ + readUintBE(offset: number, byteLength: number): number; + /** + * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a little-endian, two's complement signed value + * supporting up to 48 bits of accuracy. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); + * + * console.log(buf.readIntLE(0, 6).toString(16)); + * // Prints: -546f87a9cbee + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. + */ + readIntLE(offset: number, byteLength: number): number; + /** + * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a big-endian, two's complement signed value + * supporting up to 48 bits of accuracy. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); + * + * console.log(buf.readIntBE(0, 6).toString(16)); + * // Prints: 1234567890ab + * console.log(buf.readIntBE(1, 6).toString(16)); + * // Throws ERR_OUT_OF_RANGE. + * console.log(buf.readIntBE(1, 0).toString(16)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * + * Note: as of Bun v0.1.2, this is not implemented yet. + * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. + * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. + */ + readIntBE(offset: number, byteLength: number): number; + /** + * Reads an unsigned 8-bit integer from `buf` at the specified `offset`. + * + * This function is also available under the `readUint8` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([1, -2]); + * + * console.log(buf.readUInt8(0)); + * // Prints: 1 + * console.log(buf.readUInt8(1)); + * // Prints: 254 + * console.log(buf.readUInt8(2)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`. + */ + readUInt8(offset?: number): number; + /** + * @alias Buffer.readUInt8 + */ + readUint8(offset?: number): number; + /** + * Reads an unsigned, little-endian 16-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readUint16LE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56]); + * + * console.log(buf.readUInt16LE(0).toString(16)); + * // Prints: 3412 + * console.log(buf.readUInt16LE(1).toString(16)); + * // Prints: 5634 + * console.log(buf.readUInt16LE(2).toString(16)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. + */ + readUInt16LE(offset?: number): number; + /** + * @alias Buffer.readUInt16LE + */ + readUint16LE(offset?: number): number; + /** + * Reads an unsigned, big-endian 16-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readUint16BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56]); + * + * console.log(buf.readUInt16BE(0).toString(16)); + * // Prints: 1234 + * console.log(buf.readUInt16BE(1).toString(16)); + * // Prints: 3456 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. + */ + readUInt16BE(offset?: number): number; + /** + * @alias Buffer.readUInt16BE + */ + readUint16BE(offset?: number): number; + /** + * Reads an unsigned, little-endian 32-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readUint32LE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]); + * + * console.log(buf.readUInt32LE(0).toString(16)); + * // Prints: 78563412 + * console.log(buf.readUInt32LE(1).toString(16)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readUInt32LE(offset?: number): number; + /** + * @alias Buffer.readUInt32LE + */ + readUint32LE(offset?: number): number; + /** + * Reads an unsigned, big-endian 32-bit integer from `buf` at the specified`offset`. + * + * This function is also available under the `readUint32BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]); + * + * console.log(buf.readUInt32BE(0).toString(16)); + * // Prints: 12345678 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readUInt32BE(offset?: number): number; + /** + * @alias Buffer.readUInt32BE + */ + readUint32BE(offset?: number): number; + /** + * Reads a signed 8-bit integer from `buf` at the specified `offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed values. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([-1, 5]); + * + * console.log(buf.readInt8(0)); + * // Prints: -1 + * console.log(buf.readInt8(1)); + * // Prints: 5 + * console.log(buf.readInt8(2)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`. + */ + readInt8(offset?: number): number; + /** + * Reads a signed, little-endian 16-bit integer from `buf` at the specified`offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed values. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0, 5]); + * + * console.log(buf.readInt16LE(0)); + * // Prints: 1280 + * console.log(buf.readInt16LE(1)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. + */ + readInt16LE(offset?: number): number; + /** + * Reads a signed, big-endian 16-bit integer from `buf` at the specified `offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed values. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0, 5]); + * + * console.log(buf.readInt16BE(0)); + * // Prints: 5 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. + */ + readInt16BE(offset?: number): number; + /** + * Reads a signed, little-endian 32-bit integer from `buf` at the specified`offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed values. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0, 0, 0, 5]); + * + * console.log(buf.readInt32LE(0)); + * // Prints: 83886080 + * console.log(buf.readInt32LE(1)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readInt32LE(offset?: number): number; + /** + * Reads a signed, big-endian 32-bit integer from `buf` at the specified `offset`. + * + * Integers read from a `Buffer` are interpreted as two's complement signed values. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([0, 0, 0, 5]); + * + * console.log(buf.readInt32BE(0)); + * // Prints: 5 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readInt32BE(offset?: number): number; + /** + * Reads a 32-bit, little-endian float from `buf` at the specified `offset`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([1, 2, 3, 4]); + * + * console.log(buf.readFloatLE(0)); + * // Prints: 1.539989614439558e-36 + * console.log(buf.readFloatLE(1)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readFloatLE(offset?: number): number; + /** + * Reads a 32-bit, big-endian float from `buf` at the specified `offset`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([1, 2, 3, 4]); + * + * console.log(buf.readFloatBE(0)); + * // Prints: 2.387939260590663e-38 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. + */ + readFloatBE(offset?: number): number; + /** + * Reads a 64-bit, little-endian double from `buf` at the specified `offset`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); + * + * console.log(buf.readDoubleLE(0)); + * // Prints: 5.447603722011605e-270 + * console.log(buf.readDoubleLE(1)); + * // Throws ERR_OUT_OF_RANGE. + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`. + */ + readDoubleLE(offset?: number): number; + /** + * Reads a 64-bit, big-endian double from `buf` at the specified `offset`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); + * + * console.log(buf.readDoubleBE(0)); + * // Prints: 8.20788039913184e-304 + * ``` + * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`. + */ + readDoubleBE(offset?: number): number; + reverse(): this; + /** + * Interprets `buf` as an array of unsigned 16-bit integers and swaps the + * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 2. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); + * + * console.log(buf1); + * // Prints: + * + * buf1.swap16(); + * + * console.log(buf1); + * // Prints: + * + * const buf2 = Buffer.from([0x1, 0x2, 0x3]); + * + * buf2.swap16(); + * // Throws ERR_INVALID_BUFFER_SIZE. + * ``` + * + * One convenient use of `buf.swap16()` is to perform a fast in-place conversion + * between UTF-16 little-endian and UTF-16 big-endian: + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('This is little-endian UTF-16', 'utf16le'); + * buf.swap16(); // Convert to big-endian UTF-16 text. + * ``` + * @return A reference to `buf`. + */ + swap16(): Buffer; + /** + * Interprets `buf` as an array of unsigned 32-bit integers and swaps the + * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 4. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); + * + * console.log(buf1); + * // Prints: + * + * buf1.swap32(); + * + * console.log(buf1); + * // Prints: + * + * const buf2 = Buffer.from([0x1, 0x2, 0x3]); + * + * buf2.swap32(); + * // Throws ERR_INVALID_BUFFER_SIZE. + * ``` + * @return A reference to `buf`. + */ + swap32(): Buffer; + /** + * Interprets `buf` as an array of 64-bit numbers and swaps byte order _in-place_. + * Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 8. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); + * + * console.log(buf1); + * // Prints: + * + * buf1.swap64(); + * + * console.log(buf1); + * // Prints: + * + * const buf2 = Buffer.from([0x1, 0x2, 0x3]); + * + * buf2.swap64(); + * // Throws ERR_INVALID_BUFFER_SIZE. + * ``` + * @return A reference to `buf`. + */ + swap64(): Buffer; + /** + * Writes `value` to `buf` at the specified `offset`. `value` must be a + * valid unsigned 8-bit integer. Behavior is undefined when `value` is anything + * other than an unsigned 8-bit integer. + * + * This function is also available under the `writeUint8` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeUInt8(0x3, 0); + * buf.writeUInt8(0x4, 1); + * buf.writeUInt8(0x23, 2); + * buf.writeUInt8(0x42, 3); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`. + * @return `offset` plus the number of bytes written. + */ + writeUInt8(value: number, offset?: number): number; + /** + * @alias Buffer.writeUInt8 + */ + writeUint8(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value` is + * anything other than an unsigned 16-bit integer. + * + * This function is also available under the `writeUint16LE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeUInt16LE(0xdead, 0); + * buf.writeUInt16LE(0xbeef, 2); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. + * @return `offset` plus the number of bytes written. + */ + writeUInt16LE(value: number, offset?: number): number; + /** + * @alias Buffer.writeUInt16LE + */ + writeUint16LE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value`is anything other than an + * unsigned 16-bit integer. + * + * This function is also available under the `writeUint16BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeUInt16BE(0xdead, 0); + * buf.writeUInt16BE(0xbeef, 2); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. + * @return `offset` plus the number of bytes written. + */ + writeUInt16BE(value: number, offset?: number): number; + /** + * @alias Buffer.writeUInt16BE + */ + writeUint16BE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value` is + * anything other than an unsigned 32-bit integer. + * + * This function is also available under the `writeUint32LE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeUInt32LE(0xfeedface, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeUInt32LE(value: number, offset?: number): number; + /** + * @alias Buffer.writeUInt32LE + */ + writeUint32LE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value`is anything other than an + * unsigned 32-bit integer. + * + * This function is also available under the `writeUint32BE` alias. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeUInt32BE(0xfeedface, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeUInt32BE(value: number, offset?: number): number; + /** + * @alias Buffer.writeUInt32BE + */ + writeUint32BE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset`. `value` must be a valid + * signed 8-bit integer. Behavior is undefined when `value` is anything other than + * a signed 8-bit integer. + * + * `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(2); + * + * buf.writeInt8(2, 0); + * buf.writeInt8(-2, 1); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`. + * @return `offset` plus the number of bytes written. + */ + writeInt8(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is + * anything other than a signed 16-bit integer. + * + * The `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(2); + * + * buf.writeInt16LE(0x0304, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. + * @return `offset` plus the number of bytes written. + */ + writeInt16LE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is + * anything other than a signed 16-bit integer. + * + * The `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(2); + * + * buf.writeInt16BE(0x0102, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. + * @return `offset` plus the number of bytes written. + */ + writeInt16BE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is + * anything other than a signed 32-bit integer. + * + * The `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeInt32LE(0x05060708, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeInt32LE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is + * anything other than a signed 32-bit integer. + * + * The `value` is interpreted and written as a two's complement signed integer. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeInt32BE(0x01020304, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeInt32BE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. Behavior is + * undefined when `value` is anything other than a JavaScript number. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeFloatLE(0xcafebabe, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeFloatLE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. Behavior is + * undefined when `value` is anything other than a JavaScript number. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(4); + * + * buf.writeFloatBE(0xcafebabe, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. + * @return `offset` plus the number of bytes written. + */ + writeFloatBE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything + * other than a JavaScript number. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeDoubleLE(123.456, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeDoubleLE(value: number, offset?: number): number; + /** + * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything + * other than a JavaScript number. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(8); + * + * buf.writeDoubleBE(123.456, 0); + * + * console.log(buf); + * // Prints: + * ``` + * @param value Number to be written to `buf`. + * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`. + * @return `offset` plus the number of bytes written. + */ + writeDoubleBE(value: number, offset?: number): number; + /** + * Fills `buf` with the specified `value`. If the `offset` and `end` are not given, + * the entire `buf` will be filled: + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Fill a `Buffer` with the ASCII character 'h'. + * + * const b = Buffer.allocUnsafe(50).fill('h'); + * + * console.log(b.toString()); + * // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh + * ``` + * + * `value` is coerced to a `uint32` value if it is not a string, `Buffer`, or + * integer. If the resulting integer is greater than `255` (decimal), `buf` will be + * filled with `value & 255`. + * + * If the final write of a `fill()` operation falls on a multi-byte character, + * then only the bytes of that character that fit into `buf` are written: + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Fill a `Buffer` with character that takes up two bytes in UTF-8. + * + * console.log(Buffer.allocUnsafe(5).fill('\u0222')); + * // Prints: + * ``` + * + * If `value` contains invalid characters, it is truncated; if no valid + * fill data remains, an exception is thrown: + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.allocUnsafe(5); + * + * console.log(buf.fill('a')); + * // Prints: + * console.log(buf.fill('aazz', 'hex')); + * // Prints: + * console.log(buf.fill('zz', 'hex')); + * // Throws an exception. + * ``` + * @param value The value with which to fill `buf`. + * @param [offset=0] Number of bytes to skip before starting to fill `buf`. + * @param [end=buf.length] Where to stop filling `buf` (not inclusive). + * @param [encoding='utf8'] The encoding for `value` if `value` is a string. + * @return A reference to `buf`. + */ + fill( + value: string | Uint8Array | number, + offset?: number, + end?: number, + encoding?: BufferEncoding, + ): this; + /** + * If `value` is: + * + * * a string, `value` is interpreted according to the character encoding in`encoding`. + * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety. + * To compare a partial `Buffer`, use `buf.subarray`. + * * a number, `value` will be interpreted as an unsigned 8-bit integer + * value between `0` and `255`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('this is a buffer'); + * + * console.log(buf.indexOf('this')); + * // Prints: 0 + * console.log(buf.indexOf('is')); + * // Prints: 2 + * console.log(buf.indexOf(Buffer.from('a buffer'))); + * // Prints: 8 + * console.log(buf.indexOf(97)); + * // Prints: 8 (97 is the decimal ASCII value for 'a') + * console.log(buf.indexOf(Buffer.from('a buffer example'))); + * // Prints: -1 + * console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8))); + * // Prints: 8 + * + * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le'); + * + * console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le')); + * // Prints: 4 + * console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le')); + * // Prints: 6 + * ``` + * + * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value, + * an integer between 0 and 255. + * + * If `byteOffset` is not a number, it will be coerced to a number. If the result + * of coercion is `NaN` or `0`, then the entire buffer will be searched. This + * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf). + * + * ```js + * import { Buffer } from 'buffer'; + * + * const b = Buffer.from('abcdef'); + * + * // Passing a value that's a number, but not a valid byte. + * // Prints: 2, equivalent to searching for 99 or 'c'. + * console.log(b.indexOf(99.9)); + * console.log(b.indexOf(256 + 99)); + * + * // Passing a byteOffset that coerces to NaN or 0. + * // Prints: 1, searching the whole buffer. + * console.log(b.indexOf('b', undefined)); + * console.log(b.indexOf('b', {})); + * console.log(b.indexOf('b', null)); + * console.log(b.indexOf('b', [])); + * ``` + * + * If `value` is an empty string or empty `Buffer` and `byteOffset` is less + * than `buf.length`, `byteOffset` will be returned. If `value` is empty and`byteOffset` is at least `buf.length`, `buf.length` will be returned. + * @param value What to search for. + * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. + * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`. + * @return The index of the first occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`. + */ + indexOf( + value: string | number | Uint8Array, + byteOffset?: number, + encoding?: BufferEncoding, + ): number; + /** + * Identical to `buf.indexOf()`, except the last occurrence of `value` is found + * rather than the first occurrence. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('this buffer is a buffer'); + * + * console.log(buf.lastIndexOf('this')); + * // Prints: 0 + * console.log(buf.lastIndexOf('buffer')); + * // Prints: 17 + * console.log(buf.lastIndexOf(Buffer.from('buffer'))); + * // Prints: 17 + * console.log(buf.lastIndexOf(97)); + * // Prints: 15 (97 is the decimal ASCII value for 'a') + * console.log(buf.lastIndexOf(Buffer.from('yolo'))); + * // Prints: -1 + * console.log(buf.lastIndexOf('buffer', 5)); + * // Prints: 5 + * console.log(buf.lastIndexOf('buffer', 4)); + * // Prints: -1 + * + * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le'); + * + * console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le')); + * // Prints: 6 + * console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le')); + * // Prints: 4 + * ``` + * + * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value, + * an integer between 0 and 255. + * + * If `byteOffset` is not a number, it will be coerced to a number. Any arguments + * that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer. + * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf). + * + * ```js + * import { Buffer } from 'buffer'; + * + * const b = Buffer.from('abcdef'); + * + * // Passing a value that's a number, but not a valid byte. + * // Prints: 2, equivalent to searching for 99 or 'c'. + * console.log(b.lastIndexOf(99.9)); + * console.log(b.lastIndexOf(256 + 99)); + * + * // Passing a byteOffset that coerces to NaN. + * // Prints: 1, searching the whole buffer. + * console.log(b.lastIndexOf('b', undefined)); + * console.log(b.lastIndexOf('b', {})); + * + * // Passing a byteOffset that coerces to 0. + * // Prints: -1, equivalent to passing 0. + * console.log(b.lastIndexOf('b', null)); + * console.log(b.lastIndexOf('b', [])); + * ``` + * + * If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned. + * @param value What to search for. + * @param [byteOffset=buf.length - 1] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. + * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`. + * @return The index of the last occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`. + */ + lastIndexOf( + value: string | number | Uint8Array, + byteOffset?: number, + encoding?: BufferEncoding, + ): number; + /** + * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `[index, byte]` pairs from the contents + * of `buf`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * // Log the entire contents of a `Buffer`. + * + * const buf = Buffer.from('buffer'); + * + * for (const pair of buf.entries()) { + * console.log(pair); + * } + * // Prints: + * // [0, 98] + * // [1, 117] + * // [2, 102] + * // [3, 102] + * // [4, 101] + * // [5, 114] + * ``` + */ + entries(): IterableIterator<[number, number]>; + /** + * Equivalent to `buf.indexOf() !== -1`. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('this is a buffer'); + * + * console.log(buf.includes('this')); + * // Prints: true + * console.log(buf.includes('is')); + * // Prints: true + * console.log(buf.includes(Buffer.from('a buffer'))); + * // Prints: true + * console.log(buf.includes(97)); + * // Prints: true (97 is the decimal ASCII value for 'a') + * console.log(buf.includes(Buffer.from('a buffer example'))); + * // Prints: false + * console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8))); + * // Prints: true + * console.log(buf.includes('this', 4)); + * // Prints: false + * ``` + * @param value What to search for. + * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. + * @param [encoding='utf8'] If `value` is a string, this is its encoding. + * @return `true` if `value` was found in `buf`, `false` otherwise. + */ + includes( + value: string | number | Buffer, + byteOffset?: number, + encoding?: BufferEncoding, + ): boolean; + /** + * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `buf` keys (indices). + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('buffer'); + * + * for (const key of buf.keys()) { + * console.log(key); + * } + * // Prints: + * // 0 + * // 1 + * // 2 + * // 3 + * // 4 + * // 5 + * ``` + */ + keys(): IterableIterator; + /** + * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) for `buf` values (bytes). This function is + * called automatically when a `Buffer` is used in a `for..of` statement. + * + * ```js + * import { Buffer } from 'buffer'; + * + * const buf = Buffer.from('buffer'); + * + * for (const value of buf.values()) { + * console.log(value); + * } + * // Prints: + * // 98 + * // 117 + * // 102 + * // 102 + * // 101 + * // 114 + * + * for (const value of buf) { + * console.log(value); + * } + * // Prints: + * // 98 + * // 117 + * // 102 + * // 102 + * // 101 + * // 114 + * ``` + */ + values(): IterableIterator; + } + var Buffer: BufferConstructor; + } +} +declare module "node:buffer" { + export * from "buffer"; +} diff --git a/packages/bun-types/bun-test.d.ts b/packages/bun-types/bun-test.d.ts new file mode 100644 index 0000000000..1ec84492a2 --- /dev/null +++ b/packages/bun-types/bun-test.d.ts @@ -0,0 +1,44 @@ +/** + * + * This isn't really designed for third-party usage yet. + * You can try it if you want though! + * + * To run the tests, run `bun wiptest` + * + * @example + * + * ```bash + * $ bun wiptest + * ``` + * + * @example + * ```bash + * $ bun wiptest file-name + * ``` + */ + +declare module "bun:test" { + export function describe(label: string, body: () => void): any; + export function it(label: string, test: () => void | Promise): any; + export function test( + label: string, + test: (done: () => void) => void | Promise, + ): any; + + export function expect(value: any): Expect; + export function afterAll(fn: () => void): void; + export function beforeAll(fn: () => void): void; + + export function afterEach(fn: () => void): void; + export function beforeEach(fn: () => void): void; + + interface Expect { + toBe(value: any): void; + toContain(value: any): void; + } +} + +declare module "test" { + import BunTestModule = require("bun:test"); + export = BunTestModule; +} diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts new file mode 100644 index 0000000000..8611ccb301 --- /dev/null +++ b/packages/bun-types/bun.d.ts @@ -0,0 +1,2768 @@ +interface VoidFunction { + (): void; +} + +/** + * + * Bun.js runtime APIs + * + * @example + * + * ```js + * import {file} from 'bun'; + * + * // Log the file to the console + * const input = await file('/path/to/file.txt').text(); + * console.log(input); + * ``` + * + * This module aliases `globalThis.Bun`. + * + */ +declare module "bun" { + /** + * The environment variables of the process + * + * Defaults to `process.env` as it was when the current Bun process launched. + * + * Changes to `process.env` at runtime won't automatically be reflected in the default value. For that, you can pass `process.env` explicitly. + * + */ + export const env: Record; + export const origin: string; + + /** + * Find the path to an executable, similar to typing which in your terminal. Reads the `PATH` environment variable unless overridden with `options.PATH`. + * + * @param {string} command The name of the executable or script + * @param {string} options.PATH Overrides the PATH environment variable + * @param {string} options.cwd Limits the search to a particular directory in which to searc + * + */ + export function which( + command: string, + options?: { PATH?: string; cwd?: string }, + ): string; + + /** + * Start a fast HTTP server. + * + * @param options Server options (port defaults to $PORT || 8080) + * + * ----- + * + * @example + * + * ```ts + * Bun.serve({ + * fetch(req: Request): Response | Promise { + * return new Response("Hello World!"); + * }, + * + * // Optional port number - the default value is 3000 + * port: process.env.PORT || 3000, + * }); + * ``` + * ----- + * + * @example + * + * Send a file + * + * ```ts + * Bun.serve({ + * fetch(req: Request): Response | Promise { + * return new Response(Bun.file("./package.json")); + * }, + * + * // Optional port number - the default value is 3000 + * port: process.env.PORT || 3000, + * }); + * ``` + */ + export function serve>( + options: ServeOoptions, + ): Server; + + /** + * Synchronously resolve a `moduleId` as though it were imported from `parent` + * + * On failure, throws a `ResolveError` + */ + // tslint:disable-next-line:unified-signatures + export function resolveSync(moduleId: string, parent: string): string; + + /** + * Resolve a `moduleId` as though it were imported from `parent` + * + * On failure, throws a `ResolveError` + * + * For now, use the sync version. There is zero performance benefit to using this async version. It exists for future-proofing. + */ + // tslint:disable-next-line:unified-signatures + export function resolve(moduleId: string, parent: string): Promise; + + /** + * + * Use the fastest syscalls available to copy from `input` into `destination`. + * + * If `destination` exists, it must be a regular file or symlink to a file. + * + * @param destination The file or file path to write to + * @param input The data to copy into `destination`. + * @returns A promise that resolves with the number of bytes written. + */ + // tslint:disable-next-line:unified-signatures + export function write( + destination: FileBlob | PathLike, + input: Blob | TypedArray | ArrayBufferLike | string | BlobPart[], + ): Promise; + + /** + * + * Persist a {@link Response} body to disk. + * + * @param destination The file to write to. If the file doesn't exist, + * it will be created and if the file does exist, it will be + * overwritten. If `input`'s size is less than `destination`'s size, + * `destination` will be truncated. + * @param input - `Response` object + * @returns A promise that resolves with the number of bytes written. + */ + export function write( + destination: FileBlob, + input: Response, + ): Promise; + + /** + * + * Persist a {@link Response} body to disk. + * + * @param destinationPath The file path to write to. If the file doesn't + * exist, it will be created and if the file does exist, it will be + * overwritten. If `input`'s size is less than `destination`'s size, + * `destination` will be truncated. + * @param input - `Response` object + * @returns A promise that resolves with the number of bytes written. + */ + // tslint:disable-next-line:unified-signatures + export function write( + destinationPath: PathLike, + input: Response, + ): Promise; + + /** + * + * Use the fastest syscalls available to copy from `input` into `destination`. + * + * If `destination` exists, it must be a regular file or symlink to a file. + * + * On Linux, this uses `copy_file_range`. + * + * On macOS, when the destination doesn't already exist, this uses + * [`clonefile()`](https://www.manpagez.com/man/2/clonefile/) and falls + * back to [`fcopyfile()`](https://www.manpagez.com/man/2/fcopyfile/) + * + * @param destination The file to write to. If the file doesn't exist, + * it will be created and if the file does exist, it will be + * overwritten. If `input`'s size is less than `destination`'s size, + * `destination` will be truncated. + * @param input The file to copy from. + * @returns A promise that resolves with the number of bytes written. + */ + // tslint:disable-next-line:unified-signatures + export function write( + destination: FileBlob, + input: FileBlob, + ): Promise; + + /** + * + * Use the fastest syscalls available to copy from `input` into `destination`. + * + * If `destination` exists, it must be a regular file or symlink to a file. + * + * On Linux, this uses `copy_file_range`. + * + * On macOS, when the destination doesn't already exist, this uses + * [`clonefile()`](https://www.manpagez.com/man/2/clonefile/) and falls + * back to [`fcopyfile()`](https://www.manpagez.com/man/2/fcopyfile/) + * + * @param destinationPath The file path to write to. If the file doesn't + * exist, it will be created and if the file does exist, it will be + * overwritten. If `input`'s size is less than `destination`'s size, + * `destination` will be truncated. + * @param input The file to copy from. + * @returns A promise that resolves with the number of bytes written. + */ + // tslint:disable-next-line:unified-signatures + export function write( + destinationPath: PathLike, + input: FileBlob, + ): Promise; + + export interface SystemError extends Error { + errno?: number | undefined; + code?: string | undefined; + path?: string | undefined; + syscall?: string | undefined; + } + + /** + * Concatenate an array of typed arrays into a single `ArrayBuffer`. This is a fast path. + * + * You can do this manually if you'd like, but this function will generally + * be a little faster. + * + * If you want a `Uint8Array` instead, consider `Buffer.concat`. + * + * @param buffers An array of typed arrays to concatenate. + * @returns An `ArrayBuffer` with the data from all the buffers. + * + * Here is similar code to do it manually, except about 30% slower: + * ```js + * var chunks = [...]; + * var size = 0; + * for (const chunk of chunks) { + * size += chunk.byteLength; + * } + * var buffer = new ArrayBuffer(size); + * var view = new Uint8Array(buffer); + * var offset = 0; + * for (const chunk of chunks) { + * view.set(chunk, offset); + * offset += chunk.byteLength; + * } + * return buffer; + * ``` + * + * This function is faster because it uses uninitialized memory when copying. Since the entire + * length of the buffer is known, it is safe to use uninitialized memory. + */ + export function concatArrayBuffers( + buffers: Array, + ): ArrayBuffer; + + /** + * Consume all data from a {@link ReadableStream} until it closes or errors. + * + * Concatenate the chunks into a single {@link ArrayBuffer}. + * + * Each chunk must be a TypedArray or an ArrayBuffer. If you need to support + * chunks of different types, consider {@link readableStreamToBlob} + * + * @param stream The stream to consume. + * @returns A promise that resolves with the concatenated chunks or the concatenated chunks as an `ArrayBuffer`. + */ + export function readableStreamToArrayBuffer( + stream: ReadableStream, + ): Promise | ArrayBuffer; + + /** + * Consume all data from a {@link ReadableStream} until it closes or errors. + * + * Concatenate the chunks into a single {@link Blob}. + * + * @param stream The stream to consume. + * @returns A promise that resolves with the concatenated chunks as a {@link Blob}. + */ + export function readableStreamToBlob(stream: ReadableStream): Promise; + + /** + * Consume all data from a {@link ReadableStream} until it closes or errors. + * + * Concatenate the chunks into a single string. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}. + * + * @param stream The stream to consume. + * @returns A promise that resolves with the concatenated chunks as a {@link String}. + */ + export function readableStreamToText(stream: ReadableStream): Promise; + + /** + * Consume all data from a {@link ReadableStream} until it closes or errors. + * + * Concatenate the chunks into a single string and parse as JSON. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}. + * + * @param stream The stream to consume. + * @returns A promise that resolves with the concatenated chunks as a {@link String}. + */ + export function readableStreamToJSON(stream: ReadableStream): Promise; + + /** + * Consume all data from a {@link ReadableStream} until it closes or errors. + * + * @param stream The stream to consume + * @returns A promise that resolves with the chunks as an array + * + */ + export function readableStreamToArray( + stream: ReadableStream, + ): Promise | T[]; + + /** + * Escape the following characters in a string: + * + * - `"` becomes `"""` + * - `&` becomes `"&"` + * - `'` becomes `"'"` + * - `<` becomes `"<"` + * - `>` becomes `">"` + * + * This function is optimized for large input. On an M1X, it processes 480 MB/s - + * 20 GB/s, depending on how much data is being escaped and whether there is non-ascii + * text. + * + * Non-string types will be converted to a string before escaping. + */ + export function escapeHTML(input: string | object | number | boolean): string; + + /** + * Convert a filesystem path to a file:// URL. + * + * @param path The path to convert. + * @returns A {@link URL} with the file:// scheme. + * + * @example + * ```js + * const url = Bun.pathToFileURL("/foo/bar.txt"); + * console.log(url.href); // "file:///foo/bar.txt" + *``` + * + * Internally, this function uses WebKit's URL API to + * convert the path to a file:// URL. + */ + export function pathToFileURL(path: string): URL; + + export interface Peek { + (promise: T | Promise): Promise | T; + status( + promise: T | Promise, + ): "pending" | "fulfilled" | "rejected"; + } + /** + * Extract the value from the Promise in the same tick of the event loop + */ + export const peek: Peek; + + /** + * Convert a {@link URL} to a filesystem path. + * @param url The URL to convert. + * @returns A filesystem path. + * @throws If the URL is not a URL. + * @example + * ```js + * const path = Bun.fileURLToPath(new URL("file:///foo/bar.txt")); + * console.log(path); // "/foo/bar.txt" + * ``` + */ + export function fileURLToPath(url: URL): string; + + /** + * Fast incremental writer that becomes an `ArrayBuffer` on end(). + */ + export class ArrayBufferSink { + constructor(); + + start(options?: { + asUint8Array?: boolean; + /** + * Preallocate an internal buffer of this size + * This can significantly improve performance when the chunk size is small + */ + highWaterMark?: number; + /** + * On {@link ArrayBufferSink.flush}, return the written data as a `Uint8Array`. + * Writes will restart from the beginning of the buffer. + */ + stream?: boolean; + }): void; + + write(chunk: string | ArrayBufferView | ArrayBuffer): number; + /** + * Flush the internal buffer + * + * If {@link ArrayBufferSink.start} was passed a `stream` option, this will return a `ArrayBuffer` + * If {@link ArrayBufferSink.start} was passed a `stream` option and `asUint8Array`, this will return a `Uint8Array` + * Otherwise, this will return the number of bytes written since the last flush + * + * This API might change later to separate Uint8ArraySink and ArrayBufferSink + */ + flush(): number | Uint8Array | ArrayBuffer; + end(): ArrayBuffer | Uint8Array; + } + + /** + * Fast incremental writer for files and pipes. + * + * This uses the same interface as {@link ArrayBufferSink}, but writes to a file or pipe. + */ + export interface FileSink { + /** + * Write a chunk of data to the file. + * + * If the file descriptor is not writable yet, the data is buffered. + */ + write(chunk: string | ArrayBufferView | ArrayBuffer): number; + /** + * Flush the internal buffer, committing the data to disk or the pipe. + */ + flush(): number | Promise; + /** + * Close the file descriptor. This also flushes the internal buffer. + */ + end(error?: Error): number | Promise; + } + + /** + * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files. + * + * This Blob is lazy. That means it won't do any work until you read from it. + * + * - `size` will not be valid until the contents of the file are read at least once. + * - `type` is auto-set based on the file extension when possible + * + * @example + * ```js + * const file = Bun.file("./hello.json"); + * console.log(file.type); // "application/json" + * console.log(await file.text()); // '{"hello":"world"}' + * ``` + * + * @example + * ```js + * await Bun.write( + * Bun.file("./hello.txt"), + * "Hello, world!" + * ); + * ``` + * + */ + export interface FileBlob extends Blob { + /** + * Offset any operation on the file starting at `begin` and ending at `end`. `end` is relative to 0 + * + * Similar to [`TypedArray.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray). Does not copy the file, open the file, or modify the file. + * + * If `begin` > 0, {@link Bun.write()} will be slower on macOS + * + * @param begin - start offset in bytes + * @param end - absolute offset in bytes (relative to 0) + */ + slice(begin?: number, end?: number): FileBlob; + + /** + * Incremental writer for files and pipes. + */ + writer(options?: { highWaterMark?: number }): FileSink; + + readonly readable: ReadableStream; + + // TODO: writable: WritableStream; + } + + /** + * This lets you use macros as regular imports + * @example + * ``` + * { + * "react-relay": { + * "graphql": "bun-macro-relay/bun-macro-relay.tsx" + * } + * } + * ``` + */ + export type MacroMap = Record>; + + /** + * Hash a string or array buffer using Wyhash + * + * This is not a cryptographic hash function. + * @param data The data to hash. + * @param seed The seed to use. + */ + export const hash: (( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint) & + Hash; + + interface Hash { + wyhash: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + crc32: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + adler32: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + cityHash32: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + cityHash64: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + murmur32v3: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + murmur64v2: ( + data: string | ArrayBufferView | ArrayBuffer, + seed?: number, + ) => number | bigint; + } + + export type Platform = + /** + * When building for bun.js + */ + | "bun" + /** + * When building for the web + */ + | "browser" + /** + * When building for node.js + */ + | "node" + | "neutral"; + + export type JavaScriptLoader = "jsx" | "js" | "ts" | "tsx"; + + export interface TranspilerOptions { + /** + * Replace key with value. Value must be a JSON string. + * @example + * ``` + * { "process.env.NODE_ENV": "\"production\"" } + * ``` + */ + define?: Record; + + /** What is the default loader used for this transpiler? */ + loader?: JavaScriptLoader; + + /** What platform are we targeting? This may affect how import and/or require is used */ + /** @example "browser" */ + platform?: Platform; + + /** + * TSConfig.json file as stringified JSON or an object + * Use this to set a custom JSX factory, fragment, or import source + * For example, if you want to use Preact instead of React. Or if you want to use Emotion. + */ + tsconfig?: string; + + /** + * Replace an import statement with a macro. + * + * This will remove the import statement from the final output + * and replace any function calls or template strings with the result returned by the macro + * + * @example + * ```json + * { + * "react-relay": { + * "graphql": "bun-macro-relay" + * } + * } + * ``` + * + * Code that calls `graphql` will be replaced with the result of the macro. + * + * ```js + * import {graphql} from "react-relay"; + * + * // Input: + * const query = graphql` + * query { + * ... on User { + * id + * } + * } + * }`; + * ``` + * + * Will be replaced with: + * + * ```js + * import UserQuery from "./UserQuery.graphql"; + * const query = UserQuery; + * ``` + */ + macros?: MacroMap; + + autoImportJSX?: boolean; + allowBunRuntime?: boolean; + exports?: { + eliminate?: string[]; + replace?: Record; + }; + treeShaking?: boolean; + trimUnusedImports?: boolean; + jsxOptimizationInline?: boolean; + } + + /** + * Quickly transpile TypeScript, JSX, or JS to modern JavaScript. + * + * @example + * ```js + * const transpiler = new Bun.Transpiler(); + * transpiler.transformSync(` + * const App = () =>
Hello World
; + *export default App; + * `); + * // This outputs: + * const output = ` + * const App = () => jsx("div", { + * children: "Hello World" + * }, undefined, false, undefined, this); + *export default App; + * ` + * ``` + * + */ + export class Transpiler { + constructor(options: TranspilerOptions); + + /** + * Transpile code from TypeScript or JSX into valid JavaScript. + * This function does not resolve imports. + * @param code The code to transpile + */ + transform(code: StringOrBuffer, loader?: JavaScriptLoader): Promise; + /** + * Transpile code from TypeScript or JSX into valid JavaScript. + * This function does not resolve imports. + * @param code The code to transpile + * + */ + transformSync( + code: StringOrBuffer, + loader: JavaScriptLoader, + ctx: object, + ): string; + /** + * Transpile code from TypeScript or JSX into valid JavaScript. + * This function does not resolve imports. + * @param code The code to transpile + * @param ctx An object to pass to macros + * + */ + transformSync(code: StringOrBuffer, ctx: object): string; + + /** + * Transpile code from TypeScript or JSX into valid JavaScript. + * This function does not resolve imports. + * @param code The code to transpile + * + */ + transformSync(code: StringOrBuffer, loader: JavaScriptLoader): string; + + /** + * Get a list of import paths and paths from a TypeScript, JSX, TSX, or JavaScript file. + * @param code The code to scan + * @example + * ```js + * const {imports, exports} = transpiler.scan(` + * import {foo} from "baz"; + * const hello = "hi!"; + * `); + * + * console.log(imports); // ["baz"] + * console.log(exports); // ["hello"] + * ``` + */ + scan(code: StringOrBuffer): { exports: string[]; imports: Import[] }; + + /** + * Get a list of import paths from a TypeScript, JSX, TSX, or JavaScript file. + * @param code The code to scan + * @example + * ```js + * const imports = transpiler.scanImports(` + * import {foo} from "baz"; + * import type {FooType} from "bar"; + * import type {DogeType} from "wolf"; + * `); + * + * console.log(imports); // ["baz"] + * ``` + * This is a fast path which performs less work than `scan`. + */ + scanImports(code: StringOrBuffer): Import[]; + } + + export interface Import { + path: string; + + kind: + | "import-statement" + | "require-call" + | "require-resolve" + | "dynamic-import" + | "import-rule" + | "url-token" + | "internal" + | "entry-point"; + } + + /** + * **0** means the message was **dropped** + * + * **-1** means **backpressure** + * + * **> 0** is the **number of bytes sent** + * + */ + type ServerWebSocketSendStatus = 0 | -1 | number; + + /** + * Fast WebSocket API designed for server environments. + * + * Features: + * - **Message compression** - Messages can be compressed + * - **Backpressure** - If the client is not ready to receive data, the server will tell you. + * - **Dropped messages** - If the client cannot receive data, the server will tell you. + * - **Topics** - Messages can be {@link ServerWebSocket.publish}ed to a specific topic and the client can {@link ServerWebSocket.subscribe} to topics + * + * This is slightly different than the browser {@link WebSocket} which Bun supports for clients. + * + * Powered by [uWebSockets](https://github.com/uNetworking/uWebSockets) + */ + export interface ServerWebSocket { + /** + * + * Send a message to the client. + * + * @param data The message to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * @example + * + * ```js + * const status = ws.send("Hello World"); + * if (status === 0) { + * console.log("Message was dropped"); + * } else if (status === -1) { + * console.log("Backpressure was applied"); + * } else { + * console.log(`Message sent! ${status} bytes sent`); + * } + * ``` + * + * @example + * + * ```js + * ws.send("Feeling very compressed", true); + * ``` + * + * @example + * + * ```js + * ws.send(new Uint8Array([1, 2, 3, 4])); + * ``` + * + * @example + * + * ```js + * ws.send(new ArrayBuffer(4)); + * ``` + * + * @example + * + * ```js + * ws.send(new DataView(new ArrayBuffer(4))); + * ``` + * + */ + send( + data: string | ArrayBufferView | ArrayBuffer, + compress?: boolean, + ): ServerWebSocketSendStatus; + + /** + * + * Send a message to the client. + * + * This function is the same as {@link ServerWebSocket.send} but it only accepts a string. This function includes a fast path. + * + * @param data The message to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * @example + * + * ```js + * const status = ws.send("Hello World"); + * if (status === 0) { + * console.log("Message was dropped"); + * } else if (status === -1) { + * console.log("Backpressure was applied"); + * } else { + * console.log(`Message sent! ${status} bytes sent`); + * } + * ``` + * + * @example + * + * ```js + * ws.send("Feeling very compressed", true); + * ``` + * + * + */ + sendText(data: string, compress?: boolean): ServerWebSocketSendStatus; + + /** + * + * Send a message to the client. + * + * This function is the same as {@link ServerWebSocket.send} but it only accepts Uint8Array. + * + * @param data The message to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * + * ```js + * ws.sendBinary(new Uint8Array([1, 2, 3, 4])); + * ``` + * + * @example + * + * ```js + * ws.sendBinary(new ArrayBuffer(4)); + * ``` + * + * @example + * + * ```js + * ws.sendBinary(new DataView(new ArrayBuffer(4))); + * ``` + * + */ + sendBinary(data: Uint8Array, compress?: boolean): ServerWebSocketSendStatus; + + /** + * Gently close the connection. + * + * @param code The close code + * + * @param reason The close reason + * + * To close the connection abruptly, use `close(0, "")` + */ + close(code?: number, reason?: string): void; + + /** + * Send a message to all subscribers of a topic + * + * @param topic The topic to publish to + * @param data The data to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * @example + * + * ```js + * ws.publish("chat", "Hello World"); + * ``` + * + * @example + * ```js + * ws.publish("chat", new Uint8Array([1, 2, 3, 4])); + * ``` + * + * @example + * ```js + * ws.publish("chat", new ArrayBuffer(4), true); + * ``` + * + * @example + * ```js + * ws.publish("chat", new DataView(new ArrayBuffer(4))); + * ``` + */ + publish( + topic: string, + data: string | ArrayBufferView | ArrayBuffer, + compress?: boolean, + ): ServerWebSocketSendStatus; + + /** + * Send a message to all subscribers of a topic + * + * This function is the same as {@link publish} but only accepts string input. This function has a fast path. + * + * @param topic The topic to publish to + * @param data The data to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * @example + * + * ```js + * ws.publishText("chat", "Hello World"); + * ``` + * + */ + publishText( + topic: string, + data: string, + compress?: boolean, + ): ServerWebSocketSendStatus; + + /** + * Send a message to all subscribers of a topic + * + * This function is the same as {@link publish} but only accepts a Uint8Array. This function has a fast path. + * + * @param topic The topic to publish to + * @param data The data to send + * @param compress Should the data be compressed? Ignored if the client does not support compression. + * + * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent. + * + * @example + * + * ```js + * ws.publishBinary("chat", "Hello World"); + * ``` + * + * @example + * ```js + * ws.publishBinary("chat", new Uint8Array([1, 2, 3, 4])); + * ``` + * + * @example + * ```js + * ws.publishBinary("chat", new ArrayBuffer(4), true); + * ``` + * + * @example + * ```js + * ws.publishBinary("chat", new DataView(new ArrayBuffer(4))); + * ``` + */ + publishBinary( + topic: string, + data: Uint8Array, + compress?: boolean, + ): ServerWebSocketSendStatus; + + /** + * Subscribe to a topic + * @param topic The topic to subscribe to + * + * @example + * ```js + * ws.subscribe("chat"); + * ``` + */ + subscribe(topic: string): void; + + /** + * Unsubscribe from a topic + * @param topic The topic to unsubscribe from + * + * @example + * ```js + * ws.unsubscribe("chat"); + * ``` + * + */ + unsubscribe(topic: string): void; + + /** + * Is the socket subscribed to a topic? + * @param topic The topic to check + * + * @returns `true` if the socket is subscribed to the topic, `false` otherwise + */ + isSubscribed(topic: string): boolean; + + /** + * The remote address of the client + * @example + * ```js + * console.log(socket.remoteAddress); // "127.0.0.1" + * ``` + */ + readonly remoteAddress: string; + + /** + * Ready state of the socket + * + * @example + * ```js + * console.log(socket.readyState); // 1 + * ``` + */ + readonly readyState: -1 | 0 | 1 | 2 | 3; + + /** + * The data from the {@link Server.upgrade} function + * + * Put any data you want to share between the `fetch` function and the websocket here. + * + * You can read/write to this property at any time. + */ + data: T; + + /** + * Batch data sent to a {@link ServerWebSocket} + * + * This makes it significantly faster to {@link ServerWebSocket.send} or {@link ServerWebSocket.publish} multiple messages + * + * The `message`, `open`, and `drain` callbacks are automatically corked, so + * you only need to call this if you are sending messages outside of those + * callbacks or in async functions + */ + cork: (callback: (ws: ServerWebSocket) => any) => void | Promise; + + /** + * Configure the {@link WebSocketHandler.message} callback to return a {@link ArrayBuffer} instead of a {@link Uint8Array} + * + * @default "uint8array" + */ + binaryType?: "arraybuffer" | "uint8array"; + } + + type WebSocketCompressor = + | "disable" + | "shared" + | "dedicated" + | "3KB" + | "4KB" + | "8KB" + | "16KB" + | "32KB" + | "64KB" + | "128KB" + | "256KB"; + + /** + * Create a server-side {@link ServerWebSocket} handler for use with {@link Bun.serve} + * + * @example + * ```ts + * import { websocket, serve } from "bun"; + * + * serve({ + * port: 3000, + * websocket: websocket<{name: string}>({ + * open: (ws) => { + * console.log("Client connected"); + * }, + * message: (ws, message) => { + * console.log(`${ws.data.name}: ${message}`); + * }, + * close: (ws) => { + * console.log("Client disconnected"); + * }, + * }), + * + * fetch(req, server) { + * if (req.url === "/chat") { + * const upgraded = server.upgrade(req, { + * data: { + * name: new URL(req.url).searchParams.get("name"), + * }, + * }); + * if (!upgraded) { + * return new Response("Upgrade failed", { status: 400 }); + * } + * return; + * } + * return new Response("Hello World"); + * }, + * }); + */ + export interface WebSocketHandler { + /** + * Handle an incoming message to a {@link ServerWebSocket} + * + * @param ws The {@link ServerWebSocket} that received the message + * @param message The message received + * + * To change `message` to be an `ArrayBuffer` instead of a `Uint8Array`, set `ws.binaryType = "arraybuffer"` + */ + message: ( + ws: ServerWebSocket, + message: string | Uint8Array, + ) => void | Promise; + + /** + * The {@link ServerWebSocket} has been opened + * + * @param ws The {@link ServerWebSocket} that was opened + */ + open?: (ws: ServerWebSocket) => void | Promise; + /** + * The {@link ServerWebSocket} is ready for more data + * + * @param ws The {@link ServerWebSocket} that is ready + */ + drain?: (ws: ServerWebSocket) => void | Promise; + /** + * The {@link ServerWebSocket} is being closed + * @param ws The {@link ServerWebSocket} that was closed + * @param code The close code + * @param message The close message + */ + close?: ( + ws: ServerWebSocket, + code: number, + message: string, + ) => void | Promise; + + /** + * Enable compression for clients that support it. By default, compression is disabled. + * + * @default false + * + * `true` is equivalent to `"shared" + */ + perMessageDeflate?: + | true + | false + | { + /** + * Enable compression on the {@link ServerWebSocket} + * + * @default false + * + * `true` is equivalent to `"shared" + */ + compress?: WebSocketCompressor | false | true; + /** + * Configure decompression + * + * @default false + * + * `true` is equivalent to `"shared" + */ + decompress?: WebSocketCompressor | false | true; + }; + + /** + * The maximum size of a message + */ + maxPayloadLength?: number; + /** + * After a connection has not received a message for this many seconds, it will be closed. + * @default 120 (2 minutes) + */ + idleTimeout?: number; + /** + * The maximum number of bytes that can be buffered for a single connection. + * @default 16MB + */ + backpressureLimit?: number; + /** + * Close the connection if the backpressure limit is reached. + * @default false + * @see {@link backpressureLimit} + * @see {@link ServerWebSocketSendStatus} + * @see {@link ServerWebSocket.send} + * @see {@link ServerWebSocket.publish} + */ + closeOnBackpressureLimit?: boolean; + } + + interface GenericServeOptions { + /** + * What port should the server listen on? + * @default process.env.PORT || "3000" + */ + port?: string | number; + + /** + * What hostname should the server listen on? + * + * @default + * ```js + * "0.0.0.0" // listen on all interfaces + * ``` + * @example + * ```js + * "127.0.0.1" // Only listen locally + * ``` + * @example + * ```js + * "remix.run" // Only listen on remix.run + * ```` + * + * note: hostname should not include a {@link port} + */ + hostname?: string; + + /** + * What URI should be used to make {@link Request.url} absolute? + * + * By default, looks at {@link hostname}, {@link port}, and whether or not SSL is enabled to generate one + * + * @example + *```js + * "http://my-app.com" + * ``` + * + * @example + *```js + * "https://wongmjane.com/" + * ``` + * + * This should be the public, absolute URL – include the protocol and {@link hostname}. If the port isn't 80 or 443, then include the {@link port} too. + * + * @example + * "http://localhost:3000" + * + */ + baseURI?: string; + + /** + * What is the maximum size of a request body? (in bytes) + * @default 1024 * 1024 * 128 // 128MB + */ + maxRequestBodySize?: number; + + /** + * Render contextual errors? This enables bun's error page + * @default process.env.NODE_ENV !== 'production' + */ + development?: boolean; + + error?: ( + this: Server, + request: Errorlike, + ) => Response | Promise | undefined | void | Promise; + } + + export interface ServeOptions extends GenericServeOptions { + /** + * Handle HTTP requests + * + * Respond to {@link Request} objects with a {@link Response} object. + * + */ + fetch( + this: Server, + request: Request, + server: Server, + ): Response | Promise; + } + + export interface WebSocketServeOptions + extends GenericServeOptions { + /** + * Enable websockets with {@link Bun.serve} + * + * For simpler type safety, see {@link Bun.websocket} + * + * @example + * ```js + *import { serve, websocket } from "bun"; + *serve({ + * websocket: websocket({ + * open: (ws) => { + * console.log("Client connected"); + * }, + * message: (ws, message) => { + * console.log("Client sent message", message); + * }, + * close: (ws) => { + * console.log("Client disconnected"); + * }, + * }), + * fetch(req, server) { + * if (req.url === "/chat") { + * const upgraded = server.upgrade(req); + * if (!upgraded) { + * return new Response("Upgrade failed", { status: 400 }); + * } + * } + * return new Response("Hello World"); + * }, + *}); + *``` + * Upgrade a {@link Request} to a {@link ServerWebSocket} via {@link Server.upgrade} + * + * Pass `data` in @{link Server.upgrade} to attach data to the {@link ServerWebSocket.data} property + * + * + */ + websocket: WebSocketHandler; + + /** + * Handle HTTP requests or upgrade them to a {@link ServerWebSocket} + * + * Respond to {@link Request} objects with a {@link Response} object. + * + */ + fetch( + this: Server, + request: Request, + server: Server, + ): Response | undefined | Promise; + } + + export interface Errorlike extends Error { + code?: string; + errno?: number; + syscall?: string; + } + + interface TLSOptions { + /** + * File path to a TLS key + * + * To enable TLS, this option is required. + */ + keyFile: string; + /** + * File path to a TLS certificate + * + * To enable TLS, this option is required. + */ + certFile: string; + + passphrase?: string; + caFile?: string; + dhParamsFile?: string; + + /** + * This sets `OPENSSL_RELEASE_BUFFERS` to 1. + * It reduces overall performance but saves some memory. + * @default false + */ + lowMemoryMode?: boolean; + } + + export type TLSServeOptions = ( + | WebSocketServeOptions + | ServerWebSocket + ) & + TLSOptions & { + /** + * The keys are [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) hostnames. + * The values are SSL options objects. + */ + serverNames: Record; + }; + + /** + * HTTP & HTTPS Server + * + * To start the server, see {@link serve} + * + * For performance, Bun pre-allocates most of the data for 2048 concurrent requests. + * That means starting a new server allocates about 500 KB of memory. Try to + * avoid starting and stopping the server often (unless it's a new instance of bun). + * + * Powered by a fork of [uWebSockets](https://github.com/uNetworking/uWebSockets). Thank you @alexhultman. + * + */ + export interface Server { + /** + * Stop listening to prevent new connections from being accepted. + * + * It does not close existing connections. + * + * It may take a second or two to actually stop. + */ + stop(): void; + + /** + * Update the `fetch` and `error` handlers without restarting the server. + * + * This is useful if you want to change the behavior of your server without + * restarting it or for hot reloading. + * + * @example + * + * ```js + * // create the server + * const server = Bun.serve({ + * fetch(request) { + * return new Response("Hello World v1") + * } + * }); + * + * // Update the server to return a different response + * server.update({ + * fetch(request) { + * return new Response("Hello World v2") + * } + * }); + * ``` + * + * Passing other options such as `port` or `hostname` won't do anything. + */ + reload(options: Serve): void; + + /** + * Mock the fetch handler for a running server. + * + * This feature is not fully implemented yet. It doesn't normalize URLs + * consistently in all cases and it doesn't yet call the `error` handler + * consistently. This needs to be fixed + */ + fetch(request: Request): Response | Promise; + + /** + * Upgrade a {@link Request} to a {@link ServerWebSocket} + * + * @param request The {@link Request} to upgrade + * @param options Pass headers or attach data to the {@link ServerWebSocket} + * + * @returns `true` if the upgrade was successful and `false` if it failed + * + * @example + * ```js + * import { serve, websocket } from "bun"; + * serve({ + * websocket: websocket({ + * open: (ws) => { + * console.log("Client connected"); + * }, + * message: (ws, message) => { + * console.log("Client sent message", message); + * }, + * close: (ws) => { + * console.log("Client disconnected"); + * }, + * }), + * fetch(req, server) { + * if (req.url === "/chat") { + * const upgraded = server.upgrade(req); + * if (!upgraded) { + * return new Response("Upgrade failed", { status: 400 }); + * } + * } + * return new Response("Hello World"); + * }, + * }); + * ``` + * What you pass to `data` is available on the {@link ServerWebSocket.data} property + * + */ + upgrade( + request: Request, + options?: { + /** + * Send any additional headers while upgrading, like cookies + */ + headers?: HeadersInit; + /** + * This value is passed to the {@link ServerWebSocket.data} property + */ + data?: T; + }, + ): boolean; + + /** + * How many requests are in-flight right now? + */ + readonly pendingRequests: number; + + /** + * How many {@link ServerWebSocket}s are in-flight right now? + */ + readonly pendingWebSockets: number; + + readonly port: number; + /** + * The hostname the server is listening on. Does not include the port + * @example + * ```js + * "localhost" + * ``` + */ + readonly hostname: string; + /** + * Is the server running in development mode? + * + * In development mode, `Bun.serve()` returns rendered error messages with + * stack traces instead of a generic 500 error. This makes debugging easier, + * but development mode shouldn't be used in production or you will risk + * leaking sensitive information. + * + */ + readonly development: boolean; + } + + export type Serve = + | TLSServeOptions + | WebSocketServeOptions + | ServeOptions; + + /** + * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files. + * + * This Blob is lazy. That means it won't do any work until you read from it. + * + * - `size` will not be valid until the contents of the file are read at least once. + * - `type` is auto-set based on the file extension when possible + * + * @example + * ```js + * const file = Bun.file("./hello.json"); + * console.log(file.type); // "application/json" + * console.log(await file.json()); // { hello: "world" } + * ``` + * + * @example + * ```js + * await Bun.write( + * Bun.file("./hello.txt"), + * "Hello, world!" + * ); + * ``` + * @param path The path to the file (lazily loaded) + * + */ + // tslint:disable-next-line:unified-signatures + export function file(path: string, options?: BlobPropertyBag): FileBlob; + + /** + * `Blob` that leverages the fastest system calls available to operate on files. + * + * This Blob is lazy. It won't do any work until you read from it. Errors propagate as promise rejections. + * + * `Blob.size` will not be valid until the contents of the file are read at least once. + * `Blob.type` will have a default set based on the file extension + * + * @example + * ```js + * const file = Bun.file(new TextEncoder.encode("./hello.json")); + * console.log(file.type); // "application/json" + * ``` + * + * @param path The path to the file as a byte buffer (the buffer is copied) + */ + // tslint:disable-next-line:unified-signatures + export function file( + path: ArrayBufferLike | Uint8Array, + options?: BlobPropertyBag, + ): FileBlob; + + /** + * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files. + * + * This Blob is lazy. That means it won't do any work until you read from it. + * + * - `size` will not be valid until the contents of the file are read at least once. + * + * @example + * ```js + * const file = Bun.file(fd); + * ``` + * + * @param fileDescriptor The file descriptor of the file + */ + // tslint:disable-next-line:unified-signatures + export function file( + fileDescriptor: number, + options?: BlobPropertyBag, + ): FileBlob; + + /** + * Allocate a new [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) without zeroing the bytes. + * + * This can be 3.5x faster than `new Uint8Array(size)`, but if you send uninitialized memory to your users (even unintentionally), it can potentially leak anything recently in memory. + */ + export function allocUnsafe(size: number): Uint8Array; + + /** + * Pretty-print an object the same as {@link console.log} to a `string` + * + * Supports JSX + * + * @param args + */ + export function inspect(...args: any): string; + + interface MMapOptions { + /** + * Sets MAP_SYNC flag on Linux. Ignored on macOS due to lack of support. + */ + sync?: boolean; + /** + * Allow other processes to see results instantly? + * This enables MAP_SHARED. If false, it enables MAP_PRIVATE. + * @default true + */ + shared?: boolean; + } + /** + * Open a file as a live-updating `Uint8Array` without copying memory + * - Writing to the array writes to the file. + * - Reading from the array reads from the file. + * + * This uses the [`mmap()`](https://man7.org/linux/man-pages/man2/mmap.2.html) syscall under the hood. + * + * --- + * + * This API inherently has some rough edges: + * - It does not support empty files. It will throw a `SystemError` with `EINVAL` + * - Usage on shared/networked filesystems is discouraged. It will be very slow. + * - If you delete or truncate the file, that will crash bun. This is called a segmentation fault. + * + * --- + * + * To close the file, set the array to `null` and it will be garbage collected eventually. + * + */ + export function mmap(path: PathLike, opts?: MMapOptions): Uint8Array; + + /** Write to stdout */ + const stdout: FileBlob; + /** Write to stderr */ + const stderr: FileBlob; + /** + * Read from stdin + * + * This is read-only + */ + const stdin: FileBlob; + + interface unsafe { + /** + * Cast bytes to a `String` without copying. This is the fastest way to get a `String` from a `Uint8Array` or `ArrayBuffer`. + * + * **Only use this for ASCII strings**. If there are non-ascii characters, your application may crash and/or very confusing bugs will happen such as `"foo" !== "foo"`. + * + * **The input buffer must not be garbage collected**. That means you will need to hold on to it for the duration of the string's lifetime. + * + */ + arrayBufferToString(buffer: Uint8Array | ArrayBufferLike): string; + + /** + * Cast bytes to a `String` without copying. This is the fastest way to get a `String` from a `Uint16Array` + * + * **The input must be a UTF-16 encoded string**. This API does no validation whatsoever. + * + * **The input buffer must not be garbage collected**. That means you will need to hold on to it for the duration of the string's lifetime. + * + */ + // tslint:disable-next-line:unified-signatures + arrayBufferToString(buffer: Uint16Array): string; + + /** Mock bun's segfault handler. You probably don't want to use this */ + segfault(): void; + } + export const unsafe: unsafe; + + type DigestEncoding = "hex" | "base64"; + + /** + * Are ANSI colors enabled for stdin and stdout? + * + * Used for {@link console.log} + */ + export const enableANSIColors: boolean; + + /** + * What script launched bun? + * + * Absolute file path + * + * @example "/never-gonna-give-you-up.js" + */ + export const main: string; + + /** + * Manually trigger the garbage collector + * + * This does two things: + * 1. It tells JavaScriptCore to run the garbage collector + * 2. It tells [mimalloc](https://github.com/microsoft/mimalloc) to clean up fragmented memory. Mimalloc manages the heap not used in JavaScriptCore. + * + * @param force Synchronously run the garbage collector + */ + export function gc(force: boolean): void; + + /** + * JavaScriptCore engine's internal heap snapshot + * + * I don't know how to make this something Chrome or Safari can read. + * + * If you have any ideas, please file an issue https://github.com/oven-sh/bun + */ + interface HeapSnapshot { + /** "2" */ + version: string; + + /** "Inspector" */ + type: string; + + nodes: number[]; + + nodeClassNames: string[]; + edges: number[]; + edgeTypes: string[]; + edgeNames: string[]; + } + + /** + * Nanoseconds since Bun.js was started as an integer. + * + * This uses a high-resolution monotonic system timer. + * + * After 14 weeks of consecutive uptime, this function + * wraps + */ + export function nanoseconds(): number; + + /** + * Generate a heap snapshot for seeing where the heap is being used + */ + export function generateHeapSnapshot(): HeapSnapshot; + + /** + * The next time JavaScriptCore is idle, clear unused memory and attempt to reduce the heap size. + */ + export function shrink(): void; + + /** + * Open a file in your local editor. Auto-detects via `$VISUAL` || `$EDITOR` + * + * @param path path to open + */ + export function openInEditor(path: string, options?: EditorOptions): void; + + interface EditorOptions { + editor?: "vscode" | "subl"; + line?: number; + column?: number; + } + + /** + * This class only exists in types + */ + abstract class CryptoHashInterface { + /** + * Update the hash with data + * + * @param data + */ + update(data: StringOrBuffer): T; + + /** + * Finalize the hash + * + * @param encoding `DigestEncoding` to return the hash in. If none is provided, it will return a `Uint8Array`. + */ + digest(encoding: DigestEncoding): string; + + /** + * Finalize the hash + * + * @param hashInto `TypedArray` to write the hash into. Faster than creating a new one each time + */ + digest(hashInto?: TypedArray): TypedArray; + + /** + * Run the hash over the given data + * + * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` is faster. + * + * @param hashInto `TypedArray` to write the hash into. Faster than creating a new one each time + */ + static hash(input: StringOrBuffer, hashInto?: TypedArray): TypedArray; + + /** + * Run the hash over the given data + * + * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` is faster. + * + * @param encoding `DigestEncoding` to return the hash in + */ + static hash(input: StringOrBuffer, encoding: DigestEncoding): string; + } + + /** + * Sleep the thread for a given number of milliseconds + * + * This is a blocking function. + * + * Internally, it calls [nanosleep(2)](https://man7.org/linux/man-pages/man2/nanosleep.2.html) + */ + export function sleepSync(ms: number): void; + + /** + * + * Hash `input` using [SHA-2 512/256](https://en.wikipedia.org/wiki/SHA-2#Comparison_of_SHA_functions) + * + * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` will be faster + * @param hashInto optional `Uint8Array` to write the hash to. 32 bytes minimum. + * + * This hashing function balances speed with cryptographic strength. This does not encrypt or decrypt data. + * + * The implementation uses [BoringSSL](https://boringssl.googlesource.com/boringssl) (used in Chromium & Go) + * + * The equivalent `openssl` command is: + * + * ```bash + * # You will need OpenSSL 3 or later + * openssl sha512-256 /path/to/file + *``` + */ + export function sha(input: StringOrBuffer, hashInto?: Uint8Array): Uint8Array; + + /** + * + * Hash `input` using [SHA-2 512/256](https://en.wikipedia.org/wiki/SHA-2#Comparison_of_SHA_functions) + * + * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` will be faster + * @param encoding `DigestEncoding` to return the hash in + * + * This hashing function balances speed with cryptographic strength. This does not encrypt or decrypt data. + * + * The implementation uses [BoringSSL](https://boringssl.googlesource.com/boringssl) (used in Chromium & Go) + * + * The equivalent `openssl` command is: + * + * ```bash + * # You will need OpenSSL 3 or later + * openssl sha512-256 /path/to/file + *``` + */ + export function sha(input: StringOrBuffer, encoding: DigestEncoding): string; + + /** + * This is not the default because it's not cryptographically secure and it's slower than {@link SHA512} + * + * Consider using the ugly-named {@link SHA512_256} instead + */ + export class SHA1 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 20; + } + export class MD5 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 16; + } + export class MD4 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 16; + } + export class SHA224 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 28; + } + export class SHA512 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 64; + } + export class SHA384 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 48; + } + export class SHA256 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 32; + } + /** + * See also {@link sha} + */ + export class SHA512_256 extends CryptoHashInterface { + constructor(); + + /** + * The number of bytes the hash will produce + */ + static readonly byteLength: 32; + } + + /** Compression options for `Bun.deflateSync` and `Bun.gzipSync` */ + export type ZlibCompressionOptions = { + /** + * The compression level to use. Must be between `-1` and `9`. + * - A value of `-1` uses the default compression level (Currently `6`) + * - A value of `0` gives no compression + * - A value of `1` gives least compression, fastest speed + * - A value of `9` gives best compression, slowest speed + */ + level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * How much memory should be allocated for the internal compression state. + * + * A value of `1` uses minimum memory but is slow and reduces compression ratio. + * + * A value of `9` uses maximum memory for optimal speed. The default is `8`. + */ + memLevel?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The base 2 logarithm of the window size (the size of the history buffer). + * + * Larger values of this parameter result in better compression at the expense of memory usage. + * + * The following value ranges are supported: + * - `9..15`: The output will have a zlib header and footer (Deflate) + * - `-9..-15`: The output will **not** have a zlib header or footer (Raw Deflate) + * - `25..31` (16+`9..15`): The output will have a gzip header and footer (gzip) + * + * The gzip header will have no file name, no extra data, no comment, no modification time (set to zero) and no header CRC. + */ + windowBits?: + | -9 + | -10 + | -11 + | -12 + | -13 + | -14 + | -15 + | 9 + | 10 + | 11 + | 12 + | 13 + | 14 + | 15 + | 25 + | 26 + | 27 + | 28 + | 29 + | 30 + | 31; + /** + * Tunes the compression algorithm. + * + * - `Z_DEFAULT_STRATEGY`: For normal data **(Default)** + * - `Z_FILTERED`: For data produced by a filter or predictor + * - `Z_HUFFMAN_ONLY`: Force Huffman encoding only (no string match) + * - `Z_RLE`: Limit match distances to one (run-length encoding) + * - `Z_FIXED` prevents the use of dynamic Huffman codes + * + * `Z_RLE` is designed to be almost as fast as `Z_HUFFMAN_ONLY`, but give better compression for PNG image data. + * + * `Z_FILTERED` forces more Huffman coding and less string matching, it is + * somewhat intermediate between `Z_DEFAULT_STRATEGY` and `Z_HUFFMAN_ONLY`. + * Filtered data consists mostly of small values with a somewhat random distribution. + */ + strategy?: number; + }; + + /** + * Compresses a chunk of data with `zlib` DEFLATE algorithm. + * @param data The buffer of data to compress + * @param options Compression options to use + * @returns The output buffer with the compressed data + */ + export function deflateSync( + data: Uint8Array, + options?: ZlibCompressionOptions, + ): Uint8Array; + /** + * Compresses a chunk of data with `zlib` GZIP algorithm. + * @param data The buffer of data to compress + * @param options Compression options to use + * @returns The output buffer with the compressed data + */ + export function gzipSync( + data: Uint8Array, + options?: ZlibCompressionOptions, + ): Uint8Array; + /** + * Decompresses a chunk of data with `zlib` INFLATE algorithm. + * @param data The buffer of data to decompress + * @returns The output buffer with the decompressed data + */ + export function inflateSync(data: Uint8Array): Uint8Array; + /** + * Decompresses a chunk of data with `zlib` GUNZIP algorithm. + * @param data The buffer of data to decompress + * @returns The output buffer with the decompressed data + */ + export function gunzipSync(data: Uint8Array): Uint8Array; + + export type PluginTarget = + /** + * The default environment when using `bun run` or `bun` to load a script + */ + | "bun" + /** + * The plugin will be applied to Node.js builds + */ + | "node" + /** + * The plugin will be applied to browser builds + */ + | "browser"; + + interface PluginConstraints { + /** + * Only apply the plugin when the import specifier matches this regular expression + * + * @example + * ```ts + * // Only apply the plugin when the import specifier matches the regex + * Bun.plugin({ + * setup(builder) { + * builder.onLoad({ filter: /node_modules\/underscore/ }, (args) => { + * return { contents: "throw new Error('Please use lodash instead of underscore.')" }; + * }); + * } + * }) + * ``` + */ + filter: RegExp; + + /** + * Only apply the plugin when the import specifier has a namespace matching + * this string + * + * Namespaces are prefixes in import specifiers. For example, `"bun:ffi"` + * has the namespace `"bun"`. + * + * The default namespace is `"file"` and it can be omitted from import + * specifiers. + */ + namespace?: string; + } + + interface OnLoadResultSourceCode { + /** + * The source code of the module + */ + contents: string | ArrayBufferView | ArrayBuffer; + /** + * The loader to use for this file + * + * "css" will be added in a future version of Bun. + */ + loader: "js" | "jsx" | "ts" | "tsx"; + } + + interface OnLoadResultObject { + /** + * The object to use as the module + * @example + * ```ts + * // In your loader + * builder.onLoad({ filter: /^hello:world$/ }, (args) => { + * return { exports: { foo: "bar" }, loader: "object" }; + * }); + * + * // In your script + * import {foo} from "hello:world"; + * console.log(foo); // "bar" + * ``` + */ + exports: Record; + /** + * The loader to use for this file + */ + loader: "object"; + } + + interface OnLoadArgs { + /** + * The resolved import specifier of the module being loaded + * @example + * ```ts + * builder.onLoad({ filter: /^hello:world$/ }, (args) => { + * console.log(args.path); // "hello:world" + * return { exports: { foo: "bar" }, loader: "object" }; + * }); + * ``` + */ + path: string; + } + + type OnLoadResult = OnLoadResultSourceCode | OnLoadResultObject; + type OnLoadCallback = ( + args: OnLoadArgs, + ) => OnLoadResult | Promise; + + interface OnResolveArgs { + /** + * The import specifier of the module being loaded + */ + path: string; + /** + * The module that imported the module being resolved + */ + importer: string; + } + + interface OnResolveResult { + /** + * The destination of the import + */ + path: string; + /** + * The namespace of the destination + * It will be concatenated with `path` to form the final import specifier + * @example + * ```ts + * "foo" // "foo:bar" + * ``` + */ + namespace?: string; + } + + type OnResolveCallback = (args: OnResolveArgs) => OnResolveResult | void; + + interface PluginBuilder { + /** + * Register a callback to load imports with a specific import specifier + * @param constraints The constraints to apply the plugin to + * @param callback The callback to handle the import + * @example + * ```ts + * Bun.plugin({ + * setup(builder) { + * builder.onLoad({ filter: /^hello:world$/ }, (args) => { + * return { exports: { foo: "bar" }, loader: "object" }; + * }); + * }, + * }); + * ``` + */ + onLoad(constraints: PluginConstraints, callback: OnLoadCallback): void; + /** + * Register a callback to resolve imports matching a filter and/or namespace + * @param constraints The constraints to apply the plugin to + * @param callback The callback to handle the import + * @example + * ```ts + * Bun.plugin({ + * setup(builder) { + * builder.onResolve({ filter: /^wat$/ }, (args) => { + * return { path: "/tmp/woah.js" }; + * }); + * }, + * }); + * ``` + */ + onResolve( + constraints: PluginConstraints, + callback: OnResolveCallback, + ): void; + /** + * The current target environment + */ + target: PluginTarget; + } + + /** + * Extend Bun's module resolution and loading behavior + * + * Plugins are applied in the order they are defined. + * + * Today, there are two kinds of hooks: + * - `onLoad` lets you return source code or an object that will become the module's exports + * - `onResolve` lets you redirect a module specifier to another module specifier. It does not chain. + * + * Plugin hooks must define a `filter` RegExp and will only be matched if the + * import specifier contains a "." or a ":". + * + * ES Module resolution semantics mean that plugins may be initialized _after_ + * a module is resolved. You might need to load plugins at the very beginning + * of the application and then use a dynamic import to load the rest of the + * application. A future version of Bun may also support specifying plugins + * via `bunfig.toml`. + * + * + * @example + * A YAML loader plugin + * + * ```js + *Bun.plugin({ + * setup(builder) { + * builder.onLoad({ filter: /\.yaml$/ }, ({path}) => ({ + * loader: "object", + * exports: require("js-yaml").load(fs.readFileSync(path, "utf8")) + * })); + *}); + * + * // You can use require() + * const {foo} = require("./file.yaml"); + * + * // Or import + * await import("./file.yaml"); + * + * ``` + */ + interface BunPlugin { + (options: { + /** + * Human-readable name of the plugin + * + * In a future version of Bun, this will be used in error messages. + */ + name?: string; + + /** + * The target JavaScript environment the plugin should be applied to. + * - `bun`: The default environment when using `bun run` or `bun` to load a script + * - `browser`: The plugin will be applied to browser builds + * - `node`: The plugin will be applied to Node.js builds + * + * If in Bun's runtime, the default target is `bun`. + * + * If unspecified, it is assumed that the plugin is compatible with the default target. + */ + target?: PluginTarget; + /** + * A function that will be called when the plugin is loaded. + * + * This function may be called in the same tick that it is registered, or it may be called later. It could potentially be called multiple times for different targets. + */ + setup( + /** + * A builder object that can be used to register plugin hooks + * @example + * ```ts + * builder.onLoad({ filter: /\.yaml$/ }, ({ path }) => ({ + * loader: "object", + * exports: require("js-yaml").load(fs.readFileSync(path, "utf8")), + * })); + * ``` + */ + builder: PluginBuilder, + ): void | Promise; + }): ReturnType; + + /** + * Deactivate all plugins + * + * This prevents registered plugins from being applied to future builds. + */ + clearAll(): void; + } + + var plugin: BunPlugin; + + interface Socket { + /** + * Write `data` to the socket + * + * @param data The data to write to the socket + * @param byteOffset The offset in the buffer to start writing from (defaults to 0) + * @param byteLength The number of bytes to write (defaults to the length of the buffer) + * + * When passed a string, `byteOffset` and `byteLength` refer to the UTF-8 offset, not the string character offset. + * + * This is unbuffered as of Bun v0.2.2. That means individual write() calls + * will be slow. In the future, Bun will buffer writes and flush them at the + * end of the tick, when the event loop is idle, or sooner if the buffer is full. + */ + write( + data: string | BufferSource, + byteOffset?: number, + byteLength?: number, + ): number; + + /** + * The data context for the socket. + */ + data: Data; + + /** + * Like {@link Socket.write} except it includes a TCP FIN packet + * + * Use it to send your last message and close the connection. + */ + end( + data?: string | BufferSource, + byteOffset?: number, + byteLength?: number, + ): number; + + /** + * Close the socket immediately + */ + end(): void; + + /** + * Keep Bun's process alive at least until this socket is closed + * + * After the socket has closed, the socket is unref'd, the process may exit, + * and this becomes a no-op + */ + ref(): void; + + /** + * Set a timeout until the socket automatically closes. + * + * To reset the timeout, call this function again. + * + * When a timeout happens, the `timeout` callback is called and the socket is closed. + */ + timeout(seconds: number): void; + + /** + * Shutdown writes to a socket + * + * This makes the socket a half-closed socket. It can still receive data. + * + * This calls [shutdown(2)](https://man7.org/linux/man-pages/man2/shutdown.2.html) internally + */ + shutdown(halfClose?: boolean): void; + + readonly readyState: "open" | "closing" | "closed"; + + /** + * Allow Bun's process to exit even if this socket is still open + * + * After the socket has closed, this function does nothing. + */ + unref(): void; + + /** + * Reset the socket's callbacks. This is useful with `bun --hot` to facilitate hot reloading. + * + * This will apply to all sockets from the same {@link Listener}. it is per socket only for {@link Bun.connect}. + */ + reload(handler: SocketHandler): void; + + /** + * Get the server that created this socket + * + * This will return undefined if the socket was created by {@link Bun.connect} or if the listener has already closed. + */ + readonly listener?: SocketListener; + } + + interface SocketListener { + stop(): void; + ref(): void; + unref(): void; + reload(options: Pick, "socket">): void; + data: Options["data"]; + } + interface TCPSocketListener> + extends SocketListener { + readonly port: number; + readonly hostname: string; + } + interface UnixSocketListener> + extends SocketListener { + readonly unix: string; + } + + interface TCPSocket extends Socket {} + interface TLSSocket extends Socket {} + + interface SocketHandler { + open(socket: Socket): void | Promise; + close?(socket: Socket): void | Promise; + error?(socket: Socket, error: Error): void | Promise; + data?(socket: Socket, data: BufferSource): void | Promise; + drain?(socket: Socket): void | Promise; + } + + interface SocketOptions { + socket: SocketHandler; + tls?: TLSOptions; + data?: Data; + } + interface TCPSocketOptions extends SocketOptions { + hostname: string; + port: number; + } + + interface UnixSocketOptions extends SocketOptions { + unix: string; + } + + /** + * + * Create a TCP client that connects to a server + * + * @param options The options to use when creating the client + * @param options.socket The socket handler to use + * @param options.data The per-instance data context + * @param options.hostname The hostname to connect to + * @param options.port The port to connect to + * @param options.tls The TLS configuration object + * @param options.unix The unix socket to connect to + * + */ + export function connect( + options: TCPSocketOptions, + ): Promise>; + export function connect( + options: UnixSocketOptions, + ): Promise>; + + /** + * + * Create a TCP server that listens on a port + * + * @param options The options to use when creating the server + * @param options.socket The socket handler to use + * @param options.data The per-instance data context + * @param options.hostname The hostname to connect to + * @param options.port The port to connect to + * @param options.tls The TLS configuration object + * @param options.unix The unix socket to connect to + * + */ + export function listen( + options: TCPSocketOptions, + ): TCPSocketListener; + export function listen( + options: UnixSocketOptions, + ): UnixSocketListener; + + namespace SpawnOptions { + type Readable = + | "inherit" + | "ignore" + | "pipe" + | null + | undefined + | FileBlob + | ArrayBufferView + | number; + + type Writable = + | "inherit" + | "ignore" + | "pipe" + | null + | ReadableStream // supported by stdin + | undefined + | FileBlob + | ArrayBufferView + | Blob + | number + | Response + | Request; + + interface OptionsObject { + /** + * The current working directory of the process + * + * Defaults to `process.cwd()` + */ + cwd?: string; + + /** + * The environment variables of the process + * + * Defaults to `process.env` as it was when the current Bun process launched. + * + * Changes to `process.env` at runtime won't automatically be reflected in the default value. For that, you can pass `process.env` explicitly. + * + */ + env?: Record; + + /** + * The standard file descriptors of the process + * - `inherit`: The process will inherit the standard input of the current process + * - `pipe`: The process will have a new pipe for standard input + * - `null`: The process will have no standard input + * - `ArrayBufferView`, `Blob`: The process will read from the buffer + * - `number`: The process will read from the file descriptor + * - `undefined`: The default value + */ + stdio?: [ + SpawnOptions.Writable, + SpawnOptions.Readable, + SpawnOptions.Readable, + ]; + stdin?: SpawnOptions.Writable; + stdout?: SpawnOptions.Readable; + stderr?: SpawnOptions.Readable; + + /** + * Callback that runs when the {@link Subprocess} exits + * + * You can also do `await subprocess.exited` to wait for the process to exit. + * + * @example + * + * ```ts + * const subprocess = spawn({ + * cmd: ["echo", "hello"], + * onExit: (code) => { + * console.log(`Process exited with code ${code}`); + * }, + * }); + * ``` + */ + onExit?: (exitCode: number) => void | Promise; + } + } + + interface SubprocessIO { + readonly stdin?: undefined | number | ReadableStream | FileSink; + readonly stdout?: undefined | number | ReadableStream; + readonly stderr?: undefined | number | ReadableStream; + } + interface Subprocess { + readonly stdin: T["stdin"] | undefined; + readonly stdout: T["stdout"] | undefined; + readonly stderr: T["stderr"] | undefined; + + /** + * This returns the same value as {@link Subprocess.stdout} + * + * It exists for compatibility with {@link ReadableStream.pipeThrough} + */ + readonly readable: T["stdout"] | undefined; + + /** + * The process ID of the child process + * @example + * ```ts + * const { pid } = Bun.spawn({ cmd: ["echo", "hello"] }); + * console.log(pid); // 1234 + * ``` + */ + readonly pid: number; + /** + * The exit code of the process + * + * The promise will resolve when the process exits + */ + readonly exited: Promise; + + /** + * Has the process exited? + */ + readonly killed: boolean; + + /** + * Kill the process + * @param exitCode The exitCode to send to the process + */ + kill(exitCode?: number): void; + + /** + * This method will tell Bun to wait for this process to exit after you already + * called `unref()`. + * + * Before shutting down, Bun will wait for all subprocesses to exit by default + */ + ref(): void; + + /** + * Before shutting down, Bun will wait for all subprocesses to exit by default + * + * This method will tell Bun to not wait for this process to exit before shutting down. + */ + unref(): void; + } + + interface SyncSubprocess { + stdout?: Buffer; + stderr?: Buffer; + exitCode: number; + success: boolean; + } + + /** + * Spawn a new process + * + * ```js + * const subprocess = Bun.spawn({ + * cmd: ["echo", "hello"], + * stdout: "pipe", + * }); + * const text = await readableStreamToText(subprocess.stdout); + * console.log(text); // "hello\n" + * ``` + * + * Internally, this uses [posix_spawn(2)](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/posix_spawn.2.html) + */ + function spawn( + options: Opts & { + /** + * The command to run + * + * The first argument will be resolved to an absolute executable path. It must be a file, not a directory. + * + * If you explicitly set `PATH` in `env`, that `PATH` will be used to resolve the executable instead of the default `PATH`. + * + * To check if the command exists before running it, use `Bun.which(bin)`. + * + */ + cmd: string[]; // to support dynamically constructed commands + }, + ): Subprocess>; + + /** + * Spawn a new process + * + * ```js + * const {stdout} = Bun.spawn(["echo", "hello"])); + * const text = await readableStreamToText(stdout); + * console.log(text); // "hello\n" + * ``` + * + * Internally, this uses [posix_spawn(2)](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/posix_spawn.2.html) + */ + function spawn( + /** + * The command to run + * @example + * ```ts + * const subprocess = Bun.spawn(["echo", "hello"]); + */ + cmds: string[], + options?: Opts, + ): Subprocess>; + type OptionsToSubprocessIO = { + stdin?: Opts["stdin"] extends number + ? number + : Opts["stdin"] extends "pipe" + ? FileSink + : ReadableStream; + stdout?: Opts["stdout"] extends number ? number : ReadableStream; + stderr?: Opts["stderr"] extends number ? number : ReadableStream; + }; + + /** + * Spawn a new process + * + * ```js + * const {stdout} = Bun.spawnSync({ + * cmd: ["echo", "hello"], + * }); + * console.log(stdout.toString()); // "hello\n" + * ``` + * + * Internally, this uses [posix_spawn(2)](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/posix_spawn.2.html) + */ + function spawnSync( + options: SpawnOptions.OptionsObject & { + /** + * The command to run + * + * The first argument will be resolved to an absolute executable path. It must be a file, not a directory. + * + * If you explicitly set `PATH` in `env`, that `PATH` will be used to resolve the executable instead of the default `PATH`. + * + * To check if the command exists before running it, use `Bun.which(bin)`. + * + */ + cmd: [string, ...string[]]; + }, + ): SyncSubprocess; + + /** + * Synchronously spawn a new process + * + * ```js + * const {stdout} = Bun.spawnSync(["echo", "hello"])); + * console.log(stdout.toString()); // "hello\n" + * ``` + * + * Internally, this uses [posix_spawn(2)](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/posix_spawn.2.html) + */ + function spawnSync( + /** + * The command to run + * @example + * ```ts + * const subprocess = Bun.spawn(["echo", "hello"]); + */ + cmds: [ + /** One command is required */ + string, + /** Additional arguments */ + ...string[], + ], + options?: SpawnOptions.OptionsObject, + ): SyncSubprocess; + + /** + * The current version of Bun + * @example + * "0.2.0" + */ + export const version: string; + + /** + * The git sha at the time the currently-running version of Bun was compiled + * @example + * "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2" + */ + export const revision: string; +} + +type TypedArray = + | Uint8Array + | Int8Array + | Uint8ClampedArray + | Int16Array + | Uint16Array + | Int32Array + | Uint32Array + | Float32Array + | Float64Array; +type TimeLike = string | number | Date; +type StringOrBuffer = string | TypedArray | ArrayBufferLike; +type PathLike = string | TypedArray | ArrayBufferLike | URL; +type PathOrFileDescriptor = PathLike | number; +type NoParamCallback = VoidFunction; +type BufferEncoding = + | "buffer" + | "utf8" + | "utf-8" + | "ascii" + | "utf16le" + | "ucs2" + | "ucs-2" + | "latin1" + | "binary" + | "hex" + | "base64" + | "base64url"; + +interface BufferEncodingOption { + encoding?: BufferEncoding; +} + +// declare var Bun: typeof import("bun"); +declare namespace Bun { + export * from "bun"; +} diff --git a/packages/bun-types/bun.lockb b/packages/bun-types/bun.lockb new file mode 100755 index 0000000000000000000000000000000000000000..cf33f4cab6bfdf0240428a9525ed78c66457e2ba GIT binary patch literal 76065 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 literal 0 HcmV?d00001 diff --git a/packages/bun-types/child_process.d.ts b/packages/bun-types/child_process.d.ts new file mode 100644 index 0000000000..639dcaf621 --- /dev/null +++ b/packages/bun-types/child_process.d.ts @@ -0,0 +1,1702 @@ +/** + * The `child_process` module provides the ability to spawn subprocesses in + * a manner that is similar, but not identical, to [`popen(3)`](http://man7.org/linux/man-pages/man3/popen.3.html). This capability + * is primarily provided by the {@link spawn} function: + * + * ```js + * const { spawn } = require('child_process'); + * const ls = spawn('ls', ['-lh', '/usr']); + * + * ls.stdout.on('data', (data) => { + * console.log(`stdout: ${data}`); + * }); + * + * ls.stderr.on('data', (data) => { + * console.error(`stderr: ${data}`); + * }); + * + * ls.on('close', (code) => { + * console.log(`child process exited with code ${code}`); + * }); + * ``` + * + * By default, pipes for `stdin`, `stdout`, and `stderr` are established between + * the parent Node.js process and the spawned subprocess. These pipes have + * limited (and platform-specific) capacity. If the subprocess writes to + * stdout in excess of that limit without the output being captured, the + * subprocess blocks waiting for the pipe buffer to accept more data. This is + * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`option if the output will not be consumed. + * + * The command lookup is performed using the `options.env.PATH` environment + * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is + * used. If `options.env` is set without `PATH`, lookup on Unix is performed + * on a default search path search of `/usr/bin:/bin` (see your operating system's + * manual for execvpe/execvp), on Windows the current processes environment + * variable `PATH` is used. + * + * On Windows, environment variables are case-insensitive. Node.js + * lexicographically sorts the `env` keys and uses the first one that + * case-insensitively matches. Only first (in lexicographic order) entry will be + * passed to the subprocess. This might lead to issues on Windows when passing + * objects to the `env` option that have multiple variants of the same key, such as`PATH` and `Path`. + * + * The {@link spawn} method spawns the child process asynchronously, + * without blocking the Node.js event loop. The {@link spawnSync} function provides equivalent functionality in a synchronous manner that blocks + * the event loop until the spawned process either exits or is terminated. + * + * For convenience, the `child_process` module provides a handful of synchronous + * and asynchronous alternatives to {@link spawn} and {@link spawnSync}. Each of these alternatives are implemented on + * top of {@link spawn} or {@link spawnSync}. + * + * * {@link exec}: spawns a shell and runs a command within that + * shell, passing the `stdout` and `stderr` to a callback function when + * complete. + * * {@link execFile}: similar to {@link exec} except + * that it spawns the command directly without first spawning a shell by + * default. + * * {@link fork}: spawns a new Node.js process and invokes a + * specified module with an IPC communication channel established that allows + * sending messages between parent and child. + * * {@link execSync}: a synchronous version of {@link exec} that will block the Node.js event loop. + * * {@link execFileSync}: a synchronous version of {@link execFile} that will block the Node.js event loop. + * + * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however, + * the synchronous methods can have significant impact on performance due to + * stalling the event loop while spawned processes complete. + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/child_process.js) + */ +declare module "child_process" { + import { BunSpawnOptions } from "bun"; + import { ObjectEncodingOptions } from "node:fs"; + import { EventEmitter, Abortable } from "node:events"; + import * as net from "node:net"; + import { Writable, Readable, Stream, Pipe } from "node:stream"; + import { URL } from "node:url"; + type Serializable = string | object | number | boolean | bigint; + type SendHandle = net.Socket | net.Server; + /** + * Instances of the `ChildProcess` represent spawned child processes. + * + * Instances of `ChildProcess` are not intended to be created directly. Rather, + * use the {@link spawn}, {@link exec},{@link execFile}, or {@link fork} methods to create + * instances of `ChildProcess`. + * @since v2.2.0 + */ + class ChildProcess extends EventEmitter { + spawn( + options: BunSpawnOptions & { cmd: string[] }, + ): ChildProcessWithoutNullStreams; + + /** + * A `Writable Stream` that represents the child process's `stdin`. + * + * If a child process waits to read all of its input, the child will not continue + * until this stream has been closed via `end()`. + * + * If the child was spawned with `stdio[0]` set to anything other than `'pipe'`, + * then this will be `null`. + * + * `subprocess.stdin` is an alias for `subprocess.stdio[0]`. Both properties will + * refer to the same value. + * + * The `subprocess.stdin` property can be `undefined` if the child process could + * not be successfully spawned. + * @since v0.1.90 + */ + stdin: Writable | null; + /** + * A `Readable Stream` that represents the child process's `stdout`. + * + * If the child was spawned with `stdio[1]` set to anything other than `'pipe'`, + * then this will be `null`. + * + * `subprocess.stdout` is an alias for `subprocess.stdio[1]`. Both properties will + * refer to the same value. + * + * ```js + * const { spawn } = require('child_process'); + * + * const subprocess = spawn('ls'); + * + * subprocess.stdout.on('data', (data) => { + * console.log(`Received chunk ${data}`); + * }); + * ``` + * + * The `subprocess.stdout` property can be `null` if the child process could + * not be successfully spawned. + * @since v0.1.90 + */ + stdout: Readable | null; + /** + * A `Readable Stream` that represents the child process's `stderr`. + * + * If the child was spawned with `stdio[2]` set to anything other than `'pipe'`, + * then this will be `null`. + * + * `subprocess.stderr` is an alias for `subprocess.stdio[2]`. Both properties will + * refer to the same value. + * + * The `subprocess.stderr` property can be `null` if the child process could + * not be successfully spawned. + * @since v0.1.90 + */ + stderr: Readable | null; + /** + * The `subprocess.channel` property is a reference to the child's IPC channel. If + * no IPC channel currently exists, this property is `undefined`. + * @since v7.1.0 + */ + readonly channel?: Pipe | null | undefined; + /** + * A sparse array of pipes to the child process, corresponding with positions in + * the `stdio` option passed to {@link spawn} that have been set + * to the value `'pipe'`. `subprocess.stdio[0]`, `subprocess.stdio[1]`, and`subprocess.stdio[2]` are also available as `subprocess.stdin`,`subprocess.stdout`, and `subprocess.stderr`, + * respectively. + * + * In the following example, only the child's fd `1` (stdout) is configured as a + * pipe, so only the parent's `subprocess.stdio[1]` is a stream, all other values + * in the array are `null`. + * + * ```js + * const assert = require('assert'); + * const fs = require('fs'); + * const child_process = require('child_process'); + * + * const subprocess = child_process.spawn('ls', { + * stdio: [ + * 0, // Use parent's stdin for child. + * 'pipe', // Pipe child's stdout to parent. + * fs.openSync('err.out', 'w'), // Direct child's stderr to a file. + * ] + * }); + * + * assert.strictEqual(subprocess.stdio[0], null); + * assert.strictEqual(subprocess.stdio[0], subprocess.stdin); + * + * assert(subprocess.stdout); + * assert.strictEqual(subprocess.stdio[1], subprocess.stdout); + * + * assert.strictEqual(subprocess.stdio[2], null); + * assert.strictEqual(subprocess.stdio[2], subprocess.stderr); + * ``` + * + * The `subprocess.stdio` property can be `undefined` if the child process could + * not be successfully spawned. + * @since v0.7.10 + */ + readonly stdio: [ + Writable | null, + // stdin + Readable | null, + // stdout + Readable | null, + // stderr + Readable | Writable | null | undefined, + // extra + Readable | Writable | null | undefined, // extra + ]; + /** + * The `subprocess.killed` property indicates whether the child process + * successfully received a signal from `subprocess.kill()`. The `killed` property + * does not indicate that the child process has been terminated. + * @since v0.5.10 + */ + readonly killed: boolean; + /** + * Returns the process identifier (PID) of the child process. If the child process + * fails to spawn due to errors, then the value is `undefined` and `error` is + * emitted. + * + * ```js + * const { spawn } = require('child_process'); + * const grep = spawn('grep', ['ssh']); + * + * console.log(`Spawned child pid: ${grep.pid}`); + * grep.stdin.end(); + * ``` + * @since v0.1.90 + */ + readonly pid?: number | undefined; + /** + * The `subprocess.connected` property indicates whether it is still possible to + * send and receive messages from a child process. When `subprocess.connected` is`false`, it is no longer possible to send or receive messages. + * @since v0.7.2 + */ + readonly connected: boolean; + /** + * The `subprocess.exitCode` property indicates the exit code of the child process. + * If the child process is still running, the field will be `null`. + */ + readonly exitCode: number | null; + /** + * The `subprocess.signalCode` property indicates the signal received by + * the child process if any, else `null`. + */ + readonly signalCode: NodeJS.Signals | null; + /** + * The `subprocess.spawnargs` property represents the full list of command-line + * arguments the child process was launched with. + */ + readonly spawnargs: string[]; + /** + * The `subprocess.spawnfile` property indicates the executable file name of + * the child process that is launched. + * + * For {@link fork}, its value will be equal to `process.execPath`. + * For {@link spawn}, its value will be the name of + * the executable file. + * For {@link exec}, its value will be the name of the shell + * in which the child process is launched. + */ + readonly spawnfile: string; + /** + * The `subprocess.kill()` method sends a signal to the child process. If no + * argument is given, the process will be sent the `'SIGTERM'` signal. See [`signal(7)`](http://man7.org/linux/man-pages/man7/signal.7.html) for a list of available signals. This function + * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise. + * + * ```js + * const { spawn } = require('child_process'); + * const grep = spawn('grep', ['ssh']); + * + * grep.on('close', (code, signal) => { + * console.log( + * `child process terminated due to receipt of signal ${signal}`); + * }); + * + * // Send SIGHUP to process. + * grep.kill('SIGHUP'); + * ``` + * + * The `ChildProcess` object may emit an `'error'` event if the signal + * cannot be delivered. Sending a signal to a child process that has already exited + * is not an error but may have unforeseen consequences. Specifically, if the + * process identifier (PID) has been reassigned to another process, the signal will + * be delivered to that process instead which can have unexpected results. + * + * While the function is called `kill`, the signal delivered to the child process + * may not actually terminate the process. + * + * See [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) for reference. + * + * On Windows, where POSIX signals do not exist, the `signal` argument will be + * ignored, and the process will be killed forcefully and abruptly (similar to`'SIGKILL'`). + * See `Signal Events` for more details. + * + * On Linux, child processes of child processes will not be terminated + * when attempting to kill their parent. This is likely to happen when running a + * new process in a shell or with the use of the `shell` option of `ChildProcess`: + * + * ```js + * 'use strict'; + * const { spawn } = require('child_process'); + * + * const subprocess = spawn( + * 'sh', + * [ + * '-c', + * `node -e "setInterval(() => { + * console.log(process.pid, 'is alive') + * }, 500);"`, + * ], { + * stdio: ['inherit', 'inherit', 'inherit'] + * } + * ); + * + * setTimeout(() => { + * subprocess.kill(); // Does not terminate the Node.js process in the shell. + * }, 2000); + * ``` + * @since v0.1.90 + */ + kill(signal?: NodeJS.Signals | number): boolean; + /** + * When an IPC channel has been established between the parent and child ( + * i.e. when using {@link fork}), the `subprocess.send()` method can + * be used to send messages to the child process. When the child process is a + * Node.js instance, these messages can be received via the `'message'` event. + * + * The message goes through serialization and parsing. The resulting + * message might not be the same as what is originally sent. + * + * For example, in the parent script: + * + * ```js + * const cp = require('child_process'); + * const n = cp.fork(`${__dirname}/sub.js`); + * + * n.on('message', (m) => { + * console.log('PARENT got message:', m); + * }); + * + * // Causes the child to print: CHILD got message: { hello: 'world' } + * n.send({ hello: 'world' }); + * ``` + * + * And then the child script, `'sub.js'` might look like this: + * + * ```js + * process.on('message', (m) => { + * console.log('CHILD got message:', m); + * }); + * + * // Causes the parent to print: PARENT got message: { foo: 'bar', baz: null } + * process.send({ foo: 'bar', baz: NaN }); + * ``` + * + * Child Node.js processes will have a `process.send()` method of their own + * that allows the child to send messages back to the parent. + * + * There is a special case when sending a `{cmd: 'NODE_foo'}` message. Messages + * containing a `NODE_` prefix in the `cmd` property are reserved for use within + * Node.js core and will not be emitted in the child's `'message'` event. Rather, such messages are emitted using the`'internalMessage'` event and are consumed internally by Node.js. + * Applications should avoid using such messages or listening for`'internalMessage'` events as it is subject to change without notice. + * + * The optional `sendHandle` argument that may be passed to `subprocess.send()` is + * for passing a TCP server or socket object to the child process. The child will + * receive the object as the second argument passed to the callback function + * registered on the `'message'` event. Any data that is received + * and buffered in the socket will not be sent to the child. + * + * The optional `callback` is a function that is invoked after the message is + * sent but before the child may have received it. The function is called with a + * single argument: `null` on success, or an `Error` object on failure. + * + * If no `callback` function is provided and the message cannot be sent, an`'error'` event will be emitted by the `ChildProcess` object. This can + * happen, for instance, when the child process has already exited. + * + * `subprocess.send()` will return `false` if the channel has closed or when the + * backlog of unsent messages exceeds a threshold that makes it unwise to send + * more. Otherwise, the method returns `true`. The `callback` function can be + * used to implement flow control. + * + * #### Example: sending a server object + * + * The `sendHandle` argument can be used, for instance, to pass the handle of + * a TCP server object to the child process as illustrated in the example below: + * + * ```js + * const subprocess = require('child_process').fork('subprocess.js'); + * + * // Open up the server object and send the handle. + * const server = require('net').createServer(); + * server.on('connection', (socket) => { + * socket.end('handled by parent'); + * }); + * server.listen(1337, () => { + * subprocess.send('server', server); + * }); + * ``` + * + * The child would then receive the server object as: + * + * ```js + * process.on('message', (m, server) => { + * if (m === 'server') { + * server.on('connection', (socket) => { + * socket.end('handled by child'); + * }); + * } + * }); + * ``` + * + * Once the server is now shared between the parent and child, some connections + * can be handled by the parent and some by the child. + * + * While the example above uses a server created using the `net` module, `dgram`module servers use exactly the same workflow with the exceptions of listening on + * a `'message'` event instead of `'connection'` and using `server.bind()` instead + * of `server.listen()`. This is, however, currently only supported on Unix + * platforms. + * + * #### Example: sending a socket object + * + * Similarly, the `sendHandler` argument can be used to pass the handle of a + * socket to the child process. The example below spawns two children that each + * handle connections with "normal" or "special" priority: + * + * ```js + * const { fork } = require('child_process'); + * const normal = fork('subprocess.js', ['normal']); + * const special = fork('subprocess.js', ['special']); + * + * // Open up the server and send sockets to child. Use pauseOnConnect to prevent + * // the sockets from being read before they are sent to the child process. + * const server = require('net').createServer({ pauseOnConnect: true }); + * server.on('connection', (socket) => { + * + * // If this is special priority... + * if (socket.remoteAddress === '74.125.127.100') { + * special.send('socket', socket); + * return; + * } + * // This is normal priority. + * normal.send('socket', socket); + * }); + * server.listen(1337); + * ``` + * + * The `subprocess.js` would receive the socket handle as the second argument + * passed to the event callback function: + * + * ```js + * process.on('message', (m, socket) => { + * if (m === 'socket') { + * if (socket) { + * // Check that the client socket exists. + * // It is possible for the socket to be closed between the time it is + * // sent and the time it is received in the child process. + * socket.end(`Request handled with ${process.argv[2]} priority`); + * } + * } + * }); + * ``` + * + * Do not use `.maxConnections` on a socket that has been passed to a subprocess. + * The parent cannot track when the socket is destroyed. + * + * Any `'message'` handlers in the subprocess should verify that `socket` exists, + * as the connection may have been closed during the time it takes to send the + * connection to the child. + * @since v0.5.9 + * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties: + */ + send( + message: Serializable, + callback?: (error: Error | null) => void, + ): boolean; + send( + message: Serializable, + sendHandle?: SendHandle, + callback?: (error: Error | null) => void, + ): boolean; + send( + message: Serializable, + sendHandle?: SendHandle, + options?: MessageOptions, + callback?: (error: Error | null) => void, + ): boolean; + /** + * Closes the IPC channel between parent and child, allowing the child to exit + * gracefully once there are no other connections keeping it alive. After calling + * this method the `subprocess.connected` and `process.connected` properties in + * both the parent and child (respectively) will be set to `false`, and it will be + * no longer possible to pass messages between the processes. + * + * The `'disconnect'` event will be emitted when there are no messages in the + * process of being received. This will most often be triggered immediately after + * calling `subprocess.disconnect()`. + * + * When the child process is a Node.js instance (e.g. spawned using {@link fork}), the `process.disconnect()` method can be invoked + * within the child process to close the IPC channel as well. + * @since v0.7.2 + */ + disconnect(): void; + /** + * By default, the parent will wait for the detached child to exit. To prevent the + * parent from waiting for a given `subprocess` to exit, use the`subprocess.unref()` method. Doing so will cause the parent's event loop to not + * include the child in its reference count, allowing the parent to exit + * independently of the child, unless there is an established IPC channel between + * the child and the parent. + * + * ```js + * const { spawn } = require('child_process'); + * + * const subprocess = spawn(process.argv[0], ['child_program.js'], { + * detached: true, + * stdio: 'ignore' + * }); + * + * subprocess.unref(); + * ``` + * @since v0.7.10 + */ + unref(): void; + /** + * Calling `subprocess.ref()` after making a call to `subprocess.unref()` will + * restore the removed reference count for the child process, forcing the parent + * to wait for the child to exit before exiting itself. + * + * ```js + * const { spawn } = require('child_process'); + * + * const subprocess = spawn(process.argv[0], ['child_program.js'], { + * detached: true, + * stdio: 'ignore' + * }); + * + * subprocess.unref(); + * subprocess.ref(); + * ``` + * @since v0.7.10 + */ + ref(): void; + /** + * events.EventEmitter + * 1. close + * 2. disconnect + * 3. error + * 4. exit + * 5. message + * 6. spawn + */ + addListener(event: string, listener: (...args: any[]) => void): this; + addListener( + event: "close", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + addListener(event: "disconnect", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener( + event: "exit", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + addListener( + event: "message", + listener: (message: Serializable, sendHandle: SendHandle) => void, + ): this; + addListener(event: "spawn", listener: () => void): this; + emit(event: string | symbol, ...args: any[]): boolean; + emit( + event: "close", + code: number | null, + signal: NodeJS.Signals | null, + ): boolean; + emit(event: "disconnect"): boolean; + emit(event: "error", err: Error): boolean; + emit( + event: "exit", + code: number | null, + signal: NodeJS.Signals | null, + ): boolean; + emit( + event: "message", + message: Serializable, + sendHandle: SendHandle, + ): boolean; + emit(event: "spawn", listener: () => void): boolean; + on(event: string, listener: (...args: any[]) => void): this; + on( + event: "close", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + on(event: "disconnect", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on( + event: "exit", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + on( + event: "message", + listener: (message: Serializable, sendHandle: SendHandle) => void, + ): this; + on(event: "spawn", listener: () => void): this; + once(event: string, listener: (...args: any[]) => void): this; + once( + event: "close", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + once(event: "disconnect", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once( + event: "exit", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + once( + event: "message", + listener: (message: Serializable, sendHandle: SendHandle) => void, + ): this; + once(event: "spawn", listener: () => void): this; + prependListener(event: string, listener: (...args: any[]) => void): this; + prependListener( + event: "close", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + prependListener(event: "disconnect", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener( + event: "exit", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + prependListener( + event: "message", + listener: (message: Serializable, sendHandle: SendHandle) => void, + ): this; + prependListener(event: "spawn", listener: () => void): this; + prependOnceListener( + event: string, + listener: (...args: any[]) => void, + ): this; + prependOnceListener( + event: "close", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + prependOnceListener(event: "disconnect", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener( + event: "exit", + listener: (code: number | null, signal: NodeJS.Signals | null) => void, + ): this; + prependOnceListener( + event: "message", + listener: (message: Serializable, sendHandle: SendHandle) => void, + ): this; + prependOnceListener(event: "spawn", listener: () => void): this; + } + // return this object when stdio option is undefined or not specified + interface ChildProcessWithoutNullStreams extends ChildProcess { + stdin: Writable; + stdout: Readable; + stderr: Readable; + readonly stdio: [ + Writable, + Readable, + Readable, + // stderr + Readable | Writable | null | undefined, + // extra, no modification + Readable | Writable | null | undefined, // extra, no modification + ]; + } + // return this object when stdio option is a tuple of 3 + interface ChildProcessByStdio< + I extends null | Writable, + O extends null | Readable, + E extends null | Readable, + > extends ChildProcess { + stdin: I; + stdout: O; + stderr: E; + readonly stdio: [ + I, + O, + E, + Readable | Writable | null | undefined, + // extra, no modification + Readable | Writable | null | undefined, // extra, no modification + ]; + } + interface MessageOptions { + keepOpen?: boolean | undefined; + } + type IOType = "overlapped" | "pipe" | "ignore" | "inherit"; + type StdioOptions = + | IOType + | Array; + type SerializationType = "json" | "advanced"; + interface MessagingOptions extends Abortable { + /** + * Specify the kind of serialization used for sending messages between processes. + * @default 'json' + */ + serialization?: SerializationType | undefined; + /** + * The signal value to be used when the spawned process will be killed by the abort signal. + * @default 'SIGTERM' + */ + killSignal?: NodeJS.Signals | number | undefined; + /** + * In milliseconds the maximum amount of time the process is allowed to run. + */ + timeout?: number | undefined; + } + interface ProcessEnvOptions { + uid?: number | undefined; + gid?: number | undefined; + cwd?: string | URL | undefined; + env?: NodeJS.ProcessEnv | undefined; + } + interface CommonOptions extends ProcessEnvOptions { + /** + * @default true + */ + windowsHide?: boolean | undefined; + /** + * @default 0 + */ + timeout?: number | undefined; + } + interface CommonSpawnOptions + extends CommonOptions, + MessagingOptions, + Abortable { + argv0?: string | undefined; + stdio?: StdioOptions | undefined; + shell?: boolean | string | undefined; + windowsVerbatimArguments?: boolean | undefined; + } + interface SpawnOptions extends CommonSpawnOptions { + detached?: boolean | undefined; + } + interface SpawnOptionsWithoutStdio extends SpawnOptions { + stdio?: StdioPipeNamed | StdioPipe[] | undefined; + } + type StdioNull = "inherit" | "ignore" | Stream; + type StdioPipeNamed = "pipe" | "overlapped"; + type StdioPipe = undefined | null | StdioPipeNamed; + interface SpawnOptionsWithStdioTuple< + Stdin extends StdioNull | StdioPipe, + Stdout extends StdioNull | StdioPipe, + Stderr extends StdioNull | StdioPipe, + > extends SpawnOptions { + stdio: [Stdin, Stdout, Stderr]; + } + /** + * The `child_process.spawn()` method spawns a new process using the given`command`, with command-line arguments in `args`. If omitted, `args` defaults + * to an empty array. + * + * **If the `shell` option is enabled, do not pass unsanitized user input to this** + * **function. Any input containing shell metacharacters may be used to trigger** + * **arbitrary command execution.** + * + * A third argument may be used to specify additional options, with these defaults: + * + * ```js + * const defaults = { + * cwd: undefined, + * env: process.env + * }; + * ``` + * + * Use `cwd` to specify the working directory from which the process is spawned. + * If not given, the default is to inherit the current working directory. If given, + * but the path does not exist, the child process emits an `ENOENT` error + * and exits immediately. `ENOENT` is also emitted when the command + * does not exist. + * + * Use `env` to specify environment variables that will be visible to the new + * process, the default is `process.env`. + * + * `undefined` values in `env` will be ignored. + * + * Example of running `ls -lh /usr`, capturing `stdout`, `stderr`, and the + * exit code: + * + * ```js + * const { spawn } = require('child_process'); + * const ls = spawn('ls', ['-lh', '/usr']); + * + * ls.stdout.on('data', (data) => { + * console.log(`stdout: ${data}`); + * }); + * + * ls.stderr.on('data', (data) => { + * console.error(`stderr: ${data}`); + * }); + * + * ls.on('close', (code) => { + * console.log(`child process exited with code ${code}`); + * }); + * ``` + * + * Example: A very elaborate way to run `ps ax | grep ssh` + * + * ```js + * const { spawn } = require('child_process'); + * const ps = spawn('ps', ['ax']); + * const grep = spawn('grep', ['ssh']); + * + * ps.stdout.on('data', (data) => { + * grep.stdin.write(data); + * }); + * + * ps.stderr.on('data', (data) => { + * console.error(`ps stderr: ${data}`); + * }); + * + * ps.on('close', (code) => { + * if (code !== 0) { + * console.log(`ps process exited with code ${code}`); + * } + * grep.stdin.end(); + * }); + * + * grep.stdout.on('data', (data) => { + * console.log(data.toString()); + * }); + * + * grep.stderr.on('data', (data) => { + * console.error(`grep stderr: ${data}`); + * }); + * + * grep.on('close', (code) => { + * if (code !== 0) { + * console.log(`grep process exited with code ${code}`); + * } + * }); + * ``` + * + * Example of checking for failed `spawn`: + * + * ```js + * const { spawn } = require('child_process'); + * const subprocess = spawn('bad_command'); + * + * subprocess.on('error', (err) => { + * console.error('Failed to start subprocess.'); + * }); + * ``` + * + * Certain platforms (macOS, Linux) will use the value of `argv[0]` for the process + * title while others (Windows, SunOS) will use `command`. + * + * Node.js currently overwrites `argv[0]` with `process.execPath` on startup, so`process.argv[0]` in a Node.js child process will not match the `argv0`parameter passed to `spawn` from the parent, + * retrieve it with the`process.argv0` property instead. + * + * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except + * the error passed to the callback will be an `AbortError`: + * + * ```js + * const { spawn } = require('child_process'); + * const controller = new AbortController(); + * const { signal } = controller; + * const grep = spawn('grep', ['ssh'], { signal }); + * grep.on('error', (err) => { + * // This will be called with err being an AbortError if the controller aborts + * }); + * controller.abort(); // Stops the child process + * ``` + * @since v0.1.90 + * @param command The command to run. + * @param args List of string arguments. + */ + function spawn( + command: string, + options?: SpawnOptionsWithoutStdio, + ): ChildProcessWithoutNullStreams; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn(command: string, options: SpawnOptions): ChildProcess; + // overloads of spawn with 'args' + function spawn( + command: string, + args?: ReadonlyArray, + options?: SpawnOptionsWithoutStdio, + ): ChildProcessWithoutNullStreams; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptionsWithStdioTuple, + ): ChildProcessByStdio; + function spawn( + command: string, + args: ReadonlyArray, + options: SpawnOptions, + ): ChildProcess; + interface ExecOptions extends CommonOptions { + shell?: string | undefined; + signal?: AbortSignal | undefined; + maxBuffer?: number | undefined; + killSignal?: NodeJS.Signals | number | undefined; + } + interface ExecOptionsWithStringEncoding extends ExecOptions { + encoding: BufferEncoding; + } + interface ExecOptionsWithBufferEncoding extends ExecOptions { + encoding: BufferEncoding | null; // specify `null`. + } + interface ExecException extends Error { + cmd?: string | undefined; + killed?: boolean | undefined; + code?: number | undefined; + signal?: NodeJS.Signals | undefined; + } + /** + * Spawns a shell then executes the `command` within that shell, buffering any + * generated output. The `command` string passed to the exec function is processed + * directly by the shell and special characters (vary based on [shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters)) + * need to be dealt with accordingly: + * + * ```js + * const { exec } = require('child_process'); + * + * exec('"/path/to/test file/test.sh" arg1 arg2'); + * // Double quotes are used so that the space in the path is not interpreted as + * // a delimiter of multiple arguments. + * + * exec('echo "The \\$HOME variable is $HOME"'); + * // The $HOME variable is escaped in the first instance, but not in the second. + * ``` + * + * **Never pass unsanitized user input to this function. Any input containing shell** + * **metacharacters may be used to trigger arbitrary command execution.** + * + * If a `callback` function is provided, it is called with the arguments`(error, stdout, stderr)`. On success, `error` will be `null`. On error,`error` will be an instance of `Error`. The + * `error.code` property will be + * the exit code of the process. By convention, any exit code other than `0`indicates an error. `error.signal` will be the signal that terminated the + * process. + * + * The `stdout` and `stderr` arguments passed to the callback will contain the + * stdout and stderr output of the child process. By default, Node.js will decode + * the output as UTF-8 and pass strings to the callback. The `encoding` option + * can be used to specify the character encoding used to decode the stdout and + * stderr output. If `encoding` is `'buffer'`, or an unrecognized character + * encoding, `Buffer` objects will be passed to the callback instead. + * + * ```js + * const { exec } = require('child_process'); + * exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => { + * if (error) { + * console.error(`exec error: ${error}`); + * return; + * } + * console.log(`stdout: ${stdout}`); + * console.error(`stderr: ${stderr}`); + * }); + * ``` + * + * If `timeout` is greater than `0`, the parent will send the signal + * identified by the `killSignal` property (the default is `'SIGTERM'`) if the + * child runs longer than `timeout` milliseconds. + * + * Unlike the [`exec(3)`](http://man7.org/linux/man-pages/man3/exec.3.html) POSIX system call, `child_process.exec()` does not replace + * the existing process and uses a shell to execute the command. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In + * case of an error (including any error resulting in an exit code other than 0), a + * rejected promise is returned, with the same `error` object given in the + * callback, but with two additional properties `stdout` and `stderr`. + * + * ```js + * const util = require('util'); + * const exec = util.promisify(require('child_process').exec); + * + * async function lsExample() { + * const { stdout, stderr } = await exec('ls'); + * console.log('stdout:', stdout); + * console.error('stderr:', stderr); + * } + * lsExample(); + * ``` + * + * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except + * the error passed to the callback will be an `AbortError`: + * + * ```js + * const { exec } = require('child_process'); + * const controller = new AbortController(); + * const { signal } = controller; + * const child = exec('grep ssh', { signal }, (error) => { + * console.log(error); // an AbortError + * }); + * controller.abort(); + * ``` + * @since v0.1.90 + * @param command The command to run, with space-separated arguments. + * @param callback called with the output when process terminates. + */ + function exec( + command: string, + callback?: ( + error: ExecException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`. + function exec( + command: string, + options: { + encoding: "buffer" | null; + } & ExecOptions, + callback?: ( + error: ExecException | null, + stdout: Buffer, + stderr: Buffer, + ) => void, + ): ChildProcess; + // `options` with well known `encoding` means stdout/stderr are definitely `string`. + function exec( + command: string, + options: { + encoding: BufferEncoding; + } & ExecOptions, + callback?: ( + error: ExecException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`. + // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`. + function exec( + command: string, + options: { + encoding: BufferEncoding; + } & ExecOptions, + callback?: ( + error: ExecException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void, + ): ChildProcess; + // `options` without an `encoding` means stdout/stderr are definitely `string`. + function exec( + command: string, + options: ExecOptions, + callback?: ( + error: ExecException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // fallback if nothing else matches. Worst case is always `string | Buffer`. + function exec( + command: string, + options: (ObjectEncodingOptions & ExecOptions) | undefined | null, + callback?: ( + error: ExecException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void, + ): ChildProcess; + interface PromiseWithChild extends Promise { + child: ChildProcess; + } + namespace exec { + function __promisify__(command: string): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + command: string, + options: { + encoding: "buffer" | null; + } & ExecOptions, + ): PromiseWithChild<{ + stdout: Buffer; + stderr: Buffer; + }>; + function __promisify__( + command: string, + options: { + encoding: BufferEncoding; + } & ExecOptions, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + command: string, + options: ExecOptions, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + command: string, + options?: (ObjectEncodingOptions & ExecOptions) | null, + ): PromiseWithChild<{ + stdout: string | Buffer; + stderr: string | Buffer; + }>; + } + interface ExecFileOptions extends CommonOptions, Abortable { + maxBuffer?: number | undefined; + killSignal?: NodeJS.Signals | number | undefined; + windowsVerbatimArguments?: boolean | undefined; + shell?: boolean | string | undefined; + signal?: AbortSignal | undefined; + } + interface ExecFileOptionsWithStringEncoding extends ExecFileOptions { + encoding: BufferEncoding; + } + interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions { + encoding: "buffer" | null; + } + interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions { + encoding: BufferEncoding; + } + type ExecFileException = ExecException & NodeJS.ErrnoException; + /** + * The `child_process.execFile()` function is similar to {@link exec} except that it does not spawn a shell by default. Rather, the specified + * executable `file` is spawned directly as a new process making it slightly more + * efficient than {@link exec}. + * + * The same options as {@link exec} are supported. Since a shell is + * not spawned, behaviors such as I/O redirection and file globbing are not + * supported. + * + * ```js + * const { execFile } = require('child_process'); + * const child = execFile('node', ['--version'], (error, stdout, stderr) => { + * if (error) { + * throw error; + * } + * console.log(stdout); + * }); + * ``` + * + * The `stdout` and `stderr` arguments passed to the callback will contain the + * stdout and stderr output of the child process. By default, Node.js will decode + * the output as UTF-8 and pass strings to the callback. The `encoding` option + * can be used to specify the character encoding used to decode the stdout and + * stderr output. If `encoding` is `'buffer'`, or an unrecognized character + * encoding, `Buffer` objects will be passed to the callback instead. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In + * case of an error (including any error resulting in an exit code other than 0), a + * rejected promise is returned, with the same `error` object given in the + * callback, but with two additional properties `stdout` and `stderr`. + * + * ```js + * const util = require('util'); + * const execFile = util.promisify(require('child_process').execFile); + * async function getVersion() { + * const { stdout } = await execFile('node', ['--version']); + * console.log(stdout); + * } + * getVersion(); + * ``` + * + * **If the `shell` option is enabled, do not pass unsanitized user input to this** + * **function. Any input containing shell metacharacters may be used to trigger** + * **arbitrary command execution.** + * + * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except + * the error passed to the callback will be an `AbortError`: + * + * ```js + * const { execFile } = require('child_process'); + * const controller = new AbortController(); + * const { signal } = controller; + * const child = execFile('node', ['--version'], { signal }, (error) => { + * console.log(error); // an AbortError + * }); + * controller.abort(); + * ``` + * @since v0.1.91 + * @param file The name or path of the executable file to run. + * @param args List of string arguments. + * @param callback Called with the output when process terminates. + */ + function execFile(file: string): ChildProcess; + function execFile( + file: string, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + ): ChildProcess; + function execFile( + file: string, + args?: ReadonlyArray | null, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + ): ChildProcess; + // no `options` definitely means stdout/stderr are `string`. + function execFile( + file: string, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`. + function execFile( + file: string, + options: ExecFileOptionsWithBufferEncoding, + callback: ( + error: ExecFileException | null, + stdout: Buffer, + stderr: Buffer, + ) => void, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithBufferEncoding, + callback: ( + error: ExecFileException | null, + stdout: Buffer, + stderr: Buffer, + ) => void, + ): ChildProcess; + // `options` with well known `encoding` means stdout/stderr are definitely `string`. + function execFile( + file: string, + options: ExecFileOptionsWithStringEncoding, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithStringEncoding, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`. + // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`. + function execFile( + file: string, + options: ExecFileOptionsWithOtherEncoding, + callback: ( + error: ExecFileException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithOtherEncoding, + callback: ( + error: ExecFileException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void, + ): ChildProcess; + // `options` without an `encoding` means stdout/stderr are definitely `string`. + function execFile( + file: string, + options: ExecFileOptions, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptions, + callback: ( + error: ExecFileException | null, + stdout: string, + stderr: string, + ) => void, + ): ChildProcess; + // fallback if nothing else matches. Worst case is always `string | Buffer`. + function execFile( + file: string, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + callback: + | (( + error: ExecFileException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void) + | undefined + | null, + ): ChildProcess; + function execFile( + file: string, + args: ReadonlyArray | undefined | null, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + callback: + | (( + error: ExecFileException | null, + stdout: string | Buffer, + stderr: string | Buffer, + ) => void) + | undefined + | null, + ): ChildProcess; + namespace execFile { + function __promisify__(file: string): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + options: ExecFileOptionsWithBufferEncoding, + ): PromiseWithChild<{ + stdout: Buffer; + stderr: Buffer; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithBufferEncoding, + ): PromiseWithChild<{ + stdout: Buffer; + stderr: Buffer; + }>; + function __promisify__( + file: string, + options: ExecFileOptionsWithStringEncoding, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithStringEncoding, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + options: ExecFileOptionsWithOtherEncoding, + ): PromiseWithChild<{ + stdout: string | Buffer; + stderr: string | Buffer; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptionsWithOtherEncoding, + ): PromiseWithChild<{ + stdout: string | Buffer; + stderr: string | Buffer; + }>; + function __promisify__( + file: string, + options: ExecFileOptions, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + options: ExecFileOptions, + ): PromiseWithChild<{ + stdout: string; + stderr: string; + }>; + function __promisify__( + file: string, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + ): PromiseWithChild<{ + stdout: string | Buffer; + stderr: string | Buffer; + }>; + function __promisify__( + file: string, + args: ReadonlyArray | undefined | null, + options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null, + ): PromiseWithChild<{ + stdout: string | Buffer; + stderr: string | Buffer; + }>; + } + interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable { + execPath?: string | undefined; + execArgv?: string[] | undefined; + silent?: boolean | undefined; + stdio?: StdioOptions | undefined; + detached?: boolean | undefined; + windowsVerbatimArguments?: boolean | undefined; + } + /** + * The `child_process.fork()` method is a special case of {@link spawn} used specifically to spawn new Node.js processes. + * Like {@link spawn}, a `ChildProcess` object is returned. The + * returned `ChildProcess` will have an additional communication channel + * built-in that allows messages to be passed back and forth between the parent and + * child. See `subprocess.send()` for details. + * + * Keep in mind that spawned Node.js child processes are + * independent of the parent with exception of the IPC communication channel + * that is established between the two. Each process has its own memory, with + * their own V8 instances. Because of the additional resource allocations + * required, spawning a large number of child Node.js processes is not + * recommended. + * + * By default, `child_process.fork()` will spawn new Node.js instances using the `process.execPath` of the parent process. The `execPath` property in the`options` object allows for an alternative + * execution path to be used. + * + * Node.js processes launched with a custom `execPath` will communicate with the + * parent process using the file descriptor (fd) identified using the + * environment variable `NODE_CHANNEL_FD` on the child process. + * + * Unlike the [`fork(2)`](http://man7.org/linux/man-pages/man2/fork.2.html) POSIX system call, `child_process.fork()` does not clone the + * current process. + * + * The `shell` option available in {@link spawn} is not supported by`child_process.fork()` and will be ignored if set. + * + * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except + * the error passed to the callback will be an `AbortError`: + * + * ```js + * if (process.argv[2] === 'child') { + * setTimeout(() => { + * console.log(`Hello from ${process.argv[2]}!`); + * }, 1_000); + * } else { + * const { fork } = require('child_process'); + * const controller = new AbortController(); + * const { signal } = controller; + * const child = fork(__filename, ['child'], { signal }); + * child.on('error', (err) => { + * // This will be called with err being an AbortError if the controller aborts + * }); + * controller.abort(); // Stops the child process + * } + * ``` + * @since v0.5.0 + * @param modulePath The module to run in the child. + * @param args List of string arguments. + */ + function fork(modulePath: string, options?: ForkOptions): ChildProcess; + function fork( + modulePath: string, + args?: ReadonlyArray, + options?: ForkOptions, + ): ChildProcess; + interface SpawnSyncOptions extends CommonSpawnOptions { + input?: string | NodeJS.ArrayBufferView | undefined; + maxBuffer?: number | undefined; + encoding?: BufferEncoding | "buffer" | null | undefined; + } + interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions { + encoding: BufferEncoding; + } + interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions { + encoding?: "buffer" | null | undefined; + } + interface SpawnSyncReturns { + pid: number; + output: Array; + stdout: T; + stderr: T; + status: number | null; + signal: NodeJS.Signals | null; + error?: Error | undefined; + } + /** + * The `child_process.spawnSync()` method is generally identical to {@link spawn} with the exception that the function will not return + * until the child process has fully closed. When a timeout has been encountered + * and `killSignal` is sent, the method won't return until the process has + * completely exited. If the process intercepts and handles the `SIGTERM` signal + * and doesn't exit, the parent process will wait until the child process has + * exited. + * + * **If the `shell` option is enabled, do not pass unsanitized user input to this** + * **function. Any input containing shell metacharacters may be used to trigger** + * **arbitrary command execution.** + * @since v0.11.12 + * @param command The command to run. + * @param args List of string arguments. + */ + function spawnSync(command: string): SpawnSyncReturns; + function spawnSync( + command: string, + options: SpawnSyncOptionsWithStringEncoding, + ): SpawnSyncReturns; + function spawnSync( + command: string, + options: SpawnSyncOptionsWithBufferEncoding, + ): SpawnSyncReturns; + function spawnSync( + command: string, + options?: SpawnSyncOptions, + ): SpawnSyncReturns; + function spawnSync( + command: string, + args: ReadonlyArray, + ): SpawnSyncReturns; + function spawnSync( + command: string, + args: ReadonlyArray, + options: SpawnSyncOptionsWithStringEncoding, + ): SpawnSyncReturns; + function spawnSync( + command: string, + args: ReadonlyArray, + options: SpawnSyncOptionsWithBufferEncoding, + ): SpawnSyncReturns; + function spawnSync( + command: string, + args?: ReadonlyArray, + options?: SpawnSyncOptions, + ): SpawnSyncReturns; + interface CommonExecOptions extends CommonOptions { + input?: string | NodeJS.ArrayBufferView | undefined; + stdio?: StdioOptions | undefined; + killSignal?: NodeJS.Signals | number | undefined; + maxBuffer?: number | undefined; + encoding?: BufferEncoding | "buffer" | null | undefined; + } + interface ExecSyncOptions extends CommonExecOptions { + shell?: string | undefined; + } + interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions { + encoding: BufferEncoding; + } + interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions { + encoding?: "buffer" | null | undefined; + } + /** + * The `child_process.execSync()` method is generally identical to {@link exec} with the exception that the method will not return + * until the child process has fully closed. When a timeout has been encountered + * and `killSignal` is sent, the method won't return until the process has + * completely exited. If the child process intercepts and handles the `SIGTERM`signal and doesn't exit, the parent process will wait until the child process + * has exited. + * + * If the process times out or has a non-zero exit code, this method will throw. + * The `Error` object will contain the entire result from {@link spawnSync}. + * + * **Never pass unsanitized user input to this function. Any input containing shell** + * **metacharacters may be used to trigger arbitrary command execution.** + * @since v0.11.12 + * @param command The command to run. + * @return The stdout from the command. + */ + function execSync(command: string): Buffer; + function execSync( + command: string, + options: ExecSyncOptionsWithStringEncoding, + ): string; + function execSync( + command: string, + options: ExecSyncOptionsWithBufferEncoding, + ): Buffer; + function execSync( + command: string, + options?: ExecSyncOptions, + ): string | Buffer; + interface ExecFileSyncOptions extends CommonExecOptions { + shell?: boolean | string | undefined; + } + interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions { + encoding: BufferEncoding; + } + interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions { + encoding?: "buffer" | null; // specify `null`. + } + /** + * The `child_process.execFileSync()` method is generally identical to {@link execFile} with the exception that the method will not + * return until the child process has fully closed. When a timeout has been + * encountered and `killSignal` is sent, the method won't return until the process + * has completely exited. + * + * If the child process intercepts and handles the `SIGTERM` signal and + * does not exit, the parent process will still wait until the child process has + * exited. + * + * If the process times out or has a non-zero exit code, this method will throw an `Error` that will include the full result of the underlying {@link spawnSync}. + * + * **If the `shell` option is enabled, do not pass unsanitized user input to this** + * **function. Any input containing shell metacharacters may be used to trigger** + * **arbitrary command execution.** + * @since v0.11.12 + * @param file The name or path of the executable file to run. + * @param args List of string arguments. + * @return The stdout from the command. + */ + function execFileSync(file: string): Buffer; + function execFileSync( + file: string, + options: ExecFileSyncOptionsWithStringEncoding, + ): string; + function execFileSync( + file: string, + options: ExecFileSyncOptionsWithBufferEncoding, + ): Buffer; + function execFileSync( + file: string, + options?: ExecFileSyncOptions, + ): string | Buffer; + function execFileSync(file: string, args: ReadonlyArray): Buffer; + function execFileSync( + file: string, + args: ReadonlyArray, + options: ExecFileSyncOptionsWithStringEncoding, + ): string; + function execFileSync( + file: string, + args: ReadonlyArray, + options: ExecFileSyncOptionsWithBufferEncoding, + ): Buffer; + function execFileSync( + file: string, + args?: ReadonlyArray, + options?: ExecFileSyncOptions, + ): string | Buffer; +} +declare module "node:child_process" { + export * from "child_process"; +} diff --git a/packages/bun-types/constants.d.ts b/packages/bun-types/constants.d.ts new file mode 100644 index 0000000000..6a672ad3de --- /dev/null +++ b/packages/bun-types/constants.d.ts @@ -0,0 +1,18 @@ +/** @deprecated use constants property exposed by the relevant module instead. */ +declare module "constants" { + import { constants as osConstants, SignalConstants } from "node:os"; + import { constants as cryptoConstants } from "node:crypto"; + import { constants as fsConstants } from "node:fs"; + + const exp: typeof osConstants.errno & + typeof osConstants.priority & + SignalConstants & + typeof cryptoConstants & + typeof fsConstants; + export = exp; +} + +declare module "node:constants" { + import constants = require("constants"); + export = constants; +} diff --git a/packages/bun-types/crypto.d.ts b/packages/bun-types/crypto.d.ts new file mode 100644 index 0000000000..288bfe9168 --- /dev/null +++ b/packages/bun-types/crypto.d.ts @@ -0,0 +1,3918 @@ +/** + * The `crypto` module provides cryptographic functionality that includes a set of + * wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions. + * + * ```js + * const { createHmac } = await import('crypto'); + * + * const secret = 'abcdefg'; + * const hash = createHmac('sha256', secret) + * .update('I love cupcakes') + * .digest('hex'); + * console.log(hash); + * // Prints: + * // c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/crypto.js) + */ +declare module "crypto" { + import * as stream from "node:stream"; + /** + * SPKAC is a Certificate Signing Request mechanism originally implemented by + * Netscape and was specified formally as part of [HTML5's `keygen` element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen). + * + * `` is deprecated since [HTML 5.2](https://www.w3.org/TR/html52/changes.html#features-removed) and new projects + * should not use this element anymore. + * + * The `crypto` module provides the `Certificate` class for working with SPKAC + * data. The most common usage is handling output generated by the HTML5`` element. Node.js uses [OpenSSL's SPKAC + * implementation](https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html) internally. + */ + class Certificate { + /** + * ```js + * const { Certificate } = await import('crypto'); + * const spkac = getSpkacSomehow(); + * const challenge = Certificate.exportChallenge(spkac); + * console.log(challenge.toString('utf8')); + * // Prints: the challenge as a UTF8 string + * ``` + * @param encoding The `encoding` of the `spkac` string. + * @return The challenge component of the `spkac` data structure, which includes a public key and a challenge. + */ + static exportChallenge(spkac: BinaryLike): Buffer; + /** + * ```js + * const { Certificate } = await import('crypto'); + * const spkac = getSpkacSomehow(); + * const publicKey = Certificate.exportPublicKey(spkac); + * console.log(publicKey); + * // Prints: the public key as + * ``` + * @param encoding The `encoding` of the `spkac` string. + * @return The public key component of the `spkac` data structure, which includes a public key and a challenge. + */ + static exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer; + /** + * ```js + * import { Buffer } from 'buffer'; + * const { Certificate } = await import('crypto'); + * + * const spkac = getSpkacSomehow(); + * console.log(Certificate.verifySpkac(Buffer.from(spkac))); + * // Prints: true or false + * ``` + * @param encoding The `encoding` of the `spkac` string. + * @return `true` if the given `spkac` data structure is valid, `false` otherwise. + */ + static verifySpkac(spkac: ArrayBufferView): boolean; + /** + * @deprecated + * @param spkac + * @returns The challenge component of the `spkac` data structure, + * which includes a public key and a challenge. + */ + exportChallenge(spkac: BinaryLike): Buffer; + /** + * @deprecated + * @param spkac + * @param encoding The encoding of the spkac string. + * @returns The public key component of the `spkac` data structure, + * which includes a public key and a challenge. + */ + exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer; + /** + * @deprecated + * @param spkac + * @returns `true` if the given `spkac` data structure is valid, + * `false` otherwise. + */ + verifySpkac(spkac: ArrayBufferView): boolean; + } + namespace constants { + // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants + const OPENSSL_VERSION_NUMBER: number; + /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */ + const SSL_OP_ALL: number; + /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */ + const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number; + /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */ + const SSL_OP_CIPHER_SERVER_PREFERENCE: number; + /** Instructs OpenSSL to use Cisco's "speshul" version of DTLS_BAD_VER. */ + const SSL_OP_CISCO_ANYCONNECT: number; + /** Instructs OpenSSL to turn on cookie exchange. */ + const SSL_OP_COOKIE_EXCHANGE: number; + /** Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft. */ + const SSL_OP_CRYPTOPRO_TLSEXT_BUG: number; + /** Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d. */ + const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number; + /** Instructs OpenSSL to always use the tmp_rsa key when performing RSA operations. */ + const SSL_OP_EPHEMERAL_RSA: number; + /** Allows initial connection to servers that do not support RI. */ + const SSL_OP_LEGACY_SERVER_CONNECT: number; + const SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number; + const SSL_OP_MICROSOFT_SESS_ID_BUG: number; + /** Instructs OpenSSL to disable the workaround for a man-in-the-middle protocol-version vulnerability in the SSL 2.0 server implementation. */ + const SSL_OP_MSIE_SSLV2_RSA_PADDING: number; + const SSL_OP_NETSCAPE_CA_DN_BUG: number; + const SSL_OP_NETSCAPE_CHALLENGE_BUG: number; + const SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number; + const SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number; + /** Instructs OpenSSL to disable support for SSL/TLS compression. */ + const SSL_OP_NO_COMPRESSION: number; + const SSL_OP_NO_QUERY_MTU: number; + /** Instructs OpenSSL to always start a new session when performing renegotiation. */ + const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number; + const SSL_OP_NO_SSLv2: number; + const SSL_OP_NO_SSLv3: number; + const SSL_OP_NO_TICKET: number; + const SSL_OP_NO_TLSv1: number; + const SSL_OP_NO_TLSv1_1: number; + const SSL_OP_NO_TLSv1_2: number; + const SSL_OP_PKCS1_CHECK_1: number; + const SSL_OP_PKCS1_CHECK_2: number; + /** Instructs OpenSSL to always create a new key when using temporary/ephemeral DH parameters. */ + const SSL_OP_SINGLE_DH_USE: number; + /** Instructs OpenSSL to always create a new key when using temporary/ephemeral ECDH parameters. */ + const SSL_OP_SINGLE_ECDH_USE: number; + const SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number; + const SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number; + const SSL_OP_TLS_BLOCK_PADDING_BUG: number; + const SSL_OP_TLS_D5_BUG: number; + /** Instructs OpenSSL to disable version rollback attack detection. */ + const SSL_OP_TLS_ROLLBACK_BUG: number; + const ENGINE_METHOD_RSA: number; + const ENGINE_METHOD_DSA: number; + const ENGINE_METHOD_DH: number; + const ENGINE_METHOD_RAND: number; + const ENGINE_METHOD_EC: number; + const ENGINE_METHOD_CIPHERS: number; + const ENGINE_METHOD_DIGESTS: number; + const ENGINE_METHOD_PKEY_METHS: number; + const ENGINE_METHOD_PKEY_ASN1_METHS: number; + const ENGINE_METHOD_ALL: number; + const ENGINE_METHOD_NONE: number; + const DH_CHECK_P_NOT_SAFE_PRIME: number; + const DH_CHECK_P_NOT_PRIME: number; + const DH_UNABLE_TO_CHECK_GENERATOR: number; + const DH_NOT_SUITABLE_GENERATOR: number; + const ALPN_ENABLED: number; + const RSA_PKCS1_PADDING: number; + const RSA_SSLV23_PADDING: number; + const RSA_NO_PADDING: number; + const RSA_PKCS1_OAEP_PADDING: number; + const RSA_X931_PADDING: number; + const RSA_PKCS1_PSS_PADDING: number; + /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying. */ + const RSA_PSS_SALTLEN_DIGEST: number; + /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data. */ + const RSA_PSS_SALTLEN_MAX_SIGN: number; + /** Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature. */ + const RSA_PSS_SALTLEN_AUTO: number; + const POINT_CONVERSION_COMPRESSED: number; + const POINT_CONVERSION_UNCOMPRESSED: number; + const POINT_CONVERSION_HYBRID: number; + /** Specifies the built-in default cipher list used by Node.js (colon-separated values). */ + const defaultCoreCipherList: string; + /** Specifies the active default cipher list used by the current Node.js process (colon-separated values). */ + const defaultCipherList: string; + } + interface HashOptions extends stream.TransformOptions { + /** + * For XOF hash functions such as `shake256`, the + * outputLength option can be used to specify the desired output length in bytes. + */ + outputLength?: number | undefined; + } + /** @deprecated since v10.0.0 */ + const fips: boolean; + /** + * Creates and returns a `Hash` object that can be used to generate hash digests + * using the given `algorithm`. Optional `options` argument controls stream + * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option + * can be used to specify the desired output length in bytes. + * + * The `algorithm` is dependent on the available algorithms supported by the + * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc. + * On recent releases of OpenSSL, `openssl list -digest-algorithms` will + * display the available digest algorithms. + * + * Example: generating the sha256 sum of a file + * + * ```js + * import { + * createReadStream + * } from 'fs'; + * import { argv } from 'process'; + * const { + * createHash + * } = await import('crypto'); + * + * const filename = argv[2]; + * + * const hash = createHash('sha256'); + * + * const input = createReadStream(filename); + * input.on('readable', () => { + * // Only one element is going to be produced by the + * // hash stream. + * const data = input.read(); + * if (data) + * hash.update(data); + * else { + * console.log(`${hash.digest('hex')} ${filename}`); + * } + * }); + * ``` + * @param options `stream.transform` options + */ + function createHash(algorithm: string, options?: HashOptions): Hash; + /** + * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`. + * Optional `options` argument controls stream behavior. + * + * The `algorithm` is dependent on the available algorithms supported by the + * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc. + * On recent releases of OpenSSL, `openssl list -digest-algorithms` will + * display the available digest algorithms. + * + * The `key` is the HMAC key used to generate the cryptographic HMAC hash. If it is + * a `KeyObject`, its type must be `secret`. + * + * Example: generating the sha256 HMAC of a file + * + * ```js + * import { + * createReadStream + * } from 'fs'; + * import { argv } from 'process'; + * const { + * createHmac + * } = await import('crypto'); + * + * const filename = argv[2]; + * + * const hmac = createHmac('sha256', 'a secret'); + * + * const input = createReadStream(filename); + * input.on('readable', () => { + * // Only one element is going to be produced by the + * // hash stream. + * const data = input.read(); + * if (data) + * hmac.update(data); + * else { + * console.log(`${hmac.digest('hex')} ${filename}`); + * } + * }); + * ``` + * @param options `stream.transform` options + */ + function createHmac( + algorithm: string, + key: BinaryLike | KeyObject, + options?: stream.TransformOptions, + ): Hmac; + // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings + type BinaryToTextEncoding = "base64" | "base64url" | "hex" | "binary"; + type CharacterEncoding = "utf8" | "utf-8" | "utf16le" | "latin1"; + type LegacyCharacterEncoding = "ascii" | "binary" | "ucs2" | "ucs-2"; + type Encoding = + | BinaryToTextEncoding + | CharacterEncoding + | LegacyCharacterEncoding; + type ECDHKeyFormat = "compressed" | "uncompressed" | "hybrid"; + /** + * The `Hash` class is a utility for creating hash digests of data. It can be + * used in one of two ways: + * + * * As a `stream` that is both readable and writable, where data is written + * to produce a computed hash digest on the readable side, or + * * Using the `hash.update()` and `hash.digest()` methods to produce the + * computed hash. + * + * The {@link createHash} method is used to create `Hash` instances. `Hash`objects are not to be created directly using the `new` keyword. + * + * Example: Using `Hash` objects as streams: + * + * ```js + * const { + * createHash + * } = await import('crypto'); + * + * const hash = createHash('sha256'); + * + * hash.on('readable', () => { + * // Only one element is going to be produced by the + * // hash stream. + * const data = hash.read(); + * if (data) { + * console.log(data.toString('hex')); + * // Prints: + * // 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50 + * } + * }); + * + * hash.write('some data to hash'); + * hash.end(); + * ``` + * + * Example: Using `Hash` and piped streams: + * + * ```js + * import { createReadStream } from 'fs'; + * import { stdout } from 'process'; + * const { createHash } = await import('crypto'); + * + * const hash = createHash('sha256'); + * + * const input = createReadStream('test.js'); + * input.pipe(hash).setEncoding('hex').pipe(stdout); + * ``` + * + * Example: Using the `hash.update()` and `hash.digest()` methods: + * + * ```js + * const { + * createHash + * } = await import('crypto'); + * + * const hash = createHash('sha256'); + * + * hash.update('some data to hash'); + * console.log(hash.digest('hex')); + * // Prints: + * // 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50 + * ``` + */ + class Hash extends stream.Transform { + private constructor(); + /** + * Creates a new `Hash` object that contains a deep copy of the internal state + * of the current `Hash` object. + * + * The optional `options` argument controls stream behavior. For XOF hash + * functions such as `'shake256'`, the `outputLength` option can be used to + * specify the desired output length in bytes. + * + * An error is thrown when an attempt is made to copy the `Hash` object after + * its `hash.digest()` method has been called. + * + * ```js + * // Calculate a rolling hash. + * const { + * createHash + * } = await import('crypto'); + * + * const hash = createHash('sha256'); + * + * hash.update('one'); + * console.log(hash.copy().digest('hex')); + * + * hash.update('two'); + * console.log(hash.copy().digest('hex')); + * + * hash.update('three'); + * console.log(hash.copy().digest('hex')); + * + * // Etc. + * ``` + * @param options `stream.transform` options + */ + copy(options?: stream.TransformOptions): Hash; + /** + * Updates the hash content with the given `data`, the encoding of which + * is given in `inputEncoding`. + * If `encoding` is not provided, and the `data` is a string, an + * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored. + * + * This can be called many times with new data as it is streamed. + * @param inputEncoding The `encoding` of the `data` string. + */ + update(data: BinaryLike): Hash; + update(data: string, inputEncoding: Encoding): Hash; + /** + * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method). + * If `encoding` is provided a string will be returned; otherwise + * a `Buffer` is returned. + * + * The `Hash` object can not be used again after `hash.digest()` method has been + * called. Multiple calls will cause an error to be thrown. + * @param encoding The `encoding` of the return value. + */ + digest(): Buffer; + digest(encoding: BinaryToTextEncoding): string; + } + /** + * The `Hmac` class is a utility for creating cryptographic HMAC digests. It can + * be used in one of two ways: + * + * * As a `stream` that is both readable and writable, where data is written + * to produce a computed HMAC digest on the readable side, or + * * Using the `hmac.update()` and `hmac.digest()` methods to produce the + * computed HMAC digest. + * + * The {@link createHmac} method is used to create `Hmac` instances. `Hmac`objects are not to be created directly using the `new` keyword. + * + * Example: Using `Hmac` objects as streams: + * + * ```js + * const { + * createHmac + * } = await import('crypto'); + * + * const hmac = createHmac('sha256', 'a secret'); + * + * hmac.on('readable', () => { + * // Only one element is going to be produced by the + * // hash stream. + * const data = hmac.read(); + * if (data) { + * console.log(data.toString('hex')); + * // Prints: + * // 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e + * } + * }); + * + * hmac.write('some data to hash'); + * hmac.end(); + * ``` + * + * Example: Using `Hmac` and piped streams: + * + * ```js + * import { createReadStream } from 'fs'; + * import { stdout } from 'process'; + * const { + * createHmac + * } = await import('crypto'); + * + * const hmac = createHmac('sha256', 'a secret'); + * + * const input = createReadStream('test.js'); + * input.pipe(hmac).pipe(stdout); + * ``` + * + * Example: Using the `hmac.update()` and `hmac.digest()` methods: + * + * ```js + * const { + * createHmac + * } = await import('crypto'); + * + * const hmac = createHmac('sha256', 'a secret'); + * + * hmac.update('some data to hash'); + * console.log(hmac.digest('hex')); + * // Prints: + * // 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e + * ``` + */ + class Hmac extends stream.Transform { + private constructor(); + /** + * Updates the `Hmac` content with the given `data`, the encoding of which + * is given in `inputEncoding`. + * If `encoding` is not provided, and the `data` is a string, an + * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored. + * + * This can be called many times with new data as it is streamed. + * @param inputEncoding The `encoding` of the `data` string. + */ + update(data: BinaryLike): Hmac; + update(data: string, inputEncoding: Encoding): Hmac; + /** + * Calculates the HMAC digest of all of the data passed using `hmac.update()`. + * If `encoding` is + * provided a string is returned; otherwise a `Buffer` is returned; + * + * The `Hmac` object can not be used again after `hmac.digest()` has been + * called. Multiple calls to `hmac.digest()` will result in an error being thrown. + * @param encoding The `encoding` of the return value. + */ + digest(): Buffer; + digest(encoding: BinaryToTextEncoding): string; + } + type KeyObjectType = "secret" | "public" | "private"; + interface KeyExportOptions { + type: "pkcs1" | "spki" | "pkcs8" | "sec1"; + format: T; + cipher?: string | undefined; + passphrase?: string | Buffer | undefined; + } + interface JwkKeyExportOptions { + format: "jwk"; + } + interface JsonWebKey { + crv?: string | undefined; + d?: string | undefined; + dp?: string | undefined; + dq?: string | undefined; + e?: string | undefined; + k?: string | undefined; + kty?: string | undefined; + n?: string | undefined; + p?: string | undefined; + q?: string | undefined; + qi?: string | undefined; + x?: string | undefined; + y?: string | undefined; + [key: string]: unknown; + } + interface AsymmetricKeyDetails { + /** + * Key size in bits (RSA, DSA). + */ + modulusLength?: number | undefined; + /** + * Public exponent (RSA). + */ + publicExponent?: bigint | undefined; + /** + * Name of the message digest (RSA-PSS). + */ + hashAlgorithm?: string | undefined; + /** + * Name of the message digest used by MGF1 (RSA-PSS). + */ + mgf1HashAlgorithm?: string | undefined; + /** + * Minimal salt length in bytes (RSA-PSS). + */ + saltLength?: number | undefined; + /** + * Size of q in bits (DSA). + */ + divisorLength?: number | undefined; + /** + * Name of the curve (EC). + */ + namedCurve?: string | undefined; + } + interface JwkKeyExportOptions { + format: "jwk"; + } + /** + * Node.js uses a `KeyObject` class to represent a symmetric or asymmetric key, + * and each kind of key exposes different functions. The {@link createSecretKey}, {@link createPublicKey} and {@link createPrivateKey} methods are used to create `KeyObject`instances. `KeyObject` + * objects are not to be created directly using the `new`keyword. + * + * Most applications should consider using the new `KeyObject` API instead of + * passing keys as strings or `Buffer`s due to improved security features. + * + * `KeyObject` instances can be passed to other threads via `postMessage()`. + * The receiver obtains a cloned `KeyObject`, and the `KeyObject` does not need to + * be listed in the `transferList` argument. + */ + class KeyObject { + private constructor(); + /** + * Example: Converting a `CryptoKey` instance to a `KeyObject`: + * + * ```js + * const { webcrypto, KeyObject } = await import('crypto'); + * const { subtle } = webcrypto; + * + * const key = await subtle.generateKey({ + * name: 'HMAC', + * hash: 'SHA-256', + * length: 256 + * }, true, ['sign', 'verify']); + * + * const keyObject = KeyObject.from(key); + * console.log(keyObject.symmetricKeySize); + * // Prints: 32 (symmetric key size in bytes) + * ``` + */ + // static from(key: webcrypto.CryptoKey): KeyObject; + /** + * For asymmetric keys, this property represents the type of the key. Supported key + * types are: + * + * * `'rsa'` (OID 1.2.840.113549.1.1.1) + * * `'rsa-pss'` (OID 1.2.840.113549.1.1.10) + * * `'dsa'` (OID 1.2.840.10040.4.1) + * * `'ec'` (OID 1.2.840.10045.2.1) + * * `'x25519'` (OID 1.3.101.110) + * * `'x448'` (OID 1.3.101.111) + * * `'ed25519'` (OID 1.3.101.112) + * * `'ed448'` (OID 1.3.101.113) + * * `'dh'` (OID 1.2.840.113549.1.3.1) + * + * This property is `undefined` for unrecognized `KeyObject` types and symmetric + * keys. + */ + asymmetricKeyType?: KeyType | undefined; + /** + * For asymmetric keys, this property represents the size of the embedded key in + * bytes. This property is `undefined` for symmetric keys. + */ + asymmetricKeySize?: number | undefined; + /** + * This property exists only on asymmetric keys. Depending on the type of the key, + * this object contains information about the key. None of the information obtained + * through this property can be used to uniquely identify a key or to compromise + * the security of the key. + * + * For RSA-PSS keys, if the key material contains a `RSASSA-PSS-params` sequence, + * the `hashAlgorithm`, `mgf1HashAlgorithm`, and `saltLength` properties will be + * set. + * + * Other key details might be exposed via this API using additional attributes. + */ + asymmetricKeyDetails?: AsymmetricKeyDetails | undefined; + /** + * For symmetric keys, the following encoding options can be used: + * + * For public keys, the following encoding options can be used: + * + * For private keys, the following encoding options can be used: + * + * The result type depends on the selected encoding format, when PEM the + * result is a string, when DER it will be a buffer containing the data + * encoded as DER, when [JWK](https://tools.ietf.org/html/rfc7517) it will be an object. + * + * When [JWK](https://tools.ietf.org/html/rfc7517) encoding format was selected, all other encoding options are + * ignored. + * + * PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of + * the `cipher` and `format` options. The PKCS#8 `type` can be used with any`format` to encrypt any key algorithm (RSA, EC, or DH) by specifying a`cipher`. PKCS#1 and SEC1 can only be + * encrypted by specifying a `cipher`when the PEM `format` is used. For maximum compatibility, use PKCS#8 for + * encrypted private keys. Since PKCS#8 defines its own + * encryption mechanism, PEM-level encryption is not supported when encrypting + * a PKCS#8 key. See [RFC 5208](https://www.rfc-editor.org/rfc/rfc5208.txt) for PKCS#8 encryption and [RFC 1421](https://www.rfc-editor.org/rfc/rfc1421.txt) for + * PKCS#1 and SEC1 encryption. + */ + export(options: KeyExportOptions<"pem">): string | Buffer; + export(options?: KeyExportOptions<"der">): Buffer; + export(options?: JwkKeyExportOptions): JsonWebKey; + /** + * For secret keys, this property represents the size of the key in bytes. This + * property is `undefined` for asymmetric keys. + */ + symmetricKeySize?: number | undefined; + /** + * Depending on the type of this `KeyObject`, this property is either`'secret'` for secret (symmetric) keys, `'public'` for public (asymmetric) keys + * or `'private'` for private (asymmetric) keys. + */ + type: KeyObjectType; + } + type CipherCCMTypes = + | "aes-128-ccm" + | "aes-192-ccm" + | "aes-256-ccm" + | "chacha20-poly1305"; + type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm"; + type CipherOCBTypes = "aes-128-ocb" | "aes-192-ocb" | "aes-256-ocb"; + type BinaryLike = string | ArrayBufferView; + type CipherKey = BinaryLike | KeyObject; + interface CipherCCMOptions extends stream.TransformOptions { + authTagLength: number; + } + interface CipherGCMOptions extends stream.TransformOptions { + authTagLength?: number | undefined; + } + interface CipherOCBOptions extends stream.TransformOptions { + authTagLength: number; + } + /** + * Creates and returns a `Cipher` object that uses the given `algorithm` and`password`. + * + * The `options` argument controls stream behavior and is optional except when a + * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the + * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication + * tag that will be returned by `getAuthTag()` and defaults to 16 bytes. + * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes. + * + * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On + * recent OpenSSL releases, `openssl list -cipher-algorithms` will + * display the available cipher algorithms. + * + * The `password` is used to derive the cipher key and initialization vector (IV). + * The value must be either a `'latin1'` encoded string, a `Buffer`, a`TypedArray`, or a `DataView`. + * + * The implementation of `crypto.createCipher()` derives keys using the OpenSSL + * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) with the digest algorithm set to MD5, one + * iteration, and no salt. The lack of salt allows dictionary attacks as the same + * password always creates the same key. The low iteration count and + * non-cryptographically secure hash algorithm allow passwords to be tested very + * rapidly. + * + * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that + * developers derive a key and IV on + * their own using {@link scrypt} and to use {@link createCipheriv} to create the `Cipher` object. Users should not use ciphers with counter mode + * (e.g. CTR, GCM, or CCM) in `crypto.createCipher()`. A warning is emitted when + * they are used in order to avoid the risk of IV reuse that causes + * vulnerabilities. For the case when IV is reused in GCM, see [Nonce-Disrespecting Adversaries](https://github.com/nonce-disrespect/nonce-disrespect) for details. + * @deprecated Since v10.0.0 - Use {@link createCipheriv} instead. + * @param options `stream.transform` options + */ + function createCipher( + algorithm: CipherCCMTypes, + password: BinaryLike, + options: CipherCCMOptions, + ): CipherCCM; + /** @deprecated since v10.0.0 use `createCipheriv()` */ + function createCipher( + algorithm: CipherGCMTypes, + password: BinaryLike, + options?: CipherGCMOptions, + ): CipherGCM; + /** @deprecated since v10.0.0 use `createCipheriv()` */ + function createCipher( + algorithm: string, + password: BinaryLike, + options?: stream.TransformOptions, + ): Cipher; + /** + * Creates and returns a `Cipher` object, with the given `algorithm`, `key` and + * initialization vector (`iv`). + * + * The `options` argument controls stream behavior and is optional except when a + * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the + * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication + * tag that will be returned by `getAuthTag()` and defaults to 16 bytes. + * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes. + * + * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On + * recent OpenSSL releases, `openssl list -cipher-algorithms` will + * display the available cipher algorithms. + * + * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded + * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be + * a `KeyObject` of type `secret`. If the cipher does not need + * an initialization vector, `iv` may be `null`. + * + * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * Initialization vectors should be unpredictable and unique; ideally, they will be + * cryptographically random. They do not have to be secret: IVs are typically just + * added to ciphertext messages unencrypted. It may sound contradictory that + * something has to be unpredictable and unique, but does not have to be secret; + * remember that an attacker must not be able to predict ahead of time what a + * given IV will be. + * @param options `stream.transform` options + */ + function createCipheriv( + algorithm: CipherCCMTypes, + key: CipherKey, + iv: BinaryLike, + options: CipherCCMOptions, + ): CipherCCM; + function createCipheriv( + algorithm: CipherOCBTypes, + key: CipherKey, + iv: BinaryLike, + options: CipherOCBOptions, + ): CipherOCB; + function createCipheriv( + algorithm: CipherGCMTypes, + key: CipherKey, + iv: BinaryLike, + options?: CipherGCMOptions, + ): CipherGCM; + function createCipheriv( + algorithm: string, + key: CipherKey, + iv: BinaryLike | null, + options?: stream.TransformOptions, + ): Cipher; + /** + * Instances of the `Cipher` class are used to encrypt data. The class can be + * used in one of two ways: + * + * * As a `stream` that is both readable and writable, where plain unencrypted + * data is written to produce encrypted data on the readable side, or + * * Using the `cipher.update()` and `cipher.final()` methods to produce + * the encrypted data. + * + * The {@link createCipher} or {@link createCipheriv} methods are + * used to create `Cipher` instances. `Cipher` objects are not to be created + * directly using the `new` keyword. + * + * Example: Using `Cipher` objects as streams: + * + * ```js + * const { + * scrypt, + * randomFill, + * createCipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * + * // First, we'll generate the key. The key length is dependent on the algorithm. + * // In this case for aes192, it is 24 bytes (192 bits). + * scrypt(password, 'salt', 24, (err, key) => { + * if (err) throw err; + * // Then, we'll generate a random initialization vector + * randomFill(new Uint8Array(16), (err, iv) => { + * if (err) throw err; + * + * // Once we have the key and iv, we can create and use the cipher... + * const cipher = createCipheriv(algorithm, key, iv); + * + * let encrypted = ''; + * cipher.setEncoding('hex'); + * + * cipher.on('data', (chunk) => encrypted += chunk); + * cipher.on('end', () => console.log(encrypted)); + * + * cipher.write('some clear text data'); + * cipher.end(); + * }); + * }); + * ``` + * + * Example: Using `Cipher` and piped streams: + * + * ```js + * import { + * createReadStream, + * createWriteStream, + * } from 'fs'; + * + * import { + * pipeline + * } from 'stream'; + * + * const { + * scrypt, + * randomFill, + * createCipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * + * // First, we'll generate the key. The key length is dependent on the algorithm. + * // In this case for aes192, it is 24 bytes (192 bits). + * scrypt(password, 'salt', 24, (err, key) => { + * if (err) throw err; + * // Then, we'll generate a random initialization vector + * randomFill(new Uint8Array(16), (err, iv) => { + * if (err) throw err; + * + * const cipher = createCipheriv(algorithm, key, iv); + * + * const input = createReadStream('test.js'); + * const output = createWriteStream('test.enc'); + * + * pipeline(input, cipher, output, (err) => { + * if (err) throw err; + * }); + * }); + * }); + * ``` + * + * Example: Using the `cipher.update()` and `cipher.final()` methods: + * + * ```js + * const { + * scrypt, + * randomFill, + * createCipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * + * // First, we'll generate the key. The key length is dependent on the algorithm. + * // In this case for aes192, it is 24 bytes (192 bits). + * scrypt(password, 'salt', 24, (err, key) => { + * if (err) throw err; + * // Then, we'll generate a random initialization vector + * randomFill(new Uint8Array(16), (err, iv) => { + * if (err) throw err; + * + * const cipher = createCipheriv(algorithm, key, iv); + * + * let encrypted = cipher.update('some clear text data', 'utf8', 'hex'); + * encrypted += cipher.final('hex'); + * console.log(encrypted); + * }); + * }); + * ``` + */ + class Cipher extends stream.Transform { + private constructor(); + /** + * Updates the cipher with `data`. If the `inputEncoding` argument is given, + * the `data`argument is a string using the specified encoding. If the `inputEncoding`argument is not given, `data` must be a `Buffer`, `TypedArray`, or`DataView`. If `data` is a `Buffer`, + * `TypedArray`, or `DataView`, then`inputEncoding` is ignored. + * + * The `outputEncoding` specifies the output format of the enciphered + * data. If the `outputEncoding`is specified, a string using the specified encoding is returned. If no`outputEncoding` is provided, a `Buffer` is returned. + * + * The `cipher.update()` method can be called multiple times with new data until `cipher.final()` is called. Calling `cipher.update()` after `cipher.final()` will result in an error being + * thrown. + * @param inputEncoding The `encoding` of the data. + * @param outputEncoding The `encoding` of the return value. + */ + update(data: BinaryLike): Buffer; + update(data: string, inputEncoding: Encoding): Buffer; + update( + data: ArrayBufferView, + inputEncoding: undefined, + outputEncoding: Encoding, + ): string; + update( + data: string, + inputEncoding: Encoding | undefined, + outputEncoding: Encoding, + ): string; + /** + * Once the `cipher.final()` method has been called, the `Cipher` object can no + * longer be used to encrypt data. Attempts to call `cipher.final()` more than + * once will result in an error being thrown. + * @param outputEncoding The `encoding` of the return value. + * @return Any remaining enciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned. + */ + final(): Buffer; + final(outputEncoding: BufferEncoding): string; + /** + * When using block encryption algorithms, the `Cipher` class will automatically + * add padding to the input data to the appropriate block size. To disable the + * default padding call `cipher.setAutoPadding(false)`. + * + * When `autoPadding` is `false`, the length of the entire input data must be a + * multiple of the cipher's block size or `cipher.final()` will throw an error. + * Disabling automatic padding is useful for non-standard padding, for instance + * using `0x0` instead of PKCS padding. + * + * The `cipher.setAutoPadding()` method must be called before `cipher.final()`. + * @param [autoPadding=true] + * @return for method chaining. + */ + setAutoPadding(autoPadding?: boolean): this; + } + interface CipherCCM extends Cipher { + setAAD( + buffer: ArrayBufferView, + options: { + plaintextLength: number; + }, + ): this; + getAuthTag(): Buffer; + } + interface CipherGCM extends Cipher { + setAAD( + buffer: ArrayBufferView, + options?: { + plaintextLength: number; + }, + ): this; + getAuthTag(): Buffer; + } + interface CipherOCB extends Cipher { + setAAD( + buffer: ArrayBufferView, + options?: { + plaintextLength: number; + }, + ): this; + getAuthTag(): Buffer; + } + /** + * Creates and returns a `Decipher` object that uses the given `algorithm` and`password` (key). + * + * The `options` argument controls stream behavior and is optional except when a + * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the + * authentication tag in bytes, see `CCM mode`. + * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes. + * + * The implementation of `crypto.createDecipher()` derives keys using the OpenSSL + * function [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) with the digest algorithm set to MD5, one + * iteration, and no salt. The lack of salt allows dictionary attacks as the same + * password always creates the same key. The low iteration count and + * non-cryptographically secure hash algorithm allow passwords to be tested very + * rapidly. + * + * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that + * developers derive a key and IV on + * their own using {@link scrypt} and to use {@link createDecipheriv} to create the `Decipher` object. + * @deprecated Since v10.0.0 - Use {@link createDecipheriv} instead. + * @param options `stream.transform` options + */ + function createDecipher( + algorithm: CipherCCMTypes, + password: BinaryLike, + options: CipherCCMOptions, + ): DecipherCCM; + /** @deprecated since v10.0.0 use `createDecipheriv()` */ + function createDecipher( + algorithm: CipherGCMTypes, + password: BinaryLike, + options?: CipherGCMOptions, + ): DecipherGCM; + /** @deprecated since v10.0.0 use `createDecipheriv()` */ + function createDecipher( + algorithm: string, + password: BinaryLike, + options?: stream.TransformOptions, + ): Decipher; + /** + * Creates and returns a `Decipher` object that uses the given `algorithm`, `key`and initialization vector (`iv`). + * + * The `options` argument controls stream behavior and is optional except when a + * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the + * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to restrict accepted authentication tags + * to those with the specified length. + * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes. + * + * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On + * recent OpenSSL releases, `openssl list -cipher-algorithms` will + * display the available cipher algorithms. + * + * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded + * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be + * a `KeyObject` of type `secret`. If the cipher does not need + * an initialization vector, `iv` may be `null`. + * + * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * Initialization vectors should be unpredictable and unique; ideally, they will be + * cryptographically random. They do not have to be secret: IVs are typically just + * added to ciphertext messages unencrypted. It may sound contradictory that + * something has to be unpredictable and unique, but does not have to be secret; + * remember that an attacker must not be able to predict ahead of time what a given + * IV will be. + * @param options `stream.transform` options + */ + function createDecipheriv( + algorithm: CipherCCMTypes, + key: CipherKey, + iv: BinaryLike, + options: CipherCCMOptions, + ): DecipherCCM; + function createDecipheriv( + algorithm: CipherOCBTypes, + key: CipherKey, + iv: BinaryLike, + options: CipherOCBOptions, + ): DecipherOCB; + function createDecipheriv( + algorithm: CipherGCMTypes, + key: CipherKey, + iv: BinaryLike, + options?: CipherGCMOptions, + ): DecipherGCM; + function createDecipheriv( + algorithm: string, + key: CipherKey, + iv: BinaryLike | null, + options?: stream.TransformOptions, + ): Decipher; + /** + * Instances of the `Decipher` class are used to decrypt data. The class can be + * used in one of two ways: + * + * * As a `stream` that is both readable and writable, where plain encrypted + * data is written to produce unencrypted data on the readable side, or + * * Using the `decipher.update()` and `decipher.final()` methods to + * produce the unencrypted data. + * + * The {@link createDecipher} or {@link createDecipheriv} methods are + * used to create `Decipher` instances. `Decipher` objects are not to be created + * directly using the `new` keyword. + * + * Example: Using `Decipher` objects as streams: + * + * ```js + * import { Buffer } from 'buffer'; + * const { + * scryptSync, + * createDecipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * // Key length is dependent on the algorithm. In this case for aes192, it is + * // 24 bytes (192 bits). + * // Use the async `crypto.scrypt()` instead. + * const key = scryptSync(password, 'salt', 24); + * // The IV is usually passed along with the ciphertext. + * const iv = Buffer.alloc(16, 0); // Initialization vector. + * + * const decipher = createDecipheriv(algorithm, key, iv); + * + * let decrypted = ''; + * decipher.on('readable', () => { + * while (null !== (chunk = decipher.read())) { + * decrypted += chunk.toString('utf8'); + * } + * }); + * decipher.on('end', () => { + * console.log(decrypted); + * // Prints: some clear text data + * }); + * + * // Encrypted with same algorithm, key and iv. + * const encrypted = + * 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'; + * decipher.write(encrypted, 'hex'); + * decipher.end(); + * ``` + * + * Example: Using `Decipher` and piped streams: + * + * ```js + * import { + * createReadStream, + * createWriteStream, + * } from 'fs'; + * import { Buffer } from 'buffer'; + * const { + * scryptSync, + * createDecipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * // Use the async `crypto.scrypt()` instead. + * const key = scryptSync(password, 'salt', 24); + * // The IV is usually passed along with the ciphertext. + * const iv = Buffer.alloc(16, 0); // Initialization vector. + * + * const decipher = createDecipheriv(algorithm, key, iv); + * + * const input = createReadStream('test.enc'); + * const output = createWriteStream('test.js'); + * + * input.pipe(decipher).pipe(output); + * ``` + * + * Example: Using the `decipher.update()` and `decipher.final()` methods: + * + * ```js + * import { Buffer } from 'buffer'; + * const { + * scryptSync, + * createDecipheriv + * } = await import('crypto'); + * + * const algorithm = 'aes-192-cbc'; + * const password = 'Password used to generate key'; + * // Use the async `crypto.scrypt()` instead. + * const key = scryptSync(password, 'salt', 24); + * // The IV is usually passed along with the ciphertext. + * const iv = Buffer.alloc(16, 0); // Initialization vector. + * + * const decipher = createDecipheriv(algorithm, key, iv); + * + * // Encrypted using same algorithm, key and iv. + * const encrypted = + * 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'; + * let decrypted = decipher.update(encrypted, 'hex', 'utf8'); + * decrypted += decipher.final('utf8'); + * console.log(decrypted); + * // Prints: some clear text data + * ``` + */ + class Decipher extends stream.Transform { + private constructor(); + /** + * Updates the decipher with `data`. If the `inputEncoding` argument is given, + * the `data`argument is a string using the specified encoding. If the `inputEncoding`argument is not given, `data` must be a `Buffer`. If `data` is a `Buffer` then `inputEncoding` is + * ignored. + * + * The `outputEncoding` specifies the output format of the enciphered + * data. If the `outputEncoding`is specified, a string using the specified encoding is returned. If no`outputEncoding` is provided, a `Buffer` is returned. + * + * The `decipher.update()` method can be called multiple times with new data until `decipher.final()` is called. Calling `decipher.update()` after `decipher.final()` will result in an error + * being thrown. + * @param inputEncoding The `encoding` of the `data` string. + * @param outputEncoding The `encoding` of the return value. + */ + update(data: ArrayBufferView): Buffer; + update(data: string, inputEncoding: Encoding): Buffer; + update( + data: ArrayBufferView, + inputEncoding: undefined, + outputEncoding: Encoding, + ): string; + update( + data: string, + inputEncoding: Encoding | undefined, + outputEncoding: Encoding, + ): string; + /** + * Once the `decipher.final()` method has been called, the `Decipher` object can + * no longer be used to decrypt data. Attempts to call `decipher.final()` more + * than once will result in an error being thrown. + * @param outputEncoding The `encoding` of the return value. + * @return Any remaining deciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned. + */ + final(): Buffer; + final(outputEncoding: BufferEncoding): string; + /** + * When data has been encrypted without standard block padding, calling`decipher.setAutoPadding(false)` will disable automatic padding to prevent `decipher.final()` from checking for and + * removing padding. + * + * Turning auto padding off will only work if the input data's length is a + * multiple of the ciphers block size. + * + * The `decipher.setAutoPadding()` method must be called before `decipher.final()`. + * @param [autoPadding=true] + * @return for method chaining. + */ + setAutoPadding(auto_padding?: boolean): this; + } + interface DecipherCCM extends Decipher { + setAuthTag(buffer: ArrayBufferView): this; + setAAD( + buffer: ArrayBufferView, + options: { + plaintextLength: number; + }, + ): this; + } + interface DecipherGCM extends Decipher { + setAuthTag(buffer: ArrayBufferView): this; + setAAD( + buffer: ArrayBufferView, + options?: { + plaintextLength: number; + }, + ): this; + } + interface DecipherOCB extends Decipher { + setAuthTag(buffer: ArrayBufferView): this; + setAAD( + buffer: ArrayBufferView, + options?: { + plaintextLength: number; + }, + ): this; + } + interface PrivateKeyInput { + key: string | Buffer; + format?: KeyFormat | undefined; + type?: "pkcs1" | "pkcs8" | "sec1" | undefined; + passphrase?: string | Buffer | undefined; + } + interface PublicKeyInput { + key: string | Buffer; + format?: KeyFormat | undefined; + type?: "pkcs1" | "spki" | undefined; + } + /** + * Asynchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`. + * + * ```js + * const { + * generateKey + * } = await import('crypto'); + * + * generateKey('hmac', { length: 64 }, (err, key) => { + * if (err) throw err; + * console.log(key.export().toString('hex')); // 46e..........620 + * }); + * ``` + * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`. + */ + function generateKey( + type: "hmac" | "aes", + options: { + length: number; + }, + callback: (err: Error | null, key: KeyObject) => void, + ): void; + /** + * Synchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`. + * + * ```js + * const { + * generateKeySync + * } = await import('crypto'); + * + * const key = generateKeySync('hmac', { length: 64 }); + * console.log(key.export().toString('hex')); // e89..........41e + * ``` + * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`. + */ + function generateKeySync( + type: "hmac" | "aes", + options: { + length: number; + }, + ): KeyObject; + interface JsonWebKeyInput { + key: JsonWebKey; + format: "jwk"; + } + /** + * Creates and returns a new key object containing a private key. If `key` is a + * string or `Buffer`, `format` is assumed to be `'pem'`; otherwise, `key`must be an object with the properties described above. + * + * If the private key is encrypted, a `passphrase` must be specified. The length + * of the passphrase is limited to 1024 bytes. + */ + function createPrivateKey( + key: PrivateKeyInput | string | Buffer | JsonWebKeyInput, + ): KeyObject; + /** + * Creates and returns a new key object containing a public key. If `key` is a + * string or `Buffer`, `format` is assumed to be `'pem'`; if `key` is a `KeyObject`with type `'private'`, the public key is derived from the given private key; + * otherwise, `key` must be an object with the properties described above. + * + * If the format is `'pem'`, the `'key'` may also be an X.509 certificate. + * + * Because public keys can be derived from private keys, a private key may be + * passed instead of a public key. In that case, this function behaves as if {@link createPrivateKey} had been called, except that the type of the + * returned `KeyObject` will be `'public'` and that the private key cannot be + * extracted from the returned `KeyObject`. Similarly, if a `KeyObject` with type`'private'` is given, a new `KeyObject` with type `'public'` will be returned + * and it will be impossible to extract the private key from the returned object. + */ + function createPublicKey( + key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput, + ): KeyObject; + /** + * Creates and returns a new key object containing a secret key for symmetric + * encryption or `Hmac`. + * @param encoding The string encoding when `key` is a string. + */ + function createSecretKey(key: ArrayBufferView): KeyObject; + function createSecretKey(key: string, encoding: BufferEncoding): KeyObject; + /** + * Creates and returns a `Sign` object that uses the given `algorithm`. Use {@link getHashes} to obtain the names of the available digest algorithms. + * Optional `options` argument controls the `stream.Writable` behavior. + * + * In some cases, a `Sign` instance can be created using the name of a signature + * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use + * the corresponding digest algorithm. This does not work for all signature + * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest + * algorithm names. + * @param options `stream.Writable` options + */ + function createSign( + algorithm: string, + options?: stream.WritableOptions, + ): Sign; + type DSAEncoding = "der" | "ieee-p1363"; + interface SigningOptions { + /** + * @See crypto.constants.RSA_PKCS1_PADDING + */ + padding?: number | undefined; + saltLength?: number | undefined; + dsaEncoding?: DSAEncoding | undefined; + } + interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {} + interface SignKeyObjectInput extends SigningOptions { + key: KeyObject; + } + interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {} + interface VerifyKeyObjectInput extends SigningOptions { + key: KeyObject; + } + type KeyLike = string | Buffer | KeyObject; + /** + * The `Sign` class is a utility for generating signatures. It can be used in one + * of two ways: + * + * * As a writable `stream`, where data to be signed is written and the `sign.sign()` method is used to generate and return the signature, or + * * Using the `sign.update()` and `sign.sign()` methods to produce the + * signature. + * + * The {@link createSign} method is used to create `Sign` instances. The + * argument is the string name of the hash function to use. `Sign` objects are not + * to be created directly using the `new` keyword. + * + * Example: Using `Sign` and `Verify` objects as streams: + * + * ```js + * const { + * generateKeyPairSync, + * createSign, + * createVerify + * } = await import('crypto'); + * + * const { privateKey, publicKey } = generateKeyPairSync('ec', { + * namedCurve: 'sect239k1' + * }); + * + * const sign = createSign('SHA256'); + * sign.write('some data to sign'); + * sign.end(); + * const signature = sign.sign(privateKey, 'hex'); + * + * const verify = createVerify('SHA256'); + * verify.write('some data to sign'); + * verify.end(); + * console.log(verify.verify(publicKey, signature, 'hex')); + * // Prints: true + * ``` + * + * Example: Using the `sign.update()` and `verify.update()` methods: + * + * ```js + * const { + * generateKeyPairSync, + * createSign, + * createVerify + * } = await import('crypto'); + * + * const { privateKey, publicKey } = generateKeyPairSync('rsa', { + * modulusLength: 2048, + * }); + * + * const sign = createSign('SHA256'); + * sign.update('some data to sign'); + * sign.end(); + * const signature = sign.sign(privateKey); + * + * const verify = createVerify('SHA256'); + * verify.update('some data to sign'); + * verify.end(); + * console.log(verify.verify(publicKey, signature)); + * // Prints: true + * ``` + */ + class Sign extends stream.Writable { + private constructor(); + /** + * Updates the `Sign` content with the given `data`, the encoding of which + * is given in `inputEncoding`. + * If `encoding` is not provided, and the `data` is a string, an + * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored. + * + * This can be called many times with new data as it is streamed. + * @param inputEncoding The `encoding` of the `data` string. + */ + update(data: BinaryLike): this; + update(data: string, inputEncoding: Encoding): this; + /** + * Calculates the signature on all the data passed through using either `sign.update()` or `sign.write()`. + * + * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an + * object, the following additional properties can be passed: + * + * If `outputEncoding` is provided a string is returned; otherwise a `Buffer` is returned. + * + * The `Sign` object can not be again used after `sign.sign()` method has been + * called. Multiple calls to `sign.sign()` will result in an error being thrown. + */ + sign( + privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput, + ): Buffer; + sign( + privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput, + outputFormat: BinaryToTextEncoding, + ): string; + } + /** + * Creates and returns a `Verify` object that uses the given algorithm. + * Use {@link getHashes} to obtain an array of names of the available + * signing algorithms. Optional `options` argument controls the`stream.Writable` behavior. + * + * In some cases, a `Verify` instance can be created using the name of a signature + * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use + * the corresponding digest algorithm. This does not work for all signature + * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest + * algorithm names. + * @param options `stream.Writable` options + */ + function createVerify( + algorithm: string, + options?: stream.WritableOptions, + ): Verify; + /** + * The `Verify` class is a utility for verifying signatures. It can be used in one + * of two ways: + * + * * As a writable `stream` where written data is used to validate against the + * supplied signature, or + * * Using the `verify.update()` and `verify.verify()` methods to verify + * the signature. + * + * The {@link createVerify} method is used to create `Verify` instances.`Verify` objects are not to be created directly using the `new` keyword. + * + * See `Sign` for examples. + */ + class Verify extends stream.Writable { + private constructor(); + /** + * Updates the `Verify` content with the given `data`, the encoding of which + * is given in `inputEncoding`. + * If `inputEncoding` is not provided, and the `data` is a string, an + * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored. + * + * This can be called many times with new data as it is streamed. + * @param inputEncoding The `encoding` of the `data` string. + */ + update(data: BinaryLike): Verify; + update(data: string, inputEncoding: Encoding): Verify; + /** + * Verifies the provided data using the given `object` and `signature`. + * + * If `object` is not a `KeyObject`, this function behaves as if`object` had been passed to {@link createPublicKey}. If it is an + * object, the following additional properties can be passed: + * + * The `signature` argument is the previously calculated signature for the data, in + * the `signatureEncoding`. + * If a `signatureEncoding` is specified, the `signature` is expected to be a + * string; otherwise `signature` is expected to be a `Buffer`,`TypedArray`, or `DataView`. + * + * The `verify` object can not be used again after `verify.verify()` has been + * called. Multiple calls to `verify.verify()` will result in an error being + * thrown. + * + * Because public keys can be derived from private keys, a private key may + * be passed instead of a public key. + */ + verify( + object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: ArrayBufferView, + ): boolean; + verify( + object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: string, + signature_format?: BinaryToTextEncoding, + ): boolean; + } + /** + * Creates a `DiffieHellman` key exchange object using the supplied `prime` and an + * optional specific `generator`. + * + * The `generator` argument can be a number, string, or `Buffer`. If`generator` is not specified, the value `2` is used. + * + * If `primeEncoding` is specified, `prime` is expected to be a string; otherwise + * a `Buffer`, `TypedArray`, or `DataView` is expected. + * + * If `generatorEncoding` is specified, `generator` is expected to be a string; + * otherwise a number, `Buffer`, `TypedArray`, or `DataView` is expected. + * @param primeEncoding The `encoding` of the `prime` string. + * @param [generator=2] + * @param generatorEncoding The `encoding` of the `generator` string. + */ + function createDiffieHellman( + primeLength: number, + generator?: number | ArrayBufferView, + ): DiffieHellman; + function createDiffieHellman(prime: ArrayBufferView): DiffieHellman; + function createDiffieHellman( + prime: string, + primeEncoding: BinaryToTextEncoding, + ): DiffieHellman; + function createDiffieHellman( + prime: string, + primeEncoding: BinaryToTextEncoding, + generator: number | ArrayBufferView, + ): DiffieHellman; + function createDiffieHellman( + prime: string, + primeEncoding: BinaryToTextEncoding, + generator: string, + generatorEncoding: BinaryToTextEncoding, + ): DiffieHellman; + /** + * The `DiffieHellman` class is a utility for creating Diffie-Hellman key + * exchanges. + * + * Instances of the `DiffieHellman` class can be created using the {@link createDiffieHellman} function. + * + * ```js + * import assert from 'assert'; + * + * const { + * createDiffieHellman + * } = await import('crypto'); + * + * // Generate Alice's keys... + * const alice = createDiffieHellman(2048); + * const aliceKey = alice.generateKeys(); + * + * // Generate Bob's keys... + * const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator()); + * const bobKey = bob.generateKeys(); + * + * // Exchange and generate the secret... + * const aliceSecret = alice.computeSecret(bobKey); + * const bobSecret = bob.computeSecret(aliceKey); + * + * // OK + * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex')); + * ``` + */ + class DiffieHellman { + private constructor(); + /** + * Generates private and public Diffie-Hellman key values, and returns + * the public key in the specified `encoding`. This key should be + * transferred to the other party. + * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + */ + generateKeys(): Buffer; + generateKeys(encoding: BinaryToTextEncoding): string; + /** + * Computes the shared secret using `otherPublicKey` as the other + * party's public key and returns the computed shared secret. The supplied + * key is interpreted using the specified `inputEncoding`, and secret is + * encoded using specified `outputEncoding`. + * If the `inputEncoding` is not + * provided, `otherPublicKey` is expected to be a `Buffer`,`TypedArray`, or `DataView`. + * + * If `outputEncoding` is given a string is returned; otherwise, a `Buffer` is returned. + * @param inputEncoding The `encoding` of an `otherPublicKey` string. + * @param outputEncoding The `encoding` of the return value. + */ + computeSecret(otherPublicKey: ArrayBufferView): Buffer; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + ): Buffer; + computeSecret( + otherPublicKey: ArrayBufferView, + outputEncoding: BinaryToTextEncoding, + ): string; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + outputEncoding: BinaryToTextEncoding, + ): string; + /** + * Returns the Diffie-Hellman prime in the specified `encoding`. + * If `encoding` is provided a string is + * returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + */ + getPrime(): Buffer; + getPrime(encoding: BinaryToTextEncoding): string; + /** + * Returns the Diffie-Hellman generator in the specified `encoding`. + * If `encoding` is provided a string is + * returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + */ + getGenerator(): Buffer; + getGenerator(encoding: BinaryToTextEncoding): string; + /** + * Returns the Diffie-Hellman public key in the specified `encoding`. + * If `encoding` is provided a + * string is returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + */ + getPublicKey(): Buffer; + getPublicKey(encoding: BinaryToTextEncoding): string; + /** + * Returns the Diffie-Hellman private key in the specified `encoding`. + * If `encoding` is provided a + * string is returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + */ + getPrivateKey(): Buffer; + getPrivateKey(encoding: BinaryToTextEncoding): string; + /** + * Sets the Diffie-Hellman public key. If the `encoding` argument is provided,`publicKey` is expected + * to be a string. If no `encoding` is provided, `publicKey` is expected + * to be a `Buffer`, `TypedArray`, or `DataView`. + * @param encoding The `encoding` of the `publicKey` string. + */ + setPublicKey(publicKey: ArrayBufferView): void; + setPublicKey(publicKey: string, encoding: BufferEncoding): void; + /** + * Sets the Diffie-Hellman private key. If the `encoding` argument is provided,`privateKey` is expected + * to be a string. If no `encoding` is provided, `privateKey` is expected + * to be a `Buffer`, `TypedArray`, or `DataView`. + * @param encoding The `encoding` of the `privateKey` string. + */ + setPrivateKey(privateKey: ArrayBufferView): void; + setPrivateKey(privateKey: string, encoding: BufferEncoding): void; + /** + * A bit field containing any warnings and/or errors resulting from a check + * performed during initialization of the `DiffieHellman` object. + * + * The following values are valid for this property (as defined in `constants`module): + * + * * `DH_CHECK_P_NOT_SAFE_PRIME` + * * `DH_CHECK_P_NOT_PRIME` + * * `DH_UNABLE_TO_CHECK_GENERATOR` + * * `DH_NOT_SUITABLE_GENERATOR` + */ + verifyError: number; + } + /** + * Creates a predefined `DiffieHellmanGroup` key exchange object. The + * supported groups are: `'modp1'`, `'modp2'`, `'modp5'` (defined in [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt), but see `Caveats`) and `'modp14'`, `'modp15'`,`'modp16'`, `'modp17'`, + * `'modp18'` (defined in [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt)). The + * returned object mimics the interface of objects created by {@link createDiffieHellman}, but will not allow changing + * the keys (with `diffieHellman.setPublicKey()`, for example). The + * advantage of using this method is that the parties do not have to + * generate nor exchange a group modulus beforehand, saving both processor + * and communication time. + * + * Example (obtaining a shared secret): + * + * ```js + * const { + * getDiffieHellman + * } = await import('crypto'); + * const alice = getDiffieHellman('modp14'); + * const bob = getDiffieHellman('modp14'); + * + * alice.generateKeys(); + * bob.generateKeys(); + * + * const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex'); + * const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex'); + * + * // aliceSecret and bobSecret should be the same + * console.log(aliceSecret === bobSecret); + * ``` + */ + function getDiffieHellman(groupName: string): DiffieHellman; + /** + * Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2) + * implementation. A selected HMAC digest algorithm specified by `digest` is + * applied to derive a key of the requested byte length (`keylen`) from the`password`, `salt` and `iterations`. + * + * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an error occurs while deriving the key, `err` will be set; + * otherwise `err` will be `null`. By default, the successfully generated`derivedKey` will be passed to the callback as a `Buffer`. An error will be + * thrown if any of the input arguments specify invalid values or types. + * + * If `digest` is `null`, `'sha1'` will be used. This behavior is deprecated, + * please specify a `digest` explicitly. + * + * The `iterations` argument must be a number set as high as possible. The + * higher the number of iterations, the more secure the derived key will be, + * but will take a longer amount of time to complete. + * + * The `salt` should be as unique as possible. It is recommended that a salt is + * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details. + * + * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * ```js + * const { + * pbkdf2 + * } = await import('crypto'); + * + * pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => { + * if (err) throw err; + * console.log(derivedKey.toString('hex')); // '3745e48...08d59ae' + * }); + * ``` + * + * The `crypto.DEFAULT_ENCODING` property can be used to change the way the`derivedKey` is passed to the callback. This property, however, has been + * deprecated and use should be avoided. + * + * ```js + * import crypto from 'crypto'; + * crypto.DEFAULT_ENCODING = 'hex'; + * crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, derivedKey) => { + * if (err) throw err; + * console.log(derivedKey); // '3745e48...aa39b34' + * }); + * ``` + * + * An array of supported digest functions can be retrieved using {@link getHashes}. + * + * This API uses libuv's threadpool, which can have surprising and + * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information. + */ + function pbkdf2( + password: BinaryLike, + salt: BinaryLike, + iterations: number, + keylen: number, + digest: string, + callback: (err: Error | null, derivedKey: Buffer) => void, + ): void; + /** + * Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2) + * implementation. A selected HMAC digest algorithm specified by `digest` is + * applied to derive a key of the requested byte length (`keylen`) from the`password`, `salt` and `iterations`. + * + * If an error occurs an `Error` will be thrown, otherwise the derived key will be + * returned as a `Buffer`. + * + * If `digest` is `null`, `'sha1'` will be used. This behavior is deprecated, + * please specify a `digest` explicitly. + * + * The `iterations` argument must be a number set as high as possible. The + * higher the number of iterations, the more secure the derived key will be, + * but will take a longer amount of time to complete. + * + * The `salt` should be as unique as possible. It is recommended that a salt is + * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details. + * + * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * ```js + * const { + * pbkdf2Sync + * } = await import('crypto'); + * + * const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512'); + * console.log(key.toString('hex')); // '3745e48...08d59ae' + * ``` + * + * The `crypto.DEFAULT_ENCODING` property may be used to change the way the`derivedKey` is returned. This property, however, is deprecated and use + * should be avoided. + * + * ```js + * import crypto from 'crypto'; + * crypto.DEFAULT_ENCODING = 'hex'; + * const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512'); + * console.log(key); // '3745e48...aa39b34' + * ``` + * + * An array of supported digest functions can be retrieved using {@link getHashes}. + */ + function pbkdf2Sync( + password: BinaryLike, + salt: BinaryLike, + iterations: number, + keylen: number, + digest: string, + ): Buffer; + /** + * Generates cryptographically strong pseudorandom data. The `size` argument + * is a number indicating the number of bytes to generate. + * + * If a `callback` function is provided, the bytes are generated asynchronously + * and the `callback` function is invoked with two arguments: `err` and `buf`. + * If an error occurs, `err` will be an `Error` object; otherwise it is `null`. The`buf` argument is a `Buffer` containing the generated bytes. + * + * ```js + * // Asynchronous + * const { + * randomBytes + * } = await import('crypto'); + * + * randomBytes(256, (err, buf) => { + * if (err) throw err; + * console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`); + * }); + * ``` + * + * If the `callback` function is not provided, the random bytes are generated + * synchronously and returned as a `Buffer`. An error will be thrown if + * there is a problem generating the bytes. + * + * ```js + * // Synchronous + * const { + * randomBytes + * } = await import('crypto'); + * + * const buf = randomBytes(256); + * console.log( + * `${buf.length} bytes of random data: ${buf.toString('hex')}`); + * ``` + * + * The `crypto.randomBytes()` method will not complete until there is + * sufficient entropy available. + * This should normally never take longer than a few milliseconds. The only time + * when generating the random bytes may conceivably block for a longer period of + * time is right after boot, when the whole system is still low on entropy. + * + * This API uses libuv's threadpool, which can have surprising and + * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information. + * + * The asynchronous version of `crypto.randomBytes()` is carried out in a single + * threadpool request. To minimize threadpool task length variation, partition + * large `randomBytes` requests when doing so as part of fulfilling a client + * request. + * @param size The number of bytes to generate. The `size` must not be larger than `2**31 - 1`. + * @return if the `callback` function is not provided. + */ + function randomBytes(size: number): Buffer; + function randomBytes( + size: number, + callback: (err: Error | null, buf: Buffer) => void, + ): void; + function pseudoRandomBytes(size: number): Buffer; + function pseudoRandomBytes( + size: number, + callback: (err: Error | null, buf: Buffer) => void, + ): void; + /** + * Return a random integer `n` such that `min <= n < max`. This + * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias). + * + * The range (`max - min`) must be less than 248. `min` and `max` must + * be [safe integers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger). + * + * If the `callback` function is not provided, the random integer is + * generated synchronously. + * + * ```js + * // Asynchronous + * const { + * randomInt + * } = await import('crypto'); + * + * randomInt(3, (err, n) => { + * if (err) throw err; + * console.log(`Random number chosen from (0, 1, 2): ${n}`); + * }); + * ``` + * + * ```js + * // Synchronous + * const { + * randomInt + * } = await import('crypto'); + * + * const n = randomInt(3); + * console.log(`Random number chosen from (0, 1, 2): ${n}`); + * ``` + * + * ```js + * // With `min` argument + * const { + * randomInt + * } = await import('crypto'); + * + * const n = randomInt(1, 7); + * console.log(`The dice rolled: ${n}`); + * ``` + * @param [min=0] Start of random range (inclusive). + * @param max End of random range (exclusive). + * @param callback `function(err, n) {}`. + */ + function randomInt(max: number): number; + function randomInt(min: number, max: number): number; + function randomInt( + max: number, + callback: (err: Error | null, value: number) => void, + ): void; + function randomInt( + min: number, + max: number, + callback: (err: Error | null, value: number) => void, + ): void; + /** + * Synchronous version of {@link randomFill}. + * + * ```js + * import { Buffer } from 'buffer'; + * const { randomFillSync } = await import('crypto'); + * + * const buf = Buffer.alloc(10); + * console.log(randomFillSync(buf).toString('hex')); + * + * randomFillSync(buf, 5); + * console.log(buf.toString('hex')); + * + * // The above is equivalent to the following: + * randomFillSync(buf, 5, 5); + * console.log(buf.toString('hex')); + * ``` + * + * Any `ArrayBuffer`, `TypedArray` or `DataView` instance may be passed as`buffer`. + * + * ```js + * import { Buffer } from 'buffer'; + * const { randomFillSync } = await import('crypto'); + * + * const a = new Uint32Array(10); + * console.log(Buffer.from(randomFillSync(a).buffer, + * a.byteOffset, a.byteLength).toString('hex')); + * + * const b = new DataView(new ArrayBuffer(10)); + * console.log(Buffer.from(randomFillSync(b).buffer, + * b.byteOffset, b.byteLength).toString('hex')); + * + * const c = new ArrayBuffer(10); + * console.log(Buffer.from(randomFillSync(c)).toString('hex')); + * ``` + * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`. + * @param [offset=0] + * @param [size=buffer.length - offset] + * @return The object passed as `buffer` argument. + */ + function randomFillSync( + buffer: T, + offset?: number, + size?: number, + ): T; + /** + * This function is similar to {@link randomBytes} but requires the first + * argument to be a `Buffer` that will be filled. It also + * requires that a callback is passed in. + * + * If the `callback` function is not provided, an error will be thrown. + * + * ```js + * import { Buffer } from 'buffer'; + * const { randomFill } = await import('crypto'); + * + * const buf = Buffer.alloc(10); + * randomFill(buf, (err, buf) => { + * if (err) throw err; + * console.log(buf.toString('hex')); + * }); + * + * randomFill(buf, 5, (err, buf) => { + * if (err) throw err; + * console.log(buf.toString('hex')); + * }); + * + * // The above is equivalent to the following: + * randomFill(buf, 5, 5, (err, buf) => { + * if (err) throw err; + * console.log(buf.toString('hex')); + * }); + * ``` + * + * Any `ArrayBuffer`, `TypedArray`, or `DataView` instance may be passed as`buffer`. + * + * While this includes instances of `Float32Array` and `Float64Array`, this + * function should not be used to generate random floating-point numbers. The + * result may contain `+Infinity`, `-Infinity`, and `NaN`, and even if the array + * contains finite numbers only, they are not drawn from a uniform random + * distribution and have no meaningful lower or upper bounds. + * + * ```js + * import { Buffer } from 'buffer'; + * const { randomFill } = await import('crypto'); + * + * const a = new Uint32Array(10); + * randomFill(a, (err, buf) => { + * if (err) throw err; + * console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength) + * .toString('hex')); + * }); + * + * const b = new DataView(new ArrayBuffer(10)); + * randomFill(b, (err, buf) => { + * if (err) throw err; + * console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength) + * .toString('hex')); + * }); + * + * const c = new ArrayBuffer(10); + * randomFill(c, (err, buf) => { + * if (err) throw err; + * console.log(Buffer.from(buf).toString('hex')); + * }); + * ``` + * + * This API uses libuv's threadpool, which can have surprising and + * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information. + * + * The asynchronous version of `crypto.randomFill()` is carried out in a single + * threadpool request. To minimize threadpool task length variation, partition + * large `randomFill` requests when doing so as part of fulfilling a client + * request. + * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`. + * @param [offset=0] + * @param [size=buffer.length - offset] + * @param callback `function(err, buf) {}`. + */ + function randomFill( + buffer: T, + callback: (err: Error | null, buf: T) => void, + ): void; + function randomFill( + buffer: T, + offset: number, + callback: (err: Error | null, buf: T) => void, + ): void; + function randomFill( + buffer: T, + offset: number, + size: number, + callback: (err: Error | null, buf: T) => void, + ): void; + interface ScryptOptions { + cost?: number | undefined; + blockSize?: number | undefined; + parallelization?: number | undefined; + N?: number | undefined; + r?: number | undefined; + p?: number | undefined; + maxmem?: number | undefined; + } + /** + * Provides an asynchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based + * key derivation function that is designed to be expensive computationally and + * memory-wise in order to make brute-force attacks unrewarding. + * + * The `salt` should be as unique as possible. It is recommended that a salt is + * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details. + * + * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * The `callback` function is called with two arguments: `err` and `derivedKey`.`err` is an exception object when key derivation fails, otherwise `err` is`null`. `derivedKey` is passed to the + * callback as a `Buffer`. + * + * An exception is thrown when any of the input arguments specify invalid values + * or types. + * + * ```js + * const { + * scrypt + * } = await import('crypto'); + * + * // Using the factory defaults. + * scrypt('password', 'salt', 64, (err, derivedKey) => { + * if (err) throw err; + * console.log(derivedKey.toString('hex')); // '3745e48...08d59ae' + * }); + * // Using a custom N parameter. Must be a power of two. + * scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => { + * if (err) throw err; + * console.log(derivedKey.toString('hex')); // '3745e48...aa39b34' + * }); + * ``` + */ + function scrypt( + password: BinaryLike, + salt: BinaryLike, + keylen: number, + callback: (err: Error | null, derivedKey: Buffer) => void, + ): void; + function scrypt( + password: BinaryLike, + salt: BinaryLike, + keylen: number, + options: ScryptOptions, + callback: (err: Error | null, derivedKey: Buffer) => void, + ): void; + /** + * Provides a synchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based + * key derivation function that is designed to be expensive computationally and + * memory-wise in order to make brute-force attacks unrewarding. + * + * The `salt` should be as unique as possible. It is recommended that a salt is + * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details. + * + * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`. + * + * An exception is thrown when key derivation fails, otherwise the derived key is + * returned as a `Buffer`. + * + * An exception is thrown when any of the input arguments specify invalid values + * or types. + * + * ```js + * const { + * scryptSync + * } = await import('crypto'); + * // Using the factory defaults. + * + * const key1 = scryptSync('password', 'salt', 64); + * console.log(key1.toString('hex')); // '3745e48...08d59ae' + * // Using a custom N parameter. Must be a power of two. + * const key2 = scryptSync('password', 'salt', 64, { N: 1024 }); + * console.log(key2.toString('hex')); // '3745e48...aa39b34' + * ``` + */ + function scryptSync( + password: BinaryLike, + salt: BinaryLike, + keylen: number, + options?: ScryptOptions, + ): Buffer; + interface RsaPublicKey { + key: KeyLike; + padding?: number | undefined; + } + interface RsaPrivateKey { + key: KeyLike; + passphrase?: string | undefined; + /** + * @default 'sha1' + */ + oaepHash?: string | undefined; + oaepLabel?: TypedArray | undefined; + padding?: number | undefined; + } + /** + * Encrypts the content of `buffer` with `key` and returns a new `Buffer` with encrypted content. The returned data can be decrypted using + * the corresponding private key, for example using {@link privateDecrypt}. + * + * If `key` is not a `KeyObject`, this function behaves as if`key` had been passed to {@link createPublicKey}. If it is an + * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_OAEP_PADDING`. + * + * Because RSA public keys can be derived from private keys, a private key may + * be passed instead of a public key. + */ + function publicEncrypt( + key: RsaPublicKey | RsaPrivateKey | KeyLike, + buffer: ArrayBufferView, + ): Buffer; + /** + * Decrypts `buffer` with `key`.`buffer` was previously encrypted using + * the corresponding private key, for example using {@link privateEncrypt}. + * + * If `key` is not a `KeyObject`, this function behaves as if`key` had been passed to {@link createPublicKey}. If it is an + * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_PADDING`. + * + * Because RSA public keys can be derived from private keys, a private key may + * be passed instead of a public key. + */ + function publicDecrypt( + key: RsaPublicKey | RsaPrivateKey | KeyLike, + buffer: ArrayBufferView, + ): Buffer; + /** + * Decrypts `buffer` with `privateKey`. `buffer` was previously encrypted using + * the corresponding public key, for example using {@link publicEncrypt}. + * + * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an + * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_OAEP_PADDING`. + */ + function privateDecrypt( + privateKey: RsaPrivateKey | KeyLike, + buffer: ArrayBufferView, + ): Buffer; + /** + * Encrypts `buffer` with `privateKey`. The returned data can be decrypted using + * the corresponding public key, for example using {@link publicDecrypt}. + * + * If `privateKey` is not a `KeyObject`, this function behaves as if`privateKey` had been passed to {@link createPrivateKey}. If it is an + * object, the `padding` property can be passed. Otherwise, this function uses`RSA_PKCS1_PADDING`. + */ + function privateEncrypt( + privateKey: RsaPrivateKey | KeyLike, + buffer: ArrayBufferView, + ): Buffer; + /** + * ```js + * const { + * getCiphers + * } = await import('crypto'); + * + * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...] + * ``` + * @return An array with the names of the supported cipher algorithms. + */ + function getCiphers(): string[]; + /** + * ```js + * const { + * getCurves + * } = await import('crypto'); + * + * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...] + * ``` + * @return An array with the names of the supported elliptic curves. + */ + function getCurves(): string[]; + /** + * @return `1` if and only if a FIPS compliant crypto provider is currently in use, `0` otherwise. A future semver-major release may change the return type of this API to a {boolean}. + */ + function getFips(): 1 | 0; + /** + * ```js + * const { + * getHashes + * } = await import('crypto'); + * + * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...] + * ``` + * @return An array of the names of the supported hash algorithms, such as `'RSA-SHA256'`. Hash algorithms are also called "digest" algorithms. + */ + function getHashes(): string[]; + /** + * The `ECDH` class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH) + * key exchanges. + * + * Instances of the `ECDH` class can be created using the {@link createECDH} function. + * + * ```js + * import assert from 'assert'; + * + * const { + * createECDH + * } = await import('crypto'); + * + * // Generate Alice's keys... + * const alice = createECDH('secp521r1'); + * const aliceKey = alice.generateKeys(); + * + * // Generate Bob's keys... + * const bob = createECDH('secp521r1'); + * const bobKey = bob.generateKeys(); + * + * // Exchange and generate the secret... + * const aliceSecret = alice.computeSecret(bobKey); + * const bobSecret = bob.computeSecret(aliceKey); + * + * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex')); + * // OK + * ``` + */ + class ECDH { + private constructor(); + /** + * Converts the EC Diffie-Hellman public key specified by `key` and `curve` to the + * format specified by `format`. The `format` argument specifies point encoding + * and can be `'compressed'`, `'uncompressed'` or `'hybrid'`. The supplied key is + * interpreted using the specified `inputEncoding`, and the returned key is encoded + * using the specified `outputEncoding`. + * + * Use {@link getCurves} to obtain a list of available curve names. + * On recent OpenSSL releases, `openssl ecparam -list_curves` will also display + * the name and description of each available elliptic curve. + * + * If `format` is not specified the point will be returned in `'uncompressed'`format. + * + * If the `inputEncoding` is not provided, `key` is expected to be a `Buffer`,`TypedArray`, or `DataView`. + * + * Example (uncompressing a key): + * + * ```js + * const { + * createECDH, + * ECDH + * } = await import('crypto'); + * + * const ecdh = createECDH('secp256k1'); + * ecdh.generateKeys(); + * + * const compressedKey = ecdh.getPublicKey('hex', 'compressed'); + * + * const uncompressedKey = ECDH.convertKey(compressedKey, + * 'secp256k1', + * 'hex', + * 'hex', + * 'uncompressed'); + * + * // The converted key and the uncompressed public key should be the same + * console.log(uncompressedKey === ecdh.getPublicKey('hex')); + * ``` + * @param inputEncoding The `encoding` of the `key` string. + * @param outputEncoding The `encoding` of the return value. + * @param [format='uncompressed'] + */ + static convertKey( + key: BinaryLike, + curve: string, + inputEncoding?: BinaryToTextEncoding, + outputEncoding?: "latin1" | "hex" | "base64" | "base64url", + format?: "uncompressed" | "compressed" | "hybrid", + ): Buffer | string; + /** + * Generates private and public EC Diffie-Hellman key values, and returns + * the public key in the specified `format` and `encoding`. This key should be + * transferred to the other party. + * + * The `format` argument specifies point encoding and can be `'compressed'` or`'uncompressed'`. If `format` is not specified, the point will be returned in`'uncompressed'` format. + * + * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned. + * @param encoding The `encoding` of the return value. + * @param [format='uncompressed'] + */ + generateKeys(): Buffer; + generateKeys( + encoding: BinaryToTextEncoding, + format?: ECDHKeyFormat, + ): string; + /** + * Computes the shared secret using `otherPublicKey` as the other + * party's public key and returns the computed shared secret. The supplied + * key is interpreted using specified `inputEncoding`, and the returned secret + * is encoded using the specified `outputEncoding`. + * If the `inputEncoding` is not + * provided, `otherPublicKey` is expected to be a `Buffer`, `TypedArray`, or`DataView`. + * + * If `outputEncoding` is given a string will be returned; otherwise a `Buffer` is returned. + * + * `ecdh.computeSecret` will throw an`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY` error when `otherPublicKey`lies outside of the elliptic curve. Since `otherPublicKey` is + * usually supplied from a remote user over an insecure network, + * be sure to handle this exception accordingly. + * @param inputEncoding The `encoding` of the `otherPublicKey` string. + * @param outputEncoding The `encoding` of the return value. + */ + computeSecret(otherPublicKey: ArrayBufferView): Buffer; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + ): Buffer; + computeSecret( + otherPublicKey: ArrayBufferView, + outputEncoding: BinaryToTextEncoding, + ): string; + computeSecret( + otherPublicKey: string, + inputEncoding: BinaryToTextEncoding, + outputEncoding: BinaryToTextEncoding, + ): string; + /** + * If `encoding` is specified, a string is returned; otherwise a `Buffer` is + * returned. + * @param encoding The `encoding` of the return value. + * @return The EC Diffie-Hellman in the specified `encoding`. + */ + getPrivateKey(): Buffer; + getPrivateKey(encoding: BinaryToTextEncoding): string; + /** + * The `format` argument specifies point encoding and can be `'compressed'` or`'uncompressed'`. If `format` is not specified the point will be returned in`'uncompressed'` format. + * + * If `encoding` is specified, a string is returned; otherwise a `Buffer` is + * returned. + * @param encoding The `encoding` of the return value. + * @param [format='uncompressed'] + * @return The EC Diffie-Hellman public key in the specified `encoding` and `format`. + */ + getPublicKey(): Buffer; + getPublicKey( + encoding: BinaryToTextEncoding, + format?: ECDHKeyFormat, + ): string; + /** + * Sets the EC Diffie-Hellman private key. + * If `encoding` is provided, `privateKey` is expected + * to be a string; otherwise `privateKey` is expected to be a `Buffer`,`TypedArray`, or `DataView`. + * + * If `privateKey` is not valid for the curve specified when the `ECDH` object was + * created, an error is thrown. Upon setting the private key, the associated + * public point (key) is also generated and set in the `ECDH` object. + * @param encoding The `encoding` of the `privateKey` string. + */ + setPrivateKey(privateKey: ArrayBufferView): void; + setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void; + } + /** + * Creates an Elliptic Curve Diffie-Hellman (`ECDH`) key exchange object using a + * predefined curve specified by the `curveName` string. Use {@link getCurves} to obtain a list of available curve names. On recent + * OpenSSL releases, `openssl ecparam -list_curves` will also display the name + * and description of each available elliptic curve. + */ + function createECDH(curveName: string): ECDH; + /** + * This function is based on a constant-time algorithm. + * Returns true if `a` is equal to `b`, without leaking timing information that + * would allow an attacker to guess one of the values. This is suitable for + * comparing HMAC digests or secret values like authentication cookies or [capability urls](https://www.w3.org/TR/capability-urls/). + * + * `a` and `b` must both be `Buffer`s, `TypedArray`s, or `DataView`s, and they + * must have the same byte length. An error is thrown if `a` and `b` have + * different byte lengths. + * + * If at least one of `a` and `b` is a `TypedArray` with more than one byte per + * entry, such as `Uint16Array`, the result will be computed using the platform + * byte order. + * + * Use of `crypto.timingSafeEqual` does not guarantee that the _surrounding_ code + * is timing-safe. Care should be taken to ensure that the surrounding code does + * not introduce timing vulnerabilities. + */ + function timingSafeEqual(a: ArrayBufferView, b: ArrayBufferView): boolean; + /** @deprecated since v10.0.0 */ + const DEFAULT_ENCODING: BufferEncoding; + type KeyType = + | "rsa" + | "rsa-pss" + | "dsa" + | "ec" + | "ed25519" + | "ed448" + | "x25519" + | "x448"; + type KeyFormat = "pem" | "der"; + interface BasePrivateKeyEncodingOptions { + format: T; + cipher?: string | undefined; + passphrase?: string | undefined; + } + interface KeyPairKeyObjectResult { + publicKey: KeyObject; + privateKey: KeyObject; + } + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface ED25519KeyPairKeyObjectOptions {} + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface ED448KeyPairKeyObjectOptions {} + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface X25519KeyPairKeyObjectOptions {} + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface X448KeyPairKeyObjectOptions {} + interface ECKeyPairKeyObjectOptions { + /** + * Name of the curve to use + */ + namedCurve: string; + } + interface RSAKeyPairKeyObjectOptions { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Public exponent + * @default 0x10001 + */ + publicExponent?: number | undefined; + } + interface RSAPSSKeyPairKeyObjectOptions { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Public exponent + * @default 0x10001 + */ + publicExponent?: number | undefined; + /** + * Name of the message digest + */ + hashAlgorithm?: string; + /** + * Name of the message digest used by MGF1 + */ + mgf1HashAlgorithm?: string; + /** + * Minimal salt length in bytes + */ + saltLength?: string; + } + interface DSAKeyPairKeyObjectOptions { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Size of q in bits + */ + divisorLength: number; + } + interface RSAKeyPairOptions { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Public exponent + * @default 0x10001 + */ + publicExponent?: number | undefined; + publicKeyEncoding: { + type: "pkcs1" | "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs1" | "pkcs8"; + }; + } + interface RSAPSSKeyPairOptions< + PubF extends KeyFormat, + PrivF extends KeyFormat, + > { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Public exponent + * @default 0x10001 + */ + publicExponent?: number | undefined; + /** + * Name of the message digest + */ + hashAlgorithm?: string; + /** + * Name of the message digest used by MGF1 + */ + mgf1HashAlgorithm?: string; + /** + * Minimal salt length in bytes + */ + saltLength?: string; + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface DSAKeyPairOptions { + /** + * Key size in bits + */ + modulusLength: number; + /** + * Size of q in bits + */ + divisorLength: number; + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface ECKeyPairOptions { + /** + * Name of the curve to use. + */ + namedCurve: string; + publicKeyEncoding: { + type: "pkcs1" | "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "sec1" | "pkcs8"; + }; + } + interface ED25519KeyPairOptions< + PubF extends KeyFormat, + PrivF extends KeyFormat, + > { + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface ED448KeyPairOptions< + PubF extends KeyFormat, + PrivF extends KeyFormat, + > { + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface X25519KeyPairOptions< + PubF extends KeyFormat, + PrivF extends KeyFormat, + > { + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface X448KeyPairOptions< + PubF extends KeyFormat, + PrivF extends KeyFormat, + > { + publicKeyEncoding: { + type: "spki"; + format: PubF; + }; + privateKeyEncoding: BasePrivateKeyEncodingOptions & { + type: "pkcs8"; + }; + } + interface KeyPairSyncResult< + T1 extends string | Buffer, + T2 extends string | Buffer, + > { + publicKey: T1; + privateKey: T2; + } + /** + * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC, + * Ed25519, Ed448, X25519, X448, and DH are currently supported. + * + * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function + * behaves as if `keyObject.export()` had been called on its result. Otherwise, + * the respective part of the key is returned as a `KeyObject`. + * + * When encoding public keys, it is recommended to use `'spki'`. When encoding + * private keys, it is recommended to use `'pkcs8'` with a strong passphrase, + * and to keep the passphrase confidential. + * + * ```js + * const { + * generateKeyPairSync + * } = await import('crypto'); + * + * const { + * publicKey, + * privateKey, + * } = generateKeyPairSync('rsa', { + * modulusLength: 4096, + * publicKeyEncoding: { + * type: 'spki', + * format: 'pem' + * }, + * privateKeyEncoding: { + * type: 'pkcs8', + * format: 'pem', + * cipher: 'aes-256-cbc', + * passphrase: 'top secret' + * } + * }); + * ``` + * + * The return value `{ publicKey, privateKey }` represents the generated key pair. + * When PEM encoding was selected, the respective key will be a string, otherwise + * it will be a buffer containing the data encoded as DER. + * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`. + */ + function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa", + options: RSAKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "rsa-pss", + options: RSAPSSKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "dsa", + options: DSAKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "dsa", + options: DSAKeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "dsa", + options: DSAKeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "dsa", + options: DSAKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "dsa", + options: DSAKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ec", + options: ECKeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ec", + options: ECKeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed25519", + options?: ED25519KeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "ed448", + options: ED448KeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed448", + options: ED448KeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed448", + options: ED448KeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed448", + options: ED448KeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "ed448", + options?: ED448KeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "x25519", + options: X25519KeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x25519", + options: X25519KeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x25519", + options: X25519KeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x25519", + options: X25519KeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x25519", + options?: X25519KeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + function generateKeyPairSync( + type: "x448", + options: X448KeyPairOptions<"pem", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x448", + options: X448KeyPairOptions<"pem", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x448", + options: X448KeyPairOptions<"der", "pem">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x448", + options: X448KeyPairOptions<"der", "der">, + ): KeyPairSyncResult; + function generateKeyPairSync( + type: "x448", + options?: X448KeyPairKeyObjectOptions, + ): KeyPairKeyObjectResult; + /** + * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC, + * Ed25519, Ed448, X25519, X448, and DH are currently supported. + * + * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function + * behaves as if `keyObject.export()` had been called on its result. Otherwise, + * the respective part of the key is returned as a `KeyObject`. + * + * It is recommended to encode public keys as `'spki'` and private keys as`'pkcs8'` with encryption for long-term storage: + * + * ```js + * const { + * generateKeyPair + * } = await import('crypto'); + * + * generateKeyPair('rsa', { + * modulusLength: 4096, + * publicKeyEncoding: { + * type: 'spki', + * format: 'pem' + * }, + * privateKeyEncoding: { + * type: 'pkcs8', + * format: 'pem', + * cipher: 'aes-256-cbc', + * passphrase: 'top secret' + * } + * }, (err, publicKey, privateKey) => { + * // Handle errors and use the generated key pair. + * }); + * ``` + * + * On completion, `callback` will be called with `err` set to `undefined` and`publicKey` / `privateKey` representing the generated key pair. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a `Promise` for an `Object` with `publicKey` and `privateKey` properties. + * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`. + */ + function generateKeyPair( + type: "rsa", + options: RSAKeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "rsa", + options: RSAKeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "rsa", + options: RSAKeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "rsa", + options: RSAKeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "rsa", + options: RSAKeyPairKeyObjectOptions, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "rsa-pss", + options: RSAPSSKeyPairKeyObjectOptions, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "dsa", + options: DSAKeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "dsa", + options: DSAKeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "dsa", + options: DSAKeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "dsa", + options: DSAKeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "dsa", + options: DSAKeyPairKeyObjectOptions, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "ec", + options: ECKeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ec", + options: ECKeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ec", + options: ECKeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ec", + options: ECKeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ec", + options: ECKeyPairKeyObjectOptions, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ed25519", + options: ED25519KeyPairKeyObjectOptions | undefined, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "ed448", + options: ED448KeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ed448", + options: ED448KeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ed448", + options: ED448KeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "ed448", + options: ED448KeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "ed448", + options: ED448KeyPairKeyObjectOptions | undefined, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "x25519", + options: X25519KeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "x25519", + options: X25519KeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "x25519", + options: X25519KeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "x25519", + options: X25519KeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "x25519", + options: X25519KeyPairKeyObjectOptions | undefined, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + function generateKeyPair( + type: "x448", + options: X448KeyPairOptions<"pem", "pem">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "x448", + options: X448KeyPairOptions<"pem", "der">, + callback: ( + err: Error | null, + publicKey: string, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "x448", + options: X448KeyPairOptions<"der", "pem">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: string, + ) => void, + ): void; + function generateKeyPair( + type: "x448", + options: X448KeyPairOptions<"der", "der">, + callback: ( + err: Error | null, + publicKey: Buffer, + privateKey: Buffer, + ) => void, + ): void; + function generateKeyPair( + type: "x448", + options: X448KeyPairKeyObjectOptions | undefined, + callback: ( + err: Error | null, + publicKey: KeyObject, + privateKey: KeyObject, + ) => void, + ): void; + namespace generateKeyPair { + function __promisify__( + type: "rsa", + options: RSAKeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "rsa", + options: RSAKeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "rsa", + options: RSAKeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "rsa", + options: RSAKeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "rsa", + options: RSAKeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "rsa-pss", + options: RSAPSSKeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "rsa-pss", + options: RSAPSSKeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "dsa", + options: DSAKeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "dsa", + options: DSAKeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "dsa", + options: DSAKeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "dsa", + options: DSAKeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "dsa", + options: DSAKeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "ec", + options: ECKeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "ec", + options: ECKeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "ec", + options: ECKeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "ec", + options: ECKeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "ec", + options: ECKeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "ed25519", + options: ED25519KeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "ed25519", + options: ED25519KeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "ed25519", + options?: ED25519KeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "ed448", + options: ED448KeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "ed448", + options: ED448KeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "ed448", + options: ED448KeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "ed448", + options: ED448KeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "ed448", + options?: ED448KeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "x25519", + options: X25519KeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "x25519", + options: X25519KeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "x25519", + options: X25519KeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "x25519", + options: X25519KeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "x25519", + options?: X25519KeyPairKeyObjectOptions, + ): Promise; + function __promisify__( + type: "x448", + options: X448KeyPairOptions<"pem", "pem">, + ): Promise<{ + publicKey: string; + privateKey: string; + }>; + function __promisify__( + type: "x448", + options: X448KeyPairOptions<"pem", "der">, + ): Promise<{ + publicKey: string; + privateKey: Buffer; + }>; + function __promisify__( + type: "x448", + options: X448KeyPairOptions<"der", "pem">, + ): Promise<{ + publicKey: Buffer; + privateKey: string; + }>; + function __promisify__( + type: "x448", + options: X448KeyPairOptions<"der", "der">, + ): Promise<{ + publicKey: Buffer; + privateKey: Buffer; + }>; + function __promisify__( + type: "x448", + options?: X448KeyPairKeyObjectOptions, + ): Promise; + } + /** + * Calculates and returns the signature for `data` using the given private key and + * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is + * dependent upon the key type (especially Ed25519 and Ed448). + * + * If `key` is not a `KeyObject`, this function behaves as if `key` had been + * passed to {@link createPrivateKey}. If it is an object, the following + * additional properties can be passed: + * + * If the `callback` function is provided this function uses libuv's threadpool. + */ + function sign( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput, + ): Buffer; + function sign( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput, + callback: (error: Error | null, data: Buffer) => void, + ): void; + /** + * Verifies the given signature for `data` using the given key and algorithm. If`algorithm` is `null` or `undefined`, then the algorithm is dependent upon the + * key type (especially Ed25519 and Ed448). + * + * If `key` is not a `KeyObject`, this function behaves as if `key` had been + * passed to {@link createPublicKey}. If it is an object, the following + * additional properties can be passed: + * + * The `signature` argument is the previously calculated signature for the `data`. + * + * Because public keys can be derived from private keys, a private key or a public + * key may be passed for `key`. + * + * If the `callback` function is provided this function uses libuv's threadpool. + */ + function verify( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: ArrayBufferView, + ): boolean; + function verify( + algorithm: string | null | undefined, + data: ArrayBufferView, + key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, + signature: ArrayBufferView, + callback: (error: Error | null, result: boolean) => void, + ): void; + /** + * Computes the Diffie-Hellman secret based on a `privateKey` and a `publicKey`. + * Both keys must have the same `asymmetricKeyType`, which must be one of `'dh'`(for Diffie-Hellman), `'ec'` (for ECDH), `'x448'`, or `'x25519'` (for ECDH-ES). + */ + function diffieHellman(options: { + privateKey: KeyObject; + publicKey: KeyObject; + }): Buffer; + type CipherMode = + | "cbc" + | "ccm" + | "cfb" + | "ctr" + | "ecb" + | "gcm" + | "ocb" + | "ofb" + | "stream" + | "wrap" + | "xts"; + interface CipherInfoOptions { + /** + * A test key length. + */ + keyLength?: number | undefined; + /** + * A test IV length. + */ + ivLength?: number | undefined; + } + interface CipherInfo { + /** + * The name of the cipher. + */ + name: string; + /** + * The nid of the cipher. + */ + nid: number; + /** + * The block size of the cipher in bytes. + * This property is omitted when mode is 'stream'. + */ + blockSize?: number | undefined; + /** + * The expected or default initialization vector length in bytes. + * This property is omitted if the cipher does not use an initialization vector. + */ + ivLength?: number | undefined; + /** + * The expected or default key length in bytes. + */ + keyLength: number; + /** + * The cipher mode. + */ + mode: CipherMode; + } + /** + * Returns information about a given cipher. + * + * Some ciphers accept variable length keys and initialization vectors. By default, + * the `crypto.getCipherInfo()` method will return the default values for these + * ciphers. To test if a given key length or iv length is acceptable for given + * cipher, use the `keyLength` and `ivLength` options. If the given values are + * unacceptable, `undefined` will be returned. + * @param nameOrNid The name or nid of the cipher to query. + */ + function getCipherInfo( + nameOrNid: string | number, + options?: CipherInfoOptions, + ): CipherInfo | undefined; + /** + * HKDF is a simple key derivation function defined in RFC 5869\. The given `ikm`,`salt` and `info` are used with the `digest` to derive a key of `keylen` bytes. + * + * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an errors occurs while deriving the key, `err` will be set; + * otherwise `err` will be `null`. The successfully generated `derivedKey` will + * be passed to the callback as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). An error will be thrown if any + * of the input arguments specify invalid values or types. + * + * ```js + * import { Buffer } from 'buffer'; + * const { + * hkdf + * } = await import('crypto'); + * + * hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => { + * if (err) throw err; + * console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653' + * }); + * ``` + * @param digest The digest algorithm to use. + * @param ikm The input keying material. It must be at least one byte in length. + * @param salt The salt value. Must be provided but can be zero-length. + * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes. + * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512` + * generates 64-byte hashes, making the maximum HKDF output 16320 bytes). + */ + function hkdf( + digest: string, + irm: BinaryLike | KeyObject, + salt: BinaryLike, + info: BinaryLike, + keylen: number, + callback: (err: Error | null, derivedKey: ArrayBuffer) => void, + ): void; + /** + * Provides a synchronous HKDF key derivation function as defined in RFC 5869\. The + * given `ikm`, `salt` and `info` are used with the `digest` to derive a key of`keylen` bytes. + * + * The successfully generated `derivedKey` will be returned as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). + * + * An error will be thrown if any of the input arguments specify invalid values or + * types, or if the derived key cannot be generated. + * + * ```js + * import { Buffer } from 'buffer'; + * const { + * hkdfSync + * } = await import('crypto'); + * + * const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64); + * console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653' + * ``` + * @param digest The digest algorithm to use. + * @param ikm The input keying material. It must be at least one byte in length. + * @param salt The salt value. Must be provided but can be zero-length. + * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes. + * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512` + * generates 64-byte hashes, making the maximum HKDF output 16320 bytes). + */ + function hkdfSync( + digest: string, + ikm: BinaryLike | KeyObject, + salt: BinaryLike, + info: BinaryLike, + keylen: number, + ): ArrayBuffer; + interface SecureHeapUsage { + /** + * The total allocated secure heap size as specified using the `--secure-heap=n` command-line flag. + */ + total: number; + /** + * The minimum allocation from the secure heap as specified using the `--secure-heap-min` command-line flag. + */ + min: number; + /** + * The total number of bytes currently allocated from the secure heap. + */ + used: number; + /** + * The calculated ratio of `used` to `total` allocated bytes. + */ + utilization: number; + } + /** + */ + function secureHeapUsed(): SecureHeapUsage; + interface RandomUUIDOptions { + /** + * By default, to improve performance, + * Node.js will pre-emptively generate and persistently cache enough + * random data to generate up to 128 random UUIDs. To generate a UUID + * without using the cache, set `disableEntropyCache` to `true`. + * + * @default `false` + */ + disableEntropyCache?: boolean | undefined; + } + /** + * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a + * cryptographic pseudorandom number generator. + */ + function randomUUID(options?: RandomUUIDOptions): string; + interface X509CheckOptions { + /** + * @default 'always' + */ + subject: "always" | "never"; + /** + * @default true + */ + wildcards: boolean; + /** + * @default true + */ + partialWildcards: boolean; + /** + * @default false + */ + multiLabelWildcards: boolean; + /** + * @default false + */ + singleLabelSubdomains: boolean; + } + type LargeNumberLike = + | ArrayBufferView + | SharedArrayBuffer + | ArrayBuffer + | bigint; + interface GeneratePrimeOptions { + add?: LargeNumberLike | undefined; + rem?: LargeNumberLike | undefined; + /** + * @default false + */ + safe?: boolean | undefined; + bigint?: boolean | undefined; + } + interface GeneratePrimeOptionsBigInt extends GeneratePrimeOptions { + bigint: true; + } + interface GeneratePrimeOptionsArrayBuffer extends GeneratePrimeOptions { + bigint?: false | undefined; + } + /** + * Generates a pseudorandom prime of `size` bits. + * + * If `options.safe` is `true`, the prime will be a safe prime -- that is,`(prime - 1) / 2` will also be a prime. + * + * The `options.add` and `options.rem` parameters can be used to enforce additional + * requirements, e.g., for Diffie-Hellman: + * + * * If `options.add` and `options.rem` are both set, the prime will satisfy the + * condition that `prime % add = rem`. + * * If only `options.add` is set and `options.safe` is not `true`, the prime will + * satisfy the condition that `prime % add = 1`. + * * If only `options.add` is set and `options.safe` is set to `true`, the prime + * will instead satisfy the condition that `prime % add = 3`. This is necessary + * because `prime % add = 1` for `options.add > 2` would contradict the condition + * enforced by `options.safe`. + * * `options.rem` is ignored if `options.add` is not given. + * + * Both `options.add` and `options.rem` must be encoded as big-endian sequences + * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`. + * + * By default, the prime is encoded as a big-endian sequence of octets + * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a + * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided. + * @param size The size (in bits) of the prime to generate. + */ + function generatePrime( + size: number, + callback: (err: Error | null, prime: ArrayBuffer) => void, + ): void; + function generatePrime( + size: number, + options: GeneratePrimeOptionsBigInt, + callback: (err: Error | null, prime: bigint) => void, + ): void; + function generatePrime( + size: number, + options: GeneratePrimeOptionsArrayBuffer, + callback: (err: Error | null, prime: ArrayBuffer) => void, + ): void; + function generatePrime( + size: number, + options: GeneratePrimeOptions, + callback: (err: Error | null, prime: ArrayBuffer | bigint) => void, + ): void; + /** + * Generates a pseudorandom prime of `size` bits. + * + * If `options.safe` is `true`, the prime will be a safe prime -- that is,`(prime - 1) / 2` will also be a prime. + * + * The `options.add` and `options.rem` parameters can be used to enforce additional + * requirements, e.g., for Diffie-Hellman: + * + * * If `options.add` and `options.rem` are both set, the prime will satisfy the + * condition that `prime % add = rem`. + * * If only `options.add` is set and `options.safe` is not `true`, the prime will + * satisfy the condition that `prime % add = 1`. + * * If only `options.add` is set and `options.safe` is set to `true`, the prime + * will instead satisfy the condition that `prime % add = 3`. This is necessary + * because `prime % add = 1` for `options.add > 2` would contradict the condition + * enforced by `options.safe`. + * * `options.rem` is ignored if `options.add` is not given. + * + * Both `options.add` and `options.rem` must be encoded as big-endian sequences + * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`. + * + * By default, the prime is encoded as a big-endian sequence of octets + * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a + * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided. + * @param size The size (in bits) of the prime to generate. + */ + function generatePrimeSync(size: number): ArrayBuffer; + function generatePrimeSync( + size: number, + options: GeneratePrimeOptionsBigInt, + ): bigint; + function generatePrimeSync( + size: number, + options: GeneratePrimeOptionsArrayBuffer, + ): ArrayBuffer; + function generatePrimeSync( + size: number, + options: GeneratePrimeOptions, + ): ArrayBuffer | bigint; + interface CheckPrimeOptions { + /** + * The number of Miller-Rabin probabilistic primality iterations to perform. + * When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most 2-64 for random input. + * Care must be used when selecting a number of checks. + * Refer to the OpenSSL documentation for the BN_is_prime_ex function nchecks options for more details. + * + * @default 0 + */ + checks?: number | undefined; + } + /** + * Checks the primality of the `candidate`. + * @param candidate A possible prime encoded as a sequence of big endian octets of arbitrary length. + */ + function checkPrime( + value: LargeNumberLike, + callback: (err: Error | null, result: boolean) => void, + ): void; + function checkPrime( + value: LargeNumberLike, + options: CheckPrimeOptions, + callback: (err: Error | null, result: boolean) => void, + ): void; + /** + * Checks the primality of the `candidate`. + * @param candidate A possible prime encoded as a sequence of big endian octets of arbitrary length. + * @return `true` if the candidate is a prime with an error probability less than `0.25 ** options.checks`. + */ + function checkPrimeSync( + candidate: LargeNumberLike, + options?: CheckPrimeOptions, + ): boolean; +} +declare module "node:crypto" { + export * from "crypto"; +} diff --git a/packages/bun-types/domain.d.ts b/packages/bun-types/domain.d.ts new file mode 100644 index 0000000000..e1df3fc7ad --- /dev/null +++ b/packages/bun-types/domain.d.ts @@ -0,0 +1,170 @@ +/** + * **This module is pending deprecation.** Once a replacement API has been + * finalized, this module will be fully deprecated. Most developers should + * **not** have cause to use this module. Users who absolutely must have + * the functionality that domains provide may rely on it for the time being + * but should expect to have to migrate to a different solution + * in the future. + * + * Domains provide a way to handle multiple different IO operations as a + * single group. If any of the event emitters or callbacks registered to a + * domain emit an `'error'` event, or throw an error, then the domain object + * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to + * exit immediately with an error code. + * @deprecated + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/domain.js) + */ +declare module "domain" { + import EventEmitter = require("node:events"); + /** + * The `Domain` class encapsulates the functionality of routing errors and + * uncaught exceptions to the active `Domain` object. + * + * To handle the errors that it catches, listen to its `'error'` event. + */ + class Domain extends EventEmitter { + /** + * An array of timers and event emitters that have been explicitly added + * to the domain. + */ + members: Array; + /** + * The `enter()` method is plumbing used by the `run()`, `bind()`, and`intercept()` methods to set the active domain. It sets `domain.active` and`process.domain` to the domain, and implicitly + * pushes the domain onto the domain + * stack managed by the domain module (see {@link exit} for details on the + * domain stack). The call to `enter()` delimits the beginning of a chain of + * asynchronous calls and I/O operations bound to a domain. + * + * Calling `enter()` changes only the active domain, and does not alter the domain + * itself. `enter()` and `exit()` can be called an arbitrary number of times on a + * single domain. + */ + enter(): void; + /** + * The `exit()` method exits the current domain, popping it off the domain stack. + * Any time execution is going to switch to the context of a different chain of + * asynchronous calls, it's important to ensure that the current domain is exited. + * The call to `exit()` delimits either the end of or an interruption to the chain + * of asynchronous calls and I/O operations bound to a domain. + * + * If there are multiple, nested domains bound to the current execution context,`exit()` will exit any domains nested within this domain. + * + * Calling `exit()` changes only the active domain, and does not alter the domain + * itself. `enter()` and `exit()` can be called an arbitrary number of times on a + * single domain. + */ + exit(): void; + /** + * Run the supplied function in the context of the domain, implicitly + * binding all event emitters, timers, and lowlevel requests that are + * created in that context. Optionally, arguments can be passed to + * the function. + * + * This is the most basic way to use a domain. + * + * ```js + * const domain = require('domain'); + * const fs = require('fs'); + * const d = domain.create(); + * d.on('error', (er) => { + * console.error('Caught error!', er); + * }); + * d.run(() => { + * process.nextTick(() => { + * setTimeout(() => { // Simulating some various async stuff + * fs.open('non-existent file', 'r', (er, fd) => { + * if (er) throw er; + * // proceed... + * }); + * }, 100); + * }); + * }); + * ``` + * + * In this example, the `d.on('error')` handler will be triggered, rather + * than crashing the program. + */ + run(fn: (...args: any[]) => T, ...args: any[]): T; + /** + * Explicitly adds an emitter to the domain. If any event handlers called by + * the emitter throw an error, or if the emitter emits an `'error'` event, it + * will be routed to the domain's `'error'` event, just like with implicit + * binding. + * + * This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by + * the domain `'error'` handler. + * + * If the Timer or `EventEmitter` was already bound to a domain, it is removed + * from that one, and bound to this one instead. + * @param emitter emitter or timer to be added to the domain + */ + add(emitter: EventEmitter | number): void; + /** + * The opposite of {@link add}. Removes domain handling from the + * specified emitter. + * @param emitter emitter or timer to be removed from the domain + */ + remove(emitter: EventEmitter | number): void; + /** + * The returned function will be a wrapper around the supplied callback + * function. When the returned function is called, any errors that are + * thrown will be routed to the domain's `'error'` event. + * + * ```js + * const d = domain.create(); + * + * function readSomeFile(filename, cb) { + * fs.readFile(filename, 'utf8', d.bind((er, data) => { + * // If this throws, it will also be passed to the domain. + * return cb(er, data ? JSON.parse(data) : null); + * })); + * } + * + * d.on('error', (er) => { + * // An error occurred somewhere. If we throw it now, it will crash the program + * // with the normal line number and stack message. + * }); + * ``` + * @param callback The callback function + * @return The bound function + */ + bind(callback: T): T; + /** + * This method is almost identical to {@link bind}. However, in + * addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function. + * + * In this way, the common `if (err) return callback(err);` pattern can be replaced + * with a single error handler in a single place. + * + * ```js + * const d = domain.create(); + * + * function readSomeFile(filename, cb) { + * fs.readFile(filename, 'utf8', d.intercept((data) => { + * // Note, the first argument is never passed to the + * // callback since it is assumed to be the 'Error' argument + * // and thus intercepted by the domain. + * + * // If this throws, it will also be passed to the domain + * // so the error-handling logic can be moved to the 'error' + * // event on the domain instead of being repeated throughout + * // the program. + * return cb(null, JSON.parse(data)); + * })); + * } + * + * d.on('error', (er) => { + * // An error occurred somewhere. If we throw it now, it will crash the program + * // with the normal line number and stack message. + * }); + * ``` + * @param callback The callback function + * @return The intercepted function + */ + intercept(callback: T): T; + } + function create(): Domain; +} +declare module "node:domain" { + export * from "domain"; +} diff --git a/packages/bun-types/events.d.ts b/packages/bun-types/events.d.ts new file mode 100644 index 0000000000..2e90566184 --- /dev/null +++ b/packages/bun-types/events.d.ts @@ -0,0 +1,647 @@ +/** + * Much of the Node.js core API is built around an idiomatic asynchronous + * event-driven architecture in which certain kinds of objects (called "emitters") + * emit named events that cause `Function` objects ("listeners") to be called. + * + * For instance: a `net.Server` object emits an event each time a peer + * connects to it; a `fs.ReadStream` emits an event when the file is opened; + * a `stream` emits an event whenever data is available to be read. + * + * All objects that emit events are instances of the `EventEmitter` class. These + * objects expose an `eventEmitter.on()` function that allows one or more + * functions to be attached to named events emitted by the object. Typically, + * event names are camel-cased strings but any valid JavaScript property key + * can be used. + * + * When the `EventEmitter` object emits an event, all of the functions attached + * to that specific event are called _synchronously_. Any values returned by the + * called listeners are _ignored_ and discarded. + * + * The following example shows a simple `EventEmitter` instance with a single + * listener. The `eventEmitter.on()` method is used to register listeners, while + * the `eventEmitter.emit()` method is used to trigger the event. + * + * ```js + * const EventEmitter = require('events'); + * + * class MyEmitter extends EventEmitter {} + * + * const myEmitter = new MyEmitter(); + * myEmitter.on('event', () => { + * console.log('an event occurred!'); + * }); + * myEmitter.emit('event'); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/events.js) + */ +declare module "events" { + interface EventEmitterOptions { + /** + * Enables automatic capturing of promise rejection. + */ + captureRejections?: boolean | undefined; + } + interface NodeEventTarget { + once(eventName: string | symbol, listener: (...args: any[]) => void): this; + } + interface DOMEventTarget { + addEventListener( + eventName: string, + listener: (...args: any[]) => void, + opts?: { + once: boolean; + }, + ): any; + } + interface StaticEventEmitterOptions { + signal?: AbortSignal | undefined; + } + interface EventEmitter { + /** + * Alias for `emitter.on(eventName, listener)`. + */ + addListener( + eventName: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * Adds the `listener` function to the end of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * ```js + * server.on('connection', (stream) => { + * console.log('someone connected!'); + * }); + * ``` + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the + * event listener to the beginning of the listeners array. + * + * ```js + * const myEE = new EventEmitter(); + * myEE.on('foo', () => console.log('a')); + * myEE.prependListener('foo', () => console.log('b')); + * myEE.emit('foo'); + * // Prints: + * // b + * // a + * ``` + * @param eventName The name of the event. + * @param listener The callback function + */ + on(eventName: string | symbol, listener: (...args: any[]) => void): this; + /** + * Adds a **one-time**`listener` function for the event named `eventName`. The + * next time `eventName` is triggered, this listener is removed and then invoked. + * + * ```js + * server.once('connection', (stream) => { + * console.log('Ah, we have our first user!'); + * }); + * ``` + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * + * By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the + * event listener to the beginning of the listeners array. + * + * ```js + * const myEE = new EventEmitter(); + * myEE.once('foo', () => console.log('a')); + * myEE.prependOnceListener('foo', () => console.log('b')); + * myEE.emit('foo'); + * // Prints: + * // b + * // a + * ``` + * @param eventName The name of the event. + * @param listener The callback function + */ + once(eventName: string | symbol, listener: (...args: any[]) => void): this; + /** + * Removes the specified `listener` from the listener array for the event named`eventName`. + * + * ```js + * const callback = (stream) => { + * console.log('someone connected!'); + * }; + * server.on('connection', callback); + * // ... + * server.removeListener('connection', callback); + * ``` + * + * `removeListener()` will remove, at most, one instance of a listener from the + * listener array. If any single listener has been added multiple times to the + * listener array for the specified `eventName`, then `removeListener()` must be + * called multiple times to remove each instance. + * + * Once an event is emitted, all listeners attached to it at the + * time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and_before_ the last listener finishes execution will + * not remove them from`emit()` in progress. Subsequent events behave as expected. + * + * ```js + * const myEmitter = new MyEmitter(); + * + * const callbackA = () => { + * console.log('A'); + * myEmitter.removeListener('event', callbackB); + * }; + * + * const callbackB = () => { + * console.log('B'); + * }; + * + * myEmitter.on('event', callbackA); + * + * myEmitter.on('event', callbackB); + * + * // callbackA removes listener callbackB but it will still be called. + * // Internal listener array at time of emit [callbackA, callbackB] + * myEmitter.emit('event'); + * // Prints: + * // A + * // B + * + * // callbackB is now removed. + * // Internal listener array [callbackA] + * myEmitter.emit('event'); + * // Prints: + * // A + * ``` + * + * Because listeners are managed using an internal array, calling this will + * change the position indices of any listener registered _after_ the listener + * being removed. This will not impact the order in which listeners are called, + * but it means that any copies of the listener array as returned by + * the `emitter.listeners()` method will need to be recreated. + * + * When a single function has been added as a handler multiple times for a single + * event (as in the example below), `removeListener()` will remove the most + * recently added instance. In the example the `once('ping')`listener is removed: + * + * ```js + * const ee = new EventEmitter(); + * + * function pong() { + * console.log('pong'); + * } + * + * ee.on('ping', pong); + * ee.once('ping', pong); + * ee.removeListener('ping', pong); + * + * ee.emit('ping'); + * ee.emit('ping'); + * ``` + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + */ + removeListener( + eventName: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * Alias for `emitter.removeListener()`. + */ + off(eventName: string | symbol, listener: (...args: any[]) => void): this; + /** + * Removes all listeners, or those of the specified `eventName`. + * + * It is bad practice to remove listeners added elsewhere in the code, + * particularly when the `EventEmitter` instance was created by some other + * component or module (e.g. sockets or file streams). + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + */ + removeAllListeners(event?: string | symbol): this; + /** + * By default `EventEmitter`s will print a warning if more than `10` listeners are + * added for a particular event. This is a useful default that helps finding + * memory leaks. The `emitter.setMaxListeners()` method allows the limit to be + * modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners. + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + */ + setMaxListeners(n: number): this; + /** + * Returns the current max listener value for the `EventEmitter` which is either + * set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}. + */ + getMaxListeners(): number; + /** + * Returns a copy of the array of listeners for the event named `eventName`. + * + * ```js + * server.on('connection', (stream) => { + * console.log('someone connected!'); + * }); + * console.log(util.inspect(server.listeners('connection'))); + * // Prints: [ [Function] ] + * ``` + */ + listeners(eventName: string | symbol): Function[]; + /** + * Returns a copy of the array of listeners for the event named `eventName`, + * including any wrappers (such as those created by `.once()`). + * + * ```js + * const emitter = new EventEmitter(); + * emitter.once('log', () => console.log('log once')); + * + * // Returns a new Array with a function `onceWrapper` which has a property + * // `listener` which contains the original listener bound above + * const listeners = emitter.rawListeners('log'); + * const logFnWrapper = listeners[0]; + * + * // Logs "log once" to the console and does not unbind the `once` event + * logFnWrapper.listener(); + * + * // Logs "log once" to the console and removes the listener + * logFnWrapper(); + * + * emitter.on('log', () => console.log('log persistently')); + * // Will return a new Array with a single function bound by `.on()` above + * const newListeners = emitter.rawListeners('log'); + * + * // Logs "log persistently" twice + * newListeners[0](); + * emitter.emit('log'); + * ``` + */ + rawListeners(eventName: string | symbol): Function[]; + /** + * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments + * to each. + * + * Returns `true` if the event had listeners, `false` otherwise. + * + * ```js + * const EventEmitter = require('events'); + * const myEmitter = new EventEmitter(); + * + * // First listener + * myEmitter.on('event', function firstListener() { + * console.log('Helloooo! first listener'); + * }); + * // Second listener + * myEmitter.on('event', function secondListener(arg1, arg2) { + * console.log(`event with parameters ${arg1}, ${arg2} in second listener`); + * }); + * // Third listener + * myEmitter.on('event', function thirdListener(...args) { + * const parameters = args.join(', '); + * console.log(`event with parameters ${parameters} in third listener`); + * }); + * + * console.log(myEmitter.listeners('event')); + * + * myEmitter.emit('event', 1, 2, 3, 4, 5); + * + * // Prints: + * // [ + * // [Function: firstListener], + * // [Function: secondListener], + * // [Function: thirdListener] + * // ] + * // Helloooo! first listener + * // event with parameters 1, 2 in second listener + * // event with parameters 1, 2, 3, 4, 5 in third listener + * ``` + */ + emit(eventName: string | symbol, ...args: any[]): boolean; + /** + * Returns the number of listeners listening to the event named `eventName`. + * @param eventName The name of the event being listened for + */ + listenerCount(eventName: string | symbol): number; + /** + * Adds the `listener` function to the _beginning_ of the listeners array for the + * event named `eventName`. No checks are made to see if the `listener` has + * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple + * times. + * + * ```js + * server.prependListener('connection', (stream) => { + * console.log('someone connected!'); + * }); + * ``` + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * @param eventName The name of the event. + * @param listener The callback function + */ + prependListener( + eventName: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * Adds a **one-time**`listener` function for the event named `eventName` to the_beginning_ of the listeners array. The next time `eventName` is triggered, this + * listener is removed, and then invoked. + * + * ```js + * server.prependOnceListener('connection', (stream) => { + * console.log('Ah, we have our first user!'); + * }); + * ``` + * + * Returns a reference to the `EventEmitter`, so that calls can be chained. + * @param eventName The name of the event. + * @param listener The callback function + */ + prependOnceListener( + eventName: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * Returns an array listing the events for which the emitter has registered + * listeners. The values in the array are strings or `Symbol`s. + * + * ```js + * const EventEmitter = require('events'); + * const myEE = new EventEmitter(); + * myEE.on('foo', () => {}); + * myEE.on('bar', () => {}); + * + * const sym = Symbol('symbol'); + * myEE.on(sym, () => {}); + * + * console.log(myEE.eventNames()); + * // Prints: [ 'foo', 'bar', Symbol(symbol) ] + * ``` + */ + eventNames(): Array; + } + /** + * The `EventEmitter` class is defined and exposed by the `events` module: + * + * ```js + * const EventEmitter = require('events'); + * ``` + * + * All `EventEmitter`s emit the event `'newListener'` when new listeners are + * added and `'removeListener'` when existing listeners are removed. + * + * It supports the following option: + */ + class EventEmitter { + constructor(options?: EventEmitterOptions); + /** + * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given + * event or that is rejected if the `EventEmitter` emits `'error'` while waiting. + * The `Promise` will resolve with an array of all the arguments emitted to the + * given event. + * + * This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event + * semantics and does not listen to the `'error'` event. + * + * ```js + * const { once, EventEmitter } = require('events'); + * + * async function run() { + * const ee = new EventEmitter(); + * + * process.nextTick(() => { + * ee.emit('myevent', 42); + * }); + * + * const [value] = await once(ee, 'myevent'); + * console.log(value); + * + * const err = new Error('kaboom'); + * process.nextTick(() => { + * ee.emit('error', err); + * }); + * + * try { + * await once(ee, 'myevent'); + * } catch (err) { + * console.log('error happened', err); + * } + * } + * + * run(); + * ``` + * + * The special handling of the `'error'` event is only used when `events.once()`is used to wait for another event. If `events.once()` is used to wait for the + * '`error'` event itself, then it is treated as any other kind of event without + * special handling: + * + * ```js + * const { EventEmitter, once } = require('events'); + * + * const ee = new EventEmitter(); + * + * once(ee, 'error') + * .then(([err]) => console.log('ok', err.message)) + * .catch((err) => console.log('error', err.message)); + * + * ee.emit('error', new Error('boom')); + * + * // Prints: ok boom + * ``` + * + * An `AbortSignal` can be used to cancel waiting for the event: + * + * ```js + * const { EventEmitter, once } = require('events'); + * + * const ee = new EventEmitter(); + * const ac = new AbortController(); + * + * async function foo(emitter, event, signal) { + * try { + * await once(emitter, event, { signal }); + * console.log('event emitted!'); + * } catch (error) { + * if (error.name === 'AbortError') { + * console.error('Waiting for the event was canceled!'); + * } else { + * console.error('There was an error', error.message); + * } + * } + * } + * + * foo(ee, 'foo', ac.signal); + * ac.abort(); // Abort waiting for the event + * ee.emit('foo'); // Prints: Waiting for the event was canceled! + * ``` + */ + static once( + emitter: NodeEventTarget, + eventName: string | symbol, + options?: StaticEventEmitterOptions, + ): Promise; + static once( + emitter: DOMEventTarget, + eventName: string, + options?: StaticEventEmitterOptions, + ): Promise; + /** + * ```js + * const { on, EventEmitter } = require('events'); + * + * (async () => { + * const ee = new EventEmitter(); + * + * // Emit later on + * process.nextTick(() => { + * ee.emit('foo', 'bar'); + * ee.emit('foo', 42); + * }); + * + * for await (const event of on(ee, 'foo')) { + * // The execution of this inner block is synchronous and it + * // processes one event at a time (even with await). Do not use + * // if concurrent execution is required. + * console.log(event); // prints ['bar'] [42] + * } + * // Unreachable here + * })(); + * ``` + * + * Returns an `AsyncIterator` that iterates `eventName` events. It will throw + * if the `EventEmitter` emits `'error'`. It removes all listeners when + * exiting the loop. The `value` returned by each iteration is an array + * composed of the emitted event arguments. + * + * An `AbortSignal` can be used to cancel waiting on events: + * + * ```js + * const { on, EventEmitter } = require('events'); + * const ac = new AbortController(); + * + * (async () => { + * const ee = new EventEmitter(); + * + * // Emit later on + * process.nextTick(() => { + * ee.emit('foo', 'bar'); + * ee.emit('foo', 42); + * }); + * + * for await (const event of on(ee, 'foo', { signal: ac.signal })) { + * // The execution of this inner block is synchronous and it + * // processes one event at a time (even with await). Do not use + * // if concurrent execution is required. + * console.log(event); // prints ['bar'] [42] + * } + * // Unreachable here + * })(); + * + * process.nextTick(() => ac.abort()); + * ``` + * @param eventName The name of the event being listened for + * @return that iterates `eventName` events emitted by the `emitter` + */ + static on( + emitter: EventEmitter, + eventName: string, + options?: StaticEventEmitterOptions, + ): AsyncIterableIterator; + /** + * A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`. + * + * ```js + * const { EventEmitter, listenerCount } = require('events'); + * const myEmitter = new EventEmitter(); + * myEmitter.on('event', () => {}); + * myEmitter.on('event', () => {}); + * console.log(listenerCount(myEmitter, 'event')); + * // Prints: 2 + * ``` + * @deprecated Since v3.2.0 - Use `listenerCount` instead. + * @param emitter The emitter to query + * @param eventName The event name + */ + static listenerCount( + emitter: EventEmitter, + eventName: string | symbol, + ): number; + /** + * Returns a copy of the array of listeners for the event named `eventName`. + * + * For `EventEmitter`s this behaves exactly the same as calling `.listeners` on + * the emitter. + * + * For `EventTarget`s this is the only way to get the event listeners for the + * event target. This is useful for debugging and diagnostic purposes. + * + * ```js + * const { getEventListeners, EventEmitter } = require('events'); + * + * { + * const ee = new EventEmitter(); + * const listener = () => console.log('Events are fun'); + * ee.on('foo', listener); + * getEventListeners(ee, 'foo'); // [listener] + * } + * { + * const et = new EventTarget(); + * const listener = () => console.log('Events are fun'); + * et.addEventListener('foo', listener); + * getEventListeners(et, 'foo'); // [listener] + * } + * ``` + */ + static getEventListeners( + emitter: DOMEventTarget | EventEmitter, + name: string | symbol, + ): Function[]; + /** + * ```js + * const { + * setMaxListeners, + * EventEmitter + * } = require('events'); + * + * const target = new EventTarget(); + * const emitter = new EventEmitter(); + * + * setMaxListeners(5, target, emitter); + * ``` + * @param n A non-negative number. The maximum number of listeners per `EventTarget` event. + * @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter} + * objects. + */ + static setMaxListeners( + n?: number, + ...eventTargets: Array + ): void; + /** + * This symbol shall be used to install a listener for only monitoring `'error'` + * events. Listeners installed using this symbol are called before the regular + * `'error'` listeners are called. + * + * Installing a listener using this symbol does not change the behavior once an + * `'error'` event is emitted, therefore the process will still crash if no + * regular `'error'` listener is installed. + */ + static readonly errorMonitor: unique symbol; + static readonly captureRejectionSymbol: unique symbol; + /** + * Sets or gets the default captureRejection value for all emitters. + */ + static captureRejections: boolean; + static defaultMaxListeners: number; + } + import internal = require("node:events"); + namespace EventEmitter { + // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4 + export { internal as EventEmitter }; + export interface Abortable { + /** + * When provided the corresponding `AbortController` can be used to cancel an asynchronous action. + */ + signal?: AbortSignal | undefined; + } + } + export = EventEmitter; +} +declare module "node:events" { + import events = require("events"); + export = events; +} diff --git a/packages/bun-types/ffi.d.ts b/packages/bun-types/ffi.d.ts new file mode 100644 index 0000000000..316673b9ec --- /dev/null +++ b/packages/bun-types/ffi.d.ts @@ -0,0 +1,813 @@ +/** + * `bun:ffi` lets you efficiently call C functions & FFI functions from JavaScript + * without writing bindings yourself. + * + * ```js + * import {dlopen, CString, ptr} from 'bun:ffi'; + * + * const lib = dlopen('libsqlite3', { + * }); + * ``` + * + * This is powered by just-in-time compiling C wrappers + * that convert JavaScript types to C types and back. Internally, + * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks + * goes to Fabrice Bellard and TinyCC maintainers for making this possible. + * + */ +declare module "bun:ffi" { + export enum FFIType { + char = 0, + /** + * 8-bit signed integer + * + * Must be a value between -127 and 127 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * signed char + * char // on x64 & aarch64 macOS + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + int8_t = 1, + /** + * 8-bit signed integer + * + * Must be a value between -127 and 127 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * signed char + * char // on x64 & aarch64 macOS + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + i8 = 1, + + /** + * 8-bit unsigned integer + * + * Must be a value between 0 and 255 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * unsigned char + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + uint8_t = 2, + /** + * 8-bit unsigned integer + * + * Must be a value between 0 and 255 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * unsigned char + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + u8 = 2, + + /** + * 16-bit signed integer + * + * Must be a value between -32768 and 32767 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * in16_t + * short // on arm64 & x64 + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + int16_t = 3, + /** + * 16-bit signed integer + * + * Must be a value between -32768 and 32767 + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * in16_t + * short // on arm64 & x64 + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + i16 = 3, + + /** + * 16-bit unsigned integer + * + * Must be a value between 0 and 65535, inclusive. + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * uint16_t + * unsigned short // on arm64 & x64 + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + uint16_t = 4, + /** + * 16-bit unsigned integer + * + * Must be a value between 0 and 65535, inclusive. + * + * When passing to a FFI function (C ABI), type coercion is not performed. + * + * In C: + * ```c + * uint16_t + * unsigned short // on arm64 & x64 + * ``` + * + * In JavaScript: + * ```js + * var num = 0; + * ``` + */ + u16 = 4, + + /** + * 32-bit signed integer + * + */ + int32_t = 5, + + /** + * 32-bit signed integer + * + * Alias of {@link FFIType.int32_t} + */ + i32 = 5, + /** + * 32-bit signed integer + * + * The same as `int` in C + * + * ```c + * int + * ``` + */ + int = 5, + + /** + * 32-bit unsigned integer + * + * The same as `unsigned int` in C (on x64 & arm64) + * + * C: + * ```c + * unsigned int + * ``` + * JavaScript: + * ```js + * ptr(new Uint32Array(1)) + * ``` + */ + uint32_t = 6, + /** + * 32-bit unsigned integer + * + * Alias of {@link FFIType.uint32_t} + */ + u32 = 6, + + /** + * int64 is a 64-bit signed integer + * + * This is not implemented yet! + */ + int64_t = 7, + /** + * i64 is a 64-bit signed integer + * + * This is not implemented yet! + */ + i64 = 7, + + /** + * 64-bit unsigned integer + * + * This is not implemented yet! + */ + uint64_t = 8, + /** + * 64-bit unsigned integer + * + * This is not implemented yet! + */ + u64 = 8, + + /** + * Doubles are not supported yet! + */ + double = 9, + /** + * Doubles are not supported yet! + */ + f64 = 9, + /** + * Floats are not supported yet! + */ + float = 10, + /** + * Floats are not supported yet! + */ + f32 = 10, + + /** + * Booelan value + * + * Must be `true` or `false`. `0` and `1` type coercion is not supported. + * + * In C, this corresponds to: + * ```c + * bool + * _Bool + * ``` + * + * + */ + bool = 11, + + /** + * Pointer value + * + * See {@link Bun.FFI.ptr} for more information + * + * In C: + * ```c + * void* + * ``` + * + * In JavaScript: + * ```js + * ptr(new Uint8Array(1)) + * ``` + */ + ptr = 12, + /** + * Pointer value + * + * alias of {@link FFIType.ptr} + */ + pointer = 12, + + /** + * void value + * + * void arguments are not supported + * + * void return type is the default return type + * + * In C: + * ```c + * void + * ``` + * + */ + void = 13, + + /** + * When used as a `returns`, this will automatically become a {@link CString}. + * + * When used in `args` it is equivalent to {@link FFIType.pointer} + * + */ + cstring = 14, + + /** + * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance + * but means you might get a `BigInt` or you might get a `number`. + * + * In C, this always becomes `int64_t` + * + * In JavaScript, this could be number or it could be BigInt, depending on what + * value is passed in. + * + */ + i64_fast = 15, + + /** + * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance + * but means you might get a `BigInt` or you might get a `number`. + * + * In C, this always becomes `uint64_t` + * + * In JavaScript, this could be number or it could be BigInt, depending on what + * value is passed in. + * + */ + u64_fast = 16, + } + export type FFITypeOrString = + | FFIType + | "char" + | "int8_t" + | "i8" + | "uint8_t" + | "u8" + | "int16_t" + | "i16" + | "uint16_t" + | "u16" + | "int32_t" + | "i32" + | "int" + | "uint32_t" + | "u32" + | "int64_t" + | "i64" + | "uint64_t" + | "u64" + | "double" + | "f64" + | "float" + | "f32" + | "bool" + | "ptr" + | "pointer" + | "void" + | "cstring" + | "function"; + + interface FFIFunction { + /** + * Arguments to a FFI function (C ABI) + * + * Defaults to an empty array, which means no arguments. + * + * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}. + * + * @example + * From JavaScript: + * ```js + * const lib = dlopen('add', { + * // FFIType can be used or you can pass string labels. + * args: [FFIType.i32, "i32"], + * returns: "i32", + * }); + * lib.symbols.add(1, 2) + * ``` + * In C: + * ```c + * int add(int a, int b) { + * return a + b; + * } + * ``` + */ + args?: FFITypeOrString[]; + /** + * Return type to a FFI function (C ABI) + * + * Defaults to {@link FFIType.void} + * + * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}. + * + * @example + * From JavaScript: + * ```js + * const lib = dlopen('z', { + * version: { + * returns: "ptr", + * } + * }); + * console.log(new CString(lib.symbols.version())); + * ``` + * In C: + * ```c + * char* version() + * { + * return "1.0.0"; + * } + * ``` + */ + returns?: FFITypeOrString; + + /** + * Function pointer to the native function + * + * If provided, instead of using dlsym() to lookup the function, Bun will use this instead. + * This pointer should not be null (0). + * + * This is useful if the library has already been loaded + * or if the module is also using Node-API. + */ + ptr?: number | bigint; + + /** + * Can C/FFI code call this function from a separate thread? + * + * Only supported with {@link JSCallback}. + * + * This does not make the function run in a separate thread. It is still up to the application/library + * to run their code in a separate thread. + * + * By default, {@link JSCallback} calls are not thread-safe. Turning this on + * incurs a small performance penalty for every function call. That small + * performance penalty needs to be less than the performance gain from + * running the function in a separate thread. + * + * @default false + */ + threadsafe?: boolean; + } + + type Symbols = Record; + + // /** + // * Compile a callback function + // * + // * Returns a function pointer + // * + // */ + // export function callback(ffi: FFIFunction, cb: Function): number; + + export interface Library { + symbols: Record< + string, + CallableFunction & { + /** + * The function without a wrapper + */ + native: CallableFunction; + } + >; + + /** + * `dlclose` the library, unloading the symbols and freeing allocated memory. + * + * Once called, the library is no longer usable. + * + * Calling a function from a library that has been closed is undefined behavior. + */ + close(): void; + } + + /** + * Open a library using `"bun:ffi"` + * + * @param name The name of the library or file path. This will be passed to `dlopen()` + * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction} + * + * @example + * + * ```js + * import {dlopen} from 'bun:ffi'; + * + * const lib = dlopen("duckdb.dylib", { + * get_version: { + * returns: "cstring", + * args: [], + * }, + * }); + * lib.symbols.get_version(); + * // "1.0.0" + * ``` + * + * This is powered by just-in-time compiling C wrappers + * that convert JavaScript types to C types and back. Internally, + * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks + * goes to Fabrice Bellard and TinyCC maintainers for making this possible. + * + */ + export function dlopen(name: string, symbols: Symbols): Library; + + /** + * Turn a native library's function pointer into a JavaScript function + * + * Libraries using Node-API & bun:ffi in the same module could use this to skip an extra dlopen() step. + * + * @param fn {@link FFIFunction} declaration. `ptr` is required + * + * @example + * + * ```js + * import {CFunction} from 'bun:ffi'; + * + * const getVersion = new CFunction({ + * returns: "cstring", + * args: [], + * ptr: myNativeLibraryGetVersion, + * }); + * getVersion(); + * getVersion.close(); + * ``` + * + * This is powered by just-in-time compiling C wrappers + * that convert JavaScript types to C types and back. Internally, + * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks + * goes to Fabrice Bellard and TinyCC maintainers for making this possible. + * + */ + export function CFunction( + fn: FFIFunction & { ptr: number | bigint }, + ): CallableFunction & { + /** + * Free the memory allocated by the wrapping function + */ + close(): void; + }; + + /** + * Link a map of symbols to JavaScript functions + * + * This lets you use native libraries that were already loaded somehow. You usually will want {@link dlopen} instead. + * + * You could use this with Node-API to skip loading a second time. + * + * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction} + * + * @example + * + * ```js + * import { linkSymbols } from "bun:ffi"; + * + * const [majorPtr, minorPtr, patchPtr] = getVersionPtrs(); + * + * const lib = linkSymbols({ + * // Unlike with dlopen(), the names here can be whatever you want + * getMajor: { + * returns: "cstring", + * args: [], + * + * // Since this doesn't use dlsym(), you have to provide a valid ptr + * // That ptr could be a number or a bigint + * // An invalid pointer will crash your program. + * ptr: majorPtr, + * }, + * getMinor: { + * returns: "cstring", + * args: [], + * ptr: minorPtr, + * }, + * getPatch: { + * returns: "cstring", + * args: [], + * ptr: patchPtr, + * }, + * }); + * + * const [major, minor, patch] = [ + * lib.symbols.getMajor(), + * lib.symbols.getMinor(), + * lib.symbols.getPatch(), + * ]; + * ``` + * + * This is powered by just-in-time compiling C wrappers + * that convert JavaScript types to C types and back. Internally, + * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks + * goes to Fabrice Bellard and TinyCC maintainers for making this possible. + * + */ + export function linkSymbols(symbols: Symbols): Library; + + /** + * Read a pointer as a {@link Buffer} + * + * If `byteLength` is not provided, the pointer is assumed to be 0-terminated. + * + * @param ptr The memory address to read + * @param byteOffset bytes to skip before reading + * @param byteLength bytes to read + * + * While there are some checks to catch invalid pointers, this is a difficult + * thing to do safely. Passing an invalid pointer can crash the program and + * reading beyond the bounds of the pointer will crash the program or cause + * undefined behavior. Use with care! + * + */ + export function toBuffer( + ptr: number, + byteOffset?: number, + byteLength?: number, + ): Buffer; + + /** + * Read a pointer as an {@link ArrayBuffer} + * + * If `byteLength` is not provided, the pointer is assumed to be 0-terminated. + * + * @param ptr The memory address to read + * @param byteOffset bytes to skip before reading + * @param byteLength bytes to read + * + * While there are some checks to catch invalid pointers, this is a difficult + * thing to do safely. Passing an invalid pointer can crash the program and + * reading beyond the bounds of the pointer will crash the program or cause + * undefined behavior. Use with care! + */ + export function toArrayBuffer( + ptr: number, + byteOffset?: number, + byteLength?: number, + ): ArrayBuffer; + + /** + * Get the pointer backing a {@link TypedArray} or {@link ArrayBuffer} + * + * Use this to pass {@link TypedArray} or {@link ArrayBuffer} to C functions. + * + * This is for use with FFI functions. For performance reasons, FFI will + * not automatically convert typed arrays to C pointers. + * + * @param {TypedArray|ArrayBuffer|DataView} view the typed array or array buffer to get the pointer for + * @param {number} byteOffset optional offset into the view in bytes + * + * @example + * + * From JavaScript: + * ```js + * const array = new Uint8Array(10); + * const rawPtr = ptr(array); + * myFFIFunction(rawPtr); + * ``` + * To C: + * ```c + * void myFFIFunction(char* rawPtr) { + * // Do something with rawPtr + * } + * ``` + * + */ + export function ptr( + view: TypedArray | ArrayBufferLike | DataView, + byteOffset?: number, + ): number; + + /** + * Get a string from a UTF-8 encoded C string + * If `byteLength` is not provided, the string is assumed to be null-terminated. + * + * @example + * ```js + * var ptr = lib.symbols.getVersion(); + * console.log(new CString(ptr)); + * ``` + * + * @example + * ```js + * var ptr = lib.symbols.getVersion(); + * // print the first 4 characters + * console.log(new CString(ptr, 0, 4)); + * ``` + * + * While there are some checks to catch invalid pointers, this is a difficult + * thing to do safely. Passing an invalid pointer can crash the program and + * reading beyond the bounds of the pointer will crash the program or cause + * undefined behavior. Use with care! + */ + + export class CString extends String { + /** + * Get a string from a UTF-8 encoded C string + * If `byteLength` is not provided, the string is assumed to be null-terminated. + * + * @param ptr The pointer to the C string + * @param byteOffset bytes to skip before reading + * @param byteLength bytes to read + * + * + * @example + * ```js + * var ptr = lib.symbols.getVersion(); + * console.log(new CString(ptr)); + * ``` + * + * @example + * ```js + * var ptr = lib.symbols.getVersion(); + * // print the first 4 characters + * console.log(new CString(ptr, 0, 4)); + * ``` + * + * While there are some checks to catch invalid pointers, this is a difficult + * thing to do safely. Passing an invalid pointer can crash the program and + * reading beyond the bounds of the pointer will crash the program or cause + * undefined behavior. Use with care! + */ + constructor(ptr: number, byteOffset?: number, byteLength?: number); + + /** + * The ptr to the C string + * + * This `CString` instance is a clone of the string, so it + * is safe to continue using this instance after the `ptr` has been + * freed. + */ + ptr: number; + byteOffset?: number; + byteLength?: number; + + /** + * Get the {@link ptr} as an `ArrayBuffer` + * + * `null` or empty ptrs returns an `ArrayBuffer` with `byteLength` 0 + */ + get arrayBuffer(): ArrayBuffer; + } + + /** + * Pass a JavaScript function to FFI (Foreign Function Interface) + */ + export class JSCallback { + /** + * Enable a JavaScript callback function to be passed to C with bun:ffi + * + * @param callback The JavaScript function to be called + * @param definition The C function definition + */ + constructor(callback: (...args: any[]) => any, definition: FFIFunction); + + /** + * The pointer to the C function + * + * Becomes `null` once {@link JSCallback.prototype.close} is called + */ + readonly ptr: number | null; + + /** + * Can the callback be called from a different thread? + */ + readonly threadsafe: boolean; + + /** + * Free the memory allocated for the callback + * + * If called multiple times, does nothing after the first call. + */ + close(): void; + } + + /** + * View the generated C code for FFI bindings + * + * You probably won't need this unless there's a bug in the FFI bindings + * generator or you're just curious. + */ + export function viewSource(symbols: Symbols, is_callback?: false): string[]; + export function viewSource(callback: FFIFunction, is_callback: true): string; + + /** + * Platform-specific file extension name for dynamic libraries + * + * "." is not included + * + * @example + * ```js + * "dylib" // macOS + * ``` + * + * @example + * ```js + * "so" // linux + * ``` + */ + export const suffix: string; +} diff --git a/packages/bun-types/fs.d.ts b/packages/bun-types/fs.d.ts new file mode 100644 index 0000000000..c4fc1f99c4 --- /dev/null +++ b/packages/bun-types/fs.d.ts @@ -0,0 +1,3935 @@ +/** + * The `fs` module enables interacting with the file system in a + * way modeled on standard POSIX functions. + * + * To use the promise-based APIs: + * + * ```js + * import * as fs from 'fs/promises'; + * ``` + * + * To use the callback and sync APIs: + * + * ```js + * import * as fs from 'fs'; + * ``` + * + * All file system operations have synchronous and callback + * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM). + */ +declare module "fs" { + import * as stream from "stream"; + import type { SystemError } from "bun"; + + interface ObjectEncodingOptions { + encoding?: BufferEncoding | null | undefined; + } + type EncodingOption = + | ObjectEncodingOptions + | BufferEncoding + | undefined + | null; + type OpenMode = number | string; + type Mode = number | string; + type SimlinkType = "symlink" | "junction" | undefined | null; + interface StatsBase { + isFile(): boolean; + isDirectory(): boolean; + isBlockDevice(): boolean; + isCharacterDevice(): boolean; + isSymbolicLink(): boolean; + isFIFO(): boolean; + isSocket(): boolean; + dev: T; + ino: T; + mode: T; + nlink: T; + uid: T; + gid: T; + rdev: T; + size: T; + blksize: T; + blocks: T; + atimeMs: T; + mtimeMs: T; + ctimeMs: T; + birthtimeMs: T; + atime: Date; + mtime: Date; + ctime: Date; + birthtime: Date; + } + interface Stats extends StatsBase {} + /** + * A `fs.Stats` object provides information about a file. + * + * Objects returned from {@link stat}, {@link lstat} and {@link fstat} and + * their synchronous counterparts are of this type. + * If `bigint` in the `options` passed to those methods is true, the numeric values + * will be `bigint` instead of `number`, and the object will contain additional + * nanosecond-precision properties suffixed with `Ns`. + * + * ```console + * Stats { + * dev: 2114, + * ino: 48064969, + * mode: 33188, + * nlink: 1, + * uid: 85, + * gid: 100, + * rdev: 0, + * size: 527, + * blksize: 4096, + * blocks: 8, + * atimeMs: 1318289051000.1, + * mtimeMs: 1318289051000.1, + * ctimeMs: 1318289051000.1, + * birthtimeMs: 1318289051000.1, + * atime: Mon, 10 Oct 2011 23:24:11 GMT, + * mtime: Mon, 10 Oct 2011 23:24:11 GMT, + * ctime: Mon, 10 Oct 2011 23:24:11 GMT, + * birthtime: Mon, 10 Oct 2011 23:24:11 GMT } + * ``` + * + * `bigint` version: + * + * ```console + * BigIntStats { + * dev: 2114n, + * ino: 48064969n, + * mode: 33188n, + * nlink: 1n, + * uid: 85n, + * gid: 100n, + * rdev: 0n, + * size: 527n, + * blksize: 4096n, + * blocks: 8n, + * atimeMs: 1318289051000n, + * mtimeMs: 1318289051000n, + * ctimeMs: 1318289051000n, + * birthtimeMs: 1318289051000n, + * atimeNs: 1318289051000000000n, + * mtimeNs: 1318289051000000000n, + * ctimeNs: 1318289051000000000n, + * birthtimeNs: 1318289051000000000n, + * atime: Mon, 10 Oct 2011 23:24:11 GMT, + * mtime: Mon, 10 Oct 2011 23:24:11 GMT, + * ctime: Mon, 10 Oct 2011 23:24:11 GMT, + * birthtime: Mon, 10 Oct 2011 23:24:11 GMT } + * ``` + * @since v0.0.67 + */ + class Stats {} + /** + * A representation of a directory entry, which can be a file or a subdirectory + * within the directory, as returned by reading from an `fs.Dir`. The + * directory entry is a combination of the file name and file type pairs. + * + * Additionally, when {@link readdir} or {@link readdirSync} is called with + * the `withFileTypes` option set to `true`, the resulting array is filled with `fs.Dirent` objects, rather than strings or `Buffer` s. + * @since v0.0.67 + */ + class Dirent { + /** + * Returns `true` if the `fs.Dirent` object describes a regular file. + * @since v0.0.67 + */ + isFile(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a file system + * directory. + * @since v0.0.67 + */ + isDirectory(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a block device. + * @since v0.0.67 + */ + isBlockDevice(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a character device. + * @since v0.0.67 + */ + isCharacterDevice(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a symbolic link. + * @since v0.0.67 + */ + isSymbolicLink(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a first-in-first-out + * (FIFO) pipe. + * @since v0.0.67 + */ + isFIFO(): boolean; + /** + * Returns `true` if the `fs.Dirent` object describes a socket. + * @since v0.0.67 + */ + isSocket(): boolean; + /** + * The file name that this `fs.Dirent` object refers to. The type of this + * value is determined by the `options.encoding` passed to {@link readdir} or {@link readdirSync}. + * @since v0.0.67 + */ + name: string; + } + + /** + * Asynchronously rename file at `oldPath` to the pathname provided + * as `newPath`. In the case that `newPath` already exists, it will + * be overwritten. If there is a directory at `newPath`, an error will + * be raised instead. No arguments other than a possible exception are + * given to the completion callback. + * + * See also: [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html). + * + * ```js + * import { rename } from 'fs'; + * + * rename('oldFile.txt', 'newFile.txt', (err) => { + * if (err) throw err; + * console.log('Rename complete!'); + * }); + * ``` + * @since v0.0.67 + */ + function rename( + oldPath: PathLike, + newPath: PathLike, + callback: NoParamCallback, + ): void; + // namespace rename { + // /** + // * Asynchronous rename(2) - Change the name or location of a file or directory. + // * @param oldPath A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // * @param newPath A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // */ + // function __promisify__(oldPath: PathLike, newPath: PathLike): Promise; + // } + /** + * Renames the file from `oldPath` to `newPath`. Returns `undefined`. + * + * See the POSIX [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html) documentation for more details. + * @since v0.0.67 + */ + function renameSync(oldPath: PathLike, newPath: PathLike): void; + /** + * Truncates the file. No arguments other than a possible exception are + * given to the completion callback. A file descriptor can also be passed as the + * first argument. In this case, `fs.ftruncate()` is called. + * + * ```js + * import { truncate } from 'fs'; + * // Assuming that 'path/file.txt' is a regular file. + * truncate('path/file.txt', (err) => { + * if (err) throw err; + * console.log('path/file.txt was truncated'); + * }); + * ``` + * + * Passing a file descriptor is deprecated and may result in an error being thrown + * in the future. + * + * See the POSIX [`truncate(2)`](http://man7.org/linux/man-pages/man2/truncate.2.html) documentation for more details. + * @since v0.0.67 + * @param [len=0] + */ + function truncate( + path: PathLike, + len: number | undefined | null, + callback: NoParamCallback, + ): void; + /** + * Asynchronous truncate(2) - Truncate a file to a specified length. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + function truncate(path: PathLike, callback: NoParamCallback): void; + // namespace truncate { + // /** + // * Asynchronous truncate(2) - Truncate a file to a specified length. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param len If not specified, defaults to `0`. + // */ + // function __promisify__(path: PathLike, len?: number | null): Promise; + // } + /** + * Truncates the file. Returns `undefined`. A file descriptor can also be + * passed as the first argument. In this case, `fs.ftruncateSync()` is called. + * + * Passing a file descriptor is deprecated and may result in an error being thrown + * in the future. + * @since v0.0.67 + * @param [len=0] + */ + function truncateSync(path: PathLike, len?: number | null): void; + /** + * Truncates the file descriptor. No arguments other than a possible exception are + * given to the completion callback. + * + * See the POSIX [`ftruncate(2)`](http://man7.org/linux/man-pages/man2/ftruncate.2.html) documentation for more detail. + * + * If the file referred to by the file descriptor was larger than `len` bytes, only + * the first `len` bytes will be retained in the file. + * + * For example, the following program retains only the first four bytes of the + * file: + * + * ```js + * import { open, close, ftruncate } from 'fs'; + * + * function closeFd(fd) { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * + * open('temp.txt', 'r+', (err, fd) => { + * if (err) throw err; + * + * try { + * ftruncate(fd, 4, (err) => { + * closeFd(fd); + * if (err) throw err; + * }); + * } catch (err) { + * closeFd(fd); + * if (err) throw err; + * } + * }); + * ``` + * + * If the file previously was shorter than `len` bytes, it is extended, and the + * extended part is filled with null bytes (`'\0'`): + * + * If `len` is negative then `0` will be used. + * @since v0.0.67 + * @param [len=0] + */ + function ftruncate( + fd: number, + len: number | undefined | null, + callback: NoParamCallback, + ): void; + /** + * Asynchronous ftruncate(2) - Truncate a file to a specified length. + * @param fd A file descriptor. + */ + function ftruncate(fd: number, callback: NoParamCallback): void; + // namespace ftruncate { + // /** + // * Asynchronous ftruncate(2) - Truncate a file to a specified length. + // * @param fd A file descriptor. + // * @param len If not specified, defaults to `0`. + // */ + // function __promisify__(fd: number, len?: number | null): Promise; + // } + /** + * Truncates the file descriptor. Returns `undefined`. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link ftruncate}. + * @since v0.0.67 + * @param [len=0] + */ + function ftruncateSync(fd: number, len?: number | null): void; + /** + * Asynchronously changes owner and group of a file. No arguments other than a + * possible exception are given to the completion callback. + * + * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail. + * @since v0.0.67 + */ + function chown( + path: PathLike, + uid: number, + gid: number, + callback: NoParamCallback, + ): void; + // namespace chown { + // /** + // * Asynchronous chown(2) - Change ownership of a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // path: PathLike, + // uid: number, + // gid: number + // ): Promise; + // } + /** + * Synchronously changes owner and group of a file. Returns `undefined`. + * This is the synchronous version of {@link chown}. + * + * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail. + * @since v0.0.67 + */ + function chownSync(path: PathLike, uid: number, gid: number): void; + /** + * Sets the owner of the file. No arguments other than a possible exception are + * given to the completion callback. + * + * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail. + * @since v0.0.67 + */ + function fchown( + fd: number, + uid: number, + gid: number, + callback: NoParamCallback, + ): void; + // namespace fchown { + // /** + // * Asynchronous fchown(2) - Change ownership of a file. + // * @param fd A file descriptor. + // */ + // function __promisify__(fd: number, uid: number, gid: number): Promise; + // } + /** + * Sets the owner of the file. Returns `undefined`. + * + * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail. + * @since v0.0.67 + * @param uid The file's new owner's user id. + * @param gid The file's new group's group id. + */ + function fchownSync(fd: number, uid: number, gid: number): void; + /** + * Set the owner of the symbolic link. No arguments other than a possible + * exception are given to the completion callback. + * + * See the POSIX [`lchown(2)`](http://man7.org/linux/man-pages/man2/lchown.2.html) documentation for more detail. + */ + function lchown( + path: PathLike, + uid: number, + gid: number, + callback: NoParamCallback, + ): void; + // namespace lchown { + // /** + // * Asynchronous lchown(2) - Change ownership of a file. Does not dereference symbolic links. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // path: PathLike, + // uid: number, + // gid: number + // ): Promise; + // } + /** + * Set the owner for the path. Returns `undefined`. + * + * See the POSIX [`lchown(2)`](http://man7.org/linux/man-pages/man2/lchown.2.html) documentation for more details. + * @param uid The file's new owner's user id. + * @param gid The file's new group's group id. + */ + function lchownSync(path: PathLike, uid: number, gid: number): void; + /** + * Changes the access and modification times of a file in the same way as {@link utimes}, with the difference that if the path refers to a symbolic + * link, then the link is not dereferenced: instead, the timestamps of the + * symbolic link itself are changed. + * + * No arguments other than a possible exception are given to the completion + * callback. + * @since v0.0.67 + */ + function lutimes( + path: PathLike, + atime: TimeLike, + mtime: TimeLike, + callback: NoParamCallback, + ): void; + // namespace lutimes { + // /** + // * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`, + // * with the difference that if the path refers to a symbolic link, then the link is not + // * dereferenced: instead, the timestamps of the symbolic link itself are changed. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param atime The last access time. If a string is provided, it will be coerced to number. + // * @param mtime The last modified time. If a string is provided, it will be coerced to number. + // */ + // function __promisify__( + // path: PathLike, + // atime: TimeLike, + // mtime: TimeLike + // ): Promise; + // } + /** + * Change the file system timestamps of the symbolic link referenced by `path`. + * Returns `undefined`, or throws an exception when parameters are incorrect or + * the operation fails. This is the synchronous version of {@link lutimes}. + * @since v0.0.67 + */ + function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void; + /** + * Asynchronously changes the permissions of a file. No arguments other than a + * possible exception are given to the completion callback. + * + * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail. + * + * ```js + * import { chmod } from 'fs'; + * + * chmod('my_file.txt', 0o775, (err) => { + * if (err) throw err; + * console.log('The permissions for file "my_file.txt" have been changed!'); + * }); + * ``` + * @since v0.0.67 + */ + function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void; + // namespace chmod { + // /** + // * Asynchronous chmod(2) - Change permissions of a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param mode A file mode. If a string is passed, it is parsed as an octal integer. + // */ + // function __promisify__(path: PathLike, mode: Mode): Promise; + // } + /** + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link chmod}. + * + * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail. + * @since v0.0.67 + */ + function chmodSync(path: PathLike, mode: Mode): void; + /** + * Sets the permissions on the file. No arguments other than a possible exception + * are given to the completion callback. + * + * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail. + * @since v0.0.67 + */ + function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void; + // namespace fchmod { + // /** + // * Asynchronous fchmod(2) - Change permissions of a file. + // * @param fd A file descriptor. + // * @param mode A file mode. If a string is passed, it is parsed as an octal integer. + // */ + // function __promisify__(fd: number, mode: Mode): Promise; + // } + /** + * Sets the permissions on the file. Returns `undefined`. + * + * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail. + * @since v0.0.67 + */ + function fchmodSync(fd: number, mode: Mode): void; + /** + * Changes the permissions on a symbolic link. No arguments other than a possible + * exception are given to the completion callback. + * + * This method is only implemented on macOS. + * + * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail. + * @deprecated Since v0.4.7 + */ + function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void; + // /** @deprecated */ + // namespace lchmod { + // /** + // * Asynchronous lchmod(2) - Change permissions of a file. Does not dereference symbolic links. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param mode A file mode. If a string is passed, it is parsed as an octal integer. + // */ + // function __promisify__(path: PathLike, mode: Mode): Promise; + // } + /** + * Changes the permissions on a symbolic link. Returns `undefined`. + * + * This method is only implemented on macOS. + * + * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail. + * @deprecated Since v0.4.7 + */ + function lchmodSync(path: PathLike, mode: Mode): void; + /** + * Asynchronous [`stat(2)`](http://man7.org/linux/man-pages/man2/stat.2.html). The callback gets two arguments `(err, stats)` where`stats` is an `fs.Stats` object. + * + * In case of an error, the `err.code` will be one of `Common System Errors`. + * + * Using `fs.stat()` to check for the existence of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()` is not recommended. + * Instead, user code should open/read/write the file directly and handle the + * error raised if the file is not available. + * + * To check if a file exists without manipulating it afterwards, {@link access} is recommended. + * + * For example, given the following directory structure: + * + * ```text + * - txtDir + * -- file.txt + * - app.js + * ``` + * + * The next program will check for the stats of the given paths: + * + * ```js + * import { stat } from 'fs'; + * + * const pathsToCheck = ['./txtDir', './txtDir/file.txt']; + * + * for (let i = 0; i < pathsToCheck.length; i++) { + * stat(pathsToCheck[i], (err, stats) => { + * console.log(stats.isDirectory()); + * console.log(stats); + * }); + * } + * ``` + * + * The resulting output will resemble: + * + * ```console + * true + * Stats { + * dev: 16777220, + * mode: 16877, + * nlink: 3, + * uid: 501, + * gid: 20, + * rdev: 0, + * blksize: 4096, + * ino: 14214262, + * size: 96, + * blocks: 0, + * atimeMs: 1561174653071.963, + * mtimeMs: 1561174614583.3518, + * ctimeMs: 1561174626623.5366, + * birthtimeMs: 1561174126937.2893, + * atime: 2019-06-22T03:37:33.072Z, + * mtime: 2019-06-22T03:36:54.583Z, + * ctime: 2019-06-22T03:37:06.624Z, + * birthtime: 2019-06-22T03:28:46.937Z + * } + * false + * Stats { + * dev: 16777220, + * mode: 33188, + * nlink: 1, + * uid: 501, + * gid: 20, + * rdev: 0, + * blksize: 4096, + * ino: 14214074, + * size: 8, + * blocks: 8, + * atimeMs: 1561174616618.8555, + * mtimeMs: 1561174614584, + * ctimeMs: 1561174614583.8145, + * birthtimeMs: 1561174007710.7478, + * atime: 2019-06-22T03:36:56.619Z, + * mtime: 2019-06-22T03:36:54.584Z, + * ctime: 2019-06-22T03:36:54.584Z, + * birthtime: 2019-06-22T03:26:47.711Z + * } + * ``` + * @since v0.0.67 + */ + function stat( + path: PathLike, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function stat( + path: PathLike, + options: + | (StatOptions & { + bigint?: false | undefined; + }) + | undefined, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function stat( + path: PathLike, + options: StatOptions & { + bigint: true; + }, + callback: (err: SystemError | null, stats: BigIntStats) => void, + ): void; + function stat( + path: PathLike, + options: StatOptions | undefined, + callback: (err: SystemError | null, stats: Stats | BigIntStats) => void, + ): void; + // namespace stat { + // /** + // * Asynchronous stat(2) - Get file status. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // path: PathLike, + // options?: StatOptions & { + // bigint?: false | undefined; + // } + // ): Promise; + // function __promisify__( + // path: PathLike, + // options: StatOptions & { + // bigint: true; + // } + // ): Promise; + // function __promisify__( + // path: PathLike, + // options?: StatOptions + // ): Promise; + // } + // tslint:disable-next-line:unified-signatures + interface StatSyncFn extends Function { + // tslint:disable-next-line:unified-signatures + (path: PathLike, options?: undefined): Stats; + ( + path: PathLike, + options?: StatSyncOptions & { + bigint?: false | undefined; + throwIfNoEntry: false; + }, + ): Stats | undefined; + ( + path: PathLike, + options: StatSyncOptions & { + bigint: true; + throwIfNoEntry: false; + }, + ): BigIntStats | undefined; + // tslint:disable-next-line:unified-signatures + ( + path: PathLike, + // tslint:disable-next-line:unified-signatures + options?: StatSyncOptions & { + bigint?: false | undefined; + }, + ): Stats; + ( + path: PathLike, + options: StatSyncOptions & { + bigint: true; + }, + ): BigIntStats; + ( + path: PathLike, + options: StatSyncOptions & { + bigint: boolean; + throwIfNoEntry?: false | undefined; + }, + ): Stats | BigIntStats; + (path: PathLike, options?: StatSyncOptions): + | Stats + | BigIntStats + | undefined; + } + /** + * Synchronous stat(2) - Get file status. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + var statSync: StatSyncFn; + /** + * Invokes the callback with the `fs.Stats` for the file descriptor. + * + * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail. + * @since v0.0.67 + */ + function fstat( + fd: number, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function fstat( + fd: number, + options: + | (StatOptions & { + bigint?: false | undefined; + }) + | undefined, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function fstat( + fd: number, + options: StatOptions & { + bigint: true; + }, + callback: (err: SystemError | null, stats: BigIntStats) => void, + ): void; + function fstat( + fd: number, + options: StatOptions | undefined, + callback: (err: SystemError | null, stats: Stats | BigIntStats) => void, + ): void; + // namespace fstat { + // /** + // * Asynchronous fstat(2) - Get file status. + // * @param fd A file descriptor. + // */ + // function __promisify__( + // fd: number, + // options?: StatOptions & { + // bigint?: false | undefined; + // } + // ): Promise; + // function __promisify__( + // fd: number, + // options: StatOptions & { + // bigint: true; + // } + // ): Promise; + // function __promisify__( + // fd: number, + // options?: StatOptions + // ): Promise; + // } + /** + * Retrieves the `fs.Stats` for the file descriptor. + * + * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail. + * @since v0.0.67 + */ + function fstatSync( + fd: number, + options?: StatOptions & { + bigint?: false | undefined; + }, + ): Stats; + function fstatSync( + fd: number, + options: StatOptions & { + bigint: true; + }, + ): BigIntStats; + function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats; + /** + * Retrieves the `fs.Stats` for the symbolic link referred to by the path. + * The callback gets two arguments `(err, stats)` where `stats` is a `fs.Stats` object. `lstat()` is identical to `stat()`, except that if `path` is a symbolic + * link, then the link itself is stat-ed, not the file that it refers to. + * + * See the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) documentation for more details. + * @since v0.0.67 + */ + function lstat( + path: PathLike, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function lstat( + path: PathLike, + options: + | (StatOptions & { + bigint?: false | undefined; + }) + | undefined, + callback: (err: SystemError | null, stats: Stats) => void, + ): void; + function lstat( + path: PathLike, + options: StatOptions & { + bigint: true; + }, + callback: (err: SystemError | null, stats: BigIntStats) => void, + ): void; + function lstat( + path: PathLike, + options: StatOptions | undefined, + callback: (err: SystemError | null, stats: Stats | BigIntStats) => void, + ): void; + // namespace lstat { + // /** + // * Asynchronous lstat(2) - Get file status. Does not dereference symbolic links. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // path: PathLike, + // options?: StatOptions & { + // bigint?: false | undefined; + // } + // ): Promise; + // function __promisify__( + // path: PathLike, + // options: StatOptions & { + // bigint: true; + // } + // ): Promise; + // function __promisify__( + // path: PathLike, + // options?: StatOptions + // ): Promise; + // } + /** + * Synchronous lstat(2) - Get file status. Does not dereference symbolic links. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + var lstatSync: StatSyncFn; + /** + * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. No arguments other than + * a possible + * exception are given to the completion callback. + * @since v0.0.67 + */ + function link( + existingPath: PathLike, + newPath: PathLike, + callback: NoParamCallback, + ): void; + // namespace link { + // /** + // * Asynchronous link(2) - Create a new link (also known as a hard link) to an existing file. + // * @param existingPath A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param newPath A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // existingPath: PathLike, + // newPath: PathLike + // ): Promise; + // } + /** + * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. Returns `undefined`. + * @since v0.0.67 + */ + function linkSync(existingPath: PathLike, newPath: PathLike): void; + /** + * Creates the link called `path` pointing to `target`. No arguments other than a + * possible exception are given to the completion callback. + * + * See the POSIX [`symlink(2)`](http://man7.org/linux/man-pages/man2/symlink.2.html) documentation for more details. + * + * The `type` argument is only available on Windows and ignored on other platforms. + * It can be set to `'dir'`, `'file'`, or `'junction'`. If the `type` argument is + * not set, Node.js will autodetect `target` type and use `'file'` or `'dir'`. If + * the `target` does not exist, `'file'` will be used. Windows junction points + * require the destination path to be absolute. When using `'junction'`, the`target` argument will automatically be normalized to absolute path. + * + * Relative targets are relative to the link’s parent directory. + * + * ```js + * import { symlink } from 'fs'; + * + * symlink('./mew', './example/mewtwo', callback); + * ``` + * + * The above example creates a symbolic link `mewtwo` in the `example` which points + * to `mew` in the same directory: + * + * ```bash + * $ tree example/ + * example/ + * ├── mew + * └── mewtwo -> ./mew + * ``` + * @since v0.0.67 + */ + function symlink( + target: PathLike, + path: PathLike, + type: SimlinkType, + callback: NoParamCallback, + ): void; + /** + * Asynchronous symlink(2) - Create a new symbolic link to an existing file. + * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol. + * @param path A path to the new symlink. If a URL is provided, it must use the `file:` protocol. + */ + function symlink( + target: PathLike, + path: PathLike, + callback: NoParamCallback, + ): void; + // namespace symlink { + // /** + // * Asynchronous symlink(2) - Create a new symbolic link to an existing file. + // * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol. + // * @param path A path to the new symlink. If a URL is provided, it must use the `file:` protocol. + // * @param type May be set to `'dir'`, `'file'`, or `'junction'` (default is `'file'`) and is only available on Windows (ignored on other platforms). + // * When using `'junction'`, the `target` argument will automatically be normalized to an absolute path. + // */ + // function __promisify__( + // target: PathLike, + // path: PathLike, + // type?: string | null + // ): Promise; + // type Type = "dir" | "file" | "junction"; + // } + /** + * Returns `undefined`. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link symlink}. + * @since v0.0.67 + */ + function symlinkSync( + target: PathLike, + path: PathLike, + type?: SimlinkType, + ): void; + /** + * Reads the contents of the symbolic link referred to by `path`. The callback gets + * two arguments `(err, linkString)`. + * + * See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more details. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the link path passed to the callback. If the `encoding` is set to `'buffer'`, + * the link path returned will be passed as a `Buffer` object. + * @since v0.0.67 + */ + function readlink( + path: PathLike, + options: EncodingOption, + callback: (err: SystemError | null, linkString: string) => void, + ): void; + /** + * Asynchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + // tslint:disable-next-line:unified-signatures + function readlink( + path: PathLike, + options: BufferEncodingOption, + callback: (err: SystemError | null, linkString: Buffer) => void, + ): void; + /** + * Asynchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + // tslint:disable-next-line:unified-signatures + function readlink( + path: PathLike, + options: EncodingOption, + // tslint:disable-next-line:unified-signatures + callback: (err: SystemError | null, linkString: string | Buffer) => void, + ): void; + /** + * Asynchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + // tslint:disable-next-line:unified-signatures + function readlink( + path: PathLike, + callback: (err: SystemError | null, linkString: string) => void, + ): void; + // namespace readlink { + // /** + // * Asynchronous readlink(2) - read value of a symbolic link. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: EncodingOption + // ): Promise; + // /** + // * Asynchronous readlink(2) - read value of a symbolic link. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options: BufferEncodingOption + // ): Promise; + // /** + // * Asynchronous readlink(2) - read value of a symbolic link. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: EncodingOption + // ): Promise; + // } + /** + * Returns the symbolic link's string value. + * + * See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more details. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the link path returned. If the `encoding` is set to `'buffer'`, + * the link path returned will be passed as a `Buffer` object. + * @since v0.0.67 + */ + function readlinkSync(path: PathLike, options?: EncodingOption): string; + /** + * Synchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readlinkSync(path: PathLike, options: BufferEncodingOption): Buffer; + /** + * Synchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readlinkSync( + path: PathLike, + options?: EncodingOption, + ): string | Buffer; + /** + * Asynchronously computes the canonical pathname by resolving `.`, `..` and + * symbolic links. + * + * A canonical pathname is not necessarily unique. Hard links and bind mounts can + * expose a file system entity through many pathnames. + * + * This function behaves like [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html), with some exceptions: + * + * 1. No case conversion is performed on case-insensitive file systems. + * 2. The maximum number of symbolic links is platform-independent and generally + * (much) higher than what the native [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html) implementation supports. + * + * The `callback` gets two arguments `(err, resolvedPath)`. May use `process.cwd`to resolve relative paths. + * + * Only paths that can be converted to UTF8 strings are supported. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the path passed to the callback. If the `encoding` is set to `'buffer'`, + * the path returned will be passed as a `Buffer` object. + * + * If `path` resolves to a socket or a pipe, the function will return a system + * dependent name for that object. + * @since v0.0.67 + */ + function realpath( + path: PathLike, + options: EncodingOption, + callback: (err: SystemError | null, resolvedPath: string) => void, + ): void; + /** + * Asynchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + // tslint:disable-next-line:unified-signatures + function realpath( + path: PathLike, + options: BufferEncodingOption, + callback: (err: SystemError | null, resolvedPath: Buffer) => void, + ): void; + /** + * Asynchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + // tslint:disable-next-line:unified-signatures + function realpath( + path: PathLike, + options: EncodingOption, + // tslint:disable-next-line:unified-signatures + callback: (err: SystemError | null, resolvedPath: string | Buffer) => void, + ): void; + /** + * Asynchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + // tslint:disable-next-line:unified-signatures + function realpath( + path: PathLike, + callback: (err: SystemError | null, resolvedPath: string) => void, + ): void; + // namespace realpath { + // /** + // * Asynchronous realpath(3) - return the canonicalized absolute pathname. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: EncodingOption + // ): Promise; + // /** + // * Asynchronous realpath(3) - return the canonicalized absolute pathname. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options: BufferEncodingOption + // ): Promise; + // /** + // * Asynchronous realpath(3) - return the canonicalized absolute pathname. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: EncodingOption + // ): Promise; + // /** + // * Asynchronous [`realpath(3)`](http://man7.org/linux/man-pages/man3/realpath.3.html). + // * + // * The `callback` gets two arguments `(err, resolvedPath)`. + // * + // * Only paths that can be converted to UTF8 strings are supported. + // * + // * The optional `options` argument can be a string specifying an encoding, or an + // * object with an `encoding` property specifying the character encoding to use for + // * the path passed to the callback. If the `encoding` is set to `'buffer'`, + // * the path returned will be passed as a `Buffer` object. + // * + // * On Linux, when Node.js is linked against musl libc, the procfs file system must + // * be mounted on `/proc` in order for this function to work. Glibc does not have + // * this restriction. + // * @since v0.0.67 + // */ + // function native( + // path: PathLike, + // options: EncodingOption, + // // tslint:disable-next-line:unified-signatures + // callback: (err: SystemError | null, resolvedPath: string) => void + // ): void; + // function native( + // path: PathLike, + // options: BufferEncodingOption, + // // tslint:disable-next-line:unified-signatures + // callback: (err: SystemError | null, resolvedPath: Buffer) => void + // ): void; + // function native( + // path: PathLike, + // options: EncodingOption, + // // tslint:disable-next-line:unified-signatures + // callback: (err: SystemError | null, resolvedPath: string | Buffer) => void + // ): void; + // function native( + // path: PathLike, + // callback: (err: SystemError | null, resolvedPath: string) => void + // ): void; + // } + /** + * Returns the resolved pathname. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link realpath}. + * @since v0.0.67 + */ + function realpathSync(path: PathLike, options?: EncodingOption): string; + /** + * Synchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function realpathSync(path: PathLike, options: BufferEncodingOption): Buffer; + /** + * Synchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function realpathSync( + path: PathLike, + options?: EncodingOption, + ): string | Buffer; + namespace realpathSync { + function native(path: PathLike, options?: EncodingOption): string; + function native(path: PathLike, options: BufferEncodingOption): Buffer; + function native(path: PathLike, options?: EncodingOption): string | Buffer; + } + /** + * Asynchronously removes a file or symbolic link. No arguments other than a + * possible exception are given to the completion callback. + * + * ```js + * import { unlink } from 'fs'; + * // Assuming that 'path/file.txt' is a regular file. + * unlink('path/file.txt', (err) => { + * if (err) throw err; + * console.log('path/file.txt was deleted'); + * }); + * ``` + * + * `fs.unlink()` will not work on a directory, empty or otherwise. To remove a + * directory, use {@link rmdir}. + * + * See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more details. + * @since v0.0.67 + */ + function unlink(path: PathLike, callback: NoParamCallback): void; + // namespace unlink { + // /** + // * Asynchronous unlink(2) - delete a name and possibly the file it refers to. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__(path: PathLike): Promise; + // } + /** + * Synchronous [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html). Returns `undefined`. + * @since v0.0.67 + */ + function unlinkSync(path: PathLike): void; + interface RmDirOptions { + /** + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or + * `EPERM` error is encountered, Node.js will retry the operation with a linear + * backoff wait of `retryDelay` ms longer on each try. This option represents the + * number of retries. This option is ignored if the `recursive` option is not + * `true`. + * @default 0 + */ + maxRetries?: number | undefined; + /** + * @deprecated since v14.14.0 In future versions of Node.js and will trigger a warning + * `fs.rmdir(path, { recursive: true })` will throw if `path` does not exist or is a file. + * Use `fs.rm(path, { recursive: true, force: true })` instead. + * + * If `true`, perform a recursive directory removal. In + * recursive mode operations are retried on failure. + * @default false + */ + recursive?: boolean | undefined; + /** + * The amount of time in milliseconds to wait between retries. + * This option is ignored if the `recursive` option is not `true`. + * @default 100 + */ + retryDelay?: number | undefined; + } + /** + * Asynchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). No arguments other than a possible exception are given + * to the completion callback. + * + * Using `fs.rmdir()` on a file (not a directory) results in an `ENOENT` error on + * Windows and an `ENOTDIR` error on POSIX. + * + * To get a behavior similar to the `rm -rf` Unix command, use {@link rm} with options `{ recursive: true, force: true }`. + * @since v0.0.67 + */ + function rmdir(path: PathLike, callback: NoParamCallback): void; + function rmdir( + path: PathLike, + options: RmDirOptions, + callback: NoParamCallback, + ): void; + // namespace rmdir { + // /** + // * Asynchronous rmdir(2) - delete a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // */ + // function __promisify__( + // path: PathLike, + // options?: RmDirOptions + // ): Promise; + // } + /** + * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`. + * + * Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error + * on Windows and an `ENOTDIR` error on POSIX. + * + * To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`. + * @since v0.0.67 + */ + function rmdirSync(path: PathLike, options?: RmDirOptions): void; + interface RmOptions { + /** + * When `true`, exceptions will be ignored if `path` does not exist. + * @default false + */ + force?: boolean | undefined; + /** + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or + * `EPERM` error is encountered, Node.js will retry the operation with a linear + * backoff wait of `retryDelay` ms longer on each try. This option represents the + * number of retries. This option is ignored if the `recursive` option is not + * `true`. + * @default 0 + */ + maxRetries?: number | undefined; + /** + * If `true`, perform a recursive directory removal. In + * recursive mode, operations are retried on failure. + * @default false + */ + recursive?: boolean | undefined; + /** + * The amount of time in milliseconds to wait between retries. + * This option is ignored if the `recursive` option is not `true`. + * @default 100 + */ + retryDelay?: number | undefined; + } + /** + * Asynchronously removes files and directories (modeled on the standard POSIX `rm`utility). No arguments other than a possible exception are given to the + * completion callback. + * @since v14.14.0 + */ + export function rm(path: PathLike, callback: NoParamCallback): void; + export function rm( + path: PathLike, + options: RmOptions, + callback: NoParamCallback, + ): void; + export namespace rm { + /** + * Asynchronously removes files and directories (modeled on the standard POSIX `rm` utility). + */ + function __promisify__(path: PathLike, options?: RmOptions): Promise; + } + /** + * Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`. + * @since v14.14.0 + */ + export function rmSync(path: PathLike, options?: RmOptions): void; + export interface MakeDirectoryOptions { + /** + * Indicates whether parent folders should be created. + * If a folder was created, the path to the first created folder will be returned. + * @default false + */ + recursive?: boolean | undefined; + /** + * A file mode. If a string is passed, it is parsed as an octal integer. If not specified + * @default 0o777 + */ + mode?: Mode | undefined; + } + interface MakeDirectoryOptions { + /** + * Indicates whether parent folders should be created. + * If a folder was created, the path to the first created folder will be returned. + * @default false + */ + recursive?: boolean | undefined; + /** + * A file mode. If a string is passed, it is parsed as an octal integer. If not specified + * @default 0o777 + */ + mode?: Mode | undefined; + } + /** + * Asynchronously creates a directory. + * + * The callback is given a possible exception and, if `recursive` is `true`, the + * first directory path created, `(err[, path])`.`path` can still be `undefined` when `recursive` is `true`, if no directory was + * created. + * + * The optional `options` argument can be an integer specifying `mode` (permission + * and sticky bits), or an object with a `mode` property and a `recursive`property indicating whether parent directories should be created. Calling`fs.mkdir()` when `path` is a directory that + * exists results in an error only + * when `recursive` is false. + * + * ```js + * import { mkdir } from 'fs'; + * + * // Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist. + * mkdir('/tmp/a/apple', { recursive: true }, (err) => { + * if (err) throw err; + * }); + * ``` + * + * On Windows, using `fs.mkdir()` on the root directory even with recursion will + * result in an error: + * + * ```js + * import { mkdir } from 'fs'; + * + * mkdir('/', { recursive: true }, (err) => { + * // => [Error: EPERM: operation not permitted, mkdir 'C:\'] + * }); + * ``` + * + * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details. + * @since v0.0.67 + */ + function mkdir( + path: PathLike, + options: MakeDirectoryOptions & { + recursive: true; + }, + callback: (err: SystemError | null, path?: string) => void, + ): void; + /** + * Asynchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdir( + path: PathLike, + options: + | Mode + | (MakeDirectoryOptions & { + recursive?: false | undefined; + }) + | null + | undefined, + callback: NoParamCallback, + ): void; + /** + * Asynchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdir( + path: PathLike, + // tslint:disable-next-line:unified-signatures + options: Mode | MakeDirectoryOptions | null | undefined, + callback: (err: SystemError | null, path?: string) => void, + ): void; + /** + * Asynchronous mkdir(2) - create a directory with a mode of `0o777`. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + function mkdir(path: PathLike, callback: NoParamCallback): void; + // namespace mkdir { + // /** + // * Asynchronous mkdir(2) - create a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + // * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + // */ + // function __promisify__( + // path: PathLike, + // options: MakeDirectoryOptions & { + // recursive: true; + // } + // ): Promise; + // /** + // * Asynchronous mkdir(2) - create a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + // * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + // */ + // function __promisify__( + // path: PathLike, + // options?: + // | Mode + // | (MakeDirectoryOptions & { + // recursive?: false | undefined; + // }) + // | null + // ): Promise; + // /** + // * Asynchronous mkdir(2) - create a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + // * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + // */ + // function __promisify__( + // path: PathLike, + // options?: Mode | MakeDirectoryOptions | null + // ): Promise; + // } + /** + * Synchronously creates a directory. Returns `undefined`, or if `recursive` is`true`, the first directory path created. + * This is the synchronous version of {@link mkdir}. + * + * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details. + * @since v0.0.67 + */ + function mkdirSync( + path: PathLike, + options: MakeDirectoryOptions & { + recursive: true; + }, + ): string | undefined; + /** + * Synchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdirSync( + path: PathLike, + options?: + | Mode + | (MakeDirectoryOptions & { + recursive?: false | undefined; + }) + | null, + ): void; + /** + * Synchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdirSync( + path: PathLike, + options?: Mode | MakeDirectoryOptions | null, + ): string | undefined; + /** + * Creates a unique temporary directory. + * + * Generates six random characters to be appended behind a required`prefix` to create a unique temporary directory. Due to platform + * inconsistencies, avoid trailing `X` characters in `prefix`. Some platforms, + * notably the BSDs, can return more than six random characters, and replace + * trailing `X` characters in `prefix` with random characters. + * + * The created directory path is passed as a string to the callback's second + * parameter. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use. + * + * ```js + * import { mkdtemp } from 'fs'; + * + * mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => { + * if (err) throw err; + * console.log(directory); + * // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2 + * }); + * ``` + * + * The `fs.mkdtemp()` method will append the six randomly selected characters + * directly to the `prefix` string. For instance, given a directory `/tmp`, if the + * intention is to create a temporary directory _within_`/tmp`, the `prefix`must end with a trailing platform-specific path separator + * (`require('path').sep`). + * + * ```js + * import { tmpdir } from 'os'; + * import { mkdtemp } from 'fs'; + * + * // The parent directory for the new temporary directory + * const tmpDir = tmpdir(); + * + * // This method is *INCORRECT*: + * mkdtemp(tmpDir, (err, directory) => { + * if (err) throw err; + * console.log(directory); + * // Will print something similar to `/tmpabc123`. + * // A new temporary directory is created at the file system root + * // rather than *within* the /tmp directory. + * }); + * + * // This method is *CORRECT*: + * import { sep } from 'path'; + * mkdtemp(`${tmpDir}${sep}`, (err, directory) => { + * if (err) throw err; + * console.log(directory); + * // Will print something similar to `/tmp/abc123`. + * // A new temporary directory is created within + * // the /tmp directory. + * }); + * ``` + * @since v0.0.67 + */ + function mkdtemp( + prefix: string, + options: EncodingOption, + callback: (err: SystemError | null, folder: string) => void, + ): void; + /** + * Asynchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function mkdtemp( + prefix: string, + options: + | "buffer" + | { + encoding: "buffer"; + }, + callback: (err: SystemError | null, folder: Buffer) => void, + ): void; + /** + * Asynchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function mkdtemp( + prefix: string, + options: EncodingOption, + // tslint:disable-next-line:unified-signatures + callback: (err: SystemError | null, folder: string | Buffer) => void, + ): void; + /** + * Asynchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + */ + // tslint:disable-next-line:unified-signatures + function mkdtemp( + prefix: string, + callback: (err: SystemError | null, folder: string) => void, + ): void; + // namespace mkdtemp { + // /** + // * Asynchronously creates a unique temporary directory. + // * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // prefix: string, + // options?: EncodingOption + // ): Promise; + // /** + // * Asynchronously creates a unique temporary directory. + // * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // prefix: string, + // options: BufferEncodingOption + // ): Promise; + // /** + // * Asynchronously creates a unique temporary directory. + // * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // prefix: string, + // options?: EncodingOption + // ): Promise; + // } + /** + * Returns the created directory path. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link mkdtemp}. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use. + * @since v0.0.67 + */ + function mkdtempSync(prefix: string, options?: EncodingOption): string; + /** + * Synchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer; + /** + * Synchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function mkdtempSync( + prefix: string, + options?: EncodingOption, + ): string | Buffer; + /** + * Reads the contents of a directory. The callback gets two arguments `(err, files)`where `files` is an array of the names of the files in the directory excluding`'.'` and `'..'`. + * + * See the POSIX [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) documentation for more details. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the filenames passed to the callback. If the `encoding` is set to `'buffer'`, + * the filenames returned will be passed as `Buffer` objects. + * + * If `options.withFileTypes` is set to `true`, the `files` array will contain `fs.Dirent` objects. + * @since v0.0.67 + */ + function readdir( + path: PathLike, + options: + | { + encoding: BufferEncoding | null; + withFileTypes?: false | undefined; + } + | BufferEncoding + | undefined + | null, + callback: (err: SystemError | null, files: string[]) => void, + ): void; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readdir( + path: PathLike, + options: + | { + encoding: "buffer"; + withFileTypes?: false | undefined; + } + | "buffer", + callback: (err: SystemError | null, files: Buffer[]) => void, + ): void; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readdir( + path: PathLike, + options: + | (ObjectEncodingOptions & { + withFileTypes?: false | undefined; + }) + | BufferEncoding + | undefined + | null, + callback: (err: SystemError | null, files: string[] | Buffer[]) => void, + ): void; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + function readdir( + path: PathLike, + callback: (err: SystemError | null, files: string[]) => void, + ): void; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options If called with `withFileTypes: true` the result data will be an array of Dirent. + */ + function readdir( + path: PathLike, + options: ObjectEncodingOptions & { + withFileTypes: true; + }, + callback: (err: SystemError | null, files: Dirent[]) => void, + ): void; + // namespace readdir { + // /** + // * Asynchronous readdir(3) - read a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: + // | { + // encoding: BufferEncoding | null; + // withFileTypes?: false | undefined; + // } + // | BufferEncoding + // | null + // ): Promise; + // /** + // * Asynchronous readdir(3) - read a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options: + // | "buffer" + // | { + // encoding: "buffer"; + // withFileTypes?: false | undefined; + // } + // ): Promise; + // /** + // * Asynchronous readdir(3) - read a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + // */ + // function __promisify__( + // path: PathLike, + // options?: + // | (ObjectEncodingOptions & { + // withFileTypes?: false | undefined; + // }) + // | BufferEncoding + // | null + // ): Promise; + // /** + // * Asynchronous readdir(3) - read a directory. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param options If called with `withFileTypes: true` the result data will be an array of Dirent + // */ + // function __promisify__( + // path: PathLike, + // options: ObjectEncodingOptions & { + // withFileTypes: true; + // } + // ): Promise; + // } + /** + * Reads the contents of the directory. + * + * See the POSIX [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) documentation for more details. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the filenames returned. If the `encoding` is set to `'buffer'`, + * the filenames returned will be passed as `Buffer` objects. + * + * If `options.withFileTypes` is set to `true`, the result will contain `fs.Dirent` objects. + * @since v0.0.67 + */ + function readdirSync( + path: PathLike, + options?: + | { + encoding: BufferEncoding | null; + withFileTypes?: false | undefined; + } + | BufferEncoding + | null, + ): string[]; + /** + * Synchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readdirSync( + path: PathLike, + options: + | { + encoding: "buffer"; + withFileTypes?: false | undefined; + } + | "buffer", + ): Buffer[]; + /** + * Synchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used. + */ + function readdirSync( + path: PathLike, + options?: + | (ObjectEncodingOptions & { + withFileTypes?: false | undefined; + }) + | BufferEncoding + | null, + ): string[] | Buffer[]; + /** + * Synchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options If called with `withFileTypes: true` the result data will be an array of Dirent. + */ + function readdirSync( + path: PathLike, + options: ObjectEncodingOptions & { + withFileTypes: true; + }, + ): Dirent[]; + /** + * Closes the file descriptor. No arguments other than a possible exception are + * given to the completion callback. + * + * Calling `fs.close()` on any file descriptor (`fd`) that is currently in use + * through any other `fs` operation may lead to undefined behavior. + * + * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail. + * @since v0.0.67 + */ + function close(fd: number, callback?: NoParamCallback): void; + // namespace close { + // /** + // * Asynchronous close(2) - close a file descriptor. + // * @param fd A file descriptor. + // */ + // function __promisify__(fd: number): Promise; + // } + /** + * Closes the file descriptor. Returns `undefined`. + * + * Calling `fs.closeSync()` on any file descriptor (`fd`) that is currently in use + * through any other `fs` operation may lead to undefined behavior. + * + * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail. + * @since v0.0.67 + */ + function closeSync(fd: number): void; + /** + * Asynchronous file open. See the POSIX [`open(2)`](http://man7.org/linux/man-pages/man2/open.2.html) documentation for more details. + * + * `mode` sets the file mode (permission and sticky bits), but only if the file was + * created. On Windows, only the write permission can be manipulated; see {@link chmod}. + * + * The callback gets two arguments `(err, fd)`. + * + * Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented + * by [Naming Files, Paths, and Namespaces](https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file). Under NTFS, if the filename contains + * a colon, Node.js will open a file system stream, as described by [this MSDN page](https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams). + * + * Functions based on `fs.open()` exhibit this behavior as well:`fs.writeFile()`, `fs.readFile()`, etc. + * @since v0.0.67 + * @param [flags='r'] See `support of file system `flags``. + * @param [mode=0o666] + */ + function open( + path: PathLike, + flags: OpenMode, + mode: Mode | undefined | null, + callback: (err: SystemError | null, fd: number) => void, + ): void; + /** + * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + */ + function open( + path: PathLike, + flags: OpenMode, + callback: (err: SystemError | null, fd: number) => void, + ): void; + // namespace open { + // /** + // * Asynchronous open(2) - open and possibly create a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param mode A file mode. If a string is passed, it is parsed as an octal integer. If not supplied, defaults to `0o666`. + // */ + // function __promisify__( + // path: PathLike, + // flags: OpenMode, + // mode?: Mode | null + // ): Promise; + // } + /** + * Returns an integer representing the file descriptor. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link open}. + * @since v0.0.67 + * @param [flags='r'] + * @param [mode=0o666] + */ + function openSync( + path: PathLike, + flags: OpenMode, + mode?: Mode | null, + ): number; + /** + * Change the file system timestamps of the object referenced by `path`. + * + * The `atime` and `mtime` arguments follow these rules: + * + * * Values can be either numbers representing Unix epoch time in seconds,`Date`s, or a numeric string like `'123456789.0'`. + * * If the value can not be converted to a number, or is `NaN`, `Infinity` or`-Infinity`, an `Error` will be thrown. + * @since v0.0.67 + */ + function utimes( + path: PathLike, + atime: TimeLike, + mtime: TimeLike, + callback: NoParamCallback, + ): void; + // namespace utimes { + // /** + // * Asynchronously change file timestamps of the file referenced by the supplied path. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * @param atime The last access time. If a string is provided, it will be coerced to number. + // * @param mtime The last modified time. If a string is provided, it will be coerced to number. + // */ + // function __promisify__( + // path: PathLike, + // atime: TimeLike, + // mtime: TimeLike + // ): Promise; + // } + /** + * Returns `undefined`. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link utimes}. + * @since v0.0.67 + */ + function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void; + /** + * Change the file system timestamps of the object referenced by the supplied file + * descriptor. See {@link utimes}. + * @since v0.0.67 + */ + function futimes( + fd: number, + atime: TimeLike, + mtime: TimeLike, + callback: NoParamCallback, + ): void; + // namespace futimes { + // /** + // * Asynchronously change file timestamps of the file referenced by the supplied file descriptor. + // * @param fd A file descriptor. + // * @param atime The last access time. If a string is provided, it will be coerced to number. + // * @param mtime The last modified time. If a string is provided, it will be coerced to number. + // */ + // function __promisify__( + // fd: number, + // atime: TimeLike, + // mtime: TimeLike + // ): Promise; + // } + /** + * Synchronous version of {@link futimes}. Returns `undefined`. + * @since v0.0.67 + */ + function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void; + /** + * Request that all data for the open file descriptor is flushed to the storage + * device. The specific implementation is operating system and device specific. + * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail. No arguments other + * than a possible exception are given to the completion callback. + * @since v0.0.67 + */ + function fsync(fd: number, callback: NoParamCallback): void; + // namespace fsync { + // /** + // * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device. + // * @param fd A file descriptor. + // */ + // function __promisify__(fd: number): Promise; + // } + /** + * Request that all data for the open file descriptor is flushed to the storage + * device. The specific implementation is operating system and device specific. + * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail. Returns `undefined`. + * @since v0.0.67 + */ + function fsyncSync(fd: number): void; + /** + * Write `buffer` to the file specified by `fd`. If `buffer` is a normal object, it + * must have an own `toString` function property. + * + * `offset` determines the part of the buffer to be written, and `length` is + * an integer specifying the number of bytes to write. + * + * `position` refers to the offset from the beginning of the file where this data + * should be written. If `typeof position !== 'number'`, the data will be written + * at the current position. See [`pwrite(2)`](http://man7.org/linux/man-pages/man2/pwrite.2.html). + * + * The callback will be given three arguments `(err, bytesWritten, buffer)` where`bytesWritten` specifies how many _bytes_ were written from `buffer`. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a promise for an `Object` with `bytesWritten` and `buffer` properties. + * + * It is unsafe to use `fs.write()` multiple times on the same file without waiting + * for the callback. + * + * On Linux, positional writes don't work when the file is opened in append mode. + * The kernel ignores the position argument and always appends the data to + * the end of the file. + * @since v0.0.67 + */ + function write( + fd: number, + buffer: TBuffer, + offset: number | undefined | null, + length: number | undefined | null, + position: number | undefined | null, + callback: ( + err: SystemError | null, + written: number, + buffer: TBuffer, + ) => void, + ): void; + /** + * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + * @param offset The part of the buffer to be written. If not supplied, defaults to `0`. + * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`. + */ + function write( + fd: number, + buffer: TBuffer, + offset: number | undefined | null, + length: number | undefined | null, + callback: ( + err: SystemError | null, + written: number, + buffer: TBuffer, + ) => void, + ): void; + /** + * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + * @param offset The part of the buffer to be written. If not supplied, defaults to `0`. + */ + function write( + fd: number, + buffer: TBuffer, + offset: number | undefined | null, + callback: ( + err: SystemError | null, + written: number, + buffer: TBuffer, + ) => void, + ): void; + /** + * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + */ + function write( + fd: number, + buffer: TBuffer, + callback: ( + err: SystemError | null, + written: number, + buffer: TBuffer, + ) => void, + ): void; + /** + * Asynchronously writes `string` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + * @param string A string to write. + * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position. + * @param encoding The expected string encoding. + */ + function write( + fd: number, + string: string, + position: number | undefined | null, + encoding: BufferEncoding | undefined | null, + callback: (err: SystemError | null, written: number, str: string) => void, + ): void; + /** + * Asynchronously writes `string` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + * @param string A string to write. + * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position. + */ + function write( + fd: number, + string: string, + position: number | undefined | null, + callback: (err: SystemError | null, written: number, str: string) => void, + ): void; + /** + * Asynchronously writes `string` to the file referenced by the supplied file descriptor. + * @param fd A file descriptor. + * @param string A string to write. + */ + function write( + fd: number, + string: string, + callback: (err: SystemError | null, written: number, str: string) => void, + ): void; + // namespace write { + // /** + // * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor. + // * @param fd A file descriptor. + // * @param offset The part of the buffer to be written. If not supplied, defaults to `0`. + // * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`. + // * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position. + // */ + // function __promisify__( + // fd: number, + // buffer?: TBuffer, + // offset?: number, + // length?: number, + // position?: number | null + // ): Promise<{ + // bytesWritten: number; + // buffer: TBuffer; + // }>; + // /** + // * Asynchronously writes `string` to the file referenced by the supplied file descriptor. + // * @param fd A file descriptor. + // * @param string A string to write. + // * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position. + // * @param encoding The expected string encoding. + // */ + // function __promisify__( + // fd: number, + // string: string, + // position?: number | null, + // encoding?: BufferEncoding | null + // ): Promise<{ + // bytesWritten: number; + // buffer: string; + // }>; + // } + /** + * If `buffer` is a plain object, it must have an own (not inherited) `toString`function property. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link write}. + * @since v0.0.67 + * @return The number of bytes written. + */ + function writeSync( + fd: number, + buffer: ArrayBufferView, + offset?: number | null, + length?: number | null, + position?: number | null, + ): number; + /** + * Synchronously writes `string` to the file referenced by the supplied file descriptor, returning the number of bytes written. + * @param fd A file descriptor. + * @param string A string to write. + * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position. + * @param encoding The expected string encoding. + */ + function writeSync( + fd: number, + string: string, + position?: number | null, + encoding?: BufferEncoding | null, + ): number; + type ReadPosition = number | bigint; + interface ReadSyncOptions { + /** + * @default 0 + */ + offset?: number | undefined; + /** + * @default `length of buffer` + */ + length?: number | undefined; + /** + * @default null + */ + position?: ReadPosition | null | undefined; + } + interface ReadAsyncOptions + extends ReadSyncOptions { + buffer?: TBuffer; + } + /** + * Read data from the file specified by `fd`. + * + * The callback is given the three arguments, `(err, bytesRead, buffer)`. + * + * If the file is not modified concurrently, the end-of-file is reached when the + * number of bytes read is zero. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a promise for an `Object` with `bytesRead` and `buffer` properties. + * @since v0.0.67 + * @param buffer The buffer that the data will be written to. + * @param offset The position in `buffer` to write the data to. + * @param length The number of bytes to read. + * @param position Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If + * `position` is an integer, the file position will be unchanged. + */ + function read( + fd: number, + buffer: TBuffer, + offset: number, + length: number, + position: ReadPosition | null, + callback: ( + err: SystemError | null, + bytesRead: number, + buffer: TBuffer, + ) => void, + ): void; + /** + * Similar to the above `fs.read` function, this version takes an optional `options` object. + * If not otherwise specified in an `options` object, + * `buffer` defaults to `Buffer.alloc(16384)`, + * `offset` defaults to `0`, + * `length` defaults to `buffer.byteLength`, `- offset` as of Node 17.6.0 + * `position` defaults to `null` + * @since v0.0.67 + */ + function read( + fd: number, + options: ReadAsyncOptions, + callback: ( + err: SystemError | null, + bytesRead: number, + buffer: TBuffer, + ) => void, + ): void; + function read( + fd: number, + callback: ( + err: SystemError | null, + bytesRead: number, + buffer: ArrayBufferView, + ) => void, + ): void; + // namespace read { + // /** + // * @param fd A file descriptor. + // * @param buffer The buffer that the data will be written to. + // * @param offset The offset in the buffer at which to start writing. + // * @param length The number of bytes to read. + // * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position. + // */ + // function __promisify__( + // fd: number, + // buffer: TBuffer, + // offset: number, + // length: number, + // position: number | null + // ): Promise<{ + // bytesRead: number; + // buffer: TBuffer; + // }>; + // function __promisify__( + // fd: number, + // options: ReadAsyncOptions + // ): Promise<{ + // bytesRead: number; + // buffer: TBuffer; + // }>; + // function __promisify__(fd: number): Promise<{ + // bytesRead: number; + // buffer: ArrayBufferView; + // }>; + // } + + // TODO: Add AbortSignal support + // tslint:disable-next-line:no-empty-interface + interface Abortable {} + + /** + * Returns the number of `bytesRead`. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link read}. + * @since v0.0.67 + */ + function readSync( + fd: number, + buffer: ArrayBufferView, + offset: number, + length: number, + position: ReadPosition | null, + ): number; + /** + * Similar to the above `fs.readSync` function, this version takes an optional `options` object. + * If no `options` object is specified, it will default with the above values. + */ + function readSync( + fd: number, + buffer: ArrayBufferView, + opts?: ReadSyncOptions, + ): number; + /** + * Asynchronously reads the entire contents of a file. + * + * ```js + * import { readFile } from 'fs'; + * + * readFile('/etc/passwd', (err, data) => { + * if (err) throw err; + * console.log(data); + * }); + * ``` + * + * The callback is passed two arguments `(err, data)`, where `data` is the + * contents of the file. + * + * If no encoding is specified, then the raw buffer is returned. + * + * If `options` is a string, then it specifies the encoding: + * + * ```js + * import { readFile } from 'fs'; + * + * readFile('/etc/passwd', 'utf8', callback); + * ``` + * + * When the path is a directory, the behavior of `fs.readFile()` and {@link readFileSync} is platform-specific. On macOS, Linux, and Windows, an + * error will be returned. On FreeBSD, a representation of the directory's contents + * will be returned. + * + * ```js + * import { readFile } from 'fs'; + * + * // macOS, Linux, and Windows + * readFile('', (err, data) => { + * // => [Error: EISDIR: illegal operation on a directory, read ] + * }); + * + * // FreeBSD + * readFile('', (err, data) => { + * // => null, + * }); + * ``` + * + * It is possible to abort an ongoing request using an `AbortSignal`. If a + * request is aborted the callback is called with an `AbortError`: + * + * ```js + * import { readFile } from 'fs'; + * + * const controller = new AbortController(); + * const signal = controller.signal; + * readFile(fileInfo[0].name, { signal }, (err, buf) => { + * // ... + * }); + * // When you want to abort the request + * controller.abort(); + * ``` + * + * The `fs.readFile()` function buffers the entire file. To minimize memory costs, + * when possible prefer streaming via `fs.createReadStream()`. + * + * Aborting an ongoing request does not abort individual operating + * system requests but rather the internal buffering `fs.readFile` performs. + * @since v0.0.67 + * @param path filename or file descriptor + */ + function readFile( + path: PathOrFileDescriptor, + options: + | ({ + encoding?: null | undefined; + flag?: string | undefined; + } & Abortable) + | undefined + | null, + callback: (err: SystemError | null, data: Buffer) => void, + ): void; + /** + * Asynchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + * If a flag is not provided, it defaults to `'r'`. + */ + function readFile( + path: PathOrFileDescriptor, + options: + | ({ + encoding: BufferEncoding; + flag?: string | undefined; + } & Abortable) + | BufferEncoding, + callback: (err: SystemError | null, data: string) => void, + ): void; + /** + * Asynchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + * If a flag is not provided, it defaults to `'r'`. + */ + function readFile( + path: PathOrFileDescriptor, + options: + | (ObjectEncodingOptions & { + flag?: string | undefined; + } & Abortable) + | BufferEncoding + | undefined + | null, + callback: (err: SystemError | null, data: string | Buffer) => void, + ): void; + /** + * Asynchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + */ + function readFile( + path: PathOrFileDescriptor, + callback: (err: SystemError | null, data: Buffer) => void, + ): void; + // namespace readFile { + // /** + // * Asynchronously reads the entire contents of a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + // * @param options An object that may contain an optional flag. + // * If a flag is not provided, it defaults to `'r'`. + // */ + // function __promisify__( + // path: PathOrFileDescriptor, + // options?: { + // encoding?: null | undefined; + // flag?: string | undefined; + // } | null + // ): Promise; + // /** + // * Asynchronously reads the entire contents of a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + // * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + // * If a flag is not provided, it defaults to `'r'`. + // */ + // function __promisify__( + // path: PathOrFileDescriptor, + // options: + // | { + // encoding: BufferEncoding; + // flag?: string | undefined; + // } + // | BufferEncoding + // ): Promise; + // /** + // * Asynchronously reads the entire contents of a file. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + // * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + // * If a flag is not provided, it defaults to `'r'`. + // */ + // function __promisify__( + // path: PathOrFileDescriptor, + // options?: + // | (ObjectEncodingOptions & { + // flag?: string | undefined; + // }) + // | BufferEncoding + // | null + // ): Promise; + // } + /** + * Returns the contents of the `path`. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link readFile}. + * + * If the `encoding` option is specified then this function returns a + * string. Otherwise it returns a buffer. + * + * Similar to {@link readFile}, when the path is a directory, the behavior of`fs.readFileSync()` is platform-specific. + * + * ```js + * import { readFileSync } from 'fs'; + * + * // macOS, Linux, and Windows + * readFileSync(''); + * // => [Error: EISDIR: illegal operation on a directory, read ] + * + * // FreeBSD + * readFileSync(''); // => + * ``` + * @since v0.0.67 + * @param path filename or file descriptor + */ + function readFileSync( + path: PathOrFileDescriptor, + options?: { + encoding?: null | undefined; + flag?: string | undefined; + } | null, + ): Buffer; + /** + * Synchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + * If a flag is not provided, it defaults to `'r'`. + */ + function readFileSync( + path: PathOrFileDescriptor, + options: + | { + encoding: BufferEncoding; + flag?: string | undefined; + } + | BufferEncoding, + ): string; + /** + * Synchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag. + * If a flag is not provided, it defaults to `'r'`. + */ + function readFileSync( + path: PathOrFileDescriptor, + options?: + | (ObjectEncodingOptions & { + flag?: string | undefined; + }) + | BufferEncoding + | null, + ): string | Buffer; + type WriteFileOptions = + | (ObjectEncodingOptions & + Abortable & { + mode?: Mode | undefined; + flag?: string | undefined; + }) + | BufferEncoding + | null; + /** + * When `file` is a filename, asynchronously writes data to the file, replacing the + * file if it already exists. `data` can be a string or a buffer. + * + * When `file` is a file descriptor, the behavior is similar to calling`fs.write()` directly (which is recommended). See the notes below on using + * a file descriptor. + * + * The `encoding` option is ignored if `data` is a buffer. + * + * The `mode` option only affects the newly created file. See {@link open} for more details. + * + * If `data` is a plain object, it must have an own (not inherited) `toString`function property. + * + * ```js + * import { writeFile } from 'fs'; + * import { Buffer } from 'buffer'; + * + * const data = new Uint8Array(Buffer.from('Hello Node.js')); + * writeFile('message.txt', data, (err) => { + * if (err) throw err; + * console.log('The file has been saved!'); + * }); + * ``` + * + * If `options` is a string, then it specifies the encoding: + * + * ```js + * import { writeFile } from 'fs'; + * + * writeFile('message.txt', 'Hello Node.js', 'utf8', callback); + * ``` + * + * It is unsafe to use `fs.writeFile()` multiple times on the same file without + * waiting for the callback. + * + * Similarly to `fs.readFile` \- `fs.writeFile` is a convenience method that + * performs multiple `write` calls internally to write the buffer passed to it. + * + * It is possible to use an `AbortSignal` to cancel an `fs.writeFile()`. + * Cancelation is "best effort", and some amount of data is likely still + * to be written. + * + * ```js + * import { writeFile } from 'fs'; + * import { Buffer } from 'buffer'; + * + * const controller = new AbortController(); + * const { signal } = controller; + * const data = new Uint8Array(Buffer.from('Hello Node.js')); + * writeFile('message.txt', data, { signal }, (err) => { + * // When a request is aborted - the callback is called with an AbortError + * }); + * // When the request should be aborted + * controller.abort(); + * ``` + * + * Aborting an ongoing request does not abort individual operating + * system requests but rather the internal buffering `fs.writeFile` performs. + * @since v0.0.67 + * @param file filename or file descriptor + */ + function writeFile( + file: PathOrFileDescriptor, + data: string | ArrayBufferView | ArrayBufferLike, + options: WriteFileOptions, + callback: NoParamCallback, + ): void; + /** + * Asynchronously writes data to a file, replacing the file if it already exists. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string. + */ + function writeFile( + path: PathOrFileDescriptor, + data: string | ArrayBufferView | ArrayBufferLike, + callback: NoParamCallback, + ): void; + // namespace writeFile { + // /** + // * Asynchronously writes data to a file, replacing the file if it already exists. + // * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + // * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string. + // * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag. + // * If `encoding` is not supplied, the default of `'utf8'` is used. + // * If `mode` is not supplied, the default of `0o666` is used. + // * If `mode` is a string, it is parsed as an octal integer. + // * If `flag` is not supplied, the default of `'w'` is used. + // */ + // function __promisify__( + // path: PathOrFileDescriptor, + // data: string | ArrayBufferView, + // options?: WriteFileOptions + // ): Promise; + // } + /** + * Returns `undefined`. + * + * If `data` is a plain object, it must have an own (not inherited) `toString`function property. + * + * The `mode` option only affects the newly created file. See {@link open} for more details. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link writeFile}. + * @since v0.0.67 + * @param file filename or file descriptor + */ + function writeFileSync( + file: PathOrFileDescriptor, + data: string | ArrayBufferView | ArrayBufferLike, + options?: WriteFileOptions, + ): void; + /** + * Asynchronously append data to a file, creating the file if it does not yet + * exist. `data` can be a string or a `Buffer`. + * + * The `mode` option only affects the newly created file. See {@link open} for more details. + * + * ```js + * import { appendFile } from 'fs'; + * + * appendFile('message.txt', 'data to append', (err) => { + * if (err) throw err; + * console.log('The "data to append" was appended to file!'); + * }); + * ``` + * + * If `options` is a string, then it specifies the encoding: + * + * ```js + * import { appendFile } from 'fs'; + * + * appendFile('message.txt', 'data to append', 'utf8', callback); + * ``` + * + * The `path` may be specified as a numeric file descriptor that has been opened + * for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will + * not be closed automatically. + * + * ```js + * import { open, close, appendFile } from 'fs'; + * + * function closeFd(fd) { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * + * open('message.txt', 'a', (err, fd) => { + * if (err) throw err; + * + * try { + * appendFile(fd, 'data to append', 'utf8', (err) => { + * closeFd(fd); + * if (err) throw err; + * }); + * } catch (err) { + * closeFd(fd); + * throw err; + * } + * }); + * ``` + * @since v0.0.67 + * @param path filename or file descriptor + */ + function appendFile( + path: PathOrFileDescriptor, + data: string | Uint8Array, + options: WriteFileOptions, + callback: NoParamCallback, + ): void; + /** + * Asynchronously append data to a file, creating the file if it does not exist. + * @param file A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string. + */ + function appendFile( + file: PathOrFileDescriptor, + data: string | Uint8Array, + callback: NoParamCallback, + ): void; + // namespace appendFile { + // /** + // * Asynchronously append data to a file, creating the file if it does not exist. + // * @param file A path to a file. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // * If a file descriptor is provided, the underlying file will _not_ be closed automatically. + // * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string. + // * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag. + // * If `encoding` is not supplied, the default of `'utf8'` is used. + // * If `mode` is not supplied, the default of `0o666` is used. + // * If `mode` is a string, it is parsed as an octal integer. + // * If `flag` is not supplied, the default of `'a'` is used. + // */ + // function __promisify__( + // file: PathOrFileDescriptor, + // data: string | Uint8Array, + // options?: WriteFileOptions + // ): Promise; + // } + /** + * Synchronously append data to a file, creating the file if it does not yet + * exist. `data` can be a string or a `Buffer`. + * + * The `mode` option only affects the newly created file. See {@link open} for more details. + * + * ```js + * import { appendFileSync } from 'fs'; + * + * try { + * appendFileSync('message.txt', 'data to append'); + * console.log('The "data to append" was appended to file!'); + * } catch (err) { + * // Handle the error + * } + * ``` + * + * If `options` is a string, then it specifies the encoding: + * + * ```js + * import { appendFileSync } from 'fs'; + * + * appendFileSync('message.txt', 'data to append', 'utf8'); + * ``` + * + * The `path` may be specified as a numeric file descriptor that has been opened + * for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will + * not be closed automatically. + * + * ```js + * import { openSync, closeSync, appendFileSync } from 'fs'; + * + * let fd; + * + * try { + * fd = openSync('message.txt', 'a'); + * appendFileSync(fd, 'data to append', 'utf8'); + * } catch (err) { + * // Handle the error + * } finally { + * if (fd !== undefined) + * closeSync(fd); + * } + * ``` + * @since v0.0.67 + * @param path filename or file descriptor + */ + function appendFileSync( + path: PathOrFileDescriptor, + data: string | Uint8Array, + options?: WriteFileOptions, + ): void; + + /** + * Test whether or not the given path exists by checking with the file system. + * Then call the `callback` argument with either true or false: + * + * ```js + * import { exists } from 'fs'; + * + * exists('/etc/passwd', (e) => { + * console.log(e ? 'it exists' : 'no passwd!'); + * }); + * ``` + * + * **The parameters for this callback are not consistent with other Node.js** + * **callbacks.** Normally, the first parameter to a Node.js callback is an `err`parameter, optionally followed by other parameters. The `fs.exists()` callback + * has only one boolean parameter. This is one reason `fs.access()` is recommended + * instead of `fs.exists()`. + * + * Using `fs.exists()` to check for the existence of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()` is not recommended. Doing + * so introduces a race condition, since other processes may change the file's + * state between the two calls. Instead, user code should open/read/write the + * file directly and handle the error raised if the file does not exist. + * + * **write (NOT RECOMMENDED)** + * + * ```js + * import { exists, open, close } from 'fs'; + * + * exists('myfile', (e) => { + * if (e) { + * console.error('myfile already exists'); + * } else { + * open('myfile', 'wx', (err, fd) => { + * if (err) throw err; + * + * try { + * writeMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * } + * }); + * ``` + * + * **write (RECOMMENDED)** + * + * ```js + * import { open, close } from 'fs'; + * open('myfile', 'wx', (err, fd) => { + * if (err) { + * if (err.code === 'EEXIST') { + * console.error('myfile already exists'); + * return; + * } + * + * throw err; + * } + * + * try { + * writeMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * ``` + * + * **read (NOT RECOMMENDED)** + * + * ```js + * import { open, close, exists } from 'fs'; + * + * exists('myfile', (e) => { + * if (e) { + * open('myfile', 'r', (err, fd) => { + * if (err) throw err; + * + * try { + * readMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * } else { + * console.error('myfile does not exist'); + * } + * }); + * ``` + * + * **read (RECOMMENDED)** + * + * ```js + * import { open, close } from 'fs'; + * + * open('myfile', 'r', (err, fd) => { + * if (err) { + * if (err.code === 'ENOENT') { + * console.error('myfile does not exist'); + * return; + * } + * + * throw err; + * } + * + * try { + * readMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * ``` + * + * The "not recommended" examples above check for existence and then use the + * file; the "recommended" examples are better because they use the file directly + * and handle the error, if any. + * + * In general, check for the existence of a file only if the file won’t be + * used directly, for example when its existence is a signal from another + * process. + * @since v0.0.67 + */ + function exists(path: PathLike, callback: (exists: boolean) => void): void; + /** + * Returns `true` if the path exists, `false` otherwise. + * + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link exists}. + * + * `fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`parameter to `fs.exists()` accepts parameters that are inconsistent with other + * Node.js callbacks. `fs.existsSync()` does not use a callback. + * + * ```js + * import { existsSync } from 'fs'; + * + * if (existsSync('/etc/passwd')) + * console.log('The path exists.'); + * ``` + * @since v0.0.67 + */ + function existsSync(path: PathLike): boolean; + namespace constants { + // File Access Constants + /** Constant for fs.access(). File is visible to the calling process. */ + var F_OK: number; + /** Constant for fs.access(). File can be read by the calling process. */ + var R_OK: number; + /** Constant for fs.access(). File can be written by the calling process. */ + var W_OK: number; + /** Constant for fs.access(). File can be executed by the calling process. */ + var X_OK: number; + // File Copy Constants + /** Constant for fs.copyFile. Flag indicating the destination file should not be overwritten if it already exists. */ + var COPYFILE_EXCL: number; + /** + * Constant for fs.copyFile. copy operation will attempt to create a copy-on-write reflink. + * If the underlying platform does not support copy-on-write, then a fallback copy mechanism is used. + */ + var COPYFILE_FICLONE: number; + /** + * Constant for fs.copyFile. Copy operation will attempt to create a copy-on-write reflink. + * If the underlying platform does not support copy-on-write, then the operation will fail with an error. + */ + var COPYFILE_FICLONE_FORCE: number; + // File Open Constants + /** Constant for fs.open(). Flag indicating to open a file for read-only access. */ + var O_RDONLY: number; + /** Constant for fs.open(). Flag indicating to open a file for write-only access. */ + var O_WRONLY: number; + /** Constant for fs.open(). Flag indicating to open a file for read-write access. */ + var O_RDWR: number; + /** Constant for fs.open(). Flag indicating to create the file if it does not already exist. */ + var O_CREAT: number; + /** Constant for fs.open(). Flag indicating that opening a file should fail if the O_CREAT flag is set and the file already exists. */ + var O_EXCL: number; + /** + * Constant for fs.open(). Flag indicating that if path identifies a terminal device, + * opening the path shall not cause that terminal to become the controlling terminal for the process + * (if the process does not already have one). + */ + var O_NOCTTY: number; + /** Constant for fs.open(). Flag indicating that if the file exists and is a regular file, and the file is opened successfully for write access, its length shall be truncated to zero. */ + var O_TRUNC: number; + /** Constant for fs.open(). Flag indicating that data will be appended to the end of the file. */ + var O_APPEND: number; + /** Constant for fs.open(). Flag indicating that the open should fail if the path is not a directory. */ + var O_DIRECTORY: number; + /** + * constant for fs.open(). + * Flag indicating reading accesses to the file system will no longer result in + * an update to the atime information associated with the file. + * This flag is available on Linux operating systems only. + */ + var O_NOATIME: number; + /** Constant for fs.open(). Flag indicating that the open should fail if the path is a symbolic link. */ + var O_NOFOLLOW: number; + /** Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O. */ + var O_SYNC: number; + /** Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O with write operations waiting for data integrity. */ + var O_DSYNC: number; + /** Constant for fs.open(). Flag indicating to open the symbolic link itself rather than the resource it is pointing to. */ + var O_SYMLINK: number; + /** Constant for fs.open(). When set, an attempt will be made to minimize caching effects of file I/O. */ + var O_DIRECT: number; + /** Constant for fs.open(). Flag indicating to open the file in nonblocking mode when possible. */ + var O_NONBLOCK: number; + // File Type Constants + /** Constant for fs.Stats mode property for determining a file's type. Bit mask used to extract the file type code. */ + var S_IFMT: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a regular file. */ + var S_IFREG: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a directory. */ + var S_IFDIR: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a character-oriented device file. */ + var S_IFCHR: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a block-oriented device file. */ + var S_IFBLK: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a FIFO/pipe. */ + var S_IFIFO: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a symbolic link. */ + var S_IFLNK: number; + /** Constant for fs.Stats mode property for determining a file's type. File type constant for a socket. */ + var S_IFSOCK: number; + // File Mode Constants + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by owner. */ + var S_IRWXU: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by owner. */ + var S_IRUSR: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by owner. */ + var S_IWUSR: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by owner. */ + var S_IXUSR: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by group. */ + var S_IRWXG: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by group. */ + var S_IRGRP: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by group. */ + var S_IWGRP: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by group. */ + var S_IXGRP: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by others. */ + var S_IRWXO: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by others. */ + var S_IROTH: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by others. */ + var S_IWOTH: number; + /** Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by others. */ + var S_IXOTH: number; + /** + * When set, a memory file mapping is used to access the file. This flag + * is available on Windows operating systems only. On other operating systems, + * this flag is ignored. + */ + var UV_FS_O_FILEMAP: number; + } + /** + * Tests a user's permissions for the file or directory specified by `path`. + * The `mode` argument is an optional integer that specifies the accessibility + * checks to be performed. Check `File access constants` for possible values + * of `mode`. It is possible to create a mask consisting of the bitwise OR of + * two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`). + * + * The final argument, `callback`, is a callback function that is invoked with + * a possible error argument. If any of the accessibility checks fail, the error + * argument will be an `Error` object. The following examples check if`package.json` exists, and if it is readable or writable. + * + * ```js + * import { access, constants } from 'fs'; + * + * const file = 'package.json'; + * + * // Check if the file exists in the current directory. + * access(file, constants.F_OK, (err) => { + * console.log(`${file} ${err ? 'does not exist' : 'exists'}`); + * }); + * + * // Check if the file is readable. + * access(file, constants.R_OK, (err) => { + * console.log(`${file} ${err ? 'is not readable' : 'is readable'}`); + * }); + * + * // Check if the file is writable. + * access(file, constants.W_OK, (err) => { + * console.log(`${file} ${err ? 'is not writable' : 'is writable'}`); + * }); + * + * // Check if the file exists in the current directory, and if it is writable. + * access(file, constants.F_OK | constants.W_OK, (err) => { + * if (err) { + * console.error( + * `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`); + * } else { + * console.log(`${file} exists, and it is writable`); + * } + * }); + * ``` + * + * Do not use `fs.access()` to check for the accessibility of a file before calling`fs.open()`, `fs.readFile()` or `fs.writeFile()`. Doing + * so introduces a race condition, since other processes may change the file's + * state between the two calls. Instead, user code should open/read/write the + * file directly and handle the error raised if the file is not accessible. + * + * **write (NOT RECOMMENDED)** + * + * ```js + * import { access, open, close } from 'fs'; + * + * access('myfile', (err) => { + * if (!err) { + * console.error('myfile already exists'); + * return; + * } + * + * open('myfile', 'wx', (err, fd) => { + * if (err) throw err; + * + * try { + * writeMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * }); + * ``` + * + * **write (RECOMMENDED)** + * + * ```js + * import { open, close } from 'fs'; + * + * open('myfile', 'wx', (err, fd) => { + * if (err) { + * if (err.code === 'EEXIST') { + * console.error('myfile already exists'); + * return; + * } + * + * throw err; + * } + * + * try { + * writeMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * ``` + * + * **read (NOT RECOMMENDED)** + * + * ```js + * import { access, open, close } from 'fs'; + * access('myfile', (err) => { + * if (err) { + * if (err.code === 'ENOENT') { + * console.error('myfile does not exist'); + * return; + * } + * + * throw err; + * } + * + * open('myfile', 'r', (err, fd) => { + * if (err) throw err; + * + * try { + * readMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * }); + * ``` + * + * **read (RECOMMENDED)** + * + * ```js + * import { open, close } from 'fs'; + * + * open('myfile', 'r', (err, fd) => { + * if (err) { + * if (err.code === 'ENOENT') { + * console.error('myfile does not exist'); + * return; + * } + * + * throw err; + * } + * + * try { + * readMyData(fd); + * } finally { + * close(fd, (err) => { + * if (err) throw err; + * }); + * } + * }); + * ``` + * + * The "not recommended" examples above check for accessibility and then use the + * file; the "recommended" examples are better because they use the file directly + * and handle the error, if any. + * + * In general, check for the accessibility of a file only if the file will not be + * used directly, for example when its accessibility is a signal from another + * process. + * + * On Windows, access-control policies (ACLs) on a directory may limit access to + * a file or directory. The `fs.access()` function, however, does not check the + * ACL and therefore may report that a path is accessible even if the ACL restricts + * the user from reading or writing to it. + * @since v0.0.67 + * @param [mode=fs.constants.F_OK] + */ + function access( + path: PathLike, + mode: number | undefined, + callback: NoParamCallback, + ): void; + /** + * Asynchronously tests a user's permissions for the file specified by path. + * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol. + */ + function access(path: PathLike, callback: NoParamCallback): void; + // namespace access { + // /** + // * Asynchronously tests a user's permissions for the file specified by path. + // * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol. + // * URL support is _experimental_. + // */ + // function __promisify__(path: PathLike, mode?: number): Promise; + // } + /** + * Synchronously tests a user's permissions for the file or directory specified + * by `path`. The `mode` argument is an optional integer that specifies the + * accessibility checks to be performed. Check `File access constants` for + * possible values of `mode`. It is possible to create a mask consisting of + * the bitwise OR of two or more values + * (e.g. `fs.constants.W_OK | fs.constants.R_OK`). + * + * If any of the accessibility checks fail, an `Error` will be thrown. Otherwise, + * the method will return `undefined`. + * + * ```js + * import { accessSync, constants } from 'fs'; + * + * try { + * accessSync('etc/passwd', constants.R_OK | constants.W_OK); + * console.log('can read/write'); + * } catch (err) { + * console.error('no access!'); + * } + * ``` + * @since v0.0.67 + * @param [mode=fs.constants.F_OK] + */ + function accessSync(path: PathLike, mode?: number): void; + + interface StreamOptions { + flags?: string | undefined; + encoding?: BufferEncoding | undefined; + fd?: number | undefined; // | promises.FileHandle; + mode?: number | undefined; + autoClose?: boolean | undefined; + /** + * @default false + */ + emitClose?: boolean | undefined; + start?: number | undefined; + highWaterMark?: number | undefined; + } + interface ReadStreamOptions extends StreamOptions { + end?: number | undefined; + } + /** + * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream + * returned by this method has a default `highWaterMark` of 64 kb. + * + * `options` can include `start` and `end` values to read a range of bytes from + * the file instead of the entire file. Both `start` and `end` are inclusive and + * start counting at 0, allowed values are in the + * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. If `fd` is specified and `start` is + * omitted or `undefined`, `fs.createReadStream()` reads sequentially from the + * current file position. The `encoding` can be any one of those accepted by `Buffer`. + * + * If `fd` is specified, `ReadStream` will ignore the `path` argument and will use + * the specified file descriptor. This means that no `'open'` event will be + * emitted. `fd` should be blocking; non-blocking `fd`s should be passed to `net.Socket`. + * + * If `fd` points to a character device that only supports blocking reads + * (such as keyboard or sound card), read operations do not finish until data is + * available. This can prevent the process from exiting and the stream from + * closing naturally. + * + * By default, the stream will emit a `'close'` event after it has been + * destroyed. Set the `emitClose` option to `false` to change this behavior. + * + * By providing the `fs` option, it is possible to override the corresponding `fs`implementations for `open`, `read`, and `close`. When providing the `fs` option, + * an override for `read` is required. If no `fd` is provided, an override for`open` is also required. If `autoClose` is `true`, an override for `close` is + * also required. + * + * ```js + * import { createReadStream } from 'fs'; + * + * // Create a stream from some character device. + * const stream = createReadStream('/dev/input/event0'); + * setTimeout(() => { + * stream.close(); // This may not close the stream. + * // Artificially marking end-of-stream, as if the underlying resource had + * // indicated end-of-file by itself, allows the stream to close. + * // This does not cancel pending read operations, and if there is such an + * // operation, the process may still not be able to exit successfully + * // until it finishes. + * stream.push(null); + * stream.read(0); + * }, 100); + * ``` + * + * If `autoClose` is false, then the file descriptor won't be closed, even if + * there's an error. It is the application's responsibility to close it and make + * sure there's no file descriptor leak. If `autoClose` is set to true (default + * behavior), on `'error'` or `'end'` the file descriptor will be closed + * automatically. + * + * `mode` sets the file mode (permission and sticky bits), but only if the + * file was created. + * + * An example to read the last 10 bytes of a file which is 100 bytes long: + * + * ```js + * import { createReadStream } from 'fs'; + * + * createReadStream('sample.txt', { start: 90, end: 99 }); + * ``` + * + * If `options` is a string, then it specifies the encoding. + * @since v0.1.31 + */ + export function createReadStream( + path: PathLike, + options?: BufferEncoding | ReadStreamOptions, + ): ReadStream; + /** + * `options` may also include a `start` option to allow writing data at some + * position past the beginning of the file, allowed values are in the + * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than + * replacing it may require the `flags` option to be set to `r+` rather than the + * default `w`. The `encoding` can be any one of those accepted by `Buffer`. + * + * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false, + * then the file descriptor won't be closed, even if there's an error. + * It is the application's responsibility to close it and make sure there's no + * file descriptor leak. + * + * By default, the stream will emit a `'close'` event after it has been + * destroyed. Set the `emitClose` option to `false` to change this behavior. + * + * By providing the `fs` option it is possible to override the corresponding `fs`implementations for `open`, `write`, `writev` and `close`. Overriding `write()`without `writev()` can reduce + * performance as some optimizations (`_writev()`) + * will be disabled. When providing the `fs` option, overrides for at least one of`write` and `writev` are required. If no `fd` option is supplied, an override + * for `open` is also required. If `autoClose` is `true`, an override for `close`is also required. + * + * Like `fs.ReadStream`, if `fd` is specified, `fs.WriteStream` will ignore the`path` argument and will use the specified file descriptor. This means that no`'open'` event will be + * emitted. `fd` should be blocking; non-blocking `fd`s + * should be passed to `net.Socket`. + * + * If `options` is a string, then it specifies the encoding. + * @since v0.1.31 + */ + export function createWriteStream( + path: PathLike, + options?: BufferEncoding | StreamOptions, + ): WriteStream; + + /** + * Forces all currently queued I/O operations associated with the file to the + * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. No arguments other + * than a possible + * exception are given to the completion callback. + * @since v0.0.67 + */ + /** + * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function. + * @since v0.1.93 + */ + export class ReadStream extends stream.Readable { + close(callback?: (err?: ErrnoException | null) => void): Promise; + /** + * The number of bytes that have been read so far. + * @since v6.4.0 + */ + bytesRead: number; + /** + * The path to the file the stream is reading from as specified in the first + * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a + * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`. + * @since v0.1.93 + */ + path: string | Buffer; + /** + * This property is `true` if the underlying file has not been opened yet, + * i.e. before the `'ready'` event is emitted. + * @since v11.2.0, v10.16.0 + */ + pending: boolean; + /** + * events.EventEmitter + * 1. open + * 2. close + * 3. ready + */ + addListener(event: "close", listener: () => void): this; + addListener( + event: "data", + listener: (chunk: Buffer | string) => void, + ): this; + addListener(event: "end", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "open", listener: (fd: number) => void): this; + addListener(event: "pause", listener: () => void): this; + addListener(event: "readable", listener: () => void): this; + addListener(event: "ready", listener: () => void): this; + addListener(event: "resume", listener: () => void): this; + addListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + on(event: "close", listener: () => void): this; + on(event: "data", listener: (chunk: Buffer | string) => void): this; + on(event: "end", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "open", listener: (fd: number) => void): this; + on(event: "pause", listener: () => void): this; + on(event: "readable", listener: () => void): this; + on(event: "ready", listener: () => void): this; + on(event: "resume", listener: () => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "data", listener: (chunk: Buffer | string) => void): this; + once(event: "end", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "open", listener: (fd: number) => void): this; + once(event: "pause", listener: () => void): this; + once(event: "readable", listener: () => void): this; + once(event: "ready", listener: () => void): this; + once(event: "resume", listener: () => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + // prependListener(event: 'close', listener: () => void): this; + // prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this; + // prependListener(event: 'end', listener: () => void): this; + // prependListener(event: 'error', listener: (err: Error) => void): this; + // prependListener(event: 'open', listener: (fd: number) => void): this; + // prependListener(event: 'pause', listener: () => void): this; + // prependListener(event: 'readable', listener: () => void): this; + // prependListener(event: 'ready', listener: () => void): this; + // prependListener(event: 'resume', listener: () => void): this; + // prependListener(event: string | symbol, listener: (...args: any[]) => void): this; + // prependOnceListener(event: 'close', listener: () => void): this; + // prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this; + // prependOnceListener(event: 'end', listener: () => void): this; + // prependOnceListener(event: 'error', listener: (err: Error) => void): this; + // prependOnceListener(event: 'open', listener: (fd: number) => void): this; + // prependOnceListener(event: 'pause', listener: () => void): this; + // prependOnceListener(event: 'readable', listener: () => void): this; + // prependOnceListener(event: 'ready', listener: () => void): this; + // prependOnceListener(event: 'resume', listener: () => void): this; + // prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; + } + /** + * * Extends `stream.Writable` + * + * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function. + * @since v0.1.93 + */ + export class WriteStream extends stream.Writable { + /** + * Closes `writeStream`. Optionally accepts a + * callback that will be executed once the `writeStream`is closed. + * @since v0.9.4 + */ + close(callback?: (err?: ErrnoException | null) => void): Promise; + /** + * The number of bytes written so far. Does not include data that is still queued + * for writing. + * @since v0.4.7 + */ + bytesWritten: number; + /** + * The path to the file the stream is writing to as specified in the first + * argument to {@link createWriteStream}. If `path` is passed as a string, then`writeStream.path` will be a string. If `path` is passed as a `Buffer`, then`writeStream.path` will be a + * `Buffer`. + * @since v0.1.93 + */ + path: string | Buffer; + /** + * This property is `true` if the underlying file has not been opened yet, + * i.e. before the `'ready'` event is emitted. + * @since v11.2.0 + */ + // pending: boolean; + /** + * events.EventEmitter + * 1. open + * 2. close + * 3. ready + */ + addListener(event: "close", listener: () => void): this; + addListener(event: "drain", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "finish", listener: () => void): this; + addListener(event: "open", listener: (fd: number) => void): this; + addListener(event: "pipe", listener: (src: stream.Readable) => void): this; + addListener(event: "ready", listener: () => void): this; + addListener( + event: "unpipe", + listener: (src: stream.Readable) => void, + ): this; + addListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + on(event: "close", listener: () => void): this; + on(event: "drain", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "finish", listener: () => void): this; + on(event: "open", listener: (fd: number) => void): this; + on(event: "pipe", listener: (src: stream.Readable) => void): this; + on(event: "ready", listener: () => void): this; + on(event: "unpipe", listener: (src: stream.Readable) => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "drain", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "finish", listener: () => void): this; + once(event: "open", listener: (fd: number) => void): this; + once(event: "pipe", listener: (src: stream.Readable) => void): this; + once(event: "ready", listener: () => void): this; + once(event: "unpipe", listener: (src: stream.Readable) => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + // prependListener(event: 'close', listener: () => void): this; + // prependListener(event: 'drain', listener: () => void): this; + // prependListener(event: 'error', listener: (err: Error) => void): this; + // prependListener(event: 'finish', listener: () => void): this; + // prependListener(event: 'open', listener: (fd: number) => void): this; + // prependListener(event: 'pipe', listener: (src: stream.Readable) => void): this; + // prependListener(event: 'ready', listener: () => void): this; + // prependListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; + // prependListener(event: string | symbol, listener: (...args: any[]) => void): this; + // prependOnceListener(event: 'close', listener: () => void): this; + // prependOnceListener(event: 'drain', listener: () => void): this; + // prependOnceListener(event: 'error', listener: (err: Error) => void): this; + // prependOnceListener(event: 'finish', listener: () => void): this; + // prependOnceListener(event: 'open', listener: (fd: number) => void): this; + // prependOnceListener(event: 'pipe', listener: (src: stream.Readable) => void): this; + // prependOnceListener(event: 'ready', listener: () => void): this; + // prependOnceListener(event: 'unpipe', listener: (src: stream.Readable) => void): this; + // prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; + } + function fdatasync(fd: number, callback: NoParamCallback): void; + // namespace fdatasync { + // /** + // * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device. + // * @param fd A file descriptor. + // */ + // function __promisify__(fd: number): Promise; + // } + /** + * Forces all currently queued I/O operations associated with the file to the + * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. Returns `undefined`. + * @since v0.0.67 + */ + function fdatasyncSync(fd: number): void; + /** + * Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it + * already exists. No arguments other than a possible exception are given to the + * callback function. Node.js makes no guarantees about the atomicity of the copy + * operation. If an error occurs after the destination file has been opened for + * writing, Node.js will attempt to remove the destination. + * + * `mode` is an optional integer that specifies the behavior + * of the copy operation. It is possible to create a mask consisting of the bitwise + * OR of two or more values (e.g.`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`). + * + * * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already + * exists. + * * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a + * copy-on-write reflink. If the platform does not support copy-on-write, then a + * fallback copy mechanism is used. + * * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to + * create a copy-on-write reflink. If the platform does not support + * copy-on-write, then the operation will fail. + * + * ```js + * import { copyFile, constants } from 'fs'; + * + * function callback(err) { + * if (err) throw err; + * console.log('source.txt was copied to destination.txt'); + * } + * + * // destination.txt will be created or overwritten by default. + * copyFile('source.txt', 'destination.txt', callback); + * + * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists. + * copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback); + * ``` + * @since v0.0.67 + * @param src source filename to copy + * @param dest destination filename of the copy operation + * @param [mode=0] modifiers for copy operation. + */ + function copyFile( + src: PathLike, + dest: PathLike, + callback: NoParamCallback, + ): void; + function copyFile( + src: PathLike, + dest: PathLike, + mode: number, + callback: NoParamCallback, + ): void; + // namespace copyFile { + // function __promisify__( + // src: PathLike, + // dst: PathLike, + // mode?: number + // ): Promise; + // } + /** + * Synchronously copies `src` to `dest`. By default, `dest` is overwritten if it + * already exists. Returns `undefined`. Node.js makes no guarantees about the + * atomicity of the copy operation. If an error occurs after the destination file + * has been opened for writing, Node.js will attempt to remove the destination. + * + * `mode` is an optional integer that specifies the behavior + * of the copy operation. It is possible to create a mask consisting of the bitwise + * OR of two or more values (e.g.`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`). + * + * * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already + * exists. + * * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a + * copy-on-write reflink. If the platform does not support copy-on-write, then a + * fallback copy mechanism is used. + * * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to + * create a copy-on-write reflink. If the platform does not support + * copy-on-write, then the operation will fail. + * + * ```js + * import { copyFileSync, constants } from 'fs'; + * + * // destination.txt will be created or overwritten by default. + * copyFileSync('source.txt', 'destination.txt'); + * console.log('source.txt was copied to destination.txt'); + * + * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists. + * copyFileSync('source.txt', 'destination.txt', constants.COPYFILE_EXCL); + * ``` + * @since v0.0.67 + * @param src source filename to copy + * @param dest destination filename of the copy operation + * @param [mode=0] modifiers for copy operation. + */ + function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void; + /** + * Write an array of `ArrayBufferView`s to the file specified by `fd` using`writev()`. + * + * `position` is the offset from the beginning of the file where this data + * should be written. If `typeof position !== 'number'`, the data will be written + * at the current position. + * + * The callback will be given three arguments: `err`, `bytesWritten`, and`buffers`. `bytesWritten` is how many bytes were written from `buffers`. + * + * If this method is `util.promisify()` ed, it returns a promise for an`Object` with `bytesWritten` and `buffers` properties. + * + * + * On Linux, positional writes don't work when the file is opened in append mode. + * The kernel ignores the position argument and always appends the data to + * the end of the file. + * @since v0.0.67 + */ + function writev( + fd: number, + buffers: ReadonlyArray, + cb: ( + err: SystemError | null, + bytesWritten: number, + buffers: ArrayBufferView[], + ) => void, + ): void; + function writev( + fd: number, + buffers: ReadonlyArray, + position: number, + cb: ( + err: SystemError | null, + bytesWritten: number, + buffers: ArrayBufferView[], + ) => void, + ): void; + interface WriteVResult { + bytesWritten: number; + buffers: ArrayBufferView[]; + } + // namespace writev { + // function __promisify__( + // fd: number, + // buffers: ReadonlyArray, + // position?: number + // ): Promise; + // } + /** + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link writev}. + * @since v0.0.67 + * @return The number of bytes written. + */ + function writevSync( + fd: number, + buffers: ReadonlyArray, + position?: number, + ): number; + /** + * Read from a file specified by `fd` and write to an array of `ArrayBufferView`s + * using `readv()`. + * + * `position` is the offset from the beginning of the file from where data + * should be read. If `typeof position !== 'number'`, the data will be read + * from the current position. + * + * The callback will be given three arguments: `err`, `bytesRead`, and`buffers`. `bytesRead` is how many bytes were read from the file. + * + * If this method is invoked as its `util.promisify()` ed version, it returns + * a promise for an `Object` with `bytesRead` and `buffers` properties. + * @since v0.0.67 + */ + function readv( + fd: number, + buffers: ReadonlyArray, + cb: ( + err: SystemError | null, + bytesRead: number, + buffers: ArrayBufferView[], + ) => void, + ): void; + function readv( + fd: number, + buffers: ReadonlyArray, + position: number, + cb: ( + err: SystemError | null, + bytesRead: number, + buffers: ArrayBufferView[], + ) => void, + ): void; + interface ReadVResult { + bytesRead: number; + buffers: ArrayBufferView[]; + } + // namespace readv { + // function __promisify__( + // fd: number, + // buffers: ReadonlyArray, + // position?: number + // ): Promise; + // } + /** + * For detailed information, see the documentation of the asynchronous version of + * this API: {@link readv}. + * @since v0.0.67 + * @return The number of bytes read. + */ + function readvSync( + fd: number, + buffers: ReadonlyArray, + position?: number, + ): number; + interface OpenDirOptions { + encoding?: BufferEncoding | undefined; + /** + * Number of directory entries that are buffered + * internally when reading from the directory. Higher values lead to better + * performance but higher memory usage. + * @default 32 + */ + bufferSize?: number | undefined; + } + + interface BigIntStats extends StatsBase { + atimeNs: bigint; + mtimeNs: bigint; + ctimeNs: bigint; + birthtimeNs: bigint; + } + interface BigIntOptions { + bigint: true; + } + interface StatOptions { + bigint?: boolean | undefined; + } + interface StatSyncOptions extends StatOptions { + throwIfNoEntry?: boolean | undefined; + } + interface CopyOptions { + /** + * Dereference symlinks + * @default false + */ + dereference?: boolean; + /** + * When `force` is `false`, and the destination + * exists, throw an error. + * @default false + */ + errorOnExist?: boolean; + /** + * function to filter copied files/directories. Return + * `true` to copy the item, `false` to ignore it. + */ + filter?(source: string, destination: string): boolean; + /** + * Overwrite existing file or directory. _The copy + * operation will ignore errors if you set this to false and the destination + * exists. Use the `errorOnExist` option to change this behavior. + * @default true + */ + force?: boolean; + /** + * When `true` timestamps from `src` will + * be preserved. + * @default false + */ + preserveTimestamps?: boolean; + /** + * Copy directories recursively. + * @default false + */ + recursive?: boolean; + } +} + +declare module "node:fs" { + import * as fs from "fs"; + export = fs; +} diff --git a/packages/bun-types/fs/promises.d.ts b/packages/bun-types/fs/promises.d.ts new file mode 100644 index 0000000000..3749ca058e --- /dev/null +++ b/packages/bun-types/fs/promises.d.ts @@ -0,0 +1,677 @@ +/** + * The `fs/promises` API provides asynchronous file system methods that return + * promises. + * + * The promise APIs use the underlying Bun threadpool to perform file + * system operations off the event loop thread. These operations are not + * synchronized or threadsafe. Care must be taken when performing multiple + * concurrent modifications on the same file or data corruption may occur. + */ +declare module "fs/promises" { + import { + Stats, + BigIntStats, + StatOptions, + MakeDirectoryOptions, + Dirent, + ObjectEncodingOptions, + OpenMode, + Mode, + // eslint-disable-next-line @typescript-eslint/no-unused-vars + CopyOptions, + EncodingOption, + WriteFileOptions, + SimlinkType, + Abortable, + } from "node:fs"; + + interface FlagAndOpenMode { + mode?: Mode | undefined; + flag?: OpenMode | undefined; + } + interface FileReadResult { + bytesRead: number; + buffer: T; + } + interface FileReadOptions { + /** + * @default `Buffer.alloc(0xffff)` + */ + buffer?: T; + /** + * @default 0 + */ + offset?: number | null; + /** + * @default `buffer.byteLength` + */ + length?: number | null; + position?: number | null; + } + /** + * Tests a user"s permissions for the file or directory specified by `path`. + * The `mode` argument is an optional integer that specifies the accessibility + * checks to be performed. `mode` should be either the value `fs.constants.F_OK`or a mask consisting of the bitwise OR of any of `fs.constants.R_OK`,`fs.constants.W_OK`, and `fs.constants.X_OK` + * (e.g.`fs.constants.W_OK | fs.constants.R_OK`). Check `File access constants` for + * possible values of `mode`. + * + * If the accessibility check is successful, the promise is resolved with no + * value. If any of the accessibility checks fail, the promise is rejected + * with an [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) object. The following example checks if the file`/etc/passwd` can be read and + * written by the current process. + * + * ```js + * import { access } from "fs/promises"; + * import { constants } from "fs"; + * + * try { + * await access("/etc/passwd", constants.R_OK | constants.W_OK); + * console.log("can access"); + * } catch { + * console.error("cannot access"); + * } + * ``` + * + * Using `fsPromises.access()` to check for the accessibility of a file before + * calling `fsPromises.open()` is not recommended. Doing so introduces a race + * condition, since other processes may change the file"s state between the two + * calls. Instead, user code should open/read/write the file directly and handle + * the error raised if the file is not accessible. + * @since v0.0.67 + * @param [mode=fs.constants.F_OK] + * @return Fulfills with `undefined` upon success. + */ + function access(path: PathLike, mode?: number): Promise; + /** + * Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it + * already exists. + * + * No guarantees are made about the atomicity of the copy operation. If an + * error occurs after the destination file has been opened for writing, an attempt + * will be made to remove the destination. + * + * ```js + * import { constants } from "fs"; + * import { copyFile } from "fs/promises"; + * + * try { + * await copyFile("source.txt", "destination.txt"); + * console.log("source.txt was copied to destination.txt"); + * } catch { + * console.log("The file could not be copied"); + * } + * + * // By using COPYFILE_EXCL, the operation will fail if destination.txt exists. + * try { + * await copyFile("source.txt", "destination.txt", constants.COPYFILE_EXCL); + * console.log("source.txt was copied to destination.txt"); + * } catch { + * console.log("The file could not be copied"); + * } + * ``` + * @since v0.0.67 + * @param src source filename to copy + * @param dest destination filename of the copy operation + * @param [mode=0] Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. + * `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`) + * @return Fulfills with `undefined` upon success. + */ + function copyFile( + src: PathLike, + dest: PathLike, + mode?: number, + ): Promise; + /** + * Opens a `FileHandle`. + * + * Refer to the POSIX [`open(2)`](http://man7.org/linux/man-pages/man2/open.2.html) documentation for more detail. + * + * Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented + * by [Naming Files, Paths, and Namespaces](https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file). Under NTFS, if the filename contains + * a colon, Node.js will open a file system stream, as described by [this MSDN page](https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams). + * @since v0.0.67 + * @param [flags="r"] See `support of file system `flags``. + * @param [mode=0o666] Sets the file mode (permission and sticky bits) if the file is created. + * @return Fulfills with a {FileHandle} object. + */ + function open(path: PathLike, flags?: OpenMode, mode?: Mode): Promise; + /** + * Renames `oldPath` to `newPath`. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function rename(oldPath: PathLike, newPath: PathLike): Promise; + /** + * Truncates (shortens or extends the length) of the content at `path` to `len`bytes. + * @since v0.0.67 + * @param [len=0] + * @return Fulfills with `undefined` upon success. + */ + function truncate(path: PathLike, len?: number): Promise; + /** + * Asynchronously creates a directory. + * + * The optional `options` argument can be an integer specifying `mode` (permission + * and sticky bits), or an object with a `mode` property and a `recursive`property indicating whether parent directories should be created. Calling`fsPromises.mkdir()` when `path` is a directory + * that exists results in a + * rejection only when `recursive` is false. + * @since v0.0.67 + * @return Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`. + */ + function mkdir( + path: PathLike, + options: MakeDirectoryOptions & { + recursive: true; + }, + ): Promise; + /** + * Asynchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdir( + path: PathLike, + options?: + | Mode + | (MakeDirectoryOptions & { + recursive?: false | undefined; + }) + | null, + ): Promise; + /** + * Asynchronous mkdir(2) - create a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders + * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`. + */ + function mkdir( + path: PathLike, + options?: Mode | MakeDirectoryOptions | null | undefined, + ): Promise; + /** + * Reads the contents of a directory. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the filenames. If the `encoding` is set to `"buffer"`, the filenames returned + * will be passed as `Buffer` objects. + * + * If `options.withFileTypes` is set to `true`, the resolved array will contain `fs.Dirent` objects. + * + * ```js + * import { readdir } from "fs/promises"; + * + * try { + * const files = await readdir(path); + * for (const file of files) + * console.log(file); + * } catch (err) { + * console.error(err); + * } + * ``` + * @since v0.0.67 + * @return Fulfills with an array of the names of the files in the directory excluding `"."` and `".."`. + */ + function readdir( + path: PathLike, + options?: + | (ObjectEncodingOptions & { + withFileTypes?: false | undefined; + }) + | BufferEncoding + | undefined + | null, + ): Promise; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function readdir( + path: PathLike, + options: + | { + encoding: "buffer"; + withFileTypes?: false | undefined; + } + | "buffer", + ): Promise; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function readdir( + path: PathLike, + options?: + | (ObjectEncodingOptions & { + withFileTypes?: false | undefined; + }) + | BufferEncoding + | null, + ): Promise; + /** + * Asynchronous readdir(3) - read a directory. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options If called with `withFileTypes: true` the result data will be an array of Dirent. + */ + function readdir( + path: PathLike, + options: ObjectEncodingOptions & { + withFileTypes: true; + }, + ): Promise; + /** + * Reads the contents of the symbolic link referred to by `path`. See the POSIX [`readlink(2)`](http://man7.org/linux/man-pages/man2/readlink.2.html) documentation for more detail. The promise is + * resolved with the`linkString` upon success. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the link path returned. If the `encoding` is set to `"buffer"`, the link path + * returned will be passed as a `Buffer` object. + * @since v0.0.67 + * @return Fulfills with the `linkString` upon success. + */ + function readlink( + path: PathLike, + options?: EncodingOption | BufferEncoding | null, + ): Promise; + /** + * Asynchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function readlink( + path: PathLike, + options: BufferEncodingOption, + ): Promise; + /** + * Asynchronous readlink(2) - read value of a symbolic link. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function readlink( + path: PathLike, + options?: EncodingOption | string | null, + ): Promise; + /** + * Creates a symbolic link. + * + * The `type` argument is only used on Windows platforms and can be one of `"dir"`,`"file"`, or `"junction"`. Windows junction points require the destination path + * to be absolute. When using `"junction"`, the `target` argument will + * automatically be normalized to absolute path. + * @since v0.0.67 + * @param [type="file"] + * @return Fulfills with `undefined` upon success. + */ + function symlink( + target: PathLike, + path: PathLike, + type?: SimlinkType, + ): Promise; + /** + * Equivalent to `fsPromises.stat()` unless `path` refers to a symbolic link, + * in which case the link itself is stat-ed, not the file that it refers to. + * Refer to the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) document for more detail. + * @since v0.0.67 + * @return Fulfills with the {fs.Stats} object for the given symbolic link `path`. + */ + function lstat( + path: PathLike, + options?: + | (StatOptions & { + bigint?: false | undefined; + }) + | undefined, + ): Promise; + function lstat( + path: PathLike, + options: StatOptions & { + bigint: true; + }, + ): Promise; + function lstat( + path: PathLike, + options?: StatOptions, + ): Promise; + /** + * @since v0.0.67 + * @return Fulfills with the {fs.Stats} object for the given `path`. + */ + function stat( + path: PathLike, + options?: + | (StatOptions & { + bigint?: false | undefined; + }) + | undefined, + ): Promise; + function stat( + path: PathLike, + options: StatOptions & { + bigint: true; + }, + ): Promise; + function stat( + path: PathLike, + options?: StatOptions, + ): Promise; + /** + * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function link(existingPath: PathLike, newPath: PathLike): Promise; + /** + * If `path` refers to a symbolic link, then the link is removed without affecting + * the file or directory to which that link refers. If the `path` refers to a file + * path that is not a symbolic link, the file is deleted. See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more detail. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function unlink(path: PathLike): Promise; + /** + * Changes the permissions of a file. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function chmod(path: PathLike, mode: Mode): Promise; + /** + * Changes the permissions on a symbolic link. + * + * This method is only implemented on macOS. + * @deprecated Since v0.4.7 + * @return Fulfills with `undefined` upon success. + */ + function lchmod(path: PathLike, mode: Mode): Promise; + /** + * Changes the ownership on a symbolic link. + * @return Fulfills with `undefined` upon success. + */ + function lchown(path: PathLike, uid: number, gid: number): Promise; + /** + * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`, with the difference that if the path refers to a + * symbolic link, then the link is not dereferenced: instead, the timestamps of + * the symbolic link itself are changed. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function lutimes( + path: PathLike, + atime: TimeLike, + mtime: TimeLike, + ): Promise; + /** + * Changes the ownership of a file. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function chown(path: PathLike, uid: number, gid: number): Promise; + /** + * Change the file system timestamps of the object referenced by `path`. + * + * The `atime` and `mtime` arguments follow these rules: + * + * * Values can be either numbers representing Unix epoch time, `Date`s, or a + * numeric string like `"123456789.0"`. + * * If the value can not be converted to a number, or is `NaN`, `Infinity` or`-Infinity`, an `Error` will be thrown. + * @since v0.0.67 + * @return Fulfills with `undefined` upon success. + */ + function utimes( + path: PathLike, + atime: TimeLike, + mtime: TimeLike, + ): Promise; + /** + * Determines the actual location of `path` using the same semantics as the`fs.realpath.native()` function. + * + * Only paths that can be converted to UTF8 strings are supported. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use for + * the path. If the `encoding` is set to `"buffer"`, the path returned will be + * passed as a `Buffer` object. + * + * On Linux, when Node.js is linked against musl libc, the procfs file system must + * be mounted on `/proc` in order for this function to work. Glibc does not have + * this restriction. + * @since v0.0.67 + * @return Fulfills with the resolved path upon success. + */ + function realpath( + path: PathLike, + options?: EncodingOption | null, + ): Promise; + /** + * Asynchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function realpath( + path: PathLike, + options: BufferEncodingOption, + ): Promise; + /** + * Asynchronous realpath(3) - return the canonicalized absolute pathname. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function realpath( + path: PathLike, + options?: EncodingOption | null, + ): Promise; + /** + * Creates a unique temporary directory. A unique directory name is generated by + * appending six random characters to the end of the provided `prefix`. Due to + * platform inconsistencies, avoid trailing `X` characters in `prefix`. Some + * platforms, notably the BSDs, can return more than six random characters, and + * replace trailing `X` characters in `prefix` with random characters. + * + * The optional `options` argument can be a string specifying an encoding, or an + * object with an `encoding` property specifying the character encoding to use. + * + * ```js + * import { mkdtemp } from "fs/promises"; + * + * try { + * await mkdtemp(path.join(os.tmpdir(), "foo-")); + * } catch (err) { + * console.error(err); + * } + * ``` + * + * The `fsPromises.mkdtemp()` method will append the six randomly selected + * characters directly to the `prefix` string. For instance, given a directory`/tmp`, if the intention is to create a temporary directory _within_`/tmp`, the`prefix` must end with a trailing + * platform-specific path separator + * (`require("path").sep`). + * @since v0.0.67 + * @return Fulfills with a string containing the filesystem path of the newly created temporary directory. + */ + function mkdtemp( + prefix: string, + options?: EncodingOption | null, + ): Promise; + /** + * Asynchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required `prefix` to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function mkdtemp( + prefix: string, + options: BufferEncodingOption, + ): Promise; + /** + * Asynchronously creates a unique temporary directory. + * Generates six random characters to be appended behind a required `prefix` to create a unique temporary directory. + * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `"utf8"` is used. + */ + function mkdtemp( + prefix: string, + options?: EncodingOption | null, + ): Promise; + /** + * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an + * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or + * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object. + * + * The `encoding` option is ignored if `data` is a buffer. + * + * If `options` is a string, then it specifies the encoding. + * + * The `mode` option only affects the newly created file. See `fs.open()` for more details. + * + * Any specified `FileHandle` has to support writing. + * + * It is unsafe to use `fsPromises.writeFile()` multiple times on the same file + * without waiting for the promise to be settled. + * + * Similarly to `fsPromises.readFile` \- `fsPromises.writeFile` is a convenience + * method that performs multiple `write` calls internally to write the buffer + * passed to it. For performance sensitive code consider using `fs.createWriteStream()` or `filehandle.createWriteStream()`. + * + * It is possible to use an `AbortSignal` to cancel an `fsPromises.writeFile()`. + * Cancelation is "best effort", and some amount of data is likely still + * to be written. + * + * ```js + * import { writeFile } from "fs/promises"; + * import { Buffer } from "buffer"; + * + * try { + * const controller = new AbortController(); + * const { signal } = controller; + * const data = new Uint8Array(Buffer.from("Hello Node.js")); + * const promise = writeFile("message.txt", data, { signal }); + * + * // Abort the request before the promise settles. + * controller.abort(); + * + * await promise; + * } catch (err) { + * // When a request is aborted - err is an AbortError + * console.error(err); + * } + * ``` + * + * Aborting an ongoing request does not abort individual operating + * system requests but rather the internal buffering `fs.writeFile` performs. + * @since v0.0.67 + * @param file filename or `FileHandle` + * @return Fulfills with `undefined` upon success. + */ + function writeFile( + file: PathOrFileDescriptor, + data: string | ArrayBufferView | ArrayBufferLike, + options?: WriteFileOptions, + ): Promise; + /** + * Asynchronously append data to a file, creating the file if it does not yet + * exist. `data` can be a string or a `Buffer`. + * + * If `options` is a string, then it specifies the `encoding`. + * + * The `mode` option only affects the newly created file. See `fs.open()` for more details. + * + * The `path` may be specified as a `FileHandle` that has been opened + * for appending (using `fsPromises.open()`). + * @since v0.0.67 + * @param path filename or {FileHandle} + * @return Fulfills with `undefined` upon success. + */ + function appendFile( + path: PathOrFileDescriptor, + data: string | Uint8Array, + options?: WriteFileOptions, + ): Promise; + /** + * Asynchronously reads the entire contents of a file. + * + * If no encoding is specified (using `options.encoding`), the data is returned + * as a `Buffer` object. Otherwise, the data will be a string. + * + * If `options` is a string, then it specifies the encoding. + * + * When the `path` is a directory, the behavior of `fsPromises.readFile()` is + * platform-specific. On macOS, Linux, and Windows, the promise will be rejected + * with an error. On FreeBSD, a representation of the directory"s contents will be + * returned. + * + * It is possible to abort an ongoing `readFile` using an `AbortSignal`. If a + * request is aborted the promise returned is rejected with an `AbortError`: + * + * ```js + * import { readFile } from "fs/promises"; + * + * try { + * const controller = new AbortController(); + * const { signal } = controller; + * const promise = readFile(fileName, { signal }); + * + * // Abort the request before the promise settles. + * controller.abort(); + * + * await promise; + * } catch (err) { + * // When a request is aborted - err is an AbortError + * console.error(err); + * } + * ``` + * + * Aborting an ongoing request does not abort individual operating + * system requests but rather the internal buffering `fs.readFile` performs. + * + * Any specified `FileHandle` has to support reading. + * @since v0.0.67 + * @param path filename or `FileHandle` + * @return Fulfills with the contents of the file. + */ + function readFile( + path: PathOrFileDescriptor, + options?: + | ({ + encoding?: null | undefined; + flag?: string | undefined; + } & Abortable) + | null, + ): Promise; + /** + * Asynchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically. + * @param options An object that may contain an optional flag. + * If a flag is not provided, it defaults to `"r"`. + */ + function readFile( + path: PathOrFileDescriptor, + options: + | ({ + encoding: BufferEncoding; + flag?: OpenMode | undefined; + } & Abortable) + | BufferEncoding, + ): Promise; + /** + * Asynchronously reads the entire contents of a file. + * @param path A path to a file. If a URL is provided, it must use the `file:` protocol. + * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically. + * @param options An object that may contain an optional flag. + * If a flag is not provided, it defaults to `"r"`. + */ + function readFile( + path: PathOrFileDescriptor, + options?: + | (ObjectEncodingOptions & + Abortable & { + flag?: OpenMode | undefined; + }) + | BufferEncoding + | null, + ): Promise; +} + +declare module "node:fs/promises" { + import * as fsPromises from "fs/promises"; + export = fsPromises; +} diff --git a/packages/bun-types/globals.d.ts b/packages/bun-types/globals.d.ts new file mode 100644 index 0000000000..1c6474297a --- /dev/null +++ b/packages/bun-types/globals.d.ts @@ -0,0 +1,2562 @@ +type BinaryType = "arraybuffer" | "blob"; +type Transferable = ArrayBuffer; +type MessageEventSource = undefined; +type Encoding = "utf-8" | "windows-1252" | "utf-16"; +type Platform = + | "aix" + | "android" + | "darwin" + | "freebsd" + | "haiku" + | "linux" + | "openbsd" + | "sunos" + | "win32" + | "cygwin" + | "netbsd"; +type Architecture = + | "arm" + | "arm64" + | "ia32" + | "mips" + | "mipsel" + | "ppc" + | "ppc64" + | "s390" + | "s390x" + | "x64"; +type Signals = + | "SIGABRT" + | "SIGALRM" + | "SIGBUS" + | "SIGCHLD" + | "SIGCONT" + | "SIGFPE" + | "SIGHUP" + | "SIGILL" + | "SIGINT" + | "SIGIO" + | "SIGIOT" + | "SIGKILL" + | "SIGPIPE" + | "SIGPOLL" + | "SIGPROF" + | "SIGPWR" + | "SIGQUIT" + | "SIGSEGV" + | "SIGSTKFLT" + | "SIGSTOP" + | "SIGSYS" + | "SIGTERM" + | "SIGTRAP" + | "SIGTSTP" + | "SIGTTIN" + | "SIGTTOU" + | "SIGUNUSED" + | "SIGURG" + | "SIGUSR1" + | "SIGUSR2" + | "SIGVTALRM" + | "SIGWINCH" + | "SIGXCPU" + | "SIGXFSZ" + | "SIGBREAK" + | "SIGLOST" + | "SIGINFO"; + +interface console { + assert(condition?: boolean, ...data: any[]): void; + clear(): void; + /** + * Increment a [count](https://www.youtube.com/watch?v=2AoxCkySv34&t=22s) + * @param label label counter + */ + count(label?: string): void; + countReset(label?: string): void; + debug(...data: any[]): void; + dir(item?: any, options?: any): void; + dirxml(...data: any[]): void; + /** + * Log to stderr in your terminal + * + * Appears in red + * + * @param data something to display + */ + error(...data: any[]): void; + /** Does nothing currently */ + group(...data: any[]): void; + /** Does nothing currently */ + groupCollapsed(...data: any[]): void; + /** Does nothing currently */ + groupEnd(): void; + info(...data: any[]): void; + log(...data: any[]): void; + /** Does nothing currently */ + table(tabularData?: any, properties?: string[]): void; + /** + * Begin a timer to log with {@link console.timeEnd} + * + * @param label - The label to use for the timer + * + * ```ts + * console.time("how long????"); + * for (let i = 0; i < 999999; i++) { + * // do stuff + * let x = i * i; + * } + * console.timeEnd("how long????"); + * ``` + */ + time(label?: string): void; + /** + * End a timer to log with {@link console.time} + * + * @param label - The label to use for the timer + * + * ```ts + * console.time("how long????"); + * for (let i = 0; i < 999999; i++) { + * // do stuff + * let x = i * i; + * } + * console.timeEnd("how long????"); + * ``` + */ + timeEnd(label?: string): void; + timeLog(label?: string, ...data: any[]): void; + timeStamp(label?: string): void; + trace(...data: any[]): void; + warn(...data: any[]): void; +} + +declare var console: console; + +declare namespace NodeJS { + interface RequireResolve { + (id: string, options?: { paths?: string[] | undefined }): string; + paths(request: string): string[] | null; + } + + interface Require { + (id: string): any; + resolve: RequireResolve; + } +} + +interface ImportMeta { + /** + * `file://` url string for the current module. + * + * @example + * ```ts + * console.log(import.meta.url); + * "file:///Users/me/projects/my-app/src/my-app.ts" + * ``` + */ + url: string; + /** + * Absolute path to the source file + */ + path: string; + /** + * Absolute path to the directory containing the source file. + * + * Does not have a trailing slash + */ + dir: string; + /** + * Filename of the source file + */ + file: string; + /** + * Resolve a module ID the same as if you imported it + * + * On failure, throws a `ResolveError` + */ + resolve(moduleId: string): Promise; + /** + * Resolve a `moduleId` as though it were imported from `parent` + * + * On failure, throws a `ResolveError` + */ + // tslint:disable-next-line:unified-signatures + resolve(moduleId: string, parent: string): Promise; + + /** + * Resolve a module ID the same as if you imported it + * + * The `parent` argument is optional, and defaults to the current module's path. + */ + resolveSync(moduleId: string, parent?: string): string; + + /** + * Resolve a module ID the same as if you imported it + * + * The `parent` argument is optional, and defaults to the current module's path. + */ + require: NodeJS.Require; +} + +/** + * NodeJS-style `require` function + * + * Internally, uses `import.meta.require` + * + * @param moduleId - The module ID to resolve + */ +declare var require: NodeJS.Require; + +/** @deprecated Please use `import.meta.path` instead. */ +declare var __filename: string; + +/** @deprecated Please use `import.meta.dir` instead. */ +declare var __dirname: string; + +interface StructuredSerializeOptions { + transfer?: Transferable[]; +} + +interface EncodeIntoResult { + /** + * The read Unicode code units of input. + */ + read: number; + /** + * The written UTF-8 bytes of output. + */ + written: number; +} + +interface Process { + /** + * The current version of Bun + */ + version: string; + /** + * Run a function on the next tick of the event loop + * + * This is the same as {@link queueMicrotask} + * + * @param callback - The function to run + */ + nextTick(callback: (...args: any) => any, ...args: any): void; + title: string; + exitCode: number; + browser: boolean; + versions: Record; + ppid: number; + hrtime: { + (time?: [number, number]): [number, number]; + bigint(): bigint; + }; + pid: number; + arch: Architecture; + platform: Platform; + argv: string[]; + // execArgv: string[]; + env: Record & { + NODE_ENV: string; + }; + + /** Whether you are using Bun */ + isBun: 1; // FIXME: this should actually return a boolean + /** The current git sha of Bun **/ + revision: string; + // execPath: string; + // abort(): void; + chdir(directory: string): void; + cwd(): string; + exit(code?: number): void; + getgid(): number; + setgid(id: number | string): void; + getuid(): number; + setuid(id: number | string): void; + dlopen(module: { exports: any }, filename: string, flags?: number): void; +} + +declare var process: Process; + +declare module "process" { + var process: Process; + export = process; +} +declare module "node:process" { + import process = require("process"); + export = process; +} + +interface BlobInterface { + text(): Promise; + arrayBuffer(): Promise; + json(): Promise; +} + +type BlobPart = string | Blob | BufferSource | ArrayBuffer; +interface BlobPropertyBag { + /** Set a default "type" */ + type?: string; + + /** Not implemented in Bun yet. */ + endings?: "transparent" | "native"; +} + +/** + * This Fetch API interface allows you to perform various actions on HTTP + * request and response headers. These actions include retrieving, setting, + * adding to, and removing. A Headers object has an associated header list, + * which is initially empty and consists of zero or more name and value + * pairs. + * + * You can add to this using methods like append() + * + * In all methods of this interface, header names are matched by + * case-insensitive byte sequence. + */ +interface Headers { + append(name: string, value: string): void; + delete(name: string): void; + get(name: string): string | null; + has(name: string): boolean; + set(name: string, value: string): void; + entries(): IterableIterator<[string, string]>; + keys(): IterableIterator; + values(): IterableIterator; + forEach( + callbackfn: (value: string, key: string, parent: Headers) => void, + thisArg?: any, + ): void; +} + +declare var Headers: { + prototype: Headers; + new (init?: HeadersInit): Headers; +}; + +type HeadersInit = Array<[string, string]> | Record | Headers; +type ResponseType = + | "basic" + | "cors" + | "default" + | "error" + | "opaque" + | "opaqueredirect"; + +declare class Blob implements BlobInterface { + /** + * Create a new [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) + * + * @param `parts` - An array of strings, numbers, BufferSource, or [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects + * @param `options` - An object containing properties to be added to the [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) + */ + constructor(parts?: BlobPart[] | Blob, options?: BlobPropertyBag); + /** + * Create a new view **without 🚫 copying** the underlying data. + * + * Similar to [`BufferSource.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BufferSource/subarray) + * + * @param begin The index that sets the beginning of the view. + * @param end The index that sets the end of the view. + * + */ + slice(begin?: number, end?: number): Blob; + + /** + * Read the data from the blob as a string. It will be decoded from UTF-8. + */ + text(): Promise; + + /** + * Read the data from the blob as a ReadableStream. + */ + stream(): ReadableStream; + + /** + * Read the data from the blob as an ArrayBuffer. + * + * This copies the data into a new ArrayBuffer. + */ + arrayBuffer(): Promise; + + /** + * Read the data from the blob as a JSON object. + * + * This first decodes the data from UTF-8, then parses it as JSON. + * + */ + json(): Promise; + + type: string; + size: number; +} + +interface ResponseInit { + headers?: HeadersInit; + /** @default 200 */ + status?: number; + + /** @default "OK" */ + statusText?: string; +} + +/** + * Represents an HTTP [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) + * + * Use it to get the body of the response, the status code, and other information. + * + * @example + * ```ts + * const response: Response = await fetch("https://remix.run"); + * await response.text(); + * ``` + * @example + * ```ts + * const response: Response = await fetch("https://remix.run"); + * await Bun.write("remix.html", response); + * ``` + */ +declare class Response implements BlobInterface { + constructor( + body?: ReadableStream | BlobPart | BlobPart[] | null, + options?: ResponseInit, + ); + + /** + * Create a new {@link Response} with a JSON body + * + * @param body - The body of the response + * @param options - options to pass to the response + * + * @example + * + * ```ts + * const response = Response.json({hi: "there"}); + * console.assert( + * await response.text(), + * `{"hi":"there"}` + * ); + * ``` + * ------- + * + * This is syntactic sugar for: + * ```js + * new Response(JSON.stringify(body), {headers: { "Content-Type": "application/json" }}) + * ``` + * @link https://github.com/whatwg/fetch/issues/1389 + */ + static json(body?: any, options?: ResponseInit | number): Response; + /** + * Create a new {@link Response} that redirects to url + * + * @param url - the URL to redirect to + * @param status - the HTTP status code to use for the redirect + */ + // tslint:disable-next-line:unified-signatures + static redirect(url: string, status?: number): Response; + + /** + * Create a new {@link Response} that redirects to url + * + * @param url - the URL to redirect to + * @param options - options to pass to the response + */ + // tslint:disable-next-line:unified-signatures + static redirect(url: string, options?: ResponseInit): Response; + + /** + * Create a new {@link Response} that has a network error + */ + static error(): Response; + + /** + * HTTP [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) sent with the response. + * + * @example + * ```ts + * const {headers} = await fetch("https://remix.run"); + * headers.get("Content-Type"); + * headers.get("Content-Length"); + * headers.get("Set-Cookie"); + * ``` + */ + readonly headers: Headers; + + /** + * HTTP response body as a [ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) + * + * This is part of web Streams + * + * @example + * ```ts + * const {body} = await fetch("https://remix.run"); + * const reader = body.getReader(); + * const {done, value} = await reader.read(); + * console.log(value); // Uint8Array + * ``` + */ + readonly body: ReadableStream | null; + + /** + * Has the body of the response already been consumed? + */ + readonly bodyUsed: boolean; + + /** + * Read the data from the Response as a string. It will be decoded from UTF-8. + * + * When the body is valid latin1, this operation is zero copy. + */ + text(): Promise; + + /** + * Read the data from the Response as a string. It will be decoded from UTF-8. + * + * When the body is valid latin1, this operation is zero copy. + */ + arrayBuffer(): Promise; + + /** + * Read the data from the Response as a JSON object. + * + * This first decodes the data from UTF-8, then parses it as JSON. + * + */ + json(): Promise; + + /** + * Read the data from the Response as a Blob. + * + * This allows you to reuse the underlying data. + * + * @returns Promise - The body of the response as a {@link Blob}. + */ + blob(): Promise; + + readonly ok: boolean; + readonly redirected: boolean; + /** + * HTTP status code + * + * @example + * 200 + * + * 0 for network errors + */ + readonly status: number; + readonly statusText: string; + readonly type: ResponseType; + /** HTTP url as a string */ + readonly url: string; + + /** Copy the Response object into a new Response, including the body */ + clone(): Response; +} + +type RequestCache = + | "default" + | "force-cache" + | "no-cache" + | "no-store" + | "only-if-cached" + | "reload"; +type RequestCredentials = "include" | "omit" | "same-origin"; +type RequestDestination = + | "" + | "audio" + | "audioworklet" + | "document" + | "embed" + | "font" + | "frame" + | "iframe" + | "image" + | "manifest" + | "object" + | "paintworklet" + | "report" + | "script" + | "sharedworker" + | "style" + | "track" + | "video" + | "worker" + | "xslt"; +type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin"; +type RequestRedirect = "error" | "follow" | "manual"; +type ReferrerPolicy = + | "" + | "no-referrer" + | "no-referrer-when-downgrade" + | "origin" + | "origin-when-cross-origin" + | "same-origin" + | "strict-origin" + | "strict-origin-when-cross-origin" + | "unsafe-url"; +type RequestInfo = Request | string; + +type BodyInit = ReadableStream | XMLHttpRequestBodyInit; +type XMLHttpRequestBodyInit = Blob | BufferSource | string; +type ReadableStreamController = ReadableStreamDefaultController; +type ReadableStreamDefaultReadResult = + | ReadableStreamDefaultReadValueResult + | ReadableStreamDefaultReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader; + +interface RequestInit { + /** + * A BodyInit object or null to set request's body. + */ + body?: BodyInit | null; + /** + * A string indicating how the request will interact with the browser's cache to set request's cache. + * + * Note: as of Bun v0.0.74, this is not implemented yet. + */ + cache?: RequestCache; + /** + * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. + */ + credentials?: RequestCredentials; + /** + * A Headers object, an object literal, or an array of two-item arrays to set request's headers. + */ + headers?: HeadersInit; + /** + * A cryptographic hash of the resource to be fetched by request. Sets request's integrity. + * + * Note: as of Bun v0.0.74, this is not implemented yet. + */ + integrity?: string; + /** + * A boolean to set request's keepalive. + * + * Available in Bun v0.2.0 and above. + * + * This is enabled by default + */ + keepalive?: boolean; + /** + * A string to set request's method. + */ + method?: string; + /** + * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. + */ + mode?: RequestMode; + /** + * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. + */ + redirect?: RequestRedirect; + /** + * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. + */ + referrer?: string; + /** + * A referrer policy to set request's referrerPolicy. + */ + referrerPolicy?: ReferrerPolicy; + /** + * An AbortSignal to set request's signal. + * + * Note: as of Bun v0.0.74, this is not implemented yet. + */ + signal?: AbortSignal | null; + /** + * Can only be null. Used to disassociate request from any Window. + * + * This does nothing in Bun + */ + window?: any; + + /** + * Enable or disable HTTP request timeout + */ + timeout?: boolean; +} + +/** + * [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) represents an HTTP request. + * + * @example + * ```ts + * const request = new Request("https://remix.run/"); + * await fetch(request); + * ``` + * + * @example + * ```ts + * const request = new Request("https://remix.run/"); + * await fetch(request); + * ``` + */ +declare class Request implements BlobInterface { + constructor(requestInfo: RequestInfo, requestInit?: RequestInit); + + /** + * Read or write the HTTP headers for this request. + * + * @example + * ```ts + * const request = new Request("https://remix.run/"); + * request.headers.set("Content-Type", "application/json"); + * request.headers.set("Accept", "application/json"); + * await fetch(request); + * ``` + */ + headers: Headers; + + /** + * The URL (as a string) corresponding to the HTTP request + * @example + * ```ts + * const request = new Request("https://remix.run/"); + * request.url; // "https://remix.run/" + * ``` + */ + readonly url: string; + + /** + * Consume the [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) body as a string. It will be decoded from UTF-8. + * + * When the body is valid latin1, this operation is zero copy. + */ + text(): Promise; + + /** + * Consume the [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) body as a {@link ReadableStream}. + * + * Streaming **outgoing** HTTP request bodies via `fetch()` is not yet supported in + * Bun. + * + * Reading **incoming** HTTP request bodies via `ReadableStream` in `Bun.serve()` is supported + * as of Bun v0.2.0. + * + * + */ + get body(): ReadableStream | null; + + /** + * Consume the [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) body as an ArrayBuffer. + * + */ + arrayBuffer(): Promise; + + /** + * Consume the [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) body as a JSON object. + * + * This first decodes the data from UTF-8, then parses it as JSON. + * + */ + json(): Promise; + + /** + * Consume the [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) body as a `Blob`. + * + * This allows you to reuse the underlying data. + * + */ + blob(): Promise; + + /** + * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. + */ + readonly cache: RequestCache; + /** + * Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. + */ + readonly credentials: RequestCredentials; + /** + * Returns the kind of resource requested by request, e.g., "document" or "script". + * + * In Bun, this always returns "navigate". + */ + readonly destination: RequestDestination; + /** + * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] + * + * This does nothing in Bun right now. + */ + readonly integrity: string; + /** + * Returns a boolean indicating whether or not request can outlive the global in which it was created. + * + * In Bun, this always returns false. + */ + readonly keepalive: boolean; + /** + * Returns request's HTTP method, which is "GET" by default. + */ + readonly method: string; + /** + * Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs. + */ + readonly mode: RequestMode; + /** + * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. + */ + readonly redirect: RequestRedirect; + /** + * Returns the referrer of request. Its value can be a same-origin URL + * if explicitly set in init, the empty string to indicate no referrer, + * and "about:client" when defaulting to the global's default. This is + * used during fetching to determine the value of the `Referer` header + * of the request being made. + */ + readonly referrer: string; + /** + * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. + */ + readonly referrerPolicy: ReferrerPolicy; + /** + * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. + * + * Note: this is **not implemented yet**. The cake is a lie. + */ + readonly signal: AbortSignal; + + /** Copy the Request object into a new Request, including the body */ + clone(): Request; +} + +interface Crypto { + readonly subtle: SubtleCrypto; + + getRandomValues(array: T): T; + /** + * Generate a cryptographically secure random UUID. + * + * @example + * + * ```js + * crypto.randomUUID() + * '5e6adf82-f516-4468-b1e1-33d6f664d7dc' + * ``` + */ + randomUUID(): string; +} + +declare var crypto: Crypto; + +/** + * [`atob`](https://developer.mozilla.org/en-US/docs/Web/API/atob) decodes base64 into ascii text. + * + * @param asciiText The base64 string to decode. + */ +declare function atob(encodedData: string): string; + +/** + * [`btoa`](https://developer.mozilla.org/en-US/docs/Web/API/btoa) encodes ascii text into base64. + * + * @param stringToEncode The ascii text to encode. + */ +declare function btoa(stringToEncode: string): string; + +/** + * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextEncoder` API. All + * instances of `TextEncoder` only support UTF-8 encoding. + * + * ```js + * const encoder = new TextEncoder(); + * const uint8array = encoder.encode('this is some data'); + * ``` + * + */ +declare class TextEncoder { + /** + * The encoding supported by the `TextEncoder` instance. Always set to `'utf-8'`. + */ + readonly encoding: "utf-8"; + + constructor(encoding?: "utf-8"); + + /** + * UTF-8 encodes the `input` string and returns a `Uint8Array` containing the + * encoded bytes. + * @param [input='an empty string'] The text to encode. + */ + encode(input?: string): Uint8Array; + /** + * UTF-8 encodes the `src` string to the `dest` Uint8Array and returns an object + * containing the read Unicode code units and written UTF-8 bytes. + * + * ```js + * const encoder = new TextEncoder(); + * const src = 'this is some data'; + * const dest = new Uint8Array(10); + * const { read, written } = encoder.encodeInto(src, dest); + * ``` + * @param src The text to encode. + * @param dest The array to hold the encode result. + */ + encodeInto(src?: string, dest?: BufferSource): EncodeIntoResult; +} + +/** + * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextDecoder` API. + * + * ```js + * const decoder = new TextDecoder(); + * const u8arr = new Uint8Array([72, 101, 108, 108, 111]); + * console.log(decoder.decode(u8arr)); // Hello + * ``` + */ +declare class TextDecoder { + /** + * The encoding supported by the `TextDecoder` instance. + */ + readonly encoding: string; + /** + * The value will be `true` if decoding errors result in a `TypeError` being + * thrown. + */ + readonly fatal: boolean; + /** + * The value will be `true` if the decoding result will include the byte order + * mark. + */ + readonly ignoreBOM: boolean; + + constructor( + encoding?: Encoding, + options?: { fatal?: boolean; ignoreBOM?: boolean }, + ); + + /** + * Decodes the `input` and returns a string. If `options.stream` is `true`, any + * incomplete byte sequences occurring at the end of the `input` are buffered + * internally and emitted after the next call to `textDecoder.decode()`. + * + * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a`TypeError` being thrown. + * @param input An `ArrayBuffer`, `DataView` or `BufferSource` instance containing the encoded data. + */ + decode(input?: BufferSource | ArrayBuffer): string; +} + +/** + * ShadowRealms are a distinct global environment, with its own global object + * containing its own intrinsics and built-ins (standard objects that are not + * bound to global variables, like the initial value of Object.prototype). + * + * + * @example + * + * ```js + * const red = new ShadowRealm(); + * + * // realms can import modules that will execute within it's own environment. + * // When the module is resolved, it captured the binding value, or creates a new + * // wrapped function that is connected to the callable binding. + * const redAdd = await red.importValue('./inside-code.js', 'add'); + * + * // redAdd is a wrapped function exotic object that chains it's call to the + * // respective imported binding. + * let result = redAdd(2, 3); + * + * console.assert(result === 5); // yields true + * + * // The evaluate method can provide quick code evaluation within the constructed + * // shadowRealm without requiring any module loading, while it still requires CSP + * // relaxing. + * globalThis.someValue = 1; + * red.evaluate('globalThis.someValue = 2'); // Affects only the ShadowRealm's global + * console.assert(globalThis.someValue === 1); + * + * // The wrapped functions can also wrap other functions the other way around. + * const setUniqueValue = + * await red.importValue('./inside-code.js', 'setUniqueValue'); + * + * // setUniqueValue = (cb) => (cb(globalThis.someValue) * 2); + * + * result = setUniqueValue((x) => x ** 3); + * + * console.assert(result === 16); // yields true + * ``` + */ +declare class ShadowRealm { + /** + * Creates a new [ShadowRealm](https://github.com/tc39/proposal-shadowrealm/blob/main/explainer.md#introduction) + * + * @example + * + * ```js + * const red = new ShadowRealm(); + * + * // realms can import modules that will execute within it's own environment. + * // When the module is resolved, it captured the binding value, or creates a new + * // wrapped function that is connected to the callable binding. + * const redAdd = await red.importValue('./inside-code.js', 'add'); + * + * // redAdd is a wrapped function exotic object that chains it's call to the + * // respective imported binding. + * let result = redAdd(2, 3); + * + * console.assert(result === 5); // yields true + * + * // The evaluate method can provide quick code evaluation within the constructed + * // shadowRealm without requiring any module loading, while it still requires CSP + * // relaxing. + * globalThis.someValue = 1; + * red.evaluate('globalThis.someValue = 2'); // Affects only the ShadowRealm's global + * console.assert(globalThis.someValue === 1); + * + * // The wrapped functions can also wrap other functions the other way around. + * const setUniqueValue = + * await red.importValue('./inside-code.js', 'setUniqueValue'); + * + * // setUniqueValue = (cb) => (cb(globalThis.someValue) * 2); + * + * result = setUniqueValue((x) => x ** 3); + * + * console.assert(result === 16); // yields true + * ``` + */ + constructor(); + importValue(specifier: string, bindingName: string): Promise; + evaluate(sourceText: string): any; +} + +interface Blob { + /** + * Read the contents of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) as a JSON object + * @warn in browsers, this function is only available for `Response` and `Request` + */ + json(): Promise; + /** + * Read the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) as a UTF-8 string + * @link https://developer.mozilla.org/en-US/docs/Web/API/Blob/text + */ + text(): Promise; + /** + * Read the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) as an ArrayBuffer object + * @link https://developer.mozilla.org/en-US/docs/Web/API/Blob/arrayBuffer + */ + arrayBuffer(): Promise; +} + +declare var performance: { + /** + * Seconds since Bun.js started + * + * Uses a high-precision system timer to measure the time elapsed since the + * Bun.js runtime was initialized. The value is represented as a double + * precision floating point number. The value is monotonically increasing + * during the lifetime of the runtime. + * + */ + now: () => number; +}; + +/** + * Cancel a repeating timer by its timer ID. + * @param id timer id + */ +declare function clearInterval(id?: number): void; +/** + * Cancel a delayed function call by its timer ID. + * @param id timer id + */ +declare function clearTimeout(id?: number): void; +// declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise; +// declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; +/** + * Send a HTTP(s) request + * + * @param url URL string + * @param init A structured value that contains settings for the fetch() request. + * + * @returns A promise that resolves to {@link Response} object. + * + * + */ +declare function fetch( + url: string, + init?: RequestInit, + /** + * This is a custom property that is not part of the Fetch API specification. + * It exists mostly as a debugging tool + */ + bunOnlyOptions?: { + /** + * Log the raw HTTP request & response to stdout. This API may be + * removed in a future version of Bun without notice. + */ + verbose: boolean; + }, +): Promise; + +/** + * Send a HTTP(s) request + * + * @param request Request object + * @param init A structured value that contains settings for the fetch() request. + * + * @returns A promise that resolves to {@link Response} object. + * + * + */ +// tslint:disable-next-line:unified-signatures +declare function fetch( + request: Request, + init?: RequestInit, + /** + * This is a custom property that is not part of the Fetch API specification. + * It exists mostly as a debugging tool + */ + bunOnlyOptions?: { + /** + * Log the raw HTTP request & response to stdout. This API may be + * removed in a future version of Bun without notice. + */ + verbose: boolean; + }, +): Promise; + +declare function queueMicrotask(callback: (...args: any[]) => void): void; +/** + * Log an error using the default exception handler + * @param error Error or string + */ +declare function reportError(error: any): void; +/** + * Run a function every `interval` milliseconds + * @param handler function to call + * @param interval milliseconds to wait between calls + */ +declare function setInterval( + handler: TimerHandler, + interval?: number, + ...arguments: any[] +): number; +/** + * Run a function after `timeout` (milliseconds) + * @param handler function to call + * @param timeout milliseconds to wait between calls + */ +declare function setTimeout( + handler: TimerHandler, + timeout?: number, + ...arguments: any[] +): number; +declare function addEventListener( + type: K, + listener: (this: object, ev: EventMap[K]) => any, + options?: boolean | AddEventListenerOptions, +): void; +declare function addEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | AddEventListenerOptions, +): void; +declare function removeEventListener( + type: K, + listener: (this: object, ev: EventMap[K]) => any, + options?: boolean | EventListenerOptions, +): void; +declare function removeEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | EventListenerOptions, +): void; + +// ----------------------- +// ----------------------- +// --- libdom.d.ts + +interface ErrorEventInit extends EventInit { + colno?: number; + error?: any; + filename?: string; + lineno?: number; + message?: string; +} + +interface CloseEventInit extends EventInit { + code?: number; + reason?: string; + wasClean?: boolean; +} + +interface MessageEventInit extends EventInit { + data?: T; + lastEventId?: string; + origin?: string; + source?: MessageEventSource; +} + +interface EventInit { + bubbles?: boolean; + cancelable?: boolean; + composed?: boolean; +} + +interface EventListenerOptions { + capture?: boolean; +} + +interface UIEventInit extends EventInit { + detail?: number; + view?: null; + /** @deprecated */ + which?: number; +} + +interface EventModifierInit extends UIEventInit { + altKey?: boolean; + ctrlKey?: boolean; + metaKey?: boolean; + modifierAltGraph?: boolean; + modifierCapsLock?: boolean; + modifierFn?: boolean; + modifierFnLock?: boolean; + modifierHyper?: boolean; + modifierNumLock?: boolean; + modifierScrollLock?: boolean; + modifierSuper?: boolean; + modifierSymbol?: boolean; + modifierSymbolLock?: boolean; + shiftKey?: boolean; +} + +interface EventSourceInit { + withCredentials?: boolean; +} + +/** A controller object that allows you to abort one or more DOM requests as and when desired. */ +interface AbortController { + /** + * Returns the AbortSignal object associated with this object. + */ + readonly signal: AbortSignal; + /** + * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted. + */ + abort(): void; +} + +/** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */ +interface EventTarget { + /** + * Appends an event listener for events whose type attribute value is + * type. The callback argument sets the callback that will be invoked + * when the event is dispatched. + * + * The options argument sets listener-specific options. For + * compatibility this can be a boolean, in which case the method behaves + * exactly as if the value was specified as options's capture. + * + * When set to true, options's capture prevents callback from being + * invoked when the event's eventPhase attribute value is + * BUBBLING_PHASE. When false (or not present), callback will not be + * invoked when event's eventPhase attribute value is CAPTURING_PHASE. + * Either way,callback will be invoked if event's eventPhase attribute + * value is AT_TARGET. + * + * When set to true, options's passive indicates that the callback will + * not cancel the event by invoking preventDefault(). This is used to + * enable performance optimizations described in § 2.8 Observing event + * listeners. + * + * When set to true, options's once indicates that the callback will + * only be invoked once after which the event listener will be removed. + * + * If an AbortSignal is passed for options's signal, then the event + * listener will be removed when signal is aborted. + * + * The event listener is appended to target's event listener list and is + * not appended if it has the same type, callback, and capture. + */ + addEventListener( + type: string, + callback: EventListenerOrEventListenerObject | null, + options?: AddEventListenerOptions | boolean, + ): void; + /** Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. */ + dispatchEvent(event: Event): boolean; + /** Removes the event listener in target's event listener list with the same type, callback, and options. */ + removeEventListener( + type: string, + callback: EventListenerOrEventListenerObject | null, + options?: EventListenerOptions | boolean, + ): void; +} + +declare var EventTarget: { + prototype: EventTarget; + new (): EventTarget; +}; + +/** An event which takes place in the DOM. */ +interface Event { + /** + * Returns true or false depending on how event was initialized. True + * if event goes through its target's ancestors in reverse tree order, + * and false otherwise. + */ + readonly bubbles: boolean; + cancelBubble: boolean; + /** + * Returns true or false depending on how event was initialized. Its + * return value does not always carry meaning, but true can indicate + * that part of the operation during which event was dispatched, can be + * canceled by invoking the preventDefault() method. + */ + readonly cancelable: boolean; + /** + * Returns true or false depending on how event was initialized. True + * if event invokes listeners past a ShadowRoot node that is the root of + * its target, and false otherwise. + */ + readonly composed: boolean; + /** + * Returns the object whose event listener's callback is currently + * being invoked. + */ + readonly currentTarget: EventTarget | null; + /** + * Returns true if preventDefault() was invoked successfully to + * indicate cancelation, and false otherwise. + */ + readonly defaultPrevented: boolean; + /** + * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, + * AT_TARGET, and BUBBLING_PHASE. + */ + readonly eventPhase: number; + /** + * Returns true if event was dispatched by the user agent, and false + * otherwise. + */ + readonly isTrusted: boolean; + /** + * @deprecated + */ + returnValue: boolean; + /** + * @deprecated + */ + readonly srcElement: EventTarget | null; + /** + * Returns the object to which event is dispatched (its target). + */ + readonly target: EventTarget | null; + /** + * Returns the event's timestamp as the number of milliseconds measured + * relative to the time origin. + */ + readonly timeStamp: DOMHighResTimeStamp; + /** + * Returns the type of event, e.g. "click", "hashchange", or "submit". + */ + readonly type: string; + /** + * Returns the invocation target objects of event's path (objects on + * which listeners will be invoked), except for any nodes in shadow + * trees of which the shadow root's mode is "closed" that are not + * reachable from event's currentTarget. + */ + composedPath(): EventTarget[]; + /** + * @deprecated + */ + initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void; + /** + * If invoked when the cancelable attribute value is true, and while + * executing a listener for the event with passive set to false, signals + * to the operation that caused event to be dispatched that it needs to + * be canceled. + */ + preventDefault(): void; + /** + * Invoking this method prevents event from reaching any registered + * event listeners after the current one finishes running and, when + * dispatched in a tree, also prevents event from reaching any other + * objects. + */ + stopImmediatePropagation(): void; + /** + * When dispatched in a tree, invoking this method prevents event from + * reaching any objects other than the current object. + */ + stopPropagation(): void; + readonly AT_TARGET: number; + readonly BUBBLING_PHASE: number; + readonly CAPTURING_PHASE: number; + readonly NONE: number; +} + +declare var Event: { + prototype: Event; + new (type: string, eventInitDict?: EventInit): Event; + readonly AT_TARGET: number; + readonly BUBBLING_PHASE: number; + readonly CAPTURING_PHASE: number; + readonly NONE: number; +}; + +/** + * Events providing information related to errors in scripts or in files. + */ +interface ErrorEvent extends Event { + readonly colno: number; + readonly error: any; + readonly filename: string; + readonly lineno: number; + readonly message: string; +} + +declare var ErrorEvent: { + prototype: ErrorEvent; + new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent; +}; + +/** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */ +interface CloseEvent extends Event { + /** Returns the WebSocket connection close code provided by the server. */ + readonly code: number; + /** Returns the WebSocket connection close reason provided by the server. */ + readonly reason: string; + /** Returns true if the connection closed cleanly; false otherwise. */ + readonly wasClean: boolean; +} + +declare var CloseEvent: { + prototype: CloseEvent; + new (type: string, eventInitDict?: CloseEventInit): CloseEvent; +}; + +/** A message received by a target object. */ +interface MessageEvent extends Event { + /** Returns the data of the message. */ + readonly data: T; + /** Returns the last event ID string, for server-sent events. */ + readonly lastEventId: string; + /** Returns the origin of the message, for server-sent events and cross-document messaging. */ + readonly origin: string; + readonly source: MessageEventSource; + /** @deprecated */ + initMessageEvent( + type: string, + bubbles?: boolean, + cancelable?: boolean, + data?: any, + origin?: string, + lastEventId?: string, + source?: null, + ): void; +} + +declare var MessageEvent: { + prototype: MessageEvent; + new (type: string, eventInitDict?: MessageEventInit): MessageEvent; +}; + +/** + * An implementation of the [WebSocket API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) + */ +interface WebSocketEventMap { + close: CloseEvent; + error: Event; + message: MessageEvent; + open: Event; +} + +/** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */ +interface WebSocket extends EventTarget { + /** + * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts: + * + * Can be set, to change how binary data is returned. The default is "blob". + */ + binaryType: BinaryType; + /** + * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network. + * + * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.) + */ + readonly bufferedAmount: number; + /** Returns the extensions selected by the server, if any. */ + readonly extensions: string; + onclose: ((this: WebSocket, ev: CloseEvent) => any) | null; + onerror: ((this: WebSocket, ev: Event) => any) | null; + onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null; + onopen: ((this: WebSocket, ev: Event) => any) | null; + /** Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation. */ + readonly protocol: string; + /** Returns the state of the WebSocket object's connection. It can have the values described below. */ + readonly readyState: number; + /** Returns the URL that was used to establish the WebSocket connection. */ + readonly url: string; + /** Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason. */ + close(code?: number, reason?: string): void; + /** Transmits data using the WebSocket connection. data can be a string, an ArrayBuffer, or an BufferSource. */ + send(data: string | ArrayBufferLike | BufferSource): void; + readonly CLOSED: number; + readonly CLOSING: number; + readonly CONNECTING: number; + readonly OPEN: number; + addEventListener( + type: K, + listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, + options?: boolean | AddEventListenerOptions, + ): void; + addEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | AddEventListenerOptions, + ): void; + removeEventListener( + type: K, + listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, + options?: boolean | EventListenerOptions, + ): void; + removeEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | EventListenerOptions, + ): void; +} + +declare var WebSocket: { + prototype: WebSocket; + new (url: string | URL, protocols?: string | string[]): WebSocket; + readonly CLOSED: number; + readonly CLOSING: number; + readonly CONNECTING: number; + readonly OPEN: number; +}; + +/** + * The URL interface represents an object providing static methods used for + * creating object URLs. + */ +interface URL { + hash: string; + host: string; + hostname: string; + href: string; + toString(): string; + readonly origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + search: string; + readonly searchParams: URLSearchParams; + username: string; + toJSON(): string; +} + +interface URLSearchParams { + /** Appends a specified key/value pair as a new search parameter. */ + append(name: string, value: string): void; + /** Deletes the given search parameter, and its associated value, from the list of all search parameters. */ + delete(name: string): void; + /** Returns the first value associated to the given search parameter. */ + get(name: string): string | null; + /** Returns all the values association with a given search parameter. */ + getAll(name: string): string[]; + /** Returns a Boolean indicating if such a search parameter exists. */ + has(name: string): boolean; + /** Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. */ + set(name: string, value: string): void; + sort(): void; + entries(): IterableIterator<[string, string]>; + /** Returns an iterator allowing to go through all keys of the key/value pairs of this search parameter. */ + keys(): IterableIterator; + /** Returns an iterator allowing to go through all values of the key/value pairs of this search parameter. */ + values(): IterableIterator; + forEach( + callbackfn: (value: string, key: string, parent: URLSearchParams) => void, + thisArg?: any, + ): void; + /** Returns a string containing a query string suitable for use in a URL. Does not include the question mark. */ + toString(): string; +} + +declare var URLSearchParams: { + prototype: URLSearchParams; + new ( + init?: string[][] | Record | string | URLSearchParams, + ): URLSearchParams; + toString(): string; +}; + +declare var URL: { + prototype: URL; + new (url: string | URL, base?: string | URL): URL; + /** Not implemented yet */ + createObjectURL(obj: Blob): string; + /** Not implemented yet */ + revokeObjectURL(url: string): void; +}; + +type TimerHandler = (...args: any[]) => void; + +interface EventListener { + (evt: Event): void; +} + +interface EventListenerObject { + handleEvent(object: Event): void; +} + +declare var AbortController: { + prototype: AbortController; + new (): AbortController; +}; + +interface FetchEvent extends Event { + readonly request: Request; + readonly url: string; + + waitUntil(promise: Promise): void; + respondWith(response: Response | Promise): void; +} + +interface EventMap { + fetch: FetchEvent; + // exit: Event; +} + +interface AbortSignalEventMap { + abort: Event; +} + +interface AddEventListenerOptions extends EventListenerOptions { + once?: boolean; + passive?: boolean; + signal?: AbortSignal; +} + +/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */ +interface AbortSignal extends EventTarget { + /** + * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. + */ + readonly aborted: boolean; + onabort: ((this: AbortSignal, ev: Event) => any) | null; + addEventListener( + type: K, + listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, + options?: boolean | AddEventListenerOptions, + ): void; + addEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | AddEventListenerOptions, + ): void; + removeEventListener( + type: K, + listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, + options?: boolean | EventListenerOptions, + ): void; + removeEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | EventListenerOptions, + ): void; +} + +declare var AbortSignal: { + prototype: AbortSignal; + new (): AbortSignal; +}; + +// type AlgorithmIdentifier = Algorithm | string; +// type BodyInit = ReadableStream | XMLHttpRequestBodyInit; +type BufferSource = ArrayBufferView | ArrayBuffer | SharedArrayBuffer; +// type COSEAlgorithmIdentifier = number; +// type CSSNumberish = number; +// type CanvasImageSource = +// | HTMLOrSVGImageElement +// | HTMLVideoElement +// | HTMLCanvasElement +// | ImageBitmap; +type DOMHighResTimeStamp = number; +// type EpochTimeStamp = number; +type EventListenerOrEventListenerObject = EventListener | EventListenerObject; + +/** + * Low-level JavaScriptCore API for accessing the native ES Module loader (not a Bun API) + * + * Before using this, be aware of a few things: + * + * **Using this incorrectly will crash your application**. + * + * This API may change any time JavaScriptCore is updated. + * + * Bun may rewrite ESM import specifiers to point to bundled code. This will + * be confusing when using this API, as it will return a string like + * "/node_modules.server.bun". + * + * Bun may inject additional imports into your code. This usually has a `bun:` prefix. + * + */ +declare var Loader: { + /** + * ESM module registry + * + * This lets you implement live reload in Bun. If you + * delete a module specifier from this map, the next time it's imported, it + * will be re-transpiled and loaded again. + * + * The keys are the module specifiers and the + * values are metadata about the module. + * + * The keys are an implementation detail for Bun that will change between + * versions. + * + * - Userland modules are an absolute file path + * - Virtual modules have a `bun:` prefix or `node:` prefix + * - JS polyfills start with `"/bun-vfs/"`. `"buffer"` is an example of a JS polyfill + * - If you have a `node_modules.bun` file, many modules will point to that file + * + * Virtual modules and JS polyfills are embedded in bun's binary. They don't + * point to anywhere in your local filesystem. + * + * + */ + registry: Map< + string, + { + /** + * This refers to the state the ESM module is in + * + * TODO: make an enum for this number + * + * + */ + state: number; + dependencies: string[]; + /** + * Your application will probably crash if you mess with this. + */ + module: any; + } + >; + /** + * For an already-evaluated module, return the dependencies as module specifiers + * + * This list is already sorted and uniqued. + * + * @example + * + * For this code: + * ```js + * // /foo.js + * import classNames from 'classnames'; + * import React from 'react'; + * import {createElement} from 'react'; + * ``` + * + * This would return: + * ```js + * Loader.dependencyKeysIfEvaluated("/foo.js") + * ["bun:wrap", "/path/to/node_modules/classnames/index.js", "/path/to/node_modules/react/index.js"] + * ``` + * + * @param specifier - module specifier as it appears in transpiled source code + * + */ + dependencyKeysIfEvaluated: (specifier: string) => string[]; + /** + * The function JavaScriptCore internally calls when you use an import statement. + * + * This may return a path to `node_modules.server.bun`, which will be confusing. + * + * Consider {@link Bun.resolve} or {@link ImportMeta.resolve} + * instead. + * + * @param specifier - module specifier as it appears in transpiled source code + * @param referrer - module specifier that is resolving this specifier + */ + resolve: (specifier: string, referrer: string) => string; +}; + +/** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */ +interface ReadableStream { + readonly locked: boolean; + cancel(reason?: any): Promise; + getReader(): ReadableStreamDefaultReader; + pipeThrough( + transform: ReadableWritablePair, + options?: StreamPipeOptions, + ): ReadableStream; + pipeTo( + destination: WritableStream, + options?: StreamPipeOptions, + ): Promise; + tee(): [ReadableStream, ReadableStream]; + forEach( + callbackfn: (value: any, key: number, parent: ReadableStream) => void, + thisArg?: any, + ): void; + [Symbol.asyncIterator](): AsyncIterableIterator; + values(options?: { preventCancel: boolean }): AsyncIterableIterator; +} + +declare var ReadableStream: { + prototype: ReadableStream; + new ( + underlyingSource?: DirectUnderlyingSource | UnderlyingSource, + strategy?: QueuingStrategy, + ): ReadableStream; +}; + +interface QueuingStrategy { + highWaterMark?: number; + size?: QueuingStrategySize; +} + +interface QueuingStrategyInit { + /** + * Creates a new ByteLengthQueuingStrategy with the provided high water mark. + * + * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw. + */ + highWaterMark: number; +} + +/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */ +interface ByteLengthQueuingStrategy extends QueuingStrategy { + readonly highWaterMark: number; + readonly size: QueuingStrategySize; +} + +declare var ByteLengthQueuingStrategy: { + prototype: ByteLengthQueuingStrategy; + new (init: QueuingStrategyInit): ByteLengthQueuingStrategy; +}; + +interface ReadableStreamDefaultController { + readonly desiredSize: number | null; + close(): void; + enqueue(chunk?: R): void; + error(e?: any): void; +} + +interface ReadableStreamDirectController { + close(error?: Error): void; + write(data: BufferSource | ArrayBuffer | string): number | Promise; + end(): number | Promise; + flush(): number | Promise; + start(): void; +} + +declare var ReadableStreamDefaultController: { + prototype: ReadableStreamDefaultController; + new (): ReadableStreamDefaultController; +}; + +interface ReadableStreamDefaultReader + extends ReadableStreamGenericReader { + read(): Promise>; + releaseLock(): void; +} + +declare var ReadableStreamDefaultReader: { + prototype: ReadableStreamDefaultReader; + new (stream: ReadableStream): ReadableStreamDefaultReader; +}; + +interface ReadableStreamGenericReader { + readonly closed: Promise; + cancel(reason?: any): Promise; +} + +interface ReadableStreamDefaultReadDoneResult { + done: true; + value?: undefined; +} + +interface ReadableStreamDefaultReadValueResult { + done: false; + value: T; +} + +interface ReadableWritablePair { + readable: ReadableStream; + /** + * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use. + * + * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader. + */ + writable: WritableStream; +} + +/** This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing. */ +interface WritableStream { + readonly locked: boolean; + abort(reason?: any): Promise; + close(): Promise; + getWriter(): WritableStreamDefaultWriter; +} + +declare var WritableStream: { + prototype: WritableStream; + new ( + underlyingSink?: UnderlyingSink, + strategy?: QueuingStrategy, + ): WritableStream; +}; + +/** This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. */ +interface WritableStreamDefaultController { + error(e?: any): void; +} + +declare var WritableStreamDefaultController: { + prototype: WritableStreamDefaultController; + new (): WritableStreamDefaultController; +}; + +/** This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. */ +interface WritableStreamDefaultWriter { + readonly closed: Promise; + readonly desiredSize: number | null; + readonly ready: Promise; + abort(reason?: any): Promise; + close(): Promise; + releaseLock(): void; + write(chunk?: W): Promise; +} + +declare var WritableStreamDefaultWriter: { + prototype: WritableStreamDefaultWriter; + new (stream: WritableStream): WritableStreamDefaultWriter; +}; + +interface ReadWriteStream extends ReadableStream, WritableStream {} + +interface TransformerFlushCallback { + (controller: TransformStreamDefaultController): void | PromiseLike; +} + +interface TransformerStartCallback { + (controller: TransformStreamDefaultController): any; +} + +interface TransformerTransformCallback { + ( + chunk: I, + controller: TransformStreamDefaultController, + ): void | PromiseLike; +} + +interface UnderlyingSinkAbortCallback { + (reason?: any): void | PromiseLike; +} + +interface UnderlyingSinkCloseCallback { + (): void | PromiseLike; +} + +interface UnderlyingSinkStartCallback { + (controller: WritableStreamDefaultController): any; +} + +interface UnderlyingSinkWriteCallback { + ( + chunk: W, + controller: WritableStreamDefaultController, + ): void | PromiseLike; +} + +interface UnderlyingSourceCancelCallback { + (reason?: any): void | PromiseLike; +} + +interface UnderlyingSink { + abort?: UnderlyingSinkAbortCallback; + close?: UnderlyingSinkCloseCallback; + start?: UnderlyingSinkStartCallback; + type?: undefined | "default" | "bytes"; + write?: UnderlyingSinkWriteCallback; +} + +interface UnderlyingSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: UnderlyingSourcePullCallback; + start?: UnderlyingSourceStartCallback; + type?: undefined; +} + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +interface DirectUnderlyingSource { + cancel?: UnderlyingSourceCancelCallback; + pull: ( + controller: ReadableStreamDirectController, + ) => void | PromiseLike; + type: "direct"; +} + +interface UnderlyingSourcePullCallback { + (controller: ReadableStreamController): void | PromiseLike; +} + +interface UnderlyingSourceStartCallback { + (controller: ReadableStreamController): any; +} + +interface GenericTransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; +} + +interface TransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; +} + +declare var TransformStream: { + prototype: TransformStream; + new ( + transformer?: Transformer, + writableStrategy?: QueuingStrategy, + readableStrategy?: QueuingStrategy, + ): TransformStream; +}; + +interface TransformStreamDefaultController { + readonly desiredSize: number | null; + enqueue(chunk?: O): void; + error(reason?: any): void; + terminate(): void; +} + +declare var TransformStreamDefaultController: { + prototype: TransformStreamDefaultController; + new (): TransformStreamDefaultController; +}; + +interface StreamPipeOptions { + preventAbort?: boolean; + preventCancel?: boolean; + /** + * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered. + * + * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader. + * + * Errors and closures of the source and destination streams propagate as follows: + * + * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination. + * + * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source. + * + * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error. + * + * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source. + * + * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set. + */ + preventClose?: boolean; + signal?: AbortSignal; +} + +/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */ +interface CountQueuingStrategy extends QueuingStrategy { + readonly highWaterMark: number; + readonly size: QueuingStrategySize; +} + +declare var CountQueuingStrategy: { + prototype: CountQueuingStrategy; + new (init: QueuingStrategyInit): CountQueuingStrategy; +}; + +interface QueuingStrategySize { + (chunk?: T): number; +} + +interface Transformer { + flush?: TransformerFlushCallback; + readableType?: undefined; + start?: TransformerStartCallback; + transform?: TransformerTransformCallback; + writableType?: undefined; +} + +interface Dict { + [key: string]: T | undefined; +} + +interface ReadOnlyDict { + readonly [key: string]: T | undefined; +} + +interface ErrnoException extends Error { + errno?: number | undefined; + code?: string | undefined; + path?: string | undefined; + syscall?: string | undefined; +} + +declare function alert(message?: string): void; +declare function confirm(message?: string): boolean; +declare function prompt(message?: string, _default?: string): string | null; + +/* + + Web Crypto API + +*/ + +type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki"; +type KeyType = "private" | "public" | "secret"; +type KeyUsage = + | "decrypt" + | "deriveBits" + | "deriveKey" + | "encrypt" + | "sign" + | "unwrapKey" + | "verify" + | "wrapKey"; +type HashAlgorithmIdentifier = AlgorithmIdentifier; +type NamedCurve = string; + +type BigInteger = Uint8Array; + +interface KeyAlgorithm { + name: string; +} + +interface Algorithm { + name: string; +} + +interface AesCbcParams extends Algorithm { + iv: BufferSource; +} + +interface AesCtrParams extends Algorithm { + counter: BufferSource; + length: number; +} + +interface AesDerivedKeyParams extends Algorithm { + length: number; +} + +interface AesGcmParams extends Algorithm { + additionalData?: BufferSource; + iv: BufferSource; + tagLength?: number; +} + +interface AesKeyAlgorithm extends KeyAlgorithm { + length: number; +} + +interface AesKeyGenParams extends Algorithm { + length: number; +} + +interface EcKeyAlgorithm extends KeyAlgorithm { + namedCurve: NamedCurve; +} + +interface EcKeyGenParams extends Algorithm { + namedCurve: NamedCurve; +} + +interface EcKeyImportParams extends Algorithm { + namedCurve: NamedCurve; +} + +interface EcdhKeyDeriveParams extends Algorithm { + public: CryptoKey; +} + +interface EcdsaParams extends Algorithm { + hash: HashAlgorithmIdentifier; +} + +interface JsonWebKey { + alg?: string; + crv?: string; + d?: string; + dp?: string; + dq?: string; + e?: string; + ext?: boolean; + k?: string; + key_ops?: string[]; + kty?: string; + n?: string; + oth?: RsaOtherPrimesInfo[]; + p?: string; + q?: string; + qi?: string; + use?: string; + x?: string; + y?: string; +} + +interface HkdfParams extends Algorithm { + hash: HashAlgorithmIdentifier; + info: BufferSource; + salt: BufferSource; +} + +interface HmacImportParams extends Algorithm { + hash: HashAlgorithmIdentifier; + length?: number; +} + +interface HmacKeyAlgorithm extends KeyAlgorithm { + hash: KeyAlgorithm; + length: number; +} + +interface HmacKeyGenParams extends Algorithm { + hash: HashAlgorithmIdentifier; + length?: number; +} + +interface Pbkdf2Params extends Algorithm { + hash: HashAlgorithmIdentifier; + iterations: number; + salt: BufferSource; +} + +interface RsaHashedImportParams extends Algorithm { + hash: HashAlgorithmIdentifier; +} + +interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm { + hash: KeyAlgorithm; +} + +interface RsaHashedKeyGenParams extends RsaKeyGenParams { + hash: HashAlgorithmIdentifier; +} + +interface RsaKeyAlgorithm extends KeyAlgorithm { + modulusLength: number; + publicExponent: BigInteger; +} + +interface RsaKeyGenParams extends Algorithm { + modulusLength: number; + publicExponent: BigInteger; +} + +interface RsaOaepParams extends Algorithm { + label?: BufferSource; +} + +interface RsaOtherPrimesInfo { + d?: string; + r?: string; + t?: string; +} + +interface CryptoKeyPair { + privateKey: CryptoKey; + publicKey: CryptoKey; +} + +type AlgorithmIdentifier = Algorithm | string; + +/** + * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). + */ +interface SubtleCrypto { + decrypt( + algorithm: + | AlgorithmIdentifier + | RsaOaepParams + | AesCtrParams + | AesCbcParams + | AesGcmParams, + key: CryptoKey, + data: BufferSource, + ): Promise; + deriveBits( + algorithm: + | AlgorithmIdentifier + | EcdhKeyDeriveParams + | HkdfParams + | Pbkdf2Params, + baseKey: CryptoKey, + length: number, + ): Promise; + deriveKey( + algorithm: + | AlgorithmIdentifier + | EcdhKeyDeriveParams + | HkdfParams + | Pbkdf2Params, + baseKey: CryptoKey, + derivedKeyType: + | AlgorithmIdentifier + | AesDerivedKeyParams + | HmacImportParams + | HkdfParams + | Pbkdf2Params, + extractable: boolean, + keyUsages: KeyUsage[], + ): Promise; + digest( + algorithm: AlgorithmIdentifier, + data: BufferSource, + ): Promise; + encrypt( + algorithm: + | AlgorithmIdentifier + | RsaOaepParams + | AesCtrParams + | AesCbcParams + | AesGcmParams, + key: CryptoKey, + data: BufferSource, + ): Promise; + exportKey(format: "jwk", key: CryptoKey): Promise; + exportKey( + format: Exclude, + key: CryptoKey, + ): Promise; + generateKey( + algorithm: RsaHashedKeyGenParams | EcKeyGenParams, + extractable: boolean, + keyUsages: ReadonlyArray, + ): Promise; + generateKey( + algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, + extractable: boolean, + keyUsages: ReadonlyArray, + ): Promise; + generateKey( + algorithm: AlgorithmIdentifier, + extractable: boolean, + keyUsages: KeyUsage[], + ): Promise; + importKey( + format: "jwk", + keyData: JsonWebKey, + algorithm: + | AlgorithmIdentifier + | RsaHashedImportParams + | EcKeyImportParams + | HmacImportParams + | AesKeyAlgorithm, + extractable: boolean, + keyUsages: ReadonlyArray, + ): Promise; + importKey( + format: Exclude, + keyData: BufferSource, + algorithm: + | AlgorithmIdentifier + | RsaHashedImportParams + | EcKeyImportParams + | HmacImportParams + | AesKeyAlgorithm, + extractable: boolean, + keyUsages: KeyUsage[], + ): Promise; + sign( + algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, + key: CryptoKey, + data: BufferSource, + ): Promise; + unwrapKey( + format: KeyFormat, + wrappedKey: BufferSource, + unwrappingKey: CryptoKey, + unwrapAlgorithm: + | AlgorithmIdentifier + | RsaOaepParams + | AesCtrParams + | AesCbcParams + | AesGcmParams, + unwrappedKeyAlgorithm: + | AlgorithmIdentifier + | RsaHashedImportParams + | EcKeyImportParams + | HmacImportParams + | AesKeyAlgorithm, + extractable: boolean, + keyUsages: KeyUsage[], + ): Promise; + verify( + algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, + key: CryptoKey, + signature: BufferSource, + data: BufferSource, + ): Promise; + wrapKey( + format: KeyFormat, + key: CryptoKey, + wrappingKey: CryptoKey, + wrapAlgorithm: + | AlgorithmIdentifier + | RsaOaepParams + | AesCtrParams + | AesCbcParams + | AesGcmParams, + ): Promise; +} + +declare var SubtleCrypto: { + prototype: SubtleCrypto; + new (): SubtleCrypto; +}; + +interface RsaPssParams extends Algorithm { + saltLength: number; +} + +/** + * The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. + */ +interface CryptoKey { + readonly algorithm: KeyAlgorithm; + readonly extractable: boolean; + readonly type: KeyType; + readonly usages: KeyUsage[]; +} + +declare var CryptoKey: { + prototype: CryptoKey; + new (): CryptoKey; +}; + +interface Position { + lineText: string; + file: string; + namespace: string; + line: number; + column: number; + length: number; + offset: number; +} + +interface ResolveError { + readonly position: Position | null; + readonly code: string; + readonly message: string; + readonly referrer: string; + readonly name: string; + readonly specifier: string; + readonly importKind: + | "entry_point" + | "stmt" + | "require" + | "import" + | "dynamic" + | "require_resolve" + | "at" + | "at_conditional" + | "url" + | "internal"; + + toString(): string; +} + +declare var ResolveError: { + readonly protoype: ResolveError; +}; + +interface BuildError { + readonly position: Position | null; + readonly message: string; + readonly name: string; +} + +declare var BuildError: { + readonly protoype: BuildError; +}; + +// Declare "static" methods in Error +interface ErrorConstructor { + /** Create .stack property on a target object */ + captureStackTrace(targetObject: object, constructorOpt?: Function): void; + + /** + * Optional override for formatting stack traces + * + * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces + */ + prepareStackTrace?: + | ((err: Error, stackTraces: CallSite[]) => any) + | undefined; + + stackTraceLimit: number; +} + +interface CallSite { + /** + * Value of "this" + */ + getThis(): unknown; + + /** + * Type of "this" as a string. + * This is the name of the function stored in the constructor field of + * "this", if available. Otherwise the object's [[Class]] internal + * property. + */ + getTypeName(): string | null; + + /** + * Current function + */ + getFunction(): Function | undefined; + + /** + * Name of the current function, typically its name property. + * If a name property is not available an attempt will be made to try + * to infer a name from the function's context. + */ + getFunctionName(): string | null; + + /** + * Name of the property [of "this" or one of its prototypes] that holds + * the current function + */ + getMethodName(): string | null; + + /** + * Name of the script [if this function was defined in a script] + */ + getFileName(): string | null; + + /** + * Current line number [if this function was defined in a script] + */ + getLineNumber(): number | null; + + /** + * Current column number [if this function was defined in a script] + */ + getColumnNumber(): number | null; + + /** + * A call site object representing the location where eval was called + * [if this function was created using a call to eval] + */ + getEvalOrigin(): string | undefined; + + /** + * Is this a toplevel invocation, that is, is "this" the global object? + */ + isToplevel(): boolean; + + /** + * Does this call take place in code defined by a call to eval? + */ + isEval(): boolean; + + /** + * Is this call in native code? + */ + isNative(): boolean; + + /** + * Is this a constructor call? + */ + isConstructor(): boolean; +} diff --git a/packages/bun-types/header.txt b/packages/bun-types/header.txt new file mode 100644 index 0000000000..0488d730ae --- /dev/null +++ b/packages/bun-types/header.txt @@ -0,0 +1,8 @@ +// Type definitions for bun {version} +// Project: https://github.com/oven-sh/bun +// Definitions by: Jarred Sumner +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +/// +/// + +// This file is bundled so that your TypeScript editor integration loads it faster. diff --git a/packages/bun-types/html-rewriter.d.ts b/packages/bun-types/html-rewriter.d.ts new file mode 100644 index 0000000000..7f260fd5a5 --- /dev/null +++ b/packages/bun-types/html-rewriter.d.ts @@ -0,0 +1,113 @@ +declare namespace HTMLRewriterTypes { + interface HTMLRewriterElementContentHandlers { + element?(element: Element): void | Promise; + comments?(comment: Comment): void | Promise; + text?(text: Text): void | Promise; + } + + interface HTMLRewriterDocumentContentHandlers { + doctype?(doctype: Doctype): void | Promise; + comments?(comment: Comment): void | Promise; + text?(text: Text): void | Promise; + end?(end: DocumentEnd): void | Promise; + } + + interface Text { + readonly text: string; + readonly lastInTextNode: boolean; + readonly removed: boolean; + before(content: Content, options?: ContentOptions): Text; + after(content: Content, options?: ContentOptions): Text; + replace(content: Content, options?: ContentOptions): Text; + remove(): Text; + } + + interface Doctype { + readonly name: string | null; + readonly publicId: string | null; + readonly systemId: string | null; + } + + interface DocumentEnd { + append(content: Content, options?: ContentOptions): DocumentEnd; + } + + interface ContentOptions { + html?: boolean; + } + type Content = string; + + interface Comment { + text: string; + readonly removed: boolean; + before(content: Content, options?: ContentOptions): Comment; + after(content: Content, options?: ContentOptions): Comment; + replace(content: Content, options?: ContentOptions): Comment; + remove(): Comment; + } + + interface Element { + tagName: string; + readonly attributes: IterableIterator; + readonly removed: boolean; + readonly namespaceURI: string; + getAttribute(name: string): string | null; + hasAttribute(name: string): boolean; + setAttribute(name: string, value: string): Element; + removeAttribute(name: string): Element; + before(content: Content, options?: ContentOptions): Element; + after(content: Content, options?: ContentOptions): Element; + prepend(content: Content, options?: ContentOptions): Element; + append(content: Content, options?: ContentOptions): Element; + replace(content: Content, options?: ContentOptions): Element; + remove(): Element; + removeAndKeepContent(): Element; + setInnerContent(content: Content, options?: ContentOptions): Element; + onEndTag(handler: (tag: EndTag) => void | Promise): void; + } + + interface EndTag { + name: string; + before(content: Content, options?: ContentOptions): EndTag; + after(content: Content, options?: ContentOptions): EndTag; + remove(): EndTag; + } +} + +/** + * [HTMLRewriter](https://developers.cloudflare.com/workers/runtime-apis/html-rewriter?bun) is a fast API for transforming HTML. + * + * Bun leverages a native implementation powered by [lol-html](https://github.com/cloudflare/lol-html). + * + * HTMLRewriter can be used to transform HTML in a variety of ways, including: + * * Rewriting URLs + * * Adding meta tags + * * Removing elements + * * Adding elements to the head + * + * @example + * ```ts + * const rewriter = new HTMLRewriter().on('a[href]', { + * element(element: Element) { + * // Rewrite all the URLs to this youtube video + * element.setAttribute('href', 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'); + * } + * }); + * rewriter.transform(await fetch("https://remix.run")); + * ``` + */ +declare class HTMLRewriter { + constructor(); + on( + selector: string, + handlers: HTMLRewriterTypes.HTMLRewriterElementContentHandlers, + ): HTMLRewriter; + onDocument( + handlers: HTMLRewriterTypes.HTMLRewriterDocumentContentHandlers, + ): HTMLRewriter; + /** + * @param input - The HTML to transform + * @returns A new {@link Response} with the transformed HTML + */ + transform(input: Response): Response; +} diff --git a/packages/bun-types/http.d.ts b/packages/bun-types/http.d.ts new file mode 100644 index 0000000000..a282b621d9 --- /dev/null +++ b/packages/bun-types/http.d.ts @@ -0,0 +1,902 @@ +/** + * To use the HTTP server and client one must `require('http')`. + * + * The HTTP interfaces in Node.js are designed to support many features + * of the protocol which have been traditionally difficult to use. + * In particular, large, possibly chunk-encoded, messages. The interface is + * careful to never buffer entire requests or responses, so the + * user is able to stream data. + * + * HTTP message headers are represented by an object like this: + * + * ```js + * { 'content-length': '123', + * 'content-type': 'text/plain', + * 'connection': 'keep-alive', + * 'host': 'example.com', + * 'accept': '*' } + * ``` + * + * Keys are lowercased. Values are not modified. + * + * In order to support the full spectrum of possible HTTP applications, the Node.js + * HTTP API is very low-level. It deals with stream handling and message + * parsing only. It parses a message into headers and body but it does not + * parse the actual headers or the body. + * + * See `message.headers` for details on how duplicate headers are handled. + * + * The raw headers as they were received are retained in the `rawHeaders`property, which is an array of `[key, value, key2, value2, ...]`. For + * example, the previous message header object might have a `rawHeaders`list like the following: + * + * ```js + * [ 'ConTent-Length', '123456', + * 'content-LENGTH', '123', + * 'content-type', 'text/plain', + * 'CONNECTION', 'keep-alive', + * 'Host', 'example.com', + * 'accepT', '*' ] + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/http.js) + */ +declare module "http" { + import * as stream from "node:stream"; + // incoming headers will never contain number + interface IncomingHttpHeaders extends Dict { + accept?: string | undefined; + "accept-language"?: string | undefined; + "accept-patch"?: string | undefined; + "accept-ranges"?: string | undefined; + "access-control-allow-credentials"?: string | undefined; + "access-control-allow-headers"?: string | undefined; + "access-control-allow-methods"?: string | undefined; + "access-control-allow-origin"?: string | undefined; + "access-control-expose-headers"?: string | undefined; + "access-control-max-age"?: string | undefined; + "access-control-request-headers"?: string | undefined; + "access-control-request-method"?: string | undefined; + age?: string | undefined; + allow?: string | undefined; + "alt-svc"?: string | undefined; + authorization?: string | undefined; + "cache-control"?: string | undefined; + connection?: string | undefined; + "content-disposition"?: string | undefined; + "content-encoding"?: string | undefined; + "content-language"?: string | undefined; + "content-length"?: string | undefined; + "content-location"?: string | undefined; + "content-range"?: string | undefined; + "content-type"?: string | undefined; + cookie?: string | undefined; + date?: string | undefined; + etag?: string | undefined; + expect?: string | undefined; + expires?: string | undefined; + forwarded?: string | undefined; + from?: string | undefined; + host?: string | undefined; + "if-match"?: string | undefined; + "if-modified-since"?: string | undefined; + "if-none-match"?: string | undefined; + "if-unmodified-since"?: string | undefined; + "last-modified"?: string | undefined; + location?: string | undefined; + origin?: string | undefined; + pragma?: string | undefined; + "proxy-authenticate"?: string | undefined; + "proxy-authorization"?: string | undefined; + "public-key-pins"?: string | undefined; + range?: string | undefined; + referer?: string | undefined; + "retry-after"?: string | undefined; + "sec-websocket-accept"?: string | undefined; + "sec-websocket-extensions"?: string | undefined; + "sec-websocket-key"?: string | undefined; + "sec-websocket-protocol"?: string | undefined; + "sec-websocket-version"?: string | undefined; + "set-cookie"?: string[] | undefined; + "strict-transport-security"?: string | undefined; + tk?: string | undefined; + trailer?: string | undefined; + "transfer-encoding"?: string | undefined; + upgrade?: string | undefined; + "user-agent"?: string | undefined; + vary?: string | undefined; + via?: string | undefined; + warning?: string | undefined; + "www-authenticate"?: string | undefined; + } + // outgoing headers allows numbers (as they are converted internally to strings) + type OutgoingHttpHeader = number | string | string[]; + interface OutgoingHttpHeaders extends Dict {} + interface ClientRequestArgs { + signal?: AbortSignal | undefined; + protocol?: string | null | undefined; + host?: string | null | undefined; + hostname?: string | null | undefined; + family?: number | undefined; + port?: number | string | null | undefined; + defaultPort?: number | string | undefined; + localAddress?: string | undefined; + socketPath?: string | undefined; + /** + * @default 8192 + */ + maxHeaderSize?: number | undefined; + method?: string | undefined; + path?: string | null | undefined; + headers?: OutgoingHttpHeaders | undefined; + auth?: string | null | undefined; + timeout?: number | undefined; + setHost?: boolean | undefined; + } + interface InformationEvent { + statusCode: number; + statusMessage: string; + httpVersion: string; + httpVersionMajor: number; + httpVersionMinor: number; + headers: IncomingHttpHeaders; + rawHeaders: string[]; + } + /** + * This object is created internally and returned from {@link request}. It + * represents an _in-progress_ request whose header has already been queued. The + * header is still mutable using the `setHeader(name, value)`,`getHeader(name)`, `removeHeader(name)` API. The actual header will + * be sent along with the first data chunk or when calling `request.end()`. + * + * To get the response, add a listener for `'response'` to the request object.`'response'` will be emitted from the request object when the response + * headers have been received. The `'response'` event is executed with one + * argument which is an instance of {@link IncomingMessage}. + * + * During the `'response'` event, one can add listeners to the + * response object; particularly to listen for the `'data'` event. + * + * If no `'response'` handler is added, then the response will be + * entirely discarded. However, if a `'response'` event handler is added, + * then the data from the response object **must** be consumed, either by + * calling `response.read()` whenever there is a `'readable'` event, or + * by adding a `'data'` handler, or by calling the `.resume()` method. + * Until the data is consumed, the `'end'` event will not fire. Also, until + * the data is read it will consume memory that can eventually lead to a + * 'process out of memory' error. + * + * For backward compatibility, `res` will only emit `'error'` if there is an`'error'` listener registered. + * + * Node.js does not check whether Content-Length and the length of the + * body which has been transmitted are equal or not. + */ + class ClientRequest { + /** + * The `request.aborted` property will be `true` if the request has + * been aborted. + * @deprecated Since v17.0.0,v16.12.0 - Check `destroyed` instead. + */ + aborted: boolean; + /** + * The request host. + */ + host: string; + /** + * The request protocol. + */ + protocol: string; + /** + * When sending request through a keep-alive enabled agent, the underlying socket + * might be reused. But if server closes connection at unfortunate time, client + * may run into a 'ECONNRESET' error. + * + * ```js + * const http = require('http'); + * + * // Server has a 5 seconds keep-alive timeout by default + * http + * .createServer((req, res) => { + * res.write('hello\n'); + * res.end(); + * }) + * .listen(3000); + * + * setInterval(() => { + * // Adapting a keep-alive agent + * http.get('http://localhost:3000', { agent }, (res) => { + * res.on('data', (data) => { + * // Do nothing + * }); + * }); + * }, 5000); // Sending request on 5s interval so it's easy to hit idle timeout + * ``` + * + * By marking a request whether it reused socket or not, we can do + * automatic error retry base on it. + * + * ```js + * const http = require('http'); + * const agent = new http.Agent({ keepAlive: true }); + * + * function retriableRequest() { + * const req = http + * .get('http://localhost:3000', { agent }, (res) => { + * // ... + * }) + * .on('error', (err) => { + * // Check if retry is needed + * if (req.reusedSocket && err.code === 'ECONNRESET') { + * retriableRequest(); + * } + * }); + * } + * + * retriableRequest(); + * ``` + */ + reusedSocket: boolean; + /** + * Limits maximum response headers count. If set to 0, no limit will be applied. + */ + maxHeadersCount: number; + constructor( + url: string | URL | ClientRequestArgs, + cb?: (res: IncomingMessage) => void, + ); + /** + * The request method. + */ + method: string; + /** + * The request path. + */ + path: string; + /** + * Marks the request as aborting. Calling this will cause remaining data + * in the response to be dropped and the socket to be destroyed. + * @deprecated Since v14.1.0,v13.14.0 - Use `destroy` instead. + */ + abort(): void; + /** + * Once a socket is assigned to this request and is connected `socket.setTimeout()` will be called. + * @param timeout Milliseconds before a request times out. + * @param callback Optional function to be called when a timeout occurs. Same as binding to the `'timeout'` event. + */ + setTimeout(timeout: number, callback?: () => void): this; + /** + * Sets a single header value for the header object. + * @param name Header name + * @param value Header value + */ + setHeader( + name: string, + value: number | string | ReadonlyArray, + ): this; + /** + * Gets the value of HTTP header with the given name. If such a name doesn't + * exist in message, it will be `undefined`. + * @param name Name of header + */ + getHeader(name: string): number | string | string[] | undefined; + /** + * Removes a header that is queued for implicit sending. + * + * ```js + * outgoingMessage.removeHeader('Content-Encoding'); + * ``` + * @param name Header name + */ + removeHeader(name: string): void; + /** + * Compulsorily flushes the message headers + * + * For efficiency reason, Node.js normally buffers the message headers + * until `outgoingMessage.end()` is called or the first chunk of message data + * is written. It then tries to pack the headers and data into a single TCP + * packet. + * + * It is usually desired (it saves a TCP round-trip), but not when the first + * data is not sent until possibly much later. `outgoingMessage.flushHeaders()`bypasses the optimization and kickstarts the request. + */ + flushHeaders(): void; + /** + * Once a socket is assigned to this request and is connected `socket.setNoDelay()` will be called. + */ + setNoDelay(noDelay?: boolean): void; + /** + * Once a socket is assigned to this request and is connected `socket.setKeepAlive()` will be called. + */ + setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; + /** + * Returns an array containing the unique names of the current outgoing raw + * headers. Header names are returned with their exact casing being set. + * + * ```js + * request.setHeader('Foo', 'bar'); + * request.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']); + * + * const headerNames = request.getRawHeaderNames(); + * // headerNames === ['Foo', 'Set-Cookie'] + * ``` + */ + getRawHeaderNames(): string[]; + /** + * @deprecated + */ + addListener(event: "abort", listener: () => void): this; + addListener(event: "continue", listener: () => void): this; + addListener( + event: "information", + listener: (info: InformationEvent) => void, + ): this; + addListener( + event: "response", + listener: (response: IncomingMessage) => void, + ): this; + addListener(event: "timeout", listener: () => void): this; + addListener(event: "close", listener: () => void): this; + addListener(event: "drain", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "finish", listener: () => void): this; + addListener(event: "pipe", listener: (src: stream.Readable) => void): this; + addListener( + event: "unpipe", + listener: (src: stream.Readable) => void, + ): this; + addListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * @deprecated + */ + on(event: "abort", listener: () => void): this; + on(event: "continue", listener: () => void): this; + on(event: "information", listener: (info: InformationEvent) => void): this; + on(event: "response", listener: (response: IncomingMessage) => void): this; + on(event: "timeout", listener: () => void): this; + on(event: "close", listener: () => void): this; + on(event: "drain", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "finish", listener: () => void): this; + on(event: "pipe", listener: (src: stream.Readable) => void): this; + on(event: "unpipe", listener: (src: stream.Readable) => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + /** + * @deprecated + */ + once(event: "abort", listener: () => void): this; + once(event: "continue", listener: () => void): this; + once( + event: "information", + listener: (info: InformationEvent) => void, + ): this; + once( + event: "response", + listener: (response: IncomingMessage) => void, + ): this; + once(event: "timeout", listener: () => void): this; + once(event: "close", listener: () => void): this; + once(event: "drain", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "finish", listener: () => void): this; + once(event: "pipe", listener: (src: stream.Readable) => void): this; + once(event: "unpipe", listener: (src: stream.Readable) => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + /** + * @deprecated + */ + prependListener(event: "abort", listener: () => void): this; + prependListener(event: "continue", listener: () => void): this; + prependListener( + event: "information", + listener: (info: InformationEvent) => void, + ): this; + prependListener( + event: "response", + listener: (response: IncomingMessage) => void, + ): this; + prependListener(event: "timeout", listener: () => void): this; + prependListener(event: "close", listener: () => void): this; + prependListener(event: "drain", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener(event: "finish", listener: () => void): this; + prependListener( + event: "pipe", + listener: (src: stream.Readable) => void, + ): this; + prependListener( + event: "unpipe", + listener: (src: stream.Readable) => void, + ): this; + prependListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + /** + * @deprecated + */ + prependOnceListener(event: "abort", listener: () => void): this; + prependOnceListener(event: "continue", listener: () => void): this; + prependOnceListener( + event: "information", + listener: (info: InformationEvent) => void, + ): this; + prependOnceListener( + event: "response", + listener: (response: IncomingMessage) => void, + ): this; + prependOnceListener(event: "timeout", listener: () => void): this; + prependOnceListener(event: "close", listener: () => void): this; + prependOnceListener(event: "drain", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener(event: "finish", listener: () => void): this; + prependOnceListener( + event: "pipe", + listener: (src: stream.Readable) => void, + ): this; + prependOnceListener( + event: "unpipe", + listener: (src: stream.Readable) => void, + ): this; + prependOnceListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + } + /** + * An `IncomingMessage` object is created by {@link Server} or {@link ClientRequest} and passed as the first argument to the `'request'` and `'response'` event respectively. It may be used to + * access response + * status, headers and data. + * + * Different from its `socket` value which is a subclass of `stream.Duplex`, the`IncomingMessage` itself extends `stream.Readable` and is created separately to + * parse and emit the incoming HTTP headers and payload, as the underlying socket + * may be reused multiple times in case of keep-alive. + */ + class IncomingMessage extends stream.Readable { + /** + * The `message.aborted` property will be `true` if the request has + * been aborted. + * @deprecated Since v17.0.0,v16.12.0 - Check `message.destroyed` from stream.Readable. + */ + aborted: boolean; + /** + * In case of server request, the HTTP version sent by the client. In the case of + * client response, the HTTP version of the connected-to server. + * Probably either `'1.1'` or `'1.0'`. + * + * Also `message.httpVersionMajor` is the first integer and`message.httpVersionMinor` is the second. + */ + httpVersion: string; + httpVersionMajor: number; + httpVersionMinor: number; + /** + * The `message.complete` property will be `true` if a complete HTTP message has + * been received and successfully parsed. + * + * This property is particularly useful as a means of determining if a client or + * server fully transmitted a message before a connection was terminated: + * + * ```js + * const req = http.request({ + * host: '127.0.0.1', + * port: 8080, + * method: 'POST' + * }, (res) => { + * res.resume(); + * res.on('end', () => { + * if (!res.complete) + * console.error( + * 'The connection was terminated while the message was still being sent'); + * }); + * }); + * ``` + */ + complete: boolean; + /** + * The request/response headers object. + * + * Key-value pairs of header names and values. Header names are lower-cased. + * + * ```js + * // Prints something like: + * // + * // { 'user-agent': 'curl/7.22.0', + * // host: '127.0.0.1:8000', + * // accept: '*' } + * console.log(request.getHeaders()); + * ``` + * + * Duplicates in raw headers are handled in the following ways, depending on the + * header name: + * + * * Duplicates of `age`, `authorization`, `content-length`, `content-type`,`etag`, `expires`, `from`, `host`, `if-modified-since`, `if-unmodified-since`,`last-modified`, `location`, + * `max-forwards`, `proxy-authorization`, `referer`,`retry-after`, `server`, or `user-agent` are discarded. + * * `set-cookie` is always an array. Duplicates are added to the array. + * * For duplicate `cookie` headers, the values are joined together with '; '. + * * For all other headers, the values are joined together with ', '. + */ + headers: IncomingHttpHeaders; + /** + * The raw request/response headers list exactly as they were received. + * + * The keys and values are in the same list. It is _not_ a + * list of tuples. So, the even-numbered offsets are key values, and the + * odd-numbered offsets are the associated values. + * + * Header names are not lowercased, and duplicates are not merged. + * + * ```js + * // Prints something like: + * // + * // [ 'user-agent', + * // 'this is invalid because there can be only one', + * // 'User-Agent', + * // 'curl/7.22.0', + * // 'Host', + * // '127.0.0.1:8000', + * // 'ACCEPT', + * // '*' ] + * console.log(request.rawHeaders); + * ``` + */ + rawHeaders: string[]; + /** + * The request/response trailers object. Only populated at the `'end'` event. + */ + trailers: Dict; + /** + * The raw request/response trailer keys and values exactly as they were + * received. Only populated at the `'end'` event. + */ + rawTrailers: string[]; + /** + * Calls `message.socket.setTimeout(msecs, callback)`. + */ + setTimeout(msecs: number, callback?: () => void): this; + /** + * **Only valid for request obtained from {@link Server}.** + * + * The request method as a string. Read only. Examples: `'GET'`, `'DELETE'`. + */ + method?: string | undefined; + /** + * **Only valid for request obtained from {@link Server}.** + * + * Request URL string. This contains only the URL that is present in the actual + * HTTP request. Take the following request: + * + * ```http + * GET /status?name=ryan HTTP/1.1 + * Accept: text/plain + * ``` + * + * To parse the URL into its parts: + * + * ```js + * new URL(request.url, `http://${request.getHeaders().host}`); + * ``` + * + * When `request.url` is `'/status?name=ryan'` and`request.getHeaders().host` is `'localhost:3000'`: + * + * ```console + * $ node + * > new URL(request.url, `http://${request.getHeaders().host}`) + * URL { + * href: 'http://localhost:3000/status?name=ryan', + * origin: 'http://localhost:3000', + * protocol: 'http:', + * username: '', + * password: '', + * host: 'localhost:3000', + * hostname: 'localhost', + * port: '3000', + * pathname: '/status', + * search: '?name=ryan', + * searchParams: URLSearchParams { 'name' => 'ryan' }, + * hash: '' + * } + * ``` + */ + url?: string | undefined; + /** + * **Only valid for response obtained from {@link ClientRequest}.** + * + * The 3-digit HTTP response status code. E.G. `404`. + */ + statusCode?: number | undefined; + /** + * **Only valid for response obtained from {@link ClientRequest}.** + * + * The HTTP response status message (reason phrase). E.G. `OK` or `Internal Server Error`. + */ + statusMessage?: string | undefined; + /** + * Calls `destroy()` on the socket that received the `IncomingMessage`. If `error`is provided, an `'error'` event is emitted on the socket and `error` is passed + * as an argument to any listeners on the event. + */ + destroy(error?: Error): this; + } + const METHODS: string[]; + const STATUS_CODES: { + [errorCode: number]: string | undefined; + [errorCode: string]: string | undefined; + }; + // although RequestOptions are passed as ClientRequestArgs to ClientRequest directly, + // create interface RequestOptions would make the naming more clear to developers + interface RequestOptions extends ClientRequestArgs {} + /** + * `options` in `socket.connect()` are also supported. + * + * Node.js maintains several connections per server to make HTTP requests. + * This function allows one to transparently issue requests. + * + * `url` can be a string or a `URL` object. If `url` is a + * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object. + * + * If both `url` and `options` are specified, the objects are merged, with the`options` properties taking precedence. + * + * The optional `callback` parameter will be added as a one-time listener for + * the `'response'` event. + * + * `http.request()` returns an instance of the {@link ClientRequest} class. The `ClientRequest` instance is a writable stream. If one needs to + * upload a file with a POST request, then write to the `ClientRequest` object. + * + * ```js + * const http = require('http'); + * + * const postData = JSON.stringify({ + * 'msg': 'Hello World!' + * }); + * + * const options = { + * hostname: 'www.google.com', + * port: 80, + * path: '/upload', + * method: 'POST', + * headers: { + * 'Content-Type': 'application/json', + * 'Content-Length': Buffer.byteLength(postData) + * } + * }; + * + * const req = http.request(options, (res) => { + * console.log(`STATUS: ${res.statusCode}`); + * console.log(`HEADERS: ${JSON.stringify(res.headers)}`); + * res.setEncoding('utf8'); + * res.on('data', (chunk) => { + * console.log(`BODY: ${chunk}`); + * }); + * res.on('end', () => { + * console.log('No more data in response.'); + * }); + * }); + * + * req.on('error', (e) => { + * console.error(`problem with request: ${e.message}`); + * }); + * + * // Write data to request body + * req.write(postData); + * req.end(); + * ``` + * + * In the example `req.end()` was called. With `http.request()` one + * must always call `req.end()` to signify the end of the request - + * even if there is no data being written to the request body. + * + * If any error is encountered during the request (be that with DNS resolution, + * TCP level errors, or actual HTTP parse errors) an `'error'` event is emitted + * on the returned request object. As with all `'error'` events, if no listeners + * are registered the error will be thrown. + * + * There are a few special headers that should be noted. + * + * * Sending a 'Connection: keep-alive' will notify Node.js that the connection to + * the server should be persisted until the next request. + * * Sending a 'Content-Length' header will disable the default chunked encoding. + * * Sending an 'Expect' header will immediately send the request headers. + * Usually, when sending 'Expect: 100-continue', both a timeout and a listener + * for the `'continue'` event should be set. See RFC 2616 Section 8.2.3 for more + * information. + * * Sending an Authorization header will override using the `auth` option + * to compute basic authentication. + * + * Example using a `URL` as `options`: + * + * ```js + * const options = new URL('http://abc:xyz@example.com'); + * + * const req = http.request(options, (res) => { + * // ... + * }); + * ``` + * + * In a successful request, the following events will be emitted in the following + * order: + * + * * `'socket'` + * * `'response'` + * * `'data'` any number of times, on the `res` object + * (`'data'` will not be emitted at all if the response body is empty, for + * instance, in most redirects) + * * `'end'` on the `res` object + * * `'close'` + * + * In the case of a connection error, the following events will be emitted: + * + * * `'socket'` + * * `'error'` + * * `'close'` + * + * In the case of a premature connection close before the response is received, + * the following events will be emitted in the following order: + * + * * `'socket'` + * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'` + * * `'close'` + * + * In the case of a premature connection close after the response is received, + * the following events will be emitted in the following order: + * + * * `'socket'` + * * `'response'` + * * `'data'` any number of times, on the `res` object + * * (connection closed here) + * * `'aborted'` on the `res` object + * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`. + * * `'close'` + * * `'close'` on the `res` object + * + * If `req.destroy()` is called before a socket is assigned, the following + * events will be emitted in the following order: + * + * * (`req.destroy()` called here) + * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'` + * * `'close'` + * + * If `req.destroy()` is called before the connection succeeds, the following + * events will be emitted in the following order: + * + * * `'socket'` + * * (`req.destroy()` called here) + * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'` + * * `'close'` + * + * If `req.destroy()` is called after the response is received, the following + * events will be emitted in the following order: + * + * * `'socket'` + * * `'response'` + * * `'data'` any number of times, on the `res` object + * * (`req.destroy()` called here) + * * `'aborted'` on the `res` object + * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`. + * * `'close'` + * * `'close'` on the `res` object + * + * If `req.abort()` is called before a socket is assigned, the following + * events will be emitted in the following order: + * + * * (`req.abort()` called here) + * * `'abort'` + * * `'close'` + * + * If `req.abort()` is called before the connection succeeds, the following + * events will be emitted in the following order: + * + * * `'socket'` + * * (`req.abort()` called here) + * * `'abort'` + * * `'error'` with an error with message `'Error: socket hang up'` and code`'ECONNRESET'` + * * `'close'` + * + * If `req.abort()` is called after the response is received, the following + * events will be emitted in the following order: + * + * * `'socket'` + * * `'response'` + * * `'data'` any number of times, on the `res` object + * * (`req.abort()` called here) + * * `'abort'` + * * `'aborted'` on the `res` object + * * `'error'` on the `res` object with an error with message`'Error: aborted'` and code `'ECONNRESET'`. + * * `'close'` + * * `'close'` on the `res` object + * + * Setting the `timeout` option or using the `setTimeout()` function will + * not abort the request or do anything besides add a `'timeout'` event. + * + * Passing an `AbortSignal` and then calling `abort` on the corresponding`AbortController` will behave the same way as calling `.destroy()` on the + * request itself. + */ + function request( + options: RequestOptions | string | URL, + callback?: (res: IncomingMessage) => void, + ): ClientRequest; + function request( + url: string | URL, + options: RequestOptions, + callback?: (res: IncomingMessage) => void, + ): ClientRequest; + /** + * Since most requests are GET requests without bodies, Node.js provides this + * convenience method. The only difference between this method and {@link request} is that it sets the method to GET and calls `req.end()`automatically. The callback must take care to consume the + * response + * data for reasons stated in {@link ClientRequest} section. + * + * The `callback` is invoked with a single argument that is an instance of {@link IncomingMessage}. + * + * JSON fetching example: + * + * ```js + * http.get('http://localhost:8000/', (res) => { + * const { statusCode } = res; + * const contentType = res.headers['content-type']; + * + * let error; + * // Any 2xx status code signals a successful response but + * // here we're only checking for 200. + * if (statusCode !== 200) { + * error = new Error('Request Failed.\n' + + * `Status Code: ${statusCode}`); + * } else if (!/^application\/json/.test(contentType)) { + * error = new Error('Invalid content-type.\n' + + * `Expected application/json but received ${contentType}`); + * } + * if (error) { + * console.error(error.message); + * // Consume response data to free up memory + * res.resume(); + * return; + * } + * + * res.setEncoding('utf8'); + * let rawData = ''; + * res.on('data', (chunk) => { rawData += chunk; }); + * res.on('end', () => { + * try { + * const parsedData = JSON.parse(rawData); + * console.log(parsedData); + * } catch (e) { + * console.error(e.message); + * } + * }); + * }).on('error', (e) => { + * console.error(`Got error: ${e.message}`); + * }); + * + * // Create a local server to receive data from + * const server = http.createServer((req, res) => { + * res.writeHead(200, { 'Content-Type': 'application/json' }); + * res.end(JSON.stringify({ + * data: 'Hello World!' + * })); + * }); + * + * server.listen(8000); + * ``` + * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`. Properties that are inherited from the prototype are ignored. + */ + function get( + options: RequestOptions | string | URL, + callback?: (res: IncomingMessage) => void, + ): ClientRequest; + function get( + url: string | URL, + options: RequestOptions, + callback?: (res: IncomingMessage) => void, + ): ClientRequest; + /** + * Read-only property specifying the maximum allowed size of HTTP headers in bytes. + * Defaults to 16KB. Configurable using the `--max-http-header-size` CLI option. + */ + const maxHeaderSize: number; +} +declare module "node:http" { + export * from "http"; +} +// XXX: temporary types till theres a proper http(s) module +declare module "https" { + export * from "http"; +} +declare module "node:https" { + export * from "http"; +} diff --git a/packages/bun-types/images/README.md b/packages/bun-types/images/README.md new file mode 100644 index 0000000000..c300d46cff --- /dev/null +++ b/packages/bun-types/images/README.md @@ -0,0 +1,15 @@ +Can reference images included here in code comments, ex + +```ts +/** + * ## Large headline + * + * + * **Images** are relative to images/ directory + *![image_description](media://image_filehere.gif) + * + */ +export class MyUtil { + constructor(public config: T) {} +} +``` diff --git a/packages/bun-types/index.d.ts b/packages/bun-types/index.d.ts new file mode 100644 index 0000000000..ea734ffefb --- /dev/null +++ b/packages/bun-types/index.d.ts @@ -0,0 +1,36 @@ +/* eslint-disable */ +// Type definitions for bun 0.0 +// Project: https://github.com/oven-sh/bun +// Definitions by: Jarred Sumner +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// diff --git a/packages/bun-types/index.js b/packages/bun-types/index.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/bun-types/jsc.d.ts b/packages/bun-types/jsc.d.ts new file mode 100644 index 0000000000..c4dce65dfb --- /dev/null +++ b/packages/bun-types/jsc.d.ts @@ -0,0 +1,60 @@ +declare module "bun:jsc" { + export function describe(value: any): string; + export function describeArray(args: any[]): string; + export function gcAndSweep(): void; + export function fullGC(): void; + export function edenGC(): void; + export function heapSize(): number; + export function heapStats(): { + heapSize: number; + heapCapacity: number; + extraMemorySize: number; + objectCount: number; + protectedObjectCount: number; + globalObjectCount: number; + protectedGlobalObjectCount: number; + objectTypeCounts: Record; + protectedObjectTypeCounts: Record; + }; + export function memoryUsage(): { + current: number; + peak: number; + currentCommit: number; + peakCommit: number; + pageFaults: number; + }; + export function getRandomSeed(): number; + export function setRandomSeed(value: number): void; + export function isRope(input: string): boolean; + export function callerSourceOrigin(): string; + export function noFTL(func: Function): Function; + export function noOSRExitFuzzing(func: Function): Function; + export function optimizeNextInvocation(func: Function): Function; + export function numberOfDFGCompiles(func: Function): number; + export function releaseWeakRefs(): void; + export function totalCompileTime(func: Function): number; + export function reoptimizationRetryCount(func: Function): number; + export function drainMicrotasks(): void; + + /** + * This returns objects which native code has explicitly protected from being + * garbage collected + * + * By calling this function you create another reference to the object, which + * will further prevent it from being garbage collected + * + * This function is mostly a debugging tool for bun itself. + * + * Warning: not all objects returned are supposed to be observable from JavaScript + */ + export function getProtectedObjects(): any[]; + + /** + * Start a remote debugging socket server on the given port. + * + * This exposes JavaScriptCore's built-in debugging server. + * + * This is untested. May not be supported yet on macOS + */ + export function startRemoteDebugger(host?: string, port?: number): void; +} diff --git a/packages/bun-types/module.d.ts b/packages/bun-types/module.d.ts new file mode 100644 index 0000000000..4a39e01640 --- /dev/null +++ b/packages/bun-types/module.d.ts @@ -0,0 +1,16 @@ +declare module "node:module" { + export * from "module"; +} + +declare module "module" { + export function createRequire(filename: string): NodeJS.Require; + export function _resolveFileName( + path: string, + parent: string, + isMain: boolean, + ): string; + /** + * Bun's module cache is not exposed but this property exists for compatibility. + */ + export var _cache: {}; +} diff --git a/packages/bun-types/os.d.ts b/packages/bun-types/os.d.ts new file mode 100644 index 0000000000..a357790004 --- /dev/null +++ b/packages/bun-types/os.d.ts @@ -0,0 +1,437 @@ +/** + * The `os` module provides operating system-related utility methods and + * properties. It can be accessed using: + * + * ```js + * const os = require('os'); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/os.js) + */ +declare module "os" { + interface CpuInfo { + model: string; + speed: number; + times: { + user: number; + nice: number; + sys: number; + idle: number; + irq: number; + }; + } + interface NetworkInterfaceBase { + address: string; + netmask: string; + mac: string; + internal: boolean; + cidr: string | null; + } + interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase { + family: "IPv4"; + } + interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase { + family: "IPv6"; + scopeid: number; + } + interface UserInfo { + username: T; + uid: number; + gid: number; + shell: T; + homedir: T; + } + type NetworkInterfaceInfo = + | NetworkInterfaceInfoIPv4 + | NetworkInterfaceInfoIPv6; + /** + * Returns the host name of the operating system as a string. + */ + function hostname(): string; + /** + * Returns an array containing the 1, 5, and 15 minute load averages. + * + * The load average is a measure of system activity calculated by the operating + * system and expressed as a fractional number. + * + * The load average is a Unix-specific concept. On Windows, the return value is + * always `[0, 0, 0]`. + */ + function loadavg(): number[]; + /** + * Returns the system uptime in number of seconds. + */ + function uptime(): number; + /** + * Returns the amount of free system memory in bytes as an integer. + */ + function freemem(): number; + /** + * Returns the total amount of system memory in bytes as an integer. + */ + function totalmem(): number; + /** + * Returns an array of objects containing information about each logical CPU core. + * + * The properties included on each object include: + * + * ```js + * [ + * { + * model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz', + * speed: 2926, + * times: { + * user: 252020, + * nice: 0, + * sys: 30340, + * idle: 1070356870, + * irq: 0 + * } + * }, + * { + * model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz', + * speed: 2926, + * times: { + * user: 306960, + * nice: 0, + * sys: 26980, + * idle: 1071569080, + * irq: 0 + * } + * }, + * { + * model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz', + * speed: 2926, + * times: { + * user: 248450, + * nice: 0, + * sys: 21750, + * idle: 1070919370, + * irq: 0 + * } + * }, + * { + * model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz', + * speed: 2926, + * times: { + * user: 256880, + * nice: 0, + * sys: 19430, + * idle: 1070905480, + * irq: 20 + * } + * }, + * ] + * ``` + * + * `nice` values are POSIX-only. On Windows, the `nice` values of all processors + * are always 0. + */ + function cpus(): CpuInfo[]; + /** + * Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it + * returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows. + * + * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for additional information + * about the output of running [`uname(3)`](https://linux.die.net/man/3/uname) on various operating systems. + */ + function type(): string; + /** + * Returns the operating system as a string. + * + * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `GetVersionExW()` is used. See + * [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information. + */ + function release(): string; + /** + * Returns an object containing network interfaces that have been assigned a + * network address. + * + * Each key on the returned object identifies a network interface. The associated + * value is an array of objects that each describe an assigned network address. + * + * The properties available on the assigned network address object include: + * + * ```js + * { + * lo: [ + * { + * address: '127.0.0.1', + * netmask: '255.0.0.0', + * family: 'IPv4', + * mac: '00:00:00:00:00:00', + * internal: true, + * cidr: '127.0.0.1/8' + * }, + * { + * address: '::1', + * netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', + * family: 'IPv6', + * mac: '00:00:00:00:00:00', + * scopeid: 0, + * internal: true, + * cidr: '::1/128' + * } + * ], + * eth0: [ + * { + * address: '192.168.1.108', + * netmask: '255.255.255.0', + * family: 'IPv4', + * mac: '01:02:03:0a:0b:0c', + * internal: false, + * cidr: '192.168.1.108/24' + * }, + * { + * address: 'fe80::a00:27ff:fe4e:66a1', + * netmask: 'ffff:ffff:ffff:ffff::', + * family: 'IPv6', + * mac: '01:02:03:0a:0b:0c', + * scopeid: 1, + * internal: false, + * cidr: 'fe80::a00:27ff:fe4e:66a1/64' + * } + * ] + * } + * ``` + */ + function networkInterfaces(): Dict; + /** + * Returns the string path of the current user's home directory. + * + * On POSIX, it uses the `$HOME` environment variable if defined. Otherwise it + * uses the [effective UID](https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID) to look up the user's home directory. + * + * On Windows, it uses the `USERPROFILE` environment variable if defined. + * Otherwise it uses the path to the profile directory of the current user. + */ + function homedir(): string; + /** + * Returns information about the currently effective user. On POSIX platforms, + * this is typically a subset of the password file. The returned object includes + * the `username`, `uid`, `gid`, `shell`, and `homedir`. On Windows, the `uid` and`gid` fields are `-1`, and `shell` is `null`. + * + * The value of `homedir` returned by `os.userInfo()` is provided by the operating + * system. This differs from the result of `os.homedir()`, which queries + * environment variables for the home directory before falling back to the + * operating system response. + * + * Throws a `SystemError` if a user has no `username` or `homedir`. + */ + function userInfo(options: { encoding: "buffer" }): UserInfo; + function userInfo(options?: { encoding: BufferEncoding }): UserInfo; + type SignalConstants = { + [key in Signals]: number; + }; + namespace constants { + const UV_UDP_REUSEADDR: number; + namespace signals {} + const signals: SignalConstants; + namespace errno { + const E2BIG: number; + const EACCES: number; + const EADDRINUSE: number; + const EADDRNOTAVAIL: number; + const EAFNOSUPPORT: number; + const EAGAIN: number; + const EALREADY: number; + const EBADF: number; + const EBADMSG: number; + const EBUSY: number; + const ECANCELED: number; + const ECHILD: number; + const ECONNABORTED: number; + const ECONNREFUSED: number; + const ECONNRESET: number; + const EDEADLK: number; + const EDESTADDRREQ: number; + const EDOM: number; + const EDQUOT: number; + const EEXIST: number; + const EFAULT: number; + const EFBIG: number; + const EHOSTUNREACH: number; + const EIDRM: number; + const EILSEQ: number; + const EINPROGRESS: number; + const EINTR: number; + const EINVAL: number; + const EIO: number; + const EISCONN: number; + const EISDIR: number; + const ELOOP: number; + const EMFILE: number; + const EMLINK: number; + const EMSGSIZE: number; + const EMULTIHOP: number; + const ENAMETOOLONG: number; + const ENETDOWN: number; + const ENETRESET: number; + const ENETUNREACH: number; + const ENFILE: number; + const ENOBUFS: number; + const ENODATA: number; + const ENODEV: number; + const ENOENT: number; + const ENOEXEC: number; + const ENOLCK: number; + const ENOLINK: number; + const ENOMEM: number; + const ENOMSG: number; + const ENOPROTOOPT: number; + const ENOSPC: number; + const ENOSR: number; + const ENOSTR: number; + const ENOSYS: number; + const ENOTCONN: number; + const ENOTDIR: number; + const ENOTEMPTY: number; + const ENOTSOCK: number; + const ENOTSUP: number; + const ENOTTY: number; + const ENXIO: number; + const EOPNOTSUPP: number; + const EOVERFLOW: number; + const EPERM: number; + const EPIPE: number; + const EPROTO: number; + const EPROTONOSUPPORT: number; + const EPROTOTYPE: number; + const ERANGE: number; + const EROFS: number; + const ESPIPE: number; + const ESRCH: number; + const ESTALE: number; + const ETIME: number; + const ETIMEDOUT: number; + const ETXTBSY: number; + const EWOULDBLOCK: number; + const EXDEV: number; + const WSAEINTR: number; + const WSAEBADF: number; + const WSAEACCES: number; + const WSAEFAULT: number; + const WSAEINVAL: number; + const WSAEMFILE: number; + const WSAEWOULDBLOCK: number; + const WSAEINPROGRESS: number; + const WSAEALREADY: number; + const WSAENOTSOCK: number; + const WSAEDESTADDRREQ: number; + const WSAEMSGSIZE: number; + const WSAEPROTOTYPE: number; + const WSAENOPROTOOPT: number; + const WSAEPROTONOSUPPORT: number; + const WSAESOCKTNOSUPPORT: number; + const WSAEOPNOTSUPP: number; + const WSAEPFNOSUPPORT: number; + const WSAEAFNOSUPPORT: number; + const WSAEADDRINUSE: number; + const WSAEADDRNOTAVAIL: number; + const WSAENETDOWN: number; + const WSAENETUNREACH: number; + const WSAENETRESET: number; + const WSAECONNABORTED: number; + const WSAECONNRESET: number; + const WSAENOBUFS: number; + const WSAEISCONN: number; + const WSAENOTCONN: number; + const WSAESHUTDOWN: number; + const WSAETOOMANYREFS: number; + const WSAETIMEDOUT: number; + const WSAECONNREFUSED: number; + const WSAELOOP: number; + const WSAENAMETOOLONG: number; + const WSAEHOSTDOWN: number; + const WSAEHOSTUNREACH: number; + const WSAENOTEMPTY: number; + const WSAEPROCLIM: number; + const WSAEUSERS: number; + const WSAEDQUOT: number; + const WSAESTALE: number; + const WSAEREMOTE: number; + const WSASYSNOTREADY: number; + const WSAVERNOTSUPPORTED: number; + const WSANOTINITIALISED: number; + const WSAEDISCON: number; + const WSAENOMORE: number; + const WSAECANCELLED: number; + const WSAEINVALIDPROCTABLE: number; + const WSAEINVALIDPROVIDER: number; + const WSAEPROVIDERFAILEDINIT: number; + const WSASYSCALLFAILURE: number; + const WSASERVICE_NOT_FOUND: number; + const WSATYPE_NOT_FOUND: number; + const WSA_E_NO_MORE: number; + const WSA_E_CANCELLED: number; + const WSAEREFUSED: number; + } + namespace priority { + const PRIORITY_LOW: number; + const PRIORITY_BELOW_NORMAL: number; + const PRIORITY_NORMAL: number; + const PRIORITY_ABOVE_NORMAL: number; + const PRIORITY_HIGH: number; + const PRIORITY_HIGHEST: number; + } + } + const devNull: string; + const EOL: string; + /** + * Returns the operating system CPU architecture for which the Node.js binary was + * compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, and `'x64'`. + * + * The return value is equivalent to `process.arch`. + */ + function arch(): string; + /** + * Returns a string identifying the kernel version. + * + * On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not + * available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information. + */ + function version(): string; + /** + * Returns a string identifying the operating system platform for which + * the Node.js binary was compiled. The value is set at compile time. + * Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`,`'openbsd'`, `'sunos'`, and `'win32'`. + * + * The return value is equivalent to `process.platform`. + */ + function platform(): Platform; + /** + * Returns the operating system's default directory for temporary files as a + * string. + */ + function tmpdir(): string; + /** + * Returns a string identifying the endianness of the CPU for which the Node.js + * binary was compiled. + * + * Possible values are `'BE'` for big endian and `'LE'` for little endian. + */ + function endianness(): "BE" | "LE"; + /** + * Returns the scheduling priority for the process specified by `pid`. If `pid` is + * not provided or is `0`, the priority of the current process is returned. + * @param [pid=0] The process ID to retrieve scheduling priority for. + */ + function getPriority(pid?: number): number; + /** + * Attempts to set the scheduling priority for the process specified by `pid`. If`pid` is not provided or is `0`, the process ID of the current process is used. + * + * The `priority` input must be an integer between `-20` (high priority) and `19`(low priority). Due to differences between Unix priority levels and Windows + * priority classes, `priority` is mapped to one of six priority constants in`os.constants.priority`. When retrieving a process priority level, this range + * mapping may cause the return value to be slightly different on Windows. To avoid + * confusion, set `priority` to one of the priority constants. + * + * On Windows, setting priority to `PRIORITY_HIGHEST` requires elevated user + * privileges. Otherwise the set priority will be silently reduced to`PRIORITY_HIGH`. + * @param [pid=0] The process ID to set scheduling priority for. + * @param priority The scheduling priority to assign to the process. + */ + function setPriority(priority: number): void; + function setPriority(pid: number, priority: number): void; +} +declare module "node:os" { + export * from "os"; +} diff --git a/packages/bun-types/package.json b/packages/bun-types/package.json new file mode 100644 index 0000000000..85efdcd569 --- /dev/null +++ b/packages/bun-types/package.json @@ -0,0 +1,18 @@ +{ + "name": "bun-types", + "types": "index.d.ts", + "private": true, + "repository": "https://github.com/oven-sh/bun-types", + "scripts": { + "build": "rm -rf ./dist && bun scripts/bundle.ts ./dist && bun run fmt", + "docs": "bun run build && typedoc", + "test": "tsd" + }, + "devDependencies": { + "tsd": "^0.22.0", + "typedoc": "^0.23.9" + }, + "tsd": { + "directory": "tests" + } +} diff --git a/packages/bun-types/path.d.ts b/packages/bun-types/path.d.ts new file mode 100644 index 0000000000..796521b619 --- /dev/null +++ b/packages/bun-types/path.d.ts @@ -0,0 +1,204 @@ +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "path/posix" { + /** + * A parsed path object generated by path.parse() or consumed by path.format(). + */ + interface ParsedPath { + /** + * The root of the path such as '/' or 'c:\' + */ + root: string; + /** + * The full directory path such as '/home/user/dir' or 'c:\path\dir' + */ + dir: string; + /** + * The file name including extension (if any) such as 'index.html' + */ + base: string; + /** + * The file extension (if any) such as '.html' + */ + ext: string; + /** + * The file name without extension (if any) such as 'index' + */ + name: string; + } + interface FormatInputPathObject { + /** + * The root of the path such as '/' or 'c:\' + */ + root?: string | undefined; + /** + * The full directory path such as '/home/user/dir' or 'c:\path\dir' + */ + dir?: string | undefined; + /** + * The file name including extension (if any) such as 'index.html' + */ + base?: string | undefined; + /** + * The file extension (if any) such as '.html' + */ + ext?: string | undefined; + /** + * The file name without extension (if any) such as 'index' + */ + name?: string | undefined; + } + + /** + * Normalize a string path, reducing '..' and '.' parts. + * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used. + * + * @param p string path to normalize. + */ + export function normalize(p: string): string; + /** + * Join all arguments together and normalize the resulting path. + * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. + * + * @param paths paths to join. + */ + export function join(...paths: string[]): string; + /** + * The right-most parameter is considered {to}. Other parameters are considered an array of {from}. + * + * Starting from leftmost {from} parameter, resolves {to} to an absolute path. + * + * If {to} isn't already absolute, {from} arguments are prepended in right to left order, + * until an absolute path is found. If after using all {from} paths still no absolute path is found, + * the current working directory is used as well. The resulting path is normalized, + * and trailing slashes are removed unless the path gets resolved to the root directory. + * + * @param pathSegments string paths to join. Non-string arguments are ignored. + */ + export function resolve(...pathSegments: string[]): string; + /** + * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory. + * + * @param path path to test. + */ + export function isAbsolute(p: string): boolean; + /** + * Solve the relative path from {from} to {to}. + * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve. + */ + export function relative(from: string, to: string): string; + /** + * Return the directory name of a path. Similar to the Unix dirname command. + * + * @param p the path to evaluate. + */ + export function dirname(p: string): string; + /** + * Return the last portion of a path. Similar to the Unix basename command. + * Often used to extract the file name from a fully qualified path. + * + * @param p the path to evaluate. + * @param ext optionally, an extension to remove from the result. + */ + export function basename(p: string, ext?: string): string; + /** + * Return the extension of the path, from the last '.' to end of string in the last portion of the path. + * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string + * + * @param p the path to evaluate. + */ + export function extname(p: string): string; + /** + * The platform-specific file separator. '\\' or '/'. + */ + export var sep: string; + /** + * The platform-specific file delimiter. ';' or ':'. + */ + export var delimiter: string; + /** + * Returns an object from a path string - the opposite of format(). + * + * @param pathString path to evaluate. + */ + export function parse(p: string): ParsedPath; + /** + * Returns a path string from an object - the opposite of parse(). + * + * @param pathString path to evaluate. + */ + export function format(pP: FormatInputPathObject): string; + /** + * On Windows systems only, returns an equivalent namespace-prefixed path for the given path. + * If path is not a string, path will be returned without modifications. + * This method is meaningful only on Windows system. + * On POSIX systems, the method is non-operational and always returns path without modifications. + */ + export function toNamespacedPath(path: string): string; +} + +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "path/win32" { + export * from "path/posix"; +} + +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "path" { + export * from "path/posix"; + export * as posix from "path/posix"; + export * as win32 from "path/win32"; +} + +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "node:path" { + export * from "path"; +} +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "node:path/posix" { + export * from "path/posix"; +} +/** + * The `path` module provides utilities for working with file and directory paths. + * It can be accessed using: + * + * ```js + * import path from 'path'; + * ``` + */ +declare module "node:path/win32" { + export * from "path/win32"; +} diff --git a/packages/bun-types/punycode.d.ts b/packages/bun-types/punycode.d.ts new file mode 100644 index 0000000000..14628386c0 --- /dev/null +++ b/packages/bun-types/punycode.d.ts @@ -0,0 +1,113 @@ +/** + * **The version of the punycode module bundled in Node.js is being deprecated.**In a future major version of Node.js this module will be removed. Users + * currently depending on the `punycode` module should switch to using the + * userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL + * encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`. + * + * The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It + * can be accessed using: + * + * ```js + * const punycode = require('punycode'); + * ``` + * + * [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is + * primarily intended for use in Internationalized Domain Names. Because host + * names in URLs are limited to ASCII characters only, Domain Names that contain + * non-ASCII characters must be converted into ASCII using the Punycode scheme. + * For instance, the Japanese character that translates into the English word,`'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent + * to `'example.com'`) is represented by Punycode as the ASCII string`'xn--fsq.com'`. + * + * The `punycode` module provides a simple implementation of the Punycode standard. + * + * The `punycode` module is a third-party dependency used by Node.js and + * made available to developers as a convenience. Fixes or other modifications to + * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project. + * @deprecated + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/punycode.js) + */ +declare module "punycode" { + /** + * The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only + * characters to the equivalent string of Unicode codepoints. + * + * ```js + * punycode.decode('maana-pta'); // 'mañana' + * punycode.decode('--dqo34k'); // '☃-⌘' + * ``` + */ + function decode(string: string): string; + /** + * The `punycode.encode()` method converts a string of Unicode codepoints to a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only characters. + * + * ```js + * punycode.encode('mañana'); // 'maana-pta' + * punycode.encode('☃-⌘'); // '--dqo34k' + * ``` + */ + function encode(string: string): string; + /** + * The `punycode.toUnicode()` method converts a string representing a domain name + * containing [Punycode](https://tools.ietf.org/html/rfc3492) encoded characters into Unicode. Only the [Punycode](https://tools.ietf.org/html/rfc3492) encoded parts of the domain name are be + * converted. + * + * ```js + * // decode domain names + * punycode.toUnicode('xn--maana-pta.com'); // 'mañana.com' + * punycode.toUnicode('xn----dqo34k.com'); // '☃-⌘.com' + * punycode.toUnicode('example.com'); // 'example.com' + * ``` + */ + function toUnicode(domain: string): string; + /** + * The `punycode.toASCII()` method converts a Unicode string representing an + * Internationalized Domain Name to [Punycode](https://tools.ietf.org/html/rfc3492). Only the non-ASCII parts of the + * domain name will be converted. Calling `punycode.toASCII()` on a string that + * already only contains ASCII characters will have no effect. + * + * ```js + * // encode domain names + * punycode.toASCII('mañana.com'); // 'xn--maana-pta.com' + * punycode.toASCII('☃-⌘.com'); // 'xn----dqo34k.com' + * punycode.toASCII('example.com'); // 'example.com' + * ``` + */ + function toASCII(domain: string): string; + /** + * @deprecated + * The version of the punycode module bundled in Node.js is being deprecated. + * In a future major version of Node.js this module will be removed. + * Users currently depending on the punycode module should switch to using + * the userland-provided Punycode.js module instead. + */ + const ucs2: ucs2; + interface ucs2 { + /** + * @deprecated + * The version of the punycode module bundled in Node.js is being deprecated. + * In a future major version of Node.js this module will be removed. + * Users currently depending on the punycode module should switch to using + * the userland-provided Punycode.js module instead. + */ + decode(string: string): number[]; + /** + * @deprecated + * The version of the punycode module bundled in Node.js is being deprecated. + * In a future major version of Node.js this module will be removed. + * Users currently depending on the punycode module should switch to using + * the userland-provided Punycode.js module instead. + */ + encode(codePoints: ReadonlyArray): string; + } + /** + * @deprecated + * The version of the punycode module bundled in Node.js is being deprecated. + * In a future major version of Node.js this module will be removed. + * Users currently depending on the punycode module should switch to using + * the userland-provided Punycode.js module instead. + */ + const version: string; +} +declare module "node:punycode" { + export * from "punycode"; +} diff --git a/packages/bun-types/querystring.d.ts b/packages/bun-types/querystring.d.ts new file mode 100644 index 0000000000..429a9ab6af --- /dev/null +++ b/packages/bun-types/querystring.d.ts @@ -0,0 +1,148 @@ +/** + * The `querystring` module provides utilities for parsing and formatting URL + * query strings. It can be accessed using: + * + * ```js + * const querystring = require('querystring'); + * ``` + * + * The `querystring` API is considered Legacy. While it is still maintained, + * new code should use the `URLSearchParams` API instead. + * @deprecated Legacy + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/querystring.js) + */ +declare module "querystring" { + interface StringifyOptions { + encodeURIComponent?: ((str: string) => string) | undefined; + } + interface ParseOptions { + maxKeys?: number | undefined; + decodeURIComponent?: ((str: string) => string) | undefined; + } + interface ParsedUrlQuery extends Dict {} + interface ParsedUrlQueryInput + extends Dict< + | string + | number + | boolean + | ReadonlyArray + | ReadonlyArray + | ReadonlyArray + | null + > {} + /** + * The `querystring.stringify()` method produces a URL query string from a + * given `obj` by iterating through the object's "own properties". + * + * It serializes the following types of values passed in `obj`:[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | + * [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) | + * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) | + * [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) | + * [string\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | + * [number\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) | + * [bigint\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) | + * [boolean\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) The numeric values must be finite. Any other input values will be coerced to + * empty strings. + * + * ```js + * querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' }); + * // Returns 'foo=bar&baz=qux&baz=quux&corge=' + * + * querystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':'); + * // Returns 'foo:bar;baz:qux' + * ``` + * + * By default, characters requiring percent-encoding within the query string will + * be encoded as UTF-8\. If an alternative encoding is required, then an alternative`encodeURIComponent` option will need to be specified: + * + * ```js + * // Assuming gbkEncodeURIComponent function already exists, + * + * querystring.stringify({ w: '中文', foo: 'bar' }, null, null, + * { encodeURIComponent: gbkEncodeURIComponent }); + * ``` + * @param obj The object to serialize into a URL query string + * @param [sep='&'] The substring used to delimit key and value pairs in the query string. + * @param [eq='='] . The substring used to delimit keys and values in the query string. + */ + function stringify( + obj?: ParsedUrlQueryInput, + sep?: string, + eq?: string, + options?: StringifyOptions, + ): string; + /** + * The `querystring.parse()` method parses a URL query string (`str`) into a + * collection of key and value pairs. + * + * For example, the query string `'foo=bar&abc=xyz&abc=123'` is parsed into: + * + * ```js + * { + * foo: 'bar', + * abc: ['xyz', '123'] + * } + * ``` + * + * The object returned by the `querystring.parse()` method _does not_prototypically inherit from the JavaScript `Object`. This means that typical`Object` methods such as `obj.toString()`, + * `obj.hasOwnProperty()`, and others + * are not defined and _will not work_. + * + * By default, percent-encoded characters within the query string will be assumed + * to use UTF-8 encoding. If an alternative character encoding is used, then an + * alternative `decodeURIComponent` option will need to be specified: + * + * ```js + * // Assuming gbkDecodeURIComponent function already exists... + * + * querystring.parse('w=%D6%D0%CE%C4&foo=bar', null, null, + * { decodeURIComponent: gbkDecodeURIComponent }); + * ``` + * @param str The URL query string to parse + * @param [sep='&'] The substring used to delimit key and value pairs in the query string. + * @param [eq='='] . The substring used to delimit keys and values in the query string. + */ + function parse( + str: string, + sep?: string, + eq?: string, + options?: ParseOptions, + ): ParsedUrlQuery; + /** + * The querystring.encode() function is an alias for querystring.stringify(). + */ + const encode: typeof stringify; + /** + * The querystring.decode() function is an alias for querystring.parse(). + */ + const decode: typeof parse; + /** + * The `querystring.escape()` method performs URL percent-encoding on the given`str` in a manner that is optimized for the specific requirements of URL + * query strings. + * + * The `querystring.escape()` method is used by `querystring.stringify()` and is + * generally not expected to be used directly. It is exported primarily to allow + * application code to provide a replacement percent-encoding implementation if + * necessary by assigning `querystring.escape` to an alternative function. + */ + // FIXME: querystring.escape is typed, but not in the polyfill + // function escape(str: string): string; + /** + * The `querystring.unescape()` method performs decoding of URL percent-encoded + * characters on the given `str`. + * + * The `querystring.unescape()` method is used by `querystring.parse()` and is + * generally not expected to be used directly. It is exported primarily to allow + * application code to provide a replacement decoding implementation if + * necessary by assigning `querystring.unescape` to an alternative function. + * + * By default, the `querystring.unescape()` method will attempt to use the + * JavaScript built-in `decodeURIComponent()` method to decode. If that fails, + * a safer equivalent that does not throw on malformed URLs will be used. + */ + // FIXME: querystring.unescape is typed, but not in the polyfill + // function unescape(str: string): string; +} +declare module "node:querystring" { + export * from "querystring"; +} diff --git a/packages/bun-types/scripts/bundle.ts b/packages/bun-types/scripts/bundle.ts new file mode 100644 index 0000000000..9733352e6c --- /dev/null +++ b/packages/bun-types/scripts/bundle.ts @@ -0,0 +1,72 @@ +import { file, write } from "bun"; +import { mkdirSync } from "fs"; +import { join, resolve } from "path"; +import { getDotTsFiles } from "./utils/getDotTsFiles"; + +// Combine all the .d.ts files into a single .d.ts file +// so that your editor loads the types faster +const BUN_VERSION = ( + process.env.BUN_VERSION || + Bun.version || + process.versions.bun +).replace(/^v/, ""); +const folder = resolve(process.argv.at(-1)!); +if (folder.endsWith("bundle.ts")) { + throw new Error("Pass a folder"); +} + +try { + mkdirSync(folder, { recursive: true }); +} catch (err) { + err; +} + +const header = await file(join(import.meta.dir, "..", "header.txt")).text(); +const filesToCat = (await getDotTsFiles("./")).filter( + (f) => !["./index.d.ts"].some((tf) => f === tf), +); + +const fileContents: string[] = []; + +for (let i = 0; i < filesToCat.length; i++) { + const name = filesToCat[i]; + fileContents.push( + "// " + + name + + "\n\n" + + (await file(resolve(import.meta.dir, "..", name)).text()) + + "\n", + ); +} + +const text = header.replace("{version}", BUN_VERSION) + fileContents.join("\n"); + +const destination = resolve(folder, "types.d.ts"); +await write(destination, text); + +const packageJSON = { + name: process.env.PACKAGE_NAME || "bun-types", + version: BUN_VERSION, + description: + "Type definitions for Bun, an incredibly fast JavaScript runtime", + types: "types.d.ts", + files: ["types.d.ts", "README.md"], + private: false, + keywords: ["bun", "bun.js", "types"], + repository: "https://github.com/oven-sh/bun-types", + homepage: "https://bun.sh", +}; + +await write( + resolve(folder, "package.json"), + JSON.stringify(packageJSON, null, 2) + "\n", +); + +await write( + resolve(folder, "README.md"), + file(resolve(import.meta.dir, "..", "README.md")), +); + +export {}; + +import "../index"; diff --git a/packages/bun-types/scripts/gpr.ts b/packages/bun-types/scripts/gpr.ts new file mode 100644 index 0000000000..a17cab4d50 --- /dev/null +++ b/packages/bun-types/scripts/gpr.ts @@ -0,0 +1,11 @@ +/// +import { join } from "path"; +import pkg from "../dist/package.json"; + +const __dirname = new URL(".", import.meta.url).pathname; + +pkg.name = `@oven-sh/${pkg.name}`; +await Bun.write( + join(__dirname, "..", "dist", "package.json"), + JSON.stringify(pkg), +); diff --git a/packages/bun-types/scripts/utils/getDotTsFiles.ts b/packages/bun-types/scripts/utils/getDotTsFiles.ts new file mode 100644 index 0000000000..ea9580a9c1 --- /dev/null +++ b/packages/bun-types/scripts/utils/getDotTsFiles.ts @@ -0,0 +1,25 @@ +import { readdir } from "node:fs/promises"; +import { join } from "node:path"; + +const allDotTsFiles: string[] = []; +export const getDotTsFiles = async ( + prefix = "", + folder: string = join(import.meta.dir, "..", ".."), + folderName?: string, +) => { + const files = await readdir(folder, { withFileTypes: true }); + for await (const file of files) { + if ( + file.isDirectory() && + (file.name === "node_modules" || file.name === "tests") + ) + continue; + + if (file.isDirectory()) + await getDotTsFiles(prefix, join(folder, file.name), file.name); + else if (file.name.endsWith(".d.ts")) + allDotTsFiles.push(prefix + join(folderName || "", file.name)); + } + + return allDotTsFiles; +}; diff --git a/packages/bun-types/sqlite.d.ts b/packages/bun-types/sqlite.d.ts new file mode 100644 index 0000000000..e908f02817 --- /dev/null +++ b/packages/bun-types/sqlite.d.ts @@ -0,0 +1,747 @@ +/** + * Fast SQLite3 driver for Bun.js + * @since v0.0.83 + * + * @example + * ```ts + * import { Database } from 'bun:sqlite'; + * + * var db = new Database('app.db'); + * db.query('SELECT * FROM users WHERE name = ?').all('John'); + * // => [{ id: 1, name: 'John' }] + * ``` + * + * The following types can be used when binding parameters: + * + * | JavaScript type | SQLite type | + * | -------------- | ----------- | + * | `string` | `TEXT` | + * | `number` | `INTEGER` or `DECIMAL` | + * | `boolean` | `INTEGER` (1 or 0) | + * | `Uint8Array` | `BLOB` | + * | `Buffer` | `BLOB` | + * | `bigint` | `INTEGER` | + * | `null` | `NULL` | + */ +declare module "bun:sqlite" { + export class Database { + /** + * Open or create a SQLite3 database + * + * @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database. + * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags. + * + * @example + * + * ```ts + * const db = new Database("mydb.sqlite"); + * db.run("CREATE TABLE foo (bar TEXT)"); + * db.run("INSERT INTO foo VALUES (?)", "baz"); + * console.log(db.query("SELECT * FROM foo").all()); + * ``` + * + * @example + * + * Open an in-memory database + * + * ```ts + * const db = new Database(":memory:"); + * db.run("CREATE TABLE foo (bar TEXT)"); + * db.run("INSERT INTO foo VALUES (?)", "hiiiiii"); + * console.log(db.query("SELECT * FROM foo").all()); + * ``` + * + * @example + * + * Open read-only + * + * ```ts + * const db = new Database("mydb.sqlite", {readonly: true}); + * ``` + */ + constructor( + filename?: string, + options?: + | number + | { + /** + * Open the database as read-only (no write operations, no create). + * + * Equivalent to {@link constants.SQLITE_OPEN_READONLY} + */ + readonly?: boolean; + /** + * Allow creating a new database + * + * Equivalent to {@link constants.SQLITE_OPEN_CREATE} + */ + create?: boolean; + /** + * Open the database as read-write + * + * Equivalent to {@link constants.SQLITE_OPEN_READWRITE} + */ + readwrite?: boolean; + }, + ); + + /** + * This is an alias of `new Database()` + * + * See {@link Database} + */ + static open( + filename: string, + options?: + | number + | { + /** + * Open the database as read-only (no write operations, no create). + * + * Equivalent to {@link constants.SQLITE_OPEN_READONLY} + */ + readonly?: boolean; + /** + * Allow creating a new database + * + * Equivalent to {@link constants.SQLITE_OPEN_CREATE} + */ + create?: boolean; + /** + * Open the database as read-write + * + * Equivalent to {@link constants.SQLITE_OPEN_READWRITE} + */ + readwrite?: boolean; + }, + ): Database; + + /** + * Execute a SQL query **without returning any results**. + * + * This does not cache the query, so if you want to run a query multiple times, you should use {@link prepare} instead. + * + * @example + * ```ts + * db.run("CREATE TABLE foo (bar TEXT)"); + * db.run("INSERT INTO foo VALUES (?)", "baz"); + * ``` + * + * Useful for queries like: + * - `CREATE TABLE` + * - `INSERT INTO` + * - `UPDATE` + * - `DELETE FROM` + * - `DROP TABLE` + * - `PRAGMA` + * - `ATTACH DATABASE` + * - `DETACH DATABASE` + * - `REINDEX` + * - `VACUUM` + * - `EXPLAIN ANALYZE` + * - `CREATE INDEX` + * - `CREATE TRIGGER` + * - `CREATE VIEW` + * - `CREATE VIRTUAL TABLE` + * - `CREATE TEMPORARY TABLE` + * + * @param sql The SQL query to run + * + * @param bindings Optional bindings for the query + * + * @returns `Database` instance + * + * Under the hood, this calls `sqlite3_prepare_v3` followed by `sqlite3_step` and `sqlite3_finalize`. + * + * * The following types can be used when binding parameters: + * + * | JavaScript type | SQLite type | + * | -------------- | ----------- | + * | `string` | `TEXT` | + * | `number` | `INTEGER` or `DECIMAL` | + * | `boolean` | `INTEGER` (1 or 0) | + * | `Uint8Array` | `BLOB` | + * | `Buffer` | `BLOB` | + * | `bigint` | `INTEGER` | + * | `null` | `NULL` | + */ + run( + sqlQuery: string, + ...bindings: ParamsType[] + ): void; + /** + This is an alias of {@link Database.prototype.run} + */ + exec( + sqlQuery: string, + ...bindings: ParamsType[] + ): void; + + /** + * Compile a SQL query and return a {@link Statement} object. This is the + * same as {@link prepare} except that it caches the compiled query. + * + * This **does not execute** the query, but instead prepares it for later + * execution and caches the compiled query if possible. + * + * @example + * ```ts + * // compile the query + * const stmt = db.query("SELECT * FROM foo WHERE bar = ?"); + * // run the query + * stmt.all("baz"); + * + * // run the query again + * stmt.all(); + * ``` + * + * @param sql The SQL query to compile + * + * @returns `Statment` instance + * + * Under the hood, this calls `sqlite3_prepare_v3`. + * + */ + query( + sqlQuery: string, + ): Statement; + + /** + * Compile a SQL query and return a {@link Statement} object. + * + * This does not cache the compiled query and does not execute the query. + * + * @example + * ```ts + * // compile the query + * const stmt = db.query("SELECT * FROM foo WHERE bar = ?"); + * // run the query + * stmt.all("baz"); + * ``` + * + * @param sql The SQL query to compile + * @param params Optional bindings for the query + * + * @returns `Statment` instance + * + * Under the hood, this calls `sqlite3_prepare_v3`. + * + */ + prepare( + sql: string, + ...params: ParamsType[] + ): Statement; + + /** + * Is the database in a transaction? + * + * @returns `true` if the database is in a transaction, `false` otherwise + * + * @example + * ```ts + * db.run("CREATE TABLE foo (bar TEXT)"); + * db.run("INSERT INTO foo VALUES (?)", "baz"); + * db.run("BEGIN"); + * db.run("INSERT INTO foo VALUES (?)", "qux"); + * console.log(db.inTransaction()); + * ``` + */ + get inTransaction(): boolean; + + /** + * Close the database connection. + * + * It is safe to call this method multiple times. If the database is already + * closed, this is a no-op. Running queries after the database has been + * closed will throw an error. + * + * @example + * ```ts + * db.close(); + * ``` + * This is called automatically when the database instance is garbage collected. + * + * Internally, this calls `sqlite3_close_v2`. + */ + close(): void; + + /** + * The filename passed when `new Database()` was called + * @example + * ```ts + * const db = new Database("mydb.sqlite"); + * console.log(db.filename); + * // => "mydb.sqlite" + * ``` + */ + readonly filename: string; + + /** + * The underlying `sqlite3` database handle + * + * In native code, this is not a file descriptor, but an index into an array of database handles + */ + readonly handle: number; + + /** + * Load a SQLite3 extension + * + * macOS requires a custom SQLite3 library to be linked because the Apple build of SQLite for macOS disables loading extensions. See {@link Database.setCustomSQLite} + * + * Bun chooses the Apple build of SQLite on macOS because it brings a ~50% performance improvement. + * + * @param extension name/path of the extension to load + * @param entryPoint optional entry point of the extension + */ + loadExtension(extension: string, entryPoint?: string): void; + + /** + * Change the dynamic library path to SQLite + * + * @note macOS-only + * + * This only works before SQLite is loaded, so + * that's before you call `new Database()`. + * + * It can only be run once because this will load + * the SQLite library into the process. + * + * @param path The path to the SQLite library + * + */ + static setCustomSQLite(path: string): boolean; + + /** + * Creates a function that always runs inside a transaction. When the + * function is invoked, it will begin a new transaction. When the function + * returns, the transaction will be committed. If an exception is thrown, + * the transaction will be rolled back (and the exception will propagate as + * usual). + * + * @param insideTransaction The callback which runs inside a transaction + * + * @example + * ```ts + * // setup + * import { Database } from "bun:sqlite"; + * const db = Database.open(":memory:"); + * db.exec( + * "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)" + * ); + * + * const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)"); + * const insertMany = db.transaction((cats) => { + * for (const cat of cats) insert.run(cat); + * }); + * + * insertMany([ + * { $name: "Joey", $age: 2 }, + * { $name: "Sally", $age: 4 }, + * { $name: "Junior", $age: 1 }, + * ]); + * ``` + */ + transaction(insideTransaction: (...args: any) => void): CallableFunction & { + /** + * uses "BEGIN DEFERRED" + */ + deferred: (...args: any) => void; + /** + * uses "BEGIN IMMEDIATE" + */ + immediate: (...args: any) => void; + /** + * uses "BEGIN EXCLUSIVE" + */ + exclusive: (...args: any) => void; + }; + } + + /** + * A prepared statement. + * + * This is returned by {@link Database.prepare} and {@link Database.query}. + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * stmt.all("baz"); + * // => [{bar: "baz"}] + * ``` + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * stmt.get("baz"); + * // => {bar: "baz"} + * ``` + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * stmt.run("baz"); + * // => undefined + * ``` + */ + export class Statement { + /** + * Creates a new prepared statement from native code. + * + * This is used internally by the {@link Database} class. Probably you don't need to call this yourself. + */ + constructor(nativeHandle: any); + + /** + * Execute the prepared statement and return all results as objects. + * + * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none. + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * + * stmt.all("baz"); + * // => [{bar: "baz"}] + * + * stmt.all(); + * // => [{bar: "baz"}] + * + * stmt.all("foo"); + * // => [{bar: "foo"}] + * ``` + */ + all(...params: ParamsType[]): ReturnType[]; + + /** + * Execute the prepared statement and return **the first** result. + * + * If no result is returned, this returns `null`. + * + * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none. + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * + * stmt.all("baz"); + * // => [{bar: "baz"}] + * + * stmt.all(); + * // => [{bar: "baz"}] + * + * stmt.all("foo"); + * // => [{bar: "foo"}] + * ``` + * + * The following types can be used when binding parameters: + * + * | JavaScript type | SQLite type | + * | -------------- | ----------- | + * | `string` | `TEXT` | + * | `number` | `INTEGER` or `DECIMAL` | + * | `boolean` | `INTEGER` (1 or 0) | + * | `Uint8Array` | `BLOB` | + * | `Buffer` | `BLOB` | + * | `bigint` | `INTEGER` | + * | `null` | `NULL` | + * + */ + get(...params: ParamsType[]): ReturnType | null; + + /** + * Execute the prepared statement. This returns `undefined`. + * + * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none. + * + * @example + * ```ts + * const stmt = db.prepare("UPDATE foo SET bar = ?"); + * stmt.run("baz"); + * // => undefined + * + * stmt.run(); + * // => undefined + * + * stmt.run("foo"); + * // => undefined + * ``` + * + * The following types can be used when binding parameters: + * + * | JavaScript type | SQLite type | + * | -------------- | ----------- | + * | `string` | `TEXT` | + * | `number` | `INTEGER` or `DECIMAL` | + * | `boolean` | `INTEGER` (1 or 0) | + * | `Uint8Array` | `BLOB` | + * | `Buffer` | `BLOB` | + * | `bigint` | `INTEGER` | + * | `null` | `NULL` | + * + */ + run(...params: ParamsType[]): void; + + /** + * Execute the prepared statement and return the results as an array of arrays. + * + * This is a little faster than {@link all}. + * + * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none. + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * + * stmt.values("baz"); + * // => [['baz']] + * + * stmt.values(); + * // => [['baz']] + * + * stmt.values("foo"); + * // => [['foo']] + * ``` + * + * The following types can be used when binding parameters: + * + * | JavaScript type | SQLite type | + * | -------------- | ----------- | + * | `string` | `TEXT` | + * | `number` | `INTEGER` or `DECIMAL` | + * | `boolean` | `INTEGER` (1 or 0) | + * | `Uint8Array` | `BLOB` | + * | `Buffer` | `BLOB` | + * | `bigint` | `INTEGER` | + * | `null` | `NULL` | + * + */ + values( + ...params: ParamsType[] + ): Array>; + + /** + * The names of the columns returned by the prepared statement. + * @example + * ```ts + * const stmt = db.prepare("SELECT bar FROM foo WHERE bar = ?"); + * + * console.log(stmt.columnNames); + * // => ["bar"] + * ``` + */ + readonly columnNames: string[]; + + /** + * The number of parameters expected in the prepared statement. + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?"); + * console.log(stmt.paramsCount); + * // => 1 + * ``` + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ? AND baz = ?"); + * console.log(stmt.paramsCount); + * // => 2 + * ``` + * + */ + readonly paramsCount: number; + + /** + * Finalize the prepared statement, freeing the resources used by the + * statement and preventing it from being executed again. + * + * This is called automatically when the prepared statement is garbage collected. + * + * It is safe to call this multiple times. Calling this on a finalized + * statement has no effect. + * + * Internally, this calls `sqlite3_finalize`. + */ + finalize(): void; + + /** + * Return the expanded SQL string for the prepared statement. + * + * Internally, this calls `sqlite3_expanded_sql()` on the underlying `sqlite3_stmt`. + * + * @example + * ```ts + * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?", "baz"); + * console.log(stmt.toString()); + * // => "SELECT * FROM foo WHERE bar = 'baz'" + * console.log(stmt); + * // => "SELECT * FROM foo WHERE bar = 'baz'" + * ``` + */ + toString(): string; + + /** + * Native object representing the underlying `sqlite3_stmt` + * + * This is left untyped because the ABI of the native bindings may change at any time. + */ + readonly native: any; + } + + /** + * Constants from `sqlite3.h` + * + * This list isn't exhaustive, but some of the ones which are relevant + */ + export const constants: { + /** + * Open the database as read-only (no write operations, no create). + * @value 0x00000001 + */ + SQLITE_OPEN_READONLY: number; + /** + * Open the database for reading and writing + * @value 0x00000002 + */ + SQLITE_OPEN_READWRITE: number; + /** + * Allow creating a new database + * @value 0x00000004 + */ + SQLITE_OPEN_CREATE: number; + /** + * + * @value 0x00000008 + */ + SQLITE_OPEN_DELETEONCLOSE: number; + /** + * + * @value 0x00000010 + */ + SQLITE_OPEN_EXCLUSIVE: number; + /** + * + * @value 0x00000020 + */ + SQLITE_OPEN_AUTOPROXY: number; + /** + * + * @value 0x00000040 + */ + SQLITE_OPEN_URI: number; + /** + * + * @value 0x00000080 + */ + SQLITE_OPEN_MEMORY: number; + /** + * + * @value 0x00000100 + */ + SQLITE_OPEN_MAIN_DB: number; + /** + * + * @value 0x00000200 + */ + SQLITE_OPEN_TEMP_DB: number; + /** + * + * @value 0x00000400 + */ + SQLITE_OPEN_TRANSIENT_DB: number; + /** + * + * @value 0x00000800 + */ + SQLITE_OPEN_MAIN_JOURNAL: number; + /** + * + * @value 0x00001000 + */ + SQLITE_OPEN_TEMP_JOURNAL: number; + /** + * + * @value 0x00002000 + */ + SQLITE_OPEN_SUBJOURNAL: number; + /** + * + * @value 0x00004000 + */ + SQLITE_OPEN_SUPER_JOURNAL: number; + /** + * + * @value 0x00008000 + */ + SQLITE_OPEN_NOMUTEX: number; + /** + * + * @value 0x00010000 + */ + SQLITE_OPEN_FULLMUTEX: number; + /** + * + * @value 0x00020000 + */ + SQLITE_OPEN_SHAREDCACHE: number; + /** + * + * @value 0x00040000 + */ + SQLITE_OPEN_PRIVATECACHE: number; + /** + * + * @value 0x00080000 + */ + SQLITE_OPEN_WAL: number; + /** + * + * @value 0x01000000 + */ + SQLITE_OPEN_NOFOLLOW: number; + /** + * + * @value 0x02000000 + */ + SQLITE_OPEN_EXRESCODE: number; + /** + * + * @value 0x01 + */ + SQLITE_PREPARE_PERSISTENT: number; + /** + * + * @value 0x02 + */ + SQLITE_PREPARE_NORMALIZE: number; + /** + * + * @value 0x04 + */ + SQLITE_PREPARE_NO_VTAB: number; + }; + + /** + * The native module implementing the sqlite3 C bindings + * + * It is lazily-initialized, so this will return `undefined` until the first + * call to new Database(). + * + * The native module makes no gurantees about ABI stability, so it is left + * untyped + * + * If you need to use it directly for some reason, please let us know because + * that probably points to a deficiency in this API. + * + */ + export var native: any; + + export type SQLQueryBindings = + | string + | bigint + | TypedArray + | number + | boolean + | null + | Record; + + export default Database; +} diff --git a/packages/bun-types/stream.d.ts b/packages/bun-types/stream.d.ts new file mode 100644 index 0000000000..5962692a0c --- /dev/null +++ b/packages/bun-types/stream.d.ts @@ -0,0 +1,1482 @@ +/** + * A stream is an abstract interface for working with streaming data in Node.js. + * The `stream` module provides an API for implementing the stream interface. + * + * There are many stream objects provided by Node.js. For instance, a `request to an HTTP server` and `process.stdout` are both stream instances. + * + * Streams can be readable, writable, or both. All streams are instances of `EventEmitter`. + * + * To access the `stream` module: + * + * ```js + * const stream = require('stream'); + * ``` + * + * The `stream` module is useful for creating new types of stream instances. It is + * usually not necessary to use the `stream` module to consume streams. + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/stream.js) + */ +declare module "stream" { + import { EventEmitter, Abortable } from "node:events"; + class internal extends EventEmitter { + pipe( + destination: T, + options?: { + end?: boolean | undefined; + }, + ): T; + } + namespace internal { + class Stream extends internal { + constructor(opts?: ReadableOptions); + } + interface StreamOptions extends Abortable { + emitClose?: boolean | undefined; + highWaterMark?: number | undefined; + objectMode?: boolean | undefined; + construct?(this: T, callback: (error?: Error | null) => void): void; + destroy?( + this: T, + error: Error | null, + callback: (error: Error | null) => void, + ): void; + autoDestroy?: boolean | undefined; + } + interface ReadableOptions extends StreamOptions { + encoding?: BufferEncoding | undefined; + read?(this: Readable, size: number): void; + } + class Readable extends Stream implements ReadableStream { + // TODO: improve type later + values: any; + + readonly locked: boolean; + cancel(reason?: any): Promise; + getReader(): ReadableStreamDefaultReader; + pipeThrough( + transform: ReadableWritablePair, + options?: StreamPipeOptions, + ): ReadableStream; + pipeTo( + destination: WritableStream, + options?: StreamPipeOptions, + ): Promise; + tee(): [ReadableStream, ReadableStream]; + forEach( + callbackfn: ( + value: any, + key: number, + parent: ReadableStream, + ) => void, + thisArg?: any, + ): void; + /** + * A utility method for creating Readable Streams out of iterators. + */ + static from( + iterable: Iterable | AsyncIterable, + options?: ReadableOptions, + ): Readable; + /** + * Returns whether the stream has been read from or cancelled. + */ + static isDisturbed(stream: Readable | ReadableStream): boolean; + /** + * Returns whether the stream was destroyed or errored before emitting `'end'`. + * @experimental + */ + readonly readableAborted: boolean; + /** + * Is `true` if it is safe to call `readable.read()`, which means + * the stream has not been destroyed or emitted `'error'` or `'end'`. + */ + readable: boolean; + /** + * Getter for the property `encoding` of a given `Readable` stream. The `encoding`property can be set using the `readable.setEncoding()` method. + */ + readonly readableEncoding: BufferEncoding | null; + /** + * Becomes `true` when `'end'` event is emitted. + */ + readonly readableEnded: boolean; + /** + * This property reflects the current state of a `Readable` stream as described + * in the `Three states` section. + */ + readonly readableFlowing: boolean | null; + /** + * Returns the value of `highWaterMark` passed when creating this `Readable`. + */ + readonly readableHighWaterMark: number; + /** + * This property contains the number of bytes (or objects) in the queue + * ready to be read. The value provides introspection data regarding + * the status of the `highWaterMark`. + */ + readonly readableLength: number; + /** + * Getter for the property `objectMode` of a given `Readable` stream. + */ + readonly readableObjectMode: boolean; + /** + * Is `true` after `readable.destroy()` has been called. + */ + destroyed: boolean; + constructor(opts?: ReadableOptions); + _construct?(callback: (error?: Error | null) => void): void; + _read(size: number): void; + /** + * The `readable.read()` method reads data out of the internal buffer and + * returns it. If no data is available to be read, `null` is returned. By default, + * the data is returned as a `Buffer` object unless an encoding has been + * specified using the `readable.setEncoding()` method or the stream is operating + * in object mode. + * + * The optional `size` argument specifies a specific number of bytes to read. If`size` bytes are not available to be read, `null` will be returned _unless_the stream has ended, in which + * case all of the data remaining in the internal + * buffer will be returned. + * + * If the `size` argument is not specified, all of the data contained in the + * internal buffer will be returned. + * + * The `size` argument must be less than or equal to 1 GiB. + * + * The `readable.read()` method should only be called on `Readable` streams + * operating in paused mode. In flowing mode, `readable.read()` is called + * automatically until the internal buffer is fully drained. + * + * ```js + * const readable = getReadableStreamSomehow(); + * + * // 'readable' may be triggered multiple times as data is buffered in + * readable.on('readable', () => { + * let chunk; + * console.log('Stream is readable (new data received in buffer)'); + * // Use a loop to make sure we read all currently available data + * while (null !== (chunk = readable.read())) { + * console.log(`Read ${chunk.length} bytes of data...`); + * } + * }); + * + * // 'end' will be triggered once when there is no more data available + * readable.on('end', () => { + * console.log('Reached end of stream.'); + * }); + * ``` + * + * Each call to `readable.read()` returns a chunk of data, or `null`. The chunks + * are not concatenated. A `while` loop is necessary to consume all data + * currently in the buffer. When reading a large file `.read()` may return `null`, + * having consumed all buffered content so far, but there is still more data to + * come not yet buffered. In this case a new `'readable'` event will be emitted + * when there is more data in the buffer. Finally the `'end'` event will be + * emitted when there is no more data to come. + * + * Therefore to read a file's whole contents from a `readable`, it is necessary + * to collect chunks across multiple `'readable'` events: + * + * ```js + * const chunks = []; + * + * readable.on('readable', () => { + * let chunk; + * while (null !== (chunk = readable.read())) { + * chunks.push(chunk); + * } + * }); + * + * readable.on('end', () => { + * const content = chunks.join(''); + * }); + * ``` + * + * A `Readable` stream in object mode will always return a single item from + * a call to `readable.read(size)`, regardless of the value of the`size` argument. + * + * If the `readable.read()` method returns a chunk of data, a `'data'` event will + * also be emitted. + * + * Calling {@link read} after the `'end'` event has + * been emitted will return `null`. No runtime error will be raised. + * @param size Optional argument to specify how much data to read. + */ + read(size?: number): any; + /** + * The `readable.setEncoding()` method sets the character encoding for + * data read from the `Readable` stream. + * + * By default, no encoding is assigned and stream data will be returned as`Buffer` objects. Setting an encoding causes the stream data + * to be returned as strings of the specified encoding rather than as `Buffer`objects. For instance, calling `readable.setEncoding('utf8')` will cause the + * output data to be interpreted as UTF-8 data, and passed as strings. Calling`readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal + * string format. + * + * The `Readable` stream will properly handle multi-byte characters delivered + * through the stream that would otherwise become improperly decoded if simply + * pulled from the stream as `Buffer` objects. + * + * ```js + * const readable = getReadableStreamSomehow(); + * readable.setEncoding('utf8'); + * readable.on('data', (chunk) => { + * assert.equal(typeof chunk, 'string'); + * console.log('Got %d characters of string data:', chunk.length); + * }); + * ``` + * @param encoding The encoding to use. + */ + setEncoding(encoding: BufferEncoding): this; + /** + * The `readable.pause()` method will cause a stream in flowing mode to stop + * emitting `'data'` events, switching out of flowing mode. Any data that + * becomes available will remain in the internal buffer. + * + * ```js + * const readable = getReadableStreamSomehow(); + * readable.on('data', (chunk) => { + * console.log(`Received ${chunk.length} bytes of data.`); + * readable.pause(); + * console.log('There will be no additional data for 1 second.'); + * setTimeout(() => { + * console.log('Now data will start flowing again.'); + * readable.resume(); + * }, 1000); + * }); + * ``` + * + * The `readable.pause()` method has no effect if there is a `'readable'`event listener. + */ + pause(): this; + /** + * The `readable.resume()` method causes an explicitly paused `Readable` stream to + * resume emitting `'data'` events, switching the stream into flowing mode. + * + * The `readable.resume()` method can be used to fully consume the data from a + * stream without actually processing any of that data: + * + * ```js + * getReadableStreamSomehow() + * .resume() + * .on('end', () => { + * console.log('Reached the end, but did not read anything.'); + * }); + * ``` + * + * The `readable.resume()` method has no effect if there is a `'readable'`event listener. + */ + resume(): this; + /** + * The `readable.isPaused()` method returns the current operating state of the`Readable`. This is used primarily by the mechanism that underlies the`readable.pipe()` method. In most + * typical cases, there will be no reason to + * use this method directly. + * + * ```js + * const readable = new stream.Readable(); + * + * readable.isPaused(); // === false + * readable.pause(); + * readable.isPaused(); // === true + * readable.resume(); + * readable.isPaused(); // === false + * ``` + */ + isPaused(): boolean; + /** + * The `readable.unpipe()` method detaches a `Writable` stream previously attached + * using the {@link pipe} method. + * + * If the `destination` is not specified, then _all_ pipes are detached. + * + * If the `destination` is specified, but no pipe is set up for it, then + * the method does nothing. + * + * ```js + * const fs = require('fs'); + * const readable = getReadableStreamSomehow(); + * const writable = fs.createWriteStream('file.txt'); + * // All the data from readable goes into 'file.txt', + * // but only for the first second. + * readable.pipe(writable); + * setTimeout(() => { + * console.log('Stop writing to file.txt.'); + * readable.unpipe(writable); + * console.log('Manually close the file stream.'); + * writable.end(); + * }, 1000); + * ``` + * @param destination Optional specific stream to unpipe + */ + unpipe(destination?: WritableStream): this; + /** + * Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the + * same as `readable.push(null)`, after which no more data can be written. The EOF + * signal is put at the end of the buffer and any buffered data will still be + * flushed. + * + * The `readable.unshift()` method pushes a chunk of data back into the internal + * buffer. This is useful in certain situations where a stream is being consumed by + * code that needs to "un-consume" some amount of data that it has optimistically + * pulled out of the source, so that the data can be passed on to some other party. + * + * The `stream.unshift(chunk)` method cannot be called after the `'end'` event + * has been emitted or a runtime error will be thrown. + * + * Developers using `stream.unshift()` often should consider switching to + * use of a `Transform` stream instead. See the `API for stream implementers` section for more information. + * + * ```js + * // Pull off a header delimited by \n\n. + * // Use unshift() if we get too much. + * // Call the callback with (error, header, stream). + * const { StringDecoder } = require('string_decoder'); + * function parseHeader(stream, callback) { + * stream.on('error', callback); + * stream.on('readable', onReadable); + * const decoder = new StringDecoder('utf8'); + * let header = ''; + * function onReadable() { + * let chunk; + * while (null !== (chunk = stream.read())) { + * const str = decoder.write(chunk); + * if (str.includes('\n\n')) { + * // Found the header boundary. + * const split = str.split(/\n\n/); + * header += split.shift(); + * const remaining = split.join('\n\n'); + * const buf = Buffer.from(remaining, 'utf8'); + * stream.removeListener('error', callback); + * // Remove the 'readable' listener before unshifting. + * stream.removeListener('readable', onReadable); + * if (buf.length) + * stream.unshift(buf); + * // Now the body of the message can be read from the stream. + * callback(null, header, stream); + * return; + * } + * // Still reading the header. + * header += str; + * } + * } + * } + * ``` + * + * Unlike {@link push}, `stream.unshift(chunk)` will not + * end the reading process by resetting the internal reading state of the stream. + * This can cause unexpected results if `readable.unshift()` is called during a + * read (i.e. from within a {@link _read} implementation on a + * custom stream). Following the call to `readable.unshift()` with an immediate {@link push} will reset the reading state appropriately, + * however it is best to simply avoid calling `readable.unshift()` while in the + * process of performing a read. + * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array` or `null`. For object mode + * streams, `chunk` may be any JavaScript value. + * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`. + */ + unshift(chunk: any, encoding?: BufferEncoding): void; + /** + * Prior to Node.js 0.10, streams did not implement the entire `stream` module API + * as it is currently defined. (See `Compatibility` for more information.) + * + * When using an older Node.js library that emits `'data'` events and has a {@link pause} method that is advisory only, the`readable.wrap()` method can be used to create a `Readable` + * stream that uses + * the old stream as its data source. + * + * It will rarely be necessary to use `readable.wrap()` but the method has been + * provided as a convenience for interacting with older Node.js applications and + * libraries. + * + * ```js + * const { OldReader } = require('./old-api-module.js'); + * const { Readable } = require('stream'); + * const oreader = new OldReader(); + * const myReader = new Readable().wrap(oreader); + * + * myReader.on('readable', () => { + * myReader.read(); // etc. + * }); + * ``` + * @param stream An "old style" readable stream + */ + wrap(stream: ReadableStream): this; + push(chunk: any, encoding?: BufferEncoding): boolean; + _destroy( + error: Error | null, + callback: (error?: Error | null) => void, + ): void; + /** + * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the readable + * stream will release any internal resources and subsequent calls to `push()`will be ignored. + * + * 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'`. + * + * Implementors should not override this method, but instead implement `readable._destroy()`. + * @param error Error which will be passed as payload in `'error'` event + */ + destroy(error?: Error): this; + /** + * Event emitter + * The defined events on documents including: + * 1. close + * 2. data + * 3. end + * 4. error + * 5. pause + * 6. readable + * 7. resume + */ + addListener(event: "close", listener: () => void): this; + addListener(event: "data", listener: (chunk: any) => void): this; + addListener(event: "end", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "pause", listener: () => void): this; + addListener(event: "readable", listener: () => void): this; + addListener(event: "resume", listener: () => void): this; + addListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + emit(event: "close"): boolean; + emit(event: "data", chunk: any): boolean; + emit(event: "end"): boolean; + emit(event: "error", err: Error): boolean; + emit(event: "pause"): boolean; + emit(event: "readable"): boolean; + emit(event: "resume"): boolean; + emit(event: string | symbol, ...args: any[]): boolean; + on(event: "close", listener: () => void): this; + on(event: "data", listener: (chunk: any) => void): this; + on(event: "end", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "pause", listener: () => void): this; + on(event: "readable", listener: () => void): this; + on(event: "resume", listener: () => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "data", listener: (chunk: any) => void): this; + once(event: "end", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "pause", listener: () => void): this; + once(event: "readable", listener: () => void): this; + once(event: "resume", listener: () => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + prependListener(event: "close", listener: () => void): this; + prependListener(event: "data", listener: (chunk: any) => void): this; + prependListener(event: "end", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener(event: "pause", listener: () => void): this; + prependListener(event: "readable", listener: () => void): this; + prependListener(event: "resume", listener: () => void): this; + prependListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + prependOnceListener(event: "close", listener: () => void): this; + prependOnceListener(event: "data", listener: (chunk: any) => void): this; + prependOnceListener(event: "end", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener(event: "pause", listener: () => void): this; + prependOnceListener(event: "readable", listener: () => void): this; + prependOnceListener(event: "resume", listener: () => void): this; + prependOnceListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + removeListener(event: "close", listener: () => void): this; + removeListener(event: "data", listener: (chunk: any) => void): this; + removeListener(event: "end", listener: () => void): this; + removeListener(event: "error", listener: (err: Error) => void): this; + removeListener(event: "pause", listener: () => void): this; + removeListener(event: "readable", listener: () => void): this; + removeListener(event: "resume", listener: () => void): this; + removeListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + [Symbol.asyncIterator](): AsyncIterableIterator; + } + interface WritableOptions extends StreamOptions { + decodeStrings?: boolean | undefined; + defaultEncoding?: BufferEncoding | undefined; + write?( + this: Writable, + chunk: any, + encoding: BufferEncoding, + callback: (error?: Error | null) => void, + ): void; + writev?( + this: Writable, + chunks: Array<{ + chunk: any; + encoding: BufferEncoding; + }>, + callback: (error?: Error | null) => void, + ): void; + final?(this: Writable, callback: (error?: Error | null) => void): void; + } + class Writable extends Stream implements WritableStream { + readonly locked: boolean; + abort(reason?: any): Promise; + close(): Promise; + getWriter(): WritableStreamDefaultWriter; + /** + * Is `true` if it is safe to call `writable.write()`, which means + * the stream has not been destroyed, errored or ended. + */ + readonly writable: boolean; + /** + * Is `true` after `writable.end()` has been called. This property + * does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead. + */ + readonly writableEnded: boolean; + /** + * Is set to `true` immediately before the `'finish'` event is emitted. + */ + readonly writableFinished: boolean; + /** + * Return the value of `highWaterMark` passed when creating this `Writable`. + */ + readonly writableHighWaterMark: number; + /** + * This property contains the number of bytes (or objects) in the queue + * ready to be written. The value provides introspection data regarding + * the status of the `highWaterMark`. + */ + readonly writableLength: number; + /** + * Getter for the property `objectMode` of a given `Writable` stream. + */ + readonly writableObjectMode: boolean; + /** + * Number of times `writable.uncork()` needs to be + * called in order to fully uncork the stream. + */ + readonly writableCorked: number; + /** + * Is `true` after `writable.destroy()` has been called. + */ + destroyed: boolean; + constructor(opts?: WritableOptions); + _write( + chunk: any, + encoding: BufferEncoding, + callback: (error?: Error | null) => void, + ): void; + _writev?( + chunks: Array<{ + chunk: any; + encoding: BufferEncoding; + }>, + callback: (error?: Error | null) => void, + ): void; + _construct?(callback: (error?: Error | null) => void): void; + _destroy( + error: Error | null, + callback: (error?: Error | null) => void, + ): void; + _final(callback: (error?: Error | null) => void): void; + /** + * The `writable.write()` method writes some data to the stream, and calls the + * supplied `callback` once the data has been fully handled. If an error + * occurs, the `callback` will be called with the error as its + * first argument. The `callback` is called asynchronously and before `'error'` is + * emitted. + * + * The return value is `true` if the internal buffer is less than the`highWaterMark` configured when the stream was created after admitting `chunk`. + * If `false` is returned, further attempts to write data to the stream should + * stop until the `'drain'` event is emitted. + * + * While a stream is not draining, calls to `write()` will buffer `chunk`, and + * return false. Once all currently buffered chunks are drained (accepted for + * delivery by the operating system), the `'drain'` event will be emitted. + * Once `write()` returns false, do not write more chunks + * until the `'drain'` event is emitted. While calling `write()` on a stream that + * is not draining is allowed, Node.js will buffer all written chunks until + * maximum memory usage occurs, at which point it will abort unconditionally. + * Even before it aborts, high memory usage will cause poor garbage collector + * performance and high RSS (which is not typically released back to the system, + * even after the memory is no longer required). Since TCP sockets may never + * drain if the remote peer does not read the data, writing a socket that is + * not draining may lead to a remotely exploitable vulnerability. + * + * Writing data while the stream is not draining is particularly + * problematic for a `Transform`, because the `Transform` streams are paused + * by default until they are piped or a `'data'` or `'readable'` event handler + * is added. + * + * If the data to be written can be generated or fetched on demand, it is + * recommended to encapsulate the logic into a `Readable` and use {@link pipe}. However, if calling `write()` is preferred, it is + * possible to respect backpressure and avoid memory issues using the `'drain'` event: + * + * ```js + * function write(data, cb) { + * if (!stream.write(data)) { + * stream.once('drain', cb); + * } else { + * process.nextTick(cb); + * } + * } + * + * // Wait for cb to be called before doing any other write. + * write('hello', () => { + * console.log('Write completed, do more writes now.'); + * }); + * ``` + * + * A `Writable` stream in object mode will always ignore the `encoding` argument. + * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any + * JavaScript value other than `null`. + * @param [encoding='utf8'] The encoding, if `chunk` is a string. + * @param callback Callback for when this chunk of data is flushed. + * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`. + */ + write( + chunk: any, + callback?: (error: Error | null | undefined) => void, + ): boolean; + write( + chunk: any, + encoding: BufferEncoding, + callback?: (error: Error | null | undefined) => void, + ): boolean; + /** + * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream. + * @param encoding The new default encoding + */ + setDefaultEncoding(encoding: BufferEncoding): this; + /** + * Calling the `writable.end()` method signals that no more data will be written + * to the `Writable`. The optional `chunk` and `encoding` arguments allow one + * final additional chunk of data to be written immediately before closing the + * stream. + * + * Calling the {@link write} method after calling {@link end} will raise an error. + * + * ```js + * // Write 'hello, ' and then end with 'world!'. + * const fs = require('fs'); + * const file = fs.createWriteStream('example.txt'); + * file.write('hello, '); + * file.end('world!'); + * // Writing more now is not allowed! + * ``` + * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any + * JavaScript value other than `null`. + * @param encoding The encoding if `chunk` is a string + * @param callback Callback for when the stream is finished. + */ + end(cb?: () => void): this; + end(chunk: any, cb?: () => void): this; + end(chunk: any, encoding: BufferEncoding, cb?: () => void): this; + /** + * The `writable.cork()` method forces all written data to be buffered in memory. + * The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called. + * + * The primary intent of `writable.cork()` is to accommodate a situation in which + * several small chunks are written to the stream in rapid succession. Instead of + * immediately forwarding them to the underlying destination, `writable.cork()`buffers all the chunks until `writable.uncork()` is called, which will pass them + * all to `writable._writev()`, if present. This prevents a head-of-line blocking + * situation where data is being buffered while waiting for the first small chunk + * to be processed. However, use of `writable.cork()` without implementing`writable._writev()` may have an adverse effect on throughput. + * + * See also: `writable.uncork()`, `writable._writev()`. + */ + cork(): void; + /** + * The `writable.uncork()` method flushes all data buffered since {@link cork} was called. + * + * When using `writable.cork()` and `writable.uncork()` to manage the buffering + * of writes to a stream, defer calls to `writable.uncork()` using`process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event + * loop phase. + * + * ```js + * stream.cork(); + * stream.write('some '); + * stream.write('data '); + * process.nextTick(() => stream.uncork()); + * ``` + * + * If the `writable.cork()` method is called multiple times on a stream, the + * same number of calls to `writable.uncork()` must be called to flush the buffered + * data. + * + * ```js + * stream.cork(); + * stream.write('some '); + * stream.cork(); + * stream.write('data '); + * process.nextTick(() => { + * stream.uncork(); + * // The data will not be flushed until uncork() is called a second time. + * stream.uncork(); + * }); + * ``` + * + * See also: `writable.cork()`. + */ + uncork(): void; + /** + * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the writable + * stream has ended and subsequent calls to `write()` or `end()` will result in + * an `ERR_STREAM_DESTROYED` error. + * This is a destructive and immediate way to destroy a stream. Previous calls to`write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error. + * Use `end()` instead of destroy if data should flush before close, or wait for + * the `'drain'` event before destroying the stream. + * + * 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'`. + * + * Implementors should not override this method, + * but instead implement `writable._destroy()`. + * @param error Optional, an error to emit with `'error'` event. + */ + destroy(error?: Error): this; + /** + * Event emitter + * The defined events on documents including: + * 1. close + * 2. drain + * 3. error + * 4. finish + * 5. pipe + * 6. unpipe + */ + addListener(event: "close", listener: () => void): this; + addListener(event: "drain", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "finish", listener: () => void): this; + addListener(event: "pipe", listener: (src: Readable) => void): this; + addListener(event: "unpipe", listener: (src: Readable) => void): this; + addListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + emit(event: "close"): boolean; + emit(event: "drain"): boolean; + emit(event: "error", err: Error): boolean; + emit(event: "finish"): boolean; + emit(event: "pipe", src: Readable): boolean; + emit(event: "unpipe", src: Readable): boolean; + emit(event: string | symbol, ...args: any[]): boolean; + on(event: "close", listener: () => void): this; + on(event: "drain", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "finish", listener: () => void): this; + on(event: "pipe", listener: (src: Readable) => void): this; + on(event: "unpipe", listener: (src: Readable) => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "drain", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "finish", listener: () => void): this; + once(event: "pipe", listener: (src: Readable) => void): this; + once(event: "unpipe", listener: (src: Readable) => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + prependListener(event: "close", listener: () => void): this; + prependListener(event: "drain", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener(event: "finish", listener: () => void): this; + prependListener(event: "pipe", listener: (src: Readable) => void): this; + prependListener(event: "unpipe", listener: (src: Readable) => void): this; + prependListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + prependOnceListener(event: "close", listener: () => void): this; + prependOnceListener(event: "drain", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener(event: "finish", listener: () => void): this; + prependOnceListener( + event: "pipe", + listener: (src: Readable) => void, + ): this; + prependOnceListener( + event: "unpipe", + listener: (src: Readable) => void, + ): this; + prependOnceListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + removeListener(event: "close", listener: () => void): this; + removeListener(event: "drain", listener: () => void): this; + removeListener(event: "error", listener: (err: Error) => void): this; + removeListener(event: "finish", listener: () => void): this; + removeListener(event: "pipe", listener: (src: Readable) => void): this; + removeListener(event: "unpipe", listener: (src: Readable) => void): this; + removeListener( + event: string | symbol, + listener: (...args: any[]) => void, + ): this; + } + interface DuplexOptions extends ReadableOptions, WritableOptions { + allowHalfOpen?: boolean | undefined; + readableObjectMode?: boolean | undefined; + writableObjectMode?: boolean | undefined; + readableHighWaterMark?: number | undefined; + writableHighWaterMark?: number | undefined; + writableCorked?: number | undefined; + construct?(this: Duplex, callback: (error?: Error | null) => void): void; + read?(this: Duplex, size: number): void; + write?( + this: Duplex, + chunk: any, + encoding: BufferEncoding, + callback: (error?: Error | null) => void, + ): void; + writev?( + this: Duplex, + chunks: Array<{ + chunk: any; + encoding: BufferEncoding; + }>, + callback: (error?: Error | null) => void, + ): void; + final?(this: Duplex, callback: (error?: Error | null) => void): void; + destroy?( + this: Duplex, + error: Error | null, + callback: (error: Error | null) => void, + ): void; + } + /** + * Duplex streams are streams that implement both the `Readable` and `Writable` interfaces. + * + * Examples of `Duplex` streams include: + * + * * `TCP sockets` + * * `zlib streams` + * * `crypto streams` + */ + class Duplex extends Readable implements Writable { + readonly writable: boolean; + readonly writableEnded: boolean; + readonly writableFinished: boolean; + readonly writableHighWaterMark: number; + readonly writableLength: number; + readonly writableObjectMode: boolean; + readonly writableCorked: number; + /** + * If `false` then the stream will automatically end the writable side when the + * readable side ends. Set initially by the `allowHalfOpen` constructor option, + * which defaults to `false`. + * + * This can be changed manually to change the half-open behavior of an existing`Duplex` stream instance, but must be changed before the `'end'` event is + * emitted. + * @since v0.9.4 + */ + allowHalfOpen: boolean; + constructor(opts?: DuplexOptions); + abort(reason?: any): Promise; + close(): Promise; + getWriter(): WritableStreamDefaultWriter; + /** + * A utility method for creating duplex streams. + * + * - `Stream` converts writable stream into writable `Duplex` and readable stream + * to `Duplex`. + * - `Blob` converts into readable `Duplex`. + * - `string` converts into readable `Duplex`. + * - `ArrayBuffer` converts into readable `Duplex`. + * - `AsyncIterable` converts into a readable `Duplex`. Cannot yield `null`. + * - `AsyncGeneratorFunction` converts into a readable/writable transform + * `Duplex`. Must take a source `AsyncIterable` as first parameter. Cannot yield + * `null`. + * - `AsyncFunction` converts into a writable `Duplex`. Must return + * either `null` or `undefined` + * - `Object ({ writable, readable })` converts `readable` and + * `writable` into `Stream` and then combines them into `Duplex` where the + * `Duplex` will write to the `writable` and read from the `readable`. + * - `Promise` converts into readable `Duplex`. Value `null` is ignored. + * + * @since v16.8.0 + */ + static from( + src: + | Stream + | Blob + | ArrayBuffer + | string + | Iterable + | AsyncIterable + | AsyncGeneratorFunction + | Promise + | Object, + ): Duplex; + _write( + chunk: any, + encoding: BufferEncoding, + callback: (error?: Error | null) => void, + ): void; + _writev?( + chunks: Array<{ + chunk: any; + encoding: BufferEncoding; + }>, + callback: (error?: Error | null) => void, + ): void; + _destroy( + error: Error | null, + callback: (error: Error | null) => void, + ): void; + _final(callback: (error?: Error | null) => void): void; + write( + chunk: any, + encoding?: BufferEncoding, + cb?: (error: Error | null | undefined) => void, + ): boolean; + write( + chunk: any, + cb?: (error: Error | null | undefined) => void, + ): boolean; + setDefaultEncoding(encoding: BufferEncoding): this; + end(cb?: () => void): this; + end(chunk: any, cb?: () => void): this; + end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this; + cork(): void; + uncork(): void; + } + type TransformCallback = (error?: Error | null, data?: any) => void; + interface TransformOptions extends DuplexOptions { + construct?( + this: Transform, + callback: (error?: Error | null) => void, + ): void; + read?(this: Transform, size: number): void; + write?( + this: Transform, + chunk: any, + encoding: BufferEncoding, + callback: (error?: Error | null) => void, + ): void; + writev?( + this: Transform, + chunks: Array<{ + chunk: any; + encoding: BufferEncoding; + }>, + callback: (error?: Error | null) => void, + ): void; + final?(this: Transform, callback: (error?: Error | null) => void): void; + destroy?( + this: Transform, + error: Error | null, + callback: (error: Error | null) => void, + ): void; + transform?( + this: Transform, + chunk: any, + encoding: BufferEncoding, + callback: TransformCallback, + ): void; + flush?(this: Transform, callback: TransformCallback): void; + } + /** + * Transform streams are `Duplex` streams where the output is in some way + * related to the input. Like all `Duplex` streams, `Transform` streams + * implement both the `Readable` and `Writable` interfaces. + * + * Examples of `Transform` streams include: + * + * * `zlib streams` + * * `crypto streams` + * @since v0.9.4 + */ + class Transform extends Duplex { + constructor(opts?: TransformOptions); + _transform( + chunk: any, + encoding: BufferEncoding, + callback: TransformCallback, + ): void; + _flush(callback: TransformCallback): void; + } + /** + * The `stream.PassThrough` class is a trivial implementation of a `Transform` stream that simply passes the input bytes across to the output. Its purpose is + * primarily for examples and testing, but there are some use cases where`stream.PassThrough` is useful as a building block for novel sorts of streams. + */ + class PassThrough extends Transform {} + /** + * Attaches an AbortSignal to a readable or writeable stream. This lets code + * control stream destruction using an `AbortController`. + * + * Calling `abort` on the `AbortController` corresponding to the passed`AbortSignal` will behave the same way as calling `.destroy(new AbortError())`on the stream. + * + * ```js + * const fs = require('fs'); + * + * const controller = new AbortController(); + * const read = addAbortSignal( + * controller.signal, + * fs.createReadStream(('object.json')) + * ); + * // Later, abort the operation closing the stream + * controller.abort(); + * ``` + * + * Or using an `AbortSignal` with a readable stream as an async iterable: + * + * ```js + * const controller = new AbortController(); + * setTimeout(() => controller.abort(), 10_000); // set a timeout + * const stream = addAbortSignal( + * controller.signal, + * fs.createReadStream(('object.json')) + * ); + * (async () => { + * try { + * for await (const chunk of stream) { + * await process(chunk); + * } + * } catch (e) { + * if (e.name === 'AbortError') { + * // The operation was cancelled + * } else { + * throw e; + * } + * } + * })(); + * ``` + * @param signal A signal representing possible cancellation + * @param stream a stream to attach a signal to + */ + function addAbortSignal( + signal: AbortSignal, + stream: T, + ): T; + interface FinishedOptions extends Abortable { + error?: boolean | undefined; + readable?: boolean | undefined; + writable?: boolean | undefined; + } + /** + * A function to get notified when a stream is no longer readable, writable + * or has experienced an error or a premature close event. + * + * ```js + * const { finished } = require('stream'); + * + * const rs = fs.createReadStream('archive.tar'); + * + * finished(rs, (err) => { + * if (err) { + * console.error('Stream failed.', err); + * } else { + * console.log('Stream is done reading.'); + * } + * }); + * + * rs.resume(); // Drain the stream. + * ``` + * + * Especially useful in error handling scenarios where a stream is destroyed + * prematurely (like an aborted HTTP request), and will not emit `'end'`or `'finish'`. + * + * The `finished` API provides promise version: + * + * ```js + * const { finished } = require('stream/promises'); + * + * const rs = fs.createReadStream('archive.tar'); + * + * async function run() { + * await finished(rs); + * console.log('Stream is done reading.'); + * } + * + * run().catch(console.error); + * rs.resume(); // Drain the stream. + * ``` + * + * `stream.finished()` leaves dangling event listeners (in particular`'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been + * invoked. The reason for this is so that unexpected `'error'` events (due to + * incorrect stream implementations) do not cause unexpected crashes. + * If this is unwanted behavior then the returned cleanup function needs to be + * invoked in the callback: + * + * ```js + * const cleanup = finished(rs, (err) => { + * cleanup(); + * // ... + * }); + * ``` + * @param stream A readable and/or writable stream. + * @param callback A callback function that takes an optional error argument. + * @return A cleanup function which removes all registered listeners. + */ + function finished( + stream: ReadableStream | WritableStream | ReadWriteStream, + options: FinishedOptions, + callback: (err?: ErrnoException | null) => void, + ): () => void; + function finished( + stream: ReadableStream | WritableStream | ReadWriteStream, + callback: (err?: ErrnoException | null) => void, + ): () => void; + namespace finished { + function __promisify__( + stream: ReadableStream | WritableStream | ReadWriteStream, + options?: FinishedOptions, + ): Promise; + } + type PipelineSourceFunction = () => Iterable | AsyncIterable; + type PipelineSource = + | Iterable + | AsyncIterable + | ReadableStream + | PipelineSourceFunction; + type PipelineTransform, U> = + | ReadWriteStream + | (( + source: S extends ( + ...args: any[] + ) => Iterable | AsyncIterable + ? AsyncIterable + : S, + ) => AsyncIterable); + type PipelineTransformSource = + | PipelineSource + | PipelineTransform; + type PipelineDestinationIterableFunction = ( + source: AsyncIterable, + ) => AsyncIterable; + type PipelineDestinationPromiseFunction = ( + source: AsyncIterable, + ) => Promise

; + type PipelineDestination< + S extends PipelineTransformSource, + P, + > = S extends PipelineTransformSource + ? + | WritableStream + | PipelineDestinationIterableFunction + | PipelineDestinationPromiseFunction + : never; + type PipelineCallback> = + S extends PipelineDestinationPromiseFunction + ? (err: ErrnoException | null, value: P) => void + : (err: ErrnoException | null) => void; + type PipelinePromise> = + S extends PipelineDestinationPromiseFunction + ? Promise

+ : Promise; + interface PipelineOptions { + signal: AbortSignal; + } + /** + * A module method to pipe between streams and generators forwarding errors and + * properly cleaning up and provide a callback when the pipeline is complete. + * + * ```js + * const { pipeline } = require('stream'); + * const fs = require('fs'); + * const zlib = require('zlib'); + * + * // Use the pipeline API to easily pipe a series of streams + * // together and get notified when the pipeline is fully done. + * + * // A pipeline to gzip a potentially huge tar file efficiently: + * + * pipeline( + * fs.createReadStream('archive.tar'), + * zlib.createGzip(), + * fs.createWriteStream('archive.tar.gz'), + * (err) => { + * if (err) { + * console.error('Pipeline failed.', err); + * } else { + * console.log('Pipeline succeeded.'); + * } + * } + * ); + * ``` + * + * The `pipeline` API provides a promise version, which can also + * receive an options argument as the last parameter with a`signal` `AbortSignal` property. When the signal is aborted,`destroy` will be called on the underlying pipeline, with + * an`AbortError`. + * + * ```js + * const { pipeline } = require('stream/promises'); + * + * async function run() { + * await pipeline( + * fs.createReadStream('archive.tar'), + * zlib.createGzip(), + * fs.createWriteStream('archive.tar.gz') + * ); + * console.log('Pipeline succeeded.'); + * } + * + * run().catch(console.error); + * ``` + * + * To use an `AbortSignal`, pass it inside an options object, + * as the last argument: + * + * ```js + * const { pipeline } = require('stream/promises'); + * + * async function run() { + * const ac = new AbortController(); + * const signal = ac.signal; + * + * setTimeout(() => ac.abort(), 1); + * await pipeline( + * fs.createReadStream('archive.tar'), + * zlib.createGzip(), + * fs.createWriteStream('archive.tar.gz'), + * { signal }, + * ); + * } + * + * run().catch(console.error); // AbortError + * ``` + * + * The `pipeline` API also supports async generators: + * + * ```js + * const { pipeline } = require('stream/promises'); + * const fs = require('fs'); + * + * async function run() { + * await pipeline( + * fs.createReadStream('lowercase.txt'), + * async function* (source, { signal }) { + * source.setEncoding('utf8'); // Work with strings rather than `Buffer`s. + * for await (const chunk of source) { + * yield await processChunk(chunk, { signal }); + * } + * }, + * fs.createWriteStream('uppercase.txt') + * ); + * console.log('Pipeline succeeded.'); + * } + * + * run().catch(console.error); + * ``` + * + * Remember to handle the `signal` argument passed into the async generator. + * Especially in the case where the async generator is the source for the + * pipeline (i.e. first argument) or the pipeline will never complete. + * + * ```js + * const { pipeline } = require('stream/promises'); + * const fs = require('fs'); + * + * async function run() { + * await pipeline( + * async function* ({ signal }) { + * await someLongRunningfn({ signal }); + * yield 'asd'; + * }, + * fs.createWriteStream('uppercase.txt') + * ); + * console.log('Pipeline succeeded.'); + * } + * + * run().catch(console.error); + * ``` + * + * `stream.pipeline()` will call `stream.destroy(err)` on all streams except: + * + * * `Readable` streams which have emitted `'end'` or `'close'`. + * * `Writable` streams which have emitted `'finish'` or `'close'`. + * + * `stream.pipeline()` leaves dangling event listeners on the streams + * after the `callback` has been invoked. In the case of reuse of streams after + * failure, this can cause event listener leaks and swallowed errors. If the last + * stream is readable, dangling event listeners will be removed so that the last + * stream can be consumed later. + * + * `stream.pipeline()` closes all the streams when an error is raised. + * The `IncomingRequest` usage with `pipeline` could lead to an unexpected behavior + * once it would destroy the socket without sending the expected response. + * See the example below: + * + * ```js + * const fs = require('fs'); + * const http = require('http'); + * const { pipeline } = require('stream'); + * + * const server = http.createServer((req, res) => { + * const fileStream = fs.createReadStream('./fileNotExist.txt'); + * pipeline(fileStream, res, (err) => { + * if (err) { + * console.log(err); // No such file + * // this message can't be sent once `pipeline` already destroyed the socket + * return res.end('error!!!'); + * } + * }); + * }); + * ``` + * @param callback Called when the pipeline is fully done. + */ + function pipeline< + A extends PipelineSource, + B extends PipelineDestination, + >( + source: A, + destination: B, + callback?: PipelineCallback, + ): B extends WritableStream ? B : WritableStream; + function pipeline< + A extends PipelineSource, + T1 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + destination: B, + callback?: PipelineCallback, + ): B extends WritableStream ? B : WritableStream; + function pipeline< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + destination: B, + callback?: PipelineCallback, + ): B extends WritableStream ? B : WritableStream; + function pipeline< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + T3 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + transform3: T3, + destination: B, + callback?: PipelineCallback, + ): B extends WritableStream ? B : WritableStream; + function pipeline< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + T3 extends PipelineTransform, + T4 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + transform3: T3, + transform4: T4, + destination: B, + callback?: PipelineCallback, + ): B extends WritableStream ? B : WritableStream; + function pipeline( + streams: ReadonlyArray, + callback?: (err: ErrnoException | null) => void, + ): WritableStream; + function pipeline( + stream1: ReadableStream, + stream2: ReadWriteStream | WritableStream, + ...streams: Array< + | ReadWriteStream + | WritableStream + | ((err: ErrnoException | null) => void) + > + ): WritableStream; + namespace pipeline { + function __promisify__< + A extends PipelineSource, + B extends PipelineDestination, + >( + source: A, + destination: B, + options?: PipelineOptions, + ): PipelinePromise; + function __promisify__< + A extends PipelineSource, + T1 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + destination: B, + options?: PipelineOptions, + ): PipelinePromise; + function __promisify__< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + destination: B, + options?: PipelineOptions, + ): PipelinePromise; + function __promisify__< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + T3 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + transform3: T3, + destination: B, + options?: PipelineOptions, + ): PipelinePromise; + function __promisify__< + A extends PipelineSource, + T1 extends PipelineTransform, + T2 extends PipelineTransform, + T3 extends PipelineTransform, + T4 extends PipelineTransform, + B extends PipelineDestination, + >( + source: A, + transform1: T1, + transform2: T2, + transform3: T3, + transform4: T4, + destination: B, + options?: PipelineOptions, + ): PipelinePromise; + function __promisify__( + streams: ReadonlyArray< + ReadableStream | WritableStream | ReadWriteStream + >, + options?: PipelineOptions, + ): Promise; + function __promisify__( + stream1: ReadableStream, + stream2: ReadWriteStream | WritableStream, + ...streams: Array + ): Promise; + } + interface Pipe { + close(): void; + hasRef(): boolean; + ref(): void; + unref(): void; + } + + /** + * Returns whether the stream has encountered an error. + */ + function isErrored( + stream: Readable | Writable | ReadableStream | WritableStream, + ): boolean; + + /** + * Returns whether the stream is readable. + */ + function isReadable(stream: Readable | ReadableStream): boolean; + } + export = internal; +} +declare module "node:stream" { + import stream = require("stream"); + export = stream; +} diff --git a/packages/bun-types/string_decoder.d.ts b/packages/bun-types/string_decoder.d.ts new file mode 100644 index 0000000000..a40fa287d7 --- /dev/null +++ b/packages/bun-types/string_decoder.d.ts @@ -0,0 +1,65 @@ +/** + * The `string_decoder` module provides an API for decoding `Buffer` objects into + * strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16 + * characters. It can be accessed using: + * + * ```js + * const { StringDecoder } = require('string_decoder'); + * ``` + * + * The following example shows the basic use of the `StringDecoder` class. + * + * ```js + * const { StringDecoder } = require('string_decoder'); + * const decoder = new StringDecoder('utf8'); + * + * const cent = Buffer.from([0xC2, 0xA2]); + * console.log(decoder.write(cent)); + * + * const euro = Buffer.from([0xE2, 0x82, 0xAC]); + * console.log(decoder.write(euro)); + * ``` + * + * When a `Buffer` instance is written to the `StringDecoder` instance, an + * internal buffer is used to ensure that the decoded string does not contain + * any incomplete multibyte characters. These are held in the buffer until the + * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called. + * + * In the following example, the three UTF-8 encoded bytes of the European Euro + * symbol (`€`) are written over three separate operations: + * + * ```js + * const { StringDecoder } = require('string_decoder'); + * const decoder = new StringDecoder('utf8'); + * + * decoder.write(Buffer.from([0xE2])); + * decoder.write(Buffer.from([0x82])); + * console.log(decoder.end(Buffer.from([0xAC]))); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/string_decoder.js) + */ +declare module "string_decoder" { + class StringDecoder { + constructor(encoding?: BufferEncoding); + /** + * Returns a decoded string, ensuring that any incomplete multibyte characters at + * the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the + * returned string and stored in an internal buffer for the next call to`stringDecoder.write()` or `stringDecoder.end()`. + * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode. + */ + write(buffer: Buffer): string; + /** + * Returns any remaining input stored in the internal buffer as a string. Bytes + * representing incomplete UTF-8 and UTF-16 characters will be replaced with + * substitution characters appropriate for the character encoding. + * + * If the `buffer` argument is provided, one final call to `stringDecoder.write()`is performed before returning the remaining input. + * After `end()` is called, the `stringDecoder` object can be reused for new input. + * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode. + */ + end(buffer?: Buffer): string; + } +} +declare module "node:string_decoder" { + export * from "string_decoder"; +} diff --git a/packages/bun-types/supports-color.d.ts b/packages/bun-types/supports-color.d.ts new file mode 100644 index 0000000000..7f4323b021 --- /dev/null +++ b/packages/bun-types/supports-color.d.ts @@ -0,0 +1,55 @@ +declare module "supports-color" { + export interface Options { + /** + Whether `process.argv` should be sniffed for `--color` and `--no-color` flags. + @default true + */ + readonly sniffFlags?: boolean; + } + + /** + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + export type ColorSupportLevel = 0 | 1 | 2 | 3; + + /** + Detect whether the terminal supports color. + */ + export interface ColorSupport { + /** + The color level. + */ + level: ColorSupportLevel; + + /** + Whether basic 16 colors are supported. + */ + hasBasic: boolean; + + /** + Whether ANSI 256 colors are supported. + */ + has256: boolean; + + /** + Whether Truecolor 16 million colors are supported. + */ + has16m: boolean; + } + + export type ColorInfo = ColorSupport | false; + + export const supportsColor: { + stdout: ColorInfo; + stderr: ColorInfo; + }; + + export const stdout: ColorInfo; + export const stderr: ColorInfo; + + export default supportsColor; +} diff --git a/packages/bun-types/tests/index.d.ts b/packages/bun-types/tests/index.d.ts new file mode 100644 index 0000000000..45e52ec7d0 --- /dev/null +++ b/packages/bun-types/tests/index.d.ts @@ -0,0 +1,5 @@ +/// + +export * as fs from "fs"; +export * as fsPromises from "fs/promises"; +export default Bun; diff --git a/packages/bun-types/tests/index.test-d.ts b/packages/bun-types/tests/index.test-d.ts new file mode 100644 index 0000000000..7a23906384 --- /dev/null +++ b/packages/bun-types/tests/index.test-d.ts @@ -0,0 +1,71 @@ +import { ZlibCompressionOptions } from "bun"; +import { expectAssignable, expectType } from "tsd"; +import Bun, { fs, fsPromises } from "."; +// import Bun from "bun"; +// import fs from "fs"; +// import fsPromises from "fs/promises"; + +// Testing ../bun.d.ts + +// FileBlob +expectType>(Bun.file("index.test-d.ts").stream()); +expectType>(Bun.file("index.test-d.ts").arrayBuffer()); +expectType>(Bun.file("index.test-d.ts").text()); + +expectType(Bun.file("index.test-d.ts").size); +expectType(Bun.file("index.test-d.ts").type); + +// Hash +expectType(new Bun.MD4().update("test").digest("hex")); +expectType(new Bun.MD5().update("test").digest("hex")); +expectType(new Bun.SHA1().update("test").digest("hex")); +expectType(new Bun.SHA224().update("test").digest("hex")); +expectType(new Bun.SHA256().update("test").digest("hex")); +expectType(new Bun.SHA384().update("test").digest("hex")); +expectType(new Bun.SHA512().update("test").digest("hex")); +expectType(new Bun.SHA512_256().update("test").digest("hex")); + +// Zlib Functions +expectType(Bun.deflateSync(new Uint8Array(128))); +expectType(Bun.gzipSync(new Uint8Array(128))); +expectType( + Bun.deflateSync(new Uint8Array(128), { + level: -1, + memLevel: 8, + strategy: 0, + windowBits: 15, + }), +); +expectType( + Bun.gzipSync(new Uint8Array(128), { level: 9, memLevel: 6, windowBits: 27 }), +); +expectType(Bun.inflateSync(new Uint8Array(64))); // Pretend this is DEFLATE compressed data +expectType(Bun.gunzipSync(new Uint8Array(64))); // Pretend this is GZIP compressed data +expectAssignable({ windowBits: -11 }); + +// Other +expectType>(Bun.write("test.json", "lol")); +expectType>(Bun.write("test.json", new ArrayBuffer(32))); +expectType(Bun.pathToFileURL("/foo/bar.txt")); +expectType(Bun.fileURLToPath(new URL("file:///foo/bar.txt"))); + +// Testing ../fs.d.ts +expectType( + fs.readFileSync("./index.d.ts", { encoding: "utf-8" }).toString(), +); +expectType(fs.existsSync("./index.d.ts")); +expectType(fs.accessSync("./index.d.ts")); +expectType(fs.appendFileSync("./index.d.ts", "test")); +expectType(fs.mkdirSync("./index.d.ts")); + +// Testing ^promises.d.ts +expectType( + (await fsPromises.readFile("./index.d.ts", { encoding: "utf-8" })).toString(), +); +expectType>(fsPromises.access("./index.d.ts")); +expectType>(fsPromises.appendFile("./index.d.ts", "test")); +expectType>(fsPromises.mkdir("./index.d.ts")); + +Bun.env; + +Bun.version; diff --git a/packages/bun-types/tests/tcp.test-d.ts b/packages/bun-types/tests/tcp.test-d.ts new file mode 100644 index 0000000000..9cfcbebda7 --- /dev/null +++ b/packages/bun-types/tests/tcp.test-d.ts @@ -0,0 +1,132 @@ +import * as Bun from "bun"; + +await Bun.connect({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLocaleLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + hostname: "adsf", + port: 324, +}); + +await Bun.connect({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + hostname: "adsf", + port: 324, + tls: { + certFile: "asdf", + keyFile: "adsf", + }, +}); + +await Bun.connect({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + unix: "asdf", +}); + +await Bun.connect({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + unix: "asdf", +}); + +Bun.listen({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + hostname: "adsf", + port: 324, +}); + +Bun.listen({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + hostname: "adsf", + port: 324, + tls: { + certFile: "asdf", + keyFile: "adsf", + }, +}); + +Bun.listen({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + unix: "asdf", +}); + +const listener = Bun.listen({ + data: { arg: "asdf" }, + socket: { + data(socket) { + socket.data.arg.toLowerCase(); + }, + open() { + console.log("asdf"); + }, + }, + unix: "asdf", +}); + +listener.data.arg = "asdf"; +// @ts-expect-error arg is string +listener.data.arg = 234; + +// listener.reload({ +// data: {arg: 'asdf'}, +// }); + +listener.reload({ + socket: { + open() {}, + // ...listener. + }, +}); diff --git a/packages/bun-types/timers.d.ts b/packages/bun-types/timers.d.ts new file mode 100644 index 0000000000..522ae6a187 --- /dev/null +++ b/packages/bun-types/timers.d.ts @@ -0,0 +1,24 @@ +/** + * The `timer` module exposes a global API for scheduling functions to + * be called at some future period of time. Because the timer functions are + * globals, there is no need to call `require('timers')` to use the API. + * + * The timer functions within Node.js implement a similar API as the timers API + * provided by Web Browsers but use a different internal implementation that is + * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout). + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/timers.js) + */ + +declare module "timers" { + const _exported: { + clearTimeout: typeof clearTimeout; + clearInterval: typeof clearInterval; + setTimeout: typeof setTimeout; + setInterval: typeof setInterval; + }; + export = _exported; +} +declare module "node:timers" { + import timers = require("timers"); + export = timers; +} diff --git a/packages/bun-types/tsconfig.docs.json b/packages/bun-types/tsconfig.docs.json new file mode 100644 index 0000000000..05b4cb10b3 --- /dev/null +++ b/packages/bun-types/tsconfig.docs.json @@ -0,0 +1,25 @@ +{ + "compilerOptions": { + "composite": true, + "emitDeclarationOnly": true, + "lib": [ + "ESNext" + ], + "baseUrl": ".", + "rootDir": ".", + "outFile": "./types.d.ts", + "skipLibCheck": true, + "target": "esnext", + "disableSolutionSearching": true + }, + "include": [ + "./*.d.ts", + "dist" + ], + "exclude": [ + "node_modules", + "./node_modules", + "./node_modules/*", + "./node_modules/@types/node/index.d.ts" + ] +} \ No newline at end of file diff --git a/packages/bun-types/tsconfig.json b/packages/bun-types/tsconfig.json new file mode 100644 index 0000000000..f88d23096d --- /dev/null +++ b/packages/bun-types/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "lib": [ + "ESNext" + ], + "skipLibCheck": true, + "strict": true, + "target": "esnext", + "module": "esnext", + "moduleResolution": "node", + "allowSyntheticDefaultImports": true, + "disableSolutionSearching": true + }, + "exclude": [ + "dist", + "node_modules", + "./node_modules", + "./node_modules/*", + "./node_modules/@types/node/index.d.ts" + ] +} \ No newline at end of file diff --git a/packages/bun-types/tty.d.ts b/packages/bun-types/tty.d.ts new file mode 100644 index 0000000000..49f78fa2c5 --- /dev/null +++ b/packages/bun-types/tty.d.ts @@ -0,0 +1,17 @@ +declare module "tty" { + /** + * The `tty.isatty()` method returns `true` if the given `fd` is associated with + * a TTY and `false` if it is not, including whenever `fd` is not a non-negative + * integer. + * @since v0.5.8 + * @param fd A numeric file descriptor + */ + function isatty(fd: number): boolean; + + // TODO: tty-browserify only polyfills functions that throws errors, wouldn't make sense to have types at the moment + var ReadStream: Function; + var WriteStream: Function; +} +declare module "node:tty" { + export * from "tty"; +} diff --git a/packages/bun-types/typedoc.json b/packages/bun-types/typedoc.json new file mode 100644 index 0000000000..0fc79d1113 --- /dev/null +++ b/packages/bun-types/typedoc.json @@ -0,0 +1,8 @@ +{ + "media": "images", + "tsconfig": "./tsconfig.docs.json", + "entryPoints": ["./dist/types.d.ts"], + "out": "docs", + "exclude": ["**/node_modules/**"], + "disableSources": true +} diff --git a/packages/bun-types/url.d.ts b/packages/bun-types/url.d.ts new file mode 100644 index 0000000000..c63a911743 --- /dev/null +++ b/packages/bun-types/url.d.ts @@ -0,0 +1,347 @@ +/** + * The `url` module provides utilities for URL resolution and parsing. It can be + * accessed using: + * + * ```js + * import url from 'url'; + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/url.js) + */ +declare module "url" { + import { ParsedUrlQuery, ParsedUrlQueryInput } from "node:querystring"; + // Input to `url.format` + interface UrlObject { + auth?: string | null | undefined; + hash?: string | null | undefined; + host?: string | null | undefined; + hostname?: string | null | undefined; + href?: string | null | undefined; + pathname?: string | null | undefined; + protocol?: string | null | undefined; + search?: string | null | undefined; + slashes?: boolean | null | undefined; + port?: string | number | null | undefined; + query?: string | null | ParsedUrlQueryInput | undefined; + } + // Output of `url.parse` + interface Url { + auth: string | null; + hash: string | null; + host: string | null; + hostname: string | null; + href: string; + path: string | null; + pathname: string | null; + protocol: string | null; + search: string | null; + slashes: boolean | null; + port: string | null; + query: string | null | ParsedUrlQuery; + } + interface UrlWithParsedQuery extends Url { + query: ParsedUrlQuery; + } + interface UrlWithStringQuery extends Url { + query: string | null; + } + /** + * The `url.parse()` method takes a URL string, parses it, and returns a URL + * object. + * + * A `TypeError` is thrown if `urlString` is not a string. + * + * A `URIError` is thrown if the `auth` property is present but cannot be decoded. + * + * Use of the legacy `url.parse()` method is discouraged. Users should + * use the WHATWG `URL` API. Because the `url.parse()` method uses a + * lenient, non-standard algorithm for parsing URL strings, security + * issues can be introduced. Specifically, issues with [host name spoofing](https://hackerone.com/reports/678487) and + * incorrect handling of usernames and passwords have been identified. + * + * Deprecation of this API has been shelved for now primarily due to the the + * inability of the [WHATWG API to parse relative URLs](https://github.com/nodejs/node/issues/12682#issuecomment-1154492373). + * [Discussions are ongoing](https://github.com/whatwg/url/issues/531) for the best way to resolve this. + * + * @since v0.1.25 + * @param urlString The URL string to parse. + * @param [parseQueryString=false] If `true`, the `query` property will always be set to an object returned by the {@link querystring} module's `parse()` method. If `false`, the `query` property + * on the returned URL object will be an unparsed, undecoded string. + * @param [slashesDenoteHost=false] If `true`, the first token after the literal string `//` and preceding the next `/` will be interpreted as the `host`. For instance, given `//foo/bar`, the + * result would be `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`. + */ + function parse(urlString: string): UrlWithStringQuery; + function parse( + urlString: string, + parseQueryString: false | undefined, + slashesDenoteHost?: boolean, + ): UrlWithStringQuery; + function parse( + urlString: string, + parseQueryString: true, + slashesDenoteHost?: boolean, + ): UrlWithParsedQuery; + function parse( + urlString: string, + parseQueryString: boolean, + slashesDenoteHost?: boolean, + ): Url; + /** + * The `url.format()` method returns a formatted URL string derived from`urlObject`. + * + * ```js + * const url = require('url'); + * url.format({ + * protocol: 'https', + * hostname: 'example.com', + * pathname: '/some/path', + * query: { + * page: 1, + * format: 'json' + * } + * }); + * + * // => 'https://example.com/some/path?page=1&format=json' + * ``` + * + * If `urlObject` is not an object or a string, `url.format()` will throw a `TypeError`. + * + * The formatting process operates as follows: + * + * * A new empty string `result` is created. + * * If `urlObject.protocol` is a string, it is appended as-is to `result`. + * * Otherwise, if `urlObject.protocol` is not `undefined` and is not a string, an `Error` is thrown. + * * For all string values of `urlObject.protocol` that _do not end_ with an ASCII + * colon (`:`) character, the literal string `:` will be appended to `result`. + * * If either of the following conditions is true, then the literal string `//`will be appended to `result`: + * * `urlObject.slashes` property is true; + * * `urlObject.protocol` begins with `http`, `https`, `ftp`, `gopher`, or`file`; + * * If the value of the `urlObject.auth` property is truthy, and either`urlObject.host` or `urlObject.hostname` are not `undefined`, the value of`urlObject.auth` will be coerced into a string + * and appended to `result`followed by the literal string `@`. + * * If the `urlObject.host` property is `undefined` then: + * * If the `urlObject.hostname` is a string, it is appended to `result`. + * * Otherwise, if `urlObject.hostname` is not `undefined` and is not a string, + * an `Error` is thrown. + * * If the `urlObject.port` property value is truthy, and `urlObject.hostname`is not `undefined`: + * * The literal string `:` is appended to `result`, and + * * The value of `urlObject.port` is coerced to a string and appended to`result`. + * * Otherwise, if the `urlObject.host` property value is truthy, the value of`urlObject.host` is coerced to a string and appended to `result`. + * * If the `urlObject.pathname` property is a string that is not an empty string: + * * If the `urlObject.pathname`_does not start_ with an ASCII forward slash + * (`/`), then the literal string `'/'` is appended to `result`. + * * The value of `urlObject.pathname` is appended to `result`. + * * Otherwise, if `urlObject.pathname` is not `undefined` and is not a string, an `Error` is thrown. + * * If the `urlObject.search` property is `undefined` and if the `urlObject.query`property is an `Object`, the literal string `?` is appended to `result`followed by the output of calling the + * `querystring` module's `stringify()`method passing the value of `urlObject.query`. + * * Otherwise, if `urlObject.search` is a string: + * * If the value of `urlObject.search`_does not start_ with the ASCII question + * mark (`?`) character, the literal string `?` is appended to `result`. + * * The value of `urlObject.search` is appended to `result`. + * * Otherwise, if `urlObject.search` is not `undefined` and is not a string, an `Error` is thrown. + * * If the `urlObject.hash` property is a string: + * * If the value of `urlObject.hash`_does not start_ with the ASCII hash (`#`) + * character, the literal string `#` is appended to `result`. + * * The value of `urlObject.hash` is appended to `result`. + * * Otherwise, if the `urlObject.hash` property is not `undefined` and is not a + * string, an `Error` is thrown. + * * `result` is returned. + * @since v0.1.25 + * @deprecated Legacy: Use the WHATWG URL API instead. + * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`. + */ + function format(urlObject: URL, options?: URLFormatOptions): string; + /** + * The `url.format()` method returns a formatted URL string derived from`urlObject`. + * + * ```js + * const url = require('url'); + * url.format({ + * protocol: 'https', + * hostname: 'example.com', + * pathname: '/some/path', + * query: { + * page: 1, + * format: 'json' + * } + * }); + * + * // => 'https://example.com/some/path?page=1&format=json' + * ``` + * + * If `urlObject` is not an object or a string, `url.format()` will throw a `TypeError`. + * + * The formatting process operates as follows: + * + * * A new empty string `result` is created. + * * If `urlObject.protocol` is a string, it is appended as-is to `result`. + * * Otherwise, if `urlObject.protocol` is not `undefined` and is not a string, an `Error` is thrown. + * * For all string values of `urlObject.protocol` that _do not end_ with an ASCII + * colon (`:`) character, the literal string `:` will be appended to `result`. + * * If either of the following conditions is true, then the literal string `//`will be appended to `result`: + * * `urlObject.slashes` property is true; + * * `urlObject.protocol` begins with `http`, `https`, `ftp`, `gopher`, or`file`; + * * If the value of the `urlObject.auth` property is truthy, and either`urlObject.host` or `urlObject.hostname` are not `undefined`, the value of`urlObject.auth` will be coerced into a string + * and appended to `result`followed by the literal string `@`. + * * If the `urlObject.host` property is `undefined` then: + * * If the `urlObject.hostname` is a string, it is appended to `result`. + * * Otherwise, if `urlObject.hostname` is not `undefined` and is not a string, + * an `Error` is thrown. + * * If the `urlObject.port` property value is truthy, and `urlObject.hostname`is not `undefined`: + * * The literal string `:` is appended to `result`, and + * * The value of `urlObject.port` is coerced to a string and appended to`result`. + * * Otherwise, if the `urlObject.host` property value is truthy, the value of`urlObject.host` is coerced to a string and appended to `result`. + * * If the `urlObject.pathname` property is a string that is not an empty string: + * * If the `urlObject.pathname`_does not start_ with an ASCII forward slash + * (`/`), then the literal string `'/'` is appended to `result`. + * * The value of `urlObject.pathname` is appended to `result`. + * * Otherwise, if `urlObject.pathname` is not `undefined` and is not a string, an `Error` is thrown. + * * If the `urlObject.search` property is `undefined` and if the `urlObject.query`property is an `Object`, the literal string `?` is appended to `result`followed by the output of calling the + * `querystring` module's `stringify()`method passing the value of `urlObject.query`. + * * Otherwise, if `urlObject.search` is a string: + * * If the value of `urlObject.search`_does not start_ with the ASCII question + * mark (`?`) character, the literal string `?` is appended to `result`. + * * The value of `urlObject.search` is appended to `result`. + * * Otherwise, if `urlObject.search` is not `undefined` and is not a string, an `Error` is thrown. + * * If the `urlObject.hash` property is a string: + * * If the value of `urlObject.hash`_does not start_ with the ASCII hash (`#`) + * character, the literal string `#` is appended to `result`. + * * The value of `urlObject.hash` is appended to `result`. + * * Otherwise, if the `urlObject.hash` property is not `undefined` and is not a + * string, an `Error` is thrown. + * * `result` is returned. + * @since v0.1.25 + * @deprecated Legacy: Use the WHATWG URL API instead. + * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`. + */ + function format(urlObject: UrlObject | string): string; + /** + * The `url.resolve()` method resolves a target URL relative to a base URL in a + * manner similar to that of a web browser resolving an anchor tag. + * + * ```js + * const url = require('url'); + * url.resolve('/one/two/three', 'four'); // '/one/two/four' + * url.resolve('http://example.com/', '/one'); // 'http://example.com/one' + * url.resolve('http://example.com/one', '/two'); // 'http://example.com/two' + * ``` + * + * To achieve the same result using the WHATWG URL API: + * + * ```js + * function resolve(from, to) { + * const resolvedUrl = new URL(to, new URL(from, 'resolve://')); + * if (resolvedUrl.protocol === 'resolve:') { + * // `from` is a relative URL. + * const { pathname, search, hash } = resolvedUrl; + * return pathname + search + hash; + * } + * return resolvedUrl.toString(); + * } + * + * resolve('/one/two/three', 'four'); // '/one/two/four' + * resolve('http://example.com/', '/one'); // 'http://example.com/one' + * resolve('http://example.com/one', '/two'); // 'http://example.com/two' + * ``` + * @since v0.1.25 + * @deprecated Legacy: Use the WHATWG URL API instead. + * @param from The base URL to use if `to` is a relative URL. + * @param to The target URL to resolve. + */ + function resolve(from: string, to: string): string; + /** + * This function ensures the correct decodings of percent-encoded characters as + * well as ensuring a cross-platform valid absolute path string. + * + * ```js + * import { fileURLToPath } from 'url'; + * + * const __filename = fileURLToPath(import.meta.url); + * + * new URL('file:///C:/path/').pathname; // Incorrect: /C:/path/ + * fileURLToPath('file:///C:/path/'); // Correct: C:\path\ (Windows) + * + * new URL('file://nas/foo.txt').pathname; // Incorrect: /foo.txt + * fileURLToPath('file://nas/foo.txt'); // Correct: \\nas\foo.txt (Windows) + * + * new URL('file:///你好.txt').pathname; // Incorrect: /%E4%BD%A0%E5%A5%BD.txt + * fileURLToPath('file:///你好.txt'); // Correct: /你好.txt (POSIX) + * + * new URL('file:///hello world').pathname; // Incorrect: /hello%20world + * fileURLToPath('file:///hello world'); // Correct: /hello world (POSIX) + * ``` + * @since v10.12.0 + * @param url The file URL string or URL object to convert to a path. + * @return The fully-resolved platform-specific Node.js file path. + */ + function fileURLToPath(url: string | URL): string; + /** + * This function ensures that `path` is resolved absolutely, and that the URL + * control characters are correctly encoded when converting into a File URL. + * + * ```js + * import { pathToFileURL } from 'url'; + * + * new URL('/foo#1', 'file:'); // Incorrect: file:///foo#1 + * pathToFileURL('/foo#1'); // Correct: file:///foo%231 (POSIX) + * + * new URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c + * pathToFileURL('/some/path%.c'); // Correct: file:///some/path%25.c (POSIX) + * ``` + * @since v10.12.0 + * @param path The path to convert to a File URL. + * @return The file URL object. + */ + function pathToFileURL(path: string): URL; + interface URLFormatOptions { + auth?: boolean | undefined; + fragment?: boolean | undefined; + search?: boolean | undefined; + unicode?: boolean | undefined; + } + + /** + * The URL interface represents an object providing static methods used for + * creating object URLs. + */ + interface URL { + hash: string; + host: string; + hostname: string; + href: string; + toString(): string; + readonly origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + search: string; + readonly searchParams: URLSearchParams; + username: string; + toJSON(): string; + } + + interface URLSearchParams { + /** Appends a specified key/value pair as a new search parameter. */ + append(name: string, value: string): void; + /** Deletes the given search parameter, and its associated value, from the list of all search parameters. */ + delete(name: string): void; + /** Returns the first value associated to the given search parameter. */ + get(name: string): string | null; + /** Returns all the values association with a given search parameter. */ + getAll(name: string): string[]; + /** Returns a Boolean indicating if such a search parameter exists. */ + has(name: string): boolean; + /** Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. */ + set(name: string, value: string): void; + sort(): void; + /** Returns a string containing a query string suitable for use in a URL. Does not include the question mark. */ + toString(): string; + forEach( + callbackfn: (value: string, key: string, parent: URLSearchParams) => void, + thisArg?: any, + ): void; + } +} + +declare module "node:url" { + export * from "url"; +} diff --git a/packages/bun-types/util.d.ts b/packages/bun-types/util.d.ts new file mode 100644 index 0000000000..0f9359b104 --- /dev/null +++ b/packages/bun-types/util.d.ts @@ -0,0 +1,1183 @@ +/** + * The `util` module supports the needs of Node.js internal APIs. Many of the + * utilities are useful for application and module developers as well. To access + * it: + * + * ```js + * const util = require('util'); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/util.js) + */ +declare module "util" { + export interface InspectOptions { + /** + * If set to `true`, getters are going to be + * inspected as well. If set to `'get'` only getters without setter are going + * to be inspected. If set to `'set'` only getters having a corresponding + * setter are going to be inspected. This might cause side effects depending on + * the getter function. + * @default `false` + */ + getters?: "get" | "set" | boolean | undefined; + showHidden?: boolean | undefined; + /** + * @default 2 + */ + depth?: number | null | undefined; + colors?: boolean | undefined; + customInspect?: boolean | undefined; + showProxy?: boolean | undefined; + maxArrayLength?: number | null | undefined; + /** + * Specifies the maximum number of characters to + * include when formatting. Set to `null` or `Infinity` to show all elements. + * Set to `0` or negative to show no characters. + * @default 10000 + */ + maxStringLength?: number | null | undefined; + breakLength?: number | undefined; + /** + * Setting this to `false` causes each object key + * to be displayed on a new line. It will also add new lines to text that is + * longer than `breakLength`. If set to a number, the most `n` inner elements + * are united on a single line as long as all properties fit into + * `breakLength`. Short array elements are also grouped together. Note that no + * text will be reduced below 16 characters, no matter the `breakLength` size. + * For more information, see the example below. + * @default `true` + */ + compact?: boolean | number | undefined; + sorted?: boolean | ((a: string, b: string) => number) | undefined; + } + export type Style = + | "special" + | "number" + | "bigint" + | "boolean" + | "undefined" + | "null" + | "string" + | "symbol" + | "date" + | "regexp" + | "module"; + export type CustomInspectFunction = ( + depth: number, + options: InspectOptionsStylized, + ) => string; + export interface InspectOptionsStylized extends InspectOptions { + stylize(text: string, styleType: Style): string; + } + /** + * The `util.format()` method returns a formatted string using the first argument + * as a `printf`\-like format string which can contain zero or more format + * specifiers. Each specifier is replaced with the converted value from the + * corresponding argument. Supported specifiers are: + * + * If a specifier does not have a corresponding argument, it is not replaced: + * + * ```js + * util.format('%s:%s', 'foo'); + * // Returns: 'foo:%s' + * ``` + * + * Values that are not part of the format string are formatted using`util.inspect()` if their type is not `string`. + * + * If there are more arguments passed to the `util.format()` method than the + * number of specifiers, the extra arguments are concatenated to the returned + * string, separated by spaces: + * + * ```js + * util.format('%s:%s', 'foo', 'bar', 'baz'); + * // Returns: 'foo:bar baz' + * ``` + * + * If the first argument does not contain a valid format specifier, `util.format()`returns a string that is the concatenation of all arguments separated by spaces: + * + * ```js + * util.format(1, 2, 3); + * // Returns: '1 2 3' + * ``` + * + * If only one argument is passed to `util.format()`, it is returned as it is + * without any formatting: + * + * ```js + * util.format('%% %s'); + * // Returns: '%% %s' + * ``` + * + * `util.format()` is a synchronous method that is intended as a debugging tool. + * Some input values can have a significant performance overhead that can block the + * event loop. Use this function with care and never in a hot code path. + * @param format A `printf`-like format string. + */ + export function format(format?: any, ...param: any[]): string; + /** + * This function is identical to {@link format}, except in that it takes + * an `inspectOptions` argument which specifies options that are passed along to {@link inspect}. + * + * ```js + * util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 }); + * // Returns 'See object { foo: 42 }', where `42` is colored as a number + * // when printed to a terminal. + * ``` + */ + // FIXME: util.formatWithOptions is typed, but is not defined in the polyfill + // export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string; + /** + * Returns the string name for a numeric error code that comes from a Node.js API. + * The mapping between error codes and error names is platform-dependent. + * See `Common System Errors` for the names of common errors. + * + * ```js + * fs.access('file/that/does/not/exist', (err) => { + * const name = util.getSystemErrorName(err.errno); + * console.error(name); // ENOENT + * }); + * ``` + */ + // FIXME: util.getSystemErrorName is typed, but is not defined in the polyfill + // export function getSystemErrorName(err: number): string; + /** + * Returns a Map of all system error codes available from the Node.js API. + * The mapping between error codes and error names is platform-dependent. + * See `Common System Errors` for the names of common errors. + * + * ```js + * fs.access('file/that/does/not/exist', (err) => { + * const errorMap = util.getSystemErrorMap(); + * const name = errorMap.get(err.errno); + * console.error(name); // ENOENT + * }); + * ``` + */ + // FIXME: util.getSystemErrorMap is typed, but is not defined in the polyfill + // export function getSystemErrorMap(): Map; + /** + * The `util.log()` method prints the given `string` to `stdout` with an included + * timestamp. + * + * ```js + * const util = require('util'); + * + * util.log('Timestamped message.'); + * ``` + * @deprecated Since v6.0.0 - Use a third party module instead. + */ + export function log(string: string): void; + /** + * Returns the `string` after replacing any surrogate code points + * (or equivalently, any unpaired surrogate code units) with the + * Unicode "replacement character" U+FFFD. + */ + // FIXME: util.toUSVString is typed, but is not defined in the polyfill + // export function toUSVString(string: string): string; + /** + * The `util.inspect()` method returns a string representation of `object` that is + * intended for debugging. The output of `util.inspect` may change at any time + * and should not be depended upon programmatically. Additional `options` may be + * passed that alter the result.`util.inspect()` will use the constructor's name and/or `@@toStringTag` to make + * an identifiable tag for an inspected value. + * + * ```js + * class Foo { + * get [Symbol.toStringTag]() { + * return 'bar'; + * } + * } + * + * class Bar {} + * + * const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } }); + * + * util.inspect(new Foo()); // 'Foo [bar] {}' + * util.inspect(new Bar()); // 'Bar {}' + * util.inspect(baz); // '[foo] {}' + * ``` + * + * Circular references point to their anchor by using a reference index: + * + * ```js + * const { inspect } = require('util'); + * + * const obj = {}; + * obj.a = [obj]; + * obj.b = {}; + * obj.b.inner = obj.b; + * obj.b.obj = obj; + * + * console.log(inspect(obj)); + * // { + * // a: [ [Circular *1] ], + * // b: { inner: [Circular *2], obj: [Circular *1] } + * // } + * ``` + * + * The following example inspects all properties of the `util` object: + * + * ```js + * const util = require('util'); + * + * console.log(util.inspect(util, { showHidden: true, depth: null })); + * ``` + * + * The following example highlights the effect of the `compact` option: + * + * ```js + * const util = require('util'); + * + * const o = { + * a: [1, 2, [[ + * 'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' + + * 'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.', + * 'test', + * 'foo']], 4], + * b: new Map([['za', 1], ['zb', 'test']]) + * }; + * console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 })); + * + * // { a: + * // [ 1, + * // 2, + * // [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line + * // 'test', + * // 'foo' ] ], + * // 4 ], + * // b: Map(2) { 'za' => 1, 'zb' => 'test' } } + * + * // Setting `compact` to false or an integer creates more reader friendly output. + * console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 })); + * + * // { + * // a: [ + * // 1, + * // 2, + * // [ + * // [ + * // 'Lorem ipsum dolor sit amet,\n' + + * // 'consectetur adipiscing elit, sed do eiusmod \n' + + * // 'tempor incididunt ut labore et dolore magna aliqua.', + * // 'test', + * // 'foo' + * // ] + * // ], + * // 4 + * // ], + * // b: Map(2) { + * // 'za' => 1, + * // 'zb' => 'test' + * // } + * // } + * + * // Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a + * // single line. + * ``` + * + * The `showHidden` option allows [`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) and + * [`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) entries to be + * inspected. If there are more entries than `maxArrayLength`, there is no + * guarantee which entries are displayed. That means retrieving the same [`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) entries twice may + * result in different output. Furthermore, entries + * with no remaining strong references may be garbage collected at any time. + * + * ```js + * const { inspect } = require('util'); + * + * const obj = { a: 1 }; + * const obj2 = { b: 2 }; + * const weakSet = new WeakSet([obj, obj2]); + * + * console.log(inspect(weakSet, { showHidden: true })); + * // WeakSet { { a: 1 }, { b: 2 } } + * ``` + * + * The `sorted` option ensures that an object's property insertion order does not + * impact the result of `util.inspect()`. + * + * ```js + * const { inspect } = require('util'); + * const assert = require('assert'); + * + * const o1 = { + * b: [2, 3, 1], + * a: '`a` comes before `b`', + * c: new Set([2, 3, 1]) + * }; + * console.log(inspect(o1, { sorted: true })); + * // { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } } + * console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) })); + * // { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' } + * + * const o2 = { + * c: new Set([2, 1, 3]), + * a: '`a` comes before `b`', + * b: [2, 3, 1] + * }; + * assert.strict.equal( + * inspect(o1, { sorted: true }), + * inspect(o2, { sorted: true }) + * ); + * ``` + * + * The `numericSeparator` option adds an underscore every three digits to all + * numbers. + * + * ```js + * const { inspect } = require('util'); + * + * const thousand = 1_000; + * const million = 1_000_000; + * const bigNumber = 123_456_789n; + * const bigDecimal = 1_234.123_45; + * + * console.log(thousand, million, bigNumber, bigDecimal); + * // 1_000 1_000_000 123_456_789n 1_234.123_45 + * ``` + * + * `util.inspect()` is a synchronous method intended for debugging. Its maximum + * output length is approximately 128 MB. Inputs that result in longer output will + * be truncated. + * @param object Any JavaScript primitive or `Object`. + * @return The representation of `object`. + */ + export function inspect( + object: any, + showHidden?: boolean, + depth?: number | null, + color?: boolean, + ): string; + export function inspect(object: any, options?: InspectOptions): string; + export namespace inspect { + let colors: Dict<[number, number]>; + let styles: { + [K in Style]: string; + }; + let defaultOptions: InspectOptions; + /** + * Allows changing inspect settings from the repl. + */ + let replDefaults: InspectOptions; + /** + * That can be used to declare custom inspect functions. + */ + const custom: unique symbol; + } + /** + * Alias for [`Array.isArray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray). + * + * Returns `true` if the given `object` is an `Array`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isArray([]); + * // Returns: true + * util.isArray(new Array()); + * // Returns: true + * util.isArray({}); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Use `isArray` instead. + */ + export function isArray(object: unknown): object is unknown[]; + /** + * Returns `true` if the given `object` is a `RegExp`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isRegExp(/some regexp/); + * // Returns: true + * util.isRegExp(new RegExp('another regexp')); + * // Returns: true + * util.isRegExp({}); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Deprecated + */ + export function isRegExp(object: unknown): object is RegExp; + /** + * Returns `true` if the given `object` is a `Date`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isDate(new Date()); + * // Returns: true + * util.isDate(Date()); + * // false (without 'new' returns a String) + * util.isDate({}); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Use {@link types.isDate} instead. + */ + export function isDate(object: unknown): object is Date; + /** + * Returns `true` if the given `object` is an `Error`. Otherwise, returns`false`. + * + * ```js + * const util = require('util'); + * + * util.isError(new Error()); + * // Returns: true + * util.isError(new TypeError()); + * // Returns: true + * util.isError({ name: 'Error', message: 'an error occurred' }); + * // Returns: false + * ``` + * + * This method relies on `Object.prototype.toString()` behavior. It is + * possible to obtain an incorrect result when the `object` argument manipulates`@@toStringTag`. + * + * ```js + * const util = require('util'); + * const obj = { name: 'Error', message: 'an error occurred' }; + * + * util.isError(obj); + * // Returns: false + * obj[Symbol.toStringTag] = 'Error'; + * util.isError(obj); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use {@link types.isNativeError} instead. + */ + export function isError(object: unknown): object is Error; + /** + * Usage of `util.inherits()` is discouraged. Please use the ES6 `class` and`extends` keywords to get language level inheritance support. Also note + * that the two styles are [semantically incompatible](https://github.com/nodejs/node/issues/4179). + * + * Inherit the prototype methods from one [constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) into another. The + * prototype of `constructor` will be set to a new object created from`superConstructor`. + * + * This mainly adds some input validation on top of`Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)`. + * As an additional convenience, `superConstructor` will be accessible + * through the `constructor.super_` property. + * + * ```js + * const util = require('util'); + * const EventEmitter = require('events'); + * + * function MyStream() { + * EventEmitter.call(this); + * } + * + * util.inherits(MyStream, EventEmitter); + * + * MyStream.prototype.write = function(data) { + * this.emit('data', data); + * }; + * + * const stream = new MyStream(); + * + * console.log(stream instanceof EventEmitter); // true + * console.log(MyStream.super_ === EventEmitter); // true + * + * stream.on('data', (data) => { + * console.log(`Received data: "${data}"`); + * }); + * stream.write('It works!'); // Received data: "It works!" + * ``` + * + * ES6 example using `class` and `extends`: + * + * ```js + * const EventEmitter = require('events'); + * + * class MyStream extends EventEmitter { + * write(data) { + * this.emit('data', data); + * } + * } + * + * const stream = new MyStream(); + * + * stream.on('data', (data) => { + * console.log(`Received data: "${data}"`); + * }); + * stream.write('With ES6'); + * ``` + * @deprecated Legacy: Use ES2015 class syntax and `extends` keyword instead. + */ + export function inherits( + constructor: unknown, + superConstructor: unknown, + ): void; + export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void; + export interface DebugLogger extends DebugLoggerFunction { + enabled: boolean; + } + /** + * The `util.debuglog()` method is used to create a function that conditionally + * writes debug messages to `stderr` based on the existence of the `NODE_DEBUG`environment variable. If the `section` name appears within the value of that + * environment variable, then the returned function operates similar to `console.error()`. If not, then the returned function is a no-op. + * + * ```js + * const util = require('util'); + * const debuglog = util.debuglog('foo'); + * + * debuglog('hello from foo [%d]', 123); + * ``` + * + * If this program is run with `NODE_DEBUG=foo` in the environment, then + * it will output something like: + * + * ```console + * FOO 3245: hello from foo [123] + * ``` + * + * where `3245` is the process id. If it is not run with that + * environment variable set, then it will not print anything. + * + * The `section` supports wildcard also: + * + * ```js + * const util = require('util'); + * const debuglog = util.debuglog('foo-bar'); + * + * debuglog('hi there, it\'s foo-bar [%d]', 2333); + * ``` + * + * if it is run with `NODE_DEBUG=foo*` in the environment, then it will output + * something like: + * + * ```console + * FOO-BAR 3257: hi there, it's foo-bar [2333] + * ``` + * + * Multiple comma-separated `section` names may be specified in the `NODE_DEBUG`environment variable: `NODE_DEBUG=fs,net,tls`. + * + * The optional `callback` argument can be used to replace the logging function + * with a different function that doesn't have any initialization or + * unnecessary wrapping. + * + * ```js + * const util = require('util'); + * let debuglog = util.debuglog('internals', (debug) => { + * // Replace with a logging function that optimizes out + * // testing if the section is enabled + * debuglog = debug; + * }); + * ``` + * @param section A string identifying the portion of the application for which the `debuglog` function is being created. + * @param callback A callback invoked the first time the logging function is called with a function argument that is a more optimized logging function. + * @return The logging function + */ + export function debuglog( + section: string, + callback?: (fn: DebugLoggerFunction) => void, + ): DebugLogger; + export const debug: typeof debuglog; + /** + * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isBoolean(1); + * // Returns: false + * util.isBoolean(0); + * // Returns: false + * util.isBoolean(false); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `typeof value === 'boolean'` instead. + */ + export function isBoolean(object: unknown): object is boolean; + /** + * Returns `true` if the given `object` is a `Buffer`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isBuffer({ length: 0 }); + * // Returns: false + * util.isBuffer([]); + * // Returns: false + * util.isBuffer(Buffer.from('hello world')); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `isBuffer` instead. + */ + export function isBuffer(object: unknown): object is Buffer; + /** + * Returns `true` if the given `object` is a `Function`. Otherwise, returns`false`. + * + * ```js + * const util = require('util'); + * + * function Foo() {} + * const Bar = () => {}; + * + * util.isFunction({}); + * // Returns: false + * util.isFunction(Foo); + * // Returns: true + * util.isFunction(Bar); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `typeof value === 'function'` instead. + */ + export function isFunction(object: unknown): boolean; + /** + * Returns `true` if the given `object` is strictly `null`. Otherwise, returns`false`. + * + * ```js + * const util = require('util'); + * + * util.isNull(0); + * // Returns: false + * util.isNull(undefined); + * // Returns: false + * util.isNull(null); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `value === null` instead. + */ + export function isNull(object: unknown): object is null; + /** + * Returns `true` if the given `object` is `null` or `undefined`. Otherwise, + * returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isNullOrUndefined(0); + * // Returns: false + * util.isNullOrUndefined(undefined); + * // Returns: true + * util.isNullOrUndefined(null); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `value === undefined || value === null` instead. + */ + export function isNullOrUndefined( + object: unknown, + ): object is null | undefined; + /** + * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isNumber(false); + * // Returns: false + * util.isNumber(Infinity); + * // Returns: true + * util.isNumber(0); + * // Returns: true + * util.isNumber(NaN); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `typeof value === 'number'` instead. + */ + export function isNumber(object: unknown): object is number; + /** + * Returns `true` if the given `object` is strictly an `Object`**and** not a`Function` (even though functions are objects in JavaScript). + * Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isObject(5); + * // Returns: false + * util.isObject(null); + * // Returns: false + * util.isObject({}); + * // Returns: true + * util.isObject(() => {}); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Deprecated: Use `value !== null && typeof value === 'object'` instead. + */ + export function isObject(object: unknown): boolean; + /** + * Returns `true` if the given `object` is a primitive type. Otherwise, returns`false`. + * + * ```js + * const util = require('util'); + * + * util.isPrimitive(5); + * // Returns: true + * util.isPrimitive('foo'); + * // Returns: true + * util.isPrimitive(false); + * // Returns: true + * util.isPrimitive(null); + * // Returns: true + * util.isPrimitive(undefined); + * // Returns: true + * util.isPrimitive({}); + * // Returns: false + * util.isPrimitive(() => {}); + * // Returns: false + * util.isPrimitive(/^$/); + * // Returns: false + * util.isPrimitive(new Date()); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Use `(typeof value !== 'object' && typeof value !== 'function') || value === null` instead. + */ + export function isPrimitive(object: unknown): boolean; + /** + * Returns `true` if the given `object` is a `string`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isString(''); + * // Returns: true + * util.isString('foo'); + * // Returns: true + * util.isString(String('foo')); + * // Returns: true + * util.isString(5); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Use `typeof value === 'string'` instead. + */ + export function isString(object: unknown): object is string; + /** + * Returns `true` if the given `object` is a `Symbol`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * util.isSymbol(5); + * // Returns: false + * util.isSymbol('foo'); + * // Returns: false + * util.isSymbol(Symbol('foo')); + * // Returns: true + * ``` + * @deprecated Since v4.0.0 - Use `typeof value === 'symbol'` instead. + */ + export function isSymbol(object: unknown): object is symbol; + /** + * Returns `true` if the given `object` is `undefined`. Otherwise, returns `false`. + * + * ```js + * const util = require('util'); + * + * const foo = undefined; + * util.isUndefined(5); + * // Returns: false + * util.isUndefined(foo); + * // Returns: true + * util.isUndefined(null); + * // Returns: false + * ``` + * @deprecated Since v4.0.0 - Use `value === undefined` instead. + */ + export function isUndefined(object: unknown): object is undefined; + /** + * The `util.deprecate()` method wraps `fn` (which may be a function or class) in + * such a way that it is marked as deprecated. + * + * ```js + * const util = require('util'); + * + * exports.obsoleteFunction = util.deprecate(() => { + * // Do something here. + * }, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.'); + * ``` + * + * When called, `util.deprecate()` will return a function that will emit a`DeprecationWarning` using the `'warning'` event. The warning will + * be emitted and printed to `stderr` the first time the returned function is + * called. After the warning is emitted, the wrapped function is called without + * emitting a warning. + * + * If the same optional `code` is supplied in multiple calls to `util.deprecate()`, + * the warning will be emitted only once for that `code`. + * + * ```js + * const util = require('util'); + * + * const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001'); + * const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001'); + * fn1(); // Emits a deprecation warning with code DEP0001 + * fn2(); // Does not emit a deprecation warning because it has the same code + * ``` + * + * If either the `--no-deprecation` or `--no-warnings` command-line flags are + * used, or if the `process.noDeprecation` property is set to `true`_prior_ to + * the first deprecation warning, the `util.deprecate()` method does nothing. + * + * If the `--trace-deprecation` or `--trace-warnings` command-line flags are set, + * or the `process.traceDeprecation` property is set to `true`, a warning and a + * stack trace are printed to `stderr` the first time the deprecated function is + * called. + * + * If the `--throw-deprecation` command-line flag is set, or the`process.throwDeprecation` property is set to `true`, then an exception will be + * thrown when the deprecated function is called. + * + * The `--throw-deprecation` command-line flag and `process.throwDeprecation`property take precedence over `--trace-deprecation` and`process.traceDeprecation`. + * @param fn The function that is being deprecated. + * @param msg A warning message to display when the deprecated function is invoked. + * @param code A deprecation code. See the `list of deprecated APIs` for a list of codes. + * @return The deprecated function wrapped to emit a warning. + */ + export function deprecate( + fn: T, + msg: string, + code?: string, + ): T; + /** + * Returns `true` if there is deep strict equality between `val1` and `val2`. + * Otherwise, returns `false`. + * + * See `assert.deepStrictEqual()` for more information about deep strict + * equality. + */ + export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean; + /** + * Returns `str` with any ANSI escape codes removed. + * + * ```js + * console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m')); + * // Prints "value" + * ``` + */ + // FIXME: util.stripVTControlCharacters is typed, but is not defined in the polyfill + // export function stripVTControlCharacters(str: string): string; + /** + * Takes an `async` function (or a function that returns a `Promise`) and returns a + * function following the error-first callback style, i.e. taking + * an `(err, value) => ...` callback as the last argument. In the callback, the + * first argument will be the rejection reason (or `null` if the `Promise`resolved), and the second argument will be the resolved value. + * + * ```js + * const util = require('util'); + * + * async function fn() { + * return 'hello world'; + * } + * const callbackFunction = util.callbackify(fn); + * + * callbackFunction((err, ret) => { + * if (err) throw err; + * console.log(ret); + * }); + * ``` + * + * Will print: + * + * ```text + * hello world + * ``` + * + * The callback is executed asynchronously, and will have a limited stack trace. + * If the callback throws, the process will emit an `'uncaughtException'` event, and if not handled will exit. + * + * Since `null` has a special meaning as the first argument to a callback, if a + * wrapped function rejects a `Promise` with a falsy value as a reason, the value + * is wrapped in an `Error` with the original value stored in a field named`reason`. + * + * ```js + * function fn() { + * return Promise.reject(null); + * } + * const callbackFunction = util.callbackify(fn); + * + * callbackFunction((err, ret) => { + * // When the Promise was rejected with `null` it is wrapped with an Error and + * // the original value is stored in `reason`. + * err && Object.hasOwn(err, 'reason') && err.reason === null; // true + * }); + * ``` + * @param original An `async` function + * @return a callback style function + */ + export function callbackify( + fn: () => Promise, + ): (callback: (err: ErrnoException) => void) => void; + export function callbackify( + fn: () => Promise, + ): (callback: (err: ErrnoException, result: TResult) => void) => void; + export function callbackify( + fn: (arg1: T1) => Promise, + ): (arg1: T1, callback: (err: ErrnoException) => void) => void; + export function callbackify( + fn: (arg1: T1) => Promise, + ): ( + arg1: T1, + callback: (err: ErrnoException, result: TResult) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2) => Promise, + ): (arg1: T1, arg2: T2, callback: (err: ErrnoException) => void) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2) => Promise, + ): ( + arg1: T1, + arg2: T2, + callback: (err: ErrnoException | null, result: TResult) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + callback: (err: ErrnoException) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + callback: (err: ErrnoException | null, result: TResult) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + callback: (err: ErrnoException) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + callback: (err: ErrnoException | null, result: TResult) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + callback: (err: ErrnoException) => void, + ) => void; + export function callbackify( + fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + callback: (err: ErrnoException | null, result: TResult) => void, + ) => void; + export function callbackify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + arg6: T6, + ) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + arg6: T6, + callback: (err: ErrnoException) => void, + ) => void; + export function callbackify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + arg6: T6, + ) => Promise, + ): ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + arg6: T6, + callback: (err: ErrnoException | null, result: TResult) => void, + ) => void; + export interface CustomPromisifyLegacy + extends Function { + __promisify__: TCustom; + } + export interface CustomPromisifySymbol + extends Function { + [promisify.custom]: TCustom; + } + export type CustomPromisify = + | CustomPromisifySymbol + | CustomPromisifyLegacy; + /** + * Takes a function following the common error-first callback style, i.e. taking + * an `(err, value) => ...` callback as the last argument, and returns a version + * that returns promises. + * + * ```js + * const util = require('util'); + * const fs = require('fs'); + * + * const stat = util.promisify(fs.stat); + * stat('.').then((stats) => { + * // Do something with `stats` + * }).catch((error) => { + * // Handle the error. + * }); + * ``` + * + * Or, equivalently using `async function`s: + * + * ```js + * const util = require('util'); + * const fs = require('fs'); + * + * const stat = util.promisify(fs.stat); + * + * async function callStat() { + * const stats = await stat('.'); + * console.log(`This directory is owned by ${stats.uid}`); + * } + * ``` + * + * If there is an `original[util.promisify.custom]` property present, `promisify`will return its value, see `Custom promisified functions`. + * + * `promisify()` assumes that `original` is a function taking a callback as its + * final argument in all cases. If `original` is not a function, `promisify()`will throw an error. If `original` is a function but its last argument is not + * an error-first callback, it will still be passed an error-first + * callback as its last argument. + * + * Using `promisify()` on class methods or other methods that use `this` may not + * work as expected unless handled specially: + * + * ```js + * const util = require('util'); + * + * class Foo { + * constructor() { + * this.a = 42; + * } + * + * bar(callback) { + * callback(null, this.a); + * } + * } + * + * const foo = new Foo(); + * + * const naiveBar = util.promisify(foo.bar); + * // TypeError: Cannot read property 'a' of undefined + * // naiveBar().then(a => console.log(a)); + * + * naiveBar.call(foo).then((a) => console.log(a)); // '42' + * + * const bindBar = naiveBar.bind(foo); + * bindBar().then((a) => console.log(a)); // '42' + * ``` + */ + export function promisify( + fn: CustomPromisify, + ): TCustom; + export function promisify( + fn: (callback: (err: any, result: TResult) => void) => void, + ): () => Promise; + export function promisify( + fn: (callback: (err?: any) => void) => void, + ): () => Promise; + export function promisify( + fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void, + ): (arg1: T1) => Promise; + export function promisify( + fn: (arg1: T1, callback: (err?: any) => void) => void, + ): (arg1: T1) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + callback: (err: any, result: TResult) => void, + ) => void, + ): (arg1: T1, arg2: T2) => Promise; + export function promisify( + fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void, + ): (arg1: T1, arg2: T2) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + callback: (err: any, result: TResult) => void, + ) => void, + ): (arg1: T1, arg2: T2, arg3: T3) => Promise; + export function promisify( + fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void, + ): (arg1: T1, arg2: T2, arg3: T3) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + callback: (err: any, result: TResult) => void, + ) => void, + ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + callback: (err?: any) => void, + ) => void, + ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + callback: (err: any, result: TResult) => void, + ) => void, + ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise; + export function promisify( + fn: ( + arg1: T1, + arg2: T2, + arg3: T3, + arg4: T4, + arg5: T5, + callback: (err?: any) => void, + ) => void, + ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise; + export function promisify(fn: Function): Function; + export namespace promisify { + /** + * That can be used to declare custom promisified variants of functions. + */ + const custom: unique symbol; + } + export interface EncodeIntoResult { + /** + * The read Unicode code units of input. + */ + read: number; + /** + * The written UTF-8 bytes of output. + */ + written: number; + } +} +declare module "node:util" { + export * from "util"; +} +declare module "sys" { + export * from "util"; +} +declare module "node:sys" { + export * from "util"; +} diff --git a/packages/bun-types/zlib.d.ts b/packages/bun-types/zlib.d.ts new file mode 100644 index 0000000000..877350b93c --- /dev/null +++ b/packages/bun-types/zlib.d.ts @@ -0,0 +1,554 @@ +/** + * The `zlib` module provides compression functionality implemented using Gzip, + * Deflate/Inflate, and Brotli. + * + * To access it: + * + * ```js + * const zlib = require('zlib'); + * ``` + * + * Compression and decompression are built around the Node.js `Streams API`. + * + * Compressing or decompressing a stream (such as a file) can be accomplished by + * piping the source stream through a `zlib` `Transform` stream into a destination + * stream: + * + * ```js + * const { createGzip } = require('zlib'); + * const { pipeline } = require('stream'); + * const { + * createReadStream, + * createWriteStream + * } = require('fs'); + * + * const gzip = createGzip(); + * const source = createReadStream('input.txt'); + * const destination = createWriteStream('input.txt.gz'); + * + * pipeline(source, gzip, destination, (err) => { + * if (err) { + * console.error('An error occurred:', err); + * process.exitCode = 1; + * } + * }); + * + * // Or, Promisified + * + * const { promisify } = require('util'); + * const pipe = promisify(pipeline); + * + * async function do_gzip(input, output) { + * const gzip = createGzip(); + * const source = createReadStream(input); + * const destination = createWriteStream(output); + * await pipe(source, gzip, destination); + * } + * + * do_gzip('input.txt', 'input.txt.gz') + * .catch((err) => { + * console.error('An error occurred:', err); + * process.exitCode = 1; + * }); + * ``` + * + * It is also possible to compress or decompress data in a single step: + * + * ```js + * const { deflate, unzip } = require('zlib'); + * + * const input = '.................................'; + * deflate(input, (err, buffer) => { + * if (err) { + * console.error('An error occurred:', err); + * process.exitCode = 1; + * } + * console.log(buffer.toString('base64')); + * }); + * + * const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64'); + * unzip(buffer, (err, buffer) => { + * if (err) { + * console.error('An error occurred:', err); + * process.exitCode = 1; + * } + * console.log(buffer.toString()); + * }); + * + * // Or, Promisified + * + * const { promisify } = require('util'); + * const do_unzip = promisify(unzip); + * + * do_unzip(buffer) + * .then((buf) => console.log(buf.toString())) + * .catch((err) => { + * console.error('An error occurred:', err); + * process.exitCode = 1; + * }); + * ``` + * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/zlib.js) + */ +declare module "zlib" { + import * as stream from "node:stream"; + interface ZlibOptions { + /** + * @default constants.Z_NO_FLUSH + */ + flush?: number | undefined; + /** + * @default constants.Z_FINISH + */ + finishFlush?: number | undefined; + /** + * @default 16*1024 + */ + chunkSize?: number | undefined; + windowBits?: number | undefined; + level?: number | undefined; // compression only + memLevel?: number | undefined; // compression only + strategy?: number | undefined; // compression only + dictionary?: ArrayBufferView | ArrayBuffer | undefined; // deflate/inflate only, empty dictionary by default + info?: boolean | undefined; + maxOutputLength?: number | undefined; + } + interface BrotliOptions { + /** + * @default constants.BROTLI_OPERATION_PROCESS + */ + flush?: number | undefined; + /** + * @default constants.BROTLI_OPERATION_FINISH + */ + finishFlush?: number | undefined; + /** + * @default 16*1024 + */ + chunkSize?: number | undefined; + params?: + | { + /** + * Each key is a `constants.BROTLI_*` constant. + */ + [key: number]: boolean | number; + } + | undefined; + maxOutputLength?: number | undefined; + } + interface Zlib { + /** @deprecated Use bytesWritten instead. */ + readonly bytesRead: number; + readonly bytesWritten: number; + shell?: boolean | string | undefined; + flush(kind?: number, callback?: () => void): void; + flush(callback?: () => void): void; + } + interface ZlibParams { + params(level: number, strategy: number, callback: () => void): void; + } + interface ZlibReset { + reset(): void; + } + interface BrotliCompress extends stream.Transform, Zlib {} + interface BrotliDecompress extends stream.Transform, Zlib {} + interface Gzip extends stream.Transform, Zlib {} + interface Gunzip extends stream.Transform, Zlib {} + interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {} + interface Inflate extends stream.Transform, Zlib, ZlibReset {} + interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {} + interface InflateRaw extends stream.Transform, Zlib, ZlibReset {} + interface Unzip extends stream.Transform, Zlib {} + /** + * Creates and returns a new `BrotliCompress` object. + */ + function createBrotliCompress(options?: BrotliOptions): BrotliCompress; + /** + * Creates and returns a new `BrotliDecompress` object. + */ + function createBrotliDecompress(options?: BrotliOptions): BrotliDecompress; + /** + * Creates and returns a new `Gzip` object. + * See `example`. + */ + function createGzip(options?: ZlibOptions): Gzip; + /** + * Creates and returns a new `Gunzip` object. + */ + function createGunzip(options?: ZlibOptions): Gunzip; + /** + * Creates and returns a new `Deflate` object. + */ + function createDeflate(options?: ZlibOptions): Deflate; + /** + * Creates and returns a new `Inflate` object. + */ + function createInflate(options?: ZlibOptions): Inflate; + /** + * Creates and returns a new `DeflateRaw` object. + * + * An upgrade of zlib from 1.2.8 to 1.2.11 changed behavior when `windowBits`is set to 8 for raw deflate streams. zlib would automatically set `windowBits`to 9 if was initially set to 8\. Newer + * versions of zlib will throw an exception, + * so Node.js restored the original behavior of upgrading a value of 8 to 9, + * since passing `windowBits = 9` to zlib actually results in a compressed stream + * that effectively uses an 8-bit window only. + */ + function createDeflateRaw(options?: ZlibOptions): DeflateRaw; + /** + * Creates and returns a new `InflateRaw` object. + */ + function createInflateRaw(options?: ZlibOptions): InflateRaw; + /** + * Creates and returns a new `Unzip` object. + */ + function createUnzip(options?: ZlibOptions): Unzip; + type InputType = string | ArrayBuffer | ArrayBufferView; + type CompressCallback = (error: Error | null, result: Buffer) => void; + /** + */ + function brotliCompress( + buf: InputType, + options: BrotliOptions, + callback: CompressCallback, + ): void; + function brotliCompress(buf: InputType, callback: CompressCallback): void; + namespace brotliCompress { + function __promisify__( + buffer: InputType, + options?: BrotliOptions, + ): Promise; + } + /** + * Compress a chunk of data with `BrotliCompress`. + */ + function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer; + /** + */ + function brotliDecompress( + buf: InputType, + options: BrotliOptions, + callback: CompressCallback, + ): void; + function brotliDecompress(buf: InputType, callback: CompressCallback): void; + namespace brotliDecompress { + function __promisify__( + buffer: InputType, + options?: BrotliOptions, + ): Promise; + } + /** + * Decompress a chunk of data with `BrotliDecompress`. + */ + function brotliDecompressSync( + buf: InputType, + options?: BrotliOptions, + ): Buffer; + /** + */ + function deflate(buf: InputType, callback: CompressCallback): void; + function deflate( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace deflate { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Compress a chunk of data with `Deflate`. + */ + function deflateSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function deflateRaw(buf: InputType, callback: CompressCallback): void; + function deflateRaw( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace deflateRaw { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Compress a chunk of data with `DeflateRaw`. + */ + function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function gzip(buf: InputType, callback: CompressCallback): void; + function gzip( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace gzip { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Compress a chunk of data with `Gzip`. + */ + function gzipSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function gunzip(buf: InputType, callback: CompressCallback): void; + function gunzip( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace gunzip { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Decompress a chunk of data with `Gunzip`. + */ + function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function inflate(buf: InputType, callback: CompressCallback): void; + function inflate( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace inflate { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Decompress a chunk of data with `Inflate`. + */ + function inflateSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function inflateRaw(buf: InputType, callback: CompressCallback): void; + function inflateRaw( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace inflateRaw { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Decompress a chunk of data with `InflateRaw`. + */ + function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer; + /** + */ + function unzip(buf: InputType, callback: CompressCallback): void; + function unzip( + buf: InputType, + options: ZlibOptions, + callback: CompressCallback, + ): void; + namespace unzip { + function __promisify__( + buffer: InputType, + options?: ZlibOptions, + ): Promise; + } + /** + * Decompress a chunk of data with `Unzip`. + */ + function unzipSync(buf: InputType, options?: ZlibOptions): Buffer; + namespace constants { + const BROTLI_DECODE: number; + const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number; + const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number; + const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number; + const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number; + const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number; + const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number; + const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number; + const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number; + const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number; + const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number; + const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number; + const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number; + const BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number; + const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number; + const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number; + const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number; + const BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number; + const BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number; + const BROTLI_DECODER_ERROR_FORMAT_RESERVED: number; + const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number; + const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number; + const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number; + const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number; + const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number; + const BROTLI_DECODER_ERROR_UNREACHABLE: number; + const BROTLI_DECODER_NEEDS_MORE_INPUT: number; + const BROTLI_DECODER_NEEDS_MORE_OUTPUT: number; + const BROTLI_DECODER_NO_ERROR: number; + const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number; + const BROTLI_DECODER_PARAM_LARGE_WINDOW: number; + const BROTLI_DECODER_RESULT_ERROR: number; + const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number; + const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number; + const BROTLI_DECODER_RESULT_SUCCESS: number; + const BROTLI_DECODER_SUCCESS: number; + const BROTLI_DEFAULT_MODE: number; + const BROTLI_DEFAULT_QUALITY: number; + const BROTLI_DEFAULT_WINDOW: number; + const BROTLI_ENCODE: number; + const BROTLI_LARGE_MAX_WINDOW_BITS: number; + const BROTLI_MAX_INPUT_BLOCK_BITS: number; + const BROTLI_MAX_QUALITY: number; + const BROTLI_MAX_WINDOW_BITS: number; + const BROTLI_MIN_INPUT_BLOCK_BITS: number; + const BROTLI_MIN_QUALITY: number; + const BROTLI_MIN_WINDOW_BITS: number; + const BROTLI_MODE_FONT: number; + const BROTLI_MODE_GENERIC: number; + const BROTLI_MODE_TEXT: number; + const BROTLI_OPERATION_EMIT_METADATA: number; + const BROTLI_OPERATION_FINISH: number; + const BROTLI_OPERATION_FLUSH: number; + const BROTLI_OPERATION_PROCESS: number; + const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number; + const BROTLI_PARAM_LARGE_WINDOW: number; + const BROTLI_PARAM_LGBLOCK: number; + const BROTLI_PARAM_LGWIN: number; + const BROTLI_PARAM_MODE: number; + const BROTLI_PARAM_NDIRECT: number; + const BROTLI_PARAM_NPOSTFIX: number; + const BROTLI_PARAM_QUALITY: number; + const BROTLI_PARAM_SIZE_HINT: number; + const DEFLATE: number; + const DEFLATERAW: number; + const GUNZIP: number; + const GZIP: number; + const INFLATE: number; + const INFLATERAW: number; + const UNZIP: number; + // Allowed flush values. + const Z_NO_FLUSH: number; + const Z_PARTIAL_FLUSH: number; + const Z_SYNC_FLUSH: number; + const Z_FULL_FLUSH: number; + const Z_FINISH: number; + const Z_BLOCK: number; + const Z_TREES: number; + // Return codes for the compression/decompression functions. + // Negative values are errors, positive values are used for special but normal events. + const Z_OK: number; + const Z_STREAM_END: number; + const Z_NEED_DICT: number; + const Z_ERRNO: number; + const Z_STREAM_ERROR: number; + const Z_DATA_ERROR: number; + const Z_MEM_ERROR: number; + const Z_BUF_ERROR: number; + const Z_VERSION_ERROR: number; + // Compression levels. + const Z_NO_COMPRESSION: number; + const Z_BEST_SPEED: number; + const Z_BEST_COMPRESSION: number; + const Z_DEFAULT_COMPRESSION: number; + // Compression strategy. + const Z_FILTERED: number; + const Z_HUFFMAN_ONLY: number; + const Z_RLE: number; + const Z_FIXED: number; + const Z_DEFAULT_STRATEGY: number; + const Z_DEFAULT_WINDOWBITS: number; + const Z_MIN_WINDOWBITS: number; + const Z_MAX_WINDOWBITS: number; + const Z_MIN_CHUNK: number; + const Z_MAX_CHUNK: number; + const Z_DEFAULT_CHUNK: number; + const Z_MIN_MEMLEVEL: number; + const Z_MAX_MEMLEVEL: number; + const Z_DEFAULT_MEMLEVEL: number; + const Z_MIN_LEVEL: number; + const Z_MAX_LEVEL: number; + const Z_DEFAULT_LEVEL: number; + const ZLIB_VERNUM: number; + } + // Allowed flush values. + /** @deprecated Use `constants.Z_NO_FLUSH` */ + const Z_NO_FLUSH: number; + /** @deprecated Use `constants.Z_PARTIAL_FLUSH` */ + const Z_PARTIAL_FLUSH: number; + /** @deprecated Use `constants.Z_SYNC_FLUSH` */ + const Z_SYNC_FLUSH: number; + /** @deprecated Use `constants.Z_FULL_FLUSH` */ + const Z_FULL_FLUSH: number; + /** @deprecated Use `constants.Z_FINISH` */ + const Z_FINISH: number; + /** @deprecated Use `constants.Z_BLOCK` */ + const Z_BLOCK: number; + /** @deprecated Use `constants.Z_TREES` */ + const Z_TREES: number; + // Return codes for the compression/decompression functions. + // Negative values are errors, positive values are used for special but normal events. + /** @deprecated Use `constants.Z_OK` */ + const Z_OK: number; + /** @deprecated Use `constants.Z_STREAM_END` */ + const Z_STREAM_END: number; + /** @deprecated Use `constants.Z_NEED_DICT` */ + const Z_NEED_DICT: number; + /** @deprecated Use `constants.Z_ERRNO` */ + const Z_ERRNO: number; + /** @deprecated Use `constants.Z_STREAM_ERROR` */ + const Z_STREAM_ERROR: number; + /** @deprecated Use `constants.Z_DATA_ERROR` */ + const Z_DATA_ERROR: number; + /** @deprecated Use `constants.Z_MEM_ERROR` */ + const Z_MEM_ERROR: number; + /** @deprecated Use `constants.Z_BUF_ERROR` */ + const Z_BUF_ERROR: number; + /** @deprecated Use `constants.Z_VERSION_ERROR` */ + const Z_VERSION_ERROR: number; + // Compression levels. + /** @deprecated Use `constants.Z_NO_COMPRESSION` */ + const Z_NO_COMPRESSION: number; + /** @deprecated Use `constants.Z_BEST_SPEED` */ + const Z_BEST_SPEED: number; + /** @deprecated Use `constants.Z_BEST_COMPRESSION` */ + const Z_BEST_COMPRESSION: number; + /** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */ + const Z_DEFAULT_COMPRESSION: number; + // Compression strategy. + /** @deprecated Use `constants.Z_FILTERED` */ + const Z_FILTERED: number; + /** @deprecated Use `constants.Z_HUFFMAN_ONLY` */ + const Z_HUFFMAN_ONLY: number; + /** @deprecated Use `constants.Z_RLE` */ + const Z_RLE: number; + /** @deprecated Use `constants.Z_FIXED` */ + const Z_FIXED: number; + /** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */ + const Z_DEFAULT_STRATEGY: number; + /** @deprecated */ + const Z_BINARY: number; + /** @deprecated */ + const Z_TEXT: number; + /** @deprecated */ + const Z_ASCII: number; + /** @deprecated */ + const Z_UNKNOWN: number; + /** @deprecated */ + const Z_DEFLATED: number; +} +declare module "node:zlib" { + export * from "zlib"; +} diff --git a/packages/bun-wasm/bun.lockb b/packages/bun-wasm/bun.lockb index ff9d2fad635c6b3c76cf617525b5d589caeb8bd7..5785108fc01810274b8a18433ca642636901df41 100755 GIT binary patch delta 2329 zcma)8eP~lx6o2oU&bF>gn$)Cq)>%utq%JQ>6Q$O!l&wrFBAcVExFLN$pGj;!9(hlt zWn1cClz~O--3TcRI+RJFLNHDOP91E2Y*VDteYi|?h2h)>6YL)og>C1)kG$7s7x$o? zdw%!)&euKnriH-i&BxkW5k*nwreC@1E>xVo+Lq0JTR1Z)t=aVEu9@PIOMRh{6Pfd$ zuWX!nxs^USai}Rh2Iea$YE%+q(LJ#C&=ge-`rf4Eo8$I0JhPDHGoH%D^!#c=m+ctliex6wi3)>cNefu)ef32 zSL=aJkmQ$P7WuV`!T@RsYKA9NLxis(zXr|&*aK{ufEv3A3O1(`2h5!Iw1y2LKei!D z{zgTX?&)#Ay^ww9@*Qby_}0CPue~1ppf9)M{;8XL^0u*j-!ES%#bZp)0L@_r~!j%fIY78#^;U+uVED-<%V3jV)gvnCi^@Hoj&5 zU;W>solYy4bJsqc@}wIkE;V-39V2t^FFZwiw!e7(=2xB5S=ahd{zBz97Pq?NcPoQK zcF0+hk4QKjYT%Dt66NP>*38uznzNDtsUQme@7E-}S1(S#_mu^1Ceazp!~F`mI| ztWEh|>l9s8Pz@=});42X?ba&4U7_9pWUkugP_%>#ciVT<#p7{JT9!FW_e!!PVMD%3Yo*w%wxo!8XYFnGno2jT4UgjoQsC z{CsZm=sMqbx`B2_9~}Ji*p`!TJ*V$@X#A;T5?K)*s2fEYgo|}oX*o7-UAcn*cIS4) zS@58<9Vv0}jB`~>!KGAlUzLm7Bl7Wse2T%>oh`>*J=Jb4+o=VyDlS z;=@r55lA z+9kPZyhI7)bz=y6t#eStxWzGqHLL@%H z=|vlLJ&^-~peEwo7fp#$$z%G_u`%01QfBCXr6#aaM6Mkil-7DmN($*ECs$xaj*aQ$ zk_L2jcuEyKT7bZ&*tkyC6mw`fa@u@pB0RfSZ58Bg(BzsQcWpRUh{Btu1vjeR0C``` zLzp(*SuRN)#f0+T0VJ?U*DKHuq)Z=lqs2#PoU2VsP9+Q_$HsX>9hzdey-oEQ_<5@O E7k7rP!vFvP delta 980 zcmZ2$y~A*VmKq}i1B0`{v^Q&-Ti#0OMcv_A=qB@O^ZvWq_KzRRtBLYktmmAqATcpO zjgeSoiEeUYacW*Zm||#wisu4pUZ8v*kQM-` z1Jay8Iub~O%<%`(ApI^-zBZ8N0rJg(G)Uh(sJtSCo-EEd%OTd@_M~glDUBqr_GMCC zf7x_W*0oLatls?HbK}j=e-<;81RPkB!MsdzRrurB%&F&EgN!Hpa-48@zft;ZsRRVLY$l)PSKR!Ze<>rEfFMLHLU1ydkkaHGf*zb5P$84aoI;nmGK3%sj)_fv zCKM+POQef^-#6YhU)jXO7-ynqsAt5$pg1{RSdvkDa-f(bqxs~?!p4j)laB*Q|H;3F zC7B`_CfkThFr_d|HV~1JfhFBvW$z}qFR9f5nqsVHpl1R~^pjIWW-+xeOcHHi>SLJP zBzg{PW;%$oOU#F99>Zh~aU+O%MnVkY5Z5_CX`t68i>rbX*5n=H4qOFLVF`)JOcFNS u$r*`x>8apcH2H@_vPw>Vd1?`uTUt;6W$C7678REu_>%=?=S)^$VgUfRni*37 diff --git a/packages/bun-wasm/index.ts b/packages/bun-wasm/index.ts index d886a2cdae..b72400661a 100644 --- a/packages/bun-wasm/index.ts +++ b/packages/bun-wasm/index.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { ByteBuffer } from "peechy/bb"; import { decodeScanResult, @@ -189,7 +190,7 @@ export class Bun { if (globalThis?.WebAssembly?.instantiateStreaming) { Bun.wasm_source = await globalThis.WebAssembly.instantiateStreaming( fetch(url), - { env: env, wasi_snapshot_preview1: Wasi } + { env: env, wasi_snapshot_preview1: Wasi }, ); } else if (typeof window !== "undefined") { const resp = await fetch(url); @@ -198,7 +199,7 @@ export class Bun { { env: env, wasi_snapshot_preview1: Wasi, - } + }, ); // is it node? } else { @@ -210,7 +211,7 @@ export class Bun { { env: env, wasi_snapshot_preview1: Wasi, - } + }, ); } @@ -225,7 +226,7 @@ export class Bun { static transformSync( content: Uint8Array | string, file_name: string, - loader?: Loader + loader?: Loader, ): TransformResponse { if (!Bun.has_initialized) { throw "Please run await Bun.init(wasm_url) before using this."; @@ -264,7 +265,7 @@ export class Bun { // @ts-ignore loader: normalizeLoader(file_name, loader), }, - bb + bb, ); const data = bb.toUint8Array(); @@ -285,7 +286,7 @@ export class Bun { static scan( content: Uint8Array | string, file_name: string, - loader?: Loader + loader?: Loader, ): ScanResult { if (!Bun.has_initialized) { throw "Please run await Bun.init(wasm_url) before using this."; @@ -316,7 +317,7 @@ export class Bun { // @ts-ignore loader: normalizeLoader(file_name, loader), }, - bb + bb, ); const data = bb.toUint8Array(); diff --git a/src/.prettierignore b/src/.prettierignore deleted file mode 100644 index b50b4c2621..0000000000 --- a/src/.prettierignore +++ /dev/null @@ -1 +0,0 @@ -fallback.html \ No newline at end of file diff --git a/src/api/bun.lockb b/src/api/bun.lockb index 90a1dd4c9f1409bb76d620e22b5ef560654f5839..7d9cafc342b78c84f2fcf6070095164bf0aca9a3 100755 GIT binary patch delta 2192 zcma)7Z)g)|7{9w_Y|Yv<*EGpOkad=5Tbt|UkAD_Q39j10=KMz)3|hRNXA(^=NA9ZB zQLm1{ildw9TbMFrW(rm(CDM%qJlK+hF3Z>sq>|tgV5JH=F$Wf$LMa3cpjpMNEE+z$w`y zyQRFIv&P6zuW~1FiXVZB1g(=F014%f;R>l&@(qxiO;NnCYih+6*}S1~vwNN?;L&tb zbh`bE+aVu5`YXQ>Is3VA;?Obc&F<8>3)cqcA~&LgC%2v%p6>d2q4{CW)YH-4-G!M) zEx-MB|NHCPr(2%TXy92P`dRYQy<06kN9mTlm|x|a8$KQR@Ry0+{ZINAiCwM+Hs4DA zak@?RWUsC2#y1`QcIuH0Z+q>Pt3Td|oImMa7oM$u?mJ7<3NyrPpx%umy1r{|a|5&% zzHvB@%4h8oGc1+hMTto!sbrcxurHD1DD{%VvQx#<3d3)>eVmAnQae`E^R#jHh~X@sQ?A1=?I!2J@`11n>_dwDv}{QhaQum z_4+Ny&tLqZ{VvuIiV#IpVGPsn$xo9#r_SAe{joZuu2n<>jUKOlzkWaX;CS!Z(GEko zh_a0z5d|Dkjxk~jf%1+8HFB&3UYK--3DSZ#ID`0QlyHW8@4HG>=yv(Oh+OI*m!Z&% z(`UV+dA{mJOU`CFE=htI>FmsKv4kjPMkroL?H8$ZCe~ScBRc)szz;Q1p&%v24zqEF zk8ysM5xFY*3NKis0{PV)RTn~auAyo}t@&IiTh+Pc~#SKsFR6!8CazlL3sw2;v~Cg0qo~-TZ-d zFQbFcf|y$pcXLh|l&4NS%lJIz#1@r#s**Bn=d(Mk9@&1%)^RMGXA`CsrNz1U`SrWa zDGL|AE52QME{vp^S(N_-JHAA zY{7<(j*BhNe|9WfcUFC;eU9nWRr|zTiXP4H=X#o=s<`B=Ay@e3xg1wmME1OFD7wYU z@Pn=4Ks+!s1)eo9F>OA`E6zCi0I!Wu1vKqE;0H$t1DDO@|9ncDRrpgFIR${J0t7-P zPZY@JY=H7KCbJ5j=86!6$juR*d`r-Qkzum5kfby))qqosE%)@xS|VrmGBL)P=o#u6 zF))Zu_7{?5RGgeCWXz~Hc`lH&oO}@|;yhVUOi~(_@^(DgHmhGr{~A!Av7UjR2?Im; zWO-pp#+1pH!n2w37$#p6ZeXflm^?vLVse4VHb$_ilO06;Ac8(j9SoE2i5h`TH5R%I zO0Ylxqk&$_6jSA55Q7L$5}Q0jOabKm?Jd Uo0eHrT!P?F4wRlXS%8TR0DJ5XRsaA1 diff --git a/src/api/demo/bun.lockb b/src/api/demo/bun.lockb index 7d3f87eb310e498ca3da54f63d9910f250528bcd..1c5c6e269594d6bc4cfeafd4d745061b570c122d 100755 GIT binary patch literal 76858 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⪻{!*qUznoh* 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 literal 63276 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 -/// +/// + +// NOTE: This file should not be edited +// see https://nextjs.org/docs/basic-features/typescript for more information. diff --git a/src/api/demo/package-lock.json b/src/api/demo/package-lock.json index 9b83211cb0..bf3924fb5e 100644 --- a/src/api/demo/package-lock.json +++ b/src/api/demo/package-lock.json @@ -4378,6 +4378,201 @@ "funding": { "url": "https://github.com/sponsors/sindresorhus" } + }, + "node_modules/@next/swc-android-arm-eabi": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm-eabi/-/swc-android-arm-eabi-12.3.2.tgz", + "integrity": "sha512-r2rrz+DZ8YYGqzVrbRrpP6GKzwozpOrnFbErc4k36vUTSFMag9yQahZfaBe06JYdqu/e5yhm/saIDEaSVPRP4g==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-android-arm64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm64/-/swc-android-arm64-12.3.2.tgz", + "integrity": "sha512-B+TINJhCf+CrY1+b3/JWQlkecv53rAGa/gA7gi5B1cnBa/2Uvoe+Ue0JeCefTjfiyl1ScsyNx+NcESY8Ye2Ngg==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-darwin-arm64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-12.3.2.tgz", + "integrity": "sha512-PTUfe1ZrwjsiuTmr3bOM9lsoy5DCmfYsLOUF9ZVhtbi5MNJVmUTy4VZ06GfrvnCO5hGCr48z3vpFE9QZ0qLcPw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-darwin-x64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-12.3.2.tgz", + "integrity": "sha512-1HkjmS9awwlaeEY8Y01nRSNkSv3y+qnC/mjMPe/W66hEh3QKa/LQHqHeS7NOdEs19B2mhZ7w+EgMRXdLQ0Su8w==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-freebsd-x64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-freebsd-x64/-/swc-freebsd-x64-12.3.2.tgz", + "integrity": "sha512-h5Mx0BKDCJ5Vu/U8e07esF6PjPv1EJgmRbYWTUZMAflu13MQpCJkKEJir7+BeRfTXRfgFf+llc7uocrpd7mcrg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm-gnueabihf": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm-gnueabihf/-/swc-linux-arm-gnueabihf-12.3.2.tgz", + "integrity": "sha512-EuRZAamoxfe/WoWRaC0zsCAoE4gs/mEhilcloNM4J5Mnb3PLY8PZV394W7t5tjBjItMCF7l2Ebwjwtm46tq2RA==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm64-gnu": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-12.3.2.tgz", + "integrity": "sha512-T9GCFyOIb4S3acA9LqflUYD+QZ94iZketHCqKdoO0Nx0OCHIgGJV5rotDe8TDXwh/goYpIfyHU4j1qqw4w4VnA==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm64-musl": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-12.3.2.tgz", + "integrity": "sha512-hxNVZS6L3c2z3l9EH2GP0MGQ9exu6O8cohYNZyqC9WUl6C03sEn8xzDH1y+NgD3fVurvYkGU5F0PDddJJLfDIw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-x64-gnu": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-12.3.2.tgz", + "integrity": "sha512-fCPkLuwDwY8/QeXxciJJjDHG09liZym/Bhb4A+RLFQ877wUkwFsNWDUTSdUx0YXlYK/1gf67BKauqKkOKp6CYw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-x64-musl": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-12.3.2.tgz", + "integrity": "sha512-o+GifBIQ2K+/MEFxHsxUZoU3bsuVFLXZYWd3idimFHiVdDCVYiKsY6mYMmKDlucX+9xRyOCkKL9Tjf+3tuXJpw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-arm64-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-12.3.2.tgz", + "integrity": "sha512-crii66irzGGMSUR0L8r9+A06eTv7FTXqw4rgzJ33M79EwQJOdpY7RVKXLQMurUhniEeQEEOfamiEdPIi/qxisw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-ia32-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-12.3.2.tgz", + "integrity": "sha512-5hRUSvn3MdQ4nVRu1rmKxq5YJzpTtZfaC/NyGw6wa4NSF1noUn/pdQGUr+I5Qz3CZkd1gZzzC0eaXQHlrk0E2g==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-x64-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-12.3.2.tgz", + "integrity": "sha512-tpQJYUH+TzPMIsdVl9fH8uDg47iwiNjKY+8e9da3dXqlkztKzjSw0OwSADoqh3KrifplXeKSta+BBGLdBqg3sg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } } }, "dependencies": { @@ -7575,6 +7770,84 @@ "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==" + }, + "@next/swc-android-arm-eabi": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm-eabi/-/swc-android-arm-eabi-12.3.2.tgz", + "integrity": "sha512-r2rrz+DZ8YYGqzVrbRrpP6GKzwozpOrnFbErc4k36vUTSFMag9yQahZfaBe06JYdqu/e5yhm/saIDEaSVPRP4g==", + "optional": true + }, + "@next/swc-android-arm64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm64/-/swc-android-arm64-12.3.2.tgz", + "integrity": "sha512-B+TINJhCf+CrY1+b3/JWQlkecv53rAGa/gA7gi5B1cnBa/2Uvoe+Ue0JeCefTjfiyl1ScsyNx+NcESY8Ye2Ngg==", + "optional": true + }, + "@next/swc-darwin-arm64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-12.3.2.tgz", + "integrity": "sha512-PTUfe1ZrwjsiuTmr3bOM9lsoy5DCmfYsLOUF9ZVhtbi5MNJVmUTy4VZ06GfrvnCO5hGCr48z3vpFE9QZ0qLcPw==", + "optional": true + }, + "@next/swc-darwin-x64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-12.3.2.tgz", + "integrity": "sha512-1HkjmS9awwlaeEY8Y01nRSNkSv3y+qnC/mjMPe/W66hEh3QKa/LQHqHeS7NOdEs19B2mhZ7w+EgMRXdLQ0Su8w==", + "optional": true + }, + "@next/swc-freebsd-x64": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-freebsd-x64/-/swc-freebsd-x64-12.3.2.tgz", + "integrity": "sha512-h5Mx0BKDCJ5Vu/U8e07esF6PjPv1EJgmRbYWTUZMAflu13MQpCJkKEJir7+BeRfTXRfgFf+llc7uocrpd7mcrg==", + "optional": true + }, + "@next/swc-linux-arm-gnueabihf": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm-gnueabihf/-/swc-linux-arm-gnueabihf-12.3.2.tgz", + "integrity": "sha512-EuRZAamoxfe/WoWRaC0zsCAoE4gs/mEhilcloNM4J5Mnb3PLY8PZV394W7t5tjBjItMCF7l2Ebwjwtm46tq2RA==", + "optional": true + }, + "@next/swc-linux-arm64-gnu": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-12.3.2.tgz", + "integrity": "sha512-T9GCFyOIb4S3acA9LqflUYD+QZ94iZketHCqKdoO0Nx0OCHIgGJV5rotDe8TDXwh/goYpIfyHU4j1qqw4w4VnA==", + "optional": true + }, + "@next/swc-linux-arm64-musl": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-12.3.2.tgz", + "integrity": "sha512-hxNVZS6L3c2z3l9EH2GP0MGQ9exu6O8cohYNZyqC9WUl6C03sEn8xzDH1y+NgD3fVurvYkGU5F0PDddJJLfDIw==", + "optional": true + }, + "@next/swc-linux-x64-gnu": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-12.3.2.tgz", + "integrity": "sha512-fCPkLuwDwY8/QeXxciJJjDHG09liZym/Bhb4A+RLFQ877wUkwFsNWDUTSdUx0YXlYK/1gf67BKauqKkOKp6CYw==", + "optional": true + }, + "@next/swc-linux-x64-musl": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-12.3.2.tgz", + "integrity": "sha512-o+GifBIQ2K+/MEFxHsxUZoU3bsuVFLXZYWd3idimFHiVdDCVYiKsY6mYMmKDlucX+9xRyOCkKL9Tjf+3tuXJpw==", + "optional": true + }, + "@next/swc-win32-arm64-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-12.3.2.tgz", + "integrity": "sha512-crii66irzGGMSUR0L8r9+A06eTv7FTXqw4rgzJ33M79EwQJOdpY7RVKXLQMurUhniEeQEEOfamiEdPIi/qxisw==", + "optional": true + }, + "@next/swc-win32-ia32-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-12.3.2.tgz", + "integrity": "sha512-5hRUSvn3MdQ4nVRu1rmKxq5YJzpTtZfaC/NyGw6wa4NSF1noUn/pdQGUr+I5Qz3CZkd1gZzzC0eaXQHlrk0E2g==", + "optional": true + }, + "@next/swc-win32-x64-msvc": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-12.3.2.tgz", + "integrity": "sha512-tpQJYUH+TzPMIsdVl9fH8uDg47iwiNjKY+8e9da3dXqlkztKzjSw0OwSADoqh3KrifplXeKSta+BBGLdBqg3sg==", + "optional": true } } } diff --git a/src/api/demo/package.json b/src/api/demo/package.json index ac452254a3..59e70aed14 100644 --- a/src/api/demo/package.json +++ b/src/api/demo/package.json @@ -14,13 +14,14 @@ "esbuild": "^0.14.23", "esbuild-wasm": "^0.14.23", "next": "12", - "peechy": "latest", + "peechy": "0.4.32", "react": "17.0.2", "react-dom": "17.0.2", "sucrase": "^3.18.1" }, "devDependencies": { "@types/react": "^17.0.8", + "bun-types": "^0.2.2", "typescript": "^4.3.2", "webpack": "^5.38.1", "webpack-cli": "^4.7.0" diff --git a/src/api/demo/pages/_app.js b/src/api/demo/pages/_app.js index 1e1cec9242..2fc3e07009 100644 --- a/src/api/demo/pages/_app.js +++ b/src/api/demo/pages/_app.js @@ -1,7 +1,7 @@ -import '../styles/globals.css' +import "../styles/globals.css"; function MyApp({ Component, pageProps }) { - return + return ; } -export default MyApp +export default MyApp; diff --git a/src/api/demo/pages/api/hello.js b/src/api/demo/pages/api/hello.js index 9987aff4c3..e963280fab 100644 --- a/src/api/demo/pages/api/hello.js +++ b/src/api/demo/pages/api/hello.js @@ -1,5 +1,5 @@ // Next.js API route support: https://nextjs.org/docs/api-routes/introduction export default (req, res) => { - res.status(200).json({ name: 'John Doe' }) -} + res.status(200).json({ name: "John Doe" }); +}; diff --git a/src/api/demo/pages/index.tsx b/src/api/demo/pages/index.tsx index 7274b3d392..24577acb38 100644 --- a/src/api/demo/pages/index.tsx +++ b/src/api/demo/pages/index.tsx @@ -1,19 +1,22 @@ import Head from "next/head"; import Image from "next/image"; import styles from "../styles/Home.module.css"; +import { readFile } from "fs/promises"; import React from "react"; if (typeof window !== "undefined") { globalThis.Run = await import("../lib/run"); - await import("../lib/api.ts"); + await import("../lib/api"); } export async function getStaticProps(ctx) { return { props: { - code: Bun.readFile( - "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js" + // not tested + code: readFile( + "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js", + { encoding: "utf-8" }, ), }, }; @@ -21,7 +24,7 @@ export async function getStaticProps(ctx) { var textDecoder = new TextDecoder(); export default function Home({ code }) { - const fileNameRef = React.useRef(); + const fileNameRef = React.useRef(null); const [esbuildResult, setEsbuildResult] = React.useState(""); const [bunResult, setBunResult] = React.useState(""); const [swcResult, setSWCResult] = React.useState(""); @@ -33,14 +36,14 @@ export default function Home({ code }) { (event) => { globalThis.Run.transform( event.target.value, - fileNameRef.current.value + fileNameRef?.current?.value, ).then((result) => { setEsbuildResult(result.esbuild.code); setBunResult(textDecoder.decode(result.bun.files[0].data)); setSWCResult(result.swc.code); }, console.error); }, - [fileNameRef, setEsbuildResult, setBunResult, setSWCResult] + [fileNameRef, setEsbuildResult, setBunResult, setSWCResult], ); return (

diff --git a/src/api/demo/pages/scan.tsx b/src/api/demo/pages/scan.tsx index 819a597b9d..87cebd64d1 100644 --- a/src/api/demo/pages/scan.tsx +++ b/src/api/demo/pages/scan.tsx @@ -1,19 +1,21 @@ import Head from "next/head"; -import Image from "next/image"; +import { readFile } from "fs/promises"; import styles from "../styles/Home.module.css"; import React from "react"; if (typeof window !== "undefined") { globalThis.Scan = await import("../lib/scan"); - await import("../lib/api.ts"); + await import("../lib/api"); } export async function getStaticProps(ctx) { return { props: { - code: Bun.readFile( - "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js" + // not tested + code: readFile( + "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js", + { encoding: "utf-8" }, ), defaultFile: "magic-string.js", }, @@ -22,7 +24,7 @@ export async function getStaticProps(ctx) { var textDecoder = new TextDecoder(); export default function Home({ code, defaultFile }) { - const fileNameRef = React.useRef(); + const fileNameRef = React.useRef(null); const [lexer, setLexer] = React.useState(""); const [bunResult, setBunResult] = React.useState(""); const [file, setFile] = React.useState(defaultFile); @@ -34,13 +36,13 @@ export default function Home({ code, defaultFile }) { (event) => { globalThis.Scan.transform( event.target.value, - fileNameRef.current.value + fileNameRef?.current?.value, ).then((result) => { setLexer(JSON.stringify(result.lexer, null, 2)); setBunResult(JSON.stringify(result.bun, null, 2)); }, console.error); }, - [fileNameRef, setBunResult, setLexer] + [fileNameRef, setBunResult, setLexer], ); return (
diff --git a/src/api/demo/pages/two.tsx b/src/api/demo/pages/two.tsx index e69de29bb2..cb0ff5c3b5 100644 --- a/src/api/demo/pages/two.tsx +++ b/src/api/demo/pages/two.tsx @@ -0,0 +1 @@ +export {}; diff --git a/src/api/demo/schema.d.ts b/src/api/demo/schema.d.ts index 0a7ed3b9bc..ae45511285 100644 --- a/src/api/demo/schema.d.ts +++ b/src/api/demo/schema.d.ts @@ -685,29 +685,29 @@ export interface BunInstall { export declare function encodeStackFrame( message: StackFrame, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackFrame(buffer: ByteBuffer): StackFrame; export declare function encodeStackFramePosition( message: StackFramePosition, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackFramePosition( - buffer: ByteBuffer + buffer: ByteBuffer, ): StackFramePosition; export declare function encodeSourceLine( message: SourceLine, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeSourceLine(buffer: ByteBuffer): SourceLine; export declare function encodeStackTrace( message: StackTrace, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackTrace(buffer: ByteBuffer): StackTrace; export declare function encodeJSException( message: JSException, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJSException(buffer: ByteBuffer): JSException; export declare function encodeProblems(message: Problems, bb: ByteBuffer): void; @@ -716,175 +716,175 @@ export declare function encodeRouter(message: Router, bb: ByteBuffer): void; export declare function decodeRouter(buffer: ByteBuffer): Router; export declare function encodeFallbackMessageContainer( message: FallbackMessageContainer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFallbackMessageContainer( - buffer: ByteBuffer + buffer: ByteBuffer, ): FallbackMessageContainer; export declare function encodeJSX(message: JSX, bb: ByteBuffer): void; export declare function decodeJSX(buffer: ByteBuffer): JSX; export declare function encodeStringPointer( message: StringPointer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer; export declare function encodeJavascriptBundledModule( message: JavascriptBundledModule, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundledModule( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundledModule; export declare function encodeJavascriptBundledPackage( message: JavascriptBundledPackage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundledPackage( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundledPackage; export declare function encodeJavascriptBundle( message: JavascriptBundle, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundle( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundle; export declare function encodeJavascriptBundleContainer( message: JavascriptBundleContainer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundleContainer( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundleContainer; export declare function encodeModuleImportRecord( message: ModuleImportRecord, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeModuleImportRecord( - buffer: ByteBuffer + buffer: ByteBuffer, ): ModuleImportRecord; export declare function encodeModule(message: Module, bb: ByteBuffer): void; export declare function decodeModule(buffer: ByteBuffer): Module; export declare function encodeStringMap( message: StringMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStringMap(buffer: ByteBuffer): StringMap; export declare function encodeLoaderMap( message: LoaderMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap; export declare function encodeEnvConfig( message: EnvConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig; export declare function encodeLoadedEnvConfig( message: LoadedEnvConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedEnvConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedEnvConfig; export declare function encodeFrameworkConfig( message: FrameworkConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkConfig; export declare function encodeFrameworkEntryPoint( message: FrameworkEntryPoint, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPoint( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPoint; export declare function encodeFrameworkEntryPointMap( message: FrameworkEntryPointMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPointMap( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPointMap; export declare function encodeFrameworkEntryPointMessage( message: FrameworkEntryPointMessage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPointMessage( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPointMessage; export declare function encodeLoadedFramework( message: LoadedFramework, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedFramework( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedFramework; export declare function encodeLoadedRouteConfig( message: LoadedRouteConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedRouteConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedRouteConfig; export declare function encodeRouteConfig( message: RouteConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig; export declare function encodeTransformOptions( message: TransformOptions, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransformOptions( - buffer: ByteBuffer + buffer: ByteBuffer, ): TransformOptions; export declare function encodeFileHandle( message: FileHandle, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle; export declare function encodeTransform( message: Transform, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransform(buffer: ByteBuffer): Transform; export declare function encodeScan(message: Scan, bb: ByteBuffer): void; export declare function decodeScan(buffer: ByteBuffer): Scan; export declare function encodeScanResult( message: ScanResult, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeScanResult(buffer: ByteBuffer): ScanResult; export declare function encodeScannedImport( message: ScannedImport, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeScannedImport(buffer: ByteBuffer): ScannedImport; export declare function encodeOutputFile( message: OutputFile, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile; export declare function encodeTransformResponse( message: TransformResponse, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransformResponse( - buffer: ByteBuffer + buffer: ByteBuffer, ): TransformResponse; export declare function encodeLocation(message: Location, bb: ByteBuffer): void; export declare function decodeLocation(buffer: ByteBuffer): Location; export declare function encodeMessageData( message: MessageData, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeMessageData(buffer: ByteBuffer): MessageData; export declare function encodeMessageMeta( message: MessageMeta, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeMessageMeta(buffer: ByteBuffer): MessageMeta; export declare function encodeMessage(message: Message, bb: ByteBuffer): void; @@ -893,88 +893,88 @@ export declare function encodeLog(message: Log, bb: ByteBuffer): void; export declare function decodeLog(buffer: ByteBuffer): Log; export declare function encodeWebsocketMessage( message: WebsocketMessage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessage( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessage; export declare function encodeWebsocketMessageWelcome( message: WebsocketMessageWelcome, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageWelcome( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageWelcome; export declare function encodeWebsocketMessageFileChangeNotification( message: WebsocketMessageFileChangeNotification, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageFileChangeNotification( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageFileChangeNotification; export declare function encodeWebsocketCommand( message: WebsocketCommand, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommand( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommand; export declare function encodeWebsocketCommandBuild( message: WebsocketCommandBuild, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandBuild( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandBuild; export declare function encodeWebsocketCommandManifest( message: WebsocketCommandManifest, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandManifest( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandManifest; export declare function encodeWebsocketMessageBuildSuccess( message: WebsocketMessageBuildSuccess, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageBuildSuccess( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageBuildSuccess; export declare function encodeWebsocketMessageBuildFailure( message: WebsocketMessageBuildFailure, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageBuildFailure( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageBuildFailure; export declare function encodeWebsocketCommandBuildWithFilePath( message: WebsocketCommandBuildWithFilePath, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandBuildWithFilePath( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandBuildWithFilePath; export declare function encodeWebsocketMessageResolveID( message: WebsocketMessageResolveID, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageResolveID( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageResolveID; export declare function encodeNPMRegistry( message: NPMRegistry, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeNPMRegistry(buffer: ByteBuffer): NPMRegistry; export declare function encodeNPMRegistryMap( message: NPMRegistryMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeNPMRegistryMap( - buffer: ByteBuffer + buffer: ByteBuffer, ): NPMRegistryMap; export declare function encodeBunInstall( message: BunInstall, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeBunInstall(buffer: ByteBuffer): BunInstall; diff --git a/src/api/demo/schema.js b/src/api/demo/schema.js index b89ed4a08f..2c31d95127 100644 --- a/src/api/demo/schema.js +++ b/src/api/demo/schema.js @@ -120,7 +120,9 @@ function encodeStackFrame(message, bb) { var encoded = StackFrameScope[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "StackFrameScope"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "StackFrameScope"', ); bb.writeByte(encoded); } else { @@ -500,7 +502,7 @@ function encodeFallbackMessageContainer(message, bb) { var encoded = FallbackStep[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "FallbackStep"' + "Invalid value " + JSON.stringify(value) + ' for enum "FallbackStep"', ); bb.writeByte(encoded); } @@ -612,7 +614,7 @@ function encodeJSX(message, bb) { var encoded = JSXRuntime[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"' + "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"', ); bb.writeByte(encoded); } else { @@ -833,7 +835,7 @@ function encodeJavascriptBundle(message, bb) { bb.writeByteArray(value); } else { throw new Error( - 'Missing required field "app_package_json_dependencies_hash"' + 'Missing required field "app_package_json_dependencies_hash"', ); } @@ -960,7 +962,7 @@ function encodeModuleImportRecord(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "ModuleImportType"' + ' for enum "ModuleImportType"', ); bb.writeByte(encoded); } else { @@ -1090,7 +1092,7 @@ function encodeLoaderMap(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -1167,7 +1169,7 @@ function encodeLoadedEnvConfig(message, bb) { var encoded = DotEnvBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"' + "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"', ); bb.writeVarUint(encoded); } else { @@ -1272,7 +1274,9 @@ function encodeFrameworkConfig(message, bb) { var encoded = CSSInJSBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "CSSInJSBehavior"', ); bb.writeByte(encoded); } @@ -1308,7 +1312,7 @@ function encodeFrameworkEntryPoint(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "FrameworkEntryPointType"' + ' for enum "FrameworkEntryPointType"', ); bb.writeByte(encoded); } else { @@ -1460,7 +1464,9 @@ function encodeLoadedFramework(message, bb) { var encoded = CSSInJSBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "CSSInJSBehavior"', ); bb.writeByte(encoded); } else { @@ -1743,7 +1749,7 @@ function encodeTransformOptions(message, bb) { var encoded = ResolveMode[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"' + "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"', ); bb.writeByte(encoded); } @@ -1844,7 +1850,7 @@ function encodeTransformOptions(message, bb) { var encoded = Platform[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Platform"' + "Invalid value " + JSON.stringify(value) + ' for enum "Platform"', ); bb.writeByte(encoded); } @@ -1921,7 +1927,7 @@ function encodeTransformOptions(message, bb) { var encoded = MessageLevel[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"' + "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"', ); bb.writeVarUint(encoded); } @@ -2019,7 +2025,7 @@ function encodeTransform(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -2077,7 +2083,7 @@ function encodeScan(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -2145,7 +2151,7 @@ function encodeScannedImport(message, bb) { var encoded = ImportKind[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"' + "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"', ); bb.writeByte(encoded); } else { @@ -2246,7 +2252,7 @@ function encodeTransformResponse(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "TransformResponseStatus"' + ' for enum "TransformResponseStatus"', ); bb.writeVarUint(encoded); } else { @@ -2460,7 +2466,7 @@ function encodeMessage(message, bb) { var encoded = MessageLevel[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"' + "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"', ); bb.writeVarUint(encoded); } else { @@ -2626,7 +2632,7 @@ function encodeWebsocketMessage(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "WebsocketMessageKind"' + ' for enum "WebsocketMessageKind"', ); bb.writeByte(encoded); } else { @@ -2656,7 +2662,7 @@ function encodeWebsocketMessageWelcome(message, bb) { var encoded = Reloader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"', ); bb.writeByte(encoded); } else { @@ -2692,7 +2698,7 @@ function encodeWebsocketMessageFileChangeNotification(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { @@ -2716,7 +2722,7 @@ function encodeWebsocketCommand(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "WebsocketCommandKind"' + ' for enum "WebsocketCommandKind"', ); bb.writeByte(encoded); } else { @@ -2794,7 +2800,7 @@ function encodeWebsocketMessageBuildSuccess(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { @@ -2847,7 +2853,7 @@ function encodeWebsocketMessageBuildFailure(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { diff --git a/src/api/demo/tsconfig.json b/src/api/demo/tsconfig.json index 35d51eac90..4fa2cd0094 100644 --- a/src/api/demo/tsconfig.json +++ b/src/api/demo/tsconfig.json @@ -1,6 +1,6 @@ { "compilerOptions": { - "target": "es5", + "target": "ES2020", "lib": [ "dom", "dom.iterable", @@ -8,7 +8,8 @@ ], "allowJs": true, "skipLibCheck": true, - "strict": false, + "strict": true, + "noImplicitAny": false, "forceConsistentCasingInFileNames": true, "noEmit": true, "esModuleInterop": true, @@ -16,7 +17,11 @@ "moduleResolution": "node", "resolveJsonModule": true, "isolatedModules": true, - "jsx": "preserve" + "jsx": "preserve", + "types": [ + "bun-types" + ], + "incremental": true }, "include": [ "next-env.d.ts", @@ -26,4 +31,4 @@ "exclude": [ "node_modules" ] -} +} \ No newline at end of file diff --git a/src/api/package.json b/src/api/package.json index 9df4297df9..8a9f3064a9 100644 --- a/src/api/package.json +++ b/src/api/package.json @@ -2,6 +2,6 @@ "name": "bun-api", "private": true, "dependencies": { - "peechy": "latest" + "peechy": "0.4.32" } } diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts index d9713fdd2d..8eb7a77f20 100644 --- a/src/api/schema.d.ts +++ b/src/api/schema.d.ts @@ -704,29 +704,29 @@ export interface BunInstall { export declare function encodeStackFrame( message: StackFrame, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackFrame(buffer: ByteBuffer): StackFrame; export declare function encodeStackFramePosition( message: StackFramePosition, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackFramePosition( - buffer: ByteBuffer + buffer: ByteBuffer, ): StackFramePosition; export declare function encodeSourceLine( message: SourceLine, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeSourceLine(buffer: ByteBuffer): SourceLine; export declare function encodeStackTrace( message: StackTrace, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStackTrace(buffer: ByteBuffer): StackTrace; export declare function encodeJSException( message: JSException, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJSException(buffer: ByteBuffer): JSException; export declare function encodeProblems(message: Problems, bb: ByteBuffer): void; @@ -735,175 +735,175 @@ export declare function encodeRouter(message: Router, bb: ByteBuffer): void; export declare function decodeRouter(buffer: ByteBuffer): Router; export declare function encodeFallbackMessageContainer( message: FallbackMessageContainer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFallbackMessageContainer( - buffer: ByteBuffer + buffer: ByteBuffer, ): FallbackMessageContainer; export declare function encodeJSX(message: JSX, bb: ByteBuffer): void; export declare function decodeJSX(buffer: ByteBuffer): JSX; export declare function encodeStringPointer( message: StringPointer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer; export declare function encodeJavascriptBundledModule( message: JavascriptBundledModule, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundledModule( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundledModule; export declare function encodeJavascriptBundledPackage( message: JavascriptBundledPackage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundledPackage( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundledPackage; export declare function encodeJavascriptBundle( message: JavascriptBundle, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundle( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundle; export declare function encodeJavascriptBundleContainer( message: JavascriptBundleContainer, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeJavascriptBundleContainer( - buffer: ByteBuffer + buffer: ByteBuffer, ): JavascriptBundleContainer; export declare function encodeModuleImportRecord( message: ModuleImportRecord, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeModuleImportRecord( - buffer: ByteBuffer + buffer: ByteBuffer, ): ModuleImportRecord; export declare function encodeModule(message: Module, bb: ByteBuffer): void; export declare function decodeModule(buffer: ByteBuffer): Module; export declare function encodeStringMap( message: StringMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeStringMap(buffer: ByteBuffer): StringMap; export declare function encodeLoaderMap( message: LoaderMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap; export declare function encodeEnvConfig( message: EnvConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig; export declare function encodeLoadedEnvConfig( message: LoadedEnvConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedEnvConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedEnvConfig; export declare function encodeFrameworkConfig( message: FrameworkConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkConfig; export declare function encodeFrameworkEntryPoint( message: FrameworkEntryPoint, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPoint( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPoint; export declare function encodeFrameworkEntryPointMap( message: FrameworkEntryPointMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPointMap( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPointMap; export declare function encodeFrameworkEntryPointMessage( message: FrameworkEntryPointMessage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFrameworkEntryPointMessage( - buffer: ByteBuffer + buffer: ByteBuffer, ): FrameworkEntryPointMessage; export declare function encodeLoadedFramework( message: LoadedFramework, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedFramework( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedFramework; export declare function encodeLoadedRouteConfig( message: LoadedRouteConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeLoadedRouteConfig( - buffer: ByteBuffer + buffer: ByteBuffer, ): LoadedRouteConfig; export declare function encodeRouteConfig( message: RouteConfig, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig; export declare function encodeTransformOptions( message: TransformOptions, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransformOptions( - buffer: ByteBuffer + buffer: ByteBuffer, ): TransformOptions; export declare function encodeFileHandle( message: FileHandle, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle; export declare function encodeTransform( message: Transform, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransform(buffer: ByteBuffer): Transform; export declare function encodeScan(message: Scan, bb: ByteBuffer): void; export declare function decodeScan(buffer: ByteBuffer): Scan; export declare function encodeScanResult( message: ScanResult, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeScanResult(buffer: ByteBuffer): ScanResult; export declare function encodeScannedImport( message: ScannedImport, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeScannedImport(buffer: ByteBuffer): ScannedImport; export declare function encodeOutputFile( message: OutputFile, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile; export declare function encodeTransformResponse( message: TransformResponse, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeTransformResponse( - buffer: ByteBuffer + buffer: ByteBuffer, ): TransformResponse; export declare function encodeLocation(message: Location, bb: ByteBuffer): void; export declare function decodeLocation(buffer: ByteBuffer): Location; export declare function encodeMessageData( message: MessageData, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeMessageData(buffer: ByteBuffer): MessageData; export declare function encodeMessageMeta( message: MessageMeta, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeMessageMeta(buffer: ByteBuffer): MessageMeta; export declare function encodeMessage(message: Message, bb: ByteBuffer): void; @@ -912,88 +912,88 @@ export declare function encodeLog(message: Log, bb: ByteBuffer): void; export declare function decodeLog(buffer: ByteBuffer): Log; export declare function encodeWebsocketMessage( message: WebsocketMessage, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessage( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessage; export declare function encodeWebsocketMessageWelcome( message: WebsocketMessageWelcome, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageWelcome( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageWelcome; export declare function encodeWebsocketMessageFileChangeNotification( message: WebsocketMessageFileChangeNotification, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageFileChangeNotification( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageFileChangeNotification; export declare function encodeWebsocketCommand( message: WebsocketCommand, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommand( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommand; export declare function encodeWebsocketCommandBuild( message: WebsocketCommandBuild, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandBuild( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandBuild; export declare function encodeWebsocketCommandManifest( message: WebsocketCommandManifest, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandManifest( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandManifest; export declare function encodeWebsocketMessageBuildSuccess( message: WebsocketMessageBuildSuccess, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageBuildSuccess( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageBuildSuccess; export declare function encodeWebsocketMessageBuildFailure( message: WebsocketMessageBuildFailure, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageBuildFailure( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageBuildFailure; export declare function encodeWebsocketCommandBuildWithFilePath( message: WebsocketCommandBuildWithFilePath, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketCommandBuildWithFilePath( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketCommandBuildWithFilePath; export declare function encodeWebsocketMessageResolveID( message: WebsocketMessageResolveID, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeWebsocketMessageResolveID( - buffer: ByteBuffer + buffer: ByteBuffer, ): WebsocketMessageResolveID; export declare function encodeNPMRegistry( message: NPMRegistry, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeNPMRegistry(buffer: ByteBuffer): NPMRegistry; export declare function encodeNPMRegistryMap( message: NPMRegistryMap, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeNPMRegistryMap( - buffer: ByteBuffer + buffer: ByteBuffer, ): NPMRegistryMap; export declare function encodeBunInstall( message: BunInstall, - bb: ByteBuffer + bb: ByteBuffer, ): void; export declare function decodeBunInstall(buffer: ByteBuffer): BunInstall; diff --git a/src/api/schema.js b/src/api/schema.js index ac28f56ab3..c78693df8b 100644 --- a/src/api/schema.js +++ b/src/api/schema.js @@ -124,7 +124,9 @@ function encodeStackFrame(message, bb) { var encoded = StackFrameScope[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "StackFrameScope"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "StackFrameScope"', ); bb.writeByte(encoded); } else { @@ -504,7 +506,7 @@ function encodeFallbackMessageContainer(message, bb) { var encoded = FallbackStep[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "FallbackStep"' + "Invalid value " + JSON.stringify(value) + ' for enum "FallbackStep"', ); bb.writeByte(encoded); } @@ -620,7 +622,7 @@ function encodeJSX(message, bb) { var encoded = JSXRuntime[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"' + "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"', ); bb.writeByte(encoded); } else { @@ -841,7 +843,7 @@ function encodeJavascriptBundle(message, bb) { bb.writeByteArray(value); } else { throw new Error( - 'Missing required field "app_package_json_dependencies_hash"' + 'Missing required field "app_package_json_dependencies_hash"', ); } @@ -968,7 +970,7 @@ function encodeModuleImportRecord(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "ModuleImportType"' + ' for enum "ModuleImportType"', ); bb.writeByte(encoded); } else { @@ -1098,7 +1100,7 @@ function encodeLoaderMap(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -1175,7 +1177,7 @@ function encodeLoadedEnvConfig(message, bb) { var encoded = DotEnvBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"' + "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"', ); bb.writeVarUint(encoded); } else { @@ -1280,7 +1282,9 @@ function encodeFrameworkConfig(message, bb) { var encoded = CSSInJSBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "CSSInJSBehavior"', ); bb.writeByte(encoded); } @@ -1316,7 +1320,7 @@ function encodeFrameworkEntryPoint(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "FrameworkEntryPointType"' + ' for enum "FrameworkEntryPointType"', ); bb.writeByte(encoded); } else { @@ -1468,7 +1472,9 @@ function encodeLoadedFramework(message, bb) { var encoded = CSSInJSBehavior[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"' + "Invalid value " + + JSON.stringify(value) + + ' for enum "CSSInJSBehavior"', ); bb.writeByte(encoded); } else { @@ -1755,7 +1761,7 @@ function encodeTransformOptions(message, bb) { var encoded = ResolveMode[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"' + "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"', ); bb.writeByte(encoded); } @@ -1856,7 +1862,7 @@ function encodeTransformOptions(message, bb) { var encoded = Platform[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Platform"' + "Invalid value " + JSON.stringify(value) + ' for enum "Platform"', ); bb.writeByte(encoded); } @@ -1933,7 +1939,7 @@ function encodeTransformOptions(message, bb) { var encoded = MessageLevel[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"' + "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"', ); bb.writeVarUint(encoded); } @@ -1944,7 +1950,7 @@ function encodeTransformOptions(message, bb) { var encoded = SourceMapMode[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "SourceMapMode"' + "Invalid value " + JSON.stringify(value) + ' for enum "SourceMapMode"', ); bb.writeByte(encoded); } @@ -2054,7 +2060,7 @@ function encodeTransform(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -2112,7 +2118,7 @@ function encodeScan(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } @@ -2180,7 +2186,7 @@ function encodeScannedImport(message, bb) { var encoded = ImportKind[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"' + "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"', ); bb.writeByte(encoded); } else { @@ -2281,7 +2287,7 @@ function encodeTransformResponse(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "TransformResponseStatus"' + ' for enum "TransformResponseStatus"', ); bb.writeVarUint(encoded); } else { @@ -2495,7 +2501,7 @@ function encodeMessage(message, bb) { var encoded = MessageLevel[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"' + "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"', ); bb.writeVarUint(encoded); } else { @@ -2661,7 +2667,7 @@ function encodeWebsocketMessage(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "WebsocketMessageKind"' + ' for enum "WebsocketMessageKind"', ); bb.writeByte(encoded); } else { @@ -2692,7 +2698,7 @@ function encodeWebsocketMessageWelcome(message, bb) { var encoded = Reloader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"', ); bb.writeByte(encoded); } else { @@ -2735,7 +2741,7 @@ function encodeWebsocketMessageFileChangeNotification(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { @@ -2759,7 +2765,7 @@ function encodeWebsocketCommand(message, bb) { throw new Error( "Invalid value " + JSON.stringify(value) + - ' for enum "WebsocketCommandKind"' + ' for enum "WebsocketCommandKind"', ); bb.writeByte(encoded); } else { @@ -2837,7 +2843,7 @@ function encodeWebsocketMessageBuildSuccess(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { @@ -2890,7 +2896,7 @@ function encodeWebsocketMessageBuildFailure(message, bb) { var encoded = Loader[value]; if (encoded === void 0) throw new Error( - "Invalid value " + JSON.stringify(value) + ' for enum "Loader"' + "Invalid value " + JSON.stringify(value) + ' for enum "Loader"', ); bb.writeByte(encoded); } else { diff --git a/src/bun.js/assert.exports.js b/src/bun.js/assert.exports.js index 92efee5bed..9e82fa72bc 100644 --- a/src/bun.js/assert.exports.js +++ b/src/bun.js/assert.exports.js @@ -32,10 +32,10 @@ var __reExport = (target, module2, desc) => { "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: !0 } - : { value: module2, enumerable: !0 } - ) + : { value: module2, enumerable: !0 }, + ), ), - module2 + module2, ); var require = (path) => import.meta.require(path); @@ -73,7 +73,7 @@ var require_errors = __commonJS({ function _assertThisInitialized(self) { if (self === void 0) throw new ReferenceError( - "this hasn't been initialised - super() hasn't been called" + "this hasn't been initialised - super() hasn't been called", ); return self; } @@ -90,7 +90,7 @@ var require_errors = __commonJS({ function _inherits(subClass, superClass) { if (typeof superClass != "function" && superClass !== null) throw new TypeError( - "Super expression must either be null or a function" + "Super expression must either be null or a function", ); (subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: !0, configurable: !0 }, @@ -125,8 +125,8 @@ var require_errors = __commonJS({ this, _getPrototypeOf(NodeError2).call( this, - getMessage(arg1, arg2, arg3) - ) + getMessage(arg1, arg2, arg3), + ), )), (_this.code = code), _this @@ -178,7 +178,7 @@ var require_errors = __commonJS({ createErrorType( "ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', - TypeError + TypeError, ); createErrorType( "ERR_INVALID_ARG_TYPE", @@ -206,7 +206,7 @@ var require_errors = __commonJS({ } return (msg += ". Received type ".concat(_typeof(actual))), msg; }, - TypeError + TypeError, ); createErrorType( "ERR_INVALID_ARG_VALUE", @@ -227,7 +227,7 @@ var require_errors = __commonJS({ ); }, TypeError, - RangeError + RangeError, ); createErrorType( "ERR_INVALID_RETURN_VALUE", @@ -242,7 +242,7 @@ var require_errors = __commonJS({ .concat(name, '"') + " function but got ".concat(type, ".") ); }, - TypeError + TypeError, ); createErrorType( "ERR_MISSING_ARGS", @@ -276,7 +276,7 @@ var require_errors = __commonJS({ } return "".concat(msg, " must be specified"); }, - TypeError + TypeError, ); module2.exports.codes = codes; }, @@ -294,7 +294,7 @@ var require_assertion_error = __commonJS({ (ownKeys = ownKeys.concat( Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; - }) + }), )), ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); @@ -343,14 +343,14 @@ var require_assertion_error = __commonJS({ function _assertThisInitialized(self) { if (self === void 0) throw new ReferenceError( - "this hasn't been initialised - super() hasn't been called" + "this hasn't been initialised - super() hasn't been called", ); return self; } function _inherits(subClass, superClass) { if (typeof superClass != "function" && superClass !== null) throw new TypeError( - "Super expression must either be null or a function" + "Super expression must either be null or a function", ); (subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: !0, configurable: !0 }, @@ -364,7 +364,7 @@ var require_assertion_error = __commonJS({ if (Class2 === null || !_isNativeFunction(Class2)) return Class2; if (typeof Class2 != "function") throw new TypeError( - "Super expression must either be null or a function" + "Super expression must either be null or a function", ); if (typeof _cache != "undefined") { if (_cache.has(Class2)) return _cache.get(Class2); @@ -374,7 +374,7 @@ var require_assertion_error = __commonJS({ return _construct( Class2, arguments, - _getPrototypeOf(this).constructor + _getPrototypeOf(this).constructor, ); } return ( @@ -403,7 +403,7 @@ var require_assertion_error = __commonJS({ try { return ( Date.prototype.toString.call( - Reflect.construct(Date, [], function () {}) + Reflect.construct(Date, [], function () {}), ), !0 ); @@ -569,12 +569,12 @@ var require_assertion_error = __commonJS({ kReadableOperator[operator], ` -` +`, ) + "".concat(actualLines[0], " !== ").concat( expectedLines[0], ` -` +`, ) ); } else if (operator !== "strictEqualObject") { @@ -624,13 +624,13 @@ var require_assertion_error = __commonJS({ kReadableOperator.notIdentical, ` -` +`, ) .concat( _actualLines.join(` `), ` -` +`, ); } i > 3 && @@ -757,19 +757,19 @@ var require_assertion_error = __commonJS({ .concat( skippedMsg, ` -` +`, ) .concat( res, ` -` +`, ) .concat(blue, "...") .concat(white) .concat( other, ` -` +`, ) + "".concat(blue, "...").concat(white) ); } @@ -778,7 +778,7 @@ var require_assertion_error = __commonJS({ .concat( skipped ? skippedMsg : "", ` -` +`, ) .concat(res) .concat(other) @@ -803,7 +803,7 @@ var require_assertion_error = __commonJS({ if (((Error.stackTraceLimit = 0), message != null)) _this = _possibleConstructorReturn( this, - _getPrototypeOf(AssertionError2).call(this, String(message)) + _getPrototypeOf(AssertionError2).call(this, String(message)), ); else if ( (process.stderr && @@ -828,8 +828,8 @@ var require_assertion_error = __commonJS({ this, _getPrototypeOf(AssertionError2).call( this, - createErrDiff(actual, expected, operator) - ) + createErrDiff(actual, expected, operator), + ), ); else if ( operator === "notDeepStrictEqual" || @@ -856,8 +856,8 @@ var require_assertion_error = __commonJS({ this, _getPrototypeOf(AssertionError2).call( this, - "".concat(base, " ").concat(res[0]) - ) + "".concat(base, " ").concat(res[0]), + ), )) : (_this = _possibleConstructorReturn( this, @@ -868,15 +868,15 @@ var require_assertion_error = __commonJS({ base, ` -` +`, ) .concat( res.join(` `), ` -` - ) - ) +`, + ), + ), )); } else { var _res = inspectValue(actual), @@ -888,7 +888,7 @@ var require_assertion_error = __commonJS({ kReadableOperator[operator], ` -` +`, ) .concat(_res)), _res.length > 1024 && @@ -904,7 +904,7 @@ var require_assertion_error = __commonJS({ knownOperators, ` -` +`, ) .concat( _res, @@ -912,15 +912,15 @@ var require_assertion_error = __commonJS({ should equal -` +`, )) : (other = " ".concat(operator, " ").concat(other))), (_this = _possibleConstructorReturn( this, _getPrototypeOf(AssertionError2).call( this, - "".concat(_res).concat(other) - ) + "".concat(_res).concat(other), + ), )); } return ( @@ -939,7 +939,7 @@ should equal Error.captureStackTrace && Error.captureStackTrace( _assertThisInitialized(_this), - stackStartFn + stackStartFn, ), _this.stack, (_this.name = "AssertionError"), @@ -965,7 +965,7 @@ should equal _objectSpread({}, ctx, { customInspect: !1, depth: 0, - }) + }), ); }, }, @@ -1280,7 +1280,7 @@ var require_implementation2 = __commonJS({ if (this instanceof bound) { var result = target.apply( this, - args.concat(slice.call(arguments)) + args.concat(slice.call(arguments)), ); return Object(result) === result ? result : this; } else @@ -1298,7 +1298,7 @@ var require_implementation2 = __commonJS({ "binder", "return function (" + boundArgs.join(",") + - "){ return binder.apply(this,arguments); }" + "){ return binder.apply(this,arguments); }", )(binder)), target.prototype) ) { @@ -1341,7 +1341,7 @@ var require_get_intrinsic = __commonJS({ getEvalledConstructor = function (expressionSyntax) { try { return $Function( - '"use strict"; return (' + expressionSyntax + ").constructor;" + '"use strict"; return (' + expressionSyntax + ").constructor;", )(); } catch {} }, @@ -1562,11 +1562,11 @@ var require_get_intrinsic = __commonJS({ last = $strSlice(string, -1); if (first === "%" && last !== "%") throw new $SyntaxError( - "invalid intrinsic syntax, expected closing `%`" + "invalid intrinsic syntax, expected closing `%`", ); if (last === "%" && first !== "%") throw new $SyntaxError( - "invalid intrinsic syntax, expected opening `%`" + "invalid intrinsic syntax, expected opening `%`", ); var result = []; return ( @@ -1577,7 +1577,7 @@ var require_get_intrinsic = __commonJS({ result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match; - } + }, ), result ); @@ -1599,7 +1599,7 @@ var require_get_intrinsic = __commonJS({ throw new $TypeError( "intrinsic " + name + - " exists, but is not available. Please file an issue!" + " exists, but is not available. Please file an issue!", ); return { alias, @@ -1616,13 +1616,13 @@ var require_get_intrinsic = __commonJS({ throw new $TypeError('"allowMissing" argument must be a boolean'); if ($exec(/^%?[^%]*%?$/g, name) === null) throw new $SyntaxError( - "`%` may not be present anywhere but at the beginning and end of the intrinsic name" + "`%` may not be present anywhere but at the beginning and end of the intrinsic name", ); var parts = stringToPath(name), intrinsicBaseName = parts.length > 0 ? parts[0] : "", intrinsic = getBaseIntrinsic( "%" + intrinsicBaseName + "%", - allowMissing + allowMissing, ), intrinsicRealName = intrinsic.name, value = intrinsic.value, @@ -1645,7 +1645,7 @@ var require_get_intrinsic = __commonJS({ first !== last ) throw new $SyntaxError( - "property names with quotes must have matching quotes" + "property names with quotes must have matching quotes", ); if ( ((part === "constructor" || !isOwn) && (skipFurtherCaching = !0), @@ -1660,7 +1660,7 @@ var require_get_intrinsic = __commonJS({ throw new $TypeError( "base intrinsic for " + name + - " exists, but the property is not available." + " exists, but the property is not available.", ); return; } @@ -1831,7 +1831,7 @@ var require_shim = __commonJS({ is: function () { return Object.is !== polyfill; }, - } + }, ), polyfill ); @@ -1897,7 +1897,7 @@ var require_shim2 = __commonJS({ isNaN: function () { return Number.isNaN !== polyfill; }, - } + }, ), polyfill ); @@ -1937,7 +1937,7 @@ var require_comparisons = __commonJS({ } function _nonIterableRest() { throw new TypeError( - "Invalid attempt to destructure non-iterable instance" + "Invalid attempt to destructure non-iterable instance", ); } function _iterableToArrayLimit(arr, i) { @@ -2044,8 +2044,8 @@ var require_comparisons = __commonJS({ .filter(isNonIndex) .concat( objectGetOwnPropertySymbols(value).filter( - Object.prototype.propertyIsEnumerable.bind(value) - ) + Object.prototype.propertyIsEnumerable.bind(value), + ), ); } function compare(a, b) { @@ -2085,7 +2085,7 @@ var require_comparisons = __commonJS({ ? !1 : compare( new Uint8Array(a.buffer, a.byteOffset, a.byteLength), - new Uint8Array(b.buffer, b.byteOffset, b.byteLength) + new Uint8Array(b.buffer, b.byteOffset, b.byteLength), ) === 0; } function areEqualArrayBuffers(buf1, buf2) { @@ -2099,7 +2099,7 @@ var require_comparisons = __commonJS({ ? isNumberObject(val2) && objectIs( Number.prototype.valueOf.call(val1), - Number.prototype.valueOf.call(val2) + Number.prototype.valueOf.call(val2), ) : isStringObject(val1) ? isStringObject(val2) && @@ -2503,7 +2503,7 @@ var require_assert = __commonJS({ warn( "assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", - "DEP0094" + "DEP0094", ); } argsLen === 2 && (operator = "!="); @@ -2605,7 +2605,7 @@ var require_assert = __commonJS({ assert.deepStrictEqual = function deepStrictEqual( actual, expected, - message + message, ) { if (arguments.length < 2) throw new ERR_MISSING_ARGS("actual", "expected"); @@ -2704,7 +2704,7 @@ var require_assert = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "expected", ["Function", "RegExp"], - expected + expected, ); if (_typeof(actual) !== "object" || actual === null) { var err = new AssertionError({ @@ -2722,7 +2722,7 @@ var require_assert = __commonJS({ throw new ERR_INVALID_ARG_VALUE( "error", expected, - "may not be an empty object" + "may not be an empty object", ); return ( isDeepEqual === void 0 && lazyLoadComparison(), @@ -2768,14 +2768,14 @@ var require_assert = __commonJS({ throw new ERR_INVALID_RETURN_VALUE( "instance of Promise", "promiseFn", - resultPromise + resultPromise, ); } else if (checkIsPromise(promiseFn)) resultPromise = promiseFn; else throw new ERR_INVALID_ARG_TYPE( "promiseFn", ["Function", "Promise"], - promiseFn + promiseFn, ); return Promise.resolve() .then(function () { @@ -2795,7 +2795,7 @@ var require_assert = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "error", ["Object", "Error", "Function", "RegExp"], - error + error, ); if (_typeof(actual) === "object" && actual !== null) { if (actual.message === error) @@ -2803,13 +2803,13 @@ var require_assert = __commonJS({ "error/message", 'The error message "'.concat( actual.message, - '" is identical to the message.' - ) + '" is identical to the message.', + ), ); } else if (actual === error) throw new ERR_AMBIGUOUS_ARGUMENT( "error/message", - 'The error "'.concat(actual, '" is identical to the message.') + 'The error "'.concat(actual, '" is identical to the message.'), ); (message = error), (error = void 0); } else if ( @@ -2820,7 +2820,7 @@ var require_assert = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "error", ["Object", "Error", "Function", "RegExp"], - error + error, ); if (actual === NO_EXCEPTION_SENTINEL) { var details = ""; @@ -2856,7 +2856,7 @@ var require_assert = __commonJS({ "Got unwanted ".concat(fnType).concat( details, ` -` +`, ) + 'Actual message: "'.concat(actual && actual.message, '"'), stackStartFn, }); @@ -2911,7 +2911,7 @@ var require_assert = __commonJS({ return waitForActual(fn).then(function (result) { return expectsNoError.apply( void 0, - [doesNotReject, result].concat(args) + [doesNotReject, result].concat(args), ); }); }; @@ -2953,11 +2953,11 @@ var require_assert = __commonJS({ tmp1.join(` `), ` -` +`, ) .concat( tmp2.join(` -`) +`), ); } throw newErr; diff --git a/src/bun.js/bindings/sqlite/sqlite.exports.js b/src/bun.js/bindings/sqlite/sqlite.exports.js index 6c1bf803d9..875e28ff11 100644 --- a/src/bun.js/bindings/sqlite/sqlite.exports.js +++ b/src/bun.js/bindings/sqlite/sqlite.exports.js @@ -3,7 +3,7 @@ var symbolFor = Symbol.for; const lazy = globalThis[symbolFor("Bun.lazy")]; if (!lazy || typeof lazy !== "function") { throw new Error( - "Something went wrong while loading Bun. Expected 'Bun.lazy' to be defined." + "Something went wrong while loading Bun. Expected 'Bun.lazy' to be defined.", ); } @@ -185,14 +185,14 @@ export class Database { filenameGiven, typeof options === "object" && options ? !!options.readonly - : ((options | 0) & constants.SQLITE_OPEN_READONLY) != 0 + : ((options | 0) & constants.SQLITE_OPEN_READONLY) != 0, ); this.filename = ":memory:"; return; } throw new TypeError( - `Expected 'filename' to be a string, got '${typeof filenameGiven}'` + `Expected 'filename' to be a string, got '${typeof filenameGiven}'`, ); } @@ -208,7 +208,7 @@ export class Database { if ("readOnly" in options) throw new TypeError( - 'Misspelled option "readOnly" should be "readonly"' + 'Misspelled option "readOnly" should be "readonly"', ); if (options.create) { @@ -316,7 +316,7 @@ export class Database { query(query) { if (typeof query !== "string") { throw new TypeError( - `Expected 'query' to be a string, got '${typeof query}'` + `Expected 'query' to be a string, got '${typeof query}'`, ); } @@ -337,7 +337,7 @@ export class Database { return (this.#cachedQueriesValues[index] = this.prepare( query, undefined, - willCache ? constants.SQLITE_PREPARE_PERSISTENT : 0 + willCache ? constants.SQLITE_PREPARE_PERSISTENT : 0, )); } return stmt; @@ -349,7 +349,7 @@ export class Database { var stmt = this.prepare( query, undefined, - willCache ? constants.SQLITE_PREPARE_PERSISTENT : 0 + willCache ? constants.SQLITE_PREPARE_PERSISTENT : 0, ); if (willCache) { @@ -413,21 +413,21 @@ const getController = (db, self) => { (controller = { default: Object.assign( { begin: db.prepare("BEGIN", undefined, 0) }, - shared + shared, ), deferred: Object.assign( { begin: db.prepare("BEGIN DEFERRED", undefined, 0) }, - shared + shared, ), immediate: Object.assign( { begin: db.prepare("BEGIN IMMEDIATE", undefined, 0) }, - shared + shared, ), exclusive: Object.assign( { begin: db.prepare("BEGIN EXCLUSIVE", undefined, 0) }, - shared + shared, ), - }) + }), ); } return controller; @@ -437,7 +437,7 @@ const getController = (db, self) => { const wrapTransaction = ( fn, db, - { begin, commit, rollback, savepoint, release, rollbackTo } + { begin, commit, rollback, savepoint, release, rollbackTo }, ) => function transaction(...args) { let before, after, undo; diff --git a/src/bun.js/child_process.exports.js b/src/bun.js/child_process.exports.js index eff7bfca04..5295152dc0 100644 --- a/src/bun.js/child_process.exports.js +++ b/src/bun.js/child_process.exports.js @@ -137,7 +137,7 @@ export function spawn(file, args, options) { } else { signal.addEventListener("abort", onAbortListener, { once: true }); child.once("exit", () => - signal.removeEventListener("abort", onAbortListener) + signal.removeEventListener("abort", onAbortListener), ); } @@ -178,7 +178,7 @@ export function execFile(file, args, options, callback) { file, args, options, - callback + callback, )); options = { @@ -332,7 +332,7 @@ export function execFile(file, args, options, callback) { const truncatedLen = maxBuffer - (encodedStdoutLen - actualLen); ArrayPrototypePush.call( _stdout, - StringPrototypeSlice.apply(chunk, 0, truncatedLen) + StringPrototypeSlice.apply(chunk, 0, truncatedLen), ); ex = new ERR_CHILD_PROCESS_STDIO_MAXBUFFER("stdout"); @@ -353,7 +353,7 @@ export function execFile(file, args, options, callback) { } else { ArrayPrototypePush.call(_stdout, chunk); } - } + }, ); } @@ -383,7 +383,7 @@ export function execFile(file, args, options, callback) { const truncatedLen = maxBuffer - (encodedStderrLen - actualLen); ArrayPrototypePush.call( _stderr, - StringPrototypeSlice.call(chunk, 0, truncatedLen) + StringPrototypeSlice.call(chunk, 0, truncatedLen), ); ex = new ERR_CHILD_PROCESS_STDIO_MAXBUFFER("stderr"); @@ -399,7 +399,7 @@ export function execFile(file, args, options, callback) { const truncatedLen = maxBuffer - (stderrLen - chunk.length); ArrayPrototypePush.call( _stderr, - StringPrototypeSlice.call(chunk, 0, truncatedLen) + StringPrototypeSlice.call(chunk, 0, truncatedLen), ); ex = new ERR_CHILD_PROCESS_STDIO_MAXBUFFER("stderr"); @@ -407,7 +407,7 @@ export function execFile(file, args, options, callback) { } else { ArrayPrototypePush.call(_stderr, chunk); } - } + }, ); } @@ -651,7 +651,7 @@ function sanitizeKillSignal(killSignal) { throw new ERR_INVALID_ARG_TYPE( "options.killSignal", ["string", "number"], - killSignal + killSignal, ); } } @@ -771,7 +771,7 @@ function normalizeSpawnArguments(file, args, options) { throw new ERR_INVALID_ARG_TYPE( "options.shell", ["boolean", "string"], - options.shell + options.shell, ); } @@ -1257,7 +1257,7 @@ function validateMaxBuffer(maxBuffer) { throw new ERR_OUT_OF_RANGE( "options.maxBuffer", "a positive number", - maxBuffer + maxBuffer, ); } } @@ -1267,7 +1267,7 @@ function validateArgumentNullCheck(arg, propName) { throw new ERR_INVALID_ARG_VALUE( propName, arg, - "must be a string without null bytes" + "must be a string without null bytes", ); } } @@ -1332,9 +1332,9 @@ const validateOneOf = (value, name, oneOf) => { if (!ArrayPrototypeIncludes.call(oneOf, value)) { const allowed = ArrayPrototypeJoin.call( ArrayPrototypeMap.call(oneOf, (v) => - typeof v === "string" ? `'${v}'` : String(v) + typeof v === "string" ? `'${v}'` : String(v), ), - ", " + ", ", ); const reason = "must be one of: " + allowed; throw new ERR_INVALID_ARG_VALUE(name, value, reason); @@ -1417,7 +1417,7 @@ function nullCheck(path, propName, throwError = true) { const err = new ERR_INVALID_ARG_VALUE( propName, path, - "must be a string or Uint8Array without null bytes" + "must be a string or Uint8Array without null bytes", ); if (throwError) { throw err; @@ -1672,7 +1672,7 @@ function ERR_OUT_OF_RANGE(str, range, input, replaceDefaultBoolean = false) { // msg += ` It must be ${range}. Received ${received}`; // return new RangeError(msg); return new RangeError( - `The value of ${str} is out of range. It must be ${range}. Received ${input}` + `The value of ${str} is out of range. It must be ${range}. Received ${input}`, ); } @@ -1688,7 +1688,7 @@ function ERR_UNKNOWN_SIGNAL(name) { function ERR_INVALID_ARG_TYPE(name, type, value) { const err = new TypeError( - `The "${name}" argument must be of type ${type}. Received ${value}` + `The "${name}" argument must be of type ${type}. Received ${value}`, ); err.code = "ERR_INVALID_ARG_TYPE"; return err; @@ -1700,7 +1700,7 @@ function ERR_INVALID_OPT_VALUE(name, value) { function ERR_INVALID_ARG_VALUE(name, value, reason) { return new Error( - `The value "${value}" is invalid for argument '${name}'. Reason: ${reason}` + `The value "${value}" is invalid for argument '${name}'. Reason: ${reason}`, ); } diff --git a/src/bun.js/depd.exports.js b/src/bun.js/depd.exports.js index 04ed01555e..b6164bf026 100644 --- a/src/bun.js/depd.exports.js +++ b/src/bun.js/depd.exports.js @@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => ( isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, - mod + mod, ) ); diff --git a/src/bun.js/ffi.exports.js b/src/bun.js/ffi.exports.js index 67ad972879..ec553b7d5c 100644 --- a/src/bun.js/ffi.exports.js +++ b/src/bun.js/ffi.exports.js @@ -54,7 +54,7 @@ export class CString extends String { ? typeof byteLength === "number" && Number.isSafeInteger(byteLength) ? new BunCString(ptr, byteOffset || 0, byteLength) : new BunCString(ptr) - : "" + : "", ); this.ptr = typeof ptr === "number" ? ptr : 0; if (typeof byteOffset !== "undefined") { @@ -82,7 +82,7 @@ export class CString extends String { return (this.#cachedArrayBuffer = toArrayBuffer( this.ptr, this.byteOffset, - this.byteLength + this.byteLength, )); } } @@ -209,7 +209,7 @@ Object.defineProperty(globalThis, "__GlobalBunFFIPtrFunctionForWrapper", { }); ffiWrappers[FFIType.cstring] = ffiWrappers[FFIType.pointer] = function pointer( - val + val, ) { if (typeof val === "number") return val; if (!val) { @@ -222,7 +222,7 @@ ffiWrappers[FFIType.cstring] = ffiWrappers[FFIType.pointer] = function pointer( if (typeof val === "string") { throw new TypeError( - "To convert a string to a pointer, encode it as a buffer" + "To convert a string to a pointer, encode it as a buffer", ); } @@ -267,7 +267,7 @@ function FFIBuilder(params, returnType, functionToCall, name) { throw new TypeError( `Unsupported type ${params[i]}. Must be one of: ${Object.keys(FFIType) .sort() - .join(", ")}` + .join(", ")}`, ); } } @@ -335,7 +335,7 @@ function FFIBuilder(params, returnType, functionToCall, name) { arg6, arg7, arg8, - arg9 + arg9, ); break; default: { @@ -376,7 +376,7 @@ export function dlopen(path, options) { // "sqlite3_get_version() - sqlit3.so" path.includes("/") ? `${key} (${path.split("/").pop()})` - : `${key} (${path})` + : `${key} (${path})`, ); } else { // consistentcy @@ -400,7 +400,7 @@ export function linkSymbols(options) { options[key].args ?? [], options[key].returns ?? FFIType.void, symbol, - key + key, ); } else { // consistentcy @@ -433,7 +433,7 @@ export function CFunction(options) { cFunctionRegistry ||= new FinalizationRegistry(onCloseCFunction); cFunctionRegistry.register( result.symbols[identifier], - result.symbols[identifier].close + result.symbols[identifier].close, ); return result.symbols[identifier]; diff --git a/src/bun.js/fs.exports.js b/src/bun.js/fs.exports.js index ebf929cb1d..583ede0cb0 100644 --- a/src/bun.js/fs.exports.js +++ b/src/bun.js/fs.exports.js @@ -199,13 +199,13 @@ export var rmSync = fs.rmSync.bind(fs); // _maxListener var _lazyReadStream; var readStreamPathFastPathSymbol = Symbol.for( - "Bun.Node.readStreamPathFastPath" + "Bun.Node.readStreamPathFastPath", ); const readStreamSymbol = Symbol.for("Bun.NodeReadStream"); const readStreamPathOrFdSymbol = Symbol.for("Bun.NodeReadStreamPathOrFd"); var writeStreamPathFastPathSymbol = Symbol.for("Bun.NodeWriteStreamFastPath"); var writeStreamPathFastPathCallSymbol = Symbol.for( - "Bun.NodeWriteStreamFastPathCall" + "Bun.NodeWriteStreamFastPathCall", ); var kIoDone = Symbol.for("kIoDone"); @@ -653,7 +653,7 @@ function getLazyWriteStream() { readStream[kIoDone] = false; return Bun.write( this[writeStreamPathFastPathSymbol], - readStream[readStreamPathOrFdSymbol] + readStream[readStreamPathOrFdSymbol], ).then( (bytesWritten) => { readStream[kIoDone] = this[kIoDone] = true; @@ -666,7 +666,7 @@ function getLazyWriteStream() { readStream[kIoDone] = this[kIoDone] = true; this.#errorOrDestroy(err); readStream.emit("error", err); - } + }, ); } @@ -769,7 +769,7 @@ function getLazyWriteStream() { this.emit(kIoDone); !err ? cb() : cb(err); - } + }, ); } else { this[kIoDone] = true; @@ -784,7 +784,7 @@ function getLazyWriteStream() { this.#handleWrite(err, bytes); this.emit(kIoDone); !err ? cb() : cb(err); - } + }, ); } } diff --git a/src/bun.js/http.exports.js b/src/bun.js/http.exports.js index 4804b93224..d0a669d7be 100644 --- a/src/bun.js/http.exports.js +++ b/src/bun.js/http.exports.js @@ -85,7 +85,7 @@ export class Server extends EventEmitter { } catch (err) { this.emit( "error", - new Error(`bun-http-polyfill: Bun.serve failed: ${err.message}`) + new Error(`bun-http-polyfill: Bun.serve failed: ${err.message}`), ); } } @@ -170,7 +170,7 @@ export class IncomingMessage extends Readable { this.complete = true; } else { this.push( - this._body.subarray(this._body_offset, (this._body_offset += size)) + this._body.subarray(this._body_offset, (this._body_offset += size)), ); } } @@ -313,8 +313,8 @@ export class ServerResponse extends Writable { headers: this.#headers, status: this.statusCode, statusText: this.statusMessage ?? STATUS_CODES[this.statusCode], - } - ) + }, + ), ); } @@ -327,7 +327,7 @@ export class ServerResponse extends Writable { headers: this.#headers, status: this.statusCode, statusText: this.statusMessage ?? STATUS_CODES[this.statusCode], - }) + }), ); callback && callback(); return; diff --git a/src/bun.js/net.exports.js b/src/bun.js/net.exports.js index ce70c3ee1a..fee0c9afa1 100644 --- a/src/bun.js/net.exports.js +++ b/src/bun.js/net.exports.js @@ -36,7 +36,7 @@ const IPv6Reg = new RegExp( `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + - ")(%[0-9a-zA-Z-.:]{1,})?$" + ")(%[0-9a-zA-Z-.:]{1,})?$", ); export function isIPv4(s) { diff --git a/src/bun.js/perf_hooks.exports.js b/src/bun.js/perf_hooks.exports.js index b49e2fc4ad..d25f90ccf2 100644 --- a/src/bun.js/perf_hooks.exports.js +++ b/src/bun.js/perf_hooks.exports.js @@ -14,7 +14,7 @@ export class PerformanceEntry { export class PerformanceNodeTiming { constructor() { throw new Error( - "PerformanceNodeTiming is not supported in this environment." + "PerformanceNodeTiming is not supported in this environment.", ); } } diff --git a/src/bun.js/scripts/class-definitions.ts b/src/bun.js/scripts/class-definitions.ts index 95dfd69bfe..5dac5db9cf 100644 --- a/src/bun.js/scripts/class-definitions.ts +++ b/src/bun.js/scripts/class-definitions.ts @@ -6,7 +6,7 @@ export type Field = fn: string; length?: number; DOMJIT?: { - return: string; + returns: string; args?: [string, string] | [string, string, string] | [string]; }; } @@ -24,6 +24,7 @@ export interface ClassDefinition { noConstructor?: boolean; estimatedSize?: boolean; hasPendingActivity?: boolean; + isEventEmitter?: boolean; } export function define( @@ -35,7 +36,7 @@ export function define( call = false, construct = false, ...rest - } = {} as ClassDefinition + } = {} as ClassDefinition, ): ClassDefinition { return { ...rest, @@ -44,10 +45,10 @@ export function define( estimatedSize, values, klass: Object.fromEntries( - Object.entries(klass).sort(([a], [b]) => a.localeCompare(b)) + Object.entries(klass).sort(([a], [b]) => a.localeCompare(b)), ), proto: Object.fromEntries( - Object.entries(proto).sort(([a], [b]) => a.localeCompare(b)) + Object.entries(proto).sort(([a], [b]) => a.localeCompare(b)), ), }; } diff --git a/src/bun.js/scripts/generate-classes.ts b/src/bun.js/scripts/generate-classes.ts index 2b50246d40..ba6f68e082 100644 --- a/src/bun.js/scripts/generate-classes.ts +++ b/src/bun.js/scripts/generate-classes.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { unlinkSync } from "fs"; import { readdirSync } from "fs"; import { resolve } from "path"; @@ -95,18 +96,18 @@ function DOMJITFunctionDeclaration(jsClassName, fnName, { args, returns }) { const argNames = args.map((arg, i) => `${argTypeName(arg)} arg${i}`); return ` extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(${DOMJITName( - fnName + fnName, )}Wrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, ${argNames.join( - ", " + ", ", )})); extern "C" EncodedJSValue ${DOMJITName( - fnName + fnName, )}(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, ${argNames.join( - ", " + ", ", )}); static const JSC::DOMJIT::Signature DOMJITSignatureFor${fnName}(${DOMJITName( - fnName + fnName, )}Wrapper, ${jsClassName}::info(), JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), @@ -120,9 +121,9 @@ function DOMJITFunctionDefinition(jsClassName, fnName, { args }) { const argNames = args.map((arg, i) => `${argTypeName(arg)} arg${i}`); return ` JSC_DEFINE_JIT_OPERATION(${DOMJITName( - fnName + fnName, )}Wrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, ${argNames.join( - ", " + ", ", )})) { VM& vm = JSC::getVM(lexicalGlobalObject); @@ -131,7 +132,7 @@ JSC_DEFINE_JIT_OPERATION(${DOMJITName( IGNORE_WARNINGS_END JSC::JITOperationPrologueCallFrameTracer tracer(vm, callFrame); return ${DOMJITName( - fnName + fnName, )}(reinterpret_cast<${jsClassName}*>(thisValue)->wrapped(), lexicalGlobalObject, ${args .map((b, i) => "arg" + i) .join(", ")}); @@ -142,7 +143,7 @@ JSC_DEFINE_JIT_OPERATION(${DOMJITName( function appendSymbols( to: Map, symbolName: (name: string) => string, - prop + prop, ) { var { defaultValue, getter, setter, accesosr, fn, DOMJIT, cache } = prop; @@ -171,7 +172,7 @@ function propRow( typeName: string, name: string, prop: Field, - isWrapped = true + isWrapped = true, ) { var { defaultValue, @@ -183,7 +184,7 @@ function propRow( length = 0, cache, DOMJIT, - } = prop; + } = prop as any; if (accesosr) { getter = accesosr.getter; @@ -249,7 +250,7 @@ export function generateHashTable( typeName, obj, props = {}, - wrapped + wrapped, ) { const rows = []; @@ -294,7 +295,7 @@ ${ obj.construct ? `extern "C" void* ${classSymbolName( typeName, - "construct" + "construct", )}(JSC::JSGlobalObject*, JSC::CallFrame*); JSC_DECLARE_CUSTOM_GETTER(js${typeName}Constructor);` : "" @@ -308,7 +309,7 @@ ${ obj.call ? `extern "C" JSC_DECLARE_HOST_FUNCTION(${classSymbolName( typeName, - "call" + "call", )});` : "" } @@ -323,7 +324,7 @@ ${generateHashTable( obj, protoFields, - true + true, )} @@ -334,14 +335,14 @@ ${renderFieldsImpl( typeName, obj, protoFields, - obj.values || [] + obj.values || [], )} void ${proto}::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject) { Base::finishCreation(vm); reifyStaticProperties(vm, ${className( - typeName + typeName, )}::info(), ${proto}TableValues, *this); JSC_TO_STRING_TAG_WITHOUT_TRANSITION(); } @@ -391,7 +392,7 @@ function generateConstructorHeader(typeName) { public: using Base = JSC::InternalFunction; static ${name}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, ${prototypeName( - typeName + typeName, )}* prototype); static constexpr unsigned StructureFlags = Base::StructureFlags; @@ -409,22 +410,22 @@ function generateConstructorHeader(typeName) { return WebCore::subspaceForImpl<${name}, WebCore::UseCustomHeapCellType::No>( vm, [](auto& spaces) { return spaces.${clientSubspaceFor( - typeName + typeName, )}Constructor.get(); }, [](auto& spaces, auto&& space) { spaces.${clientSubspaceFor( - typeName + typeName, )}Constructor = WTFMove(space); }, [](auto& spaces) { return spaces.${subspaceFor( - typeName + typeName, )}Constructor.get(); }, [](auto& spaces, auto&& space) { spaces.${subspaceFor( - typeName + typeName, )}Constructor = WTFMove(space); }); } void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, ${prototypeName( - typeName + typeName, )}* prototype); // Must be defined for each specialization class. @@ -434,7 +435,7 @@ function generateConstructorHeader(typeName) { private: ${name}(JSC::VM& vm, JSC::Structure* structure); void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, ${prototypeName( - typeName + typeName, )}* prototype); }; @@ -460,7 +461,7 @@ ${renderStaticDecls(classSymbolName, typeName, fields)} ${hashTable} void ${name}::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, ${prototypeName( - typeName + typeName, )}* prototype) { Base::finishCreation(vm, 0, "${typeName}"_s, PropertyAdditionMode::WithoutStructureTransition); @@ -480,7 +481,7 @@ ${name}::${name}(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, $ } ${name}* ${name}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, ${prototypeName( - typeName + typeName, )}* prototype) { ${name}* ptr = new (NotNull, JSC::allocateCell<${name}>(vm)) ${name}(vm, structure); ptr->finishCreation(vm, globalObject, prototype); @@ -511,7 +512,7 @@ JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES ${name}::construct(JSC::JSGlobalObj void* ptr = ${classSymbolName( typeName, - "construct" + "construct", )}(globalObject, callFrame); if (UNLIKELY(!ptr)) { @@ -519,13 +520,13 @@ JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES ${name}::construct(JSC::JSGlobalObj } ${className(typeName)}* instance = ${className( - typeName + typeName, )}::create(vm, globalObject, structure, ptr); ${ obj.estimatedSize ? `vm.heap.reportExtraMemoryAllocated(${symbolName( obj.name, - "estimatedSize" + "estimatedSize", )}(instance->wrapped()));` : "" } @@ -537,13 +538,13 @@ extern "C" EncodedJSValue ${typeName}__create(Zig::GlobalObject* globalObject, v auto &vm = globalObject->vm(); JSC::Structure* structure = globalObject->${className(typeName)}Structure(); ${className(typeName)}* instance = ${className( - typeName + typeName, )}::create(vm, globalObject, structure, ptr); ${ obj.estimatedSize ? `vm.heap.reportExtraMemoryAllocated(${symbolName( obj.name, - "estimatedSize" + "estimatedSize", )}(ptr));` : "" } @@ -551,7 +552,7 @@ extern "C" EncodedJSValue ${typeName}__create(Zig::GlobalObject* globalObject, v } void ${name}::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, ${prototypeName( - typeName + typeName, )}* prototype) { @@ -607,12 +608,12 @@ function renderDecls(symbolName, typeName, proto) { rows.push( `extern "C" JSC::EncodedJSValue ${symbolName( typeName, - proto[name].getter || proto[name].accessor.getter + proto[name].getter || proto[name].accessor.getter, )}(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);`, ` JSC_DECLARE_CUSTOM_GETTER(${symbolName(typeName, name)}GetterWrap); `.trim(), - "\n" + "\n", ); } @@ -623,12 +624,12 @@ function renderDecls(symbolName, typeName, proto) { rows.push( `extern "C" bool ${symbolName( typeName, - proto[name].setter || proto[name].accessor.setter + proto[name].setter || proto[name].accessor.setter, )}(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);`, ` JSC_DECLARE_CUSTOM_SETTER(${symbolName(typeName, name)}SetterWrap); `.trim(), - "\n" + "\n", ); } @@ -636,13 +637,13 @@ function renderDecls(symbolName, typeName, proto) { rows.push( `extern "C" EncodedJSValue ${symbolName( typeName, - proto[name].fn + proto[name].fn, )}(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);`, ` JSC_DECLARE_HOST_FUNCTION(${symbolName(typeName, name)}Callback); `.trim(), - "\n" + "\n", ); if (proto[name].DOMJIT) { @@ -650,13 +651,13 @@ function renderDecls(symbolName, typeName, proto) { DOMJITFunctionDeclaration( className(typeName), symbolName(typeName, name), - proto[name].DOMJIT + proto[name].DOMJIT, ), DOMJITFunctionDefinition( className(typeName), symbolName(typeName, name), - proto[name].DOMJIT - ) + proto[name].DOMJIT, + ), ); } } @@ -676,8 +677,8 @@ function renderStaticDecls(symbolName, typeName, fields) { rows.push( `extern "C" JSC_DECLARE_CUSTOM_GETTER(${symbolName( typeName, - fields[name].getter || fields[name].accessor.getter - )});` + fields[name].getter || fields[name].accessor.getter, + )});`, ); } @@ -688,8 +689,8 @@ function renderStaticDecls(symbolName, typeName, fields) { rows.push( `extern "C" JSC_DECLARE_CUSTOM_SETTER(${symbolName( typeName, - fields[name].setter || fields[name].accessor.setter - )});` + fields[name].setter || fields[name].accessor.setter, + )});`, ); } @@ -697,8 +698,8 @@ function renderStaticDecls(symbolName, typeName, fields) { rows.push( `extern "C" JSC_DECLARE_HOST_FUNCTION(${symbolName( typeName, - fields[name].fn - )});` + fields[name].fn, + )});`, ); } } @@ -710,23 +711,23 @@ function writeBarrier(symbolName, typeName, name, cacheName) { extern "C" void ${symbolName( typeName, - name + name, )}SetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value) { auto& vm = globalObject->vm(); auto* thisObject = jsCast<${className( - typeName + typeName, )}*>(JSValue::decode(thisValue)); thisObject->${cacheName}.set(vm, thisObject, JSValue::decode(value)); } extern "C" EncodedJSValue ${symbolName( typeName, - name + name, )}GetCachedValue(JSC::EncodedJSValue thisValue) { auto* thisObject = jsCast<${className( - typeName + typeName, )}*>(JSValue::decode(thisValue)); return JSValue::encode(thisObject->${cacheName}.get()); } @@ -738,7 +739,7 @@ function renderFieldsImpl( typeName: string, obj: ClassDefinition, proto: ClassDefinition["proto"], - cachedValues: string[] + cachedValues: string[], ) { const rows: string[] = []; @@ -751,7 +752,7 @@ JSC_DEFINE_CUSTOM_GETTER(js${typeName}Constructor, (JSGlobalObject * lexicalGlob auto throwScope = DECLARE_THROW_SCOPE(vm); auto* globalObject = reinterpret_cast(lexicalGlobalObject); auto* prototype = jsDynamicCast<${prototypeName( - typeName + typeName, )}*>(JSValue::decode(thisValue)); if (UNLIKELY(!prototype)) @@ -772,14 +773,14 @@ JSC_DEFINE_CUSTOM_GETTER(js${typeName}Constructor, (JSGlobalObject * lexicalGlob rows.push(` JSC_DEFINE_CUSTOM_GETTER(${symbolName( typeName, - name + name, )}GetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) { auto& vm = lexicalGlobalObject->vm(); Zig::GlobalObject *globalObject = reinterpret_cast(lexicalGlobalObject); auto throwScope = DECLARE_THROW_SCOPE(vm); ${className(typeName)}* thisObject = jsCast<${className( - typeName + typeName, )}*>(JSValue::decode(thisValue)); JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject); @@ -789,7 +790,7 @@ JSC_DEFINE_CUSTOM_GETTER(${symbolName( JSC::JSValue result = JSC::JSValue::decode( ${symbolName( typeName, - proto[name].getter + proto[name].getter, )}(thisObject->wrapped(), globalObject) ); RETURN_IF_EXCEPTION(throwScope, {}); @@ -805,19 +806,19 @@ JSC_DEFINE_CUSTOM_GETTER(${symbolName( rows.push(` JSC_DEFINE_CUSTOM_GETTER(${symbolName( typeName, - name + name, )}GetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) { auto& vm = lexicalGlobalObject->vm(); Zig::GlobalObject *globalObject = reinterpret_cast(lexicalGlobalObject); auto throwScope = DECLARE_THROW_SCOPE(vm); ${className(typeName)}* thisObject = jsCast<${className( - typeName + typeName, )}*>(JSValue::decode(thisValue)); JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject); JSC::EncodedJSValue result = ${symbolName( typeName, - proto[name].getter + proto[name].getter, )}(thisObject->wrapped(), globalObject); RETURN_IF_EXCEPTION(throwScope, {}); RELEASE_AND_RETURN(throwScope, result); @@ -833,23 +834,23 @@ JSC_DEFINE_CUSTOM_GETTER(${symbolName( ` JSC_DEFINE_CUSTOM_SETTER(${symbolName( typeName, - name + name, )}SetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName)) { auto& vm = lexicalGlobalObject->vm(); auto throwScope = DECLARE_THROW_SCOPE(vm); ${className(typeName)}* thisObject = jsCast<${className( - typeName + typeName, )}*>(JSValue::decode(thisValue)); JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject); auto result = ${symbolName( typeName, - proto[name].setter || proto[name].accessor.setter + proto[name].setter || proto[name].accessor.setter, )}(thisObject->wrapped(), lexicalGlobalObject, encodedValue); RELEASE_AND_RETURN(throwScope, result); } -` +`, ); } @@ -857,13 +858,13 @@ JSC_DEFINE_CUSTOM_SETTER(${symbolName( rows.push(` JSC_DEFINE_HOST_FUNCTION(${symbolName( typeName, - name + name, )}Callback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame)) { auto& vm = lexicalGlobalObject->vm(); ${className(typeName)}* thisObject = jsDynamicCast<${className( - typeName + typeName, )}*>(callFrame->thisValue()); if (UNLIKELY(!thisObject)) { @@ -875,7 +876,7 @@ JSC_DEFINE_CUSTOM_SETTER(${symbolName( return ${symbolName( typeName, - proto[name].fn + proto[name].fn, )}(thisObject->wrapped(), lexicalGlobalObject, callFrame); } `); @@ -885,7 +886,7 @@ JSC_DEFINE_CUSTOM_SETTER(${symbolName( if (cachedValues?.length) { for (const cacheName of cachedValues) { rows.push( - writeBarrier(symbolName, typeName, cacheName, "m_" + cacheName) + writeBarrier(symbolName, typeName, cacheName, "m_" + cacheName), ); } } @@ -955,16 +956,16 @@ function generateClassHeader(typeName, obj: ClassDefinition) { return WebCore::subspaceForImpl<${name}, WebCore::UseCustomHeapCellType::No>( vm, [](auto& spaces) { return spaces.${clientSubspaceFor( - typeName + typeName, )}.get(); }, [](auto& spaces, auto&& space) { spaces.${clientSubspaceFor( - typeName + typeName, )} = WTFMove(space); }, [](auto& spaces) { return spaces.${subspaceFor( - typeName + typeName, )}.get(); }, [](auto& spaces, auto&& space) { spaces.${subspaceFor( - typeName + typeName, )} = WTFMove(space); }); } @@ -1027,7 +1028,7 @@ function generateClassImpl(typeName, obj: ClassDefinition) { ] .filter( ([name, { cache = false, internal = false }]) => - (cache || internal) === true + (cache || internal) === true, ) .map(([name]) => ` visitor.append(thisObject->m_${name});`) .join("\n"); @@ -1119,7 +1120,7 @@ extern "C" void* ${typeName}__fromJS(JSC::EncodedJSValue value) { return nullptr; ${className(typeName)}* object = JSC::jsDynamicCast<${className( - typeName + typeName, )}*>(decodedValue); if (!object) @@ -1130,7 +1131,7 @@ extern "C" void* ${typeName}__fromJS(JSC::EncodedJSValue value) { extern "C" bool ${typeName}__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) { ${className(typeName)}* object = JSC::jsDynamicCast<${className( - typeName + typeName, )}*>(JSValue::decode(value)); if (!object) return false; @@ -1141,7 +1142,7 @@ extern "C" bool ${typeName}__dangerouslySetPtr(JSC::EncodedJSValue value, void* extern "C" const size_t ${typeName}__ptrOffset = ${className( - typeName + typeName, )}::offsetOfWrapped(); void ${name}::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer) @@ -1157,18 +1158,18 @@ void ${name}::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer) JSObject* ${name}::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype) { return WebCore::${constructorName( - typeName + typeName, )}::create(vm, globalObject, WebCore::${constructorName( - typeName + typeName, )}::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast(prototype)); } JSObject* ${name}::createPrototype(VM& vm, JSDOMGlobalObject* globalObject) { return ${prototypeName(typeName)}::create(vm, globalObject, ${prototypeName( - typeName + typeName, )}::createStructure(vm, globalObject, globalObject->objectPrototype())); } @@ -1207,7 +1208,7 @@ function generateZig( call = false, values = [], hasPendingActivity = false, - } = {} as ClassDefinition + } = {} as ClassDefinition, ) { const exports = new Map(); @@ -1230,15 +1231,15 @@ function generateZig( if (hasPendingActivity) { exports.set( "hasPendingActivity", - symbolName(typeName, "hasPendingActivity") + symbolName(typeName, "hasPendingActivity"), ); } Object.values(klass).map((a) => - appendSymbols(exports, (name) => classSymbolName(typeName, name), a) + appendSymbols(exports, (name) => classSymbolName(typeName, name), a), ); Object.values(proto).map((a) => - appendSymbols(exports, (name) => protoSymbolName(typeName, name), a) + appendSymbols(exports, (name) => protoSymbolName(typeName, name), a), ); const externs = Object.entries({ @@ -1247,18 +1248,18 @@ function generateZig( }) .filter( ([name, { cache, internal }]) => - (cache && typeof cache !== "string") || internal + (cache && typeof cache !== "string") || internal, ) .map( ([name]) => `extern fn ${protoSymbolName( typeName, - name + name, )}SetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void; extern fn ${protoSymbolName( typeName, - name + name, )}GetCachedValue(JSC.JSValue) JSC.JSValue; /// \`${typeName}.${name}\` setter @@ -1267,7 +1268,7 @@ function generateZig( JSC.markBinding(@src()); ${protoSymbolName( typeName, - name + name, )}SetCachedValue(thisValue, globalObject, value); } @@ -1277,14 +1278,14 @@ function generateZig( JSC.markBinding(@src()); const result = ${protoSymbolName( typeName, - name + name, )}GetCachedValue(thisValue); if (result == .zero) return null; return result; } -`.trim() + "\n" +`.trim() + "\n", ) .join("\n"); @@ -1344,7 +1345,7 @@ function generateZig( output += ` if (@TypeOf(${typeName}.${DOMJITName(fn)}) != ${ZigDOMJITFunctionType( typeName, - DOMJIT + DOMJIT, )}) @compileLog( "Expected ${typeName}.${DOMJITName(fn)} to be a DOMJIT function" @@ -1357,7 +1358,7 @@ function generateZig( "Expected ${typeName}.${fn} to be a callback" );`; } - } + }, ); [...Object.values(klass)].forEach(({ getter, setter, accessor, fn }) => { @@ -1438,7 +1439,7 @@ pub const ${className(typeName)} = struct { if (comptime Environment.allow_assert) { const value__ = ${symbolName( typeName, - "create" + "create", )}(globalObject, this); std.debug.assert(value__.as(${typeName}).? == this); // If this fails, likely a C ABI issue. return value__; @@ -1458,19 +1459,19 @@ pub const ${className(typeName)} = struct { JSC.markBinding(@src()); std.debug.assert(${symbolName( typeName, - "dangerouslySetPtr" + "dangerouslySetPtr", )}(value, null)); } extern fn ${symbolName(typeName, "fromJS")}(JSC.JSValue) ?*${typeName}; extern fn ${symbolName( typeName, - "getConstructor" + "getConstructor", )}(*JSC.JSGlobalObject) JSC.JSValue; extern fn ${symbolName( typeName, - "create" + "create", )}(globalObject: *JSC.JSGlobalObject, ptr: ?*${typeName}) JSC.JSValue; extern fn ${typeName}__dangerouslySetPtr(JSC.JSValue, ?*${typeName}) bool; @@ -1482,7 +1483,7 @@ ${[...exports] .sort(([a], [b]) => a.localeCompare(b)) .map( ([internalName, externalName]) => - `@export(${typeName}.${internalName}, .{.name = "${externalName}"});` + `@export(${typeName}.${internalName}, .{.name = "${externalName}"});`, ) .join("\n ")} } @@ -1495,21 +1496,21 @@ ${[...exports] function generateLazyClassStructureHeader( typeName, - { klass = {}, proto = {} } + { klass = {}, proto = {} }, ) { return ` JSC::Structure* ${className( - typeName + typeName, )}Structure() { return m_${className( - typeName + typeName, )}.getInitializedOnMainThread(this); } JSC::JSObject* ${className( - typeName + typeName, )}Constructor() { return m_${className( - typeName + typeName, )}.constructorInitializedOnMainThread(this); } JSC::JSValue ${className(typeName)}Prototype() { return m_${className( - typeName + typeName, )}.prototypeInitializedOnMainThread(this); } JSC::LazyClassStructure m_${className(typeName)}; bool has${className(typeName)}SetterValue { false }; @@ -1520,7 +1521,7 @@ function generateLazyClassStructureHeader( function generateLazyStructureHeader(typeName, { klass = {}, proto = {} }) { return ` JSC::Structure* ${className( - typeName + typeName, )}Structure() { return m_${className(typeName)}.get(this); } JSC::LazyProperty m_${className(typeName)}; bool has${className(typeName)}SetterValue { false }; @@ -1533,10 +1534,10 @@ function generateLazyStructureImpl(typeName, { klass = {}, proto = {} }) { m_${className(typeName)}.initLater( [](const JSC::LazyProperty::Initializer& init) { auto *prototype = WebCore::${className( - typeName + typeName, )}::createPrototype(init.vm, reinterpret_cast(init.owner)); init.set(WebCore::${className( - typeName + typeName, )}::createStructure(init.vm, init.owner, prototype)); }); @@ -1548,13 +1549,13 @@ function generateLazyClassStructureImpl(typeName, { klass = {}, proto = {} }) { m_${className(typeName)}.initLater( [](LazyClassStructure::Initializer& init) { init.setPrototype(WebCore::${className( - typeName + typeName, )}::createPrototype(init.vm, reinterpret_cast(init.global))); init.setStructure(WebCore::${className( - typeName + typeName, )}::createStructure(init.vm, init.global, init.prototype)); init.setConstructor(WebCore::${className( - typeName + typeName, )}::createConstructor(init.vm, init.global, init.prototype)); }); @@ -1645,10 +1646,10 @@ void GlobalObject::visitGeneratedLazyClasses(GlobalObject *thisObject, Visitor& .map( (a) => `thisObject->m_${className( - a.name + a.name, )}.visit(visitor); visitor.append(thisObject->m_${className( - a.name - )}SetterValue);` + a.name, + )}SetterValue);`, ) .join("\n ")} } @@ -1725,9 +1726,9 @@ await writeAndUnlink( .map((a) => !a.noConstructor ? generateLazyClassStructureHeader(a.name, a) - : generateLazyStructureHeader(a.name, a) + : generateLazyStructureHeader(a.name, a), ) - .join("\n") + .join("\n"), ); await writeAndUnlink( @@ -1737,11 +1738,11 @@ await writeAndUnlink( `std::unique_ptr ${clientSubspaceFor(a.name)};`, !a.noConstructor ? `std::unique_ptr ${clientSubspaceFor( - a.name + a.name, )}Constructor;` : "", - ].join("\n") - ) + ].join("\n"), + ), ); await writeAndUnlink( @@ -1752,8 +1753,8 @@ await writeAndUnlink( !a.noConstructor ? `std::unique_ptr ${subspaceFor(a.name)}Constructor;` : ``, - ].join("\n") - ) + ].join("\n"), + ), ); await writeAndUnlink( @@ -1762,11 +1763,11 @@ await writeAndUnlink( classes.map((a) => !a.noConstructor ? generateLazyClassStructureImpl(a.name, a) - : generateLazyStructureImpl(a.name, a) - ) + : generateLazyStructureImpl(a.name, a), + ), ) + "\n" + - visitLazyClasses(classes) + visitLazyClasses(classes), ); export {}; diff --git a/src/bun.js/scripts/generate-jssink.js b/src/bun.js/scripts/generate-jssink.js index 65fc864fb9..0e9d3bb504 100644 --- a/src/bun.js/scripts/generate-jssink.js +++ b/src/bun.js/scripts/generate-jssink.js @@ -481,19 +481,19 @@ JSC_DEFINE_HOST_FUNCTION(${name}__doClose, (JSC::JSGlobalObject * lexicalGlobalO /* Source for JS${name}PrototypeTableValues.lut.h @begin JS${name}PrototypeTable close ${`${name}__doClose`.padEnd( - padding + 8 + padding + 8, )} ReadOnly|DontDelete|Function 0 flush ${`${name}__flush`.padEnd( - padding + 8 + padding + 8, )} ReadOnly|DontDelete|Function 1 end ${`${name}__end`.padEnd( - padding + 8 + padding + 8, )} ReadOnly|DontDelete|Function 0 start ${`${name}__start`.padEnd( - padding + 8 + padding + 8, )} ReadOnly|DontDelete|Function 1 write ${`${name}__write`.padEnd( - padding + 8 + padding + 8, )} ReadOnly|DontDelete|Function 1 @end */ @@ -502,19 +502,19 @@ JSC_DEFINE_HOST_FUNCTION(${name}__doClose, (JSC::JSGlobalObject * lexicalGlobalO /* Source for ${controllerPrototypeName}TableValues.lut.h @begin ${controllerPrototypeName}Table close ${`${controller}__close`.padEnd( - protopad + 4 + protopad + 4, )} ReadOnly|DontDelete|Function 0 flush ${`${name}__flush`.padEnd( - protopad + 4 + protopad + 4, )} ReadOnly|DontDelete|Function 1 end ${`${controller}__end`.padEnd( - protopad + 4 + protopad + 4, )} ReadOnly|DontDelete|Function 0 start ${`${name}__start`.padEnd( - protopad + 4 + protopad + 4, )} ReadOnly|DontDelete|Function 1 write ${`${name}__write`.padEnd( - protopad + 4 + protopad + 4, )} ReadOnly|DontDelete|Function 1 @end */ @@ -950,5 +950,5 @@ extern "C" void ${name}__onClose(JSC__JSValue controllerValue, JSC__JSValue reas await Bun.write(resolve(import.meta.dir + "/../bindings/JSSink.h"), header()); await Bun.write( resolve(import.meta.dir + "/../bindings/JSSink.cpp"), - await implementation() + await implementation(), ); diff --git a/src/bun.js/streams.exports.js b/src/bun.js/streams.exports.js index a7a37b107d..24e34447dd 100644 --- a/src/bun.js/streams.exports.js +++ b/src/bun.js/streams.exports.js @@ -94,13 +94,13 @@ var ArrayIsArray = Array.isArray; function ERR_INVALID_ARG_TYPE(name, type, value) { return new Error( - `The argument '${name}' is invalid. Received '${value}' for type '${type}'` + `The argument '${name}' is invalid. Received '${value}' for type '${type}'`, ); } function ERR_INVALID_ARG_VALUE(name, value, reason) { return new Error( - `The value '${value}' is invalid for argument '${name}'. Reason: ${reason}` + `The value '${value}' is invalid for argument '${name}'. Reason: ${reason}`, ); } @@ -220,7 +220,7 @@ var require_util = __commonJS({ constructor(errors) { if (!Array.isArray(errors)) { throw new TypeError( - `Expected input to be an Array, got ${typeof errors}` + `Expected input to be an Array, got ${typeof errors}`, ); } let message = ""; @@ -327,7 +327,7 @@ var require_util = __commonJS({ isBlob, }; module.exports.promisify.custom = Symbol.for( - "nodejs.util.promisify.custom" + "nodejs.util.promisify.custom", ); }, }); @@ -375,14 +375,14 @@ var require_errors = __commonJS({ if (typeof msg === "function") { assert( msg.length <= args.length, - `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).` + `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`, ); return msg(...args); } const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length; assert( expectedLength === args.length, - `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).` + `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`, ); if (args.length === 0) { return msg; @@ -436,7 +436,7 @@ var require_errors = __commonJS({ } const err = new AggregateError( [outerError, innerError], - outerError.message + outerError.message, ); err.code = outerError.code; return err; @@ -474,7 +474,7 @@ var require_errors = __commonJS({ for (const value of expected) { assert( typeof value === "string", - "All expected entries have to be of type string" + "All expected entries have to be of type string", ); if (kTypes.includes(value)) { types.push(value.toLowerCase()); @@ -483,7 +483,7 @@ var require_errors = __commonJS({ } else { assert( value !== "object", - 'The value "object" should be written as "Object"' + 'The value "object" should be written as "Object"', ); other.push(value); } @@ -575,7 +575,7 @@ var require_errors = __commonJS({ } return msg; }, - TypeError + TypeError, ); E( "ERR_INVALID_ARG_VALUE", @@ -587,7 +587,7 @@ var require_errors = __commonJS({ const type = name.includes(".") ? "property" : "argument"; return `The ${type} '${name}' ${reason}. Received ${inspected}`; }, - TypeError + TypeError, ); E( "ERR_INVALID_RETURN_VALUE", @@ -603,7 +603,7 @@ var require_errors = __commonJS({ : `type ${typeof value}`; return `Expected ${input} to be returned from the "${name}" function but got ${type}.`; }, - TypeError + TypeError, ); E( "ERR_MISSING_ARGS", @@ -630,7 +630,7 @@ var require_errors = __commonJS({ } return `${msg} must be specified`; }, - TypeError + TypeError, ); E( "ERR_OUT_OF_RANGE", @@ -650,32 +650,32 @@ var require_errors = __commonJS({ } return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`; }, - RangeError + RangeError, ); E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times", Error); E("ERR_METHOD_NOT_IMPLEMENTED", "The %s method is not implemented", Error); E( "ERR_STREAM_ALREADY_FINISHED", "Cannot call %s after a stream was finished", - Error + Error, ); E("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable", Error); E( "ERR_STREAM_DESTROYED", "Cannot call %s after a stream was destroyed", - Error + Error, ); E( "ERR_STREAM_NULL_VALUES", "May not write null values to stream", - TypeError + TypeError, ); E("ERR_STREAM_PREMATURE_CLOSE", "Premature close", Error); E("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF", Error); E( "ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event", - Error + Error, ); E("ERR_STREAM_WRITE_AFTER_END", "write after end", Error); E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError); @@ -745,7 +745,7 @@ var require_validators = __commonJS({ value, name, min = NumberMIN_SAFE_INTEGER, - max = NumberMAX_SAFE_INTEGER + max = NumberMAX_SAFE_INTEGER, ) => { if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value); @@ -753,7 +753,7 @@ var require_validators = __commonJS({ throw new ERR_OUT_OF_RANGE(name, "an integer", value); if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value); - } + }, ); var validateInt32 = hideStackFrames( (value, name, min = -2147483648, max = 2147483647) => { @@ -769,7 +769,7 @@ var require_validators = __commonJS({ if (value < min || value > max) { throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value); } - } + }, ); var validateUint32 = hideStackFrames((value, name, positive) => { if (typeof value !== "number") { @@ -798,9 +798,9 @@ var require_validators = __commonJS({ if (!ArrayPrototypeIncludes(oneOf, value)) { const allowed = ArrayPrototypeJoin( ArrayPrototypeMap(oneOf, (v) => - typeof v === "string" ? `'${v}'` : String2(v) + typeof v === "string" ? `'${v}'` : String2(v), ), - ", " + ", ", ); const reason = "must be one of: " + allowed; throw new ERR_INVALID_ARG_VALUE(name, value, reason); @@ -838,7 +838,7 @@ var require_validators = __commonJS({ if (signals[signal] === void 0) { if (signals[StringPrototypeToUpperCase(signal)] !== void 0) { throw new ERR_UNKNOWN_SIGNAL( - signal + " (signals must use all capital letters)" + signal + " (signals must use all capital letters)", ); } throw new ERR_UNKNOWN_SIGNAL(signal); @@ -849,7 +849,7 @@ var require_validators = __commonJS({ throw new ERR_INVALID_ARG_TYPE( name, ["Buffer", "TypedArray", "DataView"], - buffer + buffer, ); } }); @@ -860,7 +860,7 @@ var require_validators = __commonJS({ throw new ERR_INVALID_ARG_VALUE( "encoding", encoding, - `is invalid for data of length ${length}` + `is invalid for data of length ${length}`, ); } } @@ -927,7 +927,7 @@ var require_validators = __commonJS({ var require_utils = __commonJS({ "node_modules/readable-stream/lib/internal/streams/utils.js"( exports, - module + module, ) { "use strict"; var { @@ -1304,7 +1304,7 @@ var require_utils = __commonJS({ var require_end_of_stream = __commonJS({ "node_modules/readable-stream/lib/internal/streams/end-of-stream.js"( exports, - module + module, ) { "use strict"; var { AbortError, codes } = require_errors(); @@ -1489,7 +1489,7 @@ var require_end_of_stream = __commonJS({ stream, new AbortError(void 0, { cause: options.signal.reason, - }) + }), ); }; if (options.signal.aborted) { @@ -1525,7 +1525,7 @@ var require_end_of_stream = __commonJS({ var require_operators = __commonJS({ "node_modules/readable-stream/lib/internal/streams/operators.js"( exports, - module + module, ) { "use strict"; var AbortController = @@ -1738,7 +1738,7 @@ var require_operators = __commonJS({ async (...args) => { return !(await fn(...args)); }, - options + options, )); } async function find(fn, options) { @@ -1781,7 +1781,7 @@ var require_operators = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "reducer", ["Function", "AsyncFunction"], - reducer + reducer, ); } if (options != null) { @@ -1997,7 +1997,7 @@ var require_operators = __commonJS({ var require_destroy = __commonJS({ "node_modules/readable-stream/lib/internal/streams/destroy.js"( exports, - module + module, ) { "use strict"; var { @@ -2183,7 +2183,7 @@ var require_destroy = __commonJS({ if (called) { errorOrDestroy( stream, - err !== null && err !== void 0 ? err : new ERR_MULTIPLE_CALLBACK() + err !== null && err !== void 0 ? err : new ERR_MULTIPLE_CALLBACK(), ); return; } @@ -2265,7 +2265,7 @@ var require_destroy = __commonJS({ var require_legacy = __commonJS({ "node_modules/readable-stream/lib/internal/streams/legacy.js"( exports, - module + module, ) { "use strict"; var { ArrayIsArray, ObjectSetPrototypeOf } = require_primordials(); @@ -2349,7 +2349,7 @@ var require_legacy = __commonJS({ var require_add_abort_signal = __commonJS({ "node_modules/readable-stream/lib/internal/streams/add-abort-signal.js"( exports, - module + module, ) { "use strict"; var { AbortError, codes } = require_errors(); @@ -2378,7 +2378,7 @@ var require_add_abort_signal = __commonJS({ stream.destroy( new AbortError(void 0, { cause: signal.reason, - }) + }), ); }; if (signal.aborted) { @@ -2396,7 +2396,7 @@ var require_add_abort_signal = __commonJS({ var require_state = __commonJS({ "node_modules/readable-stream/lib/internal/streams/state.js"( exports, - module + module, ) { "use strict"; var { MathFloor, NumberIsInteger } = require_primordials(); @@ -2477,7 +2477,7 @@ var require_from = __commonJS({ PromisePrototypeThen( close(error), () => runOnNextTick(cb, error), - (e) => runOnNextTick(cb, e || error) + (e) => runOnNextTick(cb, e || error), ); }; async function close(error) { @@ -2531,7 +2531,7 @@ var require_from = __commonJS({ var require_readable = __commonJS({ "node_modules/readable-stream/lib/internal/streams/readable.js"( exports, - module + module, ) { "use strict"; var { @@ -2648,7 +2648,7 @@ var require_readable = __commonJS({ if (!value) throw new Error( - `Invalid value from ReadableStream reader: ${value}` + `Invalid value from ReadableStream reader: ${value}`, ); if (ArrayIsArray(value)) { this.push(...value); @@ -2698,7 +2698,7 @@ var require_readable = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "readableStream", "ReadableStream", - readableStream + readableStream, ); } @@ -2783,7 +2783,7 @@ var require_readable = __commonJS({ err = new ERR_INVALID_ARG_TYPE( "chunk", ["string", "Buffer", "Uint8Array"], - chunk + chunk, ); } } @@ -3043,7 +3043,7 @@ var require_readable = __commonJS({ if (!state.multiAwaitDrain) { state.multiAwaitDrain = true; state.awaitDrainWriters = new SafeSet( - state.awaitDrainWriters ? [state.awaitDrainWriters] : [] + state.awaitDrainWriters ? [state.awaitDrainWriters] : [], ); } } @@ -3325,7 +3325,7 @@ var require_readable = __commonJS({ error = err ? aggregateTwoErrors(error, err) : null; callback(); callback = nop; - } + }, ); try { while (true) { @@ -3530,12 +3530,12 @@ var require_readable = __commonJS({ Readable.fromWeb = function (readableStream, options) { return lazyWebStreams().newStreamReadableFromReadableStream( readableStream, - options + options, ); }; Readable.toWeb = function (streamReadable) { return lazyWebStreams().newReadableStreamFromStreamReadable( - streamReadable + streamReadable, ); }; Readable.wrap = function (src, options) { @@ -3563,7 +3563,7 @@ var require_readable = __commonJS({ var require_writable = __commonJS({ "node_modules/readable-stream/lib/internal/streams/writable.js"( exports, - module + module, ) { "use strict"; var { @@ -3721,7 +3721,7 @@ var require_writable = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "chunk", ["string", "Buffer", "Uint8Array"], - chunk + chunk, ); } } @@ -3753,7 +3753,7 @@ var require_writable = __commonJS({ } }; Writable.prototype.setDefaultEncoding = function setDefaultEncoding( - encoding + encoding, ) { if (typeof encoding === "string") encoding = StringPrototypeToLowerCase(encoding); @@ -3894,7 +3894,7 @@ var require_writable = __commonJS({ callback( (_state$errored = state.errored) !== null && _state$errored !== void 0 ? _state$errored - : new ERR_STREAM_DESTROYED("write") + : new ERR_STREAM_DESTROYED("write"), ); } const onfinishCallbacks = state[kOnFinished].splice(0); @@ -3904,7 +3904,7 @@ var require_writable = __commonJS({ (_state$errored2 = state.errored) !== null && _state$errored2 !== void 0 ? _state$errored2 - : new ERR_STREAM_DESTROYED("end") + : new ERR_STREAM_DESTROYED("end"), ); } resetBuffer(state); @@ -3968,7 +3968,7 @@ var require_writable = __commonJS({ encoding, }, ], - cb + cb, ); } else { throw new ERR_METHOD_NOT_IMPLEMENTED("_write()"); @@ -4035,7 +4035,7 @@ var require_writable = __commonJS({ if (called) { errorOrDestroy( stream, - err !== null && err !== void 0 ? err : ERR_MULTIPLE_CALLBACK() + err !== null && err !== void 0 ? err : ERR_MULTIPLE_CALLBACK(), ); return; } @@ -4089,7 +4089,7 @@ var require_writable = __commonJS({ } }, stream, - state + state, ); } else if (needFinish(state)) { state.pendingcb++; @@ -4238,12 +4238,12 @@ var require_writable = __commonJS({ Writable.fromWeb = function (writableStream, options) { return lazyWebStreams().newStreamWritableFromWritableStream( writableStream, - options + options, ); }; Writable.toWeb = function (streamWritable) { return lazyWebStreams().newWritableStreamFromStreamWritable( - streamWritable + streamWritable, ); }; }, @@ -4253,7 +4253,7 @@ var require_writable = __commonJS({ var require_duplexify = __commonJS({ "node_modules/readable-stream/lib/internal/streams/duplexify.js"( exports, - module + module, ) { "use strict"; var bufferModule = __require("buffer"); @@ -4356,7 +4356,7 @@ var require_duplexify = __commonJS({ }, (err) => { destroyer(d, err); - } + }, ); return (d = new Duplexify({ objectMode: true, @@ -4378,7 +4378,7 @@ var require_duplexify = __commonJS({ throw new ERR_INVALID_RETURN_VALUE( "Iterable, AsyncIterable or AsyncFunction", name, - value + value, ); } if (isBlob(body)) { @@ -4399,7 +4399,7 @@ var require_duplexify = __commonJS({ const readable = body !== null && body !== void 0 && body.readable ? isReadableNodeStream( - body === null || body === void 0 ? void 0 : body.readable + body === null || body === void 0 ? void 0 : body.readable, ) ? body === null || body === void 0 ? void 0 @@ -4409,7 +4409,7 @@ var require_duplexify = __commonJS({ const writable = body !== null && body !== void 0 && body.writable ? isWritableNodeStream( - body === null || body === void 0 ? void 0 : body.writable + body === null || body === void 0 ? void 0 : body.writable, ) ? body === null || body === void 0 ? void 0 @@ -4435,7 +4435,7 @@ var require_duplexify = __commonJS({ }, (err) => { destroyer(d, err); - } + }, ); return (d = new Duplexify({ objectMode: true, @@ -4456,7 +4456,7 @@ var require_duplexify = __commonJS({ "{ readable, writable } pair", "Promise", ], - body + body, ); }; function fromAsyncGen(fn) { @@ -4481,7 +4481,7 @@ var require_duplexify = __commonJS({ })(), { signal, - } + }, ); return { value, @@ -4635,7 +4635,7 @@ var require_duplexify = __commonJS({ var require_duplex = __commonJS({ "node_modules/readable-stream/lib/internal/streams/duplex.js"( exports, - module + module, ) { "use strict"; var { @@ -4686,35 +4686,35 @@ var require_duplex = __commonJS({ writable: ObjectGetOwnPropertyDescriptor(Writable.prototype, "writable"), writableHighWaterMark: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableHighWaterMark" + "writableHighWaterMark", ), writableObjectMode: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableObjectMode" + "writableObjectMode", ), writableBuffer: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableBuffer" + "writableBuffer", ), writableLength: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableLength" + "writableLength", ), writableFinished: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableFinished" + "writableFinished", ), writableCorked: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableCorked" + "writableCorked", ), writableEnded: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableEnded" + "writableEnded", ), writableNeedDrain: ObjectGetOwnPropertyDescriptor( Writable.prototype, - "writableNeedDrain" + "writableNeedDrain", ), destroyed: { get() { @@ -4742,7 +4742,7 @@ var require_duplex = __commonJS({ Duplex.fromWeb = function (pair, options) { return lazyWebStreams().newStreamDuplexFromReadableWritablePair( pair, - options + options, ); }; Duplex.toWeb = function (duplex) { @@ -4762,7 +4762,7 @@ var require_duplex = __commonJS({ var require_transform = __commonJS({ "node_modules/readable-stream/lib/internal/streams/transform.js"( exports, - module + module, ) { "use strict"; var { ObjectSetPrototypeOf, Symbol: Symbol2 } = require_primordials(); @@ -4857,7 +4857,7 @@ var require_transform = __commonJS({ var require_passthrough = __commonJS({ "node_modules/readable-stream/lib/internal/streams/passthrough.js"( exports, - module + module, ) { "use strict"; var Transform = require_transform(); @@ -4881,7 +4881,7 @@ var require_passthrough = __commonJS({ var require_pipeline = __commonJS({ "node_modules/readable-stream/lib/internal/streams/pipeline.js"( exports, - module + module, ) { "use strict"; var { @@ -4924,7 +4924,7 @@ var require_pipeline = __commonJS({ }, (err) => { finished = !err; - } + }, ); return { destroy: (err) => { @@ -4932,7 +4932,7 @@ var require_pipeline = __commonJS({ finished = true; destroyImpl.destroyer( stream, - err || new ERR_STREAM_DESTROYED("pipe") + err || new ERR_STREAM_DESTROYED("pipe"), ); }, cleanup, @@ -4941,7 +4941,7 @@ var require_pipeline = __commonJS({ function popCallback(streams) { validateFunction( streams[streams.length - 1], - "streams[stream.length - 1]" + "streams[stream.length - 1]", ); return streams.pop(); } @@ -4954,7 +4954,7 @@ var require_pipeline = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "val", ["Readable", "Iterable", "AsyncIterable"], - val + val, ); } async function* fromReadable(val) { @@ -4996,7 +4996,7 @@ var require_pipeline = __commonJS({ { readable: false, }, - resume + resume, ); try { if (writable.writableNeedDrain) { @@ -5111,7 +5111,7 @@ var require_pipeline = __commonJS({ throw new ERR_INVALID_RETURN_VALUE( "Iterable, AsyncIterable or Stream", "source", - ret + ret, ); } } else if (isIterable(stream) || isReadableNodeStream(stream)) { @@ -5129,7 +5129,7 @@ var require_pipeline = __commonJS({ throw new ERR_INVALID_RETURN_VALUE( "AsyncIterable", `transform[${i - 1}]`, - ret + ret, ); } } else { @@ -5159,7 +5159,7 @@ var require_pipeline = __commonJS({ (err) => { pt.destroy(err); runOnNextTick(finish, err); - } + }, ); } else if (isIterable(ret, true)) { finishCount++; @@ -5170,7 +5170,7 @@ var require_pipeline = __commonJS({ throw new ERR_INVALID_RETURN_VALUE( "AsyncIterable or Promise", "destination", - ret + ret, ); } ret = pt; @@ -5198,7 +5198,7 @@ var require_pipeline = __commonJS({ throw new ERR_INVALID_ARG_TYPE( "val", ["Readable", "Iterable", "AsyncIterable"], - ret + ret, ); } ret = stream; @@ -5243,7 +5243,7 @@ var require_pipeline = __commonJS({ } else { finish(err); } - } + }, ); return eos( dst, @@ -5251,7 +5251,7 @@ var require_pipeline = __commonJS({ readable: false, writable: true, }, - finish + finish, ); } module.exports = { @@ -5265,7 +5265,7 @@ var require_pipeline = __commonJS({ var require_compose = __commonJS({ "node_modules/readable-stream/lib/internal/streams/compose.js"( exports, - module + module, ) { "use strict"; var { pipeline } = require_pipeline(); @@ -5299,14 +5299,14 @@ var require_compose = __commonJS({ throw new ERR_INVALID_ARG_VALUE( `streams[${n}]`, orgStreams[n], - "must be readable" + "must be readable", ); } if (n > 0 && !isWritable(streams[n])) { throw new ERR_INVALID_ARG_VALUE( `streams[${n}]`, orgStreams[n], - "must be writable" + "must be writable", ); } } @@ -5449,7 +5449,7 @@ var require_promises = __commonJS({ { signal, end, - } + }, ); }); } diff --git a/src/bun.js/url.exports.js b/src/bun.js/url.exports.js index a59b6de08e..f1478e2124 100644 --- a/src/bun.js/url.exports.js +++ b/src/bun.js/url.exports.js @@ -1,2 +1,452 @@ -"use strict";const{URL:F,URLSearchParams:M,[Symbol.for("Bun.lazy")]:S}=globalThis;function it(s){return typeof s=="string"}function D(s){return typeof s=="object"&&s!==null}function I(s){return s===null}function E(s){return s==null}function ft(s){return s===void 0}function m(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}var tt=/^([a-z0-9.+-]+:)/i,st=/:[0-9]*$/,ht=/^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,et=["<",">",'"',"`"," ","\r",` -`," "],rt=["{","}","|","\\","^","`"].concat(et),B=["'"].concat(rt),G=["%","/","?",";","#"].concat(B),J=["/","?","#"],ot=255,K=/^[+a-z0-9A-Z_-]{0,63}$/,at=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,nt={javascript:!0,"javascript:":!0},N={javascript:!0,"javascript:":!0},R={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},Z={parse(s){var r=decodeURIComponent;return(s+"").replace(/\+/g," ").split("&").filter(Boolean).reduce(function(t,o,a){var l=o.split("="),f=r(l[0]||""),h=r(l[1]||""),g=t[f];return t[f]=g===void 0?h:[].concat(g,h),t},{})},stringify(s){var r=encodeURIComponent;return Object.keys(s||{}).reduce(function(t,o){return[].concat(s[o]).forEach(function(a){t.push(r(o)+"="+r(a))}),t},[]).join("&").replace(/\s/g,"+")}};function A(s,r,t){if(s&&D(s)&&s instanceof m)return s;var o=new m;return o.parse(s,r,t),o}m.prototype.parse=function(s,r,t){if(!it(s))throw new TypeError("Parameter 'url' must be a string, not "+typeof s);var o=s.indexOf("?"),a=o!==-1&&o127?y+="x":y+=d[x];if(!y.match(K)){var q=e.slice(0,n),O=e.slice(n+1),U=d.match(at);U&&(q.push(U[1]),O.unshift(U[2])),O.length&&(h="/"+O.join(".")+h),this.hostname=q.join(".");break}}}this.hostname.length>ot?this.hostname="":this.hostname=this.hostname.toLowerCase(),C||(this.hostname=new F(`https://${this.hostname}`).hostname);var w=this.port?":"+this.port:"",H=this.hostname||"";this.host=H+w,this.href+=this.host,C&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),h[0]!=="/"&&(h="/"+h))}if(!nt[v])for(var n=0,i=B.length;n0?t.host.split("@"):!1;y&&(t.auth=y.shift(),t.host=t.hostname=y.shift())}return t.search=s.search,t.query=s.query,(!I(t.pathname)||!I(t.search))&&(t.path=(t.pathname?t.pathname:"")+(t.search?t.search:"")),t.href=t.format(),t}if(!e.length)return t.pathname=null,t.search?t.path="/"+t.search:t.path=null,t.href=t.format(),t;for(var x=e.slice(-1)[0],_=(t.host||s.host||e.length>1)&&(x==="."||x==="..")||x==="",q=0,O=e.length;O>=0;O--)x=e[O],x==="."?e.splice(O,1):x===".."?(e.splice(O,1),q++):q&&(e.splice(O,1),q--);if(!p&&!C)for(;q--;q)e.unshift("..");p&&e[0]!==""&&(!e[0]||e[0].charAt(0)!=="/")&&e.unshift(""),_&&e.join("/").substr(-1)!=="/"&&e.push("");var U=e[0]===""||e[0]&&e[0].charAt(0)==="/";if(d){t.hostname=t.host=U?"":e.length?e.shift():"";var y=t.host&&t.host.indexOf("@")>0?t.host.split("@"):!1;y&&(t.auth=y.shift(),t.host=t.hostname=y.shift())}return p=p||t.host&&e.length,p&&!U&&e.unshift(""),e.length?t.pathname=e.join("/"):(t.pathname=null,t.path=null),(!I(t.pathname)||!I(t.search))&&(t.path=(t.pathname?t.pathname:"")+(t.search?t.search:"")),t.auth=s.auth||t.auth,t.slashes=t.slashes||s.slashes,t.href=t.format(),t},m.prototype.parseHost=function(){var s=this.host,r=st.exec(s);r&&(r=r[0],r!==":"&&(this.port=r.substr(1)),s=s.substr(0,s.length-r.length)),s&&(this.hostname=s)};var Y,k;S&&(Y=S("pathToFileURL"),k=S("fileURLToPath"));var ut={parse:A,resolve:W,resolveObject:X,format:V,Url:m,pathToFileURL:Y,fileURLToPath:k,URL:F,URLSearchParams:M};"use strict";export{F as URL,M as URLSearchParams,m as Url,ut as default,k as fileURLToPath,V as format,A as parse,Y as pathToFileURL,W as resolve,X as resolveObject}; +"use strict"; +const { URL: F, URLSearchParams: M, [Symbol.for("Bun.lazy")]: S } = globalThis; +function it(s) { + return typeof s == "string"; +} +function D(s) { + return typeof s == "object" && s !== null; +} +function I(s) { + return s === null; +} +function E(s) { + return s == null; +} +function ft(s) { + return s === void 0; +} +function m() { + (this.protocol = null), + (this.slashes = null), + (this.auth = null), + (this.host = null), + (this.port = null), + (this.hostname = null), + (this.hash = null), + (this.search = null), + (this.query = null), + (this.pathname = null), + (this.path = null), + (this.href = null); +} +var tt = /^([a-z0-9.+-]+:)/i, + st = /:[0-9]*$/, + ht = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/, + et = [ + "<", + ">", + '"', + "`", + " ", + "\r", + ` +`, + " ", + ], + rt = ["{", "}", "|", "\\", "^", "`"].concat(et), + B = ["'"].concat(rt), + G = ["%", "/", "?", ";", "#"].concat(B), + J = ["/", "?", "#"], + ot = 255, + K = /^[+a-z0-9A-Z_-]{0,63}$/, + at = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, + nt = { javascript: !0, "javascript:": !0 }, + N = { javascript: !0, "javascript:": !0 }, + R = { + http: !0, + https: !0, + ftp: !0, + gopher: !0, + file: !0, + "http:": !0, + "https:": !0, + "ftp:": !0, + "gopher:": !0, + "file:": !0, + }, + Z = { + parse(s) { + var r = decodeURIComponent; + return (s + "") + .replace(/\+/g, " ") + .split("&") + .filter(Boolean) + .reduce(function (t, o, a) { + var l = o.split("="), + f = r(l[0] || ""), + h = r(l[1] || ""), + g = t[f]; + return (t[f] = g === void 0 ? h : [].concat(g, h)), t; + }, {}); + }, + stringify(s) { + var r = encodeURIComponent; + return Object.keys(s || {}) + .reduce(function (t, o) { + return ( + [].concat(s[o]).forEach(function (a) { + t.push(r(o) + "=" + r(a)); + }), + t + ); + }, []) + .join("&") + .replace(/\s/g, "+"); + }, + }; +function A(s, r, t) { + if (s && D(s) && s instanceof m) return s; + var o = new m(); + return o.parse(s, r, t), o; +} +m.prototype.parse = function (s, r, t) { + if (!it(s)) + throw new TypeError("Parameter 'url' must be a string, not " + typeof s); + var o = s.indexOf("?"), + a = o !== -1 && o < s.indexOf("#") ? "?" : "#", + l = s.split(a), + f = /\\/g; + (l[0] = l[0].replace(f, "/")), (s = l.join(a)); + var h = s; + if (((h = h.trim()), !t && s.split("#").length === 1)) { + var g = ht.exec(h); + if (g) + return ( + (this.path = h), + (this.href = h), + (this.pathname = g[1]), + g[2] + ? ((this.search = g[2]), + r + ? (this.query = Z.parse(this.search.substr(1))) + : (this.query = this.search.substr(1))) + : r && ((this.search = ""), (this.query = {})), + this + ); + } + var c = tt.exec(h); + if (c) { + c = c[0]; + var v = c.toLowerCase(); + (this.protocol = v), (h = h.substr(c.length)); + } + if (t || c || h.match(/^\/\/[^@\/]+@[^@\/]+/)) { + var j = h.substr(0, 2) === "//"; + j && !(c && N[c]) && ((h = h.substr(2)), (this.slashes = !0)); + } + if (!N[c] && (j || (c && !R[c]))) { + for (var u = -1, n = 0; n < J.length; n++) { + var b = h.indexOf(J[n]); + b !== -1 && (u === -1 || b < u) && (u = b); + } + var P, p; + u === -1 ? (p = h.lastIndexOf("@")) : (p = h.lastIndexOf("@", u)), + p !== -1 && + ((P = h.slice(0, p)), + (h = h.slice(p + 1)), + (this.auth = decodeURIComponent(P))), + (u = -1); + for (var n = 0; n < G.length; n++) { + var b = h.indexOf(G[n]); + b !== -1 && (u === -1 || b < u) && (u = b); + } + u === -1 && (u = h.length), + (this.host = h.slice(0, u)), + (h = h.slice(u)), + this.parseHost(), + (this.hostname = this.hostname || ""); + var C = + this.hostname[0] === "[" && + this.hostname[this.hostname.length - 1] === "]"; + if (!C) + for (var e = this.hostname.split(/\./), n = 0, i = e.length; n < i; n++) { + var d = e[n]; + if (!!d && !d.match(K)) { + for (var y = "", x = 0, _ = d.length; x < _; x++) + d.charCodeAt(x) > 127 ? (y += "x") : (y += d[x]); + if (!y.match(K)) { + var q = e.slice(0, n), + O = e.slice(n + 1), + U = d.match(at); + U && (q.push(U[1]), O.unshift(U[2])), + O.length && (h = "/" + O.join(".") + h), + (this.hostname = q.join(".")); + break; + } + } + } + this.hostname.length > ot + ? (this.hostname = "") + : (this.hostname = this.hostname.toLowerCase()), + C || (this.hostname = new F(`https://${this.hostname}`).hostname); + var w = this.port ? ":" + this.port : "", + H = this.hostname || ""; + (this.host = H + w), + (this.href += this.host), + C && + ((this.hostname = this.hostname.substr(1, this.hostname.length - 2)), + h[0] !== "/" && (h = "/" + h)); + } + if (!nt[v]) + for (var n = 0, i = B.length; n < i; n++) { + var L = B[n]; + if (h.indexOf(L) !== -1) { + var z = encodeURIComponent(L); + z === L && (z = escape(L)), (h = h.split(L).join(z)); + } + } + var $ = h.indexOf("#"); + $ !== -1 && ((this.hash = h.substr($)), (h = h.slice(0, $))); + var T = h.indexOf("?"); + if ( + (T !== -1 + ? ((this.search = h.substr(T)), + (this.query = h.substr(T + 1)), + r && (this.query = Z.parse(this.query)), + (h = h.slice(0, T))) + : r && ((this.search = ""), (this.query = {})), + h && (this.pathname = h), + R[v] && this.hostname && !this.pathname && (this.pathname = "/"), + this.pathname || this.search) + ) { + var w = this.pathname || "", + Q = this.search || ""; + this.path = w + Q; + } + return (this.href = this.format()), this; +}; +function V(s) { + return ( + it(s) && (s = A(s)), + s instanceof m ? s.format() : m.prototype.format.call(s) + ); +} +m.prototype.format = function () { + var s = this.auth || ""; + s && ((s = encodeURIComponent(s)), (s = s.replace(/%3A/i, ":")), (s += "@")); + var r = this.protocol || "", + t = this.pathname || "", + o = this.hash || "", + a = !1, + l = ""; + this.host + ? (a = s + this.host) + : this.hostname && + ((a = + s + + (this.hostname.indexOf(":") === -1 + ? this.hostname + : "[" + this.hostname + "]")), + this.port && (a += ":" + this.port)), + this.query && + D(this.query) && + Object.keys(this.query).length && + (l = Z.stringify(this.query)); + var f = this.search || (l && "?" + l) || ""; + return ( + r && r.substr(-1) !== ":" && (r += ":"), + this.slashes || ((!r || R[r]) && a !== !1) + ? ((a = "//" + (a || "")), t && t.charAt(0) !== "/" && (t = "/" + t)) + : a || (a = ""), + o && o.charAt(0) !== "#" && (o = "#" + o), + f && f.charAt(0) !== "?" && (f = "?" + f), + (t = t.replace(/[?#]/g, function (h) { + return encodeURIComponent(h); + })), + (f = f.replace("#", "%23")), + r + a + t + f + o + ); +}; +function W(s, r) { + return A(s, !1, !0).resolve(r); +} +m.prototype.resolve = function (s) { + return this.resolveObject(A(s, !1, !0)).format(); +}; +function X(s, r) { + return s ? A(s, !1, !0).resolveObject(r) : r; +} +(m.prototype.resolveObject = function (s) { + if (it(s)) { + var r = new m(); + r.parse(s, !1, !0), (s = r); + } + for (var t = new m(), o = Object.keys(this), a = 0; a < o.length; a++) { + var l = o[a]; + t[l] = this[l]; + } + if (((t.hash = s.hash), s.href === "")) return (t.href = t.format()), t; + if (s.slashes && !s.protocol) { + for (var f = Object.keys(s), h = 0; h < f.length; h++) { + var g = f[h]; + g !== "protocol" && (t[g] = s[g]); + } + return ( + R[t.protocol] && t.hostname && !t.pathname && (t.path = t.pathname = "/"), + (t.href = t.format()), + t + ); + } + if (s.protocol && s.protocol !== t.protocol) { + if (!R[s.protocol]) { + for (var c = Object.keys(s), v = 0; v < c.length; v++) { + var j = c[v]; + t[j] = s[j]; + } + return (t.href = t.format()), t; + } + if (((t.protocol = s.protocol), !s.host && !N[s.protocol])) { + for ( + var i = (s.pathname || "").split("/"); + i.length && !(s.host = i.shift()); + + ); + s.host || (s.host = ""), + s.hostname || (s.hostname = ""), + i[0] !== "" && i.unshift(""), + i.length < 2 && i.unshift(""), + (t.pathname = i.join("/")); + } else t.pathname = s.pathname; + if ( + ((t.search = s.search), + (t.query = s.query), + (t.host = s.host || ""), + (t.auth = s.auth), + (t.hostname = s.hostname || s.host), + (t.port = s.port), + t.pathname || t.search) + ) { + var u = t.pathname || "", + n = t.search || ""; + t.path = u + n; + } + return (t.slashes = t.slashes || s.slashes), (t.href = t.format()), t; + } + var b = t.pathname && t.pathname.charAt(0) === "/", + P = s.host || (s.pathname && s.pathname.charAt(0) === "/"), + p = P || b || (t.host && s.pathname), + C = p, + e = (t.pathname && t.pathname.split("/")) || [], + i = (s.pathname && s.pathname.split("/")) || [], + d = t.protocol && !R[t.protocol]; + if ( + (d && + ((t.hostname = ""), + (t.port = null), + t.host && (e[0] === "" ? (e[0] = t.host) : e.unshift(t.host)), + (t.host = ""), + s.protocol && + ((s.hostname = null), + (s.port = null), + s.host && (i[0] === "" ? (i[0] = s.host) : i.unshift(s.host)), + (s.host = null)), + (p = p && (i[0] === "" || e[0] === ""))), + P) + ) + (t.host = s.host || s.host === "" ? s.host : t.host), + (t.hostname = s.hostname || s.hostname === "" ? s.hostname : t.hostname), + (t.search = s.search), + (t.query = s.query), + (e = i); + else if (i.length) + e || (e = []), + e.pop(), + (e = e.concat(i)), + (t.search = s.search), + (t.query = s.query); + else if (!E(s.search)) { + if (d) { + t.hostname = t.host = e.shift(); + var y = t.host && t.host.indexOf("@") > 0 ? t.host.split("@") : !1; + y && ((t.auth = y.shift()), (t.host = t.hostname = y.shift())); + } + return ( + (t.search = s.search), + (t.query = s.query), + (!I(t.pathname) || !I(t.search)) && + (t.path = (t.pathname ? t.pathname : "") + (t.search ? t.search : "")), + (t.href = t.format()), + t + ); + } + if (!e.length) + return ( + (t.pathname = null), + t.search ? (t.path = "/" + t.search) : (t.path = null), + (t.href = t.format()), + t + ); + for ( + var x = e.slice(-1)[0], + _ = + ((t.host || s.host || e.length > 1) && (x === "." || x === "..")) || + x === "", + q = 0, + O = e.length; + O >= 0; + O-- + ) + (x = e[O]), + x === "." + ? e.splice(O, 1) + : x === ".." + ? (e.splice(O, 1), q++) + : q && (e.splice(O, 1), q--); + if (!p && !C) for (; q--; q) e.unshift(".."); + p && e[0] !== "" && (!e[0] || e[0].charAt(0) !== "/") && e.unshift(""), + _ && e.join("/").substr(-1) !== "/" && e.push(""); + var U = e[0] === "" || (e[0] && e[0].charAt(0) === "/"); + if (d) { + t.hostname = t.host = U ? "" : e.length ? e.shift() : ""; + var y = t.host && t.host.indexOf("@") > 0 ? t.host.split("@") : !1; + y && ((t.auth = y.shift()), (t.host = t.hostname = y.shift())); + } + return ( + (p = p || (t.host && e.length)), + p && !U && e.unshift(""), + e.length + ? (t.pathname = e.join("/")) + : ((t.pathname = null), (t.path = null)), + (!I(t.pathname) || !I(t.search)) && + (t.path = (t.pathname ? t.pathname : "") + (t.search ? t.search : "")), + (t.auth = s.auth || t.auth), + (t.slashes = t.slashes || s.slashes), + (t.href = t.format()), + t + ); +}), + (m.prototype.parseHost = function () { + var s = this.host, + r = st.exec(s); + r && + ((r = r[0]), + r !== ":" && (this.port = r.substr(1)), + (s = s.substr(0, s.length - r.length))), + s && (this.hostname = s); + }); +var Y, k; +S && ((Y = S("pathToFileURL")), (k = S("fileURLToPath"))); +var ut = { + parse: A, + resolve: W, + resolveObject: X, + format: V, + Url: m, + pathToFileURL: Y, + fileURLToPath: k, + URL: F, + URLSearchParams: M, +}; +("use strict"); +export { + F as URL, + M as URLSearchParams, + m as Url, + ut as default, + k as fileURLToPath, + V as format, + A as parse, + Y as pathToFileURL, + W as resolve, + X as resolveObject, +}; diff --git a/src/bun.js/ws.exports.js b/src/bun.js/ws.exports.js index 90d3f89114..d7a79b0b75 100644 --- a/src/bun.js/ws.exports.js +++ b/src/bun.js/ws.exports.js @@ -81,7 +81,7 @@ var Receiver = (BunWebSocket.Receiver = class Receiver { }); var createWebSocketStream = (BunWebSocket.createWebSocketStream = function ( - ws + ws, ) { throw new Error("Not supported in Bun"); }); diff --git a/src/cli/tsconfig-for-init.json b/src/cli/tsconfig-for-init.json index a659f9e5bf..30522c12f4 100644 --- a/src/cli/tsconfig-for-init.json +++ b/src/cli/tsconfig-for-init.json @@ -5,15 +5,16 @@ ], "module": "esnext", "target": "esnext", - "moduleResolution": "node", + "moduleResolution": "nodenext", "strict": true, + "downlevelIteration": true, "skipLibCheck": true, + "jsx": "preserve", + "allowSyntheticDefaultImports": true, "forceConsistentCasingInFileNames": true, - // so that if your project isn't using TypeScript, it still has autocomplete "allowJs": true, - // "bun-types" is the important part "types": [ - "bun-types" + "bun-types" // add Bun global ] } } \ No newline at end of file diff --git a/src/fallback.ts b/src/fallback.ts index 103c9db1d0..964ed4e929 100644 --- a/src/fallback.ts +++ b/src/fallback.ts @@ -1,3 +1,4 @@ +declare var document: any; import { ByteBuffer } from "peechy"; import { FallbackStep } from "./api/schema"; import { @@ -7,7 +8,7 @@ import { function getFallbackInfo(): FallbackMessageContainer { const binary_string = globalThis.atob( - document.getElementById("__bunfallback").textContent.trim() + document.getElementById("__bunfallback").textContent.trim(), ); var len = binary_string.length; diff --git a/src/node-fallbacks/@vercel_fetch.js b/src/node-fallbacks/@vercel_fetch.js index 95314ba9e9..f75604b2be 100644 --- a/src/node-fallbacks/@vercel_fetch.js +++ b/src/node-fallbacks/@vercel_fetch.js @@ -1,6 +1,6 @@ // This is just a no-op. Intent is to prevent importing a bunch of stuff that isn't relevant. module.exports = ( - wrapper = "Bun" in globalThis ? Bun.fetch : globalThis.fetch + wrapper = "Bun" in globalThis ? Bun.fetch : globalThis.fetch, ) => { async function vercelFetch(url, opts = {}) { // Convert Object bodies to JSON if they are JS objects diff --git a/src/node-fallbacks/assert.js b/src/node-fallbacks/assert.js index a62319d0a4..3636f90e31 100644 --- a/src/node-fallbacks/assert.js +++ b/src/node-fallbacks/assert.js @@ -1 +1 @@ -export * from 'assert'; \ No newline at end of file +export * from "assert"; diff --git a/src/node-fallbacks/events.js b/src/node-fallbacks/events.js index e5b3d28df1..738bf1f153 100644 --- a/src/node-fallbacks/events.js +++ b/src/node-fallbacks/events.js @@ -35,7 +35,7 @@ if (R && typeof R.ownKeys === "function") { } else if (Object.getOwnPropertySymbols) { ReflectOwnKeys = function ReflectOwnKeys(target) { return Object.getOwnPropertyNames(target).concat( - Object.getOwnPropertySymbols(target) + Object.getOwnPropertySymbols(target), ); }; } else { @@ -73,7 +73,7 @@ function checkListener(listener) { if (typeof listener !== "function") { throw new TypeError( 'The "listener" argument must be of type Function. Received type ' + - typeof listener + typeof listener, ); } } @@ -88,7 +88,7 @@ Object.defineProperty(EventEmitter, "defaultMaxListeners", { throw new RangeError( 'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + - "." + ".", ); } defaultMaxListeners = arg; @@ -114,7 +114,7 @@ EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { throw new RangeError( 'The value of "n" is out of range. It must be a non-negative number. Received ' + n + - "." + ".", ); } this._maxListeners = n; @@ -150,7 +150,7 @@ EventEmitter.prototype.emit = function emit(type) { } // At least give some kind of context to the user var err = new Error( - "Unhandled error." + (er ? " (" + er.message + ")" : "") + "Unhandled error." + (er ? " (" + er.message + ")" : ""), ); err.context = er; throw err; // Unhandled 'error' event @@ -189,7 +189,7 @@ function _addListener(target, type, listener, prepend) { target.emit( "newListener", type, - listener.listener ? listener.listener : listener + listener.listener ? listener.listener : listener, ); // Re-assign `events` because a newListener handler could have caused the @@ -229,7 +229,7 @@ function _addListener(target, type, listener, prepend) { String(type) + " listeners " + "added. Use emitter.setMaxListeners() to " + - "increase limit" + "increase limit", ); w.name = "MaxListenersExceededWarning"; w.emitter = target; @@ -250,7 +250,7 @@ EventEmitter.prototype.on = EventEmitter.prototype.addListener; EventEmitter.prototype.prependListener = function prependListener( type, - listener + listener, ) { return _addListener(this, type, listener, true); }; @@ -286,7 +286,7 @@ EventEmitter.prototype.once = function once(type, listener) { EventEmitter.prototype.prependOnceListener = function prependOnceListener( type, - listener + listener, ) { checkListener(listener); this.prependListener(type, _onceWrap(this, type, listener)); @@ -296,7 +296,7 @@ EventEmitter.prototype.prependOnceListener = function prependOnceListener( // Emits a 'removeListener' event if and only if the listener was removed. EventEmitter.prototype.removeListener = function removeListener( type, - listener + listener, ) { var list, events, position, i, originalListener; @@ -511,7 +511,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) { } else { throw new TypeError( 'The "emitter" argument must be of type EventEmitter. Received type ' + - typeof emitter + typeof emitter, ); } } diff --git a/src/node-fallbacks/net.js b/src/node-fallbacks/net.js index 8f58ce1344..77afb49805 100644 --- a/src/node-fallbacks/net.js +++ b/src/node-fallbacks/net.js @@ -20,22 +20,24 @@ // USE OR OTHER DEALINGS IN THE SOFTWARE. // IPv4 Segment -const v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'; +const v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])"; const v4Str = `(${v4Seg}[.]){3}${v4Seg}`; const IPv4Reg = new RegExp(`^${v4Str}$`); // IPv6 Segment -const v6Seg = '(?:[0-9a-fA-F]{1,4})'; -const IPv6Reg = new RegExp('^(' + - `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` + - `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` + - `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` + - `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` + - `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` + - `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + - `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + - `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + -')(%[0-9a-zA-Z-.:]{1,})?$'); +const v6Seg = "(?:[0-9a-fA-F]{1,4})"; +const IPv6Reg = new RegExp( + "^(" + + `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` + + `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` + + `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` + + `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` + + `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` + + `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` + + `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` + + `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` + + ")(%[0-9a-zA-Z-.:]{1,})?$", +); export function isIPv4(s) { return IPv4Reg.test(s); @@ -55,4 +57,4 @@ export default { isIP, isIPv4, isIPv6, -} \ No newline at end of file +}; diff --git a/src/react-refresh.js b/src/react-refresh.js index 65c44002f4..d3453d5916 100644 --- a/src/react-refresh.js +++ b/src/react-refresh.js @@ -4,6 +4,345 @@ // - inlined REACT_MEMO_TYPE & REACT_FORWARD_REF_TYPE // - minified -const F="for"in Symbol?Symbol.for("react.forward_ref"):60112,C="for"in Symbol?Symbol.for("react.memo"):60115,O=typeof WeakMap=="function"?WeakMap:Map,T=new Map,k=new O,m=new O,M=new O;let g=[];const b=new Map,w=new Map,c=new Set,p=new Set,R=typeof WeakMap=="function"?new WeakMap:null;let S=!1;function _(e){if(e.fullKey!==null)return e.fullKey;let t=e.ownKey,n;try{n=e.getCustomHooks()}catch{return e.forceReset=!0,e.fullKey=t,t}for(let o=0;o{t.set(o,n)}),t}function L(e){const t=new Set;return e.forEach(n=>{t.add(n)}),t}function H(e,t){try{return e[t]}catch{return}}function j(){if(g.length===0||S)return null;S=!0;try{const e=new Set,t=new Set,n=g;g=[],n.forEach(f=>{let[i,u]=f;const a=i.current;M.set(a,i),M.set(u,i),i.current=u,v(a,u)?t.add(i):e.add(i)});const o={updatedFamilies:t,staleFamilies:e};b.forEach(f=>{f.setRefreshHandler(I)});let l=!1,s=null;const r=L(p),h=L(c),d=P(w);if(r.forEach(f=>{const i=d.get(f);if(i===void 0)throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");if(!p.has(f),R===null||!R.has(f))return;const u=R.get(f);try{i.scheduleRoot(f,u)}catch(a){l||(l=!0,s=a)}}),h.forEach(f=>{const i=d.get(f);if(i===void 0)throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");!c.has(f);try{i.scheduleRefresh(f,o)}catch(u){l||(l=!0,s=u)}}),l)throw s;return o}finally{S=!1}}function K(e,t){if(e===null||typeof e!="function"&&typeof e!="object"||k.has(e))return;let n=T.get(t);if(n===void 0?(n={current:e},T.set(t,n)):g.push([n,e]),k.set(e,n),typeof e=="object"&&e!==null)switch(H(e,"$$typeof")){case F:K(e.render,t+"$render");break;case C:K(e.type,t+"$type");break}}function E(e,t){let n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,o=arguments.length>3?arguments[3]:void 0;if(m.has(e)||m.set(e,{forceReset:n,ownKey:t,fullKey:null,getCustomHooks:o||(()=>[])}),typeof e=="object"&&e!==null)switch(H(e,"$$typeof")){case F:E(e.render,t,n,o);break;case C:E(e.type,t,n,o);break}}function A(e){const t=m.get(e);t!==void 0&&_(t)}function $(e){return T.get(e)}function W(e){return k.get(e)}function x(e){const t=new Set;return c.forEach(n=>{const o=w.get(n);if(o===void 0)throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");o.findHostInstancesForRefresh(n,e).forEach(s=>{t.add(s)})}),t}function z(e){let t=e.__REACT_DEVTOOLS_GLOBAL_HOOK__;if(t===void 0){let s=0;e.__REACT_DEVTOOLS_GLOBAL_HOOK__=t={renderers:new Map,supportsFiber:!0,inject(r){return s++},onScheduleFiberRoot(r,h,d){},onCommitFiberRoot(r,h,d,f){},onCommitFiberUnmount(){}}}if(t.isDisabled){console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");return}const n=t.inject;t.inject=function(s){const r=n.apply(this,arguments);return typeof s.scheduleRefresh=="function"&&typeof s.setRefreshHandler=="function"&&b.set(r,s),r},t.renderers.forEach((s,r)=>{typeof s.scheduleRefresh=="function"&&typeof s.setRefreshHandler=="function"&&b.set(r,s)});const o=t.onCommitFiberRoot,l=t.onScheduleFiberRoot||(()=>{});t.onScheduleFiberRoot=function(s,r,h){return S||(p.delete(r),R!==null&&R.set(r,h)),l.apply(this,arguments)},t.onCommitFiberRoot=function(s,r,h,d){const f=b.get(s);if(f!==void 0){w.set(r,f);const i=r.current,u=i.alternate;if(u!==null){const a=u.memoizedState!=null&&u.memoizedState.element!=null&&c.has(r),y=i.memoizedState!=null&&i.memoizedState.element!=null;!a&&y?(c.add(r),p.delete(r)):a&&y||(a&&!y?(c.delete(r),d?p.add(r):w.delete(r)):!a&&!y&&d&&p.add(r))}else c.add(r)}return o.apply(this,arguments)}}function G(){return!1}function N(){return c.size}function U(){let e,t,n=!1;return function(o,l,s,r){if(typeof l=="string")return e||(e=o,t=typeof r=="function"),o!=null&&(typeof o=="function"||typeof o=="object")&&E(o,l,s,r),o;!n&&t&&(n=!0,A(e))}}function V(e){switch(typeof e){case"function":{if(e.prototype!=null){if(e.prototype.isReactComponent)return!0;const n=Object.getOwnPropertyNames(e.prototype);if(n.length>1||n[0]!=="constructor"||e.prototype.__proto__!==Object.prototype)return!1}const t=e.name||e.displayName;return typeof t=="string"&&/^[A-Z]/.test(t)}case"object":{if(e!=null)switch(H(e,"$$typeof")){case F:case C:return!0;default:return!1}return!1}default:return!1}}export{N as _getMountedRootCount,A as collectCustomHooksForSignature,U as createSignatureFunctionForTransform,x as findAffectedHostInstances,$ as getFamilyByID,W as getFamilyByType,G as hasUnrecoverableErrors,z as injectIntoGlobalHook,V as isLikelyComponentType,j as performReactRefresh,K as register,E as setSignature}; +` + r); + } + return (e.fullKey = t), t; +} +function D(e, t) { + const n = m.get(e), + o = m.get(t); + return n === void 0 && o === void 0 + ? !0 + : !(n === void 0 || o === void 0 || _(n) !== _(o) || o.forceReset); +} +function B(e) { + return e.prototype && e.prototype.isReactComponent; +} +function v(e, t) { + return B(e) || B(t) ? !1 : !!D(e, t); +} +function I(e) { + return M.get(e); +} +function P(e) { + const t = new Map(); + return ( + e.forEach((n, o) => { + t.set(o, n); + }), + t + ); +} +function L(e) { + const t = new Set(); + return ( + e.forEach((n) => { + t.add(n); + }), + t + ); +} +function H(e, t) { + try { + return e[t]; + } catch { + return; + } +} +function j() { + if (g.length === 0 || S) return null; + S = !0; + try { + const e = new Set(), + t = new Set(), + n = g; + (g = []), + n.forEach((f) => { + let [i, u] = f; + const a = i.current; + M.set(a, i), + M.set(u, i), + (i.current = u), + v(a, u) ? t.add(i) : e.add(i); + }); + const o = { updatedFamilies: t, staleFamilies: e }; + b.forEach((f) => { + f.setRefreshHandler(I); + }); + let l = !1, + s = null; + const r = L(p), + h = L(c), + d = P(w); + if ( + (r.forEach((f) => { + const i = d.get(f); + if (i === void 0) + throw new Error( + "Could not find helpers for a root. This is a bug in React Refresh.", + ); + if ((!p.has(f), R === null || !R.has(f))) return; + const u = R.get(f); + try { + i.scheduleRoot(f, u); + } catch (a) { + l || ((l = !0), (s = a)); + } + }), + h.forEach((f) => { + const i = d.get(f); + if (i === void 0) + throw new Error( + "Could not find helpers for a root. This is a bug in React Refresh.", + ); + !c.has(f); + try { + i.scheduleRefresh(f, o); + } catch (u) { + l || ((l = !0), (s = u)); + } + }), + l) + ) + throw s; + return o; + } finally { + S = !1; + } +} +function K(e, t) { + if ( + e === null || + (typeof e != "function" && typeof e != "object") || + k.has(e) + ) + return; + let n = T.get(t); + if ( + (n === void 0 ? ((n = { current: e }), T.set(t, n)) : g.push([n, e]), + k.set(e, n), + typeof e == "object" && e !== null) + ) + switch (H(e, "$$typeof")) { + case F: + K(e.render, t + "$render"); + break; + case C: + K(e.type, t + "$type"); + break; + } +} +function E(e, t) { + let n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1, + o = arguments.length > 3 ? arguments[3] : void 0; + if ( + (m.has(e) || + m.set(e, { + forceReset: n, + ownKey: t, + fullKey: null, + getCustomHooks: o || (() => []), + }), + typeof e == "object" && e !== null) + ) + switch (H(e, "$$typeof")) { + case F: + E(e.render, t, n, o); + break; + case C: + E(e.type, t, n, o); + break; + } +} +function A(e) { + const t = m.get(e); + t !== void 0 && _(t); +} +function $(e) { + return T.get(e); +} +function W(e) { + return k.get(e); +} +function x(e) { + const t = new Set(); + return ( + c.forEach((n) => { + const o = w.get(n); + if (o === void 0) + throw new Error( + "Could not find helpers for a root. This is a bug in React Refresh.", + ); + o.findHostInstancesForRefresh(n, e).forEach((s) => { + t.add(s); + }); + }), + t + ); +} +function z(e) { + let t = e.__REACT_DEVTOOLS_GLOBAL_HOOK__; + if (t === void 0) { + let s = 0; + e.__REACT_DEVTOOLS_GLOBAL_HOOK__ = t = { + renderers: new Map(), + supportsFiber: !0, + inject(r) { + return s++; + }, + onScheduleFiberRoot(r, h, d) {}, + onCommitFiberRoot(r, h, d, f) {}, + onCommitFiberUnmount() {}, + }; + } + if (t.isDisabled) { + console.warn( + "Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.", + ); + return; + } + const n = t.inject; + (t.inject = function (s) { + const r = n.apply(this, arguments); + return ( + typeof s.scheduleRefresh == "function" && + typeof s.setRefreshHandler == "function" && + b.set(r, s), + r + ); + }), + t.renderers.forEach((s, r) => { + typeof s.scheduleRefresh == "function" && + typeof s.setRefreshHandler == "function" && + b.set(r, s); + }); + const o = t.onCommitFiberRoot, + l = t.onScheduleFiberRoot || (() => {}); + (t.onScheduleFiberRoot = function (s, r, h) { + return ( + S || (p.delete(r), R !== null && R.set(r, h)), l.apply(this, arguments) + ); + }), + (t.onCommitFiberRoot = function (s, r, h, d) { + const f = b.get(s); + if (f !== void 0) { + w.set(r, f); + const i = r.current, + u = i.alternate; + if (u !== null) { + const a = + u.memoizedState != null && + u.memoizedState.element != null && + c.has(r), + y = i.memoizedState != null && i.memoizedState.element != null; + !a && y + ? (c.add(r), p.delete(r)) + : (a && y) || + (a && !y + ? (c.delete(r), d ? p.add(r) : w.delete(r)) + : !a && !y && d && p.add(r)); + } else c.add(r); + } + return o.apply(this, arguments); + }); +} +function G() { + return !1; +} +function N() { + return c.size; +} +function U() { + let e, + t, + n = !1; + return function (o, l, s, r) { + if (typeof l == "string") + return ( + e || ((e = o), (t = typeof r == "function")), + o != null && + (typeof o == "function" || typeof o == "object") && + E(o, l, s, r), + o + ); + !n && t && ((n = !0), A(e)); + }; +} +function V(e) { + switch (typeof e) { + case "function": { + if (e.prototype != null) { + if (e.prototype.isReactComponent) return !0; + const n = Object.getOwnPropertyNames(e.prototype); + if ( + n.length > 1 || + n[0] !== "constructor" || + e.prototype.__proto__ !== Object.prototype + ) + return !1; + } + const t = e.name || e.displayName; + return typeof t == "string" && /^[A-Z]/.test(t); + } + case "object": { + if (e != null) + switch (H(e, "$$typeof")) { + case F: + case C: + return !0; + default: + return !1; + } + return !1; + } + default: + return !1; + } +} +export { + N as _getMountedRootCount, + A as collectCustomHooksForSignature, + U as createSignatureFunctionForTransform, + x as findAffectedHostInstances, + $ as getFamilyByID, + W as getFamilyByType, + G as hasUnrecoverableErrors, + z as injectIntoGlobalHook, + V as isLikelyComponentType, + j as performReactRefresh, + K as register, + E as setSignature, +}; diff --git a/src/runtime.footer.node.js b/src/runtime.footer.node.js index a6e425e44a..b32dc78fa8 100644 --- a/src/runtime.footer.node.js +++ b/src/runtime.footer.node.js @@ -48,7 +48,7 @@ var process = target = process = _process; return Reflect.has(_process, prop, receiver); }, - } + }, ); var Buffer = @@ -81,5 +81,5 @@ var Buffer = target = Buffer = NewBuffer; return Reflect.has(NewBuffer, prop, receiver); }, - } + }, ); diff --git a/src/runtime.js b/src/runtime.js index fe2f5b9df1..b39eaed9d3 100644 --- a/src/runtime.js +++ b/src/runtime.js @@ -45,10 +45,10 @@ export var __toModule = (module) => { "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true, configurable: true } - : { value: module, enumerable: true, configurable: true } - ) + : { value: module, enumerable: true, configurable: true }, + ), ), - module + module, ); }; @@ -83,12 +83,12 @@ export var __commonJS = (cb, name) => { Object.setPrototypeOf(mod_exports, __getProtoOf(origExports)); Object.defineProperties( mod_exports, - Object.getOwnPropertyDescriptors(origExports) + Object.getOwnPropertyDescriptors(origExports), ); } else { mod_exports = __create( __getProtoOf(mod_exports), - Object.getOwnPropertyDescriptors(mod_exports) + Object.getOwnPropertyDescriptors(mod_exports), ); } } @@ -237,13 +237,15 @@ export var __merge = (props, defaultProps) => { }; export var __decorateClass = (decorators, target, key, kind) => { - var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + var result = + kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; for (var i = decorators.length - 1, decorator; i >= 0; i--) - if (decorator = decorators[i]) - result = (kind ? decorator(target, key, result) : decorator(result)) || result; - if (kind && result) - __defProp(target, key, result); + if ((decorator = decorators[i])) + result = + (kind ? decorator(target, key, result) : decorator(result)) || result; + if (kind && result) __defProp(target, key, result); return result; }; -export var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index); \ No newline at end of file +export var __decorateParam = (index, decorator) => (target, key) => + decorator(target, key, index); diff --git a/src/runtime/errors.ts b/src/runtime/errors.ts index ad54cc3227..5affd14f15 100644 --- a/src/runtime/errors.ts +++ b/src/runtime/errors.ts @@ -1,3 +1,4 @@ +// @ts-nocheck var __BuildError; var __ResolveError; var __ImportKind; diff --git a/src/runtime/hmr.ts b/src/runtime/hmr.ts index 2882744dbf..96122feba1 100644 --- a/src/runtime/hmr.ts +++ b/src/runtime/hmr.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { ByteBuffer } from "peechy"; import * as API from "../api/schema"; @@ -178,7 +179,7 @@ if (typeof window !== "undefined") { private findMatchingSupportsRule( rule: CSSSupportsRule, id: number, - sheet: CSSStyleSheet + sheet: CSSStyleSheet, ): CSSHMRInsertionPoint | null { switch (rule.type) { // 12 is result.SUPPORTS_RULE @@ -193,7 +194,7 @@ if (typeof window !== "undefined") { const int = parseInt( rule.conditionText.substring(startIndex, endIDRegion), - 10 + 10, ); if (int !== id) { @@ -202,14 +203,14 @@ if (typeof window !== "undefined") { let startFileRegion = rule.conditionText.indexOf( '(hmr-file:"', - endIDRegion + endIDRegion, ); if (startFileRegion === -1) return null; startFileRegion += '(hmr-file:"'.length + 1; const endFileRegion = rule.conditionText.indexOf( '"', - startFileRegion + startFileRegion, ); if (endFileRegion === -1) return null; // Empty file strings are invalid @@ -220,7 +221,7 @@ if (typeof window !== "undefined") { CSSLoader.cssLoadId.sheet = sheet; CSSLoader.cssLoadId.file = rule.conditionText.substring( startFileRegion - 1, - endFileRegion + endFileRegion, ); return CSSLoader.cssLoadId; @@ -273,23 +274,23 @@ if (typeof window !== "undefined") { const bundleIdEnd = bundleIdRule.conditionText.indexOf( ")", - "(hmr-bid:".length + 1 + "(hmr-bid:".length + 1, ); if (bundleIdEnd === -1) continue; CSSLoader.cssLoadId.bundle_id = parseInt( bundleIdRule.conditionText.substring( "(hmr-bid:".length, - bundleIdEnd + bundleIdEnd, ), - 10 + 10, ); for (let j = 1; j < ruleCount && match === null; j++) { match = this.findMatchingSupportsRule( cssRules[j] as CSSSupportsRule, id, - sheet + sheet, ); } } @@ -326,20 +327,20 @@ if (typeof window !== "undefined") { const bundleIdEnd = bundleIdRule.conditionText.indexOf( ")", - "(hmr-bid:".length + 1 + "(hmr-bid:".length + 1, ); if (bundleIdEnd === -1) continue; CSSLoader.cssLoadId.bundle_id = parseInt( bundleIdRule.conditionText.substring("(hmr-bid:".length, bundleIdEnd), - 10 + 10, ); for (let j = 1; j < ruleCount && match === null; j++) { match = this.findMatchingSupportsRule( cssRules[j] as CSSSupportsRule, id, - sheet + sheet, ); } } @@ -358,7 +359,7 @@ if (typeof window !== "undefined") { handleBuildSuccess( bytes: Uint8Array, build: API.WebsocketMessageBuildSuccess, - timestamp: number + timestamp: number, ) { const start = performance.now(); var update = this.findCSSLinkTag(build.id); @@ -389,7 +390,7 @@ if (typeof window !== "undefined") { "Reloaded in", `${localDuration + fsDuration}ms`, "-", - filepath + filepath, ); update = null; @@ -445,7 +446,7 @@ if (typeof window !== "undefined") { } filePath( - file_change_notification: API.WebsocketMessageFileChangeNotification + file_change_notification: API.WebsocketMessageFileChangeNotification, ): string | null { if (file_change_notification.loader !== API.Loader.css) return null; const tag = this.findCSSLinkTag(file_change_notification.id); @@ -481,7 +482,7 @@ if (typeof window !== "undefined") { start() { if (runOnce) { __hmrlog.warn( - "Attempted to start HMR client multiple times. This may be a bug." + "Attempted to start HMR client multiple times. This may be a bug.", ); return; } @@ -514,7 +515,7 @@ if (typeof window !== "undefined") { this.nextReconnectAttempt = setTimeout( this.attemptReconnect, - this.reconnectDelay + this.reconnectDelay, ); }; @@ -608,7 +609,7 @@ if (typeof window !== "undefined") { case CSSImportState.Loaded: { promise.then( () => {}, - () => {} + () => {}, ); break; } @@ -672,19 +673,19 @@ if (typeof window !== "undefined") { link.onerror = (evt) => { console.error( `[CSS Importer] Error loading CSS file: ${urlString}\n`, - evt.toString() + evt.toString(), ); reject(); }; document.head.appendChild(link); - }).then(() => Promise.resolve()) + }).then(() => Promise.resolve()), ); } static onError(event: ErrorEvent) { if ("error" in event && !!event.error) { BunError.render( event.error, - HMRClient.client ? HMRClient.client.cwd : "" + HMRClient.client ? HMRClient.client.cwd : "", ); } } @@ -757,7 +758,7 @@ if (typeof window !== "undefined") { BunError.render(failure, this.cwd); console.group( - `Build failed: ${failure.module_path} (${failure.log.errors} errors)` + `Build failed: ${failure.module_path} (${failure.log.errors} errors)`, ); this.needsConsoleClear = true; for (let msg of failure.log.msgs) { @@ -823,7 +824,7 @@ if (typeof window !== "undefined") { `Ignoring outdated update for "${build.module_path}".\n Expected: >=`, currentVersion, `\n Received:`, - build.from_timestamp + build.from_timestamp, ); } return; @@ -834,7 +835,7 @@ if (typeof window !== "undefined") { ? new Uint8Array( buffer.data.buffer, buffer.data.byteOffset + buffer.index, - build.blob_length + build.blob_length, ) : (empty ||= new Uint8Array(0)); @@ -876,7 +877,7 @@ if (typeof window !== "undefined") { if (end > 4 && buffer.data.length >= end + 4) { new Uint8Array(this.hashBuffer.buffer).set( - buffer.data.subarray(end, end + 4) + buffer.data.subarray(end, end + 4), ); hash = this.hashBuffer[0]; } @@ -889,7 +890,7 @@ if (typeof window !== "undefined") { build, bytes, ReloadBehavior.hotReload, - hash || 0 + hash || 0, ); bytes = null; reload.timings.notify = timestamp - build.from_timestamp; @@ -911,7 +912,7 @@ if (typeof window !== "undefined") { __hmrlog.log( `[${formatDuration(timings.total)}ms] Reloaded`, - filepath + filepath, ); }, (err) => { @@ -924,7 +925,7 @@ if (typeof window !== "undefined") { } __hmrlog.error("Hot Module Reload failed!", err); debugger; - } + }, ); } @@ -942,7 +943,7 @@ if (typeof window !== "undefined") { handleFileChangeNotification( buffer: ByteBuffer, timestamp: number, - copy_file_path: boolean + copy_file_path: boolean, ) { const notification = API.decodeWebsocketMessageFileChangeNotification(buffer); @@ -977,7 +978,7 @@ if (typeof window !== "undefined") { timestamp, notification, file_path, - copy_file_path + copy_file_path, ); } @@ -985,7 +986,7 @@ if (typeof window !== "undefined") { timestamp: number, notification: API.WebsocketMessageFileChangeNotification, file_path: string, - copy_file_path: boolean + copy_file_path: boolean, ) { const accept = file_path && file_path.length > 0; @@ -1072,10 +1073,10 @@ if (typeof window !== "undefined") { const out = textEncoder.encodeInto( file_path, - writeBuffer.subarray(13) + writeBuffer.subarray(13), ); this.socket.send( - this.buildCommandBufWithFilePath.subarray(0, 13 + out.written) + this.buildCommandBufWithFilePath.subarray(0, 13 + out.written), ); } else { this.socket.send(this.buildCommandBuf); @@ -1118,7 +1119,7 @@ if (typeof window !== "undefined") { const message_header_byte_buffer = new ByteBuffer(data); const header = API.decodeWebsocketMessage(message_header_byte_buffer); const buffer = new ByteBuffer( - data.subarray(message_header_byte_buffer.index) + data.subarray(message_header_byte_buffer.index), ); switch (header.kind) { @@ -1206,7 +1207,7 @@ if (typeof window !== "undefined") { timestamp, { id, loader }, file_path, - true + true, ); break; } @@ -1233,7 +1234,7 @@ if (typeof window !== "undefined") { __hmrlog.log( "HMR connected in", formatDuration(now - clientStartTime), - "ms" + "ms", ); break; } @@ -1241,7 +1242,7 @@ if (typeof window !== "undefined") { __hmrlog.log( "Live reload connected in", formatDuration(now - clientStartTime), - "ms" + "ms", ); break; } @@ -1249,7 +1250,7 @@ if (typeof window !== "undefined") { __hmrlog.log( "Bun connected in", formatDuration(now - clientStartTime), - "ms" + "ms", ); break; } @@ -1305,7 +1306,7 @@ if (typeof window !== "undefined") { build: HotReload["build"], bytes: Uint8Array, reloader: ReloadBehavior, - hash: number + hash: number, ) { this.module_id = module_id; this.module_index = module_index; @@ -1362,7 +1363,7 @@ if (typeof window !== "undefined") { try { const blob = new Blob( sourceMapURL.length > 0 ? [this.bytes, sourceMapURL] : [this.bytes], - { type: "text/javascript" } + { type: "text/javascript" }, ); blobURL = URL.createObjectURL(blob); HMRModule.dependencies.blobToID.set(blobURL, this.module_id); @@ -1380,7 +1381,7 @@ if (typeof window !== "undefined") { globalThis.__BunRenderHMRError( exception, oldModule.file_path, - oldModule.id + oldModule.id, ); } @@ -1405,7 +1406,7 @@ if (typeof window !== "undefined") { HMRModule.dependencies.modules[this.module_index].file_path, "in", formatDuration(this.timings.import), - ". Running callbacks" + ". Running callbacks", ); } @@ -1453,7 +1454,7 @@ if (typeof window !== "undefined") { const end = Math.min( this.module_index + 1, - HMRModule.dependencies.graph_used + HMRModule.dependencies.graph_used, ); // -- For generic hot reloading -- // ES Modules delay execution until all imports are parsed @@ -1516,8 +1517,8 @@ if (typeof window !== "undefined") { } else { return Promise.reject( new ThrottleModuleUpdateError( - `Expected pendingUpdateCount: ${currentPendingUpdateCount} but received: ${pendingUpdateCount}` - ) + `Expected pendingUpdateCount: ${currentPendingUpdateCount} but received: ${pendingUpdateCount}`, + ), ); } @@ -1538,7 +1539,7 @@ if (typeof window !== "undefined") { HMRModule.dependencies.modules[this.module_index].file_path, "in", formatDuration(this.timings.callbacks), - "ms" + "ms", ); } @@ -1625,7 +1626,7 @@ if (typeof window !== "undefined") { // Grow the dependencies graph if (HMRModule.dependencies.graph.length <= this.graph_index) { const new_graph = new Uint32Array( - HMRModule.dependencies.graph.length * 4 + HMRModule.dependencies.graph.length * 4, ); new_graph.set(HMRModule.dependencies.graph); HMRModule.dependencies.graph = new_graph; @@ -1730,7 +1731,7 @@ if (typeof window !== "undefined") { $r_(Component: any, id: string) { FastRefreshLoader.RefreshRuntime.register( Component, - this.refreshRuntimeBaseID + id + this.refreshRuntimeBaseID + id, ); } // $RefreshReg$(Component, Component.name || Component.displayName) diff --git a/src/runtime/index-with-refresh.ts b/src/runtime/index-with-refresh.ts index dc0c361f8b..abea4c0f4c 100644 --- a/src/runtime/index-with-refresh.ts +++ b/src/runtime/index-with-refresh.ts @@ -1,3 +1,4 @@ +// @ts-nocheck export * from "./hmr"; export * from "./errors"; export * from "./index-without-hmr"; @@ -8,4 +9,4 @@ globalThis.process ||= { cwd() { return "/bun-fake-dir/"; }, -}; +} as any; diff --git a/src/runtime/index-without-hmr.ts b/src/runtime/index-without-hmr.ts index 8586881305..5fcebbc285 100644 --- a/src/runtime/index-without-hmr.ts +++ b/src/runtime/index-without-hmr.ts @@ -1,2 +1,3 @@ +// @ts-nocheck export * from "../runtime.js"; export { default as regeneratorRuntime } from "./regenerator"; diff --git a/src/runtime/index.ts b/src/runtime/index.ts index 3eebc8d5bc..3c35e361ce 100644 --- a/src/runtime/index.ts +++ b/src/runtime/index.ts @@ -1,3 +1,4 @@ +// @ts-nocheck export * from "./hmr"; export * from "./errors"; export * from "./index-without-hmr"; diff --git a/src/runtime/regenerator.ts b/src/runtime/regenerator.ts index ca3780f44e..0940fb9f1e 100644 --- a/src/runtime/regenerator.ts +++ b/src/runtime/regenerator.ts @@ -1,3 +1,4 @@ +// @ts-nocheck /** * Copyright (c) 2014-present, Facebook, Inc. * @@ -113,7 +114,7 @@ var runtime = (function (exports) { GeneratorFunction.displayName = define( GeneratorFunctionPrototype, toStringTagSymbol, - "GeneratorFunction" + "GeneratorFunction", ); // Helper for defining the .next, .throw, and .return methods of the @@ -174,7 +175,7 @@ var runtime = (function (exports) { }, function (err) { invoke("throw", err, resolve, reject); - } + }, ); } @@ -190,7 +191,7 @@ var runtime = (function (exports) { // If a rejected Promise was yielded, throw the rejection back // into the async generator function so it can be handled there. return invoke("throw", error, resolve, reject); - } + }, ); } } @@ -222,7 +223,7 @@ var runtime = (function (exports) { callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later // invocations of the iterator. - callInvokeWithMethodAndArg + callInvokeWithMethodAndArg, ) : callInvokeWithMethodAndArg()); } @@ -246,7 +247,7 @@ var runtime = (function (exports) { var iter = new AsyncIterator( wrap(innerFn, outerFn, self, tryLocsList), - PromiseImpl + PromiseImpl, ); return exports.isGeneratorFunction(outerFn) @@ -358,7 +359,7 @@ var runtime = (function (exports) { context.method = "throw"; context.arg = new TypeError( - "The iterator does not provide a 'throw' method" + "The iterator does not provide a 'throw' method", ); } @@ -741,7 +742,7 @@ var runtime = (function (exports) { // as the regeneratorRuntime namespace. Otherwise create a new empty // object. Either way, the resulting object will be used to initialize // the regeneratorRuntime variable at the top of this file. - typeof module === "object" ? module.exports : {} + typeof module === "object" ? module.exports : {}, ); try { diff --git a/src/test/fixtures/browsermap-false.ts b/src/test/fixtures/browsermap-false.ts index aac72e3251..b4fc1ff324 100644 --- a/src/test/fixtures/browsermap-false.ts +++ b/src/test/fixtures/browsermap-false.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { Foo } from "browsermap"; console.log(Foo); diff --git a/src/test/fixtures/cannot-assign-to-import-bug.js b/src/test/fixtures/cannot-assign-to-import-bug.js index c14b96541f..ccf2c6194f 100644 --- a/src/test/fixtures/cannot-assign-to-import-bug.js +++ b/src/test/fixtures/cannot-assign-to-import-bug.js @@ -283,7 +283,7 @@ "Instead, assign to `this.state` directly or define a `state = {};` " + "class property with the desired state in the %s component.", callerName, - componentName + componentName, ); didWarnStateUpdateForUnmountedComponent[warningKey] = true; @@ -341,7 +341,7 @@ publicInstance, completeState, callback, - callerName + callerName, ) { warnNoop(publicInstance, "replaceState"); }, @@ -362,7 +362,7 @@ publicInstance, partialState, callback, - callerName + callerName, ) { warnNoop(publicInstance, "setState"); }, @@ -424,7 +424,7 @@ ) { { throw Error( - "setState(...): takes an object of state variables to update or a function which returns an object of state variables." + "setState(...): takes an object of state variables to update or a function which returns an object of state variables.", ); } } @@ -475,7 +475,7 @@ warn( "%s(...) is deprecated in plain JavaScript React classes. %s", info[0], - info[1] + info[1], ); return undefined; @@ -549,7 +549,7 @@ if (typeof type.tag === "number") { error( "Received an unexpected object in getComponentName(). " + - "This is likely a bug in React. Please file an issue." + "This is likely a bug in React. Please file an issue.", ); } } @@ -672,7 +672,7 @@ "in `undefined` being returned. If you need to access the same " + "value within the child component, you should pass it as a different " + "prop. (https://reactjs.org/link/special-props)", - displayName + displayName, ); } } @@ -696,7 +696,7 @@ "in `undefined` being returned. If you need to access the same " + "value within the child component, you should pass it as a different " + "prop. (https://reactjs.org/link/special-props)", - displayName + displayName, ); } } @@ -728,7 +728,7 @@ "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", componentName, - config.ref + config.ref, ); didWarnAboutStringRefs[componentName] = true; @@ -905,7 +905,7 @@ self, source, ReactCurrentOwner.current, - props + props, ); } function cloneAndReplaceKey(oldElement, newKey) { @@ -916,7 +916,7 @@ oldElement._self, oldElement._source, oldElement._owner, - oldElement.props + oldElement.props, ); return newElement; } @@ -931,7 +931,7 @@ throw Error( "React.cloneElement(...): The argument must be a React element, but you passed " + element + - "." + ".", ); } } @@ -1125,7 +1125,7 @@ (mappedChild.key && (!_child || _child.key !== mappedChild.key) // $FlowFixMe Flow incorrectly thinks existing element's key can be a number ? escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + - childKey + childKey, ); } @@ -1151,7 +1151,7 @@ array, escapedPrefix, nextName, - callback + callback, ); } } else { @@ -1166,7 +1166,7 @@ if (!didWarnAboutMaps) { warn( "Using Maps as children is not supported. " + - "Use an array of keyed ReactElements instead." + "Use an array of keyed ReactElements instead.", ); } @@ -1186,7 +1186,7 @@ array, escapedPrefix, nextName, - callback + callback, ); } } else if (type === "object") { @@ -1201,7 +1201,7 @@ Object.keys(children).join(", ") + "}" : childrenString) + - "). If you meant to render a collection of children, use an array instead." + "). If you meant to render a collection of children, use an array instead.", ); } } @@ -1272,7 +1272,7 @@ function () { forEachFunc.apply(this, arguments); // Don't return anything. }, - forEachContext + forEachContext, ); } /** @@ -1308,7 +1308,7 @@ if (!isValidElement(children)) { { throw Error( - "React.Children.only expected to receive a single React element child." + "React.Children.only expected to receive a single React element child.", ); } } @@ -1328,7 +1328,7 @@ error( "createContext: Expected the optional second argument to be a " + "function. Instead received: %s", - calculateChangedBits + calculateChangedBits, ); } } @@ -1377,7 +1377,7 @@ error( "Rendering is not supported and will be removed in " + - "a future major release. Did you mean to render instead?" + "a future major release. Did you mean to render instead?", ); } @@ -1418,7 +1418,7 @@ error( "Rendering is not supported and will be removed in " + - "a future major release. Did you mean to render instead?" + "a future major release. Did you mean to render instead?", ); } @@ -1434,7 +1434,7 @@ warn( "Setting `displayName` on Context.Consumer has no effect. " + "You should set it directly on the context with Context.displayName = '%s'.", - displayName + displayName, ); hasWarnedAboutDisplayNameOnConsumer = true; @@ -1479,7 +1479,7 @@ "Instead received: %s\n\nYour code should look like: \n " + // Break up imports to avoid accidentally parsing them as dependencies. "const MyComponent = lazy(() => imp" + "ort('./MyComponent'))", - moduleObject + moduleObject, ); } } // Transition to the next state. @@ -1496,7 +1496,7 @@ rejected._status = Rejected; rejected._result = error; } - } + }, ); } @@ -1534,7 +1534,7 @@ error( "React.lazy(...): It is not supported to assign `defaultProps` to " + "a lazy component import. Either specify them where the component " + - "is defined, or create a wrapping component around it." + "is defined, or create a wrapping component around it.", ); defaultProps = newDefaultProps; // Match production behavior more closely: @@ -1554,7 +1554,7 @@ error( "React.lazy(...): It is not supported to assign `propTypes` to " + "a lazy component import. Either specify them where the component " + - "is defined, or create a wrapping component around it." + "is defined, or create a wrapping component around it.", ); propTypes = newPropTypes; // Match production behavior more closely: @@ -1577,12 +1577,12 @@ error( "forwardRef requires a render function but received a `memo` " + "component. Instead of forwardRef(memo(...)), use " + - "memo(forwardRef(...))." + "memo(forwardRef(...)).", ); } else if (typeof render !== "function") { error( "forwardRef requires a render function but was given %s.", - render === null ? "null" : typeof render + render === null ? "null" : typeof render, ); } else { if (render.length !== 0 && render.length !== 2) { @@ -1590,7 +1590,7 @@ "forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" - : "Any additional parameter will be undefined." + : "Any additional parameter will be undefined.", ); } } @@ -1599,7 +1599,7 @@ if (render.defaultProps != null || render.propTypes != null) { error( "forwardRef render functions do not support propTypes or defaultProps. " + - "Did you accidentally pass a React component?" + "Did you accidentally pass a React component?", ); } } @@ -1677,7 +1677,7 @@ error( "memo: The first argument must be a component. Instead " + "received: %s", - type === null ? "null" : typeof type + type === null ? "null" : typeof type, ); } } @@ -1715,7 +1715,7 @@ if (!(dispatcher !== null)) { { throw Error( - "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem." + "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.", ); } } @@ -1738,7 +1738,7 @@ ? "\n\nDid you call array.map(useContext)? " + "Calling Hooks inside a loop is not supported. " + "Learn more at https://reactjs.org/link/rules-of-hooks" - : "" + : "", ); } // TODO: add a more generic warning for invalid values. @@ -1749,12 +1749,12 @@ if (realContext.Consumer === Context) { error( "Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be " + - "removed in a future major release. Did you mean to call useContext(Context) instead?" + "removed in a future major release. Did you mean to call useContext(Context) instead?", ); } else if (realContext.Provider === Context) { error( "Calling useContext(Context.Provider) is not supported. " + - "Did you mean to call useContext(Context) instead?" + "Did you mean to call useContext(Context) instead?", ); } } @@ -1892,7 +1892,7 @@ if (disabledDepth < 0) { error( "disabledDepth fell below zero. " + - "This is a bug in React. Please file an issue." + "This is a bug in React. Please file an issue.", ); } } @@ -2117,7 +2117,7 @@ return describeUnknownElementTypeFrameInDEV( type.type, source, - ownerFn + ownerFn, ); case REACT_BLOCK_TYPE: @@ -2133,7 +2133,7 @@ return describeUnknownElementTypeFrameInDEV( init(payload), source, - ownerFn + ownerFn, ); } catch (x) {} } @@ -2153,7 +2153,7 @@ var stack = describeUnknownElementTypeFrameInDEV( element.type, element._source, - owner ? owner.type : null + owner ? owner.type : null, ); ReactDebugCurrentFrame$1.setExtraStackFrame(stack); } else { @@ -2187,7 +2187,7 @@ "it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`." + - "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.", ); err.name = "Invariant Violation"; throw err; @@ -2199,7 +2199,7 @@ componentName, location, null, - "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED" + "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED", ); } catch (ex) { error$1 = ex; @@ -2218,7 +2218,7 @@ componentName || "React class", location, typeSpecName, - typeof error$1 + typeof error$1, ); setCurrentlyValidatingElement(null); @@ -2249,7 +2249,7 @@ var stack = describeUnknownElementTypeFrameInDEV( element.type, element._source, - owner ? owner.type : null + owner ? owner.type : null, ); setExtraStackFrame(stack); } else { @@ -2367,7 +2367,7 @@ 'Each child in a list should have a unique "key" prop.' + "%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, - childOwner + childOwner, ); setCurrentlyValidatingElement$1(null); @@ -2464,7 +2464,7 @@ error( "Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", - _name || "Unknown" + _name || "Unknown", ); } @@ -2474,7 +2474,7 @@ ) { error( "getDefaultProps is only used on classic React.createClass " + - "definitions. Use a static property named `defaultProps` instead." + "definitions. Use a static property named `defaultProps` instead.", ); } } @@ -2497,7 +2497,7 @@ error( "Invalid prop `%s` supplied to `React.Fragment`. " + "React.Fragment can only have `key` and `children` props.", - key + key, ); setCurrentlyValidatingElement$1(null); @@ -2560,7 +2560,7 @@ "built-in components) or a class/function (for composite " + "components) but got: %s.%s", typeString, - info + info, ); } } @@ -2602,7 +2602,7 @@ warn( "React.createFactory() is deprecated and will be removed in " + "a future major release. Consider using JSX " + - "or use React.createElement() directly instead." + "or use React.createElement() directly instead.", ); } // Legacy hook: remove it @@ -2611,7 +2611,7 @@ get: function () { warn( "Factory.type is deprecated. Access the class directly " + - "before passing it to createFactory." + "before passing it to createFactory.", ); Object.defineProperty(this, "type", { @@ -2730,7 +2730,7 @@ console["error"]( "This browser doesn't support requestAnimationFrame. " + "Make sure that you load a " + - "polyfill in older browsers. https://reactjs.org/link/react-polyfills" + "polyfill in older browsers. https://reactjs.org/link/react-polyfills", ); } @@ -2739,7 +2739,7 @@ console["error"]( "This browser doesn't support cancelAnimationFrame. " + "Make sure that you load a " + - "polyfill in older browsers. https://reactjs.org/link/react-polyfills" + "polyfill in older browsers. https://reactjs.org/link/react-polyfills", ); } } @@ -2769,7 +2769,7 @@ // Using console['error'] to evade Babel and ESLint console["error"]( "forceFrameRate takes a positive int between 0 and 125, " + - "forcing frame rates higher than 125 fps is not supported" + "forcing frame rates higher than 125 fps is not supported", ); return; } @@ -2794,7 +2794,7 @@ try { var hasMoreWork = scheduledHostCallback( hasTimeRemaining, - currentTime + currentTime, ); if (!hasMoreWork) { diff --git a/src/test/fixtures/class-with-property.ts b/src/test/fixtures/class-with-property.ts index 9c9aee2d48..9d555fa2fc 100644 --- a/src/test/fixtures/class-with-property.ts +++ b/src/test/fixtures/class-with-property.ts @@ -1,3 +1,4 @@ +// @ts-nocheck class Foo { prop: string; } diff --git a/src/test/fixtures/default_export_hmr_identifier_ref.tsx b/src/test/fixtures/default_export_hmr_identifier_ref.tsx index 4c742c6ef1..a6a961532a 100644 --- a/src/test/fixtures/default_export_hmr_identifier_ref.tsx +++ b/src/test/fixtures/default_export_hmr_identifier_ref.tsx @@ -1,3 +1,4 @@ +// @ts-nocheck const Button = forwardRef(({}, ref) => {}); Button.displayName = "Button"; diff --git a/src/test/fixtures/exports-bug.js b/src/test/fixtures/exports-bug.js index 081b8cfa0a..66574686a8 100644 --- a/src/test/fixtures/exports-bug.js +++ b/src/test/fixtures/exports-bug.js @@ -213,7 +213,7 @@ function WebGLRenderer(parameters) { if (_gl === null) { if (_canvas.getContext("webgl") !== null) { throw new Error( - "Error creating WebGL context with your selected attributes." + "Error creating WebGL context with your selected attributes.", ); } else { throw new Error("Error creating WebGL context."); @@ -261,10 +261,10 @@ function WebGLRenderer(parameters) { state = new WebGLState(_gl, extensions, utils, capabilities); state.scissor( - _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor() + _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor(), ); state.viewport( - _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor() + _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor(), ); info = new WebGLInfo(_gl); @@ -276,7 +276,7 @@ function WebGLRenderer(parameters) { properties, capabilities, utils, - info + info, ); attributes = new WebGLAttributes(_gl); geometries = new WebGLGeometries(_gl, attributes, info); @@ -290,20 +290,20 @@ function WebGLRenderer(parameters) { _this, state, objects, - _premultipliedAlpha + _premultipliedAlpha, ); bufferRenderer = new WebGLBufferRenderer( _gl, extensions, info, - capabilities + capabilities, ); indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info, - capabilities + capabilities, ); info.programs = programCache.programs; @@ -334,7 +334,7 @@ function WebGLRenderer(parameters) { var shadowMap = new WebGLShadowMap( _this, objects, - capabilities.maxTextureSize + capabilities.maxTextureSize, ); this.shadowMap = shadowMap; @@ -374,7 +374,7 @@ function WebGLRenderer(parameters) { this.getSize = function (target) { if (target === undefined) { console.warn( - "WebGLRenderer: .getsize() now requires a Vector2 as an argument" + "WebGLRenderer: .getsize() now requires a Vector2 as an argument", ); target = new Vector2(); @@ -386,7 +386,7 @@ function WebGLRenderer(parameters) { this.setSize = function (width, height, updateStyle) { if (vr.isPresenting()) { console.warn( - "THREE.WebGLRenderer: Can't change size while VR device is presenting." + "THREE.WebGLRenderer: Can't change size while VR device is presenting.", ); return; } @@ -408,7 +408,7 @@ function WebGLRenderer(parameters) { this.getDrawingBufferSize = function (target) { if (target === undefined) { console.warn( - "WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument" + "WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument", ); target = new Vector2(); @@ -432,7 +432,7 @@ function WebGLRenderer(parameters) { this.getCurrentViewport = function (target) { if (target === undefined) { console.warn( - "WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument" + "WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument", ); target = new Vector4(); @@ -453,7 +453,7 @@ function WebGLRenderer(parameters) { } state.viewport( - _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor() + _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor(), ); }; @@ -469,7 +469,7 @@ function WebGLRenderer(parameters) { } state.scissor( - _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor() + _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor(), ); }; @@ -528,7 +528,7 @@ function WebGLRenderer(parameters) { _canvas.removeEventListener( "webglcontextrestored", onContextRestore, - false + false, ); renderLists.dispose(); @@ -618,7 +618,7 @@ function WebGLRenderer(parameters) { _gl.FLOAT, false, 0, - 0 + 0, ); } @@ -633,7 +633,7 @@ function WebGLRenderer(parameters) { _gl.FLOAT, false, 0, - 0 + 0, ); } @@ -656,7 +656,7 @@ function WebGLRenderer(parameters) { _gl.FLOAT, false, 0, - 0 + 0, ); } @@ -673,7 +673,7 @@ function WebGLRenderer(parameters) { geometry, material, object, - group + group, ) { var frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0; @@ -811,7 +811,7 @@ function WebGLRenderer(parameters) { ) { if (extensions.get("ANGLE_instanced_arrays") === null) { console.error( - "THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays." + "THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.", ); return; } @@ -853,7 +853,7 @@ function WebGLRenderer(parameters) { if (data && data.isInstancedInterleavedBuffer) { state.enableAttributeAndDivisor( programAttribute, - data.meshPerAttribute + data.meshPerAttribute, ); if (geometry.maxInstancedCount === undefined) { @@ -870,13 +870,13 @@ function WebGLRenderer(parameters) { type, normalized, stride * bytesPerElement, - offset * bytesPerElement + offset * bytesPerElement, ); } else { if (geometryAttribute.isInstancedBufferAttribute) { state.enableAttributeAndDivisor( programAttribute, - geometryAttribute.meshPerAttribute + geometryAttribute.meshPerAttribute, ); if (geometry.maxInstancedCount === undefined) { @@ -894,7 +894,7 @@ function WebGLRenderer(parameters) { type, normalized, 0, - 0 + 0, ); } } else if (materialDefaultAttributeValues !== undefined) { @@ -984,21 +984,21 @@ function WebGLRenderer(parameters) { if (arguments[2] !== undefined) { console.warn( - "THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead." + "THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.", ); renderTarget = arguments[2]; } if (arguments[3] !== undefined) { console.warn( - "THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead." + "THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.", ); forceClear = arguments[3]; } if (!(camera && camera.isCamera)) { console.error( - "THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera." + "THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.", ); return; } @@ -1034,12 +1034,12 @@ function WebGLRenderer(parameters) { _this, scene, camera, - renderTarget || _currentRenderTarget + renderTarget || _currentRenderTarget, ); _projScreenMatrix.multiplyMatrices( camera.projectionMatrix, - camera.matrixWorldInverse + camera.matrixWorldInverse, ); _frustum.setFromMatrix(_projScreenMatrix); @@ -1047,7 +1047,7 @@ function WebGLRenderer(parameters) { _clippingEnabled = _clipping.init( this.clippingPlanes, _localClippingEnabled, - camera + camera, ); currentRenderList = renderLists.get(scene, camera); @@ -1174,7 +1174,7 @@ function WebGLRenderer(parameters) { material, groupOrder, _vector3.z, - null + null, ); } } @@ -1191,7 +1191,7 @@ function WebGLRenderer(parameters) { object.material, groupOrder, _vector3.z, - null + null, ); } else if (object.isMesh || object.isLine || object.isPoints) { if (object.isSkinnedMesh) { @@ -1222,7 +1222,7 @@ function WebGLRenderer(parameters) { groupMaterial, groupOrder, _vector3.z, - group + group, ); } } @@ -1233,7 +1233,7 @@ function WebGLRenderer(parameters) { material, groupOrder, _vector3.z, - null + null, ); } } @@ -1287,7 +1287,7 @@ function WebGLRenderer(parameters) { object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, - object.matrixWorld + object.matrixWorld, ); object.normalMatrix.getNormalMatrix(object.modelViewMatrix); @@ -1308,7 +1308,7 @@ function WebGLRenderer(parameters) { geometry, material, object, - group + group, ); } @@ -1331,7 +1331,7 @@ function WebGLRenderer(parameters) { fog, _clipping.numPlanes, _clipping.numIntersection, - object + object, ); var code = programCache.getProgramCode(material, parameters); @@ -1385,7 +1385,7 @@ function WebGLRenderer(parameters) { material, materialProperties.shader, parameters, - code + code, ); materialProperties.program = program; @@ -1478,7 +1478,7 @@ function WebGLRenderer(parameters) { material.clipShadows, camera, materialProperties, - useCache + useCache, ); } } @@ -1534,7 +1534,7 @@ function WebGLRenderer(parameters) { p_uniforms.setValue( _gl, "logDepthBufFC", - 2.0 / (Math.log(camera.far + 1.0) / Math.LN2) + 2.0 / (Math.log(camera.far + 1.0) / Math.LN2), ); } @@ -1563,7 +1563,7 @@ function WebGLRenderer(parameters) { if (uCamPos !== undefined) { uCamPos.setValue( _gl, - _vector3.setFromMatrixPosition(camera.matrixWorld) + _vector3.setFromMatrixPosition(camera.matrixWorld), ); } } @@ -1614,7 +1614,7 @@ function WebGLRenderer(parameters) { size, size, RGBAFormat, - FloatType + FloatType, ); boneTexture.needsUpdate = true; @@ -1627,7 +1627,7 @@ function WebGLRenderer(parameters) { _gl, "boneTexture", skeleton.boneTexture, - textures + textures, ); p_uniforms.setValue(_gl, "boneTextureSize", skeleton.boneTextureSize); } else { @@ -1640,12 +1640,12 @@ function WebGLRenderer(parameters) { p_uniforms.setValue( _gl, "toneMappingExposure", - _this.toneMappingExposure + _this.toneMappingExposure, ); p_uniforms.setValue( _gl, "toneMappingWhitePoint", - _this.toneMappingWhitePoint + _this.toneMappingWhitePoint, ); if (material.lights) { @@ -1728,7 +1728,7 @@ function WebGLRenderer(parameters) { _gl, materialProperties.uniformsList, m_uniforms, - textures + textures, ); } @@ -1737,7 +1737,7 @@ function WebGLRenderer(parameters) { _gl, materialProperties.uniformsList, m_uniforms, - textures + textures, ); material.uniformsNeedUpdate = false; } @@ -1795,7 +1795,7 @@ function WebGLRenderer(parameters) { uniforms.refractionRatio.value = material.refractionRatio; uniforms.maxMipLevel.value = properties.get( - material.envMap + material.envMap, ).__maxMipLevel; } @@ -2108,7 +2108,7 @@ function WebGLRenderer(parameters) { this.setRenderTarget = function ( renderTarget, activeCubeFace, - activeMipmapLevel + activeMipmapLevel, ) { _currentRenderTarget = renderTarget; _currentActiveCubeFace = activeCubeFace; @@ -2162,7 +2162,7 @@ function WebGLRenderer(parameters) { _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + (activeCubeFace || 0), textureProperties.__webglTexture, - activeMipmapLevel || 0 + activeMipmapLevel || 0, ); } }; @@ -2174,11 +2174,11 @@ function WebGLRenderer(parameters) { width, height, buffer, - activeCubeFaceIndex + activeCubeFaceIndex, ) { if (!(renderTarget && renderTarget.isWebGLRenderTarget)) { console.error( - "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget." + "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.", ); return; } @@ -2212,7 +2212,7 @@ function WebGLRenderer(parameters) { _gl.getParameter(_gl.IMPLEMENTATION_COLOR_READ_FORMAT) ) { console.error( - "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format." + "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.", ); return; } @@ -2235,7 +2235,7 @@ function WebGLRenderer(parameters) { ) ) { console.error( - "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type." + "THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.", ); return; } @@ -2259,12 +2259,12 @@ function WebGLRenderer(parameters) { height, utils.convert(textureFormat), utils.convert(textureType), - buffer + buffer, ); } } else { console.error( - "THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete." + "THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.", ); } } finally { @@ -2290,7 +2290,7 @@ function WebGLRenderer(parameters) { position.y, width, height, - 0 + 0, ); }; @@ -2298,7 +2298,7 @@ function WebGLRenderer(parameters) { position, srcTexture, dstTexture, - level + level, ) { var width = srcTexture.image.width; var height = srcTexture.image.height; @@ -2317,7 +2317,7 @@ function WebGLRenderer(parameters) { height, glFormat, glType, - srcTexture.image.data + srcTexture.image.data, ); } else { _gl.texSubImage2D( @@ -2327,14 +2327,14 @@ function WebGLRenderer(parameters) { position.y, glFormat, glType, - srcTexture.image + srcTexture.image, ); } }; if (typeof __THREE_DEVTOOLS__ !== "undefined") { __THREE_DEVTOOLS__.dispatchEvent( - new CustomEvent("observe", { detail: this }) + new CustomEvent("observe", { detail: this }), ); // eslint-disable-line no-undef } } diff --git a/src/test/fixtures/json-parser-in-typescript.js b/src/test/fixtures/json-parser-in-typescript.js index b81b6d820a..51636bfee9 100644 --- a/src/test/fixtures/json-parser-in-typescript.js +++ b/src/test/fixtures/json-parser-in-typescript.js @@ -3,5 +3,4 @@ // } & { // "twitter": "https://twitter.com/buildsghost" // } -export default class Foo { -} +export default class Foo {} diff --git a/src/test/fixtures/json-parser-in-typescript.ts b/src/test/fixtures/json-parser-in-typescript.ts index 8987a5f7fa..6b0f9ccc23 100644 --- a/src/test/fixtures/json-parser-in-typescript.ts +++ b/src/test/fixtures/json-parser-in-typescript.ts @@ -7,11 +7,11 @@ type EatWhitespace = string extends State type AddKeyValue< Memo extends Record, Key extends string, - Value extends any + Value extends any, > = Memo & { [K in Key]: Value }; type ParseJsonObject< State extends string, - Memo extends Record = {} + Memo extends Record = {}, > = string extends State ? ParserError<"ParseJsonObject got generic string type"> : EatWhitespace extends `}${infer State}` @@ -27,18 +27,20 @@ type ParseJsonObject< : ParserError<`ParseJsonValue returned unexpected value for: ${State}`> : ParserError<`ParseJsonObject received unexpected token: ${State}`> : ParserError<`ParseJsonObject received unexpected token: ${State}`>; -type ParseJsonArray = - string extends State - ? ParserError<"ParseJsonArray got generic string type"> +type ParseJsonArray< + State extends string, + Memo extends any[] = [], +> = string extends State + ? ParserError<"ParseJsonArray got generic string type"> + : EatWhitespace extends `]${infer State}` + ? [Memo, State] + : ParseJsonValue extends [infer Value, `${infer State}`] + ? EatWhitespace extends `,${infer State}` + ? ParseJsonArray, [...Memo, Value]> : EatWhitespace extends `]${infer State}` - ? [Memo, State] - : ParseJsonValue extends [infer Value, `${infer State}`] - ? EatWhitespace extends `,${infer State}` - ? ParseJsonArray, [...Memo, Value]> - : EatWhitespace extends `]${infer State}` - ? [[...Memo, Value], State] - : ParserError<`ParseJsonArray received unexpected token: ${State}`> - : ParserError<`ParseJsonValue returned unexpected value for: ${State}`>; + ? [[...Memo, Value], State] + : ParserError<`ParseJsonArray received unexpected token: ${State}`> + : ParserError<`ParseJsonValue returned unexpected value for: ${State}`>; type ParseJsonValue = string extends State ? ParserError<"ParseJsonValue got generic string type"> : EatWhitespace extends `null${infer State}` diff --git a/src/test/fixtures/main-field.ts b/src/test/fixtures/main-field.ts index 5f69721c8e..ad159b5187 100644 --- a/src/test/fixtures/main-field.ts +++ b/src/test/fixtures/main-field.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import Algolia from "algoliasearch/lite"; console.log(Algolia); diff --git a/src/test/fixtures/namespaced-validators.ts b/src/test/fixtures/namespaced-validators.ts index fcafcb139c..ec070e8ec5 100644 --- a/src/test/fixtures/namespaced-validators.ts +++ b/src/test/fixtures/namespaced-validators.ts @@ -65,7 +65,7 @@ for (let s of strings) { console.log( `"${s}" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" - } ${name}` + } ${name}`, ); } } diff --git a/src/test/fixtures/out.esbuild.js b/src/test/fixtures/out.esbuild.js index 8afef30066..1ebec8919f 100644 --- a/src/test/fixtures/out.esbuild.js +++ b/src/test/fixtures/out.esbuild.js @@ -1,2 +1 @@ -(() => { -})(); +(() => {})(); diff --git a/src/test/fixtures/simple-150x.jsx b/src/test/fixtures/simple-150x.jsx index 385d28bab8..64cb88b1b8 100644 --- a/src/test/fixtures/simple-150x.jsx +++ b/src/test/fixtures/simple-150x.jsx @@ -121,7 +121,7 @@ import { SPACING } from "../helpers/styles"; evt.preventDefault(); Router.pushRoute( - `/sign-up/verify?${qs.stringify({ email: this.state.email })}` + `/sign-up/verify?${qs.stringify({ email: this.state.email })}`, ); }; @@ -439,6 +439,6 @@ import { SPACING } from "../helpers/styles"; } const HomepageWithStore = withRedux(initStore, null, (dispatch) => - bindActionCreators({ updateEntities, setCurrentUser }, dispatch) + bindActionCreators({ updateEntities, setCurrentUser }, dispatch), )(LoginGate(Homepage)); })(); diff --git a/src/test/fixtures/simple.jsx b/src/test/fixtures/simple.jsx index 5ece00d596..63873fe8d4 100644 --- a/src/test/fixtures/simple.jsx +++ b/src/test/fixtures/simple.jsx @@ -119,7 +119,7 @@ class SignupForm extends React.Component { evt.preventDefault(); Router.pushRoute( - `/sign-up/verify?${qs.stringify({ email: this.state.email })}` + `/sign-up/verify?${qs.stringify({ email: this.state.email })}`, ); }; @@ -429,7 +429,7 @@ class Homepage extends React.Component { } const HomepageWithStore = withRedux(initStore, null, (dispatch) => - bindActionCreators({ updateEntities, setCurrentUser }, dispatch) + bindActionCreators({ updateEntities, setCurrentUser }, dispatch), )(LoginGate(Homepage)); export default HomepageWithStore; diff --git a/src/test/fixtures/tsconfig.json b/src/test/fixtures/tsconfig.json index 04a8d8eb9b..5bf130a294 100644 --- a/src/test/fixtures/tsconfig.json +++ b/src/test/fixtures/tsconfig.json @@ -1,9 +1,13 @@ { "compilerOptions": { "baseUrl": "/Users/jarredsumner/Code/bun/src/test/fixtures", + "strict": true, + "noImplicitAny": false, "paths": { - "components/*": ["components/*"] + "components/*": [ + "components/*" + ] }, "jsx": "preserve", } -} +} \ No newline at end of file diff --git a/src/test/fixtures/type-only-import.ts b/src/test/fixtures/type-only-import.ts index af7c11a12d..8ae8fda13e 100644 --- a/src/test/fixtures/type-only-import.ts +++ b/src/test/fixtures/type-only-import.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { Foo } from "bacon"; import React from "react"; import * as Boom from "react"; @@ -5,7 +6,7 @@ import { createElement } from "react"; export const hello: Foo = React.createElement("div"); export const bacon: (foo: (what: Foo) => (the: Foo) => Foo) => Foo = ( - foo: Foo + foo: Foo, ) => { return createElement(true); }; diff --git a/src/test/fixtures/typescript-is-turing-complete.ts b/src/test/fixtures/typescript-is-turing-complete.ts index 11f9d5be0c..5abd46b73d 100644 --- a/src/test/fixtures/typescript-is-turing-complete.ts +++ b/src/test/fixtures/typescript-is-turing-complete.ts @@ -1,3 +1,4 @@ +// @ts-nocheck type StringBool = "true" | "false"; interface AnyNumber { @@ -33,7 +34,7 @@ type Subt = { interface SubtResult< TIsOverflow extends StringBool, - TResult extends AnyNumber + TResult extends AnyNumber, > { isOverflowing: TIsOverflow; result: TResult; @@ -95,7 +96,7 @@ type Mod = { type Mod2< TNumber extends AnyNumber, TModNumber extends AnyNumber, - TSubtResult extends SubtResult + TSubtResult extends SubtResult, > = { true: TNumber; false: Mod; @@ -109,7 +110,7 @@ type Equals = Equals2< type Equals2< TNumber1 extends AnyNumber, TNumber2 extends AnyNumber, - TSubtResult extends SubtResult + TSubtResult extends SubtResult, > = { true: "false"; false: IsZero; diff --git a/test/bun.js/arraybuffersink.test.ts b/test/bun.js/arraybuffersink.test.ts index a658556a5e..a0c25ceb9d 100644 --- a/test/bun.js/arraybuffersink.test.ts +++ b/test/bun.js/arraybuffersink.test.ts @@ -11,14 +11,14 @@ describe("ArrayBufferSink", () => { [ ["abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"], new TextEncoder().encode( - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", ), "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", ], [ ["😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌"], new TextEncoder().encode( - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ], @@ -29,7 +29,7 @@ describe("ArrayBufferSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "abcdefghijklmnopqrstuvwxyz" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", @@ -43,7 +43,7 @@ describe("ArrayBufferSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "(rope) " + "abcdefghijklmnopqrstuvwxyz" + @@ -58,19 +58,22 @@ describe("ArrayBufferSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "(array) " + "abcdefghijklmnopqrstuvwxyz" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ], - ]; + ] as const; for (const [input, expected, label] of fixtures) { it(`${JSON.stringify(label)}`, () => { const sink = new ArrayBufferSink(); for (let i = 0; i < input.length; i++) { - sink.write(input[i]); + const el = input[i]; + if (typeof el !== "number") { + sink.write(el); + } } const output = new Uint8Array(sink.end()); for (let i = 0; i < expected.length; i++) { diff --git a/test/bun.js/bigint.test.js b/test/bun.js/bigint.test.js index 8842c49fb2..46ad50b84a 100644 --- a/test/bun.js/bigint.test.js +++ b/test/bun.js/bigint.test.js @@ -2,13 +2,13 @@ import { describe, expect, it } from "bun:test"; describe("BigInt", () => { it("compares correctly (literal)", () => { - expect(42n).toBe(42n); + expect(42n).toBe(42n); }); it("compares correctly (object)", () => { - expect(BigInt(42n)).toBe(BigInt(42n)); - expect(42n).toBe(BigInt(42n)); - expect(BigInt(Bun.inspect(42n).substring(0, 2))).toBe(BigInt(42n)); - expect(BigInt(42n).valueOf()).toBe(BigInt(42n)); + expect(BigInt(42n)).toBe(BigInt(42n)); + expect(42n).toBe(BigInt(42n)); + expect(BigInt(Bun.inspect(42n).substring(0, 2))).toBe(BigInt(42n)); + expect(BigInt(42n).valueOf()).toBe(BigInt(42n)); }); -}) +}); diff --git a/test/bun.js/body-mixin-errors.test.ts b/test/bun.js/body-mixin-errors.test.ts index cec812c3fc..f57bbc56cf 100644 --- a/test/bun.js/body-mixin-errors.test.ts +++ b/test/bun.js/body-mixin-errors.test.ts @@ -10,7 +10,7 @@ describe("body-mixin-errors", () => { try { await res.text(); throw new Error("should not get here"); - } catch (e) { + } catch (e: any) { expect(e.message).toBe("Body already used"); } }); diff --git a/test/bun.js/body-stream.test.ts b/test/bun.js/body-stream.test.ts index ec0130fbfc..bc6dc10f8f 100644 --- a/test/bun.js/body-stream.test.ts +++ b/test/bun.js/body-stream.test.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { file, gc, serve, ServeOptions } from "bun"; import { afterEach, describe, expect, it, test } from "bun:test"; import { readFileSync } from "fs"; @@ -15,9 +16,9 @@ var port = 4020; ]; const useRequestObjectValues = [true, false]; - for (let RequestPrototyeMixin of BodyMixin) { + for (let RequestPrototypeMixin of BodyMixin) { for (let useRequestObject of useRequestObjectValues) { - describe(`Request.prototoype.${RequestPrototyeMixin.name}() ${ + describe(`Request.prototoype.${RequestPrototypeMixin.name}() ${ useRequestObject ? "fetch(req)" : "fetch(url)" }`, () => { const inputFixture = [ @@ -33,42 +34,43 @@ var port = 4020; [ JSON.stringify( "EXTREMELY LONG VERY LONG STRING WOW SO LONG YOU WONT BELIEVE IT! ".repeat( - 100 - ) + 100, + ), ), Buffer.from( JSON.stringify( "EXTREMELY LONG VERY LONG STRING WOW SO LONG YOU WONT BELIEVE IT! ".repeat( - 100 - ) - ) + 100, + ), + ), ), ], [ JSON.stringify( "EXTREMELY LONG 🔥 UTF16 🔥 VERY LONG STRING WOW SO LONG YOU WONT BELIEVE IT! ".repeat( - 100 - ) + 100, + ), ), Buffer.from( JSON.stringify( "EXTREMELY LONG 🔥 UTF16 🔥 VERY LONG STRING WOW SO LONG YOU WONT BELIEVE IT! ".repeat( - 100 - ) - ) + 100, + ), + ), ), ], ]; + for (const [name, input] of inputFixture) { test(`${name.slice( 0, - Math.min(name.length ?? name.byteLength, 64) + Math.min(name.length ?? name.byteLength, 64), )}`, async () => { await runInServer( { async fetch(req) { - var result = await RequestPrototyeMixin.call(req); - if (RequestPrototyeMixin === Request.prototype.json) { + var result = await RequestPrototypeMixin.call(req); + if (RequestPrototypeMixin === Request.prototype.json) { result = JSON.stringify(result); } if (typeof result === "string") { @@ -76,15 +78,15 @@ var port = 4020; expect(result).toBe(name); } else if (result && result instanceof Blob) { expect(result.size).toBe( - new TextEncoder().encode(name).byteLength + new TextEncoder().encode(name).byteLength, ); expect(await result.text()).toBe(name); } else { expect(result.byteLength).toBe( - Buffer.from(input).byteLength + Buffer.from(input).byteLength, ); expect(Bun.SHA1.hash(result, "base64")).toBe( - Bun.SHA1.hash(input, "base64") + Bun.SHA1.hash(input, "base64"), ); } return new Response(result, { @@ -106,7 +108,7 @@ var port = 4020; headers: { "content-type": "text/plain", }, - }) + }), ); } else { response = await fetch(url, { @@ -120,7 +122,7 @@ var port = 4020; expect(response.status).toBe(200); expect(response.headers.get("content-length")).toBe( - String(Buffer.from(input).byteLength) + String(Buffer.from(input).byteLength), ); expect(response.headers.get("content-type")).toBe("text/plain"); expect(await response.text()).toBe(name); @@ -137,7 +139,7 @@ var port = 4020; "content-type": "text/plain", "x-counter": i, }, - }) + }), ); } else { promises[i] = await fetch(url, { @@ -156,15 +158,15 @@ var port = 4020; const response = results[i]; expect(response.status).toBe(200); expect(response.headers.get("content-length")).toBe( - String(Buffer.from(input).byteLength) + String(Buffer.from(input).byteLength), ); expect(response.headers.get("content-type")).toBe( - "text/plain" + "text/plain", ); expect(response.headers.get("x-counter")).toBe(String(i)); expect(await response.text()).toBe(name); } - } + }, ); }); } @@ -175,7 +177,7 @@ var port = 4020; async function runInServer( opts: ServeOptions, - cb: (url: string) => void | Promise + cb: (url: string) => void | Promise, ) { var server; server = Bun.serve({ @@ -276,7 +278,7 @@ describe("reader", function () { new Float32Array(bytes).subarray(1), new Float32Array(bytes).subarray( 0, - new Float32Array(bytes).byteLength - 1 + new Float32Array(bytes).byteLength - 1, ), new Int16Array(bytes).subarray(0, 1), new Int32Array(bytes).subarray(0, 1), @@ -295,7 +297,7 @@ describe("reader", function () { huge instanceof Blob ? Bun.SHA1.hash( new Uint8Array(await huge.arrayBuffer()), - "base64" + "base64", ) : Bun.SHA1.hash(huge, "base64"); const expectedSize = @@ -308,14 +310,14 @@ describe("reader", function () { expect(req.headers.get("x-custom")).toBe("hello"); expect(req.headers.get("content-type")).toBe("text/plain"); expect(req.headers.get("user-agent")).toBe( - navigator.userAgent + navigator.userAgent, ); gc(); expect(req.headers.get("x-custom")).toBe("hello"); expect(req.headers.get("content-type")).toBe("text/plain"); expect(req.headers.get("user-agent")).toBe( - navigator.userAgent + navigator.userAgent, ); var reader = req.body.getReader(); @@ -330,12 +332,12 @@ describe("reader", function () { gc(); expect(out.size).toBe(expectedSize); expect(Bun.SHA1.hash(await out.arrayBuffer(), "base64")).toBe( - expectedHash + expectedHash, ); expect(req.headers.get("x-custom")).toBe("hello"); expect(req.headers.get("content-type")).toBe("text/plain"); expect(req.headers.get("user-agent")).toBe( - navigator.userAgent + navigator.userAgent, ); gc(); return new Response(out, { @@ -361,7 +363,7 @@ describe("reader", function () { huge = undefined; expect(response.status).toBe(200); const response_body = new Uint8Array( - await response.arrayBuffer() + await response.arrayBuffer(), ); expect(response_body.byteLength).toBe(expectedSize); @@ -370,7 +372,7 @@ describe("reader", function () { gc(); expect(response.headers.get("content-type")).toBe("text/plain"); gc(); - } + }, ); expect(called).toBe(true); gc(); @@ -392,7 +394,7 @@ describe("reader", function () { huge instanceof Blob ? Bun.SHA1.hash( new Uint8Array(await huge.arrayBuffer()), - "base64" + "base64", ) : Bun.SHA1.hash(huge, "base64"); const expectedSize = @@ -415,19 +417,19 @@ describe("reader", function () { expect(req.headers.get("x-custom")).toBe("hello"); expect(req.headers.get("content-type")).toBe( - "text/plain" + "text/plain", ); expect(req.headers.get("user-agent")).toBe( - navigator.userAgent + navigator.userAgent, ); gc(); expect(req.headers.get("x-custom")).toBe("hello"); expect(req.headers.get("content-type")).toBe( - "text/plain" + "text/plain", ); expect(req.headers.get("user-agent")).toBe( - navigator.userAgent + navigator.userAgent, ); const direct = { @@ -464,7 +466,7 @@ describe("reader", function () { new ReadableStream(isDirectStream ? direct : web), { headers: req.headers, - } + }, ); } catch (e) { console.error(e); @@ -486,26 +488,26 @@ describe("reader", function () { huge = undefined; expect(response.status).toBe(200); const response_body = new Uint8Array( - await response.arrayBuffer() + await response.arrayBuffer(), ); expect(response_body.byteLength).toBe(expectedSize); expect(Bun.SHA1.hash(response_body, "base64")).toBe( - expectedHash + expectedHash, ); gc(); if (!response.headers.has("content-type")) { console.error( - Object.fromEntries(response.headers.entries()) + Object.fromEntries(response.headers.entries()), ); } expect(response.headers.get("content-type")).toBe( - "text/plain" + "text/plain", ); gc(); - } + }, ); expect(called).toBe(true); gc(); diff --git a/test/bun.js/buffer.test.js b/test/bun.js/buffer.test.js index 4433cf64fd..5a367f7258 100644 --- a/test/bun.js/buffer.test.js +++ b/test/bun.js/buffer.test.js @@ -9,7 +9,7 @@ it("Buffer.toJSON()", () => { JSON.stringify({ type: "Buffer", data: [104, 101, 108, 108, 111], - }) + }), ); }); @@ -26,7 +26,7 @@ it("buffer", () => { expect(buf.toString("utf8", 0, "hello world ".length)).toBe("hello world "); gc(); expect(buf.toString("base64url", 0, "hello world ".length)).toBe( - btoa("hello world ") + btoa("hello world "), ); gc(); expect(buf instanceof Uint8Array).toBe(true); @@ -65,7 +65,7 @@ it("Buffer", () => { it("Buffer.byteLength", () => { expect(Buffer.byteLength("😀😃😄😁😆😅😂🤣☺️😊😊😇")).toBe( - new TextEncoder().encode("😀😃😄😁😆😅😂🤣☺️😊😊😇").byteLength + new TextEncoder().encode("😀😃😄😁😆😅😂🤣☺️😊😊😇").byteLength, ); }); @@ -120,7 +120,7 @@ it("Buffer.toBuffer works", () => { expect(buf.toString("utf8", 0, "hello world ".length)).toBe("hello world "); gc(); expect(buf.toString("base64url", 0, "hello world ".length)).toBe( - btoa("hello world ") + btoa("hello world "), ); gc(); @@ -149,10 +149,10 @@ it("writeInt", () => { it("Buffer.from", () => { expect(Buffer.from("hello world").toString("utf8")).toBe("hello world"); expect(Buffer.from("hello world", "ascii").toString("utf8")).toBe( - "hello world" + "hello world", ); expect(Buffer.from("hello world", "latin1").toString("utf8")).toBe( - "hello world" + "hello world", ); gc(); expect(Buffer.from([254]).join(",")).toBe("254"); @@ -166,15 +166,15 @@ it("Buffer.from", () => { expect(Buffer.from(123).join(",")).toBe(Uint8Array.from(123).join(",")); expect(Buffer.from({ length: 124 }).join(",")).toBe( - Uint8Array.from({ length: 124 }).join(",") + Uint8Array.from({ length: 124 }).join(","), ); expect(Buffer.from(new ArrayBuffer(1024), 0, 512).join(",")).toBe( - new Uint8Array(512).join(",") + new Uint8Array(512).join(","), ); expect(Buffer.from(new Buffer(new ArrayBuffer(1024), 0, 512)).join(",")).toBe( - new Uint8Array(512).join(",") + new Uint8Array(512).join(","), ); gc(); }); @@ -254,7 +254,7 @@ it("Buffer.compare", () => { [buf.slice(i), Buffer.from(s.slice(i))], [buf.slice(0, i), Buffer.from(s.slice(0, i))], [buf.slice(-i), Buffer.from(s.slice(-i))], - [buf.slice(0, -i), Buffer.from(s.slice(0, -i))] + [buf.slice(0, -i), Buffer.from(s.slice(0, -i))], ); } @@ -375,14 +375,14 @@ it("Buffer.concat", () => { array3.fill(300); gc(); expect(Buffer.concat([array1, array2, array3]).join("")).toBe( - array1.join("") + array2.join("") + array3.join("") + array1.join("") + array2.join("") + array3.join(""), ); expect(Buffer.concat([array1, array2, array3], 222).length).toBe(222); expect( - Buffer.concat([array1, array2, array3], 222).subarray(0, 128).join("") + Buffer.concat([array1, array2, array3], 222).subarray(0, 128).join(""), ).toBe("100".repeat(128)); expect( - Buffer.concat([array1, array2, array3], 222).subarray(129, 222).join("") + Buffer.concat([array1, array2, array3], 222).subarray(129, 222).join(""), ).toBe("200".repeat(222 - 129)); }); diff --git a/test/bun.js/bun-write.test.js b/test/bun.js/bun-write.test.js index e78c05e661..e7d724572f 100644 --- a/test/bun.js/bun-write.test.js +++ b/test/bun.js/bun-write.test.js @@ -6,14 +6,14 @@ import { gcTick } from "./gc"; it("Bun.write blob", async () => { await Bun.write( Bun.file("/tmp/response-file.test.txt"), - Bun.file(path.join(import.meta.dir, "fetch.js.txt")) + Bun.file(path.join(import.meta.dir, "fetch.js.txt")), ); await gcTick(); await Bun.write(Bun.file("/tmp/response-file.test.txt"), "blah blah blha"); await gcTick(); await Bun.write( Bun.file("/tmp/response-file.test.txt"), - new Uint32Array(1024) + new Uint32Array(1024), ); await gcTick(); await Bun.write("/tmp/response-file.test.txt", new Uint32Array(1024)); @@ -21,8 +21,8 @@ it("Bun.write blob", async () => { expect( await Bun.write( new TextEncoder().encode("/tmp/response-file.test.txt"), - new Uint32Array(1024) - ) + new Uint32Array(1024), + ), ).toBe(new Uint32Array(1024).byteLength); await gcTick(); }); @@ -32,7 +32,7 @@ describe("large file", () => { [ `/tmp/bun-test-large-file-${Date.now()}.txt`, "https://www.iana.org/assignments/media-types/media-types.xhtml,".repeat( - 10000 + 10000, ), ], ]; @@ -59,8 +59,8 @@ describe("large file", () => { expect(written).toBe(bytes.byteLength); expect( new Buffer(await Bun.file(filename + ".bytes").arrayBuffer()).equals( - bytes - ) + bytes, + ), ).toBe(true); try { @@ -130,7 +130,7 @@ it("Bun.file -> Bun.file", async () => { { const result = await Bun.write( Bun.file("/tmp/fetch.js.out"), - Bun.file("/tmp/fetch.js.in") + Bun.file("/tmp/fetch.js.in"), ); await gcTick(); expect(await Bun.file("/tmp/fetch.js.out").text()).toBe(text); @@ -140,10 +140,10 @@ it("Bun.file -> Bun.file", async () => { { await Bun.write( Bun.file("/tmp/fetch.js.in").slice(0, (text.length / 2) | 0), - Bun.file("/tmp/fetch.js.out") + Bun.file("/tmp/fetch.js.out"), ); expect(await Bun.file("/tmp/fetch.js.in").text()).toBe( - text.substring(0, (text.length / 2) | 0) + text.substring(0, (text.length / 2) | 0), ); } @@ -266,8 +266,8 @@ it("Bun.write(Bun.stdout, new TextEncoder().encode('Bun.write STDOUT TEST'))", a expect( await Bun.write( Bun.stdout, - new TextEncoder().encode("\nBun.write STDOUT TEST\n\n") - ) + new TextEncoder().encode("\nBun.write STDOUT TEST\n\n"), + ), ).toBe(24); }); @@ -275,8 +275,8 @@ it("Bun.write(Bun.stderr, 'new TextEncoder().encode(Bun.write STDERR TEST'))", a expect( await Bun.write( Bun.stderr, - new TextEncoder().encode("\nBun.write STDERR TEST\n\n") - ) + new TextEncoder().encode("\nBun.write STDERR TEST\n\n"), + ), ).toBe(24); }); @@ -294,6 +294,6 @@ it("Bun.write('output.html', HTMLRewriter.transform(Bun.file)))", async () => { const outpath = `/tmp/html-rewriter.${Date.now()}.html`; await Bun.write(outpath, output); expect(await Bun.file(outpath).text()).toBe( - "
it worked!
" + "
it worked!
", ); }); diff --git a/test/bun.js/bundled/tsconfig.json b/test/bun.js/bundled/tsconfig.json index 358cb55268..3ccb11ae46 100644 --- a/test/bun.js/bundled/tsconfig.json +++ b/test/bun.js/bundled/tsconfig.json @@ -1,6 +1,6 @@ { "compilerOptions": { "paths": {}, - "baseUrl": "." + "baseUrl": ".", } -} +} \ No newline at end of file diff --git a/test/bun.js/child_process-node.test.js b/test/bun.js/child_process-node.test.js index 3ac9b2fd17..17b2c4cfbe 100644 --- a/test/bun.js/child_process-node.test.js +++ b/test/bun.js/child_process-node.test.js @@ -62,7 +62,7 @@ describe("ChildProcess.spawn()", () => { // message: // 'The "options" argument must be of type object.' + // `${common.invalidArgTypeHelper(options)}`, - } + }, ); }); }); @@ -81,7 +81,7 @@ describe("ChildProcess.spawn()", () => { // message: // 'The "options.file" property must be of type string.' + // `${common.invalidArgTypeHelper(file)}`, - } + }, ); }); }); @@ -104,7 +104,7 @@ describe("ChildProcess.spawn()", () => { // message: // 'The "options.envPairs" property must be an instance of Array.' + // common.invalidArgTypeHelper(envPairs), - } + }, ); }); }); @@ -124,7 +124,7 @@ describe("ChildProcess.spawn()", () => { // message: // 'The "options.args" property must be an instance of Array.' + // common.invalidArgTypeHelper(args), - } + }, ); }); }); @@ -153,7 +153,7 @@ describe("ChildProcess.spawn", () => { () => { child.kill("foo"); }, - { code: "ERR_UNKNOWN_SIGNAL", name: "TypeError" } + { code: "ERR_UNKNOWN_SIGNAL", name: "TypeError" }, ); }); @@ -194,7 +194,7 @@ describe("ChildProcess spawn bad stdio", () => { strictEqual(stdout, ""); strictEqual(stderr, ""); }, - done + done, ); }); @@ -207,7 +207,7 @@ describe("ChildProcess spawn bad stdio", () => { strictEqual(stdout, ""); strictEqual(stderr, ""); }, - done + done, ); child.emit("error", error); @@ -221,7 +221,7 @@ describe("ChildProcess spawn bad stdio", () => { strictEqual(stdout, ""); strictEqual(stderr, ""); }, - done + done, ); }); }); @@ -234,7 +234,7 @@ describe("child_process cwd", () => { function testCwd( options, { expectPidType, expectCode = 0, expectData }, - done = () => {} + done = () => {}, ) { const createDone = createDoneDotAll(done); const { mustCall } = createCallCheckCtx(createDone(1500)); @@ -268,7 +268,7 @@ describe("child_process cwd", () => { "close", mustCall(() => { expectData && strictEqual(data.trim(), expectData); - }) + }), ); return child; @@ -326,7 +326,7 @@ describe("child_process cwd", () => { expectCode: 0, expectData: platformTmpDir, }, - createDone(1500) + createDone(1500), ); const shouldExistDir = "/dev"; testCwd( @@ -336,7 +336,7 @@ describe("child_process cwd", () => { expectCode: 0, expectData: shouldExistDir, }, - createDone(1500) + createDone(1500), ); testCwd( { cwd: Bun.pathToFileURL(tmpdir.path) }, @@ -345,7 +345,7 @@ describe("child_process cwd", () => { expectCode: 0, expectData: platformTmpDir, }, - createDone(1500) + createDone(1500), ); }); @@ -375,7 +375,7 @@ describe("child_process default options", () => { assertOk( response.includes(`TMPDIR=${process.env.TMPDIR}`), "spawn did not use process.env as default " + - `(process.env.TMPDIR = ${process.env.TMPDIR})` + `(process.env.TMPDIR = ${process.env.TMPDIR})`, ); done(); }); @@ -398,7 +398,7 @@ describe("child_process double pipe", () => { if (!grep.stdin.write(data)) { echo.stdout.pause(); } - }) + }), ); // TODO(Derrick): We don't implement the full API for this yet, @@ -415,28 +415,28 @@ describe("child_process double pipe", () => { mustCall(() => { debug("echo stdout end"); grep.stdin.end(); - }) + }), ); echo.on( "exit", mustCall(() => { debug("echo exit"); - }) + }), ); grep.on( "exit", mustCall(() => { debug("grep exit"); - }) + }), ); sed.on( "exit", mustCall(() => { debug("sed exit"); - }) + }), ); // pipe grep | sed @@ -447,7 +447,7 @@ describe("child_process double pipe", () => { if (!sed.stdin.write(data)) { grep.stdout.pause(); } - }) + }), ); // // TODO(@jasnell): This does not appear to ever be @@ -462,7 +462,7 @@ describe("child_process double pipe", () => { mustCall((code) => { debug("grep stdout end"); sed.stdin.end(); - }) + }), ); let result = ""; @@ -473,7 +473,7 @@ describe("child_process double pipe", () => { mustCallAtLeast((data) => { result += data.toString("utf8"); debug(data); - }) + }), ); sed.stdout.on( @@ -481,7 +481,7 @@ describe("child_process double pipe", () => { mustCall(() => { debug("result: " + result); strictEqual(result, `hellO\nnOde\nwOrld\n`); - }) + }), ); }); }); diff --git a/test/bun.js/child_process.test.ts b/test/bun.js/child_process.test.ts index 536f4947b6..fecc5b961f 100644 --- a/test/bun.js/child_process.test.ts +++ b/test/bun.js/child_process.test.ts @@ -57,7 +57,9 @@ describe("spawn()", () => { let child; let child2; try { + // @ts-ignore child = spawn(123); + // @ts-ignore child2 = spawn(["echo", "hello"]); } catch (e) {} expect(!!child).toBe(false); @@ -203,12 +205,17 @@ describe("spawn()", () => { describe("execFile()", () => { it("should execute a file", async () => { const result: Buffer = await new Promise((resolve, reject) => { - execFile("bun", ["-v"], (error, stdout, stderr) => { - if (error) { - reject(error); - } - resolve(stdout); - }); + execFile( + "bun", + ["-v"], + { encoding: "buffer" }, + (error, stdout, stderr) => { + if (error) { + reject(error); + } + resolve(stdout); + }, + ); }); expect(SEMVER_REGEX.test(result.toString().trim())).toBe(true); }); @@ -217,7 +224,7 @@ describe("execFile()", () => { describe("exec()", () => { it("should execute a command in a shell", async () => { const result: Buffer = await new Promise((resolve, reject) => { - exec("bun -v", (error, stdout, stderr) => { + exec("bun -v", { encoding: "buffer" }, (error, stdout, stderr) => { if (error) { reject(error); } diff --git a/test/bun.js/concat.test.js b/test/bun.js/concat.test.js index a965fdb94a..35cec4f8b3 100644 --- a/test/bun.js/concat.test.js +++ b/test/bun.js/concat.test.js @@ -28,19 +28,19 @@ describe("concat", () => { it("works with one element", () => { expect(concatToString([new Uint8Array([123])])).toBe( - polyfillToString([new Uint8Array([123])]) + polyfillToString([new Uint8Array([123])]), ); }); it("works with two elements", () => { expect( - concatToString([Uint8Array.from([123]), Uint8Array.from([456])]) + concatToString([Uint8Array.from([123]), Uint8Array.from([456])]), ).toBe(polyfillToString([Uint8Array.from([123]), Uint8Array.from([456])])); }); it("works with mix of ArrayBuffer and TypedArray elements", () => { expect( - concatToString([Uint8Array.from([123]).buffer, Uint8Array.from([456])]) + concatToString([Uint8Array.from([123]).buffer, Uint8Array.from([456])]), ).toBe(polyfillToString([Uint8Array.from([123]), Uint8Array.from([456])])); }); }); diff --git a/test/bun.js/console-log.js b/test/bun.js/console-log.js index 5c110f8b06..6252d67731 100644 --- a/test/bun.js/console-log.js +++ b/test/bun.js/console-log.js @@ -36,7 +36,7 @@ console.time("Check"); console.log( "Is it a bug or a feature that formatting numbers like %d is colored", - 123 + 123, ); console.log(globalThis); @@ -46,7 +46,7 @@ console.log( "456", "%s", "What", - "okay" + "okay", ); const infinteLoop = { @@ -57,4 +57,4 @@ const infinteLoop = { infinteLoop.bar = infinteLoop; console.log(infinteLoop, "am"); -console.log(new Array(4).fill({})) +console.log(new Array(4).fill({})); diff --git a/test/bun.js/decorators.test.ts b/test/bun.js/decorators.test.ts index 545030ef13..5549041078 100644 --- a/test/bun.js/decorators.test.ts +++ b/test/bun.js/decorators.test.ts @@ -1,3 +1,4 @@ +// @ts-nocheck import { test, expect } from "bun:test"; test("decorator order of evaluation", () => { @@ -264,7 +265,7 @@ test("parameter decorators", () => { two: string, three: boolean, @d1 @d2 width: number, - @d3 height: number + @d3 height: number, ) { this.width = width; this.height = height; @@ -336,7 +337,7 @@ test("parameter decorators", () => { constructor( @m1 private x: number, @m2 public y: boolean, - @m3 protected z: string + @m3 protected z: string, ) {} } diff --git a/test/bun.js/escapeHTML.test.js b/test/bun.js/escapeHTML.test.js index 5ea202a758..af119c6e38 100644 --- a/test/bun.js/escapeHTML.test.js +++ b/test/bun.js/escapeHTML.test.js @@ -14,10 +14,10 @@ describe("escapeHTML", () => { // 8. Returns the same string when there's no need to escape it("works", () => { expect(escapeHTML("absolutely nothing to do here")).toBe( - "absolutely nothing to do here" + "absolutely nothing to do here", ); expect(escapeHTML("")).toBe( - "<script>alert(1)</script>" + "<script>alert(1)</script>", ); expect(escapeHTML("<")).toBe("<"); expect(escapeHTML(">")).toBe(">"); @@ -36,66 +36,66 @@ describe("escapeHTML", () => { expect(escapeHTML("" + "lalala")).toBe( - "lalala<script>alert(1)</script>lalala" + "lalala<script>alert(1)</script>lalala", ); expect(escapeHTML("" + "lalala")).toBe( - "<script>alert(1)</script>lalala" + "<script>alert(1)</script>lalala", ); expect(escapeHTML("lalala" + "")).toBe( - "lalala" + "<script>alert(1)</script>" + "lalala" + "<script>alert(1)</script>", ); expect(escapeHTML("What does 😊 mean?")).toBe("What does 😊 mean?"); const output = escapeHTML("What does 😊 mean in text?")).toBe( - "<div>What does 😊 mean in text?" + "<div>What does 😊 mean in text?", ); expect( escapeHTML( - ("lalala" + "" + "lalala").repeat(900) - ) + ("lalala" + "" + "lalala").repeat(900), + ), ).toBe("lalala<script>alert(1)</script>lalala".repeat(900)); expect( - escapeHTML(("" + "lalala").repeat(900)) + escapeHTML(("" + "lalala").repeat(900)), ).toBe("<script>alert(1)</script>lalala".repeat(900)); expect( - escapeHTML(("lalala" + "").repeat(900)) + escapeHTML(("lalala" + "").repeat(900)), ).toBe(("lalala" + "<script>alert(1)</script>").repeat(900)); // the positions of the unicode codepoint are important // our simd code for U16 is at 8 bytes, so we need to especially check the boundaries expect( - escapeHTML("😊lalala" + "" + "lalala") + escapeHTML("😊lalala" + "" + "lalala"), ).toBe("😊lalala<script>alert(1)</script>lalala"); expect(escapeHTML("" + "lalala")).toBe( - "<script>😊alert(1)</script>lalala" + "<script>😊alert(1)</script>lalala", ); expect(escapeHTML("" + "lalala")).toBe( - "<script>alert(1)😊</script>lalala" + "<script>alert(1)😊</script>lalala", ); expect(escapeHTML("" + "😊lalala")).toBe( - "<script>alert(1)</script>😊lalala" + "<script>alert(1)</script>😊lalala", ); expect(escapeHTML("" + "lal😊ala")).toBe( - "<script>alert(1)</script>lal😊ala" + "<script>alert(1)</script>lal😊ala", ); expect( - escapeHTML("" + "lal😊ala".repeat(10)) + escapeHTML("" + "lal😊ala".repeat(10)), ).toBe("<script>alert(1)</script>" + "lal😊ala".repeat(10)); for (let i = 1; i < 10; i++) expect(escapeHTML("" + "la😊".repeat(i))).toBe( - "<script>alert(1)</script>" + "la😊".repeat(i) + "<script>alert(1)</script>" + "la😊".repeat(i), ); expect(escapeHTML("la😊" + "")).toBe( - "la😊" + "<script>alert(1)</script>" + "la😊" + "<script>alert(1)</script>", ); expect( - escapeHTML(("lalala" + "😊").repeat(1)) + escapeHTML(("lalala" + "😊").repeat(1)), ).toBe(("lalala" + "<script>alert(1)</script>😊").repeat(1)); expect(escapeHTML("😊".repeat(100))).toBe("😊".repeat(100)); diff --git a/test/bun.js/event-emitter.test.ts b/test/bun.js/event-emitter.test.ts index 952805cf8d..f7c73e66a6 100644 --- a/test/bun.js/event-emitter.test.ts +++ b/test/bun.js/event-emitter.test.ts @@ -1,4 +1,5 @@ import { test, describe, expect } from "bun:test"; +import fs from "node:fs"; // this is also testing that imports with default and named imports in the same statement work // our transpiler transform changes this to a var with import.meta.require diff --git a/test/bun.js/fetch.test.js b/test/bun.js/fetch.test.js index 603cdfb3c4..ebcdcbc8b0 100644 --- a/test/bun.js/fetch.test.js +++ b/test/bun.js/fetch.test.js @@ -5,7 +5,7 @@ import { gc } from "./gc"; const exampleFixture = fs.readFileSync( import.meta.path.substring(0, import.meta.path.lastIndexOf("/")) + "/fetch.js.txt", - "utf8" + "utf8", ); describe("fetch", () => { @@ -74,7 +74,7 @@ function testBlobInterface(blobbyConstructor, hasBlobFn) { var response = blobbyConstructor(JSON.stringify(jsonObject)); if (withGC) gc(); expect(JSON.stringify(await response.json())).toBe( - JSON.stringify(jsonObject) + JSON.stringify(jsonObject), ); if (withGC) gc(); }); @@ -84,11 +84,11 @@ function testBlobInterface(blobbyConstructor, hasBlobFn) { } arrayBuffer -> json${withGC ? " (with gc) " : ""}`, async () => { if (withGC) gc(); var response = blobbyConstructor( - new TextEncoder().encode(JSON.stringify(jsonObject)) + new TextEncoder().encode(JSON.stringify(jsonObject)), ); if (withGC) gc(); expect(JSON.stringify(await response.json())).toBe( - JSON.stringify(jsonObject) + JSON.stringify(jsonObject), ); if (withGC) gc(); }); @@ -108,7 +108,7 @@ function testBlobInterface(blobbyConstructor, hasBlobFn) { } arrayBuffer -> text${withGC ? " (with gc) " : ""}`, async () => { if (withGC) gc(); var response = blobbyConstructor( - new TextEncoder().encode(JSON.stringify(jsonObject)) + new TextEncoder().encode(JSON.stringify(jsonObject)), ); if (withGC) gc(); expect(await response.text()).toBe(JSON.stringify(jsonObject)); @@ -144,7 +144,7 @@ function testBlobInterface(blobbyConstructor, hasBlobFn) { if (withGC) gc(); var response = blobbyConstructor( - new TextEncoder().encode(JSON.stringify(jsonObject)) + new TextEncoder().encode(JSON.stringify(jsonObject)), ); if (withGC) gc(); @@ -219,13 +219,13 @@ describe("Blob", () => { [ new Blob([ new TextEncoder().encode( - "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 ☺️ 😊 😇 🙂 🙃 😉 😌 😍 🥰 😘 😗 😙 😚 😋 😛 😝 😜 🤪 🤨 🧐 🤓 😎 🥸 🤩 🥳" + "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 ☺️ 😊 😇 🙂 🙃 😉 😌 😍 🥰 😘 😗 😙 😚 😋 😛 😝 😜 🤪 🤨 🧐 🤓 😎 🥸 🤩 🥳", ), ]), ], [ new TextEncoder().encode( - "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 ☺️ 😊 😇 🙂 🙃 😉 😌 😍 🥰 😘 😗 😙 😚 😋 😛 😝 😜 🤪 🤨 🧐 🤓 😎 🥸 🤩 🥳" + "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 ☺️ 😊 😇 🙂 🙃 😉 😌 😍 🥰 😘 😗 😙 😚 😋 😛 😝 😜 🤪 🤨 🧐 🤓 😎 🥸 🤩 🥳", ), ], ]; @@ -253,7 +253,7 @@ describe("Blob", () => { .split("") .map((a) => a.charCodeAt(0))}, received: ${res .split("") - .map((a) => a.charCodeAt(0))}` + .map((a) => a.charCodeAt(0))}`, ); } @@ -274,7 +274,7 @@ describe("Blob", () => { expect( await combined .slice(str.indexOf(part), str.indexOf(part) + part.length) - .text() + .text(), ).toBe(part); if (withGC) gc(); } @@ -284,7 +284,7 @@ describe("Blob", () => { expect( await combined .slice(str.indexOf(part), str.indexOf(part) + part.length) - .text() + .text(), ).toBe(part); if (withGC) gc(); } @@ -358,7 +358,7 @@ describe("Response", () => { let response = Response.json("hello"); expect(response.type).toBe("basic"); expect(response.headers.get("content-type")).toBe( - "application/json;charset=utf-8" + "application/json;charset=utf-8", ); expect(response.status).toBe(200); }); @@ -366,7 +366,7 @@ describe("Response", () => { let response = Response.json("hello", 407); expect(response.type).toBe("basic"); expect(response.headers.get("content-type")).toBe( - "application/json;charset=utf-8" + "application/json;charset=utf-8", ); expect(response.status).toBe(407); }); @@ -485,7 +485,7 @@ describe("Request", () => { testBlobInterface( (data) => new Request("https://hello.com", { body: data }), - true + true, ); }); diff --git a/test/bun.js/ffi.test.fixture.callback.c b/test/bun.js/ffi.test.fixture.callback.c index 9c3c088cec..ec83dee807 100644 --- a/test/bun.js/ffi.test.fixture.callback.c +++ b/test/bun.js/ffi.test.fixture.callback.c @@ -285,9 +285,6 @@ ZIG_REPR_TYPE JSFunctionCall(void* jsGlobalObject, void* callFrame); bool my_callback_function(void* arg0); bool my_callback_function(void* arg0) { -#ifdef INJECT_BEFORE -INJECT_BEFORE; -#endif ZIG_REPR_TYPE arguments[1]; arguments[0] = PTR_TO_JSVALUE(arg0).asZigRepr; return (bool)JSVALUE_TO_BOOL(_FFI_Callback_call((void*)0x0UL, 1, arguments)); diff --git a/test/bun.js/ffi.test.js b/test/bun.js/ffi.test.js index 65b29b7881..e3e858b1fb 100644 --- a/test/bun.js/ffi.test.js +++ b/test/bun.js/ffi.test.js @@ -29,8 +29,8 @@ it("ffi print", async () => { returns: "bool", args: ["ptr"], }, - true - ) + true, + ), ); await Bun.write( import.meta.dir + "/ffi.test.fixture.receiver.c", @@ -41,8 +41,8 @@ it("ffi print", async () => { args: ["float"], }, }, - false - )[0] + false, + )[0], ); expect( viewSource( @@ -50,8 +50,8 @@ it("ffi print", async () => { returns: "int8_t", args: [], }, - true - ).length > 0 + true, + ).length > 0, ).toBe(true); expect( viewSource( @@ -61,8 +61,8 @@ it("ffi print", async () => { args: [], }, }, - false - ).length > 0 + false, + ).length > 0, ).toBe(true); }); @@ -423,17 +423,17 @@ function ffiRunner(fast) { var bigIntArray = new BigInt64Array(bigArray.buffer); expect(identity_uint64_t(bigArray[0])).toBe(bigArray[0]); expect(identity_uint64_t(bigArray[0] - BigInt(1))).toBe( - bigArray[0] - BigInt(1) + bigArray[0] - BigInt(1), ); if (fast) { expect(add_uint64_t(BigInt(-1) * bigArray[0], bigArray[0])).toBe(0); expect( - add_uint64_t(BigInt(-1) * bigArray[0] + BigInt(10), bigArray[0]) + add_uint64_t(BigInt(-1) * bigArray[0] + BigInt(10), bigArray[0]), ).toBe(10); } else { expect(add_uint64_t(BigInt(-1) * bigArray[0], bigArray[0])).toBe(0n); expect( - add_uint64_t(BigInt(-1) * bigArray[0] + BigInt(10), bigArray[0]) + add_uint64_t(BigInt(-1) * bigArray[0] + BigInt(10), bigArray[0]), ).toBe(10n); } if (fast) { @@ -450,7 +450,7 @@ function ffiRunner(fast) { expect(identity_int64_t(bigIntArray[0])).toBe(bigIntArray[0]); expect(identity_int64_t(bigIntArray[0] - BigInt(1))).toBe( - bigIntArray[0] - BigInt(1) + bigIntArray[0] - BigInt(1), ); } Bun.gc(true); @@ -475,7 +475,7 @@ function ffiRunner(fast) { const buffer = toBuffer(cptr, 0, 4); expect(buffer.readInt32(0)).toBe(42); expect(new DataView(toArrayBuffer(cptr, 0, 4), 0, 4).getInt32(0, true)).toBe( - 42 + 42, ); expect(ptr(buffer)).toBe(cptr); expect(new CString(cptr, 0, 1).toString()).toBe("*"); @@ -515,7 +515,7 @@ function ffiRunner(fast) { { returns: returnName, args: [returnName], - } + }, ).ptr, returns: returnName, args: [returnName], @@ -531,7 +531,7 @@ function ffiRunner(fast) { { returns: "bool", args: ["bool"], - } + }, ); expect(toClose.ptr > 0).toBe(true); toClose.close(); @@ -559,7 +559,7 @@ function ffiRunner(fast) { { args: [name], threadsafe: true, - } + }, ).ptr, returns: "void", args: [name], @@ -603,10 +603,10 @@ it("read", () => { for (let i = 0; i < buffer.length; i++) { buffer[i] = BigInt(i); expect(read.intptr(addr, i * 8)).toBe( - Number(dataView.getBigInt64(i * 8, true)) + Number(dataView.getBigInt64(i * 8, true)), ); expect(read.ptr(addr, i * 8)).toBe( - Number(dataView.getBigUint64(i * 8, true)) + Number(dataView.getBigUint64(i * 8, true)), ); expect(read.f64(addr, i + 8)).toBe(dataView.getFloat64(i + 8, true)); expect(read.i64(addr, i * 8)).toBe(dataView.getBigInt64(i * 8, true)); diff --git a/test/bun.js/fileUrl.test.js b/test/bun.js/fileUrl.test.js index 4799f4228e..7efa8f2351 100644 --- a/test/bun.js/fileUrl.test.js +++ b/test/bun.js/fileUrl.test.js @@ -3,7 +3,7 @@ import { pathToFileURL, fileURLToPath } from "bun"; describe("pathToFileURL", () => { it("should convert a path to a file url", () => { expect(pathToFileURL("/path/to/file.js").href).toBe( - "file:///path/to/file.js" + "file:///path/to/file.js", ); }); }); @@ -14,7 +14,7 @@ describe("fileURLToPath", () => { }); it("should convert a URL to a path", () => { expect(fileURLToPath(new URL("file:///path/to/file.js"))).toBe( - "/path/to/file.js" + "/path/to/file.js", ); }); }); diff --git a/test/bun.js/filesink.test.ts b/test/bun.js/filesink.test.ts index 28d51a1733..b3b3a7e749 100644 --- a/test/bun.js/filesink.test.ts +++ b/test/bun.js/filesink.test.ts @@ -11,14 +11,14 @@ describe("FileSink", () => { [ ["abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"], new TextEncoder().encode( - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", ), "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", ], [ ["😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌"], new TextEncoder().encode( - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ], @@ -29,7 +29,7 @@ describe("FileSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "abcdefghijklmnopqrstuvwxyz" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", @@ -43,7 +43,7 @@ describe("FileSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "(rope) " + "abcdefghijklmnopqrstuvwxyz" + @@ -58,13 +58,13 @@ describe("FileSink", () => { ], new TextEncoder().encode( "abcdefghijklmnopqrstuvwxyz" + - "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ), "(array) " + "abcdefghijklmnopqrstuvwxyz" + "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌", ], - ]; + ] as const; for (const [input, expected, label] of fixtures) { it(`${JSON.stringify(label)}`, async () => { diff --git a/test/bun.js/fs-stream.js b/test/bun.js/fs-stream.js index 4b71c95b77..1ef3ee71c9 100644 --- a/test/bun.js/fs-stream.js +++ b/test/bun.js/fs-stream.js @@ -10,7 +10,7 @@ await new Promise((resolve, reject) => { const real = readFileSync("/tmp/fs-stream.js", "utf8"); if (copied !== real) { reject( - new Error("fs-stream.js is not the same as fs-stream.copy.js") + new Error("fs-stream.js is not the same as fs-stream.copy.js"), ); return; } diff --git a/test/bun.js/fs.test.js b/test/bun.js/fs.test.js index 3976ba372c..5c80505efc 100644 --- a/test/bun.js/fs.test.js +++ b/test/bun.js/fs.test.js @@ -1,5 +1,5 @@ import { describe, expect, it } from "bun:test"; -import { gc, gcTick } from "gc"; +import { gc, gcTick } from "./gc"; import { closeSync, existsSync, @@ -31,14 +31,14 @@ describe("copyFileSync", () => { const tempdir = `/tmp/fs.test.js/${Date.now()}/1234/hi`; expect(existsSync(tempdir)).toBe(false); expect(tempdir.includes(mkdirSync(tempdir, { recursive: true }))).toBe( - true + true, ); // that don't exist copyFileSync(import.meta.path, tempdir + "/copyFileSync.js"); expect(existsSync(tempdir + "/copyFileSync.js")).toBe(true); expect(readFileSync(tempdir + "/copyFileSync.js", "utf-8")).toBe( - readFileSync(import.meta.path, "utf-8") + readFileSync(import.meta.path, "utf-8"), ); // that do exist @@ -53,7 +53,7 @@ describe("copyFileSync", () => { const tempdir = `/tmp/fs.test.js/${Date.now()}-1/1234/hi`; expect(existsSync(tempdir)).toBe(false); expect(tempdir.includes(mkdirSync(tempdir, { recursive: true }))).toBe( - true + true, ); var buffer = new Int32Array(128 * 1024); for (let i = 0; i < buffer.length; i++) { @@ -67,20 +67,20 @@ describe("copyFileSync", () => { expect(existsSync(tempdir + "/copyFileSync.src.blob")).toBe(true); copyFileSync( tempdir + "/copyFileSync.src.blob", - tempdir + "/copyFileSync.dest.blob" + tempdir + "/copyFileSync.dest.blob", ); expect(Bun.hash(readFileSync(tempdir + "/copyFileSync.dest.blob"))).toBe( - hash + hash, ); buffer[0] = 255; writeFileSync(tempdir + "/copyFileSync.src.blob", buffer.buffer); copyFileSync( tempdir + "/copyFileSync.src.blob", - tempdir + "/copyFileSync.dest.blob" + tempdir + "/copyFileSync.dest.blob", ); expect(Bun.hash(readFileSync(tempdir + "/copyFileSync.dest.blob"))).toBe( - Bun.hash(buffer.buffer) + Bun.hash(buffer.buffer), ); }); }); @@ -90,7 +90,7 @@ describe("mkdirSync", () => { const tempdir = `/tmp/fs.test.js/${Date.now()}/1234/hi`; expect(existsSync(tempdir)).toBe(false); expect(tempdir.includes(mkdirSync(tempdir, { recursive: true }))).toBe( - true + true, ); expect(existsSync(tempdir)).toBe(true); }); @@ -134,7 +134,7 @@ it("readdirSync works on empty directories", () => { it("readdirSync works on directories with under 32 files", () => { const path = `/tmp/fs-test-one-dir-${(Math.random() * 100000 + 100).toString( - 32 + 32, )}`; mkdirSync(path, { recursive: true }); writeFileSync(`${path}/a`, "a"); @@ -172,7 +172,7 @@ it("readdirSync throws when given a file path with trailing slash", () => { describe("readSync", () => { const firstFourBytes = new Uint32Array( - new TextEncoder().encode("File").buffer + new TextEncoder().encode("File").buffer, )[0]; it("works with a position set to 0", () => { const fd = openSync(import.meta.dir + "/readFileSync.txt", "r"); @@ -234,7 +234,7 @@ describe("readFileSync", () => { gc(); const text = readFileSync( new URL("file://" + import.meta.dir + "/readFileSync.txt"), - "utf8" + "utf8", ); gc(); expect(text).toBe("File read successfully"); @@ -338,7 +338,7 @@ describe("lstat", () => { const fileStats = lstatSync( new URL("./fs-stream.js", import.meta.url) .toString() - .slice("file://".length - 1) + .slice("file://".length - 1), ); expect(fileStats.isSymbolicLink()).toBe(false); expect(fileStats.isFile()).toBe(true); @@ -349,7 +349,7 @@ describe("lstat", () => { const fileStats = lstatSync( new URL("../../test", import.meta.url) .toString() - .slice("file://".length - 1) + .slice("file://".length - 1), ); expect(fileStats.isSymbolicLink()).toBe(false); expect(fileStats.isFile()).toBe(false); @@ -360,7 +360,7 @@ describe("lstat", () => { const linkStats = lstatSync( new URL("./fs-stream.link.js", import.meta.url) .toString() - .slice("file://".length - 1) + .slice("file://".length - 1), ); expect(linkStats.isSymbolicLink()).toBe(true); expect(linkStats.isFile()).toBe(false); @@ -373,7 +373,7 @@ describe("stat", () => { const fileStats = statSync( new URL("./fs-stream.js", import.meta.url) .toString() - .slice("file://".length - 1) + .slice("file://".length - 1), ); expect(fileStats.isSymbolicLink()).toBe(false); expect(fileStats.isFile()).toBe(true); @@ -384,7 +384,7 @@ describe("stat", () => { const fileStats = statSync( new URL("../../test", import.meta.url) .toString() - .slice("file://".length - 1) + .slice("file://".length - 1), ); expect(fileStats.isSymbolicLink()).toBe(false); expect(fileStats.isFile()).toBe(false); @@ -478,7 +478,7 @@ describe("createWriteStream", () => { stream.on("finish", () => { expect(readFileSync(path, "utf8")).toBe( - "Test file written successfully" + "Test file written successfully", ); resolve(true); }); diff --git a/test/bun.js/html-rewriter.test.js b/test/bun.js/html-rewriter.test.js index 29b765c2f6..008ced7916 100644 --- a/test/bun.js/html-rewriter.test.js +++ b/test/bun.js/html-rewriter.test.js @@ -74,11 +74,11 @@ describe("HTMLRewriter", () => { }, }); var input = new Response( - '
hello
' + '
hello
', ); var output = rewriter.transform(input); expect(await output.text()).toBe( - '
hello
' + '
hello
', ); expect(expected.length).toBe(0); }); @@ -104,7 +104,7 @@ describe("HTMLRewriter", () => { "<span>append</span>", "append html", "

", - ].join("") + ].join(""), ); // setInnerContent @@ -202,92 +202,92 @@ describe("HTMLRewriter", () => { await checkSelector( "p:nth-child(2)", "

1

2

3

", - "

1

new

3

" + "

1

new

3

", ); await checkSelector( "p:first-child", "

1

2

3

", - "

new

2

3

" + "

new

2

3

", ); await checkSelector( "p:nth-of-type(2)", "

1

2

3

4

5

", - "

1

2

new

4

5

" + "

1

2

new

4

5

", ); await checkSelector( "p:first-of-type", "

1

2

3

", - "

1

new

3

" + "

1

new

3

", ); await checkSelector( "p:not(:first-child)", "

1

2

3

", - "

1

new

new

" + "

1

new

new

", ); await checkSelector( "p.red", '

1

2

', - '

new

2

' + '

new

2

', ); await checkSelector( "h1#header", '

1

2

', - '

new

2

' + '

new

2

', ); await checkSelector( "p[data-test]", "

1

2

", - "

new

2

" + "

new

2

", ); await checkSelector( 'p[data-test="one"]', '

1

2

', - '

new

2

' + '

new

2

', ); await checkSelector( 'p[data-test="one" i]', '

1

2

3

', - '

new

new

3

' + '

new

new

3

', ); await checkSelector( 'p[data-test="one" s]', '

1

2

3

', - '

new

2

3

' + '

new

2

3

', ); await checkSelector( 'p[data-test~="two"]', '

1

2

3

', - '

new

new

3

' + '

new

new

3

', ); await checkSelector( 'p[data-test^="a"]', '

1

2

3

', - '

new

new

3

' + '

new

new

3

', ); await checkSelector( 'p[data-test$="1"]', '

1

2

3

', - '

new

2

new

' + '

new

2

new

', ); await checkSelector( 'p[data-test*="b"]', '

1

2

3

', - '

new

new

3

' + '

new

new

3

', ); await checkSelector( 'p[data-test|="a"]', '

1

2

3

', - '

new

new

3

' + '

new

new

3

', ); await checkSelector( "div span", "

1

23
", - "

new

new3
" + "

new

new3
", ); await checkSelector( "div > span", "

1

23
", - "

1

new3
" + "

1

new3
", ); }); }); diff --git a/test/bun.js/import-meta.test.js b/test/bun.js/import-meta.test.js index a1ead978e0..a6d6630610 100644 --- a/test/bun.js/import-meta.test.js +++ b/test/bun.js/import-meta.test.js @@ -10,7 +10,7 @@ it("primordials are not here!", () => { it("import.meta.resolveSync", () => { expect( - import.meta.resolveSync("./" + import.meta.file, import.meta.path) + import.meta.resolveSync("./" + import.meta.file, import.meta.path), ).toBe(path); const require = Module.createRequire(import.meta.path); expect(require.resolve(import.meta.path)).toBe(path); @@ -18,7 +18,7 @@ it("import.meta.resolveSync", () => { // check it works with URL objects expect( - Module.createRequire(new URL(import.meta.url)).resolve(import.meta.path) + Module.createRequire(new URL(import.meta.url)).resolve(import.meta.path), ).toBe(import.meta.path); }); diff --git a/test/bun.js/inspect.test.js b/test/bun.js/inspect.test.js index 65ba67edfa..b49265f53e 100644 --- a/test/bun.js/inspect.test.js +++ b/test/bun.js/inspect.test.js @@ -34,7 +34,7 @@ it("utf16 property name", () => { var { Database } = require("bun:sqlite"); const db = Database.open(":memory:"); expect(Bun.inspect(db.prepare("select '😀' as 笑").all())).toBe( - '[ { "笑": "😀" } ]' + '[ { "笑": "😀" } ]', ); }); @@ -53,7 +53,7 @@ it("Request object", () => { Request (0 KB) { method: "GET", url: "https://example.com" -}`.trim() +}`.trim(), ); }); @@ -62,7 +62,7 @@ it("MessageEvent", () => { `MessageEvent { type: "message", data: 123 -}` +}`, ); }); @@ -83,13 +83,13 @@ it("TypedArray prints", () => { const input = Bun.inspect(buffer); expect(input).toBe( - `${TypedArray.name}(${buffer.length}) [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]` + `${TypedArray.name}(${buffer.length}) [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]`, ); for (let i = 1; i < buffer.length + 1; i++) { expect(Bun.inspect(buffer.subarray(i))).toBe( `${TypedArray.name}(${buffer.length - i}) [ ` + [...buffer.subarray(i)].join(", ") + - " ]" + " ]", ); } } @@ -101,13 +101,13 @@ it("BigIntArray", () => { const input = Bun.inspect(buffer); expect(input).toBe( - `${TypedArray.name}(${buffer.length}) [ 1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 10n ]` + `${TypedArray.name}(${buffer.length}) [ 1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 10n ]`, ); for (let i = 1; i < buffer.length + 1; i++) { expect(Bun.inspect(buffer.subarray(i))).toBe( `${TypedArray.name}(${buffer.length - i}) [ ` + [...buffer.subarray(i)].map((a) => a.toString(10) + "n").join(", ") + - " ]" + " ]", ); } } @@ -120,14 +120,14 @@ it("FloatArray", () => { expect(input).toBe( `${TypedArray.name}(${buffer.length}) [ ${[Math.fround(42.68)].join( - ", " - )} ]` + ", ", + )} ]`, ); for (let i = 1; i < buffer.length + 1; i++) { expect(Bun.inspect(buffer.subarray(i))).toBe( `${TypedArray.name}(${buffer.length - i}) [ ` + [...buffer.subarray(i)].join(", ") + - " ]" + " ]", ); } } @@ -138,7 +138,7 @@ it("jsx with two elements", () => {
string inside child -
+
, ); const output = `
@@ -169,7 +169,7 @@ it("jsx with fragment", () => { it("inspect", () => { expect(Bun.inspect(new TypeError("what")).includes("TypeError: what")).toBe( - true + true, ); expect("hi").toBe("hi"); expect(Bun.inspect(1)).toBe("1"); @@ -182,10 +182,10 @@ it("inspect", () => { expect(Bun.inspect({ hello: 1 })).toBe("{ hello: 1 }"); expect(Bun.inspect({ hello: 1, there: 2 })).toBe("{ hello: 1, there: 2 }"); expect(Bun.inspect({ hello: "1", there: 2 })).toBe( - '{ hello: "1", there: 2 }' + '{ hello: "1", there: 2 }', ); expect(Bun.inspect({ 'hello-"there': "1", there: 2 })).toBe( - '{ "hello-\\"there": "1", there: 2 }' + '{ "hello-\\"there": "1", there: 2 }', ); var str = "123"; while (str.length < 4096) { @@ -204,29 +204,29 @@ it("inspect", () => { expect(Bun.inspect(new Set())).toBe("Set {}"); expect(Bun.inspect(new Map())).toBe("Map {}"); expect(Bun.inspect(new Map([["foo", "bar"]]))).toBe( - 'Map(1) {\n "foo": "bar",\n}' + 'Map(1) {\n "foo": "bar",\n}', ); expect(Bun.inspect(new Set(["bar"]))).toBe('Set(1) {\n "bar",\n}'); expect(Bun.inspect(
foo
)).toBe("
foo
"); expect(Bun.inspect(
foo
)).toBe("
foo
"); expect(Bun.inspect(
foo
)).toBe("
foo
"); expect(Bun.inspect(
hi
)).toBe( - "
hi
" + "
hi
", ); expect(Bun.inspect(
quoted
)).toBe( - '
quoted
' + '
quoted
', ); expect( Bun.inspect(
-
- ) +
, + ), ).toBe( `
-
`.trim() +
`.trim(), ); expect(Bun.inspect(BigInt(32))).toBe("32n"); }); diff --git a/test/bun.js/log-test.test.ts b/test/bun.js/log-test.test.ts index bdb6cbe42a..272dc7ef26 100644 --- a/test/bun.js/log-test.test.ts +++ b/test/bun.js/log-test.test.ts @@ -14,7 +14,7 @@ it("should not log .env when quiet", async () => { cwd: "/tmp/log-test-silent", }); - expect(stderr.toString()).toBe(""); + expect(stderr!.toString()).toBe(""); }); it("should log .env by default", async () => { @@ -29,7 +29,7 @@ it("should log .env by default", async () => { cwd: "/tmp/log-test-silent", }); - expect(stderr.toString().includes(".env")).toBe(true); + expect(stderr?.toString().includes(".env")).toBe(true); }); function writeDirectoryTree(base, paths) { diff --git a/test/bun.js/microtask.test.js b/test/bun.js/microtask.test.js index 18956b1e5a..dba84f36c6 100644 --- a/test/bun.js/microtask.test.js +++ b/test/bun.js/microtask.test.js @@ -60,7 +60,7 @@ it("queueMicrotask", async () => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is not a function" + "queueMicrotask should throw a TypeError if the argument is not a function", ); } @@ -74,7 +74,7 @@ it("queueMicrotask", async () => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is empty" + "queueMicrotask should throw a TypeError if the argument is empty", ); } }); diff --git a/test/bun.js/node-test-helpers.test.js b/test/bun.js/node-test-helpers.test.js index 7fb2de320e..766dfc176c 100644 --- a/test/bun.js/node-test-helpers.test.js +++ b/test/bun.js/node-test-helpers.test.js @@ -5,7 +5,7 @@ import { strictEqual, createCallCheckCtx, createDoneDotAll, -} from "node-test-helpers"; +} from "./node-test-helpers"; describe("OurAssert.throws()", () => { it("should pass when the function throws", () => { diff --git a/test/bun.js/oniguruma-regexp.test.ts b/test/bun.js/oniguruma-regexp.test.ts index 372e8eb99c..9fe3d7be87 100644 --- a/test/bun.js/oniguruma-regexp.test.ts +++ b/test/bun.js/oniguruma-regexp.test.ts @@ -1,3 +1,4 @@ +// @ts-ignore import { OnigurumaRegExp } from "bun"; import { expect, it, test } from "bun:test"; import { gc as gcTrace } from "./gc"; @@ -7,8 +8,8 @@ it("repeated match and exec calls", () => { let r1 = new OnigurumaRegExp("//.+?/[^?]+", "sg"); let r2 = new RegExp("//.+?/[^?]+", "sg"); let s1 = "https://dylan-conway.com/profile"; - expect(s1.match(r1)[0] === s1.match(r2)[0]).toBe(true); - expect(r1.exec(s1)[0] === r2.exec(s1)[0]).toBe(true); + expect(s1.match(r1)![0] === s1.match(r2)![0]).toBe(true); + expect(r1.exec(s1)![0] === r2.exec(s1)![0]).toBe(true); } }); @@ -17,8 +18,8 @@ it("repeated match and exec calls no global flag", () => { let r1 = new OnigurumaRegExp("//.+?/[^?]+", "s"); let r2 = new RegExp("//.+?/[^?]+", "s"); let s1 = "https://dylan-conway.com/profile"; - expect(r1.exec(s1)[0] === r2.exec(s1)[0]).toBe(true); - expect(s1.match(r1)[0] === s1.match(r2)[0]).toBe(true); + expect(r1.exec(s1)![0] === r2.exec(s1)![0]).toBe(true); + expect(s1.match(r1)![0] === s1.match(r2)![0]).toBe(true); } }); @@ -27,53 +28,53 @@ const rb2 = new RegExp("//.+?/[^?]+", "s"); it("repeated match calls with global regex without global flag", () => { for (let i = 0; i < 20000; i++) { let s1 = "https://dylan-conway.com/profile"; - expect(rb1.exec(s1)[0] === rb2.exec(s1)[0]).toBe(true); - expect(s1.match(rb1)[0] === s1.match(rb2)[0]).toBe(true); + expect(rb1.exec(s1)![0] === rb2.exec(s1)![0]).toBe(true); + expect(s1.match(rb1)![0] === s1.match(rb2)![0]).toBe(true); } }); it("escaped characters in character classes", () => { expect( - new RegExp("[a-z]").exec("a")[0] === - new OnigurumaRegExp("[a-z]").exec("a")[0] + new RegExp("[a-z]").exec("a")![0] === + new OnigurumaRegExp("[a-z]").exec("a")![0], ).toBe(true); Bun.gc(true); expect( - new RegExp("[a-z]").exec("b")[0] === - new OnigurumaRegExp("[a-z]").exec("b")[0] + new RegExp("[a-z]").exec("b")![0] === + new OnigurumaRegExp("[a-z]").exec("b")![0], ).toBe(true); Bun.gc(true); - expect(new RegExp("[a-zA-Z0-9_]+").exec("B9")[0]).toBe( - new OnigurumaRegExp("[a-zA-Z0-9_]+").exec("B9")[0] + expect(new RegExp("[a-zA-Z0-9_]+").exec("B9")![0]).toBe( + new OnigurumaRegExp("[a-zA-Z0-9_]+").exec("B9")![0], ); Bun.gc(true); expect(new RegExp("[a-z]").exec("-")).toBe(null); Bun.gc(true); expect(new OnigurumaRegExp("[a-z]").exec("-")).toBe(null); Bun.gc(true); - expect(new RegExp("[a\\-z]").exec("-")[0]).toBe("-"); + expect(new RegExp("[a\\-z]").exec("-")![0]).toBe("-"); Bun.gc(true); - expect(new OnigurumaRegExp("[a\\-z]").exec("-")[0]).toBe("-"); + expect(new OnigurumaRegExp("[a\\-z]").exec("-")![0]).toBe("-"); Bun.gc(true); - expect(new RegExp("[a\\-z]").exec("a")[0]).toBe("a"); + expect(new RegExp("[a\\-z]").exec("a")![0]).toBe("a"); Bun.gc(true); - expect(new OnigurumaRegExp("[a\\-z]").exec("a")[0]).toBe("a"); + expect(new OnigurumaRegExp("[a\\-z]").exec("a")![0]).toBe("a"); Bun.gc(true); - expect(new RegExp("[a\\-z]").exec("z")[0]).toBe("z"); + expect(new RegExp("[a\\-z]").exec("z")![0]).toBe("z"); Bun.gc(true); - expect(new OnigurumaRegExp("[a\\-z]").exec("z")[0]).toBe("z"); + expect(new OnigurumaRegExp("[a\\-z]").exec("z")![0]).toBe("z"); Bun.gc(true); expect(new RegExp("[a\\-z]").exec("b")).toBe(null); Bun.gc(true); expect(new OnigurumaRegExp("[a\\-z]").exec("b")).toBe(null); Bun.gc(true); - expect(new RegExp("[^b-c]").exec("a")[0]).toBe( - new OnigurumaRegExp("[^b-c]").exec("a")[0] + expect(new RegExp("[^b-c]").exec("a")![0]).toBe( + new OnigurumaRegExp("[^b-c]").exec("a")![0], ); Bun.gc(true); @@ -81,16 +82,16 @@ it("escaped characters in character classes", () => { expect(new OnigurumaRegExp("[\\^b-c]").exec("a")).toBe(null); Bun.gc(true); - expect(new RegExp("[\\^b-c]").exec("^c")[0]).toBe("^"); - expect(new OnigurumaRegExp("[\\^b-c]").exec("^c")[0]).toBe("^"); + expect(new RegExp("[\\^b-c]").exec("^c")![0]).toBe("^"); + expect(new OnigurumaRegExp("[\\^b-c]").exec("^c")![0]).toBe("^"); Bun.gc(true); - expect(new RegExp("[a^b-c]").exec("a^")[0]).toBe("a"); - expect(new OnigurumaRegExp("[a^b-c]").exec("a^")[0]).toBe("a"); + expect(new RegExp("[a^b-c]").exec("a^")![0]).toBe("a"); + expect(new OnigurumaRegExp("[a^b-c]").exec("a^")![0]).toBe("a"); Bun.gc(true); - expect(new RegExp("[\\\\]").exec("\\")[0]).toBe("\\"); - expect(new OnigurumaRegExp("[\\\\]").exec("\\")[0]).toBe("\\"); + expect(new RegExp("[\\\\]").exec("\\")![0]).toBe("\\"); + expect(new OnigurumaRegExp("[\\\\]").exec("\\")![0]).toBe("\\"); Bun.gc(true); let p = "//.+?[^?]+"; @@ -98,15 +99,15 @@ it("escaped characters in character classes", () => { const b1 = new RegExp(p, "gs"); const b2 = new OnigurumaRegExp(p, "gs"); Bun.gc(true); - expect(s.match(b1)[0] === s.match(b2)[0]).toBe(true); + expect(s.match(b1)![0] === s.match(b2)![0]).toBe(true); Bun.gc(true); const b3 = new RegExp("[\\^]"); const b4 = new OnigurumaRegExp("[\\^]"); Bun.gc(true); expect( - "https://dylan-co^nway.com/profile".match(b3)[0] === - "https://dylan-co^nway.com/profile".match(b4)[0] + "https://dylan-co^nway.com/profile".match(b3)![0] === + "https://dylan-co^nway.com/profile".match(b4)![0], ).toBe(true); Bun.gc(true); @@ -114,132 +115,132 @@ it("escaped characters in character classes", () => { p = "\/\/.+?\/[^?]+"; s = "https://dylan-conway.com/profile"; Bun.gc(true); - expect(s.match(new OnigurumaRegExp(p, "gs"))[0]).toBe( - new RegExp(p, "gs").exec(s)[0] + expect(s.match(new OnigurumaRegExp(p, "gs"))![0]).toBe( + new RegExp(p, "gs").exec(s)![0], ); Bun.gc(true); // middle no escape p = "[.i^e]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // middle with escape p = "[.i\\^e]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // end with escape p = "[.ie\\^]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // end no escape p = "[.ie^]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // start no escape p = "[^.ie]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // start with escape p = "[\\^.ie]+"; s = "https://dylan-co^nway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // middle with escape p = "[.i\\-e]+"; s = "https://dylan-conway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // end with escape p = "[.ie\\-]+"; s = "https://dylan-conway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // end no escape p = "[.ie-]+"; s = "https://dylan-conway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // start no escape p = "[-.ie]+"; s = "https://dylan-conway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); // start with escape p = "[\\-.ie]+"; s = "https://dylan-conway.com/profile"; - expect(new OnigurumaRegExp(p).exec(s)[0]).toBe(new RegExp(p).exec(s)[0]); + expect(new OnigurumaRegExp(p).exec(s)![0]).toBe(new RegExp(p).exec(s)![0]); - let r1 = new RegExp("^([[(]-?[\\d]+)?,?(-?[\\d]+[\\])])?$").exec("(1,1]"); + let r1 = new RegExp("^([[(]-?[\\d]+)?,?(-?[\\d]+[\\])])?$").exec("(1,1]")!; Bun.gc(true); let r2 = new OnigurumaRegExp("^([[(]-?[\\d]+)?,?(-?[\\d]+[\\])])?$").exec( - "(1,1]" + "(1,1]", ); Bun.gc(true); expect(r1[0]).toBe(r2[0]); Bun.gc(true); - let r3 = new RegExp("[\\d],[\\d]").exec("1,2"); + let r3 = new RegExp("[\\d],[\\d]").exec("1,2")!; let r4 = new OnigurumaRegExp("[\\d],[\\d]").exec("1,2"); expect(r3[0]).toBe(r4[0]); - let r5 = new RegExp("^[(],[)]?$").exec("(,"); + let r5 = new RegExp("^[(],[)]?$").exec("(,")!; let r6 = new OnigurumaRegExp("^[(],[)]?$").exec("(,"); expect(r5[0]).toBe(r6[0]); - let r9 = new RegExp("[([],[)\\]]").exec("[,]"); + let r9 = new RegExp("[([],[)\\]]").exec("[,]")!; let r10 = new OnigurumaRegExp("[([],[)\\]]").exec("[,]"); expect(r9[0]).toBe(r10[0]); - let r13 = new RegExp("\\[").exec("["); + let r13 = new RegExp("\\[").exec("[")!; let r14 = new OnigurumaRegExp("\\[").exec("["); expect(r13[0]).toBe(r14[0]); - let r15 = new RegExp("\\]").exec("]"); + let r15 = new RegExp("\\]").exec("]")!; let r16 = new OnigurumaRegExp("\\]").exec("]"); expect(r15[0]).toBe(r16[0]); - let r17 = new RegExp("]").exec("]"); + let r17 = new RegExp("]").exec("]")!; let r18 = new OnigurumaRegExp("]").exec("]"); expect(r17[0]).toBe(r18[0]); - let r21 = new RegExp("[\\]]").exec("]"); + let r21 = new RegExp("[\\]]").exec("]")!; let r22 = new OnigurumaRegExp("[\\]]").exec("]"); expect(r21[0]).toBe(r22[0]); - let r23 = new RegExp("[\\[]").exec("["); + let r23 = new RegExp("[\\[]").exec("[")!; let r24 = new OnigurumaRegExp("[\\[]").exec("["); expect(r23[0]).toBe(r24[0]); - let r25 = new RegExp("[[][[]").exec("[["); + let r25 = new RegExp("[[][[]").exec("[[")!; let r26 = new OnigurumaRegExp("[[][[]").exec("[["); expect(r25[0]).toBe(r26[0]); - let r27 = new RegExp("[[\\]][[\\]]").exec("[]"); + let r27 = new RegExp("[[\\]][[\\]]").exec("[]")!; let r28 = new OnigurumaRegExp("[[\\]][[\\]]").exec("[]"); expect(r27[0]).toBe(r28[0]); - let r29 = new RegExp("[[\\]][[\\]]").exec("]["); + let r29 = new RegExp("[[\\]][[\\]]").exec("][")!; let r30 = new OnigurumaRegExp("[[\\]][[\\]]").exec("]["); expect(r29[0]).toBe(r30[0]); - let r31 = new RegExp("[[\\]][[\\]]").exec("]]"); + let r31 = new RegExp("[[\\]][[\\]]").exec("]]")!; let r32 = new OnigurumaRegExp("[[\\]][[\\]]").exec("]]"); expect(r31[0]).toBe(r32[0]); - let r33 = new RegExp("[\\]][\\]]").exec("]]"); + let r33 = new RegExp("[\\]][\\]]").exec("]]")!; let r34 = new OnigurumaRegExp("[\\]][\\]]").exec("]]"); expect(r33[0]).toBe(r34[0]); - let r35 = new RegExp("[a-z&&[^aeiou]").exec("a"); + let r35 = new RegExp("[a-z&&[^aeiou]").exec("a")!; let r36 = new OnigurumaRegExp("[a-z&&[^aeiou]").exec("a"); expect(r35[0]).toBe(r36[0]); - let r37 = new RegExp("[a-z&&[^aeiou]]").exec("a]"); + let r37 = new RegExp("[a-z&&[^aeiou]]").exec("a]")!; let r38 = new OnigurumaRegExp("[a-z&&[^aeiou]]").exec("a]"); expect(r37[0]).toBe(r38[0]); }); @@ -251,7 +252,7 @@ it("OnigurumaRegExp.prototype.exec()", () => { let a2 = new RegExp("\x3e", "gd"); let a2_1 = a2.exec("table fo\x3eotball, fo\x3eosball"); - a2_1 = a2.exec("table fo\x3eotball, fo\x3eosball"); + a2_1 = a2.exec("table fo\x3eotball, fo\x3eosball")!; expect(a1_1[0]).toBe(a2_1[0]); expect(a1_1[1]).toBe(a2_1[1]); @@ -259,7 +260,9 @@ it("OnigurumaRegExp.prototype.exec()", () => { expect(a1_1.input).toBe(a2_1.input); expect(a1.lastIndex).toBe(a2.lastIndex); expect(a1_1.groups).toBe(a2_1.groups); + // @ts-ignore remove when `indices` is added to lib/dom expect(a1_1.indices[0][0]).toBe(a2_1.indices[0][0]); + // @ts-ignore expect(a1_1.indices[0][1]).toBe(a2_1.indices[0][1]); }); @@ -269,8 +272,8 @@ test("OnigurumaRegExp.prototype.exec() 2", () => { a1_1 = a1.exec("table fo\x3e\x5eotball, fo\x3e\x5eosball"); let a2 = new RegExp("\x3e\\x5e", "gd"); - let a2_1 = a2.exec("table fo\x3e\x5eotball, fo\x3e\x5eosball"); - a2_1 = a2.exec("table fo\x3e\x5eotball, fo\x3e\x5eosball"); + let a2_1 = a2.exec("table fo\x3e\x5eotball, fo\x3e\x5eosball")!; + a2_1 = a2.exec("table fo\x3e\x5eotball, fo\x3e\x5eosball")!; expect(a1_1[0]).toBe(a2_1[0]); expect(a1_1[1]).toBe(a2_1[1]); @@ -278,7 +281,9 @@ test("OnigurumaRegExp.prototype.exec() 2", () => { expect(a1_1.input).toBe(a2_1.input); expect(a1.lastIndex).toBe(a2.lastIndex); expect(a1_1.groups).toBe(a2_1.groups); + // @ts-ignore expect(a1_1.indices[0][0]).toBe(a2_1.indices[0][0]); + // @ts-ignore expect(a1_1.indices[0][1]).toBe(a2_1.indices[0][1]); }); @@ -291,7 +296,7 @@ test("OnigurumaRegExp.prototype.exec() 3", () => { let a1_1 = a1.exec("table fo\\x3\x5eotball, fo\\x3\x5eosball"); let a2 = new RegExp("\\x3\\x5e", "gd"); - let a2_1 = a2.exec("table fo\\x3\x5eotball, fo\\x3\x5eosball"); + let a2_1 = a2.exec("table fo\\x3\x5eotball, fo\\x3\x5eosball")!; expect(a1_1[0]).toBe(a2_1[0]); expect(a1_1[1]).toBe(a2_1[1]); @@ -299,7 +304,9 @@ test("OnigurumaRegExp.prototype.exec() 3", () => { expect(a1_1.input).toBe(a2_1.input); expect(a1.lastIndex).toBe(a2.lastIndex); expect(a1_1.groups).toBe(a2_1.groups); + // @ts-ignore expect(a1_1.indices[0][0]).toBe(a2_1.indices[0][0]); + // @ts-ignore expect(a1_1.indices[0][1]).toBe(a2_1.indices[0][1]); }); @@ -320,7 +327,7 @@ test("OnigurumaRegExp.prototype.exec() 4", () => { expect(new RegExpConstructor("\\x3\\x5\\j").source).toBe("\\x3\\x5\\j"); expect(new RegExpConstructor("\\x3\\x7\\xa").source).toBe("\\x3\\x7\\xa"); expect(new RegExpConstructor("\\j323\\x7\\xa").source).toBe( - "\\j323\\x7\\xa" + "\\j323\\x7\\xa", ); expect(new RegExpConstructor("\\x56").test("V")).toBe(true); } @@ -329,19 +336,19 @@ test("OnigurumaRegExp.prototype.exec() 4", () => { test("OnigurumaRegExp.prototype.test()", () => { expect(new RegExp("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\")).toBe(true); expect(new OnigurumaRegExp("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\")).toBe( - true + true, ); expect(new RegExp("\\x56").test("V")).toBe(true); expect(new OnigurumaRegExp("\\x56").test("V")).toBe(true); expect( - new RegExp("//").compile("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\") + new RegExp("//").compile("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\"), ).toBe(true); let r = new OnigurumaRegExp("//"); expect(r.compile("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\")).toBe(true); expect( - new OnigurumaRegExp("").compile("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\") + new OnigurumaRegExp("").compile("\\\\(?![*+?^${}(|)[\\]])", "g").test("\\"), ).toBe(true); }); @@ -358,11 +365,12 @@ test("OnigurumaRegExp.prototype.source", () => { expect(new OnigurumaRegExp("/").source).toBe("\\/"); expect(new RegExp("/").source).toBe("\\/"); + // @ts-ignore TS doesn't allow empty constructor expect(new OnigurumaRegExp().source).toBe(new RegExp().source); expect(new OnigurumaRegExp("").source).toBe(new RegExp("").source); expect(new OnigurumaRegExp("a").source).toBe(new RegExp("a").source); expect(new OnigurumaRegExp("a", "g").source).toBe( - new RegExp("a", "g").source + new RegExp("a", "g").source, ); expect(new OnigurumaRegExp("/").source).toBe(new RegExp("/").source); expect(new OnigurumaRegExp("\n").source).toBe(new RegExp("\n").source); @@ -370,25 +378,26 @@ test("OnigurumaRegExp.prototype.source", () => { }); test("OnigurumaRegExp.prototype.toString()", () => { + // @ts-ignore expect(new OnigurumaRegExp().toString()).toBe(new RegExp().toString()); expect(new OnigurumaRegExp("").toString()).toBe(new RegExp("").toString()); expect(new OnigurumaRegExp("a").toString()).toBe(new RegExp("a").toString()); expect(new OnigurumaRegExp("a", "g").toString()).toBe( - new RegExp("a", "g").toString() + new RegExp("a", "g").toString(), ); expect(new OnigurumaRegExp("/").toString()).toBe(new RegExp("/").toString()); expect(new OnigurumaRegExp("\n").toString()).toBe( - new RegExp("\n").toString() + new RegExp("\n").toString(), ); expect(new OnigurumaRegExp("\r").toString()).toBe( - new RegExp("\r").toString() + new RegExp("\r").toString(), ); expect( new OnigurumaRegExp( - "jf/.a.,voejpjoajglz;/qwjopeiv\\//\\/jpoqaj/Zdkj" - ).toString() + "jf/.a.,voejpjoajglz;/qwjopeiv\\//\\/jpoqaj/Zdkj", + ).toString(), ).toBe( - new RegExp("jf/.a.,voejpjoajglz;/qwjopeiv\\//\\/jpoqaj/Zdkj").toString() + new RegExp("jf/.a.,voejpjoajglz;/qwjopeiv\\//\\/jpoqaj/Zdkj").toString(), ); }); @@ -429,10 +438,10 @@ test("OnigurumaRegExp flags", () => { // case insensitive option for (const RegExpConstructor of [OnigurumaRegExp, RegExp]) { expect(new RegExpConstructor("Is ThIs SqL?").test("IS THIS SQL?")).toBe( - false + false, ); expect( - new RegExpConstructor("Is ThIs SqL?", "i").test("IS THIS SQL?") + new RegExpConstructor("Is ThIs SqL?", "i").test("IS THIS SQL?"), ).toBe(true); } @@ -505,56 +514,56 @@ test("OnigurumaRegExp errors", () => { let b = new OnigurumaRegExp("l", "m"); try { r.compile(b, "g"); - } catch (e) { + } catch (e: any) { expect(e.message).toBe( - "Cannot supply flags when constructing one RegExp from another." + "Cannot supply flags when constructing one RegExp from another.", ); } try { r.compile("ll", "a"); - } catch (e) { + } catch (e: any) { expect(e.message).toBe("Invalid flags supplied to RegExp constructor."); } try { new OnigurumaRegExp("c", "a"); - } catch (e) { + } catch (e: any) { expect(e.message).toBe("Invalid flags supplied to RegExp constructor."); } const invalidRegExpError = "Invalid regular expression: "; try { new OnigurumaRegExp("?", "g"); - } catch (e) { + } catch (e: any) { expect(e.message.substring(0, invalidRegExpError.length)).toBe( - invalidRegExpError + invalidRegExpError, ); } try { new OnigurumaRegExp("?"); - } catch (e) { + } catch (e: any) { expect(e.message.substring(0, invalidRegExpError.length)).toBe( - invalidRegExpError + invalidRegExpError, ); } try { r.compile("?", "g"); - } catch (e) { + } catch (e: any) { expect(e.message.substring(0, invalidRegExpError.length)).toBe( - invalidRegExpError + invalidRegExpError, ); } try { r.compile("?"); - } catch (e) { + } catch (e: any) { expect(e.message.substring(0, invalidRegExpError.length)).toBe( - invalidRegExpError + invalidRegExpError, ); } try { new OnigurumaRegExp("\\"); - } catch (e) { + } catch (e: any) { expect(e.message.substring(0, invalidRegExpError.length)).toBe( - invalidRegExpError + invalidRegExpError, ); } }); @@ -607,7 +616,9 @@ test("OnigurumaRegExp random", () => { expect(new OnigurumaRegExp("a", "i").sticky).toBe(false); expect(new OnigurumaRegExp("a", "u").unicode).toBe(true); expect(new OnigurumaRegExp("a", "d").unicode).toBe(false); + // @ts-ignore expect(new RegExp("a", "d").hasIndices).toBe(true); + // @ts-ignore expect(new RegExp("a", "i").hasIndices).toBe(false); expect(new RegExp("a", "s").dotAll).toBe(true); expect(new RegExp("a", "i").dotAll).toBe(false); @@ -634,7 +645,7 @@ it("String.prototype.replace", () => { expect(offset).toBe(0); expect(string).toBe("a"); return "b"; - }) + }), ).toBe("b"); } @@ -652,13 +663,13 @@ it("Strings.prototype.match", () => { let str = "The rain in SPAIN stays mainly in the plain"; for (let RegExpConstructor of [OnigurumaRegExp, RegExp]) { let r1 = new RegExpConstructor("ain", "g"); - let m1 = str.match(r1); + let m1 = str.match(r1)!; expect(m1[0]).toBe("ain"); expect(m1[1]).toBe("ain"); expect(m1[2]).toBe("ain"); r1.compile("ain", "ig"); - m1 = str.match(r1); + m1 = str.match(r1)!; expect(m1[0]).toBe("ain"); expect(m1[1]).toBe("AIN"); expect(m1[2]).toBe("ain"); @@ -709,37 +720,37 @@ it("String.prototype.split", () => { it("escapes characters, unicode, and hex", () => { for (const RegExpConstructor of [OnigurumaRegExp, RegExp]) { expect(new RegExpConstructor("[\\x00-\\x1F]").toString()).toBe( - "/[\\x00-\\x1F]/" + "/[\\x00-\\x1F]/", ); expect(new RegExpConstructor("[\\u0000-\\u001F]").toString()).toBe( - "/[\\u0000-\\u001F]/" + "/[\\u0000-\\u001F]/", ); var s = /\\x{7HHHHHHH}(?=\\u{1233})/; let a = new RegExpConstructor("\u{0001F46E}"); - expect(a.exec("👮")[0]).toBe("👮"); + expect(a.exec("👮")![0]).toBe("👮"); } let y = new OnigurumaRegExp("[👮\\x7F](?<=👮)"); - expect(y.exec("👮\\x{7F}")[0]).toBe("👮"); + expect(y.exec("👮\\x{7F}")![0]).toBe("👮"); let by = new OnigurumaRegExp("[👮\\cx7f](?<=👮)"); - expect(y.exec("👮\\x{7F}")[0]).toBe("👮"); + expect(y.exec("👮\\x{7F}")![0]).toBe("👮"); let bz = new OnigurumaRegExp("[👮\\x7](?<=👮)"); let d = new OnigurumaRegExp("[\u{0001F46E}\x7F](?<=\u{0001F46E})"); - expect(d.exec("👮\x7F")[0]).toBe("👮"); + expect(d.exec("👮\x7F")![0]).toBe("👮"); let y_2 = /[[👮\x7F](?<=👮)]/; - expect(y_2.exec("👮]")[0]).toBe("👮]"); + expect(y_2.exec("👮]")![0]).toBe("👮]"); let a1 = new OnigurumaRegExp("(f\xf3oo)", "gd"); let a1_1 = a1.exec("table f\xf3ootball, f\xf3oosball"); a1_1 = a1.exec("table f\xf3ootball, f\xf3oosball"); let a2 = new RegExp("(f\xf3oo)", "dg"); - let a2_1 = a2.exec("table f\xf3ootball, f\xf3oosball"); - a2_1 = a2.exec("table f\xf3ootball, f\xf3oosball"); + let a2_1 = a2.exec("table f\xf3ootball, f\xf3oosball")!; + a2_1 = a2.exec("table f\xf3ootball, f\xf3oosball")!; expect(a1_1[0]).toBe(a2_1[0]); expect(a1_1[1]).toBe(a2_1[1]); @@ -747,9 +758,13 @@ it("escapes characters, unicode, and hex", () => { expect(a1_1.input).toBe(a2_1.input); expect(a1.lastIndex).toBe(a2.lastIndex); expect(a1_1.groups).toBe(a2_1.groups); + // @ts-ignore expect(a1_1.indices[0][0]).toBe(a2_1.indices[0][0]); + // @ts-ignore expect(a1_1.indices[0][1]).toBe(a2_1.indices[0][1]); + // @ts-ignore expect(a1_1.indices[1][0]).toBe(a2_1.indices[1][0]); + // @ts-ignore expect(a1_1.indices[1][1]).toBe(a2_1.indices[1][1]); }); @@ -768,20 +783,20 @@ it("lookbehinds", () => { expect( /[\x00-\x1F\x27\x5C\x7F-\x9F]|[\uD800-\uDBFF]\(?<=[\uDC00-\uDFFF]\)|(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]).*[\uDC00-\uDFFF]/ instanceof - RegExp + RegExp, ).toBe(true); expect( /[\x00-\x1F\x27\x5C\x7F-\x9F]|[\uD800-\uDBFF](?<=[\uDC00-\uDFFF])|(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]).*[\uDC00-\uDFFF]/ instanceof - OnigurumaRegExp + OnigurumaRegExp, ).toBe(true); expect(/(?<=\1d(o))/ instanceof OnigurumaRegExp).toBe(true); expect(/\(?<=\1d(o)\)/ instanceof OnigurumaRegExp).toBe(false); expect( - /(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]).*[\uDC00-\uDFFF]/ instanceof RegExp + /(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]).*[\uDC00-\uDFFF]/ instanceof RegExp, ).toBe(true); expect( - /\(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]\).*[\uDC00-\uDFFF]/ instanceof RegExp + /\(?!.*[\uD800-\uDBFF][\uDC00-\uDFFF]\).*[\uDC00-\uDFFF]/ instanceof RegExp, ).toBe(true); let e = new OnigurumaRegExp("(?<=)"); diff --git a/test/bun.js/os.test.js b/test/bun.js/os.test.js index c368298cbe..792d2cf405 100644 --- a/test/bun.js/os.test.js +++ b/test/bun.js/os.test.js @@ -41,11 +41,11 @@ it("tmpdir", () => { if (process.platform === "win32") { expect(os.tmpdir()).toBe(process.env.TEMP || process.env.TMP); expect(os.tmpdir()).toBe( - `${process.env.SystemRoot || process.env.windir}\\temp` + `${process.env.SystemRoot || process.env.windir}\\temp`, ); } else { expect(os.tmpdir()).toBe( - process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp" + process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp", ); } }); @@ -57,8 +57,8 @@ it("hostname", () => { it("platform", () => { expect( ["win32", "darwin", "linux", "wasm"].some( - (platform) => os.platform() === platform - ) + (platform) => os.platform() === platform, + ), ).toBe(true); }); @@ -68,7 +68,7 @@ it("release", () => { it("type", () => { expect( - ["Windows_NT", "Darwin", "Linux"].some((type) => os.type() === type) + ["Windows_NT", "Darwin", "Linux"].some((type) => os.type() === type), ).toBe(true); }); diff --git a/test/bun.js/path.test.js b/test/bun.js/path.test.js index 72dad93d23..97132512c9 100644 --- a/test/bun.js/path.test.js +++ b/test/bun.js/path.test.js @@ -66,7 +66,7 @@ it("path.basename", () => { // On unix a backslash is just treated as any other character. strictEqual( path.posix.basename("\\dir\\basename.ext"), - "\\dir\\basename.ext" + "\\dir\\basename.ext", ); strictEqual(path.posix.basename("\\basename.ext"), "\\basename.ext"); strictEqual(path.posix.basename("basename.ext"), "basename.ext"); @@ -79,7 +79,7 @@ it("path.basename", () => { const controlCharFilename = `Icon${String.fromCharCode(13)}`; strictEqual( path.posix.basename(`/a/b/${controlCharFilename}`), - controlCharFilename + controlCharFilename, ); }); @@ -215,7 +215,7 @@ it("path.join", () => { if (actual !== expected && actualAlt !== expected) { const delimiter = test[0].map(JSON.stringify).join(","); const message = `path.${os}.join(${delimiter})\n expect=${JSON.stringify( - expected + expected, )}\n actual=${JSON.stringify(actual)}`; failures.push(`\n${message}`); } @@ -295,7 +295,7 @@ it("path.relative", () => { .slice(0, 2) .map(JSON.stringify) .join(",")})\n expect=${JSON.stringify( - expected + expected, )}\n actual=${JSON.stringify(actual)}`; failures.push(`\n${message}`); } @@ -355,7 +355,7 @@ it("path.normalize", () => { strictEqual( path.posix.normalize("./fixtures///b/../b/c.js"), - "fixtures/b/c.js" + "fixtures/b/c.js", ); strictEqual(path.posix.normalize("/foo/../../../bar"), "/bar"); strictEqual(path.posix.normalize("a//b//../b"), "a/b"); @@ -372,19 +372,19 @@ it("path.normalize", () => { strictEqual(path.posix.normalize("../.../.././.../../../bar"), "../../bar"); strictEqual( path.posix.normalize("../../../foo/../../../bar"), - "../../../../../bar" + "../../../../../bar", ); strictEqual( path.posix.normalize("../../../foo/../../../bar/../../"), - "../../../../../../" + "../../../../../../", ); strictEqual( path.posix.normalize("../foobar/barfoo/foo/../../../bar/../../"), - "../../" + "../../", ); strictEqual( path.posix.normalize("../.../../foobar/../../../bar/../../baz"), - "../../../../baz" + "../../../../baz", ); strictEqual(path.posix.normalize("foo/bar\\baz"), "foo/bar\\baz"); }); @@ -446,7 +446,7 @@ it("path.resolve", () => { const message = `path.${os}.resolve(${test .map(JSON.stringify) .join(",")})\n expect=${JSON.stringify( - expected + expected, )}\n actual=${JSON.stringify(actual)}`; if (actual !== expected && actualAlt !== expected) failures.push(message); }); diff --git a/test/bun.js/peek.test.ts b/test/bun.js/peek.test.ts index 90a7748f51..1c3920a4b3 100644 --- a/test/bun.js/peek.test.ts +++ b/test/bun.js/peek.test.ts @@ -22,11 +22,14 @@ test("peek", () => { // If we peek a rejected promise, it: // - returns the error // - does not mark the promise as handled - const rejected = Promise.reject( - new Error("Succesfully tested promise rejection") + const rejected = Promise.reject( + new Error("Succesfully tested promise rejection"), + ); + const peeked = peek(rejected); + expect(peeked instanceof Error).toBe(true); + expect((peeked as Error).message).toBe( + "Succesfully tested promise rejection", ); - expect(peek(rejected).message).toBe("Succesfully tested promise rejection"); - rejected.catch(() => {}); }); test("peek.status", () => { diff --git a/test/bun.js/performance.test.js b/test/bun.js/performance.test.js index 0ff75b9451..51479209cd 100644 --- a/test/bun.js/performance.test.js +++ b/test/bun.js/performance.test.js @@ -19,6 +19,6 @@ it("performance.now() should be monotonic", () => { it("performance.timeOrigin + performance.now() should be similar to Date.now()", () => { expect( - Math.abs(performance.timeOrigin + performance.now() - Date.now()) < 1000 + Math.abs(performance.timeOrigin + performance.now() - Date.now()) < 1000, ).toBe(true); }); diff --git a/test/bun.js/plugins.d.ts b/test/bun.js/plugins.d.ts new file mode 100644 index 0000000000..aebfd952b5 --- /dev/null +++ b/test/bun.js/plugins.d.ts @@ -0,0 +1,11 @@ +declare var objectModuleResult: any; +declare var laterCode: any; + +declare module "beep:*"; +declare module "async:*"; +declare module "asyncret:*"; +declare module "asyncfail:*"; +declare module "async-obj:*"; +declare module "obj:*"; +declare module "delay:*"; +declare module "./*.svelte"; diff --git a/test/bun.js/plugins.test.ts b/test/bun.js/plugins.test.ts index 6593b077d1..1d0b0821a9 100644 --- a/test/bun.js/plugins.test.ts +++ b/test/bun.js/plugins.test.ts @@ -1,3 +1,4 @@ +/// import { plugin } from "bun"; import { describe, expect, it } from "bun:test"; import { resolve } from "path"; @@ -45,7 +46,7 @@ plugin({ })); builder.onLoad( { filter: /.*/, namespace: "fail" }, - () => globalThis.failingObject + () => globalThis.failingObject, ); }, }); @@ -106,7 +107,7 @@ plugin({ }); }, 1); }); - } + }, ); builder.onResolve({ filter: /.*/, namespace: "asyncfail" }, ({ path }) => ({ @@ -121,7 +122,7 @@ plugin({ await Promise.resolve(1); await 1; throw globalThis.asyncfail; - } + }, ); builder.onResolve({ filter: /.*/, namespace: "asyncret" }, ({ path }) => ({ @@ -136,7 +137,7 @@ plugin({ await 100; await Promise.resolve(10); return await globalThis.asyncret; - } + }, ); }, }); @@ -170,7 +171,8 @@ describe("require", () => { describe("dynamic import", () => { it("SSRs `

Hello world!

` with Svelte", async () => { - const { default: App } = await import("./hello.svelte"); + const { default: App }: any = await import("./hello.svelte"); + const { html } = App.render(); expect(html).toBe("

Hello world!

"); @@ -240,7 +242,7 @@ describe("errors", () => { try { require(`fail:my-file-${loader}`); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } @@ -259,7 +261,7 @@ describe("errors", () => { try { require(`fail:my-file-${loader}-3`); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } @@ -273,7 +275,7 @@ describe("errors", () => { globalThis.asyncret = { wat: true }; await import("asyncret:my-file"); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } @@ -287,7 +289,7 @@ describe("errors", () => { globalThis.asyncfail = new Error("async error"); await import("asyncfail:my-file"); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } @@ -307,7 +309,7 @@ describe("errors", () => { try { require(`fail:my-file-${i}-2`); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } @@ -321,7 +323,7 @@ describe("errors", () => { globalThis.asyncOnLoad = `const x: string = -NaNAn../!!;`; await import("async:fail"); throw -1; - } catch (e) { + } catch (e: any) { if (e === -1) { throw new Error("Expected error"); } diff --git a/test/bun.js/print-process-args.js b/test/bun.js/print-process-args.js index 3d4540053c..0ab2381225 100644 --- a/test/bun.js/print-process-args.js +++ b/test/bun.js/print-process-args.js @@ -1,4 +1,4 @@ -var writer = Bun.stdout.writer() +var writer = Bun.stdout.writer(); writer.write(JSON.stringify(process.argv)); await writer.flush(true); -process.exit(0); \ No newline at end of file +process.exit(0); diff --git a/test/bun.js/process-args.test.js b/test/bun.js/process-args.test.js index 6bdfbf9e03..512b6b92cc 100644 --- a/test/bun.js/process-args.test.js +++ b/test/bun.js/process-args.test.js @@ -1,33 +1,41 @@ - import { spawn } from "bun"; import { test, expect } from "bun:test"; test("args exclude run", async () => { - const arg0 = process.argv[0]; - const arg1 = import.meta.dir + '/print-process-args.js'; + const arg0 = process.argv[0]; + const arg1 = import.meta.dir + "/print-process-args.js"; - const exe = process.versions.bun.includes("debug") ? "bun-debug" : "bun"; + const exe = process.versions.bun.includes("debug") ? "bun-debug" : "bun"; - const { stdout: s1 } = spawn([exe, "print-process-args.js"], { cwd: import.meta.dir }); - const t1 = JSON.parse(await new Response(s1).text()); - expect(t1[0]).toBe(arg0); - expect(t1[1]).toBe(arg1); + const { stdout: s1 } = spawn([exe, "print-process-args.js"], { + cwd: import.meta.dir, + }); + const t1 = JSON.parse(await new Response(s1).text()); + expect(t1[0]).toBe(arg0); + expect(t1[1]).toBe(arg1); - const { stdout: s2 } = spawn([exe, "print-process-args.js", "arg1"], { cwd: import.meta.dir }); - const t2 = JSON.parse(await new Response(s2).text()); - expect(t2[0]).toBe(arg0); - expect(t2[1]).toBe(arg1); - expect(t2[2]).toBe("arg1"); + const { stdout: s2 } = spawn([exe, "print-process-args.js", "arg1"], { + cwd: import.meta.dir, + }); + const t2 = JSON.parse(await new Response(s2).text()); + expect(t2[0]).toBe(arg0); + expect(t2[1]).toBe(arg1); + expect(t2[2]).toBe("arg1"); - const { stdout: s3 } = spawn([exe, "run", "print-process-args.js"], { cwd: import.meta.dir }); - const t3 = JSON.parse(await new Response(s3).text()); - expect(t3[0]).toBe(arg0); - expect(t3[1]).toBe(arg1); + const { stdout: s3 } = spawn([exe, "run", "print-process-args.js"], { + cwd: import.meta.dir, + }); + const t3 = JSON.parse(await new Response(s3).text()); + expect(t3[0]).toBe(arg0); + expect(t3[1]).toBe(arg1); - const { stdout: s4 } = spawn([exe, "run", "print-process-args.js", "arg1", "arg2"], { cwd: import.meta.dir }); - const t4 = JSON.parse(await new Response(s4).text()); - expect(t4[0]).toBe(arg0); - expect(t4[1]).toBe(arg1); - expect(t4[2]).toBe("arg1"); - expect(t4[3]).toBe("arg2"); -}); \ No newline at end of file + const { stdout: s4 } = spawn( + [exe, "run", "print-process-args.js", "arg1", "arg2"], + { cwd: import.meta.dir }, + ); + const t4 = JSON.parse(await new Response(s4).text()); + expect(t4[0]).toBe(arg0); + expect(t4[1]).toBe(arg1); + expect(t4[2]).toBe("arg1"); + expect(t4[3]).toBe("arg2"); +}); diff --git a/test/bun.js/process-nexttick.js b/test/bun.js/process-nexttick.js index 337977c0a7..ea9d0581eb 100644 --- a/test/bun.js/process-nexttick.js +++ b/test/bun.js/process-nexttick.js @@ -59,7 +59,7 @@ await new Promise((resolve, reject) => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is not a function" + "queueMicrotask should throw a TypeError if the argument is not a function", ); } @@ -73,7 +73,7 @@ await new Promise((resolve, reject) => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is empty" + "queueMicrotask should throw a TypeError if the argument is empty", ); } @@ -86,6 +86,6 @@ await new Promise((resolve, reject) => { resolve(true); }, 12345, - "hello" + "hello", ); }); diff --git a/test/bun.js/process-nexttick.test.js b/test/bun.js/process-nexttick.test.js index f6d2b7663f..a1b1b84b01 100644 --- a/test/bun.js/process-nexttick.test.js +++ b/test/bun.js/process-nexttick.test.js @@ -61,7 +61,7 @@ it("process.nextTick", async () => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is not a function" + "queueMicrotask should throw a TypeError if the argument is not a function", ); } @@ -75,7 +75,7 @@ it("process.nextTick", async () => { if (!passed) throw new Error( - "queueMicrotask should throw a TypeError if the argument is empty" + "queueMicrotask should throw a TypeError if the argument is empty", ); } }); @@ -89,7 +89,7 @@ it("process.nextTick 2 args", async () => { resolve(true); }, 12345, - "hello" + "hello", ); }); }); diff --git a/test/bun.js/process.test.js b/test/bun.js/process.test.js index 3ca93c9830..296e786cff 100644 --- a/test/bun.js/process.test.js +++ b/test/bun.js/process.test.js @@ -40,7 +40,7 @@ it("process", () => { if (typeof JSON.parse(JSON.stringify(process.env)).toJSON !== "undefined") { throw new Error( - "process.env should call toJSON to hide its internal state" + "process.env should call toJSON to hide its internal state", ); } @@ -72,6 +72,6 @@ it("process.release", () => { expect(process.release.sourceUrl).toBe( `https://github.com/oven-sh/bun/release/bun-v${process.versions.bun}/bun-${ process.platform - }-${{ arm64: "aarch64", x64: "x64" }[process.arch] || process.arch}.zip` + }-${{ arm64: "aarch64", x64: "x64" }[process.arch] || process.arch}.zip`, ); }); diff --git a/test/bun.js/react-dom-server.bun.cjs b/test/bun.js/react-dom-server.bun.cjs index 9cc42cc6a3..6367ee8aa0 100644 --- a/test/bun.js/react-dom-server.bun.cjs +++ b/test/bun.js/react-dom-server.bun.cjs @@ -1,5 +1,5 @@ /** -* @license React + * @license React * react-dom-server.bun.production.min.js * * Copyright (c) Meta Platforms, Inc. and affiliates. @@ -8,131 +8,2995 @@ * LICENSE file in the root directory of this source tree. */ -'use strict';var ba=require("react"),ca=require("react-dom");function l(a,b){0!==b.length&&a.write(b)}function da(a,b){"function"===typeof a.error?a.error(b):a.close()} -var r=Object.prototype.hasOwnProperty,ea=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,fa={},ha={}; -function ia(a){if(r.call(ha,a))return!0;if(r.call(fa,a))return!1;if(ea.test(a))return ha[a]=!0;fa[a]=!0;return!1}function t(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var v={},ja="children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" "); -ja.push("innerText","textContent");ja.forEach(function(a){v[a]=new t(a,0,!1,a,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];v[b]=new t(b,1,!1,a[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(a){v[a]=new t(a,2,!1,a.toLowerCase(),null,!1,!1)}); -["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){v[a]=new t(a,2,!1,a,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){v[a]=new t(a,3,!1,a.toLowerCase(),null,!1,!1)}); -["checked","multiple","muted","selected"].forEach(function(a){v[a]=new t(a,3,!0,a,null,!1,!1)});["capture","download"].forEach(function(a){v[a]=new t(a,4,!1,a,null,!1,!1)});["cols","rows","size","span"].forEach(function(a){v[a]=new t(a,6,!1,a,null,!1,!1)});["rowSpan","start"].forEach(function(a){v[a]=new t(a,5,!1,a.toLowerCase(),null,!1,!1)});var ka=/[\-:]([a-z])/g;function la(a){return a[1].toUpperCase()} -"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(ka, -la);v[b]=new t(b,1,!1,a,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(ka,la);v[b]=new t(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(ka,la);v[b]=new t(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(a){v[a]=new t(a,1,!1,a.toLowerCase(),null,!1,!1)}); -v.xlinkHref=new t("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){v[a]=new t(a,1,!1,a.toLowerCase(),null,!0,!0)}); -var ma={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0, -zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},na=["Webkit","ms","Moz","O"];Object.keys(ma).forEach(function(a){na.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);ma[b]=ma[a]})});var oa=/["'&<>]/; -function w(a){if("boolean"===typeof a||"number"===typeof a)return""+a;a=""+a;var b=oa.exec(a);if(b){var c="",d,e=0;for(d=b.index;d":'