First working commit (though running in Actions might require some authentication tweaks)

.gitignore

@@ -1,3 +1,4 @@
 !node_modules/
 !dist/
+working/
 

README.md

@@ -0,0 +1,48 @@
+# Prerequisites
+
+* **Repos must use `main` as the default branch.** Come on, it's been like 5 years.
+  * ...ok _fine_ I will consider adding customization for this. But not a priority to begin with.
+* **Source and Target repos' history on `main` must be linear** - no merge commits
+  * Personally, I believe that they should always be like that, but I do respect the fact that other people disagree. Since I predict that the number of people using this can be counted on one hand, though, I don't respect that fact _enough_ to implement it right-off-the-bat - YAGNI (and if you _DO_ "NI", please feel free to tell me and I'll take a look at whether I can actually do it)
+  * To be clear - the action should still be able to _operate_ on histories with merge commits (though, if you're still reading that as "_should be able to_" and not "_can_, I can't promise that I've actually implemented and tested it yet), it just won't sync any commits that aren't in the transitive-first-parent chain[^difference-with-parents].
+* **No two source repos can have commits that happened at the exact same time.** It would be technically possible to implement this[^can-you-implement-it], but it would be an _arse_: finding "_the first commit in RepoB earlier than or equal to commit-X in RepoA_" is a query that, _under this constraint only_, can then be used to immediately determine "_does this match the resultant description required in RepoB? If not, we write-in; if so, we **assume that this source commit has already been represented**, and skip it in_", whereas if two commits can have identically-timed commits, it can be the case that in fact we find a target commit ("_latest before the given source commit_") that doesn't match the source commit, even though a matching target commit could exist (at the same time, but earlier by `git log` sub-ordering), resulting in a loop where two repos would keep inserting themselves after the others' equivalent-time representation.
+  * ...I think a diagram would help here if I had to explain it to someone :
+
+Explicitly ok - you _can_ run this on a target repo containing no commit, it's not necessary to create an awkward `README.md`-only commit to "prime" the repo[^could-create].
+
+Not a prerequisite, but a practicality note - I _think_ this will has a runtime[^no-network] which is quasi-quadratic - i.e. `O(<number_of_commits_requested_to_sync_from_source_repo> * <number_of_commits_in_target_repo_after_that>)`. Ideally, you should limit to only syncing a limited number of commits - if you trigger it on _every_ push of the source repo, it'll be kept up-to-date from there on. That does mean that you won't get any retroactive history, though - so, by all means _try_ a one-off `limit: 0` to sync "_everything from all time in the source repo_"; but if that times-out, maybe use Binary Search to figure out how many commits would complete in whatever your runtime limitation is, then accept that as your available history? Or temporarily acquire a runtime executor with more runtime (that's fancy-speak for - instead of running it on your CI/CD Platform, run it on a developer's workstation and leave it on overnight :P)
+
+If a target-repo gets so unreasonably large that even the runtime of syncing it from a single commit is too high, then I guess you could trigger writing to different target repos from each source repo in some hash-identified way - but, as I've said many times already in this project, YAGNI :P
+
+# FAQs
+
+## Why not just use Gitea's existing mirroring functionality?
+
+(As described [here](https://docs.gitea.com/usage/repo-mirror#pushing-to-a-remote-repository))
+
+Four reasons (I do not claim that they are equally convincing):
+* Repository-syncing is, AFAIK, set from a UI interaction - there is no listed API for it (so it can't be activated programmatically), nor is it possible to activate it by putting a templated metadata/configuration file in the repo, as with Dependabot, etc. (so it can't be part of a repository template). By contrast, if this functionality is activated via `workflows/*.yaml` file, it can be created in a freshly-initialized repository from a (cookiecutter, or similar) template.
+* Many (although not necessarily all) self-hosters see virtue in reducing the value of GitHub. The more code is hosted elsewhere than it - even if GH has an "index" of that code - the more normalized decentralized and federated systems will become. Those who self-host Gitea, therefore, are likely to enjoy the opportunity to benefit from GitHub's status as a well-understood and discoverable by integrating with its recognition product, while denying it much of the value of the code itself.
+* Writing code for yourself helps you understand the systems and tools better.
+* This is an project that feels easily within my capabilities, but still sizable enough to have several moving parts. As I'm in an early test period of figuring out whether Cursor (and AI Dev Tools in general) are actually worth it, so using them on a project that doesn't stretch me in other ways is sensible - only change one thing at a time to see whether it makes a difference! If I'd taken on a hard project and tried to use Cursor for it, I would have been simultaneously spending brain power on "_solving the problem_" as well as "_learning the tool_"  - reducing my ability to focus on the latter. I also might have been tempted to use the tool to answer in areas where I would have had zero capability to check it for correctness, thus reducing my ability to accurately evaluate the tool's utility.
+
+## Doesn't this already exist?
+
+Not that I know of. In particular - [this](https://github.com/Shpota/github-activity-generator) merely generates "noise", not based on real commits. _It_ is clearly intended to falsify a GitHub contribution history; whereas this is intended to make sure it _accurately_ reflects commits, even those recorded on a different forge.
+
+Incidentally, this is also kinda my answer to a different FAQ: **Isn't this forbidden by ToS?**? I mean...I don't _think_ so, because if [that other repo](https://github.com/Shpota/github-activity-generator) is still up and unbanned, you gotta assume GitHub is fine with this. I don't see any moral reason why it _should_ be forbidden, either:
+* It doesn't consume an unreasonable amount of system resources (less, in fact, that Gitea mirroring would do, because less file data is being transferred)
+* No lie is being told about productivity - the commits being represented _are real commits_, no-one is lying about how much work they've done (unlike with the other repo).
+
+## The UI shows all the commits as just having been created! This thing is broken!
+
+...Form of a question?
+
+But, nah, it's not - well, I haven't tested on GitHub _yet_, but at least on Gitea the "commit history" page shows the _push_ time of commits, not their actual _commit_ time. You can confirm their commit time by clicking into the actual commit's detail page, then hovering over the date _there_ - which is the commit time (also visible in `git log` if you check it out).
+
+I gotta assume that that's enough for GitHub history rewrite to be legal, if [that other repo](https://github.com/Shpota/github-activity-generator) works. If not...I will consider myself the most-trolled I've ever been...
+
+[^could-create]: I guess another feature request could be - if the target repo doesn't exist, create it! I'm going to rephrase my common refrain here to IAGNI - **I* ain't gonna need it. But if you want it for some reason (idk why you would be programmatically creating target repos unless some serious scale is going on...and I kinda wanna calculate that now...Hmm, TODO), ask for it and it shouldn't be hard for me to add it.
+[^no-network]: Note that no network resources or API calls are used in this quadratic period, so you don't run a risk of overloading anything (including your wallet). These potentially-costly operations are linear _in number_ in repo size - two pulls, one push - though note of course that pulling a larger repo takes more literal throughput. But I'm not aware of any provider that has significant limitations on that? Because, y'know, monorepos exist at large companies and are (one assumes?) regularly pulled (at least once every time a developer onboards), and you are not gonna get near their sizes unless you're a company (and if you are, pay me to implement that feature :P )
+[^difference-with-parents]: Difference in implementation would be to make sure to split `parentHashes` on `,` and pick the first, I guess. But I CBA to create a source repo to test it on. If I go to _deliberately_ implement that, rather than it maybe happening by-chace, I'll write a test for it.
+[^can-you-implement-it]: Actually I don't know if it _would_ be possible to implement this - I don't know if `git` would even allow two commits at the same time in a target repo. Gotta assume it does given how many folks love to trumpet the fact that they have monorepos - at the scale of possible-committers they're at (especially considering automated tools making updates) there's _gotta_ be potential for a time-collision - just not _earlier than_ parent seems like a reasonable constraint. Might be fun to write a test for "child-younger-than-parent", but I think any such repo is f$^*-ed up enough to justify not supporting it. But, ok then, due to that potential, I guess _technically_ another prerequisite is actually **No source repo may have a parent that happened later than a child**. If you had to read this far into the small print to figure this out when you encountered an error, then, frankly, you brought this on yourself and I hope you are feeling suitably embarassed 😜

dist/index.js

@@ -25683,13 +25683,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const core = __importStar(__nccwpck_require__(7484));
+const main_1 = __nccwpck_require__(1730);
 async function run() {
     try {
         // Get input defined in action.yml
-        const exampleInput = core.getInput('example-input');
+        const domain = core.getInput('target-repo-domain');
-        console.log(`Input received: ${exampleInput}`);
+        console.log(`Input Domain received: ${domain}`);
-        // Do something with the input
+        const owner = core.getInput('target-repo-owner');
-        // ...
+        console.log(`Input Owner received: ${owner}`);
+        const name = core.getInput('target-repo-name');
+        console.log(`Input Name received: ${name}`);
+        await (0, main_1.main)(domain, owner, name);
         // Set output
         core.setOutput('example-output', 'some value');
     }
@@ -25702,6 +25706,26 @@ async function run() {
 run();
 
 
+/***/ }),
+
+/***/ 1730:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.main = main;
+const child_process_1 = __nccwpck_require__(5317);
+async function main(targetRepoDomain, targetRepoOwner, targetRepoName) {
+    const repoPath = `${targetRepoDomain}/${targetRepoOwner}/${targetRepoName}`;
+    console.log(`DEBUG - repoPath: ${repoPath}`);
+    // TODO - parametrize the scheme
+    (0, child_process_1.execSync)(`git clone https://${repoPath}`);
+    const logOutput = (0, child_process_1.execSync)(`git log --pretty=format:"%h - %an, %ar : %s"`);
+    console.log(logOutput.toString());
+}
+
+
 /***/ }),
 
 /***/ 2613:

node_modules/date-fns/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sasha Koss and Lesha Koss https://kossnocorp.mit-license.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/date-fns/README.md

@@ -0,0 +1,58 @@
+🔥️ **NEW**: [date-fns v4.0 with first-class time zone support is out!](https://blog.date-fns.org/v40-with-time-zone-support/)
+
+<img alt="date-fns" title="date-fns" src="https://raw.githubusercontent.com/date-fns/date-fns/master/docs/logotype.svg" width="150" />
+
+date-fns provides the most comprehensive, yet simple and consistent toolset for manipulating JavaScript dates in a browser & Node.js
+
+👉 [Documentation](https://date-fns.org/)
+
+👉 [Blog](https://blog.date-fns.org/)
+
+<hr>
+
+It's like [Lodash](https://lodash.com) for dates
+
+- It has [**200+ functions** for all occasions](https://date-fns.org/docs/Getting-Started/).
+- **Modular**: Pick what you need. Works with webpack, Browserify, or Rollup and also supports tree-shaking.
+- **Native dates**: Uses existing native type. It doesn't extend core objects for safety's sake.
+- **Immutable & Pure**: Built using pure functions and always returns a new date instance.
+- **TypeScript**: The library is 100% TypeScript with brand-new handcrafted types.
+- **I18n**: Dozens of locales. Include only what you need.
+- [and many more benefits](https://date-fns.org/)
+
+```js
+import { compareAsc, format } from "date-fns";
+
+format(new Date(2014, 1, 11), "yyyy-MM-dd");
+//=> '2014-02-11'
+
+const dates = [
+  new Date(1995, 6, 2),
+  new Date(1987, 1, 11),
+  new Date(1989, 6, 10),
+];
+dates.sort(compareAsc);
+//=> [
+//   Wed Feb 11 1987 00:00:00,
+//   Mon Jul 10 1989 00:00:00,
+//   Sun Jul 02 1995 00:00:00
+// ]
+```
+
+The library is available as an [npm package](https://www.npmjs.com/package/date-fns).
+To install the package run:
+
+```bash
+npm install date-fns --save
+```
+
+## Docs
+
+[See date-fns.org](https://date-fns.org/) for more details, API,
+and other docs.
+
+<br />
+
+## License
+
+[MIT © Sasha Koss](https://kossnocorp.mit-license.org/)

node_modules/date-fns/SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+Security updates are applied only to the latest release.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** 
+This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
+Please disclose it to [Sasha Koss](mailto:koss@nocorp.me). This project is maintained by a team of volunteers
+on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure.

node_modules/date-fns/_lib/addLeadingZeros.cjs

@@ -0,0 +1,7 @@
+"use strict";
+exports.addLeadingZeros = addLeadingZeros;
+function addLeadingZeros(number, targetLength) {
+  const sign = number < 0 ? "-" : "";
+  const output = Math.abs(number).toString().padStart(targetLength, "0");
+  return sign + output;
+}

node_modules/date-fns/_lib/addLeadingZeros.d.cts

@@ -0,0 +1,4 @@
+export declare function addLeadingZeros(
+  number: number,
+  targetLength: number,
+): string;

node_modules/date-fns/_lib/addLeadingZeros.js

@@ -0,0 +1,5 @@
+export function addLeadingZeros(number, targetLength) {
+  const sign = number < 0 ? "-" : "";
+  const output = Math.abs(number).toString().padStart(targetLength, "0");
+  return sign + output;
+}

node_modules/date-fns/_lib/defaultLocale.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "defaultLocale", {
+  enumerable: true,
+  get: function () {
+    return _index.enUS;
+  },
+});
+var _index = require("../locale/en-US.cjs");

node_modules/date-fns/_lib/defaultLocale.d.cts

@@ -0,0 +1 @@
+export { enUS as defaultLocale } from "../locale/en-US.js";

node_modules/date-fns/_lib/defaultLocale.js

@@ -0,0 +1 @@
+export { enUS as defaultLocale } from "../locale/en-US.js";

node_modules/date-fns/_lib/defaultOptions.cjs

@@ -0,0 +1,13 @@
+"use strict";
+exports.getDefaultOptions = getDefaultOptions;
+exports.setDefaultOptions = setDefaultOptions;
+
+let defaultOptions = {};
+
+function getDefaultOptions() {
+  return defaultOptions;
+}
+
+function setDefaultOptions(newOptions) {
+  defaultOptions = newOptions;
+}

node_modules/date-fns/_lib/defaultOptions.d.cts

@@ -0,0 +1,11 @@
+import type {
+  FirstWeekContainsDateOptions,
+  Locale,
+  LocalizedOptions,
+  WeekOptions,
+} from "../types.js";
+export type DefaultOptions = LocalizedOptions<keyof Locale> &
+  WeekOptions &
+  FirstWeekContainsDateOptions;
+export declare function getDefaultOptions(): DefaultOptions;
+export declare function setDefaultOptions(newOptions: DefaultOptions): void;

node_modules/date-fns/_lib/defaultOptions.js

@@ -0,0 +1,9 @@
+let defaultOptions = {};
+
+export function getDefaultOptions() {
+  return defaultOptions;
+}
+
+export function setDefaultOptions(newOptions) {
+  defaultOptions = newOptions;
+}

node_modules/date-fns/_lib/format/formatters.cjs

@@ -0,0 +1,780 @@
+"use strict";
+exports.formatters = void 0;
+var _index = require("../../getDayOfYear.cjs");
+var _index2 = require("../../getISOWeek.cjs");
+var _index3 = require("../../getISOWeekYear.cjs");
+var _index4 = require("../../getWeek.cjs");
+var _index5 = require("../../getWeekYear.cjs");
+
+var _index6 = require("../addLeadingZeros.cjs");
+var _index7 = require("./lightFormatters.cjs");
+
+const dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night",
+};
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+ * |  p! | Long localized time            |  P! | Long localized date            |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ * - `P` is long localized date format
+ * - `p` is long localized time format
+ */
+
+const formatters = (exports.formatters = {
+  // Era
+  G: function (date, token, localize) {
+    const era = date.getFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize.era(era, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return localize.era(era, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return localize.era(era, { width: "wide" });
+    }
+  },
+
+  // Year
+  y: function (date, token, localize) {
+    // Ordinal number
+    if (token === "yo") {
+      const signedYear = date.getFullYear();
+      // Returns 1 for 1 BC (which is year 0 in JavaScript)
+      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize.ordinalNumber(year, { unit: "year" });
+    }
+
+    return _index7.lightFormatters.y(date, token);
+  },
+
+  // Local week-numbering year
+  Y: function (date, token, localize, options) {
+    const signedWeekYear = (0, _index5.getWeekYear)(date, options);
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+
+    // Two digit year
+    if (token === "YY") {
+      const twoDigitYear = weekYear % 100;
+      return (0, _index6.addLeadingZeros)(twoDigitYear, 2);
+    }
+
+    // Ordinal number
+    if (token === "Yo") {
+      return localize.ordinalNumber(weekYear, { unit: "year" });
+    }
+
+    // Padding
+    return (0, _index6.addLeadingZeros)(weekYear, token.length);
+  },
+
+  // ISO week-numbering year
+  R: function (date, token) {
+    const isoWeekYear = (0, _index3.getISOWeekYear)(date);
+
+    // Padding
+    return (0, _index6.addLeadingZeros)(isoWeekYear, token.length);
+  },
+
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function (date, token) {
+    const year = date.getFullYear();
+    return (0, _index6.addLeadingZeros)(year, token.length);
+  },
+
+  // Quarter
+  Q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "QQ":
+        return (0, _index6.addLeadingZeros)(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone quarter
+  q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "qq":
+        return (0, _index6.addLeadingZeros)(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // Month
+  M: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return _index7.lightFormatters.M(date, token);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return localize.month(month, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return localize.month(month, { width: "wide", context: "formatting" });
+    }
+  },
+
+  // Stand-alone month
+  L: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(month + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return (0, _index6.addLeadingZeros)(month + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return localize.month(month, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return localize.month(month, { width: "wide", context: "standalone" });
+    }
+  },
+
+  // Local week of year
+  w: function (date, token, localize, options) {
+    const week = (0, _index4.getWeek)(date, options);
+
+    if (token === "wo") {
+      return localize.ordinalNumber(week, { unit: "week" });
+    }
+
+    return (0, _index6.addLeadingZeros)(week, token.length);
+  },
+
+  // ISO week of year
+  I: function (date, token, localize) {
+    const isoWeek = (0, _index2.getISOWeek)(date);
+
+    if (token === "Io") {
+      return localize.ordinalNumber(isoWeek, { unit: "week" });
+    }
+
+    return (0, _index6.addLeadingZeros)(isoWeek, token.length);
+  },
+
+  // Day of the month
+  d: function (date, token, localize) {
+    if (token === "do") {
+      return localize.ordinalNumber(date.getDate(), { unit: "date" });
+    }
+
+    return _index7.lightFormatters.d(date, token);
+  },
+
+  // Day of year
+  D: function (date, token, localize) {
+    const dayOfYear = (0, _index.getDayOfYear)(date);
+
+    if (token === "Do") {
+      return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+    }
+
+    return (0, _index6.addLeadingZeros)(dayOfYear, token.length);
+  },
+
+  // Day of week
+  E: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "EEEEE":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Local day of week
+  e: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "ee":
+        return (0, _index6.addLeadingZeros)(localDayOfWeek, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "eee":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "eeeee":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "eeeeee":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone local day of week
+  c: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "cc":
+        return (0, _index6.addLeadingZeros)(localDayOfWeek, token.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "ccc":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // T
+      case "ccccc":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // Tu
+      case "cccccc":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "standalone",
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // ISO day of week
+  i: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      // 2
+      case "i":
+        return String(isoDayOfWeek);
+      // 02
+      case "ii":
+        return (0, _index6.addLeadingZeros)(isoDayOfWeek, token.length);
+      // 2nd
+      case "io":
+        return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
+      // Tue
+      case "iii":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "iiiii":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "iiiiii":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM or PM
+  a: function (date, token, localize) {
+    const hours = date.getHours();
+    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "aaa":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "aaaaa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM, PM, midnight, noon
+  b: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "bbb":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "bbbbb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // in the morning, in the afternoon, in the evening, at night
+  B: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "BBBBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Hour [1-12]
+  h: function (date, token, localize) {
+    if (token === "ho") {
+      let hours = date.getHours() % 12;
+      if (hours === 0) hours = 12;
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return _index7.lightFormatters.h(date, token);
+  },
+
+  // Hour [0-23]
+  H: function (date, token, localize) {
+    if (token === "Ho") {
+      return localize.ordinalNumber(date.getHours(), { unit: "hour" });
+    }
+
+    return _index7.lightFormatters.H(date, token);
+  },
+
+  // Hour [0-11]
+  K: function (date, token, localize) {
+    const hours = date.getHours() % 12;
+
+    if (token === "Ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return (0, _index6.addLeadingZeros)(hours, token.length);
+  },
+
+  // Hour [1-24]
+  k: function (date, token, localize) {
+    let hours = date.getHours();
+    if (hours === 0) hours = 24;
+
+    if (token === "ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return (0, _index6.addLeadingZeros)(hours, token.length);
+  },
+
+  // Minute
+  m: function (date, token, localize) {
+    if (token === "mo") {
+      return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
+    }
+
+    return _index7.lightFormatters.m(date, token);
+  },
+
+  // Second
+  s: function (date, token, localize) {
+    if (token === "so") {
+      return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
+    }
+
+    return _index7.lightFormatters.s(date, token);
+  },
+
+  // Fraction of second
+  S: function (date, token) {
+    return _index7.lightFormatters.S(date, token);
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+
+    switch (token) {
+      // Hours and optional minutes
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Hours and optional minutes
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (GMT)
+  O: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (specific non-location)
+  z: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Seconds timestamp
+  t: function (date, token, _localize) {
+    const timestamp = Math.trunc(+date / 1000);
+    return (0, _index6.addLeadingZeros)(timestamp, token.length);
+  },
+
+  // Milliseconds timestamp
+  T: function (date, token, _localize) {
+    return (0, _index6.addLeadingZeros)(+date, token.length);
+  },
+});
+
+function formatTimezoneShort(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign + String(hours);
+  }
+  return (
+    sign + String(hours) + delimiter + (0, _index6.addLeadingZeros)(minutes, 2)
+  );
+}
+
+function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+  if (offset % 60 === 0) {
+    const sign = offset > 0 ? "-" : "+";
+    return sign + (0, _index6.addLeadingZeros)(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, delimiter);
+}
+
+function formatTimezone(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = (0, _index6.addLeadingZeros)(Math.trunc(absOffset / 60), 2);
+  const minutes = (0, _index6.addLeadingZeros)(absOffset % 60, 2);
+  return sign + hours + delimiter + minutes;
+}

node_modules/date-fns/_lib/format/formatters.d.cts

@@ -0,0 +1,18 @@
+import type { Localize } from "../../locale/types.js";
+import type {
+  FirstWeekContainsDateOptions,
+  LocalizedOptions,
+  WeekOptions,
+} from "../../types.js";
+type Formatter = (
+  date: Date,
+  token: string,
+  localize: Localize,
+  options: Required<
+    LocalizedOptions<"options"> & WeekOptions & FirstWeekContainsDateOptions
+  >,
+) => string;
+export declare const formatters: {
+  [token: string]: Formatter;
+};
+export {};

node_modules/date-fns/_lib/format/formatters.js

@@ -0,0 +1,776 @@
+import { getDayOfYear } from "../../getDayOfYear.js";
+import { getISOWeek } from "../../getISOWeek.js";
+import { getISOWeekYear } from "../../getISOWeekYear.js";
+import { getWeek } from "../../getWeek.js";
+import { getWeekYear } from "../../getWeekYear.js";
+
+import { addLeadingZeros } from "../addLeadingZeros.js";
+import { lightFormatters } from "./lightFormatters.js";
+
+const dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night",
+};
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+ * |  p! | Long localized time            |  P! | Long localized date            |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ * - `P` is long localized date format
+ * - `p` is long localized time format
+ */
+
+export const formatters = {
+  // Era
+  G: function (date, token, localize) {
+    const era = date.getFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize.era(era, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return localize.era(era, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return localize.era(era, { width: "wide" });
+    }
+  },
+
+  // Year
+  y: function (date, token, localize) {
+    // Ordinal number
+    if (token === "yo") {
+      const signedYear = date.getFullYear();
+      // Returns 1 for 1 BC (which is year 0 in JavaScript)
+      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize.ordinalNumber(year, { unit: "year" });
+    }
+
+    return lightFormatters.y(date, token);
+  },
+
+  // Local week-numbering year
+  Y: function (date, token, localize, options) {
+    const signedWeekYear = getWeekYear(date, options);
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+
+    // Two digit year
+    if (token === "YY") {
+      const twoDigitYear = weekYear % 100;
+      return addLeadingZeros(twoDigitYear, 2);
+    }
+
+    // Ordinal number
+    if (token === "Yo") {
+      return localize.ordinalNumber(weekYear, { unit: "year" });
+    }
+
+    // Padding
+    return addLeadingZeros(weekYear, token.length);
+  },
+
+  // ISO week-numbering year
+  R: function (date, token) {
+    const isoWeekYear = getISOWeekYear(date);
+
+    // Padding
+    return addLeadingZeros(isoWeekYear, token.length);
+  },
+
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function (date, token) {
+    const year = date.getFullYear();
+    return addLeadingZeros(year, token.length);
+  },
+
+  // Quarter
+  Q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "QQ":
+        return addLeadingZeros(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone quarter
+  q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "qq":
+        return addLeadingZeros(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // Month
+  M: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return lightFormatters.M(date, token);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return localize.month(month, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return localize.month(month, { width: "wide", context: "formatting" });
+    }
+  },
+
+  // Stand-alone month
+  L: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(month + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return addLeadingZeros(month + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return localize.month(month, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return localize.month(month, { width: "wide", context: "standalone" });
+    }
+  },
+
+  // Local week of year
+  w: function (date, token, localize, options) {
+    const week = getWeek(date, options);
+
+    if (token === "wo") {
+      return localize.ordinalNumber(week, { unit: "week" });
+    }
+
+    return addLeadingZeros(week, token.length);
+  },
+
+  // ISO week of year
+  I: function (date, token, localize) {
+    const isoWeek = getISOWeek(date);
+
+    if (token === "Io") {
+      return localize.ordinalNumber(isoWeek, { unit: "week" });
+    }
+
+    return addLeadingZeros(isoWeek, token.length);
+  },
+
+  // Day of the month
+  d: function (date, token, localize) {
+    if (token === "do") {
+      return localize.ordinalNumber(date.getDate(), { unit: "date" });
+    }
+
+    return lightFormatters.d(date, token);
+  },
+
+  // Day of year
+  D: function (date, token, localize) {
+    const dayOfYear = getDayOfYear(date);
+
+    if (token === "Do") {
+      return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+    }
+
+    return addLeadingZeros(dayOfYear, token.length);
+  },
+
+  // Day of week
+  E: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "EEEEE":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Local day of week
+  e: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "ee":
+        return addLeadingZeros(localDayOfWeek, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "eee":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "eeeee":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "eeeeee":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone local day of week
+  c: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "cc":
+        return addLeadingZeros(localDayOfWeek, token.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "ccc":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // T
+      case "ccccc":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // Tu
+      case "cccccc":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "standalone",
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // ISO day of week
+  i: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      // 2
+      case "i":
+        return String(isoDayOfWeek);
+      // 02
+      case "ii":
+        return addLeadingZeros(isoDayOfWeek, token.length);
+      // 2nd
+      case "io":
+        return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
+      // Tue
+      case "iii":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "iiiii":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "iiiiii":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM or PM
+  a: function (date, token, localize) {
+    const hours = date.getHours();
+    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "aaa":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "aaaaa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM, PM, midnight, noon
+  b: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "bbb":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "bbbbb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // in the morning, in the afternoon, in the evening, at night
+  B: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "BBBBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Hour [1-12]
+  h: function (date, token, localize) {
+    if (token === "ho") {
+      let hours = date.getHours() % 12;
+      if (hours === 0) hours = 12;
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return lightFormatters.h(date, token);
+  },
+
+  // Hour [0-23]
+  H: function (date, token, localize) {
+    if (token === "Ho") {
+      return localize.ordinalNumber(date.getHours(), { unit: "hour" });
+    }
+
+    return lightFormatters.H(date, token);
+  },
+
+  // Hour [0-11]
+  K: function (date, token, localize) {
+    const hours = date.getHours() % 12;
+
+    if (token === "Ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return addLeadingZeros(hours, token.length);
+  },
+
+  // Hour [1-24]
+  k: function (date, token, localize) {
+    let hours = date.getHours();
+    if (hours === 0) hours = 24;
+
+    if (token === "ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return addLeadingZeros(hours, token.length);
+  },
+
+  // Minute
+  m: function (date, token, localize) {
+    if (token === "mo") {
+      return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
+    }
+
+    return lightFormatters.m(date, token);
+  },
+
+  // Second
+  s: function (date, token, localize) {
+    if (token === "so") {
+      return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
+    }
+
+    return lightFormatters.s(date, token);
+  },
+
+  // Fraction of second
+  S: function (date, token) {
+    return lightFormatters.S(date, token);
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+
+    switch (token) {
+      // Hours and optional minutes
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Hours and optional minutes
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (GMT)
+  O: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (specific non-location)
+  z: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Seconds timestamp
+  t: function (date, token, _localize) {
+    const timestamp = Math.trunc(+date / 1000);
+    return addLeadingZeros(timestamp, token.length);
+  },
+
+  // Milliseconds timestamp
+  T: function (date, token, _localize) {
+    return addLeadingZeros(+date, token.length);
+  },
+};
+
+function formatTimezoneShort(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign + String(hours);
+  }
+  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+}
+
+function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+  if (offset % 60 === 0) {
+    const sign = offset > 0 ? "-" : "+";
+    return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, delimiter);
+}
+
+function formatTimezone(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
+  const minutes = addLeadingZeros(absOffset % 60, 2);
+  return sign + hours + delimiter + minutes;
+}

node_modules/date-fns/_lib/format/lightFormatters.cjs

@@ -0,0 +1,102 @@
+"use strict";
+exports.lightFormatters = void 0;
+var _index = require("../addLeadingZeros.cjs");
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* |                                |
+ * |  d  | Day of month                   |  D  |                                |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  y  | Year (abs)                     |  Y  |                                |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ */
+
+const lightFormatters = (exports.lightFormatters = {
+  // Year
+  y(date, token) {
+    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+    // |----------|-------|----|-------|-------|-------|
+    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+
+    const signedYear = date.getFullYear();
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return (0, _index.addLeadingZeros)(
+      token === "yy" ? year % 100 : year,
+      token.length,
+    );
+  },
+
+  // Month
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M"
+      ? String(month + 1)
+      : (0, _index.addLeadingZeros)(month + 1, 2);
+  },
+
+  // Day of the month
+  d(date, token) {
+    return (0, _index.addLeadingZeros)(date.getDate(), token.length);
+  },
+
+  // AM or PM
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+
+  // Hour [1-12]
+  h(date, token) {
+    return (0, _index.addLeadingZeros)(
+      date.getHours() % 12 || 12,
+      token.length,
+    );
+  },
+
+  // Hour [0-23]
+  H(date, token) {
+    return (0, _index.addLeadingZeros)(date.getHours(), token.length);
+  },
+
+  // Minute
+  m(date, token) {
+    return (0, _index.addLeadingZeros)(date.getMinutes(), token.length);
+  },
+
+  // Second
+  s(date, token) {
+    return (0, _index.addLeadingZeros)(date.getSeconds(), token.length);
+  },
+
+  // Fraction of second
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, numberOfDigits - 3),
+    );
+    return (0, _index.addLeadingZeros)(fractionalSeconds, token.length);
+  },
+});

node_modules/date-fns/_lib/format/lightFormatters.d.cts

@@ -0,0 +1,11 @@
+export declare const lightFormatters: {
+  y(date: Date, token: string): string;
+  M(date: Date, token: string): string;
+  d(date: Date, token: string): string;
+  a(date: Date, token: string): string;
+  h(date: Date, token: string): string;
+  H(date: Date, token: string): string;
+  m(date: Date, token: string): string;
+  s(date: Date, token: string): string;
+  S(date: Date, token: string): string;
+};

node_modules/date-fns/_lib/format/lightFormatters.js

@@ -0,0 +1,92 @@
+import { addLeadingZeros } from "../addLeadingZeros.js";
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* |                                |
+ * |  d  | Day of month                   |  D  |                                |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  y  | Year (abs)                     |  Y  |                                |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ */
+
+export const lightFormatters = {
+  // Year
+  y(date, token) {
+    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+    // |----------|-------|----|-------|-------|-------|
+    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+
+    const signedYear = date.getFullYear();
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+  },
+
+  // Month
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+  },
+
+  // Day of the month
+  d(date, token) {
+    return addLeadingZeros(date.getDate(), token.length);
+  },
+
+  // AM or PM
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+
+  // Hour [1-12]
+  h(date, token) {
+    return addLeadingZeros(date.getHours() % 12 || 12, token.length);
+  },
+
+  // Hour [0-23]
+  H(date, token) {
+    return addLeadingZeros(date.getHours(), token.length);
+  },
+
+  // Minute
+  m(date, token) {
+    return addLeadingZeros(date.getMinutes(), token.length);
+  },
+
+  // Second
+  s(date, token) {
+    return addLeadingZeros(date.getSeconds(), token.length);
+  },
+
+  // Fraction of second
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, numberOfDigits - 3),
+    );
+    return addLeadingZeros(fractionalSeconds, token.length);
+  },
+};

node_modules/date-fns/_lib/format/longFormatters.cjs

@@ -0,0 +1,67 @@
+"use strict";
+exports.longFormatters = void 0;
+
+const dateLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong.date({ width: "full" });
+  }
+};
+
+const timeLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong.time({ width: "full" });
+  }
+};
+
+const dateTimeLongFormatter = (pattern, formatLong) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong);
+  }
+
+  let dateTimeFormat;
+
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      break;
+  }
+
+  return dateTimeFormat
+    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+};
+
+const longFormatters = (exports.longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter,
+});

node_modules/date-fns/_lib/format/longFormatters.d.cts

@@ -0,0 +1,4 @@
+import type { FormatLong } from "../../locale/types.js";
+type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
+export declare const longFormatters: Record<string, LongFormatter>;
+export {};

node_modules/date-fns/_lib/format/longFormatters.js

@@ -0,0 +1,64 @@
+const dateLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong.date({ width: "full" });
+  }
+};
+
+const timeLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong.time({ width: "full" });
+  }
+};
+
+const dateTimeLongFormatter = (pattern, formatLong) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong);
+  }
+
+  let dateTimeFormat;
+
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      break;
+  }
+
+  return dateTimeFormat
+    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+};
+
+export const longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter,
+};

node_modules/date-fns/_lib/getRoundingMethod.cjs

@@ -0,0 +1,11 @@
+"use strict";
+exports.getRoundingMethod = getRoundingMethod;
+
+function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
+}

