MERDE.COM/eternos
Archived
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

registration

Browse Source
This commit is contained in:
User
2025-02-02 16:08:03 +03:00
parent 7f6495eb4d
commit 78afbaed71
6334 changed files with 196774 additions and 165754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
frontend/style/node_modules/date-fns/CHANGELOG.md generated vendored
View File

@@ -8,6 +8,70 @@ This change log follows the format documented in [Keep a CHANGELOG].
[semantic versioning]: http://semver.org/
[keep a changelog]: http://keepachangelog.com/
## v4.1.0 - 2024-09-17
This release adds time zone support to format functions (that I somehow missed when working on the feature) and fixes a few bugs.
Make sure also upgrade `TZDate` to v1.0.2 as it [includes a bunch of critical bug fixes](https://github.com/date-fns/tz/blob/main/CHANGELOG.md#v102---2024-09-14).
### Fixed
- Fixed internal `constructFrom` throwing an exception on `null` arguments. While `null` isn't allowed, the functions should rather return `Invalid Date` or `NaN` in such cases. See [#3885](https://github.com/date-fns/date-fns/issues/3885).
### Added
- Added missing time zone support to `format`, `formatISO`, `formatISO9075`, `formatRelative` and `formatRFC3339`. See [#3886](https://github.com/date-fns/date-fns/issues/3886).
## v4.0.0 - 2024-09-16
I have great news! First, ten years after its release, date-fns finally gets first-class time zone support.
Another great news is that there aren't many breaking changes in this release. All of them are type-related and will affect only those explicitly using internal date-fns types. Finally, it has been less than a year since the last major release, which is an improvement over the previous four years between v2 and v3. I plan on keeping the pace and minimizing breaking changes moving forward.
[Read more about the release in the announcement blog post](https://blog.date-fns.org/v40-with-time-zone-support/).
\- [Sasha @kossnocorp](https://twitter.com/kossnocorp)
### Added
- Added time zones support via [`@date-fns/tz`](https://github.com/date-fns/tz)'s `TZDate` class and `tz` helper function. See its [README](https://github.com/date-fns/tz) for the details about the API.
- All relevant functions now accept the context `in` option, which allows to specify the time zone to make the calculations in. If the function also returns a date, it will be in the specified time zone:
```ts
import { addDays, startOfDay } from "date-fns";
import { tz } from "@date-fns/tz";
startOfDay(addDays(Date.now(), 5, { in: tz("Asia/Singapore") }));
//=> "2024-09-16T00:00:00.000+08:00"
```
In the example, `addDays` will get the current date and time in Singapore and add 5 days to it. `startOfDay` will inherit the date type and return the start of the day in Singapore.
### Changed
- The function arguments, as well as `Interval`'s `start` and `end`, now can be of different types, allowing you to mix `UTCDate`, `TZDate`, `Date`, and other extensions, as well as primitives (strings and numbers).
The functions will normalize these values, make calculations, and return the result in the same type, preventing any bugs caused by the discrepancy. If passed, the type will be inferred from the context `in` option or the first encountered argument object type. The `Interval`'s `start` and `end` will be considered separately, starting from `start`.
In the given example, the result will be in the `TZDate` as the first argument is a number, and the `start` takes precedence over the `end`.
```ts
clamp(Date.now(), {
start: new TZDate(start, "Asia/Singapore"),
end: new UTCDate(),
});
//=> TZDate
```
- **BREAKING**: This release contains a bunch of types changes that should not affect the library's expected usage. The changes are primarily internal and nuanced, so rather than listing them here, I recommend you running the type checker after the upgrade. If there are unfixable problems, please [open an issue](https://github.com/date-fns/date-fns/issues/new).
- **BREAKING**: The package now is ESM-first. The CommonJS is still support and It should not affect most users, but it might break in certains environments. If you encounter any issues, please [report them](https://github.com/date-fns/date-fns/issues/new).
### Fixed
- Fixed CDN build compatibility with jQuery and other tools that expose `$` by properly wrapping the code in an IIFE.
## v3.6.0 - 2024-03-18
On this release worked @kossnocorp and @world1dan. Also, thanks to [@seated](https://github.com/seated) [for sponsoring me](https://github.com/sponsors/kossnocorp).
@@ -90,7 +154,7 @@ This release is brought to you by @kossnocorp, @fturmel, @grossbart, @MelvinVerm
### Fixed
- Fixed types compatability with Lodash's `flow` and fp-ts's `pipe`. ([#3641](https://github.com/date-fns/date-fns/issues/3641))
- Fixed types compatibility with Lodash's `flow` and fp-ts's `pipe`. ([#3641](https://github.com/date-fns/date-fns/issues/3641))
- [Fixed inconsistent behavior of `roundToNearestMinutes`.](https://github.com/date-fns/date-fns/pull/3132)
@@ -1599,7 +1663,7 @@ If you're upgrading from v2 alpha or beta, [see the pre-release changelog](https
- [New `roundToNearestMinutes` function](https://github.com/date-fns/date-fns/pull/928). Kudos to [@xkizer](https://github.com/xkizer).
- Added new function `fromUnixTime`. Thansk to [@xkizer](https://github.com/xkizer).
- Added new function `fromUnixTime`. Thanks to [@xkizer](https://github.com/xkizer).
- New interval, month, and year helpers to fetch a list of all Saturdays and Sundays (weekends) for a given date interval. `eachWeekendOfInterval` is the handler function while the other two are wrapper functions. Kudos to [@laekettavong](https://github.com/laekettavong)!

3
frontend/style/node_modules/date-fns/README.md generated vendored
View File

@@ -1,4 +1,4 @@
🎉️ **NEW**: [date-fns v3 is out!](https://blog.date-fns.org/v3-is-out/)
🔥️ **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" />
@@ -52,7 +52,6 @@ npm install date-fns --save
and other docs.
<br />
<!-- END OF README-JOB SECTION -->
## License

2
frontend/style/node_modules/date-fns/SECURITY.md generated vendored
View File

@@ -6,7 +6,7 @@ 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.**
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.

7
frontend/style/node_modules/date-fns/_lib/addLeadingZeros.cjs generated vendored Normal file
View File

@@ -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;
}

0
frontend/style/node_modules/date-fns/_lib/addLeadingZeros.d.mts → frontend/style/node_modules/date-fns/_lib/addLeadingZeros.d.cts generated vendored
View File

4
frontend/style/node_modules/date-fns/_lib/addLeadingZeros.js generated vendored
View File

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

5
frontend/style/node_modules/date-fns/_lib/addLeadingZeros.mjs generated vendored
View File

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

8
frontend/style/node_modules/date-fns/_lib/defaultLocale.cjs generated vendored Normal file
View File

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

0
frontend/style/node_modules/date-fns/_lib/defaultLocale.d.mts → frontend/style/node_modules/date-fns/_lib/defaultLocale.d.cts generated vendored
View File

9
frontend/style/node_modules/date-fns/_lib/defaultLocale.js generated vendored
View File

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

1
frontend/style/node_modules/date-fns/_lib/defaultLocale.mjs generated vendored
View File

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

13
frontend/style/node_modules/date-fns/_lib/defaultOptions.cjs generated vendored Normal file
View File

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

0
frontend/style/node_modules/date-fns/_lib/defaultOptions.d.mts → frontend/style/node_modules/date-fns/_lib/defaultOptions.d.cts generated vendored
View File

8
frontend/style/node_modules/date-fns/_lib/defaultOptions.js generated vendored
View File

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

9
frontend/style/node_modules/date-fns/_lib/defaultOptions.mjs generated vendored
View File

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

780
frontend/style/node_modules/date-fns/_lib/format/formatters.cjs generated vendored Normal file
View File

@@ -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;
}

0
frontend/style/node_modules/date-fns/_lib/format/formatters.d.mts → frontend/style/node_modules/date-fns/_lib/format/formatters.d.cts generated vendored
View File

93
frontend/style/node_modules/date-fns/_lib/format/formatters.js generated vendored
View File

@@ -1,13 +1,11 @@
"use strict";
exports.formatters = void 0;
var _index = require("../../getDayOfYear.js");
var _index2 = require("../../getISOWeek.js");
var _index3 = require("../../getISOWeekYear.js");
var _index4 = require("../../getWeek.js");
var _index5 = require("../../getWeekYear.js");
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";
var _index6 = require("../addLeadingZeros.js");
var _index7 = require("./lightFormatters.js");
import { addLeadingZeros } from "../addLeadingZeros.js";
import { lightFormatters } from "./lightFormatters.js";
const dayPeriodEnum = {
am: "am",
@@ -66,7 +64,7 @@ const dayPeriodEnum = {
* - `p` is long localized time format
*/
const formatters = (exports.formatters = {
export const formatters = {
// Era
G: function (date, token, localize) {
const era = date.getFullYear() > 0 ? 1 : 0;
@@ -96,19 +94,19 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(year, { unit: "year" });
}
return _index7.lightFormatters.y(date, token);
return lightFormatters.y(date, token);
},
// Local week-numbering year
Y: function (date, token, localize, options) {
const signedWeekYear = (0, _index5.getWeekYear)(date, 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 (0, _index6.addLeadingZeros)(twoDigitYear, 2);
return addLeadingZeros(twoDigitYear, 2);
}
// Ordinal number
@@ -117,15 +115,15 @@ const formatters = (exports.formatters = {
}
// Padding
return (0, _index6.addLeadingZeros)(weekYear, token.length);
return addLeadingZeros(weekYear, token.length);
},
// ISO week-numbering year
R: function (date, token) {
const isoWeekYear = (0, _index3.getISOWeekYear)(date);
const isoWeekYear = getISOWeekYear(date);
// Padding
return (0, _index6.addLeadingZeros)(isoWeekYear, token.length);
return addLeadingZeros(isoWeekYear, token.length);
},
// Extended year. This is a single number designating the year of this calendar system.
@@ -139,7 +137,7 @@ const formatters = (exports.formatters = {
// 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);
return addLeadingZeros(year, token.length);
},
// Quarter
@@ -151,7 +149,7 @@ const formatters = (exports.formatters = {
return String(quarter);
// 01, 02, 03, 04
case "QQ":
return (0, _index6.addLeadingZeros)(quarter, 2);
return addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "Qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
@@ -186,7 +184,7 @@ const formatters = (exports.formatters = {
return String(quarter);
// 01, 02, 03, 04
case "qq":
return (0, _index6.addLeadingZeros)(quarter, 2);
return addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
@@ -218,7 +216,7 @@ const formatters = (exports.formatters = {
switch (token) {
case "M":
case "MM":
return _index7.lightFormatters.M(date, token);
return lightFormatters.M(date, token);
// 1st, 2nd, ..., 12th
case "Mo":
return localize.ordinalNumber(month + 1, { unit: "month" });
@@ -250,7 +248,7 @@ const formatters = (exports.formatters = {
return String(month + 1);
// 01, 02, ..., 12
case "LL":
return (0, _index6.addLeadingZeros)(month + 1, 2);
return addLeadingZeros(month + 1, 2);
// 1st, 2nd, ..., 12th
case "Lo":
return localize.ordinalNumber(month + 1, { unit: "month" });
@@ -275,24 +273,24 @@ const formatters = (exports.formatters = {
// Local week of year
w: function (date, token, localize, options) {
const week = (0, _index4.getWeek)(date, options);
const week = getWeek(date, options);
if (token === "wo") {
return localize.ordinalNumber(week, { unit: "week" });
}
return (0, _index6.addLeadingZeros)(week, token.length);
return addLeadingZeros(week, token.length);
},
// ISO week of year
I: function (date, token, localize) {
const isoWeek = (0, _index2.getISOWeek)(date);
const isoWeek = getISOWeek(date);
if (token === "Io") {
return localize.ordinalNumber(isoWeek, { unit: "week" });
}
return (0, _index6.addLeadingZeros)(isoWeek, token.length);
return addLeadingZeros(isoWeek, token.length);
},
// Day of the month
@@ -301,18 +299,18 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(date.getDate(), { unit: "date" });
}
return _index7.lightFormatters.d(date, token);
return lightFormatters.d(date, token);
},
// Day of year
D: function (date, token, localize) {
const dayOfYear = (0, _index.getDayOfYear)(date);
const dayOfYear = getDayOfYear(date);
if (token === "Do") {
return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
}
return (0, _index6.addLeadingZeros)(dayOfYear, token.length);
return addLeadingZeros(dayOfYear, token.length);
},
// Day of week
@@ -359,7 +357,7 @@ const formatters = (exports.formatters = {
return String(localDayOfWeek);
// Padded numerical value
case "ee":
return (0, _index6.addLeadingZeros)(localDayOfWeek, 2);
return addLeadingZeros(localDayOfWeek, 2);
// 1st, 2nd, ..., 7th
case "eo":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
@@ -400,7 +398,7 @@ const formatters = (exports.formatters = {
return String(localDayOfWeek);
// Padded numerical value
case "cc":
return (0, _index6.addLeadingZeros)(localDayOfWeek, token.length);
return addLeadingZeros(localDayOfWeek, token.length);
// 1st, 2nd, ..., 7th
case "co":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
@@ -441,7 +439,7 @@ const formatters = (exports.formatters = {
return String(isoDayOfWeek);
// 02
case "ii":
return (0, _index6.addLeadingZeros)(isoDayOfWeek, token.length);
return addLeadingZeros(isoDayOfWeek, token.length);
// 2nd
case "io":
return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
@@ -590,7 +588,7 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return _index7.lightFormatters.h(date, token);
return lightFormatters.h(date, token);
},
// Hour [0-23]
@@ -599,7 +597,7 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(date.getHours(), { unit: "hour" });
}
return _index7.lightFormatters.H(date, token);
return lightFormatters.H(date, token);
},
// Hour [0-11]
@@ -610,7 +608,7 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return (0, _index6.addLeadingZeros)(hours, token.length);
return addLeadingZeros(hours, token.length);
},
// Hour [1-24]
@@ -622,7 +620,7 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return (0, _index6.addLeadingZeros)(hours, token.length);
return addLeadingZeros(hours, token.length);
},
// Minute
@@ -631,7 +629,7 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
}
return _index7.lightFormatters.m(date, token);
return lightFormatters.m(date, token);
},
// Second
@@ -640,12 +638,12 @@ const formatters = (exports.formatters = {
return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
}
return _index7.lightFormatters.s(date, token);
return lightFormatters.s(date, token);
},
// Fraction of second
S: function (date, token) {
return _index7.lightFormatters.S(date, token);
return lightFormatters.S(date, token);
},
// Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
@@ -740,16 +738,15 @@ const formatters = (exports.formatters = {
// Seconds timestamp
t: function (date, token, _localize) {
const timestamp = Math.trunc(date.getTime() / 1000);
return (0, _index6.addLeadingZeros)(timestamp, token.length);
const timestamp = Math.trunc(+date / 1000);
return addLeadingZeros(timestamp, token.length);
},
// Milliseconds timestamp
T: function (date, token, _localize) {
const timestamp = date.getTime();
return (0, _index6.addLeadingZeros)(timestamp, token.length);
return addLeadingZeros(+date, token.length);
},
});
};
function formatTimezoneShort(offset, delimiter = "") {
const sign = offset > 0 ? "-" : "+";
@@ -759,15 +756,13 @@ function formatTimezoneShort(offset, delimiter = "") {
if (minutes === 0) {
return sign + String(hours);
}
return (
sign + String(hours) + delimiter + (0, _index6.addLeadingZeros)(minutes, 2)
);
return sign + String(hours) + delimiter + 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 sign + addLeadingZeros(Math.abs(offset) / 60, 2);
}
return formatTimezone(offset, delimiter);
}
@@ -775,7 +770,7 @@ function formatTimezoneWithOptionalMinutes(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);
const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
const minutes = addLeadingZeros(absOffset % 60, 2);
return sign + hours + delimiter + minutes;
}

776
frontend/style/node_modules/date-fns/_lib/format/formatters.mjs generated vendored
View File

@@ -1,776 +0,0 @@
import { getDayOfYear } from "../../getDayOfYear.mjs";
import { getISOWeek } from "../../getISOWeek.mjs";
import { getISOWeekYear } from "../../getISOWeekYear.mjs";
import { getWeek } from "../../getWeek.mjs";
import { getWeekYear } from "../../getWeekYear.mjs";
import { addLeadingZeros } from "../addLeadingZeros.mjs";
import { lightFormatters } from "./lightFormatters.mjs";
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.getTime() / 1000);
return addLeadingZeros(timestamp, token.length);
},
// Milliseconds timestamp
T: function (date, token, _localize) {
const timestamp = date.getTime();
return addLeadingZeros(timestamp, 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;
}

102
frontend/style/node_modules/date-fns/_lib/format/lightFormatters.cjs generated vendored Normal file
View File

@@ -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);
},
});

0
frontend/style/node_modules/date-fns/_lib/format/lightFormatters.d.mts → frontend/style/node_modules/date-fns/_lib/format/lightFormatters.d.cts generated vendored
View File

32
frontend/style/node_modules/date-fns/_lib/format/lightFormatters.js generated vendored
View File

@@ -1,6 +1,4 @@
"use strict";
exports.lightFormatters = void 0;
var _index = require("../addLeadingZeros.js");
import { addLeadingZeros } from "../addLeadingZeros.js";
/*
* | | Unit | | Unit |
@@ -15,7 +13,7 @@ var _index = require("../addLeadingZeros.js");
* Letters marked by * are not implemented but reserved by Unicode standard.
*/
const lightFormatters = (exports.lightFormatters = {
export const lightFormatters = {
// Year
y(date, token) {
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
@@ -30,23 +28,18 @@ const lightFormatters = (exports.lightFormatters = {
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,
);
return 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);
return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
},
// Day of the month
d(date, token) {
return (0, _index.addLeadingZeros)(date.getDate(), token.length);
return addLeadingZeros(date.getDate(), token.length);
},
// AM or PM
@@ -69,25 +62,22 @@ const lightFormatters = (exports.lightFormatters = {
// Hour [1-12]
h(date, token) {
return (0, _index.addLeadingZeros)(
date.getHours() % 12 || 12,
token.length,
);
return addLeadingZeros(date.getHours() % 12 || 12, token.length);
},
// Hour [0-23]
H(date, token) {
return (0, _index.addLeadingZeros)(date.getHours(), token.length);
return addLeadingZeros(date.getHours(), token.length);
},
// Minute
m(date, token) {
return (0, _index.addLeadingZeros)(date.getMinutes(), token.length);
return addLeadingZeros(date.getMinutes(), token.length);
},
// Second
s(date, token) {
return (0, _index.addLeadingZeros)(date.getSeconds(), token.length);
return addLeadingZeros(date.getSeconds(), token.length);
},
// Fraction of second
@@ -97,6 +87,6 @@ const lightFormatters = (exports.lightFormatters = {
const fractionalSeconds = Math.trunc(
milliseconds * Math.pow(10, numberOfDigits - 3),
);
return (0, _index.addLeadingZeros)(fractionalSeconds, token.length);
return addLeadingZeros(fractionalSeconds, token.length);
},
});
};

92
frontend/style/node_modules/date-fns/_lib/format/lightFormatters.mjs generated vendored
View File

@@ -1,92 +0,0 @@
import { addLeadingZeros } from "../addLeadingZeros.mjs";
/*
* | | 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);
},
};

67
frontend/style/node_modules/date-fns/_lib/format/longFormatters.cjs generated vendored Normal file
View File

@@ -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,
});

0
frontend/style/node_modules/date-fns/_lib/format/longFormatters.d.mts → frontend/style/node_modules/date-fns/_lib/format/longFormatters.d.cts generated vendored
View File

7
frontend/style/node_modules/date-fns/_lib/format/longFormatters.js generated vendored
View File

@@ -1,6 +1,3 @@
"use strict";
exports.longFormatters = void 0;
const dateLongFormatter = (pattern, formatLong) => {
switch (pattern) {
case "P":
@@ -61,7 +58,7 @@ const dateTimeLongFormatter = (pattern, formatLong) => {
.replace("{{time}}", timeLongFormatter(timePattern, formatLong));
};
const longFormatters = (exports.longFormatters = {
export const longFormatters = {
p: timeLongFormatter,
P: dateTimeLongFormatter,
});
};

64
frontend/style/node_modules/date-fns/_lib/format/longFormatters.mjs generated vendored
View File

@@ -1,64 +0,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));
};
export const longFormatters = {
p: timeLongFormatter,
P: dateTimeLongFormatter,
};

11
frontend/style/node_modules/date-fns/_lib/getRoundingMethod.cjs generated vendored Normal file
View File

@@ -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;
};
}

0
frontend/style/node_modules/date-fns/_lib/getRoundingMethod.d.mts → frontend/style/node_modules/date-fns/_lib/getRoundingMethod.d.cts generated vendored
View File

5
frontend/style/node_modules/date-fns/_lib/getRoundingMethod.js generated vendored
View File

@@ -1,7 +1,4 @@
"use strict";
exports.getRoundingMethod = getRoundingMethod;
function getRoundingMethod(method) {
export function getRoundingMethod(method) {
return (number) => {
const round = method ? Math[method] : Math.trunc;
const result = round(number);

8
frontend/style/node_modules/date-fns/_lib/getRoundingMethod.mjs generated vendored
View File

@@ -1,8 +0,0 @@
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;
};
}

31
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.cjs generated vendored Normal file
View File

@@ -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;
}

15
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.cts generated vendored Normal file
View File

@@ -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;

14
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.mts generated vendored
View File

@@ -1,14 +0,0 @@
/**
* 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: Date | number | string,
): number;

3
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.ts generated vendored
View File

@@ -1,3 +1,4 @@
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
@@ -10,5 +11,5 @@
* This function returns the timezone offset in milliseconds that takes seconds in account.
*/
export declare function getTimezoneOffsetInMilliseconds(
date: Date | number | string,
date: DateArg<Date> & {},
): number;

8
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js generated vendored
View File

@@ -1,6 +1,4 @@
"use strict";
exports.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds;
var _index = require("../toDate.js");
import { toDate } from "../toDate.js";
/**
* Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
@@ -13,8 +11,8 @@ var _index = require("../toDate.js");
*
* This function returns the timezone offset in milliseconds that takes seconds in account.
*/
function getTimezoneOffsetInMilliseconds(date) {
const _date = (0, _index.toDate)(date);
export function getTimezoneOffsetInMilliseconds(date) {
const _date = toDate(date);
const utcDate = new Date(
Date.UTC(
_date.getFullYear(),

29
frontend/style/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.mjs generated vendored
View File

@@ -1,29 +0,0 @@
import { toDate } from "../toDate.mjs";
/**
* 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;
}

11
frontend/style/node_modules/date-fns/_lib/normalizeDates.cjs generated vendored Normal file
View File

@@ -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);
}

13
frontend/style/node_modules/date-fns/_lib/normalizeDates.d.cts generated vendored Normal file
View File

@@ -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[];

13
frontend/style/node_modules/date-fns/_lib/normalizeDates.d.ts generated vendored Normal file
View File

@@ -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[];

9
frontend/style/node_modules/date-fns/_lib/normalizeDates.js generated vendored Normal file
View File

@@ -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);
}

12
frontend/style/node_modules/date-fns/_lib/normalizeInterval.cjs generated vendored Normal file
View File

@@ -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 };
}

5
frontend/style/node_modules/date-fns/_lib/normalizeInterval.d.cts generated vendored Normal file
View File

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

5
frontend/style/node_modules/date-fns/_lib/normalizeInterval.d.ts generated vendored Normal file
View File

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

6
frontend/style/node_modules/date-fns/_lib/normalizeInterval.js generated vendored Normal file
View File

@@ -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 };
}

27
frontend/style/node_modules/date-fns/_lib/protectedTokens.cjs generated vendored Normal file
View File

@@ -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`;
}

0
frontend/style/node_modules/date-fns/_lib/protectedTokens.d.mts → frontend/style/node_modules/date-fns/_lib/protectedTokens.d.cts generated vendored
View File

10
frontend/style/node_modules/date-fns/_lib/protectedTokens.js generated vendored
View File

@@ -1,21 +1,17 @@
"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) {
export function isProtectedDayOfYearToken(token) {
return dayOfYearTokenRE.test(token);
}
function isProtectedWeekYearToken(token) {
export function isProtectedWeekYearToken(token) {
return weekYearTokenRE.test(token);
}
function warnOrThrowProtectedError(token, format, input) {
export function warnOrThrowProtectedError(token, format, input) {
const _message = message(token, format, input);
console.warn(_message);
if (throwTokens.includes(token)) throw new RangeError(_message);

23
frontend/style/node_modules/date-fns/_lib/protectedTokens.mjs generated vendored
View File

@@ -1,23 +0,0 @@
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`;
}

59
frontend/style/node_modules/date-fns/_lib/test.cjs generated vendored Normal file
View File

@@ -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 };
}

14
frontend/style/node_modules/date-fns/_lib/test.d.cts generated vendored Normal file
View File

@@ -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;
};

3
frontend/style/node_modules/date-fns/_lib/test.d.mts generated vendored
View File

@@ -1,3 +0,0 @@
export declare function assertType<T>(_: T): void;
export declare function resetDefaultOptions(): void;
export declare function generateOffset(originalDate: Date): string;

13
frontend/style/node_modules/date-fns/_lib/test.d.ts generated vendored
View File

@@ -1,3 +1,14 @@
export declare function assertType<T>(_: T): void;
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;
};

45
frontend/style/node_modules/date-fns/_lib/test.js generated vendored
View File

@@ -1,29 +1,24 @@
"use strict";
exports.assertType = assertType;
exports.generateOffset = generateOffset;
exports.resetDefaultOptions = resetDefaultOptions;
var _index = require("./addLeadingZeros.js");
var _index2 = require("./defaultOptions.js");
import { afterEach, beforeEach } from "./test/vitest";
import { addLeadingZeros } from "./addLeadingZeros.js";
import { setDefaultOptions } from "./defaultOptions.js";
import sinon from "./test/sinon";
function assertType(_) {}
export function assertType(_value) {}
function resetDefaultOptions() {
(0, _index2.setDefaultOptions)({});
export function resetDefaultOptions() {
setDefaultOptions({});
}
// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
function generateOffset(originalDate) {
export 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);
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 ? "+" : "-";
@@ -34,3 +29,23 @@ function generateOffset(originalDate) {
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 };
}

29
frontend/style/node_modules/date-fns/_lib/test.mjs generated vendored
View File

@@ -1,29 +0,0 @@
import { addLeadingZeros } from "./addLeadingZeros.mjs";
import { setDefaultOptions } from "./defaultOptions.mjs";
export function assertType(_) {}
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;
}

75
frontend/style/node_modules/date-fns/add.cjs generated vendored Normal file
View File

@@ -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,
);
}

44
frontend/style/node_modules/date-fns/add.d.cts generated vendored Normal file
View File

@@ -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;

45
frontend/style/node_modules/date-fns/add.d.mts generated vendored
View File

@@ -1,45 +0,0 @@
import type { Duration } from "./types.js";
/**
* @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 to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param duration - The object with years, months, weeks, days, hours, minutes and seconds to be added.
*
* | Key | Description |
* |----------------|------------------------------------|
* | years | Amount of years to be added |
* | months | Amount of months to be added |
* | weeks | Amount of weeks to be added |
* | days | Amount of days to be added |
* | hours | Amount of hours to be added |
* | minutes | Amount of minutes to be added |
* | seconds | Amount of seconds to be added |
*
* All values default to 0
*
* @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,\\-7
* minutes: 9,
* seconds: 30,
* })
* //=> Thu Jun 15 2017 15:29:20
*/
export declare function add<DateType extends Date>(
date: DateType | number | string,
duration: Duration,
): DateType;

41
frontend/style/node_modules/date-fns/add.d.ts generated vendored
View File

@@ -1,28 +1,23 @@
import type { Duration } from "./types.js";
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.
* @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.
* 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 to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @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.
*
* | Key | Description |
* |----------------|------------------------------------|
* | years | Amount of years to be added |
* | months | Amount of months to be added |
* | weeks | Amount of weeks to be added |
* | days | Amount of days to be added |
* | hours | Amount of hours to be added |
* | minutes | Amount of minutes to be added |
* | seconds | Amount of seconds to be added |
*
* All values default to 0
* @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
*
@@ -33,13 +28,17 @@ import type { Duration } from "./types.js";
* months: 9,
* weeks: 1,
* days: 7,
* hours: 5,\\-7
* hours: 5,
* minutes: 9,
* seconds: 30,
* })
* //=> Thu Jun 15 2017 15:29:20
*/
export declare function add<DateType extends Date>(
date: DateType | number | string,
export declare function add<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
duration: Duration,
): DateType;
options?: AddOptions<ResultDate> | undefined,
): ResultDate;

61
frontend/style/node_modules/date-fns/add.js generated vendored
View File

@@ -1,34 +1,26 @@
"use strict";
exports.add = add;
var _index = require("./addDays.js");
var _index2 = require("./addMonths.js");
var _index3 = require("./constructFrom.js");
var _index4 = require("./toDate.js");
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.
* @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.
* 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 to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @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.
*
* | Key | Description |
* |----------------|------------------------------------|
* | years | Amount of years to be added |
* | months | Amount of months to be added |
* | weeks | Amount of weeks to be added |
* | days | Amount of days to be added |
* | hours | Amount of hours to be added |
* | minutes | Amount of minutes to be added |
* | seconds | Amount of seconds to be added |
*
* All values default to 0
* @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
*
@@ -39,13 +31,13 @@ var _index4 = require("./toDate.js");
* months: 9,
* weeks: 1,
* days: 7,
* hours: 5,\\-7
* hours: 5,
* minutes: 9,
* seconds: 30,
* })
* //=> Thu Jun 15 2017 15:29:20
*/
function add(date, duration) {
export function add(date, duration, options) {
const {
years = 0,
months = 0,
@@ -57,26 +49,21 @@ function add(date, duration) {
} = duration;
// Add years and months
const _date = (0, _index4.toDate)(date);
const _date = toDate(date, options?.in);
const dateWithMonths =
months || years
? (0, _index2.addMonths)(_date, months + years * 12)
: _date;
months || years ? addMonths(_date, months + years * 12) : _date;
// Add weeks and days
const dateWithDays =
days || weeks
? (0, _index.addDays)(dateWithMonths, days + weeks * 7)
: dateWithMonths;
days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths;
// Add days, hours, minutes and seconds
// Add days, hours, minutes, and seconds
const minutesToAdd = minutes + hours * 60;
const secondsToAdd = seconds + minutesToAdd * 60;
const msToAdd = secondsToAdd * 1000;
const finalDate = (0, _index3.constructFrom)(
date,
dateWithDays.getTime() + msToAdd,
);
return finalDate;
return constructFrom(options?.in || date, +dateWithDays + msToAdd);
}
// Fallback for modularized imports:
export default add;

76
frontend/style/node_modules/date-fns/add.mjs generated vendored
View File

@@ -1,76 +0,0 @@
import { addDays } from "./addDays.mjs";
import { addMonths } from "./addMonths.mjs";
import { constructFrom } from "./constructFrom.mjs";
import { toDate } from "./toDate.mjs";
/**
* @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 to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param duration - The object with years, months, weeks, days, hours, minutes and seconds to be added.
*
* | Key | Description |
* |----------------|------------------------------------|
* | years | Amount of years to be added |
* | months | Amount of months to be added |
* | weeks | Amount of weeks to be added |
* | days | Amount of days to be added |
* | hours | Amount of hours to be added |
* | minutes | Amount of minutes to be added |
* | seconds | Amount of seconds to be added |
*
* All values default to 0
*
* @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,\\-7
* minutes: 9,
* seconds: 30,
* })
* //=> Thu Jun 15 2017 15:29:20
*/
export function add(date, duration) {
const {
years = 0,
months = 0,
weeks = 0,
days = 0,
hours = 0,
minutes = 0,
seconds = 0,
} = duration;
// Add years and months
const _date = toDate(date);
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;
const finalDate = constructFrom(date, dateWithDays.getTime() + msToAdd);
return finalDate;
}
// Fallback for modularized imports:
export default add;

76
frontend/style/node_modules/date-fns/addBusinessDays.cjs generated vendored Normal file
View File

@@ -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;
}

36
frontend/style/node_modules/date-fns/addBusinessDays.d.cts generated vendored Normal file
View File

@@ -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;

24
frontend/style/node_modules/date-fns/addBusinessDays.d.mts generated vendored
View File

@@ -1,24 +0,0 @@
/**
* @name addBusinessDays
* @category Date Extension 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).
*
* @param date - The date to be changed
* @param amount - The amount of business days to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

20
frontend/style/node_modules/date-fns/addBusinessDays.d.ts generated vendored
View File

@@ -1,15 +1,23 @@
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 Date Extension Helpers
* @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
*
@@ -18,7 +26,11 @@
* 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>(
date: DateType | number | string,
export declare function addBusinessDays<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddBusinessDaysOptions<ResultDate> | undefined,
): ResultDate;

39
frontend/style/node_modules/date-fns/addBusinessDays.js generated vendored
View File

@@ -1,23 +1,27 @@
"use strict";
exports.addBusinessDays = addBusinessDays;
var _index = require("./constructFrom.js");
var _index2 = require("./isSaturday.js");
var _index3 = require("./isSunday.js");
var _index4 = require("./isWeekend.js");
var _index5 = require("./toDate.js");
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 Date Extension Helpers
* @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
*
@@ -26,11 +30,11 @@ var _index5 = require("./toDate.js");
* const result = addBusinessDays(new Date(2014, 8, 1), 10)
* //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
*/
function addBusinessDays(date, amount) {
const _date = (0, _index5.toDate)(date);
const startedOnWeekend = (0, _index4.isWeekend)(_date);
export function addBusinessDays(date, amount, options) {
const _date = toDate(date, options?.in);
const startedOnWeekend = isWeekend(_date, options);
if (isNaN(amount)) return (0, _index.constructFrom)(date, NaN);
if (isNaN(amount)) return constructFrom(options?.in, NaN);
const hours = _date.getHours();
const sign = amount < 0 ? -1 : 1;
@@ -44,18 +48,18 @@ function addBusinessDays(date, amount) {
// Loops over remaining days
while (restDays > 0) {
_date.setDate(_date.getDate() + sign);
if (!(0, _index4.isWeekend)(_date)) restDays -= 1;
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 && (0, _index4.isWeekend)(_date) && amount !== 0) {
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 ((0, _index2.isSaturday)(_date))
if (isSaturday(_date, options))
_date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
if ((0, _index3.isSunday)(_date))
if (isSunday(_date, options))
_date.setDate(_date.getDate() + (sign < 0 ? 1 : -2));
}
@@ -64,3 +68,6 @@ function addBusinessDays(date, amount) {
return _date;
}
// Fallback for modularized imports:
export default addBusinessDays;

65
frontend/style/node_modules/date-fns/addBusinessDays.mjs generated vendored
View File

@@ -1,65 +0,0 @@
import { constructFrom } from "./constructFrom.mjs";
import { isSaturday } from "./isSaturday.mjs";
import { isSunday } from "./isSunday.mjs";
import { isWeekend } from "./isWeekend.mjs";
import { toDate } from "./toDate.mjs";
/**
* @name addBusinessDays
* @category Date Extension 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).
*
* @param date - The date to be changed
* @param amount - The amount of business days to be added.
*
* @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) {
const _date = toDate(date);
const startedOnWeekend = isWeekend(_date);
if (isNaN(amount)) return constructFrom(date, 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)) 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) && 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)) _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
if (isSunday(_date)) _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;

41
frontend/style/node_modules/date-fns/addDays.cjs generated vendored Normal file
View File

@@ -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;
}

36
frontend/style/node_modules/date-fns/addDays.d.cts generated vendored Normal file
View File

@@ -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;

24
frontend/style/node_modules/date-fns/addDays.d.mts generated vendored
View File

@@ -1,24 +0,0 @@
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of days to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

18
frontend/style/node_modules/date-fns/addDays.d.ts generated vendored
View File

@@ -1,3 +1,9 @@
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
@@ -7,9 +13,11 @@
* 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
*
@@ -18,7 +26,11 @@
* const result = addDays(new Date(2014, 8, 1), 10)
* //=> Thu Sep 11 2014 00:00:00
*/
export declare function addDays<DateType extends Date>(
date: DateType | number | string,
export declare function addDays<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddDaysOptions<ResultDate> | undefined,
): ResultDate;

29
frontend/style/node_modules/date-fns/addDays.js generated vendored
View File

@@ -1,7 +1,9 @@
"use strict";
exports.addDays = addDays;
var _index = require("./toDate.js");
var _index2 = require("./constructFrom.js");
import { constructFrom } from "./constructFrom.js";
import { toDate } from "./toDate.js";
/**
* The {@link addDays} function options.
*/
/**
* @name addDays
@@ -12,9 +14,11 @@ var _index2 = require("./constructFrom.js");
* 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
*
@@ -23,13 +27,16 @@ var _index2 = require("./constructFrom.js");
* const result = addDays(new Date(2014, 8, 1), 10)
* //=> Thu Sep 11 2014 00:00:00
*/
function addDays(date, amount) {
const _date = (0, _index.toDate)(date);
if (isNaN(amount)) return (0, _index2.constructFrom)(date, NaN);
if (!amount) {
// If 0 days, no-op to avoid changing times in the hour before end of DST
return _date;
}
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;

36
frontend/style/node_modules/date-fns/addDays.mjs generated vendored
View File

@@ -1,36 +0,0 @@
import { toDate } from "./toDate.mjs";
import { constructFrom } from "./constructFrom.mjs";
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of days to be added.
*
* @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) {
const _date = toDate(date);
if (isNaN(amount)) return constructFrom(date, NaN);
if (!amount) {
// If 0 days, no-op to avoid changing times in the hour before end of DST
return _date;
}
_date.setDate(_date.getDate() + amount);
return _date;
}
// Fallback for modularized imports:
export default addDays;

38
frontend/style/node_modules/date-fns/addHours.cjs generated vendored Normal file
View File

@@ -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,
);
}

36
frontend/style/node_modules/date-fns/addHours.d.cts generated vendored Normal file
View File

@@ -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;

24
frontend/style/node_modules/date-fns/addHours.d.mts generated vendored
View File

@@ -1,24 +0,0 @@
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of hours to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

20
frontend/style/node_modules/date-fns/addHours.d.ts generated vendored
View File

@@ -1,3 +1,9 @@
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
@@ -7,9 +13,11 @@
* 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 amount - The amount of hours to be added
* @param options - An object with options
*
* @returns The new date with the hours added
*
@@ -18,7 +26,11 @@
* 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>(
date: DateType | number | string,
export declare function addHours<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddHoursOptions<ResultDate> | undefined,
): ResultDate;

21
frontend/style/node_modules/date-fns/addHours.js generated vendored
View File

@@ -1,7 +1,9 @@
"use strict";
exports.addHours = addHours;
var _index = require("./addMilliseconds.js");
var _index2 = require("./constants.js");
import { addMilliseconds } from "./addMilliseconds.js";
import { millisecondsInHour } from "./constants.js";
/**
* The {@link addHours} function options.
*/
/**
* @name addHours
@@ -12,9 +14,11 @@ var _index2 = require("./constants.js");
* 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 amount - The amount of hours to be added
* @param options - An object with options
*
* @returns The new date with the hours added
*
@@ -23,6 +27,9 @@ var _index2 = require("./constants.js");
* const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
* //=> Fri Jul 11 2014 01:00:00
*/
function addHours(date, amount) {
return (0, _index.addMilliseconds)(date, amount * _index2.millisecondsInHour);
export function addHours(date, amount, options) {
return addMilliseconds(date, amount * millisecondsInHour, options);
}
// Fallback for modularized imports:
export default addHours;

29
frontend/style/node_modules/date-fns/addHours.mjs generated vendored
View File

@@ -1,29 +0,0 @@
import { addMilliseconds } from "./addMilliseconds.mjs";
import { millisecondsInHour } from "./constants.mjs";
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of hours to be added.
*
* @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) {
return addMilliseconds(date, amount * millisecondsInHour);
}
// Fallback for modularized imports:
export default addHours;

39
frontend/style/node_modules/date-fns/addISOWeekYears.cjs generated vendored Normal file
View File

@@ -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,
);
}

37
frontend/style/node_modules/date-fns/addISOWeekYears.d.cts generated vendored Normal file
View File

@@ -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;

26
frontend/style/node_modules/date-fns/addISOWeekYears.d.mts generated vendored
View File

@@ -1,26 +0,0 @@
/**
* @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.
*
* @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 Jn 26 2015 00:00:00
*/
export declare function addISOWeekYears<DateType extends Date>(
date: DateType | number | string,
amount: number,
): DateType;

19
frontend/style/node_modules/date-fns/addISOWeekYears.d.ts generated vendored
View File

@@ -1,3 +1,9 @@
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
@@ -12,15 +18,20 @@
*
* @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 Jn 26 2015 00:00:00
* //=> Fri Jun 26 2015 00:00:00
*/
export declare function addISOWeekYears<DateType extends Date>(
date: DateType | number | string,
export declare function addISOWeekYears<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddISOWeekYearsOptions<ResultDate> | undefined,
): ResultDate;

23
frontend/style/node_modules/date-fns/addISOWeekYears.js generated vendored
View File

@@ -1,7 +1,9 @@
"use strict";
exports.addISOWeekYears = addISOWeekYears;
var _index = require("./getISOWeekYear.js");
var _index2 = require("./setISOWeekYear.js");
import { getISOWeekYear } from "./getISOWeekYear.js";
import { setISOWeekYear } from "./setISOWeekYear.js";
/**
* The {@link addISOWeekYears} function options.
*/
/**
* @name addISOWeekYears
@@ -17,17 +19,18 @@ var _index2 = require("./setISOWeekYear.js");
*
* @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 Jn 26 2015 00:00:00
* //=> Fri Jun 26 2015 00:00:00
*/
function addISOWeekYears(date, amount) {
return (0, _index2.setISOWeekYear)(
date,
(0, _index.getISOWeekYear)(date) + amount,
);
export function addISOWeekYears(date, amount, options) {
return setISOWeekYear(date, getISOWeekYear(date, options) + amount, options);
}
// Fallback for modularized imports:
export default addISOWeekYears;

31
frontend/style/node_modules/date-fns/addISOWeekYears.mjs generated vendored
View File

@@ -1,31 +0,0 @@
import { getISOWeekYear } from "./getISOWeekYear.mjs";
import { setISOWeekYear } from "./setISOWeekYear.mjs";
/**
* @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.
*
* @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 Jn 26 2015 00:00:00
*/
export function addISOWeekYears(date, amount) {
return setISOWeekYear(date, getISOWeekYear(date) + amount);
}
// Fallback for modularized imports:
export default addISOWeekYears;

37
frontend/style/node_modules/date-fns/addMilliseconds.cjs generated vendored Normal file
View File

@@ -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,
);
}

36
frontend/style/node_modules/date-fns/addMilliseconds.d.cts generated vendored Normal file
View File

@@ -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;

24
frontend/style/node_modules/date-fns/addMilliseconds.d.mts generated vendored
View File

@@ -1,24 +0,0 @@
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of milliseconds to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

18
frontend/style/node_modules/date-fns/addMilliseconds.d.ts generated vendored
View File

@@ -1,3 +1,9 @@
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
@@ -7,9 +13,11 @@
* 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
*
@@ -18,7 +26,11 @@
* 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>(
date: DateType | number | string,
export declare function addMilliseconds<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddMillisecondsOptions<ResultDate> | undefined,
): ResultDate;

20
frontend/style/node_modules/date-fns/addMilliseconds.js generated vendored
View File

@@ -1,7 +1,9 @@
"use strict";
exports.addMilliseconds = addMilliseconds;
var _index = require("./toDate.js");
var _index2 = require("./constructFrom.js");
import { constructFrom } from "./constructFrom.js";
import { toDate } from "./toDate.js";
/**
* The {@link addMilliseconds} function options.
*/
/**
* @name addMilliseconds
@@ -12,9 +14,11 @@ var _index2 = require("./constructFrom.js");
* 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
*
@@ -23,7 +27,9 @@ var _index2 = require("./constructFrom.js");
* 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) {
const timestamp = +(0, _index.toDate)(date);
return (0, _index2.constructFrom)(date, timestamp + amount);
export function addMilliseconds(date, amount, options) {
return constructFrom(options?.in || date, +toDate(date) + amount);
}
// Fallback for modularized imports:
export default addMilliseconds;

30
frontend/style/node_modules/date-fns/addMilliseconds.mjs generated vendored
View File

@@ -1,30 +0,0 @@
import { toDate } from "./toDate.mjs";
import { constructFrom } from "./constructFrom.mjs";
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of milliseconds to be added.
*
* @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) {
const timestamp = +toDate(date);
return constructFrom(date, timestamp + amount);
}
// Fallback for modularized imports:
export default addMilliseconds;

36
frontend/style/node_modules/date-fns/addMinutes.cjs generated vendored Normal file
View File

@@ -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;
}

36
frontend/style/node_modules/date-fns/addMinutes.d.cts generated vendored Normal file
View File

@@ -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;

24
frontend/style/node_modules/date-fns/addMinutes.d.mts generated vendored
View File

@@ -1,24 +0,0 @@
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of minutes to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

18
frontend/style/node_modules/date-fns/addMinutes.d.ts generated vendored
View File

@@ -1,3 +1,9 @@
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
@@ -7,9 +13,11 @@
* 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
*
@@ -18,7 +26,11 @@
* 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>(
date: DateType | number | string,
export declare function addMinutes<
DateType extends Date,
ResultDate extends Date = DateType,
>(
date: DateArg<DateType>,
amount: number,
): DateType;
options?: AddMinutesOptions<ResultDate> | undefined,
): ResultDate;

24
frontend/style/node_modules/date-fns/addMinutes.js generated vendored
View File

@@ -1,7 +1,9 @@
"use strict";
exports.addMinutes = addMinutes;
var _index = require("./addMilliseconds.js");
var _index2 = require("./constants.js");
import { millisecondsInMinute } from "./constants.js";
import { toDate } from "./toDate.js";
/**
* The {@link addMinutes} function options.
*/
/**
* @name addMinutes
@@ -12,9 +14,11 @@ var _index2 = require("./constants.js");
* 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
*
@@ -23,9 +27,11 @@ var _index2 = require("./constants.js");
* const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
* //=> Thu Jul 10 2014 12:30:00
*/
function addMinutes(date, amount) {
return (0, _index.addMilliseconds)(
date,
amount * _index2.millisecondsInMinute,
);
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;

29
frontend/style/node_modules/date-fns/addMinutes.mjs generated vendored
View File

@@ -1,29 +0,0 @@
import { addMilliseconds } from "./addMilliseconds.mjs";
import { millisecondsInMinute } from "./constants.mjs";
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of minutes to be added.
*
* @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) {
return addMilliseconds(date, amount * millisecondsInMinute);
}
// Fallback for modularized imports:
export default addMinutes;

78
frontend/style/node_modules/date-fns/addMonths.cjs generated vendored Normal file
View File

@@ -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;
}
}

40
frontend/style/node_modules/date-fns/addMonths.d.cts generated vendored Normal file
View File

@@ -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;

28
frontend/style/node_modules/date-fns/addMonths.d.mts generated vendored
View File

@@ -1,28 +0,0 @@
/**
* @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).
*
* @param date - The date to be changed
* @param amount - The amount of months to be added.
*
* @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>(
date: DateType | number | string,
amount: number,
): DateType;

Some files were not shown because too many files have changed in this diff Show More