@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/esm/br-datetime-picker.entry.js

@@ -0,0 +1,1884 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { r as registerInstance, c as createEvent, h, F as Fragment, H as Host, g as getElement } from './index-C2RBydfd.js';
+import { r as requireParse, p as parseExports, i as isValidExports, t as toDateExports, w as warnInvalidPropValue, a as resolveSsrLocalDate, s as setExports, e as eachDayOfIntervalExports, b as isSameDayExports } from './isValid-DIUZX1qS.js';
+import { d as dispatchNativeFormEvent } from './event-DFN_so7I.js';
+import { r as resolveFormValidator, a as runFormValidator, g as getFormValidationState, c as setFormValidity, i as isFormControlDisabled } from './validator-D3tVP32U.js';
+import { a as hasAssignedSlotContent } from './slot-BIG-yees.js';
+import { r as requireIsValid, a as requireConstructFrom, b as requireToDate, c as requireConstants, D as DATETIME_PICKER_MODE, f as formatExports, d as DATETIME_PICKER_LOCALE } from './datetime-picker-constants-Bfm58jO6.js';
+
+var isMatch = {};
+
+var hasRequiredIsMatch;
+
+function requireIsMatch () {
+	if (hasRequiredIsMatch) return isMatch;
+	hasRequiredIsMatch = 1;
+	isMatch.isMatch = isMatch$1;
+	var _index = /*@__PURE__*/ requireIsValid();
+	var _index2 = /*@__PURE__*/ requireParse();
+
+	/**
+	 * The {@link isMatch} function options.
+	 */
+
+	/**
+	 * @name isMatch
+	 * @category Common Helpers
+	 * @summary validates the date string against given formats
+	 *
+	 * @description
+	 * Return the true if given date is string correct against the given format else
+	 * will return false.
+	 *
+	 * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
+	 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 *
+	 * The characters in the format string wrapped between two single quotes characters (') are escaped.
+	 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
+	 *
+	 * Format of the format string is based on Unicode Technical Standard #35:
+	 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+	 * with a few additions (see note 5 below the table).
+	 *
+	 * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited
+	 * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception:
+	 *
+	 * ```javascript
+	 * isMatch('23 AM', 'HH a')
+	 * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time
+	 * ```
+	 *
+	 * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true
+	 *
+	 * Accepted format string patterns:
+	 * | Unit                            |Prior| Pattern | Result examples                   | Notes |
+	 * |---------------------------------|-----|---------|-----------------------------------|-------|
+	 * | Era                             | 140 | G..GGG  | AD, BC                            |       |
+	 * |                                 |     | GGGG    | Anno Domini, Before Christ        | 2     |
+	 * |                                 |     | GGGGG   | A, B                              |       |
+	 * | Calendar year                   | 130 | y       | 44, 1, 1900, 2017, 9999           | 4     |
+	 * |                                 |     | yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
+	 * |                                 |     | yy      | 44, 01, 00, 17                    | 4     |
+	 * |                                 |     | yyy     | 044, 001, 123, 999                | 4     |
+	 * |                                 |     | yyyy    | 0044, 0001, 1900, 2017            | 4     |
+	 * |                                 |     | yyyyy   | ...                               | 2,4   |
+	 * | Local week-numbering year       | 130 | Y       | 44, 1, 1900, 2017, 9000           | 4     |
+	 * |                                 |     | Yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
+	 * |                                 |     | YY      | 44, 01, 00, 17                    | 4,6   |
+	 * |                                 |     | YYY     | 044, 001, 123, 999                | 4     |
+	 * |                                 |     | YYYY    | 0044, 0001, 1900, 2017            | 4,6   |
+	 * |                                 |     | YYYYY   | ...                               | 2,4   |
+	 * | ISO week-numbering year         | 130 | R       | -43, 1, 1900, 2017, 9999, -9999   | 4,5   |
+	 * |                                 |     | RR      | -43, 01, 00, 17                   | 4,5   |
+	 * |                                 |     | RRR     | -043, 001, 123, 999, -999         | 4,5   |
+	 * |                                 |     | RRRR    | -0043, 0001, 2017, 9999, -9999    | 4,5   |
+	 * |                                 |     | RRRRR   | ...                               | 2,4,5 |
+	 * | Extended year                   | 130 | u       | -43, 1, 1900, 2017, 9999, -999    | 4     |
+	 * |                                 |     | uu      | -43, 01, 99, -99                  | 4     |
+	 * |                                 |     | uuu     | -043, 001, 123, 999, -999         | 4     |
+	 * |                                 |     | uuuu    | -0043, 0001, 2017, 9999, -9999    | 4     |
+	 * |                                 |     | uuuuu   | ...                               | 2,4   |
+	 * | Quarter (formatting)            | 120 | Q       | 1, 2, 3, 4                        |       |
+	 * |                                 |     | Qo      | 1st, 2nd, 3rd, 4th                | 5     |
+	 * |                                 |     | QQ      | 01, 02, 03, 04                    |       |
+	 * |                                 |     | QQQ     | Q1, Q2, Q3, Q4                    |       |
+	 * |                                 |     | QQQQ    | 1st quarter, 2nd quarter, ...     | 2     |
+	 * |                                 |     | QQQQQ   | 1, 2, 3, 4                        | 4     |
+	 * | Quarter (stand-alone)           | 120 | q       | 1, 2, 3, 4                        |       |
+	 * |                                 |     | qo      | 1st, 2nd, 3rd, 4th                | 5     |
+	 * |                                 |     | qq      | 01, 02, 03, 04                    |       |
+	 * |                                 |     | qqq     | Q1, Q2, Q3, Q4                    |       |
+	 * |                                 |     | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
+	 * |                                 |     | qqqqq   | 1, 2, 3, 4                        | 3     |
+	 * | Month (formatting)              | 110 | M       | 1, 2, ..., 12                     |       |
+	 * |                                 |     | Mo      | 1st, 2nd, ..., 12th               | 5     |
+	 * |                                 |     | MM      | 01, 02, ..., 12                   |       |
+	 * |                                 |     | MMM     | Jan, Feb, ..., Dec                |       |
+	 * |                                 |     | MMMM    | January, February, ..., December  | 2     |
+	 * |                                 |     | MMMMM   | J, F, ..., D                      |       |
+	 * | Month (stand-alone)             | 110 | L       | 1, 2, ..., 12                     |       |
+	 * |                                 |     | Lo      | 1st, 2nd, ..., 12th               | 5     |
+	 * |                                 |     | LL      | 01, 02, ..., 12                   |       |
+	 * |                                 |     | LLL     | Jan, Feb, ..., Dec                |       |
+	 * |                                 |     | LLLL    | January, February, ..., December  | 2     |
+	 * |                                 |     | LLLLL   | J, F, ..., D                      |       |
+	 * | Local week of year              | 100 | w       | 1, 2, ..., 53                     |       |
+	 * |                                 |     | wo      | 1st, 2nd, ..., 53th               | 5     |
+	 * |                                 |     | ww      | 01, 02, ..., 53                   |       |
+	 * | ISO week of year                | 100 | I       | 1, 2, ..., 53                     | 5     |
+	 * |                                 |     | Io      | 1st, 2nd, ..., 53th               | 5     |
+	 * |                                 |     | II      | 01, 02, ..., 53                   | 5     |
+	 * | Day of month                    |  90 | d       | 1, 2, ..., 31                     |       |
+	 * |                                 |     | do      | 1st, 2nd, ..., 31st               | 5     |
+	 * |                                 |     | dd      | 01, 02, ..., 31                   |       |
+	 * | Day of year                     |  90 | D       | 1, 2, ..., 365, 366               | 7     |
+	 * |                                 |     | Do      | 1st, 2nd, ..., 365th, 366th       | 5     |
+	 * |                                 |     | DD      | 01, 02, ..., 365, 366             | 7     |
+	 * |                                 |     | DDD     | 001, 002, ..., 365, 366           |       |
+	 * |                                 |     | DDDD    | ...                               | 2     |
+	 * | Day of week (formatting)        |  90 | E..EEE  | Mon, Tue, Wed, ..., Su            |       |
+	 * |                                 |     | EEEE    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 |     | EEEEE   | M, T, W, T, F, S, S               |       |
+	 * |                                 |     | EEEEEE  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | ISO day of week (formatting)    |  90 | i       | 1, 2, 3, ..., 7                   | 5     |
+	 * |                                 |     | io      | 1st, 2nd, ..., 7th                | 5     |
+	 * |                                 |     | ii      | 01, 02, ..., 07                   | 5     |
+	 * |                                 |     | iii     | Mon, Tue, Wed, ..., Su            | 5     |
+	 * |                                 |     | iiii    | Monday, Tuesday, ..., Sunday      | 2,5   |
+	 * |                                 |     | iiiii   | M, T, W, T, F, S, S               | 5     |
+	 * |                                 |     | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 5     |
+	 * | Local day of week (formatting)  |  90 | e       | 2, 3, 4, ..., 1                   |       |
+	 * |                                 |     | eo      | 2nd, 3rd, ..., 1st                | 5     |
+	 * |                                 |     | ee      | 02, 03, ..., 01                   |       |
+	 * |                                 |     | eee     | Mon, Tue, Wed, ..., Su            |       |
+	 * |                                 |     | eeee    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 |     | eeeee   | M, T, W, T, F, S, S               |       |
+	 * |                                 |     | eeeeee  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | Local day of week (stand-alone) |  90 | c       | 2, 3, 4, ..., 1                   |       |
+	 * |                                 |     | co      | 2nd, 3rd, ..., 1st                | 5     |
+	 * |                                 |     | cc      | 02, 03, ..., 01                   |       |
+	 * |                                 |     | ccc     | Mon, Tue, Wed, ..., Su            |       |
+	 * |                                 |     | cccc    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 |     | ccccc   | M, T, W, T, F, S, S               |       |
+	 * |                                 |     | cccccc  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | AM, PM                          |  80 | a..aaa  | AM, PM                            |       |
+	 * |                                 |     | aaaa    | a.m., p.m.                        | 2     |
+	 * |                                 |     | aaaaa   | a, p                              |       |
+	 * | AM, PM, noon, midnight          |  80 | b..bbb  | AM, PM, noon, midnight            |       |
+	 * |                                 |     | bbbb    | a.m., p.m., noon, midnight        | 2     |
+	 * |                                 |     | bbbbb   | a, p, n, mi                       |       |
+	 * | Flexible day period             |  80 | B..BBB  | at night, in the morning, ...     |       |
+	 * |                                 |     | BBBB    | at night, in the morning, ...     | 2     |
+	 * |                                 |     | BBBBB   | at night, in the morning, ...     |       |
+	 * | Hour [1-12]                     |  70 | h       | 1, 2, ..., 11, 12                 |       |
+	 * |                                 |     | ho      | 1st, 2nd, ..., 11th, 12th         | 5     |
+	 * |                                 |     | hh      | 01, 02, ..., 11, 12               |       |
+	 * | Hour [0-23]                     |  70 | H       | 0, 1, 2, ..., 23                  |       |
+	 * |                                 |     | Ho      | 0th, 1st, 2nd, ..., 23rd          | 5     |
+	 * |                                 |     | HH      | 00, 01, 02, ..., 23               |       |
+	 * | Hour [0-11]                     |  70 | K       | 1, 2, ..., 11, 0                  |       |
+	 * |                                 |     | Ko      | 1st, 2nd, ..., 11th, 0th          | 5     |
+	 * |                                 |     | KK      | 01, 02, ..., 11, 00               |       |
+	 * | Hour [1-24]                     |  70 | k       | 24, 1, 2, ..., 23                 |       |
+	 * |                                 |     | ko      | 24th, 1st, 2nd, ..., 23rd         | 5     |
+	 * |                                 |     | kk      | 24, 01, 02, ..., 23               |       |
+	 * | Minute                          |  60 | m       | 0, 1, ..., 59                     |       |
+	 * |                                 |     | mo      | 0th, 1st, ..., 59th               | 5     |
+	 * |                                 |     | mm      | 00, 01, ..., 59                   |       |
+	 * | Second                          |  50 | s       | 0, 1, ..., 59                     |       |
+	 * |                                 |     | so      | 0th, 1st, ..., 59th               | 5     |
+	 * |                                 |     | ss      | 00, 01, ..., 59                   |       |
+	 * | Seconds timestamp               |  40 | t       | 512969520                         |       |
+	 * |                                 |     | tt      | ...                               | 2     |
+	 * | Fraction of second              |  30 | S       | 0, 1, ..., 9                      |       |
+	 * |                                 |     | SS      | 00, 01, ..., 99                   |       |
+	 * |                                 |     | SSS     | 000, 001, ..., 999                |       |
+	 * |                                 |     | SSSS    | ...                               | 2     |
+	 * | Milliseconds timestamp          |  20 | T       | 512969520900                      |       |
+	 * |                                 |     | TT      | ...                               | 2     |
+	 * | Timezone (ISO-8601 w/ Z)        |  10 | X       | -08, +0530, Z                     |       |
+	 * |                                 |     | XX      | -0800, +0530, Z                   |       |
+	 * |                                 |     | XXX     | -08:00, +05:30, Z                 |       |
+	 * |                                 |     | XXXX    | -0800, +0530, Z, +123456          | 2     |
+	 * |                                 |     | XXXXX   | -08:00, +05:30, Z, +12:34:56      |       |
+	 * | Timezone (ISO-8601 w/o Z)       |  10 | x       | -08, +0530, +00                   |       |
+	 * |                                 |     | xx      | -0800, +0530, +0000               |       |
+	 * |                                 |     | xxx     | -08:00, +05:30, +00:00            | 2     |
+	 * |                                 |     | xxxx    | -0800, +0530, +0000, +123456      |       |
+	 * |                                 |     | xxxxx   | -08:00, +05:30, +00:00, +12:34:56 |       |
+	 * | Long localized date             |  NA | P       | 05/29/1453                        | 5,8   |
+	 * |                                 |     | PP      | May 29, 1453                      |       |
+	 * |                                 |     | PPP     | May 29th, 1453                    |       |
+	 * |                                 |     | PPPP    | Sunday, May 29th, 1453            | 2,5,8 |
+	 * | Long localized time             |  NA | p       | 12:00 AM                          | 5,8   |
+	 * |                                 |     | pp      | 12:00:00 AM                       |       |
+	 * | Combination of date and time    |  NA | Pp      | 05/29/1453, 12:00 AM              |       |
+	 * |                                 |     | PPpp    | May 29, 1453, 12:00:00 AM         |       |
+	 * |                                 |     | PPPpp   | May 29th, 1453 at ...             |       |
+	 * |                                 |     | PPPPpp  | Sunday, May 29th, 1453 at ...     | 2,5,8 |
+	 * Notes:
+	 * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
+	 *    are the same as "stand-alone" units, but are different in some languages.
+	 *    "Formatting" units are declined according to the rules of the language
+	 *    in the context of a date. "Stand-alone" units are always nominative singular.
+	 *    In `format` function, they will produce different result:
+	 *
+	 *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
+	 *
+	 *    `isMatch` will try to match both formatting and stand-alone units interchangeably.
+	 *
+	 * 2. Any sequence of the identical letters is a pattern, unless it is escaped by
+	 *    the single quote characters (see below).
+	 *    If the sequence is longer than listed in table:
+	 *    - for numerical units (`yyyyyyyy`) `isMatch` will try to match a number
+	 *      as wide as the sequence
+	 *    - for text units (`MMMMMMMM`) `isMatch` will try to match the widest variation of the unit.
+	 *      These variations are marked with "2" in the last column of the table.
+	 *
+	 * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
+	 *    These tokens represent the shortest form of the quarter.
+	 *
+	 * 4. The main difference between `y` and `u` patterns are B.C. years:
+	 *
+	 *    | Year | `y` | `u` |
+	 *    |------|-----|-----|
+	 *    | AC 1 |   1 |   1 |
+	 *    | BC 1 |   1 |   0 |
+	 *    | BC 2 |   2 |  -1 |
+	 *
+	 *    Also `yy` will try to guess the century of two digit year by proximity with `referenceDate`:
+	 *
+	 *    `isMatch('50', 'yy') //=> true`
+	 *
+	 *    `isMatch('75', 'yy') //=> true`
+	 *
+	 *    while `uu` will use the year as is:
+	 *
+	 *    `isMatch('50', 'uu') //=> true`
+	 *
+	 *    `isMatch('75', 'uu') //=> true`
+	 *
+	 *    The same difference is true for local and ISO week-numbering years (`Y` and `R`),
+	 *    except local week-numbering years are dependent on `options.weekStartsOn`
+	 *    and `options.firstWeekContainsDate` (compare [setISOWeekYear](https://date-fns.org/docs/setISOWeekYear)
+	 *    and [setWeekYear](https://date-fns.org/docs/setWeekYear)).
+	 *
+	 * 5. These patterns are not in the Unicode Technical Standard #35:
+	 *    - `i`: ISO day of week
+	 *    - `I`: ISO week of year
+	 *    - `R`: ISO week-numbering year
+	 *    - `o`: ordinal number modifier
+	 *    - `P`: long localized date
+	 *    - `p`: long localized time
+	 *
+	 * 6. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
+	 *    You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 *
+	 * 7. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
+	 *    You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 *
+	 * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based
+	 *    on the given locale.
+	 *
+	 *    using `en-US` locale: `P` => `MM/dd/yyyy`
+	 *    using `en-US` locale: `p` => `hh:mm a`
+	 *    using `pt-BR` locale: `P` => `dd/MM/yyyy`
+	 *    using `pt-BR` locale: `p` => `HH:mm`
+	 *
+	 * Values will be checked in the descending order of its unit's priority.
+	 * Units of an equal priority overwrite each other in the order of appearance.
+	 *
+	 * If no values of higher priority are matched (e.g. when matching string 'January 1st' without a year),
+	 * the values will be taken from today's using `new Date()` date which works as a context of parsing.
+	 *
+	 * The result may vary by locale.
+	 *
+	 * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned.
+	 *
+	 * @param dateStr - The date string to verify
+	 * @param format - The string of tokens
+	 * @param options - An object with options.
+	 *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 *
+	 * @returns Is format string a match for date string?
+	 *
+	 * @throws `options.locale` must contain `match` property
+	 * @throws use `yyyy` instead of `YYYY` for formatting years; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 * @throws use `yy` instead of `YY` for formatting years; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 * @throws use `d` instead of `D` for formatting days of the month; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 * @throws use `dd` instead of `DD` for formatting days of the month; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+	 * @throws format string contains an unescaped latin alphabet character
+	 *
+	 * @example
+	 * // Match 11 February 2014 from middle-endian format:
+	 * const result = isMatch('02/11/2014', 'MM/dd/yyyy')
+	 * //=> true
+	 *
+	 * @example
+	 * // Match 28th of February in Esperanto locale in the context of 2010 year:
+	 * import eo from 'date-fns/locale/eo'
+	 * const result = isMatch('28-a de februaro', "do 'de' MMMM", {
+	 *   locale: eo
+	 * })
+	 * //=> true
+	 */
+	function isMatch$1(dateStr, formatStr, options) {
+	  return (0, _index.isValid)(
+	    (0, _index2.parse)(dateStr, formatStr, new Date(), options),
+	  );
+	}
+	return isMatch;
+}
+
+var isMatchExports = /*@__PURE__*/ requireIsMatch();
+
+var parseISO = {};
+
+var hasRequiredParseISO;
+
+function requireParseISO () {
+	if (hasRequiredParseISO) return parseISO;
+	hasRequiredParseISO = 1;
+	parseISO.parseISO = parseISO$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link parseISO} function options.
+	 */
+
+	/**
+	 * @name parseISO
+	 * @category Common Helpers
+	 * @summary Parse ISO string
+	 *
+	 * @description
+	 * Parse the given string in ISO 8601 format and return an instance of Date.
+	 *
+	 * Function accepts complete ISO 8601 formats as well as partial implementations.
+	 * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+	 *
+	 * If the argument isn't a string, the function cannot parse the string or
+	 * the values are invalid, it returns Invalid 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 argument - The value to convert
+	 * @param options - An object with options
+	 *
+	 * @returns The parsed date in the local time zone
+	 *
+	 * @example
+	 * // Convert string '2014-02-11T11:30:30' to date:
+	 * const result = parseISO('2014-02-11T11:30:30')
+	 * //=> Tue Feb 11 2014 11:30:30
+	 *
+	 * @example
+	 * // Convert string '+02014101' to date,
+	 * // if the additional number of digits in the extended year format is 1:
+	 * const result = parseISO('+02014101', { additionalDigits: 1 })
+	 * //=> Fri Apr 11 2014 00:00:00
+	 */
+	function parseISO$1(argument, options) {
+	  const invalidDate = () => (0, _index2.constructFrom)(options?.in, NaN);
+
+	  const additionalDigits = options?.additionalDigits ?? 2;
+	  const dateStrings = splitDateString(argument);
+
+	  let date;
+	  if (dateStrings.date) {
+	    const parseYearResult = parseYear(dateStrings.date, additionalDigits);
+	    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+	  }
+
+	  if (!date || isNaN(+date)) return invalidDate();
+
+	  const timestamp = +date;
+	  let time = 0;
+	  let offset;
+
+	  if (dateStrings.time) {
+	    time = parseTime(dateStrings.time);
+	    if (isNaN(time)) return invalidDate();
+	  }
+
+	  if (dateStrings.timezone) {
+	    offset = parseTimezone(dateStrings.timezone);
+	    if (isNaN(offset)) return invalidDate();
+	  } else {
+	    const tmpDate = new Date(timestamp + time);
+	    const result = (0, _index3.toDate)(0, options?.in);
+	    result.setFullYear(
+	      tmpDate.getUTCFullYear(),
+	      tmpDate.getUTCMonth(),
+	      tmpDate.getUTCDate(),
+	    );
+	    result.setHours(
+	      tmpDate.getUTCHours(),
+	      tmpDate.getUTCMinutes(),
+	      tmpDate.getUTCSeconds(),
+	      tmpDate.getUTCMilliseconds(),
+	    );
+	    return result;
+	  }
+
+	  return (0, _index3.toDate)(timestamp + time + offset, options?.in);
+	}
+
+	const patterns = {
+	  dateTimeDelimiter: /[T ]/,
+	  timeZoneDelimiter: /[Z ]/i,
+	  timezone: /([Z+-].*)$/,
+	};
+
+	const dateRegex =
+	  /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+	const timeRegex =
+	  /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+	const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+
+	function splitDateString(dateString) {
+	  const dateStrings = {};
+	  const array = dateString.split(patterns.dateTimeDelimiter);
+	  let timeString;
+
+	  // The regex match should only return at maximum two array elements.
+	  // [date], [time], or [date, time].
+	  if (array.length > 2) {
+	    return dateStrings;
+	  }
+
+	  if (/:/.test(array[0])) {
+	    timeString = array[0];
+	  } else {
+	    dateStrings.date = array[0];
+	    timeString = array[1];
+	    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+	      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+	      timeString = dateString.substr(
+	        dateStrings.date.length,
+	        dateString.length,
+	      );
+	    }
+	  }
+
+	  if (timeString) {
+	    const token = patterns.timezone.exec(timeString);
+	    if (token) {
+	      dateStrings.time = timeString.replace(token[1], "");
+	      dateStrings.timezone = token[1];
+	    } else {
+	      dateStrings.time = timeString;
+	    }
+	  }
+
+	  return dateStrings;
+	}
+
+	function parseYear(dateString, additionalDigits) {
+	  const regex = new RegExp(
+	    "^(?:(\\d{4}|[+-]\\d{" +
+	      (4 + additionalDigits) +
+	      "})|(\\d{2}|[+-]\\d{" +
+	      (2 + additionalDigits) +
+	      "})$)",
+	  );
+
+	  const captures = dateString.match(regex);
+	  // Invalid ISO-formatted year
+	  if (!captures) return { year: NaN, restDateString: "" };
+
+	  const year = captures[1] ? parseInt(captures[1]) : null;
+	  const century = captures[2] ? parseInt(captures[2]) : null;
+
+	  // either year or century is null, not both
+	  return {
+	    year: century === null ? year : century * 100,
+	    restDateString: dateString.slice((captures[1] || captures[2]).length),
+	  };
+	}
+
+	function parseDate(dateString, year) {
+	  // Invalid ISO-formatted year
+	  if (year === null) return new Date(NaN);
+
+	  const captures = dateString.match(dateRegex);
+	  // Invalid ISO-formatted string
+	  if (!captures) return new Date(NaN);
+
+	  const isWeekDate = !!captures[4];
+	  const dayOfYear = parseDateUnit(captures[1]);
+	  const month = parseDateUnit(captures[2]) - 1;
+	  const day = parseDateUnit(captures[3]);
+	  const week = parseDateUnit(captures[4]);
+	  const dayOfWeek = parseDateUnit(captures[5]) - 1;
+
+	  if (isWeekDate) {
+	    if (!validateWeekDate(year, week, dayOfWeek)) {
+	      return new Date(NaN);
+	    }
+	    return dayOfISOWeekYear(year, week, dayOfWeek);
+	  } else {
+	    const date = new Date(0);
+	    if (
+	      !validateDate(year, month, day) ||
+	      !validateDayOfYearDate(year, dayOfYear)
+	    ) {
+	      return new Date(NaN);
+	    }
+	    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+	    return date;
+	  }
+	}
+
+	function parseDateUnit(value) {
+	  return value ? parseInt(value) : 1;
+	}
+
+	function parseTime(timeString) {
+	  const captures = timeString.match(timeRegex);
+	  if (!captures) return NaN; // Invalid ISO-formatted time
+
+	  const hours = parseTimeUnit(captures[1]);
+	  const minutes = parseTimeUnit(captures[2]);
+	  const seconds = parseTimeUnit(captures[3]);
+
+	  if (!validateTime(hours, minutes, seconds)) {
+	    return NaN;
+	  }
+
+	  return (
+	    hours * _index.millisecondsInHour +
+	    minutes * _index.millisecondsInMinute +
+	    seconds * 1000
+	  );
+	}
+
+	function parseTimeUnit(value) {
+	  return (value && parseFloat(value.replace(",", "."))) || 0;
+	}
+
+	function parseTimezone(timezoneString) {
+	  if (timezoneString === "Z") return 0;
+
+	  const captures = timezoneString.match(timezoneRegex);
+	  if (!captures) return 0;
+
+	  const sign = captures[1] === "+" ? -1 : 1;
+	  const hours = parseInt(captures[2]);
+	  const minutes = (captures[3] && parseInt(captures[3])) || 0;
+
+	  if (!validateTimezone(hours, minutes)) {
+	    return NaN;
+	  }
+
+	  return (
+	    sign *
+	    (hours * _index.millisecondsInHour + minutes * _index.millisecondsInMinute)
+	  );
+	}
+
+	function dayOfISOWeekYear(isoWeekYear, week, day) {
+	  const date = new Date(0);
+	  date.setUTCFullYear(isoWeekYear, 0, 4);
+	  const fourthOfJanuaryDay = date.getUTCDay() || 7;
+	  const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+	  date.setUTCDate(date.getUTCDate() + diff);
+	  return date;
+	}
+
+	// Validation functions
+
+	// February is null to handle the leap year (using ||)
+	const daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+	function isLeapYearIndex(year) {
+	  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+	}
+
+	function validateDate(year, month, date) {
+	  return (
+	    month >= 0 &&
+	    month <= 11 &&
+	    date >= 1 &&
+	    date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28))
+	  );
+	}
+
+	function validateDayOfYearDate(year, dayOfYear) {
+	  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+	}
+
+	function validateWeekDate(_year, week, day) {
+	  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+	}
+
+	function validateTime(hours, minutes, seconds) {
+	  if (hours === 24) {
+	    return minutes === 0 && seconds === 0;
+	  }
+
+	  return (
+	    seconds >= 0 &&
+	    seconds < 60 &&
+	    minutes >= 0 &&
+	    minutes < 60 &&
+	    hours >= 0 &&
+	    hours < 25
+	  );
+	}
+
+	function validateTimezone(_hours, minutes) {
+	  return minutes >= 0 && minutes <= 59;
+	}
+	return parseISO;
+}
+
+var parseISOExports = /*@__PURE__*/ requireParseISO();
+
+/** Serializa o valor atual para envio em FormData conforme o modo ativo. */
+function serializeDatetimePickerFormValue(value, context) {
+    if (isDateRangeMode(context)) {
+        return serializeRangeFormValue(context.rangeStart, context.rangeEnd);
+    }
+    if (value === null) {
+        return null;
+    }
+    switch (context.mode) {
+        case DATETIME_PICKER_MODE.DATE:
+            return serializeDate(value);
+        case DATETIME_PICKER_MODE.TIME:
+            return formatExports.format(value, 'HH:mm');
+        default:
+            // Para submissão em formulários, no modo datetime retornamos a ISO completa
+            // incluindo o deslocamento de fuso local em vez de UTC (Z).
+            return formatExports.format(value, "yyyy-MM-dd'T'HH:mm:ssXXX");
+    }
+}
+/** Analisa um valor serializado de formulário para Date respeitando o modo atual. */
+function parseDatetimePickerSerializedValue(value, mode, referenceDate) {
+    if (isBlankValue(value)) {
+        return null;
+    }
+    switch (mode) {
+        case DATETIME_PICKER_MODE.DATE:
+            return parseDate(value);
+        case DATETIME_PICKER_MODE.TIME:
+            return parseTimeValue(value, referenceDate);
+        default:
+            return parseIsoDate(value);
+    }
+}
+/** Analisa intervalo serializado no formato YYYY-MM-DD/YYYY-MM-DD. */
+function parseDatetimePickerSerializedRange(value) {
+    const [startRaw, endRaw] = value.split('/');
+    if (startRaw === undefined || endRaw === undefined) {
+        return null;
+    }
+    const start = parseDate(startRaw);
+    const end = parseDate(endRaw);
+    if (start === null || end === null) {
+        return null;
+    }
+    return { start, end };
+}
+/** Informa se o componente deve sinalizar valueMissing na validação nativa. */
+function hasDatetimePickerMissingValue(context) {
+    const { required, disabled, value } = context;
+    if (!required || disabled) {
+        return false;
+    }
+    const isRangeIncomplete = isDateRangeMode(context) && (context.rangeStart === null || context.rangeEnd === null);
+    return value === null || isRangeIncomplete;
+}
+function isBlankValue(value) {
+    return value.trim() === '';
+}
+function isDateRangeMode(context) {
+    return context.selectionMode === 'range' && context.mode === DATETIME_PICKER_MODE.DATE;
+}
+function serializeRangeFormValue(rangeStart, rangeEnd) {
+    if (rangeStart === null || rangeEnd === null) {
+        return null;
+    }
+    return `${serializeDate(rangeStart)}/${serializeDate(rangeEnd)}`;
+}
+function parseTimeValue(value, referenceDate) {
+    if (!isMatchExports.isMatch(value, 'HH:mm')) {
+        return null;
+    }
+    const parsedTime = parseExports.parse(value, 'HH:mm', new Date());
+    if (!isValidExports.isValid(parsedTime)) {
+        return null;
+    }
+    const baseDate = toDateExports.toDate(referenceDate);
+    baseDate.setHours(parsedTime.getHours(), parsedTime.getMinutes(), 0, 0);
+    return baseDate;
+}
+function parseIsoDate(value) {
+    const parsedDate = parseISOExports.parseISO(value);
+    return isValidExports.isValid(parsedDate) ? parsedDate : null;
+}
+function parseDate(value) {
+    if (!isMatchExports.isMatch(value, 'yyyy-MM-dd')) {
+        return null;
+    }
+    const parsedDate = parseExports.parse(value, 'yyyy-MM-dd', new Date());
+    if (!isValidExports.isValid(parsedDate)) {
+        return null;
+    }
+    // Garante aderência estrita ao formato/calendário evitando rollover silencioso.
+    if (formatExports.format(parsedDate, 'yyyy-MM-dd') !== value) {
+        return null;
+    }
+    parsedDate.setHours(0, 0, 0, 0);
+    return parsedDate;
+}
+function serializeDate(value) {
+    return formatExports.format(value, 'yyyy-MM-dd');
+}
+
+const VALID_WEEK_START_DAYS = [0, 1, 2, 3, 4, 5, 6];
+const INITIAL_MOMENT_DATE_FORMATS = ['dd/MM/yyyy HH:mm', 'dd/MM/yyyy', 'yyyy-MM-dd HH:mm', 'yyyy-MM-dd'];
+function parseInitialMomentString(value) {
+    const trimmedValue = value.trim();
+    if (trimmedValue === '') {
+        return null;
+    }
+    const isoDate = parseISOExports.parseISO(trimmedValue);
+    if (isValidExports.isValid(isoDate)) {
+        return isoDate;
+    }
+    for (const formatPattern of INITIAL_MOMENT_DATE_FORMATS) {
+        const parsedDate = parseExports.parse(trimmedValue, formatPattern, new Date());
+        if (isValidExports.isValid(parsedDate)) {
+            return parsedDate;
+        }
+    }
+    return null;
+}
+function normalizeDateCandidate(value) {
+    if (value instanceof Date) {
+        if (!Number.isNaN(value.getTime())) {
+            return new Date(value);
+        }
+        return null;
+    }
+    if (typeof value === 'string') {
+        return parseInitialMomentString(value);
+    }
+    return null;
+}
+function tokenizeDisabledDatesString(value) {
+    return value
+        .trim()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+}
+/**
+ * Verifica se o valor informado corresponde a um modo suportado pelo componente.
+ *
+ * @param value - Valor recebido via prop ou atributo.
+ * @returns `true` quando o valor pertence ao conjunto aceito de modos.
+ */
+function isValidDatetimePickerMode(value) {
+    return Object.values(DATETIME_PICKER_MODE).includes(value);
+}
+/**
+ * Normaliza o modo informado e aplica o valor padrão quando necessário.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns O modo válido correspondente, ou o valor padrão quando o input for inválido.
+ */
+function normalizeDatetimePickerMode(value) {
+    if (isValidDatetimePickerMode(value))
+        return value;
+    warnInvalidPropValue('br-datetime-picker', 'mode', value, DATETIME_PICKER_MODE.DEFAULT);
+    return DATETIME_PICKER_MODE.DEFAULT;
+}
+/**
+ * Verifica se o valor representa um modo de seleção suportado.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `true` quando o valor é `'single'` ou `'range'`.
+ */
+function isValidDatetimePickerSelectionMode(value) {
+    return value === 'single' || value === 'range';
+}
+/**
+ * Normaliza o modo de seleção informado e aplica o valor padrão quando necessário.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns O modo de seleção válido correspondente, ou `'single'` quando o input for inválido.
+ */
+function normalizeDatetimePickerSelectionMode(value) {
+    if (isValidDatetimePickerSelectionMode(value))
+        return value;
+    warnInvalidPropValue('br-datetime-picker', 'selectionMode', value, 'single');
+    return 'single';
+}
+/**
+ * Normaliza a seleção inicial para um valor aplicável pelo componente.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `'now'`, `Date` normalizada ou `null` quando inválido.
+ */
+function normalizeDatetimePickerInitialMoment(value) {
+    if (value === null)
+        return null;
+    if (value === 'now')
+        return 'now';
+    const normalizedDate = normalizeDateCandidate(value);
+    if (normalizedDate !== null) {
+        return normalizedDate;
+    }
+    warnInvalidPropValue('br-datetime-picker', 'initialMoment', value, 'null');
+    return null;
+}
+/**
+ * Normaliza a lista de datas desabilitadas para uma coleção de `Date` válidas.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns Lista normalizada de datas; retorna array vazio quando inválido.
+ */
+function normalizeDatetimePickerDisabledDates(value) {
+    if (value === null) {
+        return [];
+    }
+    if (typeof value === 'string') {
+        const tokens = tokenizeDisabledDatesString(value);
+        if (tokens.length === 0) {
+            warnInvalidPropValue('br-datetime-picker', 'disabledDates', value, '[]');
+            return [];
+        }
+        const normalizedDates = tokens
+            .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+            .filter((dateCandidate) => dateCandidate !== null);
+        if (normalizedDates.length !== tokens.length) {
+            warnInvalidPropValue('br-datetime-picker', 'disabledDates', value, '[]');
+        }
+        return normalizedDates;
+    }
+    if (!Array.isArray(value)) {
+        warnInvalidPropValue('br-datetime-picker', 'disabledDates', value, '[]');
+        return [];
+    }
+    const normalizedDates = value
+        .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+        .filter((dateCandidate) => dateCandidate !== null);
+    if (normalizedDates.length !== value.length) {
+        warnInvalidPropValue('br-datetime-picker', 'disabledDates', value, '[]');
+    }
+    return normalizedDates;
+}
+/**
+ * Verifica se o valor informado representa um índice válido de início da semana.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `true` quando o valor está entre `0` e `6`.
+ */
+function isValidDatetimePickerWeekStartsOn(value) {
+    return VALID_WEEK_START_DAYS.includes(value);
+}
+/**
+ * Normaliza o índice de início da semana e aplica `0` quando o valor é inválido.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns Índice normalizado para o primeiro dia da semana.
+ */
+function normalizeDatetimePickerWeekStartsOn(value) {
+    const numericValue = typeof value === 'string' ? Number(value) : value;
+    if (typeof numericValue === 'number' &&
+        Number.isInteger(numericValue) &&
+        isValidDatetimePickerWeekStartsOn(numericValue)) {
+        return numericValue;
+    }
+    warnInvalidPropValue('br-datetime-picker', 'weekStartsOn', String(value), '0');
+    return 0;
+}
+
+const datetimePickerCss = () => `*,*::before,*::after{box-sizing:border-box}:host{line-height:var(--font-line-height-medium);-webkit-text-size-adjust:100%;-moz-text-size-adjust:100%;text-size-adjust:100%}main{display:block}hr{box-sizing:content-box;height:0;overflow:visible}a{background-color:rgba(0,0,0,0)}b,strong{font-weight:bolder}code{font-family:monospace;font-size:1em}small{font-size:80%}img{border-style:none}button,input,select,textarea{font-family:inherit;font-size:100%;line-height:var(--font-line-height-medium);margin:0}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{appearance:none}::-webkit-file-upload-button{appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none}.d-none{display:none !important}@media (min-width: 576px){.d-sm-block{display:block !important}.d-sm-flex{display:flex !important}}[data-toggle=dropdown]+*{position:absolute}.dropdown{position:relative}.dropdown [data-toggle=dropdown]+*{box-shadow:var(--surface-shadow-sm);left:0;position:absolute;top:100%}.dropdown>.br-notification{left:auto;right:0}.dropdown .br-item{--color:var(--color-light);--color-rgb:var(--color-light-rgb);--text-color:var(--color-light);--interactive:var(--interactive-light);--interactive-rgb:var(--color-rgb);--visited:var(--visited-light);--hover:var(--hover-light);--pressed:var(--pressed-light);--focus-color:var(--focus-color-light);--focus:var(--focus-color-light);--item-padding-y:var(--spacing-scale-2x);background-color:var(--background-light);color:var(--color)}.dropdown .br-item:not(:last-child){border-bottom:1px solid var(--border-color)}.dropdown .br-item.selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}.justify-content-start{justify-content:flex-start !important}.justify-content-end{justify-content:flex-end !important}.justify-content-center{justify-content:center !important}.align-items-center{align-items:center !important}.col,[class*=col-]{padding-left:calc(var(--grid-gutter)*.5);padding-right:calc(var(--grid-gutter)*.5);width:100%}.col{flex:1 0 0%;min-width:8.3333333333%}.col-auto{flex:0 0 auto;width:auto}.col-2{flex-basis:16.6666666667%;max-width:16.6666666667%}.container,.container-fluid,.container-lg{--grid-margin:var(--grid-portrait-margin);--grid-maxwidth:var(--grid-portrait-maxwidth);margin-left:auto;margin-right:auto;max-width:var(--grid-maxwidth);padding-left:var(--grid-margin);padding-right:var(--grid-margin);width:100%}.row{--grid-gutter:var(--grid-portrait-gutter);display:flex;flex-wrap:wrap;margin-left:calc(var(--grid-gutter)*-0.5);margin-right:calc(var(--grid-gutter)*-0.5)}@media (min-width: 576px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-sm) - var(--grid-tablet-margin))}}@media (min-width: 992px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tablet-margin)}.row{--grid-gutter:var(--grid-tablet-gutter)}.container{--grid-maxwidth:calc(var(--grid-breakpoint-md) - var(--grid-tablet-margin))}}@media (min-width: 1280px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-desktop-margin)}.row{--grid-gutter:var(--grid-desktop-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-lg) - var(--grid-desktop-margin))}}@media (min-width: 1600px){.container,.container-lg,.container-fluid{--grid-margin:var(--grid-tv-margin)}.row{--grid-gutter:var(--grid-tv-gutter)}.container,.container-lg{--grid-maxwidth:calc(var(--grid-breakpoint-xl) - var(--grid-tv-margin))}}.ease{animation-timing-function:cubic-bezier(0.25, 0.1, 0.25, 1)}.ease-in-out{animation-timing-function:cubic-bezier(0.42, 0, 0.58, 1)}.mt-1{margin-top:var(--spacing-scale-half) !important}.mr-1{margin-right:var(--spacing-scale-half) !important}.mb-1{margin-bottom:var(--spacing-scale-half) !important}.ml-1{margin-left:var(--spacing-scale-half) !important}.mx-3{margin-left:var(--spacing-scale-2x) !important;margin-right:var(--spacing-scale-2x) !important}.mb-4{margin-bottom:var(--spacing-scale-3x) !important}.ml-auto{margin-left:auto !important}.pt-half{padding-top:var(--spacing-scale-half) !important}@media (min-width: 576px){.ml-sm-0{margin-left:var(--spacing-scale-default) !important}}.highlight{background:var(--status-highlight-background) linear-gradient(var(--status-highlight-overlay), var(--status-highlight-overlay));color:var(--status-highlight-text);padding:0 var(--spacing-scale-half)}[disabled],.disabled{cursor:not-allowed;opacity:var(--disabled)}[disabled] *,.disabled *{pointer-events:none}.text-center{text-align:center !important}.text-right{text-align:right !important}.text-nowrap{white-space:nowrap !important}.text-uppercase{text-transform:uppercase !important}.text-bold{font-weight:700 !important}.text-base{font-size:var(--font-size-scale-base) !important}.text-down-01{font-size:var(--font-size-scale-down-01) !important}@media (min-width: 576px){.text-sm-center{text-align:center !important}.text-sm-left{text-align:left !important}.text-sm-right{text-align:right !important}}p{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-2x);margin-top:0}p a{text-decoration:underline}@media (min-width: 576px){p{font-size:var(--font-size-scale-up-01)}}a{--focus-offset:var(--spacing-scale-half)}a:focus{outline:none}a.focus-visible,a:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}a:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}a:not(:disabled):active{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--pressed)), rgba(var(--interactive-rgb), var(--pressed)))}a{color:var(--interactive);text-decoration:none}.main-content a{text-decoration:underline}button{cursor:pointer}img{max-width:100%;vertical-align:middle}h2,.h2{color:var(--color);font-size:var(--font-size-scale-up-03);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2xh);margin-top:var(--spacing-scale-3xh);padding-bottom:var(--spacing-scale-2xh)}@media (min-width: 576px){.h2,h2{font-size:var(--font-size-scale-up-05);font-weight:var(--font-weight-regular)}}ul,ol{margin-bottom:var(--spacing-scale-2x);margin-top:0;padding:0 0 0 var(--spacing-scale-5x)}table{--table-background:var(--background);--table-color:var(--color);--table-border-color:var(--gray-20);--table-border-style:solid;--table-border-width:1px;--table-hover:var(--color-rgb);--table-padding:var(--spacing-scale-3x);--table-font-weight:var(--font-weight-medium);--table-th-background:var(--background-alternative);--table-th-font-weight:var(--font-weight-semi-bold);--table-row-size:var(--spacing-scale-2x);border-collapse:collapse;width:100%}tr.selected,tr.is-selected{--color:var(--color-dark);--color-rgb:var(--color-dark-rgb);--text-color:var(--color-dark);--interactive:var(--interactive-dark);--interactive-rgb:var(--interactive-dark-rgb);--visited:var(--visited-dark);--hover:var(--hover-dark);--pressed:var(--pressed-dark);--focus-color:var(--focus-color-dark);--focus:var(--focus-color-dark)}label,.label{color:var(--color);font-size:var(--font-size-scale-base);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half)}fieldset,.fieldset{border:var(--surface-width-none);margin-bottom:var(--spacing-scale-5x);margin-top:0;padding:0}legend,.legend{color:var(--color);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-semi-bold);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-2x);margin-top:var(--spacing-scale-2x)}::placeholder,.placeholder{color:var(--color-light);font-size:var(--font-size-scale-base);font-style:italic;font-weight:var(--font-weight-regular);line-height:var(--font-line-height-medium);margin-bottom:var(--spacing-scale-half);margin-top:var(--spacing-scale-half);opacity:1}input,textarea,.input{color:var(--color-light);font-size:var(--font-size-scale-up-01);font-weight:var(--font-weight-medium);line-height:var(--font-line-height-low);margin-bottom:var(--spacing-scale-half)}.help{font-size:var(--font-size-scale-base)}code,.code{background:var(--gray-5);border-radius:4px;color:var(--gray-80);display:inline-block;font-family:monospace;font-size:var(--font-size-scale-base);font-weight:var(--font-weight-medium);line-height:var(--font-line-height-low);padding:var(--spacing-scale-half)}*[data-toggle=collapse]:not(:disabled):hover{background-image:linear-gradient(rgba(var(--interactive-rgb), var(--hover)), rgba(var(--interactive-rgb), var(--hover)))}*[data-toggle=collapse]:focus{outline:none}*[data-toggle=collapse].focus-visible,*[data-toggle=collapse]:focus-visible{outline-color:var(--focus);outline-offset:var(--focus-offset);outline-style:var(--focus-style);outline-width:var(--focus-width)}:host{display:inline-block;margin-bottom:var(--spacing-scale-base);position:relative;width:var(--br-datetime-picker-width, 304px)}:host([mode=time]){width:var(--br-datetime-picker-time-width, 144px)}:host([mode=date]){width:var(--br-datetime-picker-date-width, 304px)}:host([mode=datetime]){width:var(--br-datetime-picker-datetime-width, 304px)}.br-datetime-picker{width:100%}.br-datetime-picker br-datetime-input,.br-datetime-picker br-card{display:block;width:100%}.br-datetime-picker br-card{font-size:var(--font-size-scale-base)}`;
+
+const DatetimePicker = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.dateStateChange = createEvent(this, "dateStateChange", 7);
+        this.valueChange = createEvent(this, "valueChange", 7);
+        this.brDatetimePickerValidationChange = createEvent(this, "brDatetimePickerValidationChange", 7);
+        if (hostRef.$hostElement$["s-ei"]) {
+            this.elementInternals = hostRef.$hostElement$["s-ei"];
+        }
+        else {
+            this.elementInternals = hostRef.$hostElement$.attachInternals();
+            hostRef.$hostElement$["s-ei"] = this.elementInternals;
+        }
+        /**
+         * Controla se o conteúdo do picker está visível.
+         */
+        this.isPickerOpen = false;
+        this.formDisabled = false;
+        this.hasFeedbackSlot = false;
+        this.customValidationMessage = '';
+        this.validatorMessage = null;
+        this.isValidating = false;
+        this.feedbackId = `br-datetime-picker-feedback-${datetimePickerId++}`;
+        /** Lista normalizada de datas indisponíveis para seleção. */
+        this.normalizedDisabledDates = [];
+        /** Data final selecionada no modo de intervalo. */
+        this.rangeEnd = null;
+        /** Data inicial selecionada no modo de intervalo. */
+        this.rangeStart = null;
+        /**
+         * Mantém a data de referência que orienta a navegação visual do calendário.
+         */
+        this.referenceDate = new Date();
+        /**
+         * Define o modo de seleção exibido pelo componente: data, horário ou ambos.
+         *
+         * Valores aceitos: `date`, `time` ou `datetime`.
+         * Valores inválidos são corrigidos automaticamente para o valor padrão,
+         * mantendo o atributo refletido sempre consistente com o modo exibido.
+         *
+         * @default 'datetime'
+         */
+        this.mode = DATETIME_PICKER_MODE.DEFAULT;
+        /**
+         * Define o locale usado pelos subcomponentes para formatar datas e rótulos.
+         *
+         * @default 'pt-BR'
+         */
+        this.locale = DATETIME_PICKER_LOCALE.DEFAULT;
+        /**
+         * Define o placeholder exibido no campo de entrada do datetime picker.
+         *
+         * @default ''
+         */
+        this.placeholder = '';
+        /** Nome do campo para submissão em formulários nativos. */
+        this.name = '';
+        /** Indica se o campo deve ter valor antes do envio do formulário. */
+        this.required = false;
+        /** Menor data/horário aceito, interpretado conforme `mode`. */
+        this.min = null;
+        /** Maior data/horário aceito, interpretado conforme `mode`. */
+        this.max = null;
+        /**
+         * Define o tipo de seleção de datas para o calendário: única ou intervalo.
+         *
+         * `range` só funciona em conjunto com `mode="date"`.
+         * Se `selectionMode="range"` for informado, o componente ajusta automaticamente
+         * `mode` para `date`. Se `mode` mudar para `time` ou `datetime`, o componente
+         * normaliza `selectionMode` para `single` quando necessário.
+         */
+        this.selectionMode = 'single';
+        /**
+         * Define o dia inicial da semana exibida no calendário.
+         *
+         * Valores suportados: 0 (domingo) a 6 (sábado).
+         *
+         * @default 0
+         */
+        this.weekStartsOn = 0;
+        /**
+         * Define a seleção inicial do componente.
+         *
+         * Aceita:
+         * - `'now'`: seleciona o momento atual.
+         * - `Date` ou `string`: seleciona uma data arbitrária.
+         * - `null`: inicia sem seleção.
+         *
+         * Reativo em runtime: mudanças na prop atualizam estado e subcomponentes.
+         *
+         * @default null
+         */
+        this.initialMoment = null;
+        /**
+         * Valor selecionado pelo usuário. Pode ser controlado externamente e é atualizado
+         * pelo evento `valueChange`.
+         */
+        this.value = null;
+        /**
+         * Desabilita toda a interação do componente.
+         *
+         * Quando `true`, impede abrir o picker, alterar valores e navegar entre datas/horários.
+         *
+         * @default false
+         */
+        this.disabled = false;
+        /**
+         * Define um conjunto de datas indisponíveis para seleção.
+         *
+         * Aceita uma lista de `Date` e/ou strings analisáveis, ou uma string com datas
+         * separadas por espaço em branco. Datas inválidas são ignoradas com warning.
+         * A comparação considera apenas o dia (ano/mês/dia), ignorando hora.
+         *
+         * @default null
+         */
+        this.disabledDates = null;
+        /**
+         * Define se o calendário deve manter um número fixo de linhas (6 semanas = 42 dias)
+         * ou variar conforme o mês.
+         *
+         * Quando `true`, o calendário sempre exibe 6 semanas completas.
+         * Quando `false`, o calendário adapta-se ao mês, exibindo apenas as semanas necessárias.
+         *
+         * @default false
+         */
+        this.fixedRowCount = false;
+        /** Snapshot da seleção inicial usada para restaurar em reset de formulário. */
+        this.initialFormValue = null;
+        this.validationRunId = 0;
+        this.isInitialized = false;
+        this.syncingCanonicalValues = false;
+        /** Mapeia cada modo para a função responsável por renderizar seu conteúdo. */
+        this.modeRendererMap = {
+            [DATETIME_PICKER_MODE.DATE]: () => this.renderDatePicker(),
+            [DATETIME_PICKER_MODE.TIME]: () => this.renderTimePicker(),
+            [DATETIME_PICKER_MODE.DATETIME]: () => this.renderDateTimePicker(),
+        };
+        /**
+         * Sincroniza o estado local com a emissão dos subcomponentes de data e horário.
+         *
+         * @param event - Evento com a data de referência e o valor selecionado.
+         */
+        this.handleDateStateChange = (event) => {
+            // Evita que o evento interno dos subcomponentes vaze para fora do host.
+            event.stopPropagation();
+            if (this.isDisabled()) {
+                return;
+            }
+            const { referenceDate, value, range } = event.detail;
+            const selectedDate = this.resolveSelectedDateFromEvent(range, value);
+            if (selectedDate !== null && this.isDateDisabled(selectedDate)) {
+                return;
+            }
+            this.referenceDate = toDateExports.toDate(referenceDate);
+            const shouldEmitPublicEvent = this.resolvePublicEventEmissionForRange(range);
+            this.setComponentValue(value === null ? null : toDateExports.toDate(value), shouldEmitPublicEvent && this.isInitialized);
+        };
+        /**
+         * Alterna visibilidade do picker quando o input solicita.
+         */
+        this.handleTogglePicker = (event) => {
+            if (this.isDisabled()) {
+                return;
+            }
+            event.stopPropagation();
+            const willOpen = !this.isPickerOpen;
+            if (willOpen) {
+                this.referenceDate = this.value === null ? toDateExports.toDate(new Date()) : toDateExports.toDate(this.value);
+            }
+            this.isPickerOpen = willOpen;
+        };
+        /**
+         * Fecha o picker quando o clique acontece fora do host.
+         */
+        this.handleOutsideClick = (event) => {
+            const eventPath = event.composedPath();
+            if (eventPath.includes(this.el)) {
+                return;
+            }
+            this.isPickerOpen = false;
+        };
+        this.outsideClickListenerAttached = false;
+        /**
+         * Fecha o picker ao pressionar Escape, devolvendo o foco ao input interno.
+         *
+         * @param event - Evento de teclado disparado em qualquer descendente do componente.
+         */
+        this.handlePickerKeydown = (event) => {
+            if (event.key !== 'Escape' || !this.isPickerOpen)
+                return;
+            event.stopPropagation();
+            this.isPickerOpen = false;
+            this.getNativeInputElement()?.focus();
+        };
+    }
+    formDisabledCallback(disabled) {
+        this.formDisabled = disabled;
+    }
+    /** API nativa de reset de form-associated custom elements. */
+    formResetCallback() {
+        this.customValidationMessage = '';
+        this.validatorMessage = null;
+        this.validationRunId++;
+        this.restoreSelection(this.initialFormValue);
+    }
+    /** API nativa de restauração de estado (histórico/autofill) do formulário. */
+    formStateRestoreCallback(state) {
+        if (typeof state !== 'string') {
+            this.restoreSelection(null);
+            return;
+        }
+        if (this.isRangeRestoreMode()) {
+            this.restoreRangeStateFromSerialized(state);
+            return;
+        }
+        this.restoreSingleStateFromSerialized(state);
+    }
+    /**
+     * Revalida o modo sempre que a prop mudar.
+     *
+     * @param newValue - Valor recebido via atributo/prop.
+     */
+    handleModeChange(newValue) {
+        this.ensureValidMode(newValue);
+        if (this.selectionMode === 'range' && this.mode !== DATETIME_PICKER_MODE.DATE) {
+            this.selectionMode = 'single';
+            return;
+        }
+        this.updateFormInternals();
+    }
+    /** Revalida o estado do formulário quando required mudar. */
+    handleRequiredChange() {
+        this.updateFormInternals();
+    }
+    handleConstraintChange() {
+        this.updateFormInternals();
+    }
+    /** Exclui o valor do FormData enquanto o componente estiver desabilitado. */
+    handleDisabledChange() {
+        this.updateFormInternals();
+    }
+    /** Reage a mudanças no modo de seleção e limpa intervalo quando necessário. */
+    handleSelectionModeChange(newValue) {
+        this.ensureValidSelectionMode(newValue);
+        if (this.selectionMode === 'range' && this.mode !== DATETIME_PICKER_MODE.DATE) {
+            this.mode = DATETIME_PICKER_MODE.DATE;
+            return;
+        }
+        if (this.selectionMode === 'single') {
+            this.clearRangeState();
+            return;
+        }
+        this.updateFormInternals();
+    }
+    /** Revalida o dia inicial da semana sempre que a prop mudar. */
+    handleWeekStartsOnChange(newValue) {
+        this.ensureValidWeekStartsOn(newValue);
+    }
+    /**
+     * Aplica ou limpa a seleção da data atual conforme o novo valor da prop.
+     *
+     * @param newValue - Novo estado da prop.
+     */
+    handleInitialMomentChange(newValue) {
+        this.applyInitialMoment(newValue, this.isInitialized);
+        this.initialFormValue = this.cloneDate(this.value);
+    }
+    /** Sincroniza alterações externas do valor com o estado visual e o formulário nativo. */
+    handleValueChange(newValue) {
+        const normalizedValue = newValue instanceof Date && !Number.isNaN(newValue.getTime()) ? toDateExports.toDate(newValue) : null;
+        if (newValue !== null && normalizedValue === null) {
+            this.value = null;
+            return;
+        }
+        if (normalizedValue !== null) {
+            this.referenceDate = normalizedValue;
+        }
+        this.syncCanonicalValues();
+        this.updateFormInternals();
+    }
+    /** Converte alterações externas no valor serializado sem mudar o tipo da prop legada `value`. */
+    handleSerializedValueChange(newValue) {
+        if (this.syncingCanonicalValues || newValue === undefined)
+            return;
+        this.restoreSerializedValue(newValue);
+    }
+    /** Mantém `valueAsDate` e a prop legada `value` apontando para o mesmo estado observável. */
+    handleValueAsDateChange(newValue) {
+        if (this.syncingCanonicalValues || newValue === undefined)
+            return;
+        const normalizedValue = newValue instanceof Date && !Number.isNaN(newValue.getTime()) ? toDateExports.toDate(newValue) : null;
+        if (this.sameDate(this.value, normalizedValue))
+            return;
+        this.value = normalizedValue;
+    }
+    handlePickerOpenChange(isOpen) {
+        if (isOpen) {
+            this.attachOutsideClickListener();
+        }
+        else {
+            this.detachOutsideClickListener();
+        }
+    }
+    /**
+     * Recalcula a lista de datas desabilitadas quando a prop mudar.
+     *
+     * @param newValue - Nova configuração recebida via prop.
+     */
+    handleDisabledDatesChange(newValue) {
+        this.syncDisabledDates(newValue);
+    }
+    handleRangeValueChange(newValue) {
+        if (!newValue || this.selectionMode !== 'range')
+            return;
+        this.rangeStart = this.cloneDate(newValue.start);
+        this.rangeEnd = this.cloneDate(newValue.end);
+        const nextValue = newValue.end ?? newValue.start;
+        this.referenceDate = nextValue ? toDateExports.toDate(nextValue) : this.referenceDate;
+        this.setComponentValue(nextValue);
+    }
+    /** Registra o listener global somente enquanto o picker está aberto. */
+    connectedCallback() {
+        if (this.isPickerOpen)
+            this.attachOutsideClickListener();
+    }
+    /** Remove o listener global para evitar vazamento de eventos ao desmontar. */
+    disconnectedCallback() {
+        this.detachOutsideClickListener();
+    }
+    /**
+     * Normaliza o modo antes da primeira renderização e aplica a data atual quando solicitado.
+     */
+    componentWillLoad() {
+        this.referenceDate = resolveSsrLocalDate(this.el, this.referenceDate);
+        this.initializeMode();
+        this.initializeSelectionMode();
+        this.initializeWeekStartsOn();
+        this.initializeDisabledDates();
+        this.initializeDefaultValue();
+        if (this.serializedValue !== undefined) {
+            this.restoreSerializedValue(this.serializedValue);
+        }
+        else if (this.valueAsDate !== undefined) {
+            this.handleValueAsDateChange(this.valueAsDate);
+        }
+        this.initialFormValue = this.cloneDate(this.value);
+        this.syncCanonicalValues();
+        this.updateFormInternals();
+    }
+    componentDidLoad() {
+        this.isInitialized = true;
+        this.hasFeedbackSlot = this.el.querySelector('[slot="feedback"]') !== null;
+    }
+    /**
+     * Define programaticamente as datas desabilitadas por meio de array.
+     *
+     * Útil quando o componente é usado via HTML e o consumidor precisa enviar
+     * uma lista tipada em runtime.
+     *
+     * @param dates - Lista de datas (Date|string) a bloquear.
+     */
+    async setDisabledDates(dates) {
+        this.syncDisabledDates(dates);
+    }
+    /** Define o valor atual de forma imperativa aceitando Date, string serializada ou null. */
+    async setValue(value) {
+        if (this.isDisabled()) {
+            return;
+        }
+        const nextValue = this.parseMethodValue(value, this.mode);
+        if (nextValue !== null && this.isDateDisabled(nextValue)) {
+            this.setComponentValue(null);
+            return;
+        }
+        if (this.selectionMode === 'single') {
+            this.rangeStart = null;
+            this.rangeEnd = null;
+        }
+        this.referenceDate = nextValue === null ? toDateExports.toDate(new Date()) : toDateExports.toDate(nextValue);
+        this.setComponentValue(nextValue);
+    }
+    /** Retorna uma cópia do valor selecionado atualmente. */
+    async getValue() {
+        return this.cloneDate(this.value);
+    }
+    /** Limpa valor e intervalo selecionados. */
+    async clear() {
+        this.rangeStart = null;
+        this.rangeEnd = null;
+        this.referenceDate = toDateExports.toDate(new Date());
+        this.setComponentValue(null);
+    }
+    /** Abre o picker quando o componente estiver habilitado. */
+    async open() {
+        if (this.isDisabled()) {
+            return;
+        }
+        this.referenceDate = this.value === null ? toDateExports.toDate(new Date()) : toDateExports.toDate(this.value);
+        this.isPickerOpen = true;
+    }
+    /** Fecha o picker. */
+    async close() {
+        this.isPickerOpen = false;
+    }
+    /** Alterna o estado de abertura do picker. */
+    async toggle() {
+        if (this.isPickerOpen) {
+            await this.close();
+            return;
+        }
+        await this.open();
+    }
+    /** Move o foco para o input nativo interno. */
+    async focusInput() {
+        this.getNativeInputElement()?.focus();
+    }
+    /** Define intervalo de datas de forma imperativa, forçando modo date e selectionMode range. */
+    async setRange(start, end) {
+        if (this.isDisabled()) {
+            return;
+        }
+        this.selectionMode = 'range';
+        this.mode = DATETIME_PICKER_MODE.DATE;
+        const normalizedStart = this.parseMethodValue(start, DATETIME_PICKER_MODE.DATE);
+        const normalizedEnd = this.parseMethodValue(end, DATETIME_PICKER_MODE.DATE);
+        if ((normalizedStart !== null && this.isDateDisabled(normalizedStart)) ||
+            (normalizedEnd !== null && this.isDateDisabled(normalizedEnd))) {
+            this.clearRangeState();
+            return;
+        }
+        this.rangeStart = this.cloneDate(normalizedStart);
+        this.rangeEnd = this.cloneDate(normalizedEnd);
+        const nextValue = normalizedEnd ?? normalizedStart;
+        this.referenceDate = nextValue === null ? toDateExports.toDate(new Date()) : toDateExports.toDate(nextValue);
+        this.setComponentValue(nextValue);
+    }
+    /**
+     * Retorna o intervalo de datas selecionado quando em modo `selectionMode="range"`.
+     *
+     * @returns Objeto com datas `start` e `end`, ou `null` se não estiver em modo range.
+     */
+    async getRange() {
+        if (this.selectionMode !== 'range' || this.mode !== DATETIME_PICKER_MODE.DATE) {
+            return null;
+        }
+        return {
+            start: this.cloneDate(this.rangeStart),
+            end: this.cloneDate(this.rangeEnd),
+        };
+    }
+    /**
+     * Consulta se o picker está atualmente aberto.
+     *
+     * @returns `true` se o picker está visível, `false` caso contrário.
+     */
+    async isOpen() {
+        return this.isPickerOpen;
+    }
+    /** Restaura o estado inicial atualmente registrado para reset. */
+    async resetToInitial() {
+        this.restoreSelection(this.initialFormValue);
+    }
+    /** Permite que consumidores acionem validação nativa do formulário via host. */
+    async checkValidity() {
+        return this.elementInternals.checkValidity();
+    }
+    /** Permite exibir mensagens nativas de validação no host. */
+    async reportValidity() {
+        return this.elementInternals.reportValidity();
+    }
+    /** Define ou limpa uma mensagem de validade customizada. */
+    async setCustomValidity(message) {
+        this.customValidationMessage = message;
+        this.syncFormValidity();
+    }
+    /** Executa o validator do picker e retorna se a seleção atual é válida. */
+    async validate() {
+        const validator = resolveFormValidator(this.validator);
+        if (!validator || this.isDisabled())
+            return this.checkValidity();
+        const runId = ++this.validationRunId;
+        this.isValidating = true;
+        this.validatorMessage = null;
+        this.syncFormValidity();
+        this.brDatetimePickerValidationChange.emit({ validating: true, valid: null, message: null });
+        const value = this.selectionMode === 'range'
+            ? { start: this.cloneDate(this.rangeStart), end: this.cloneDate(this.rangeEnd) }
+            : this.cloneDate(this.value);
+        const message = await runFormValidator(validator, value);
+        if (runId !== this.validationRunId)
+            return false;
+        this.validatorMessage = message;
+        this.isValidating = false;
+        this.syncFormValidity();
+        const valid = message === null && (await this.checkValidity());
+        this.brDatetimePickerValidationChange.emit({ validating: false, valid, message });
+        return valid;
+    }
+    /** Retorna um snapshot serializável da Constraint Validation API. */
+    async getValidationState() {
+        return getFormValidationState(this.elementInternals);
+    }
+    /**
+     * Valida o modo de seleção e corrige para padrão se inválido.
+     *
+     * @param value - Modo informado pelo consumidor do componente.
+     */
+    ensureValidSelectionMode(value) {
+        this.selectionMode = normalizeDatetimePickerSelectionMode(value);
+    }
+    /**
+     * Normaliza o modo de seleção logo na inicialização.
+     */
+    initializeSelectionMode() {
+        this.handleSelectionModeChange(this.selectionMode);
+    }
+    /** Normaliza o dia inicial da semana logo na inicialização. */
+    initializeWeekStartsOn() {
+        this.handleWeekStartsOnChange(this.weekStartsOn);
+    }
+    /** Valida o dia inicial da semana e corrige para padrão quando necessário. */
+    ensureValidWeekStartsOn(value) {
+        this.weekStartsOn = normalizeDatetimePickerWeekStartsOn(value);
+    }
+    /**
+     * Limpa o estado do intervalo de datas ao mudar para modo single.
+     */
+    clearRangeState() {
+        this.rangeStart = null;
+        this.rangeEnd = null;
+        this.updateFormInternals();
+    }
+    /** Indica quando o componente está operando em seleção de intervalo por data. */
+    isRangeDateSelectionMode() {
+        return this.selectionMode === 'range' && this.mode === DATETIME_PICKER_MODE.DATE;
+    }
+    /**
+     * Resolve se o evento público deve ser emitido após um update vindo dos subcomponentes.
+     *
+     * No modo range, o evento externo só é emitido no clique final (quando `end` é definido).
+     */
+    resolvePublicEventEmissionForRange(range) {
+        if (!this.isRangeDateSelectionMode()) {
+            return true;
+        }
+        if (range === undefined) {
+            return false;
+        }
+        const isFinalRangeClick = this.rangeEnd === null && range.end !== null;
+        this.setRangeState(range);
+        return isFinalRangeClick;
+    }
+    /** Resolve a data efetivamente selecionada no evento para validar bloqueio em single/range. */
+    resolveSelectedDateFromEvent(range, value) {
+        if (!this.isRangeDateSelectionMode() || range === undefined) {
+            return value;
+        }
+        return range.end ?? range.start ?? value;
+    }
+    attachOutsideClickListener() {
+        if (this.outsideClickListenerAttached)
+            return;
+        document.addEventListener('click', this.handleOutsideClick);
+        this.outsideClickListenerAttached = true;
+    }
+    detachOutsideClickListener() {
+        if (!this.outsideClickListenerAttached)
+            return;
+        document.removeEventListener('click', this.handleOutsideClick);
+        this.outsideClickListenerAttached = false;
+    }
+    /**
+     * Garante que o componente inicie com um modo suportado.
+     */
+    initializeMode() {
+        this.ensureValidMode(this.mode);
+    }
+    /**
+     * Normaliza a coleção de datas desabilitadas na inicialização.
+     */
+    initializeDisabledDates() {
+        this.syncDisabledDates(this.disabledDates);
+    }
+    /**
+     * Normaliza e aplica as datas desabilitadas, limpando valor atual quando necessário.
+     *
+     * @param value - Valor bruto recebido por prop/atributo ou método público.
+     */
+    syncDisabledDates(value) {
+        this.normalizedDisabledDates = normalizeDatetimePickerDisabledDates(value);
+        if (this.rangeStart !== null && this.isDateDisabled(this.rangeStart)) {
+            this.rangeStart = null;
+        }
+        if (this.rangeEnd !== null && this.isDateDisabled(this.rangeEnd)) {
+            this.rangeEnd = null;
+        }
+        if (this.value !== null && this.isDateDisabled(this.value)) {
+            this.setComponentValue(null);
+        }
+    }
+    /**
+     * Aplica a seleção inicial configurada na prop.
+     */
+    initializeDefaultValue() {
+        if (this.value instanceof Date && !Number.isNaN(this.value.getTime())) {
+            this.referenceDate = toDateExports.toDate(this.value);
+            return;
+        }
+        this.value = null;
+        this.applyInitialMoment(this.initialMoment, false);
+    }
+    /**
+     * Aplica a seleção inicial recebida, com normalização de valores inválidos.
+     *
+     * @param selection - Configuração de seleção inicial.
+     */
+    applyInitialMoment(selection, shouldEmitEvents = true) {
+        if (this.isDisabled()) {
+            return;
+        }
+        const normalizedSelection = normalizeDatetimePickerInitialMoment(selection);
+        if (normalizedSelection === 'now') {
+            const now = toDateExports.toDate(new Date());
+            this.referenceDate = now;
+            this.setComponentValue(now, shouldEmitEvents);
+            return;
+        }
+        if (normalizedSelection === null) {
+            this.rangeStart = null;
+            this.rangeEnd = null;
+            this.setComponentValue(null, shouldEmitEvents);
+            return;
+        }
+        const selectedDate = toDateExports.toDate(normalizedSelection);
+        if (this.isDateDisabled(selectedDate)) {
+            this.setComponentValue(null, shouldEmitEvents);
+            return;
+        }
+        this.referenceDate = selectedDate;
+        this.rangeStart = null;
+        this.rangeEnd = null;
+        this.setComponentValue(selectedDate, shouldEmitEvents);
+    }
+    /** Indica se o estado serializado deve ser interpretado como intervalo. */
+    isRangeRestoreMode() {
+        return this.selectionMode === 'range' && this.mode === DATETIME_PICKER_MODE.DATE;
+    }
+    /** Restaura estado de intervalo a partir do valor serializado do formulário. */
+    restoreRangeStateFromSerialized(serializedState) {
+        const restoredRange = parseDatetimePickerSerializedRange(serializedState);
+        if (restoredRange === null) {
+            this.restoreSelection(null);
+            return;
+        }
+        const { start, end } = restoredRange;
+        this.rangeStart = start;
+        this.rangeEnd = end;
+        this.restoreSelection(end);
+    }
+    /** Restaura estado de seleção única a partir do valor serializado do formulário. */
+    restoreSingleStateFromSerialized(serializedState) {
+        const restoredValue = parseDatetimePickerSerializedValue(serializedState, this.mode, this.referenceDate);
+        if (restoredValue !== null && this.isDateDisabled(restoredValue)) {
+            this.restoreSelection(null);
+            return;
+        }
+        this.restoreSelection(restoredValue);
+    }
+    /** Resolve Date|null a partir de valores aceitos pelos métodos públicos. */
+    parseMethodValue(value, mode) {
+        if (value === null) {
+            return null;
+        }
+        if (value instanceof Date) {
+            return Number.isNaN(value.getTime()) ? null : toDateExports.toDate(value);
+        }
+        return parseDatetimePickerSerializedValue(value, mode, this.referenceDate);
+    }
+    /** Aplica a ponte serializada usando os mesmos parsers já usados por restore de formulário. */
+    restoreSerializedValue(serializedValue) {
+        if (this.isRangeRestoreMode()) {
+            this.restoreRangeStateFromSerialized(serializedValue);
+            return;
+        }
+        this.restoreSingleStateFromSerialized(serializedValue);
+    }
+    /** Atualiza os nomes canônicos sem emitir eventos adicionais ou criar ciclos de watchers. */
+    syncCanonicalValues() {
+        const nextSerializedValue = this.getSerializedValue();
+        const nextValueAsDate = this.cloneDate(this.value);
+        if (this.serializedValue === nextSerializedValue && this.sameDate(this.valueAsDate ?? null, nextValueAsDate))
+            return;
+        this.syncingCanonicalValues = true;
+        this.serializedValue = nextSerializedValue;
+        this.valueAsDate = nextValueAsDate;
+        this.syncingCanonicalValues = false;
+    }
+    /** Retorna o mesmo valor que será submetido pelo ElementInternals. */
+    getSerializedValue() {
+        const zero = (date) => (date === null ? null : setExports.set(date, { seconds: 0, milliseconds: 0 }));
+        return (serializeDatetimePickerFormValue(this.value === null ? null : zero(this.value), {
+            mode: this.mode,
+            selectionMode: this.selectionMode,
+            rangeStart: zero(this.rangeStart),
+            rangeEnd: zero(this.rangeEnd),
+            referenceDate: zero(this.referenceDate) ?? this.referenceDate,
+        }) ?? '');
+    }
+    sameDate(left, right) {
+        return left === right || (left !== null && right !== null && left.getTime() === right.getTime());
+    }
+    /** Busca o input nativo interno para ações imperativas de foco. */
+    getNativeInputElement() {
+        return this.el.shadowRoot
+            ?.querySelector('br-datetime-input')
+            ?.shadowRoot?.querySelector('br-input')
+            ?.shadowRoot?.querySelector('input');
+    }
+    /** Atualiza estado interno, FormData e validação com uma única chamada. */
+    setComponentValue(nextValue, shouldEmitPublicEvent = true) {
+        this.value = this.cloneDate(nextValue);
+        this.syncCanonicalValues();
+        if (shouldEmitPublicEvent && this.isInitialized) {
+            this.emitDateStateChange();
+            void this.validate();
+        }
+        this.updateFormInternals();
+    }
+    /** Propaga o estado atual consolidado para consumidores externos do componente raiz. */
+    emitDateStateChange() {
+        const range = this.selectionMode === 'range' && this.mode === DATETIME_PICKER_MODE.DATE
+            ? {
+                start: this.cloneDate(this.rangeStart),
+                end: this.cloneDate(this.rangeEnd),
+            }
+            : undefined;
+        const rangeDates = range !== undefined && range.start !== null && range.end !== null
+            ? this.buildRangeDatesState(range.start, range.end)
+            : undefined;
+        this.dateStateChange.emit({
+            referenceDate: this.cloneDate(this.referenceDate),
+            value: this.cloneDate(this.value),
+            range,
+            rangeDates,
+        });
+        if (range)
+            this.rangeValue = range;
+        this.valueChange.emit(this.cloneDate(this.value));
+        dispatchNativeFormEvent(this.el, 'input');
+        dispatchNativeFormEvent(this.el, 'change');
+    }
+    /** Expande o intervalo completo e marca quais dias estão desabilitados. */
+    buildRangeDatesState(start, end) {
+        const intervalStart = start.getTime() <= end.getTime() ? start : end;
+        const intervalEnd = start.getTime() <= end.getTime() ? end : start;
+        return eachDayOfIntervalExports.eachDayOfInterval({
+            start: intervalStart,
+            end: intervalEnd,
+        }).map((date) => ({
+            date: toDateExports.toDate(date),
+            disabled: this.isDateDisabled(date),
+        }));
+    }
+    /** Restaura seleção e data de referência a partir de uma data já validada. */
+    restoreSelection(nextValue) {
+        this.value = this.cloneDate(nextValue);
+        if (this.selectionMode === 'single') {
+            this.rangeStart = null;
+            this.rangeEnd = null;
+        }
+        this.referenceDate = nextValue === null ? toDateExports.toDate(new Date()) : toDateExports.toDate(nextValue);
+        this.syncCanonicalValues();
+        this.updateFormInternals();
+    }
+    /** Atualiza o estado local de intervalo a partir do evento do calendário. */
+    setRangeState(nextRange) {
+        this.rangeStart = this.cloneDate(nextRange?.start ?? null);
+        this.rangeEnd = this.cloneDate(nextRange?.end ?? null);
+    }
+    /** Mantém ElementInternals sincronizado com estado e regras do componente. */
+    updateFormInternals() {
+        this.syncFormValue();
+        this.syncFormValidity();
+    }
+    /** Atualiza o valor submetido no FormData do form-associated custom element. */
+    syncFormValue() {
+        try {
+            const zero = (d) => (d === null ? null : setExports.set(d, { seconds: 0, milliseconds: 0 }));
+            const nextValue = this.isDisabled()
+                ? null
+                : serializeDatetimePickerFormValue(this.value === null ? null : zero(this.value), {
+                    mode: this.mode,
+                    selectionMode: this.selectionMode,
+                    rangeStart: zero(this.rangeStart),
+                    rangeEnd: zero(this.rangeEnd),
+                    referenceDate: zero(this.referenceDate) ?? this.referenceDate,
+                });
+            this.elementInternals.setFormValue(nextValue);
+        }
+        catch {
+            // Ambientes de teste podem esconder attachInternals parcialmente.
+        }
+    }
+    /** Espelha a regra de required no mecanismo nativo de validade. */
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: consolida flags nativos relacionados sem esconder a precedência das mensagens.
+    syncFormValidity() {
+        try {
+            const missing = hasDatetimePickerMissingValue({
+                required: this.required,
+                disabled: this.isDisabled(),
+                value: this.value,
+                mode: this.mode,
+                selectionMode: this.selectionMode,
+                rangeStart: this.rangeStart,
+                rangeEnd: this.rangeEnd});
+            const min = this.parseConstraintValue(this.min);
+            const max = this.parseConstraintValue(this.max);
+            const values = this.selectionMode === 'range' ? [this.rangeStart, this.rangeEnd] : [this.value];
+            const rangeUnderflow = min !== null && values.some((value) => value !== null && value.getTime() < min.getTime());
+            const rangeOverflow = max !== null && values.some((value) => value !== null && value.getTime() > max.getTime());
+            const invalidRange = this.selectionMode === 'range' &&
+                this.rangeStart !== null &&
+                this.rangeEnd !== null &&
+                this.rangeStart.getTime() > this.rangeEnd.getTime();
+            const flags = {
+                customError: this.customValidationMessage !== '' || Boolean(this.validatorMessage) || invalidRange,
+                rangeOverflow,
+                rangeUnderflow,
+                valueMissing: missing,
+            };
+            const message = this.customValidationMessage ||
+                this.validatorMessage ||
+                (missing
+                    ? 'Preencha este campo.'
+                    : invalidRange
+                        ? 'A data inicial deve anteceder a data final.'
+                        : rangeUnderflow
+                            ? 'Selecione uma data igual ou posterior ao mínimo.'
+                            : rangeOverflow
+                                ? 'Selecione uma data igual ou anterior ao máximo.'
+                                : '');
+            setFormValidity(this.elementInternals, flags, message, this.getNativeInputElement());
+        }
+        catch {
+            // Ambientes sem ElementInternals completo não devem falhar.
+        }
+    }
+    parseConstraintValue(value) {
+        return value === null ? null : this.parseMethodValue(value, this.mode);
+    }
+    isDisabled() {
+        return isFormControlDisabled(this.disabled, this.formDisabled);
+    }
+    /** Duplica datas para evitar compartilhamento de referência mutável. */
+    cloneDate(value) {
+        return value === null ? null : toDateExports.toDate(value);
+    }
+    /**
+     * Verifica se a data pertence ao conjunto de dias bloqueados.
+     *
+     * @param date - Data candidata à seleção.
+     * @returns `true` quando o dia estiver desabilitado.
+     */
+    isDateDisabled(date) {
+        return this.normalizedDisabledDates.some((disabledDate) => isSameDayExports.isSameDay(disabledDate, date));
+    }
+    /**
+     * Corrige valores inválidos para o modo padrão, preservando a consistência do estado refletido.
+     *
+     * @param value - Modo informado pelo consumidor do componente.
+     */
+    ensureValidMode(value) {
+        const normalizedMode = normalizeDatetimePickerMode(value);
+        if (normalizedMode !== value) {
+            this.mode = normalizedMode;
+        }
+    }
+    /**
+     * Resolve a função de renderização associada ao modo atual.
+     *
+     * @returns Função que renderiza o conteúdo interno do picker.
+     */
+    getModeRenderer() {
+        return this.modeRendererMap[this.mode];
+    }
+    /** Retorna o conjunto de classes base aplicadas ao container do componente. */
+    getCssClassMap() {
+        return {
+            'br-datetime-picker': true,
+        };
+    }
+    /**
+     * Agrupa os bindings compartilhados para evitar divergência entre data e horário.
+     */
+    getSharedDateStateBindings() {
+        return {
+            referenceDate: this.referenceDate,
+            value: this.value,
+            selectionMode: this.selectionMode,
+            rangeStart: this.rangeStart,
+            rangeEnd: this.rangeEnd,
+            onDateStateChange: this.handleDateStateChange,
+        };
+    }
+    /** Renderiza o campo de entrada responsável por abrir e sincronizar o picker. */
+    renderInputField() {
+        return (h("br-datetime-input", { referenceDate: this.referenceDate, value: this.value, selectionMode: this.selectionMode, rangeStart: this.rangeStart, rangeEnd: this.rangeEnd, placeholder: this.placeholder, mode: this.mode, disabled: this.isDisabled(), onDateStateChange: this.handleDateStateChange, onTogglePicker: this.handleTogglePicker, exportparts: "container: input-container, input: input-field, icon: input-icon" }));
+    }
+    /** Renderiza apenas o seletor de data. */
+    renderDatePicker() {
+        const effectiveSelectionMode = this.mode === DATETIME_PICKER_MODE.DATE ? this.selectionMode : 'single';
+        return (h("br-date-picker", { ...this.getSharedDateStateBindings(), selectionMode: effectiveSelectionMode, weekStartsOn: this.weekStartsOn, locale: this.locale, disabled: this.isDisabled(), disabledDates: this.normalizedDisabledDates, fixedRowCount: this.fixedRowCount }));
+    }
+    /** Renderiza apenas o seletor de hora. */
+    renderTimePicker() {
+        return h("br-time-picker", { ...this.getSharedDateStateBindings(), disabled: this.isDisabled() });
+    }
+    /**
+     * Renderiza a combinação de data e horário no modo `datetime`.
+     */
+    renderDateTimePicker() {
+        return (h(Fragment, null, this.renderDatePicker(), this.renderDivider(), this.renderTimePicker()));
+    }
+    /** Renderiza o separador visual entre data e hora no modo combinado. */
+    renderDivider() {
+        return h("br-divider", { thickness: "medium", color: "#e6e6e6", "margin-top": "10px", "margin-bottom": "10px" });
+    }
+    /**
+     * Resolve o conteúdo interno conforme o modo atual do componente.
+     */
+    renderPickerContent() {
+        if (!this.isPickerOpen) {
+            return null;
+        }
+        const renderContent = this.getModeRenderer();
+        return h("br-card", { part: "panel" }, renderContent());
+    }
+    /**
+     * Renderização principal do componente.
+     */
+    render() {
+        return (h(Host, { key: '906849439dfc93b18952963b95e35da332e5018b', onKeyDown: this.handlePickerKeydown, "aria-busy": this.isValidating ? 'true' : null, "aria-describedby": this.hasFeedbackSlot || this.customValidationMessage || this.validatorMessage ? this.feedbackId : null, "aria-errormessage": this.customValidationMessage || this.validatorMessage || this.hasFeedbackSlot ? this.feedbackId : null }, h("div", { key: '8a77432dc84c6897d7ffb2e403f72d42e333230a', class: this.getCssClassMap(), part: "container" }, this.renderInputField(), this.renderPickerContent()), h("div", { key: '1e3f4df6f301fbb54d76eea49848ec7910bc3f33', id: this.feedbackId, part: "feedback", hidden: !this.hasFeedbackSlot && !this.customValidationMessage && !this.validatorMessage }, h("slot", { key: '7000d3c447c5bfa1f674c78024a1e58ca69652a3', name: "feedback", onSlotchange: (event) => (this.hasFeedbackSlot = hasAssignedSlotContent(event.currentTarget)) }), !this.hasFeedbackSlot && (this.customValidationMessage || this.validatorMessage) ? (h("br-message", { state: "danger", message: this.customValidationMessage || this.validatorMessage })) : null)));
+    }
+    static get formAssociated() { return true; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "mode": [{
+                "handleModeChange": 0
+            }],
+        "required": [{
+                "handleRequiredChange": 0
+            }],
+        "min": [{
+                "handleConstraintChange": 0
+            }],
+        "max": [{
+                "handleConstraintChange": 0
+            }],
+        "disabled": [{
+                "handleDisabledChange": 0
+            }],
+        "selectionMode": [{
+                "handleSelectionModeChange": 0
+            }],
+        "weekStartsOn": [{
+                "handleWeekStartsOnChange": 0
+            }],
+        "initialMoment": [{
+                "handleInitialMomentChange": 0
+            }],
+        "value": [{
+                "handleValueChange": 0
+            }],
+        "serializedValue": [{
+                "handleSerializedValueChange": 0
+            }],
+        "valueAsDate": [{
+                "handleValueAsDateChange": 0
+            }],
+        "isPickerOpen": [{
+                "handlePickerOpenChange": 0
+            }],
+        "disabledDates": [{
+                "handleDisabledDatesChange": 0
+            }],
+        "rangeValue": [{
+                "handleRangeValueChange": 0
+            }]
+    }; }
+};
+let datetimePickerId = 0;
+DatetimePicker.style = datetimePickerCss();
+
+export { DatetimePicker as br_datetime_picker };