node_modules/date-fns/_lib/getRoundingMethod.d.cts

@@ -0,0 +1,4 @@
+import type { RoundingMethod } from "../types.js";
+export declare function getRoundingMethod(
+  method: RoundingMethod | undefined,
+): (number: number) => number;

node_modules/date-fns/_lib/getRoundingMethod.js

@@ -0,0 +1,8 @@
+export function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
+}

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.cjs

@@ -0,0 +1,31 @@
+"use strict";
+exports.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds;
+var _index = require("../toDate.cjs");
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = (0, _index.toDate)(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.cts

@@ -0,0 +1,15 @@
+import type { DateArg } from "../types.js";
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export declare function getTimezoneOffsetInMilliseconds(
+  date: DateArg<Date> & {},
+): number;

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js

@@ -0,0 +1,29 @@
+import { toDate } from "../toDate.js";
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}

node_modules/date-fns/_lib/normalizeDates.cjs

@@ -0,0 +1,11 @@
+"use strict";
+exports.normalizeDates = normalizeDates;
+var _index = require("../constructFrom.cjs");
+
+function normalizeDates(context, ...dates) {
+  const normalize = _index.constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object"),
+  );
+  return dates.map(normalize);
+}

node_modules/date-fns/_lib/normalizeDates.d.cts

