tree 56a8551201f826d2ddf611384a1e73d0ff7276d5
parent 41f14ed95037b78266fd0de6fbcb63603e1f5866
author dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> 1704131585 +0000
committer GitHub <noreply@github.com> 1704131585 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJlkvwBCRBK7hj4Ov3rIwAACUYIADStmd4qMyRW7MUTSMst7lue
 9ErKjvYZPpWY5UmBOns/TpMetizSAd7O4QLr/ItOQsN8/mzeqPnr60Av+WbeiCIZ
 4SPAm0DPoT20h6OZsCrs7+ARRA3pArFdkT1aIoiDr9713Kf1FUMZSN9OIQuI6zBN
 jqnedTJoMyjTEE7YF2GU0o3/9wCsVHS7f1ra/ELVENZW2nmkDiFagkcKZ0LOSq7Q
 y+Jp/CBrzsbYHARnc1r3WCPo8fubJty9cJ6hSn59WfpXqEY0e1KpmyEY7M944SII
 fKZSUoG3Ua4I2xuL74CqPl0yA9v7FKazNCjH9oxfIcuOffbvD7OCmwBHaCw5UeU=
 =ful/
 -----END PGP SIGNATURE-----
 

Bump animations from 2.0.8 to 2.0.10 (#1067)

Bumps [animations](https://github.com/flutter/packages/tree/main/packages) from 2.0.8 to 2.0.10.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/flutter/packages/commit/c0b30f18f11a274d0458d0b60e011ace771ec262"><code>c0b30f1</code></a> [animations] Bump minimum supported Dart version to 3.2 (<a href="https://github.com/flutter/packages/tree/main/packages/issues/5598">#5598</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/c7048241ea0ddf46c3342a897c85da48a7bfe714"><code>c704824</code></a> [animations] Bump minimum Flutter version (<a href="https://github.com/flutter/packages/tree/main/packages/issues/5596">#5596</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/74b0892305453752d4d35baa37d031b2a0e6954a"><code>74b0892</code></a> Migrate Material curves to new names (<a href="https://github.com/flutter/packages/tree/main/packages/issues/4898">#4898</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/c9033ca1e9fba1dbea4cad71a84c4f9bc55c8e40"><code>c9033ca</code></a> Reverts &quot;[pointer_interceptor] Add ios implementation and move web implementa...</li>
<li><a href="https://github.com/flutter/packages/commit/96310cc32b67a153d386fa7f3ed9345639b73fde"><code>96310cc</code></a> [pointer_interceptor] Add ios implementation and move web implementation to f...</li>
<li><a href="https://github.com/flutter/packages/commit/49a60b8071a28bec634b2d443e8daade33111729"><code>49a60b8</code></a> [pigeon] Use dart:io output inheritance for tooling (<a href="https://github.com/flutter/packages/tree/main/packages/issues/5536">#5536</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/9a55d4cb9fc79080548a4056e8d48b841155bd92"><code>9a55d4c</code></a> Fix benchmark reload bug and migrate away from deprecated <code>js_util</code> APIs (<a href="https://github.com/flutter/packages/tree/main/packages/issues/5577">#5577</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/afd451711a77473c76d35a4286f105b3674c85e4"><code>afd4517</code></a> [google_sign_in] Add macOS support (<a href="https://github.com/flutter/packages/tree/main/packages/issues/4962">#4962</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/cc11b149936fabaa2a4f0452c1af56411a9a985d"><code>cc11b14</code></a> [rfw,flutter_markdown] Apparently you need a comma to end an //ignore (<a href="https://github.com/flutter/packages/tree/main/packages/issues/5582">#5582</a>)</li>
<li><a href="https://github.com/flutter/packages/commit/8be3268d979a59b6e8007d7c8ba460a05b6845fb"><code>8be3268</code></a> [file_selector] Remove deprecated <code>primary</code> and <code>onPrimary</code> references from `...</li>
<li>Additional commits viewable in <a href="https://github.com/flutter/packages/commits/animations-v2.0.10/packages">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=animations&package-manager=pub&previous-version=2.0.8&new-version=2.0.10)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`.

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>