bump(deps): update dependency esbuild to ^0.18.10 (#479)

[![Mend
Renovate](https://app.renovatebot.com/images/banner.svg)](https://renovatebot.com)

This PR contains the following updates:

| Package | Change | Age | Adoption | Passing | Confidence |
|---|---|---|---|---|---|
| [esbuild](https://togithub.com/evanw/esbuild) | [`^0.18.2` ->
`^0.18.10`](https://renovatebot.com/diffs/npm/esbuild/0.18.6/0.18.10) |
[![age](https://badges.renovateapi.com/packages/npm/esbuild/0.18.10/age-slim)](https://docs.renovatebot.com/merge-confidence/)
|
[![adoption](https://badges.renovateapi.com/packages/npm/esbuild/0.18.10/adoption-slim)](https://docs.renovatebot.com/merge-confidence/)
|
[![passing](https://badges.renovateapi.com/packages/npm/esbuild/0.18.10/compatibility-slim/0.18.6)](https://docs.renovatebot.com/merge-confidence/)
|
[![confidence](https://badges.renovateapi.com/packages/npm/esbuild/0.18.10/confidence-slim/0.18.6)](https://docs.renovatebot.com/merge-confidence/)
|

---

### Release Notes

<details>
<summary>evanw/esbuild (esbuild)</summary>

###
[`v0.18.10`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#&#8203;01810)

[Compare
Source](https://togithub.com/evanw/esbuild/compare/v0.18.9...v0.18.10)

- Fix a tree-shaking bug that removed side effects
([#&#8203;3195](https://togithub.com/evanw/esbuild/issues/3195))

This fixes a regression in version 0.18.4 where combining
`--minify-syntax` with `--keep-names` could cause expressions with side
effects after a function declaration to be considered side-effect free
for tree shaking purposes. The reason was because `--keep-names`
generates an expression statement containing a call to a helper function
after the function declaration with a special flag that makes the
function call able to be tree shaken, and then `--minify-syntax` could
potentially merge that expression statement with following expressions
without clearing the flag. This release fixes the bug by clearing the
flag when merging expression statements together.

- Fix an incorrect warning about CSS nesting
([#&#8203;3197](https://togithub.com/evanw/esbuild/issues/3197))

A warning is currently generated when transforming nested CSS to a
browser that doesn't support `:is()` because transformed nested CSS may
need to use that feature to represent nesting. This was previously
always triggered when an at-rule was encountered in a declaration
context. Typically the only case you would encounter this is when using
CSS nesting within a selector rule. However, there is a case where
that's not true: when using a margin at-rule such as `@top-left` within
`@page`. This release avoids incorrectly generating a warning in this
case by checking that the at-rule is within a selector rule before
generating a warning.

###
[`v0.18.9`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#&#8203;0189)

[Compare
Source](https://togithub.com/evanw/esbuild/compare/v0.18.8...v0.18.9)

-   Fix `await using` declarations inside `async` generator functions

I forgot about the new `await using` declarations when implementing
lowering for `async` generator functions in the previous release. This
change fixes the transformation of `await using` declarations when they
are inside lowered `async` generator functions:

    ```js
    // Original code
    async function* foo() {
      await using x = await y
    }

    // Old output (with --supported:async-generator=false)
    function foo() {
      return __asyncGenerator(this, null, function* () {
        await using x = yield new __await(y);
      });
    }

    // New output (with --supported:async-generator=false)
    function foo() {
      return __asyncGenerator(this, null, function* () {
        var _stack = [];
        try {
          const x = __using(_stack, yield new __await(y), true);
        } catch (_) {
          var _error = _, _hasError = true;
        } finally {
          var _promise = __callDispose(_stack, _error, _hasError);
          _promise && (yield new __await(_promise));
        }
      });
    }
    ```

- Insert some prefixed CSS properties when appropriate
([#&#8203;3122](https://togithub.com/evanw/esbuild/issues/3122))

With this release, esbuild will now insert prefixed CSS properties in
certain cases when the `target` setting includes browsers that require a
certain prefix. This is currently done for the following properties:

    -   `appearance: *;` => `-webkit-appearance: *; -moz-appearance: *;`
    -   `backdrop-filter: *;` => `-webkit-backdrop-filter: *;`
    -   `background-clip: text` => `-webkit-background-clip: text;`
    -   `box-decoration-break: *;` => `-webkit-box-decoration-break: *;`
    -   `clip-path: *;` => `-webkit-clip-path: *;`
    -   `font-kerning: *;` => `-webkit-font-kerning: *;`
    -   `hyphens: *;` => `-webkit-hyphens: *;`
    -   `initial-letter: *;` => `-webkit-initial-letter: *;`
    -   `mask-image: *;` => `-webkit-mask-image: *;`
    -   `mask-origin: *;` => `-webkit-mask-origin: *;`
    -   `mask-position: *;` => `-webkit-mask-position: *;`
    -   `mask-repeat: *;` => `-webkit-mask-repeat: *;`
    -   `mask-size: *;` => `-webkit-mask-size: *;`
    -   `position: sticky;` => `position: -webkit-sticky;`
    -   `print-color-adjust: *;` => `-webkit-print-color-adjust: *;`
    -   `tab-size: *;` => `-moz-tab-size: *; -o-tab-size: *;`
- `text-decoration-color: *;` => `-webkit-text-decoration-color: *;
-moz-text-decoration-color: *;`
- `text-decoration-line: *;` => `-webkit-text-decoration-line: *;
-moz-text-decoration-line: *;`
    -   `text-decoration-skip: *;` => `-webkit-text-decoration-skip: *;`
    -   `text-emphasis-color: *;` => `-webkit-text-emphasis-color: *;`
- `text-emphasis-position: *;` => `-webkit-text-emphasis-position: *;`
    -   `text-emphasis-style: *;` => `-webkit-text-emphasis-style: *;`
    -   `text-orientation: *;` => `-webkit-text-orientation: *;`
- `text-size-adjust: *;` => `-webkit-text-size-adjust: *;
-ms-text-size-adjust: *;`
- `user-select: *;` => `-webkit-user-select: *; -moz-user-select: *;
-ms-user-select: *;`

    Here is an example:

    ```css
    /* Original code */
    div {
      mask-image: url(x.png);
    }

    /* Old output (with --target=chrome99) */
    div {
      mask-image: url(x.png);
    }

    /* New output (with --target=chrome99) */
    div {
      -webkit-mask-image: url(x.png);
      mask-image: url(x.png);
    }
    ```

Browser compatibility data was sourced from the tables on
https://caniuse.com. Support for more CSS properties can be added in the
future as appropriate.

- Fix an obscure identifier minification bug
([#&#8203;2809](https://togithub.com/evanw/esbuild/issues/2809))

Function declarations in nested scopes behave differently depending on
whether or not `"use strict"` is present. To avoid generating code that
behaves differently depending on whether strict mode is enabled or not,
esbuild transforms nested function declarations into variable
declarations. However, there was a bug where the generated variable name
was not being recorded as declared internally, which meant that it
wasn't being renamed correctly by the minifier and could cause a name
collision. This bug has been fixed:

    ```js
    // Original code
    const n = ''
    for (let i of [0,1]) {
      function f () {}
    }

    // Old output (with --minify-identifiers --format=esm)
    const f = "";
    for (let o of [0, 1]) {
      let n = function() {
      };
      var f = n;
    }

    // New output (with --minify-identifiers --format=esm)
    const f = "";
    for (let o of [0, 1]) {
      let n = function() {
      };
      var t = n;
    }
    ```

- Fix a bug in esbuild's compatibility table script
([#&#8203;3179](https://togithub.com/evanw/esbuild/pull/3179))

Setting esbuild's `target` to a specific JavaScript engine tells esbuild
to use the JavaScript syntax feature compatibility data from
https://kangax.github.io/compat-table/es6/ for that engine to determine
which syntax features to allow. However, esbuild's script that builds
this internal compatibility table had a bug that incorrectly ignores
tests for engines that still have outstanding implementation bugs which
were never fixed. This change fixes this bug with the script.

The only case where this changed the information in esbuild's internal
compatibility table is that the `hermes` target is marked as no longer
supporting destructuring. This is because there is a failing
destructuring-related test for Hermes on
https://kangax.github.io/compat-table/es6/. If you want to use
destructuring with Hermes anyway, you can pass
`--supported:destructuring=true` to esbuild to override the `hermes`
target and force esbuild to accept this syntax.

This fix was contributed by
[@&#8203;ArrayZoneYour](https://togithub.com/ArrayZoneYour).

###
[`v0.18.8`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#&#8203;0188)

[Compare
Source](https://togithub.com/evanw/esbuild/compare/v0.18.7...v0.18.8)

- Implement transforming `async` generator functions
([#&#8203;2780](https://togithub.com/evanw/esbuild/issues/2780))

With this release, esbuild will now transform `async` generator
functions into normal generator functions when the configured target
environment doesn't support them. These functions behave similar to
normal generator functions except that they use the
`Symbol.asyncIterator` interface instead of the `Symbol.iterator`
interface and the iteration methods return promises. Here's an example
(helper functions are omitted):

    ```js
    // Original code
    async function* foo() {
      yield Promise.resolve(1)
      await new Promise(r => setTimeout(r, 100))
      yield *[Promise.resolve(2)]
    }
    async function bar() {
      for await (const x of foo()) {
        console.log(x)
      }
    }
    bar()

    // New output (with --target=es6)
    function foo() {
      return __asyncGenerator(this, null, function* () {
        yield Promise.resolve(1);
        yield new __await(new Promise((r) => setTimeout(r, 100)));
        yield* __yieldStar([Promise.resolve(2)]);
      });
    }
    function bar() {
      return __async(this, null, function* () {
        try {
for (var iter = __forAwait(foo()), more, temp, error; more = !(temp =
yield iter.next()).done; more = false) {
            const x = temp.value;
            console.log(x);
          }
        } catch (temp) {
          error = [temp];
        } finally {
          try {
            more && (temp = iter.return) && (yield temp.call(iter));
          } finally {
            if (error)
              throw error[0];
          }
        }
      });
    }
    bar();
    ```

This is an older feature that was added to JavaScript in ES2018 but I
didn't implement the transformation then because it's a rarely-used
feature. Note that esbuild already added support for transforming `for
await` loops (the other part of the [asynchronous iteration
proposal](https://togithub.com/tc39/proposal-async-iteration)) a year
ago, so support for asynchronous iteration should now be complete.

I have never used this feature myself and code that uses this feature is
hard to come by, so this transformation has not yet been tested on
real-world code. If you do write code that uses this feature, please let
me know if esbuild's `async` generator transformation doesn't work with
your code.

###
[`v0.18.7`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#&#8203;0187)

[Compare
Source](https://togithub.com/evanw/esbuild/compare/v0.18.6...v0.18.7)

- Add support for `using` declarations in TypeScript 5.2+
([#&#8203;3191](https://togithub.com/evanw/esbuild/issues/3191))

TypeScript 5.2 (due to be released in August of 2023) will introduce
`using` declarations, which will allow you to automatically dispose of
the declared resources when leaving the current scope. You can read the
[TypeScript PR for this
feature](https://togithub.com/microsoft/TypeScript/pull/54505) for more
information. This release of esbuild adds support for transforming this
syntax to target environments without support for `using` declarations
(which is currently all targets other than `esnext`). Here's an example
(helper functions are omitted):

    ```js
    // Original code
    class Foo {
      [Symbol.dispose]() {
        console.log('cleanup')
      }
    }
    using foo = new Foo;
    foo.bar();

    // New output (with --target=es6)
    var _stack = [];
    try {
      var Foo = class {
        [Symbol.dispose]() {
          console.log("cleanup");
        }
      };
      var foo = __using(_stack, new Foo());
      foo.bar();
    } catch (_) {
      var _error = _, _hasError = true;
    } finally {
      __callDispose(_stack, _error, _hasError);
    }
    ```

The injected helper functions ensure that the method named
`Symbol.dispose` is called on `new Foo` when control exits the scope.
Note that as with all new JavaScript APIs, you'll need to polyfill
`Symbol.dispose` if it's not present before you use it. This is not
something that esbuild does for you because esbuild only handles syntax,
not APIs. Polyfilling it can be done with something like this:

    ```js
    Symbol.dispose ||= Symbol('Symbol.dispose')
    ```

This feature also introduces `await using` declarations which are like
`using` declarations but they call `await` on the disposal method (not
on the initializer). Here's an example (helper functions are omitted):

    ```js
    // Original code
    class Foo {
      async [Symbol.asyncDispose]() {
        await new Promise(done => {
          setTimeout(done, 1000)
        })
        console.log('cleanup')
      }
    }
    await using foo = new Foo;
    foo.bar();

    // New output (with --target=es2022)
    var _stack = [];
    try {
      var Foo = class {
        async [Symbol.asyncDispose]() {
          await new Promise((done) => {
            setTimeout(done, 1e3);
          });
          console.log("cleanup");
        }
      };
      var foo = __using(_stack, new Foo(), true);
      foo.bar();
    } catch (_) {
      var _error = _, _hasError = true;
    } finally {
      var _promise = __callDispose(_stack, _error, _hasError);
      _promise && await _promise;
    }
    ```

The injected helper functions ensure that the method named
`Symbol.asyncDispose` is called on `new Foo` when control exits the
scope, and that the returned promise is awaited. Similarly to
`Symbol.dispose`, you'll also need to polyfill `Symbol.asyncDispose`
before you use it.

- Add a `--line-limit=` flag to limit line length
([#&#8203;3170](https://togithub.com/evanw/esbuild/issues/3170))

Long lines are common in minified code. However, many tools and text
editors can't handle long lines. This release introduces the
`--line-limit=` flag to tell esbuild to wrap lines longer than the
provided number of bytes. For example, `--line-limit=80` tells esbuild
to insert a newline soon after a given line reaches 80 bytes in length.
This setting applies to both JavaScript and CSS, and works even when
minification is disabled. Note that turning this setting on will make
your files bigger, as the extra newlines take up additional space in the
file (even after gzip compression).

</details>

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined),
Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

This PR has been generated by [Mend
Renovate](https://www.mend.io/free-developer-tools/renovate/). View
repository job log
[here](https://developer.mend.io/github/levaintech/contented).

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNS4xMTcuMyIsInVwZGF0ZWRJblZlciI6IjM1LjE0MS4zIiwidGFyZ2V0QnJhbmNoIjoibWFpbiJ9-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

packages/jest-preset/package.json

@@ -12,7 +12,7 @@
  },
  "dependencies": {
  "@stickyjs/jest": "1.1.2",
- "esbuild": "^0.18.2",
+ "esbuild": "^0.18.10",
  "esbuild-jest": "^0.5.0"
  }
 }