@@ -0,0 +1,13 @@
+import type { ContextFn, DateArg } from "../types.js";
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>, DateArg<Date>]
+): [Date, Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>]
+): [Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: Array<DateArg<Date> & {}>
+): Date[];

node_modules/date-fns/_lib/normalizeDates.js

@@ -0,0 +1,9 @@
+import { constructFrom } from "../constructFrom.js";
+
+export function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object"),
+  );
+  return dates.map(normalize);
+}

node_modules/date-fns/_lib/normalizeInterval.cjs

@@ -0,0 +1,12 @@
+"use strict";
+exports.normalizeInterval = normalizeInterval;
+var _index = require("./normalizeDates.cjs");
+
+function normalizeInterval(context, interval) {
+  const [start, end] = (0, _index.normalizeDates)(
+    context,
+    interval.start,
+    interval.end,
+  );
+  return { start, end };
+}

node_modules/date-fns/_lib/normalizeInterval.d.cts

@@ -0,0 +1,5 @@
+import type { ContextFn, Interval, NormalizedInterval } from "../types.js";
+export declare function normalizeInterval(
+  context: ContextFn<Date> | undefined,
+  interval: Interval,
+): NormalizedInterval<Date>;

node_modules/date-fns/_lib/normalizeInterval.js

@@ -0,0 +1,6 @@
+import { normalizeDates } from "./normalizeDates.js";
+
+export function normalizeInterval(context, interval) {
+  const [start, end] = normalizeDates(context, interval.start, interval.end);
+  return { start, end };
+}

node_modules/date-fns/_lib/protectedTokens.cjs

@@ -0,0 +1,27 @@
+"use strict";
+exports.isProtectedDayOfYearToken = isProtectedDayOfYearToken;
+exports.isProtectedWeekYearToken = isProtectedWeekYearToken;
+exports.warnOrThrowProtectedError = warnOrThrowProtectedError;
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
+
+const throwTokens = ["D", "DD", "YY", "YYYY"];
+
+function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+
+function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+
+function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}

node_modules/date-fns/_lib/protectedTokens.d.cts

@@ -0,0 +1,7 @@
+export declare function isProtectedDayOfYearToken(token: string): boolean;
+export declare function isProtectedWeekYearToken(token: string): boolean;
+export declare function warnOrThrowProtectedError(
+  token: string,
+  format: string,
+  input: string,
+): void;

node_modules/date-fns/_lib/protectedTokens.js

@@ -0,0 +1,23 @@
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
+
+const throwTokens = ["D", "DD", "YY", "YYYY"];
+
+export function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+
+export function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+
+export function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}

node_modules/date-fns/_lib/test.cjs

@@ -0,0 +1,59 @@
+"use strict";
+exports.assertType = assertType;
+exports.fakeDate = fakeDate;
+exports.generateOffset = generateOffset;
+exports.resetDefaultOptions = resetDefaultOptions;
+var _vitest = require("./test/vitest");
+var _index = require("./addLeadingZeros.cjs");
+var _index2 = require("./defaultOptions.cjs");
+var _sinon = require("./test/sinon");
+
+function assertType(_value) {}
+
+function resetDefaultOptions() {
+  (0, _index2.setDefaultOptions)({});
+}
+
+// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
+function generateOffset(originalDate) {
+  // Add the timezone.
+  let offset = "";
+  const tzOffset = originalDate.getTimezoneOffset();
+
+  if (tzOffset !== 0) {
+    const absoluteOffset = Math.abs(tzOffset);
+    const hourOffset = (0, _index.addLeadingZeros)(
+      Math.trunc(absoluteOffset / 60),
+      2,
+    );
+    const minuteOffset = (0, _index.addLeadingZeros)(absoluteOffset % 60, 2);
+    // If less than 0, the sign is +, because it is ahead of time.
+    const sign = tzOffset < 0 ? "+" : "-";
+
+    offset = `${sign}${hourOffset}:${minuteOffset}`;
+  } else {
+    offset = "Z";
+  }
+
+  return offset;
+}
+
+function fakeDate(date) {
+  let clock;
+
+  function fakeNow(date) {
+    clock?.restore();
+    clock = _sinon.default.useFakeTimers(+date);
+  }
+
+  (0, _vitest.beforeEach)(() => {
+    fakeNow(+date);
+  });
+
+  (0, _vitest.afterEach)(() => {
+    clock?.restore();
+    clock = undefined;
+  });
+
+  return { fakeNow };
+}

node_modules/date-fns/_lib/test.d.cts

@@ -0,0 +1,14 @@
+export declare function assertType<Type>(_value: Type): void;
+export declare namespace assertType {
+  type Equal<T, U> =
+    Exclude<T, U> extends never
+      ? Exclude<U, T> extends never
+        ? true
+        : false
+      : false;
+}
+export declare function resetDefaultOptions(): void;
+export declare function generateOffset(originalDate: Date): string;
+export declare function fakeDate(date: number | Date): {
+  fakeNow: (date: number | Date) => void;
+};

node_modules/date-fns/_lib/test.js

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach } from "./test/vitest";
+import { addLeadingZeros } from "./addLeadingZeros.js";
+import { setDefaultOptions } from "./defaultOptions.js";
+import sinon from "./test/sinon";
+
+export function assertType(_value) {}
+
+export function resetDefaultOptions() {
+  setDefaultOptions({});
+}
+
+// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
+export function generateOffset(originalDate) {
+  // Add the timezone.
+  let offset = "";
+  const tzOffset = originalDate.getTimezoneOffset();
+
+  if (tzOffset !== 0) {
+    const absoluteOffset = Math.abs(tzOffset);
+    const hourOffset = addLeadingZeros(Math.trunc(absoluteOffset / 60), 2);
+    const minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
+    // If less than 0, the sign is +, because it is ahead of time.
+    const sign = tzOffset < 0 ? "+" : "-";
+
+    offset = `${sign}${hourOffset}:${minuteOffset}`;
+  } else {
+    offset = "Z";
+  }
+
+  return offset;
+}
+
+export function fakeDate(date) {
+  let clock;
+
+  function fakeNow(date) {
+    clock?.restore();
+    clock = sinon.useFakeTimers(+date);
+  }
+
+  beforeEach(() => {
+    fakeNow(+date);
+  });
+
+  afterEach(() => {
+    clock?.restore();
+    clock = undefined;
+  });
+
+  return { fakeNow };
+}

node_modules/date-fns/add.cjs

@@ -0,0 +1,75 @@
+"use strict";
+exports.add = add;
+var _index = require("./addDays.cjs");
+var _index2 = require("./addMonths.cjs");
+var _index3 = require("./constructFrom.cjs");
+var _index4 = require("./toDate.cjs");
+
+/**
+ * The {@link add} function options.
+ */
+
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+function add(date, duration, options) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+  } = duration;
+
+  // Add years and months
+  const _date = (0, _index4.toDate)(date, options?.in);
+  const dateWithMonths =
+    months || years
+      ? (0, _index2.addMonths)(_date, months + years * 12)
+      : _date;
+
+  // Add weeks and days
+  const dateWithDays =
+    days || weeks
+      ? (0, _index.addDays)(dateWithMonths, days + weeks * 7)
+      : dateWithMonths;
+
+  // Add days, hours, minutes, and seconds
+  const minutesToAdd = minutes + hours * 60;
+  const secondsToAdd = seconds + minutesToAdd * 60;
+  const msToAdd = secondsToAdd * 1000;
+
+  return (0, _index3.constructFrom)(
+    options?.in || date,
+    +dateWithDays + msToAdd,
+  );
+}

node_modules/date-fns/add.d.cts

@@ -0,0 +1,44 @@
+import type { ContextOptions, DateArg, Duration } from "./types.js";
+/**
+ * The {@link add} function options.
+ */
+export interface AddOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+export declare function add<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  duration: Duration,
+  options?: AddOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/add.js

@@ -0,0 +1,69 @@
+import { addDays } from "./addDays.js";
+import { addMonths } from "./addMonths.js";
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link add} function options.
+ */
+
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+export function add(date, duration, options) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+  } = duration;
+
+  // Add years and months
+  const _date = toDate(date, options?.in);
+  const dateWithMonths =
+    months || years ? addMonths(_date, months + years * 12) : _date;
+
+  // Add weeks and days
+  const dateWithDays =
+    days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths;
+
+  // Add days, hours, minutes, and seconds
+  const minutesToAdd = minutes + hours * 60;
+  const secondsToAdd = seconds + minutesToAdd * 60;
+  const msToAdd = secondsToAdd * 1000;
+
+  return constructFrom(options?.in || date, +dateWithDays + msToAdd);
+}
+
+// Fallback for modularized imports:
+export default add;

node_modules/date-fns/addBusinessDays.cjs

@@ -0,0 +1,76 @@
+"use strict";
+exports.addBusinessDays = addBusinessDays;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./isSaturday.cjs");
+var _index3 = require("./isSunday.cjs");
+var _index4 = require("./isWeekend.cjs");
+var _index5 = require("./toDate.cjs");
+
+/**
+ * The {@link addBusinessDays} function options.
+ */
+
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+function addBusinessDays(date, amount, options) {
+  const _date = (0, _index5.toDate)(date, options?.in);
+  const startedOnWeekend = (0, _index4.isWeekend)(_date, options);
+
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in, NaN);
+
+  const hours = _date.getHours();
+  const sign = amount < 0 ? -1 : 1;
+  const fullWeeks = Math.trunc(amount / 5);
+
+  _date.setDate(_date.getDate() + fullWeeks * 7);
+
+  // Get remaining days not part of a full week
+  let restDays = Math.abs(amount % 5);
+
+  // Loops over remaining days
+  while (restDays > 0) {
+    _date.setDate(_date.getDate() + sign);
+    if (!(0, _index4.isWeekend)(_date, options)) restDays -= 1;
+  }
+
+  // If the date is a weekend day and we reduce a dividable of
+  // 5 from it, we land on a weekend date.
+  // To counter this, we add days accordingly to land on the next business day
+  if (
+    startedOnWeekend &&
+    (0, _index4.isWeekend)(_date, options) &&
+    amount !== 0
+  ) {
+    // If we're reducing days, we want to add days until we land on a weekday
+    // If we're adding days we want to reduce days until we land on a weekday
+    if ((0, _index2.isSaturday)(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
+    if ((0, _index3.isSunday)(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 1 : -2));
+  }
+
+  // Restore hours to avoid DST lag
+  _date.setHours(hours);
+
+  return _date;
+}

node_modules/date-fns/addBusinessDays.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addBusinessDays} function options.
+ */
+export interface AddBusinessDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+export declare function addBusinessDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddBusinessDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addBusinessDays.js

@@ -0,0 +1,73 @@
+import { constructFrom } from "./constructFrom.js";
+import { isSaturday } from "./isSaturday.js";
+import { isSunday } from "./isSunday.js";
+import { isWeekend } from "./isWeekend.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addBusinessDays} function options.
+ */
+
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+export function addBusinessDays(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  const startedOnWeekend = isWeekend(_date, options);
+
+  if (isNaN(amount)) return constructFrom(options?.in, NaN);
+
+  const hours = _date.getHours();
+  const sign = amount < 0 ? -1 : 1;
+  const fullWeeks = Math.trunc(amount / 5);
+
+  _date.setDate(_date.getDate() + fullWeeks * 7);
+
+  // Get remaining days not part of a full week
+  let restDays = Math.abs(amount % 5);
+
+  // Loops over remaining days
+  while (restDays > 0) {
+    _date.setDate(_date.getDate() + sign);
+    if (!isWeekend(_date, options)) restDays -= 1;
+  }
+
+  // If the date is a weekend day and we reduce a dividable of
+  // 5 from it, we land on a weekend date.
+  // To counter this, we add days accordingly to land on the next business day
+  if (startedOnWeekend && isWeekend(_date, options) && amount !== 0) {
+    // If we're reducing days, we want to add days until we land on a weekday
+    // If we're adding days we want to reduce days until we land on a weekday
+    if (isSaturday(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
+    if (isSunday(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 1 : -2));
+  }
+
+  // Restore hours to avoid DST lag
+  _date.setHours(hours);
+
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addBusinessDays;

node_modules/date-fns/addDays.cjs

@@ -0,0 +1,41 @@
+"use strict";
+exports.addDays = addDays;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addDays} function options.
+ */
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+function addDays(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN);
+
+  // If 0 days, no-op to avoid changing times in the hour before end of DST
+  if (!amount) return _date;
+
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}

node_modules/date-fns/addDays.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addDays} function options.
+ */
+export interface AddDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+export declare function addDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addDays.js

@@ -0,0 +1,42 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addDays} function options.
+ */
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+export function addDays(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
+
+  // If 0 days, no-op to avoid changing times in the hour before end of DST
+  if (!amount) return _date;
+
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addDays;

node_modules/date-fns/addHours.cjs

@@ -0,0 +1,38 @@
+"use strict";
+exports.addHours = addHours;
+var _index = require("./addMilliseconds.cjs");
+var _index2 = require("./constants.cjs");
+
+/**
+ * The {@link addHours} function options.
+ */
+
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+function addHours(date, amount, options) {
+  return (0, _index.addMilliseconds)(
+    date,
+    amount * _index2.millisecondsInHour,
+    options,
+  );
+}

node_modules/date-fns/addHours.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addHours} function options.
+ */
+export interface AddHoursOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+export declare function addHours<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddHoursOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addHours.js

@@ -0,0 +1,35 @@
+import { addMilliseconds } from "./addMilliseconds.js";
+import { millisecondsInHour } from "./constants.js";
+
+/**
+ * The {@link addHours} function options.
+ */
+
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+export function addHours(date, amount, options) {
+  return addMilliseconds(date, amount * millisecondsInHour, options);
+}
+
+// Fallback for modularized imports:
+export default addHours;

node_modules/date-fns/addISOWeekYears.cjs

@@ -0,0 +1,39 @@
+"use strict";
+exports.addISOWeekYears = addISOWeekYears;
+var _index = require("./getISOWeekYear.cjs");
+var _index2 = require("./setISOWeekYear.cjs");
+
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+function addISOWeekYears(date, amount, options) {
+  return (0, _index2.setISOWeekYear)(
+    date,
+    (0, _index.getISOWeekYear)(date, options) + amount,
+    options,
+  );
+}

node_modules/date-fns/addISOWeekYears.d.cts

@@ -0,0 +1,37 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+export interface AddISOWeekYearsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+export declare function addISOWeekYears<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddISOWeekYearsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addISOWeekYears.js

@@ -0,0 +1,36 @@
+import { getISOWeekYear } from "./getISOWeekYear.js";
+import { setISOWeekYear } from "./setISOWeekYear.js";
+
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+export function addISOWeekYears(date, amount, options) {
+  return setISOWeekYear(date, getISOWeekYear(date, options) + amount, options);
+}
+
+// Fallback for modularized imports:
+export default addISOWeekYears;

node_modules/date-fns/addMilliseconds.cjs

@@ -0,0 +1,37 @@
+"use strict";
+exports.addMilliseconds = addMilliseconds;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMilliseconds} function options.
+ */
+
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+function addMilliseconds(date, amount, options) {
+  return (0, _index.constructFrom)(
+    options?.in || date,
+    +(0, _index2.toDate)(date) + amount,
+  );
+}

node_modules/date-fns/addMilliseconds.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMilliseconds} function options.
+ */
+export interface AddMillisecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+export declare function addMilliseconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMillisecondsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMilliseconds.js

@@ -0,0 +1,35 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMilliseconds} function options.
+ */
+
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+export function addMilliseconds(date, amount, options) {
+  return constructFrom(options?.in || date, +toDate(date) + amount);
+}
+
+// Fallback for modularized imports:
+export default addMilliseconds;

node_modules/date-fns/addMinutes.cjs

@@ -0,0 +1,36 @@
+"use strict";
+exports.addMinutes = addMinutes;
+var _index = require("./constants.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMinutes} function options.
+ */
+
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+function addMinutes(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  _date.setTime(_date.getTime() + amount * _index.millisecondsInMinute);
+  return _date;
+}

node_modules/date-fns/addMinutes.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMinutes} function options.
+ */
+export interface AddMinutesOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+export declare function addMinutes<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMinutesOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMinutes.js

@@ -0,0 +1,37 @@
+import { millisecondsInMinute } from "./constants.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMinutes} function options.
+ */
+
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+export function addMinutes(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  _date.setTime(_date.getTime() + amount * millisecondsInMinute);
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addMinutes;

node_modules/date-fns/addMonths.cjs

@@ -0,0 +1,78 @@
+"use strict";
+exports.addMonths = addMonths;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMonths} function options.
+ */
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+function addMonths(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN);
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return _date;
+  }
+  const dayOfMonth = _date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  const endOfDesiredMonth = (0, _index.constructFrom)(
+    options?.in || date,
+    _date.getTime(),
+  );
+  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+  const daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    _date.setFullYear(
+      endOfDesiredMonth.getFullYear(),
+      endOfDesiredMonth.getMonth(),
+      dayOfMonth,
+    );
+    return _date;
+  }
+}

node_modules/date-fns/addMonths.d.cts

@@ -0,0 +1,40 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMonths} function options.
+ */
+export interface AddMonthsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+export declare function addMonths<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMonthsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMonths.js

@@ -0,0 +1,76 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMonths} function options.
+ */
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+export function addMonths(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return _date;
+  }
+  const dayOfMonth = _date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  const endOfDesiredMonth = constructFrom(options?.in || date, _date.getTime());
+  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+  const daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    _date.setFullYear(
+      endOfDesiredMonth.getFullYear(),
+      endOfDesiredMonth.getMonth(),
+      dayOfMonth,
+    );
+    return _date;
+  }
+}
+
+// Fallback for modularized imports:
+export default addMonths;

node_modules/date-fns/addQuarters.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addQuarters = addQuarters;
+var _index = require("./addMonths.cjs");
+
+/**
+ * The {@link addQuarters} function options.
+ */
+
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+function addQuarters(date, amount, options) {
+  return (0, _index.addMonths)(date, amount * 3, options);
+}

node_modules/date-fns/addQuarters.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addQuarters} function options.
+ */
+export interface AddQuartersOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+export declare function addQuarters<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddQuartersOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addQuarters.js

@@ -0,0 +1,34 @@
+import { addMonths } from "./addMonths.js";
+
+/**
+ * The {@link addQuarters} function options.
+ */
+
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+export function addQuarters(date, amount, options) {
+  return addMonths(date, amount * 3, options);
+}
+
+// Fallback for modularized imports:
+export default addQuarters;

node_modules/date-fns/addSeconds.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addSeconds = addSeconds;
+var _index = require("./addMilliseconds.cjs");
+
+/**
+ * The {@link addSeconds} function options.
+ */
+
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+function addSeconds(date, amount, options) {
+  return (0, _index.addMilliseconds)(date, amount * 1000, options);
+}

node_modules/date-fns/addSeconds.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addSeconds} function options.
+ */
+export interface AddSecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+export declare function addSeconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddSecondsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addSeconds.js

@@ -0,0 +1,34 @@
+import { addMilliseconds } from "./addMilliseconds.js";
+
+/**
+ * The {@link addSeconds} function options.
+ */
+
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+export function addSeconds(date, amount, options) {
+  return addMilliseconds(date, amount * 1000, options);
+}
+
+// Fallback for modularized imports:
+export default addSeconds;

node_modules/date-fns/addWeeks.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addWeeks = addWeeks;
+var _index = require("./addDays.cjs");
+
+/**
+ * The {@link addWeeks} function options.
+ */
+
+/**
+ * @name addWeeks
+ * @category Week Helpers
+ * @summary Add the specified number of weeks to the given date.
+ *
+ * @description
+ * Add the specified number of weeks to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of weeks to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the weeks added
+ *
+ * @example
+ * // Add 4 weeks to 1 September 2014:
+ * const result = addWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Sep 29 2014 00:00:00
+ */
+function addWeeks(date, amount, options) {
+  return (0, _index.addDays)(date, amount * 7, options);
+}

node_modules/date-fns/addWeeks.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addWeeks} function options.
+ */
+export interface AddWeeksOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addWeeks
+ * @category Week Helpers
+ * @summary Add the specified number of weeks to the given date.
+ *
+ * @description
+ * Add the specified number of weeks to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of weeks to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the weeks added
+ *
+ * @example
+ * // Add 4 weeks to 1 September 2014:
+ * const result = addWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Sep 29 2014 00:00:00
+ */
+export declare function addWeeks<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddWeeksOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addWeeks.js

@@ -0,0 +1,34 @@
+import { addDays } from "./addDays.js";
+
+/**
+ * The {@link addWeeks} function options.
+ */
+
+/**
+ * @name addWeeks
+ * @category Week Helpers
+ * @summary Add the specified number of weeks to the given date.
+ *
+ * @description
+ * Add the specified number of weeks to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of weeks to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the weeks added
+ *
+ * @example
+ * // Add 4 weeks to 1 September 2014:
+ * const result = addWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Sep 29 2014 00:00:00
+ */
+export function addWeeks(date, amount, options) {
+  return addDays(date, amount * 7, options);
+}
+
+// Fallback for modularized imports:
+export default addWeeks;

node_modules/date-fns/addYears.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addYears = addYears;
+var _index = require("./addMonths.cjs");
+
+/**
+ * The {@link addYears} function options.
+ */
+
+/**
+ * @name addYears
+ * @category Year Helpers
+ * @summary Add the specified number of years to the given date.
+ *
+ * @description
+ * Add the specified number of years to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of years to be added.
+ * @param options - The options
+ *
+ * @returns The new date with the years added
+ *
+ * @example
+ * // Add 5 years to 1 September 2014:
+ * const result = addYears(new Date(2014, 8, 1), 5)
+ * //=> Sun Sep 01 2019 00:00:00
+ */
+function addYears(date, amount, options) {
+  return (0, _index.addMonths)(date, amount * 12, options);
+}

node_modules/date-fns/addYears.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addYears} function options.
+ */
+export interface AddYearsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addYears
+ * @category Year Helpers
+ * @summary Add the specified number of years to the given date.
+ *
+ * @description
+ * Add the specified number of years to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of years to be added.
+ * @param options - The options
+ *
+ * @returns The new date with the years added
+ *
+ * @example
+ * // Add 5 years to 1 September 2014:
+ * const result = addYears(new Date(2014, 8, 1), 5)
+ * //=> Sun Sep 01 2019 00:00:00
+ */
+export declare function addYears<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddYearsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addYears.js

@@ -0,0 +1,34 @@
+import { addMonths } from "./addMonths.js";
+
+/**
+ * The {@link addYears} function options.
+ */
+
+/**
+ * @name addYears
+ * @category Year Helpers
+ * @summary Add the specified number of years to the given date.
+ *
+ * @description
+ * Add the specified number of years to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of years to be added.
+ * @param options - The options
+ *
+ * @returns The new date with the years added
+ *
+ * @example
+ * // Add 5 years to 1 September 2014:
+ * const result = addYears(new Date(2014, 8, 1), 5)
+ * //=> Sun Sep 01 2019 00:00:00
+ */
+export function addYears(date, amount, options) {
+  return addMonths(date, amount * 12, options);
+}
+
+// Fallback for modularized imports:
+export default addYears;

node_modules/date-fns/areIntervalsOverlapping.cjs

@@ -0,0 +1,70 @@
+"use strict";
+exports.areIntervalsOverlapping = areIntervalsOverlapping;
+var _index = require("./toDate.cjs");
+
+/**
+ * The {@link areIntervalsOverlapping} function options.
+ */
+
+/**
+ * @name areIntervalsOverlapping
+ * @category Interval Helpers
+ * @summary Is the given time interval overlapping with another time interval?
+ *
+ * @description
+ * Is the given time interval overlapping with another time interval? Adjacent intervals do not count as overlapping unless `inclusive` is set to `true`.
+ *
+ * @param intervalLeft - The first interval to compare.
+ * @param intervalRight - The second interval to compare.
+ * @param options - The object with options
+ *
+ * @returns Whether the time intervals are overlapping
+ *
+ * @example
+ * // For overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) }
+ * )
+ * //=> true
+ *
+ * @example
+ * // For non-overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // For adjacent time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 30) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // Using the inclusive option:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 24) },
+ *   { inclusive: true }
+ * )
+ * //=> true
+ */
+function areIntervalsOverlapping(intervalLeft, intervalRight, options) {
+  const [leftStartTime, leftEndTime] = [
+    +(0, _index.toDate)(intervalLeft.start, options?.in),
+    +(0, _index.toDate)(intervalLeft.end, options?.in),
+  ].sort((a, b) => a - b);
+  const [rightStartTime, rightEndTime] = [
+    +(0, _index.toDate)(intervalRight.start, options?.in),
+    +(0, _index.toDate)(intervalRight.end, options?.in),
+  ].sort((a, b) => a - b);
+
+  if (options?.inclusive)
+    return leftStartTime <= rightEndTime && rightStartTime <= leftEndTime;
+
+  return leftStartTime < rightEndTime && rightStartTime < leftEndTime;
+}

node_modules/date-fns/areIntervalsOverlapping.d.cts

@@ -0,0 +1,60 @@
+import type { ContextOptions, Interval } from "./types.js";
+/**
+ * The {@link areIntervalsOverlapping} function options.
+ */
+export interface AreIntervalsOverlappingOptions extends ContextOptions<Date> {
+  /** Whether the comparison is inclusive or not */
+  inclusive?: boolean;
+}
+/**
+ * @name areIntervalsOverlapping
+ * @category Interval Helpers
+ * @summary Is the given time interval overlapping with another time interval?
+ *
+ * @description
+ * Is the given time interval overlapping with another time interval? Adjacent intervals do not count as overlapping unless `inclusive` is set to `true`.
+ *
+ * @param intervalLeft - The first interval to compare.
+ * @param intervalRight - The second interval to compare.
+ * @param options - The object with options
+ *
+ * @returns Whether the time intervals are overlapping
+ *
+ * @example
+ * // For overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) }
+ * )
+ * //=> true
+ *
+ * @example
+ * // For non-overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // For adjacent time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 30) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // Using the inclusive option:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 24) },
+ *   { inclusive: true }
+ * )
+ * //=> true
+ */
+export declare function areIntervalsOverlapping(
+  intervalLeft: Interval,
+  intervalRight: Interval,
+  options?: AreIntervalsOverlappingOptions,
+): boolean;

node_modules/date-fns/areIntervalsOverlapping.js

@@ -0,0 +1,71 @@
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link areIntervalsOverlapping} function options.
+ */
+
+/**
+ * @name areIntervalsOverlapping
+ * @category Interval Helpers
+ * @summary Is the given time interval overlapping with another time interval?
+ *
+ * @description
+ * Is the given time interval overlapping with another time interval? Adjacent intervals do not count as overlapping unless `inclusive` is set to `true`.
+ *
+ * @param intervalLeft - The first interval to compare.
+ * @param intervalRight - The second interval to compare.
+ * @param options - The object with options
+ *
+ * @returns Whether the time intervals are overlapping
+ *
+ * @example
+ * // For overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) }
+ * )
+ * //=> true
+ *
+ * @example
+ * // For non-overlapping time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // For adjacent time intervals:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 30) }
+ * )
+ * //=> false
+ *
+ * @example
+ * // Using the inclusive option:
+ * areIntervalsOverlapping(
+ *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+ *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 24) },
+ *   { inclusive: true }
+ * )
+ * //=> true
+ */
+export function areIntervalsOverlapping(intervalLeft, intervalRight, options) {
+  const [leftStartTime, leftEndTime] = [
+    +toDate(intervalLeft.start, options?.in),
+    +toDate(intervalLeft.end, options?.in),
+  ].sort((a, b) => a - b);
+  const [rightStartTime, rightEndTime] = [
+    +toDate(intervalRight.start, options?.in),
+    +toDate(intervalRight.end, options?.in),
+  ].sort((a, b) => a - b);
+
+  if (options?.inclusive)
+    return leftStartTime <= rightEndTime && rightStartTime <= leftEndTime;
+
+  return leftStartTime < rightEndTime && rightStartTime < leftEndTime;
+}
+
+// Fallback for modularized imports:
+export default areIntervalsOverlapping;

node_modules/date-fns/clamp.cjs

@@ -0,0 +1,61 @@
+"use strict";
+exports.clamp = clamp;
+var _index = require("./_lib/normalizeDates.cjs");
+var _index2 = require("./max.cjs");
+var _index3 = require("./min.cjs");
+
+/**
+ * The {@link clamp} function options.
+ */
+
+/**
+ * The {@link clamp} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+
+/**
+ * @name clamp
+ * @category Interval Helpers
+ * @summary Return a date bounded by the start and the end of the given interval.
+ *
+ * @description
+ * Clamps a date to the lower bound with the start of the interval and the upper
+ * bound with the end of the interval.
+ *
+ * - When the date is less than the start of the interval, the start is returned.
+ * - When the date is greater than the end of the interval, the end is returned.
+ * - Otherwise the date is returned.
+ *
+ * @typeParam DateType - Date argument type.
+ * @typeParam IntervalType - Interval argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param date - The date to be bounded
+ * @param interval - The interval to bound to
+ * @param options - An object with options
+ *
+ * @returns The date bounded by the start and the end of the interval
+ *
+ * @example
+ * // What is Mar 21, 2021 bounded to an interval starting at Mar 22, 2021 and ending at Apr 01, 2021
+ * const result = clamp(new Date(2021, 2, 21), {
+ *   start: new Date(2021, 2, 22),
+ *   end: new Date(2021, 3, 1),
+ * })
+ * //=> Mon Mar 22 2021 00:00:00
+ */
+function clamp(date, interval, options) {
+  const [date_, start, end] = (0, _index.normalizeDates)(
+    options?.in,
+    date,
+    interval.start,
+    interval.end,
+  );
+
+  return (0, _index3.min)(
+    [(0, _index2.max)([date_, start], options), end],
+    options,
+  );
+}

node_modules/date-fns/clamp.d.cts

@@ -0,0 +1,66 @@
+import type { ContextOptions, DateArg, Interval } from "./types.js";
+/**
+ * The {@link clamp} function options.
+ */
+export interface ClampOptions<ContextDate extends Date = Date>
+  extends ContextOptions<ContextDate> {}
+/**
+ * The {@link clamp} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type ClampResult<
+  DateType extends DateArg<Date>,
+  IntervalType extends Interval,
+  Options extends ClampOptions | undefined,
+> =
+  Options extends ClampOptions<infer DateType extends Date>
+    ? DateType
+    : DateType extends Date
+      ? DateType
+      : IntervalType["start"] extends Date
+        ? IntervalType["start"]
+        : IntervalType["end"] extends Date
+          ? IntervalType["end"]
+          : Date;
+/**
+ * @name clamp
+ * @category Interval Helpers
+ * @summary Return a date bounded by the start and the end of the given interval.
+ *
+ * @description
+ * Clamps a date to the lower bound with the start of the interval and the upper
+ * bound with the end of the interval.
+ *
+ * - When the date is less than the start of the interval, the start is returned.
+ * - When the date is greater than the end of the interval, the end is returned.
+ * - Otherwise the date is returned.
+ *
+ * @typeParam DateType - Date argument type.
+ * @typeParam IntervalType - Interval argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param date - The date to be bounded
+ * @param interval - The interval to bound to
+ * @param options - An object with options
+ *
+ * @returns The date bounded by the start and the end of the interval
+ *
+ * @example
+ * // What is Mar 21, 2021 bounded to an interval starting at Mar 22, 2021 and ending at Apr 01, 2021
+ * const result = clamp(new Date(2021, 2, 21), {
+ *   start: new Date(2021, 2, 22),
+ *   end: new Date(2021, 3, 1),
+ * })
+ * //=> Mon Mar 22 2021 00:00:00
+ */
+export declare function clamp<
+  DateType extends DateArg<Date>,
+  IntervalType extends Interval,
+  Options extends ClampOptions | undefined = undefined,
+>(
+  date: DateType,
+  interval: IntervalType,
+  options?: Options,
+): ClampResult<DateType, IntervalType, Options>;

node_modules/date-fns/clamp.js

@@ -0,0 +1,59 @@
+import { normalizeDates } from "./_lib/normalizeDates.js";
+import { max } from "./max.js";
+import { min } from "./min.js";
+
+/**
+ * The {@link clamp} function options.
+ */
+
+/**
+ * The {@link clamp} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+
+/**
+ * @name clamp
+ * @category Interval Helpers
+ * @summary Return a date bounded by the start and the end of the given interval.
+ *
+ * @description
+ * Clamps a date to the lower bound with the start of the interval and the upper
+ * bound with the end of the interval.
+ *
+ * - When the date is less than the start of the interval, the start is returned.
+ * - When the date is greater than the end of the interval, the end is returned.
+ * - Otherwise the date is returned.
+ *
+ * @typeParam DateType - Date argument type.
+ * @typeParam IntervalType - Interval argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param date - The date to be bounded
+ * @param interval - The interval to bound to
+ * @param options - An object with options
+ *
+ * @returns The date bounded by the start and the end of the interval
+ *
+ * @example
+ * // What is Mar 21, 2021 bounded to an interval starting at Mar 22, 2021 and ending at Apr 01, 2021
+ * const result = clamp(new Date(2021, 2, 21), {
+ *   start: new Date(2021, 2, 22),
+ *   end: new Date(2021, 3, 1),
+ * })
+ * //=> Mon Mar 22 2021 00:00:00
+ */
+export function clamp(date, interval, options) {
+  const [date_, start, end] = normalizeDates(
+    options?.in,
+    date,
+    interval.start,
+    interval.end,
+  );
+
+  return min([max([date_, start], options), end], options);
+}
+
+// Fallback for modularized imports:
+export default clamp;

node_modules/date-fns/closestIndexTo.cjs

@@ -0,0 +1,56 @@
+"use strict";
+exports.closestIndexTo = closestIndexTo;
+var _index = require("./toDate.cjs");
+
+/**
+ * @name closestIndexTo
+ * @category Common Helpers
+ * @summary Return an index of the closest date from the array comparing to the given date.
+ *
+ * @description
+ * Return an index of the closest date from the array comparing to the given date.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns An index of the date closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const datesArray = [
+ *   new Date(2015, 0, 1),
+ *   new Date(2016, 0, 1),
+ *   new Date(2017, 0, 1)
+ * ]
+ * const result = closestIndexTo(dateToCompare, datesArray)
+ * //=> 1
+ */
+function closestIndexTo(dateToCompare, dates) {
+  // [TODO] It would be better to return -1 here rather than undefined, as this
+  // is how JS behaves, but it would be a breaking change, so we need
+  // to consider it for v4.
+  const timeToCompare = +(0, _index.toDate)(dateToCompare);
+
+  if (isNaN(timeToCompare)) return NaN;
+
+  let result;
+  let minDistance;
+  dates.forEach((date, index) => {
+    const date_ = (0, _index.toDate)(date);
+
+    if (isNaN(+date_)) {
+      result = NaN;
+      minDistance = NaN;
+      return;
+    }
+
+    const distance = Math.abs(timeToCompare - +date_);
+    if (result == null || distance < minDistance) {
+      result = index;
+      minDistance = distance;
+    }
+  });
+
+  return result;
+}

node_modules/date-fns/closestIndexTo.d.cts

@@ -0,0 +1,29 @@
+import type { DateArg } from "./types.js";
+/**
+ * @name closestIndexTo
+ * @category Common Helpers
+ * @summary Return an index of the closest date from the array comparing to the given date.
+ *
+ * @description
+ * Return an index of the closest date from the array comparing to the given date.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns An index of the date closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const datesArray = [
+ *   new Date(2015, 0, 1),
+ *   new Date(2016, 0, 1),
+ *   new Date(2017, 0, 1)
+ * ]
+ * const result = closestIndexTo(dateToCompare, datesArray)
+ * //=> 1
+ */
+export declare function closestIndexTo(
+  dateToCompare: DateArg<Date> & {},
+  dates: Array<DateArg<Date> & {}>,
+): number | undefined;

node_modules/date-fns/closestIndexTo.js

@@ -0,0 +1,57 @@
+import { toDate } from "./toDate.js";
+
+/**
+ * @name closestIndexTo
+ * @category Common Helpers
+ * @summary Return an index of the closest date from the array comparing to the given date.
+ *
+ * @description
+ * Return an index of the closest date from the array comparing to the given date.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns An index of the date closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const datesArray = [
+ *   new Date(2015, 0, 1),
+ *   new Date(2016, 0, 1),
+ *   new Date(2017, 0, 1)
+ * ]
+ * const result = closestIndexTo(dateToCompare, datesArray)
+ * //=> 1
+ */
+export function closestIndexTo(dateToCompare, dates) {
+  // [TODO] It would be better to return -1 here rather than undefined, as this
+  // is how JS behaves, but it would be a breaking change, so we need
+  // to consider it for v4.
+  const timeToCompare = +toDate(dateToCompare);
+
+  if (isNaN(timeToCompare)) return NaN;
+
+  let result;
+  let minDistance;
+  dates.forEach((date, index) => {
+    const date_ = toDate(date);
+
+    if (isNaN(+date_)) {
+      result = NaN;
+      minDistance = NaN;
+      return;
+    }
+
+    const distance = Math.abs(timeToCompare - +date_);
+    if (result == null || distance < minDistance) {
+      result = index;
+      minDistance = distance;
+    }
+  });
+
+  return result;
+}
+
+// Fallback for modularized imports:
+export default closestIndexTo;

node_modules/date-fns/closestTo.cjs

@@ -0,0 +1,57 @@
+"use strict";
+exports.closestTo = closestTo;
+var _index = require("./_lib/normalizeDates.cjs");
+var _index2 = require("./closestIndexTo.cjs");
+var _index3 = require("./constructFrom.cjs");
+
+/**
+ * The {@link closestTo} function options.
+ */
+
+/**
+ * The {@link closestTo} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+
+/**
+ * @name closestTo
+ * @category Common Helpers
+ * @summary Return a date from the array closest to the given date.
+ *
+ * @description
+ * Return a date from the array closest to the given date.
+ *
+ * @typeParam DateToCompare - Date to compare argument type.
+ * @typeParam DatesType - Dates array argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns The date from the array closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015: 1 January 2000 or 1 January 2030?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const result = closestTo(dateToCompare, [
+ *   new Date(2000, 0, 1),
+ *   new Date(2030, 0, 1)
+ * ])
+ * //=> Tue Jan 01 2030 00:00:00
+ */
+function closestTo(dateToCompare, dates, options) {
+  const [dateToCompare_, ...dates_] = (0, _index.normalizeDates)(
+    options?.in,
+    dateToCompare,
+    ...dates,
+  );
+
+  const index = (0, _index2.closestIndexTo)(dateToCompare_, dates_);
+
+  if (typeof index === "number" && isNaN(index))
+    return (0, _index3.constructFrom)(dateToCompare_, NaN);
+
+  if (index !== undefined) return dates_[index];
+}

node_modules/date-fns/closestTo.d.cts

@@ -0,0 +1,59 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link closestTo} function options.
+ */
+export interface ClosestToOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * The {@link closestTo} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type ClosestToResult<
+  DateToCompare extends DateArg<Date>,
+  DatesType extends DateArg<Date>[],
+  Options extends ClosestToOptions | undefined,
+> =
+  Options extends ClosestToOptions<infer DateType extends Date>
+    ? DateType
+    : DateToCompare extends Date
+      ? DateToCompare
+      : DatesType extends DateArg<infer DateType>[]
+        ? DateType
+        : Date;
+/**
+ * @name closestTo
+ * @category Common Helpers
+ * @summary Return a date from the array closest to the given date.
+ *
+ * @description
+ * Return a date from the array closest to the given date.
+ *
+ * @typeParam DateToCompare - Date to compare argument type.
+ * @typeParam DatesType - Dates array argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns The date from the array closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015: 1 January 2000 or 1 January 2030?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const result = closestTo(dateToCompare, [
+ *   new Date(2000, 0, 1),
+ *   new Date(2030, 0, 1)
+ * ])
+ * //=> Tue Jan 01 2030 00:00:00
+ */
+export declare function closestTo<
+  DateToCompare extends DateArg<Date>,
+  DatesType extends DateArg<Date>[],
+  Options extends ClosestToOptions | undefined = undefined,
+>(
+  dateToCompare: DateToCompare,
+  dates: DatesType,
+  options?: Options | undefined,
+): ClosestToResult<DateToCompare, DatesType, Options> | undefined;

node_modules/date-fns/closestTo.js

@@ -0,0 +1,58 @@
+import { normalizeDates } from "./_lib/normalizeDates.js";
+import { closestIndexTo } from "./closestIndexTo.js";
+import { constructFrom } from "./constructFrom.js";
+
+/**
+ * The {@link closestTo} function options.
+ */
+
+/**
+ * The {@link closestTo} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+
+/**
+ * @name closestTo
+ * @category Common Helpers
+ * @summary Return a date from the array closest to the given date.
+ *
+ * @description
+ * Return a date from the array closest to the given date.
+ *
+ * @typeParam DateToCompare - Date to compare argument type.
+ * @typeParam DatesType - Dates array argument type.
+ * @typeParam Options - Options type.
+ *
+ * @param dateToCompare - The date to compare with
+ * @param dates - The array to search
+ *
+ * @returns The date from the array closest to the given date or undefined if no valid value is given
+ *
+ * @example
+ * // Which date is closer to 6 September 2015: 1 January 2000 or 1 January 2030?
+ * const dateToCompare = new Date(2015, 8, 6)
+ * const result = closestTo(dateToCompare, [
+ *   new Date(2000, 0, 1),
+ *   new Date(2030, 0, 1)
+ * ])
+ * //=> Tue Jan 01 2030 00:00:00
+ */
+export function closestTo(dateToCompare, dates, options) {
+  const [dateToCompare_, ...dates_] = normalizeDates(
+    options?.in,
+    dateToCompare,
+    ...dates,
+  );
+
+  const index = closestIndexTo(dateToCompare_, dates_);
+
+  if (typeof index === "number" && isNaN(index))
+    return constructFrom(dateToCompare_, NaN);
+
+  if (index !== undefined) return dates_[index];
+}
+
+// Fallback for modularized imports:
+export default closestTo;