/*

Based off glamor's StyleSheet, thanks Sunil ❤️

high performance StyleSheet for css-in-js systems

- uses multiple style tags behind the scenes for millions of rules
- uses `insertRule` for appending in production for *much* faster performance

// usage

import { StyleSheet } from '@emotion/sheet'

let styleSheet = new StyleSheet({ key: '', container: document.head })

styleSheet.insert('#box { border: 1px solid red; }')
- appends a css rule into the stylesheet

styleSheet.flush()
- empties the stylesheet of all its contents

*/

/*
      NOTE min-height set to 0% because of Firefox bug
      FF http://stackoverflow.com/questions/28636832/firefox-overflow-y-not-working-with-nested-flexbox
    */

/*
  This is just a junk drawer, containing anything used across multiple classes.
  Because Luxon is small(ish), this should stay small and we won't worry about splitting
  it up into, say, parsingUtil.js and basicUtil.js and so on. But they are divided up by feature area.
*/

/*
  options.target         - name of the target object
  options.global         - target is the global object
  options.stat           - export as static methods of target
  options.proto          - export as prototype methods of target
  options.real           - real prototype method for the `pure` version
  options.forced         - export even if the native feature is available
  options.bind           - bind methods to the target, required for the `pure` version
  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
  options.sham           - add a flag to not completely full polyfills
  options.enumerable     - export as enumerable property
  options.dontCallGetSet - prevent calling a getter on target
  options.name           - the .name of the function if it does not match the key
*/

/*
 * @private
 */

/*
 * This file handles parsing for well-specified formats. Here's how it works:
 * Two things go into parsing: a regex to match with and an extractor to take apart the groups in the match.
 * An extractor is just a function that takes a regex match array and returns a { year: ..., month: ... } object
 * parse() does the work of executing the regex and applying the extractor. It takes multiple regex/extractor pairs to try in sequence.
 * Extractors can take a "cursor" representing the offset in the match to look at. This makes it easy to combine extractors.
 * combineExtractors() does the work of combining them, keeping track of the cursor through multiple extractions.
 * Some extractions are super dumb and simpleParse and fromStrings help DRY them.
 */

/*
 Modernizr 3.0.0pre (Custom Build) | MIT
*/

/*
IE11 support
 */

/*
given a DOM element, return the list of all scroll parents, up the list of ancesors
until we get to the top window object. This list is what we attach scroll listeners
to, because if any of these parent elements scroll, we'll need to re-calculate the
reference element's position.
*/

/*
object-assign
(c) Sindre Sorhus
@license MIT
*/

/* #__PURE__ */

/* , ...args */

/* , ...arguments */

/* , ...items */

/* , base */

/* , endPosition = @length */

/* , fromIndex = 0 */

/* , init */

/* , initialValue */

/* , mapfn = undefined, thisArg = undefined */

/* , newTarget */

/* , position = 0 */

/* , that = undefined */

/* , thisArg */

/* , value */

/* . */

/* .ErrorBox */

/* .ErrorType */

/* .FieldId */

/* .KSSOError */

/* .LegalBackendActions */

/* .N200 */

/* .Platform */

/* .Protocol */

/* .ProvisioningMethod */

/* .Retryer */

/* .Router */

/* .StepContainer */

/* .Subscribable */

/* .__RouterContext */

/* .createAndHandleError */

/* .createBrowserHistory */

/* .createLocation */

/* .createPath */

/* .css */

/* .defaultPoliciesForJitDisabled */

/* .defaultPoliciesForJitEnabled */

/* .focusManager */

/* .fontFamily */

/* .getDefaultUserProvisioningPolicies */

/* .getKindByPath */

/* .getLogger */

/* .getNextStepInSteps */

/* .getPathByKind */

/* .getPreviousStepInSteps */

/* .getProtocol */

/* .getProtocolPath */

/* .getProvisioningFromPath */

/* .getProvisioningPath */

/* .getStep */

/* .getStepList */

/* .gridSize */

/* .h200 */

/* .heading */

/* .isServer */

/* .jsx */

/* .matchPath */

/* .noop */

/* .notifyManager */

/* .onlineManager */

/* .post */

/* .scheduleMicrotask */

/* .sleep */

/* .subtleHeading */

/* .useAnalyticsEvents */

/* .useGlobalTheme */

/* .useHistory */

/* .useRouteMatch */

/* .useTrackedRef */

/* .useUrlParams */

/* B100 */

/* B200 */

/* B300 */

/* B400 */

/* B50 */

/* B500 */

/* B75 */

/* BrowserRouter */

/* Built-in method references that are verified to be native. */

/* CHANNEL */

/* ClassNames */

/* CommonActionTypes */

/* Controller */

/* DEFAULT_THEME_MODE */

/* DN0 */

/* DN10 */

/* DN100 */

/* DN20 */

/* DN200 */

/* DN30 */

/* DN300 */

/* DN40 */

/* DN400 */

/* DN500 */

/* DN60 */

/* DN600 */

/* DN70 */

/* DN80 */

/* DN90 */

/* DN900 */

/* DN90A */

/* ErrorBoundary */

/* ErrorBox */

/* ErrorMessage */

/* ErrorType */

/* G400 */

/* G50 */

/* G500 */

/* HelperMessage */

/* KSSOError */

/* Kind */

/* LegalBackendActions */

/* Math.imul(h, m): */

/* Math.imul(k, m): */

/* Modal */

/* Mutation */

/* N10 */

/* N100 */

/* N100A */

/* N20 */

/* N200 */

/* N20A */

/* N30 */

/* N300 */

/* N30A */

/* N40 */

/* N400 */

/* N500 */

/* N60A */

/* N70 */

/* N700 */

/* N80 */

/* N800 */

/* N90 */

/* N900 */

/* OidcActionTypes */

/* P50 */

/* P500 */

/* Platform */

/* Previously, defaultValue was being set as undefined in Field.defaultProps, which
         * effectively made it an optional prop to external consumers of Field. However the
         * prop types defined defaultValue as required, so inside the component it was not
         * valid for defaultValue to be undefined. We need to suppress the error
         * after changing defaultValue to explictly be an optional prop.
         * If default value has changed we are using new default value.
         * Otherwise we need to check if we already have value for this field
         * (because we are using changing key prop to re-run field level validation, and that
         * cause the component re-mounting) to not override the actual value with the default value.
         */

/* Protocol */

/* R100 */

/* R300 */

/* R400 */

/* R50 */

/* R500 */

/* R75 */

/* Retryer */

/* Route */

/* STANDARD_HEADERS */

/* SamlActionTypes */

/* StepContainer */

/* SubmitStatus */

/* Subscribable */

/* Switch */

/* THEME_MODES */

/* TOKEN_NOT_FOUND_CSS_VAR */

/* TestStep */

/* This ensures the body fills the whole space between header and footer. */

/* This loop tries to diff using larger units first.
     If we overshoot, we backtrack and try the next smaller unit.
     "cursor" starts out at the earlier timestamp and moves closer and closer to "later"
     as we use smaller and smaller units.
     highWater keeps track of where we would be if we added one more of the smallest unit,
     this is used later to potentially convert any difference smaller than the smallest higher order unit
     into a fraction of that smallest higher order unit
  */

/* TouchScrollable */

/* UserActivatePolicy */

/* UserNotFoundPolicy */

/* UserUpdatePolicy */

/* We only want to apply transform on modals shifting to the back of the stack. */

/* Y200 */

/* Y300 */

/* Y400 */

/* Y50 */

/* Y500 */

/* Z+1 */

/* ["default"] */

/* appendErrors */

/* bind */

/* bindAll */

/* binding */

/* borderRadius */

/* clearQueryClient */

/* codeFontFamily */

/* combineClass */

/* commonSVGStyles */

/* createAndHandleError */

/* createGlobalStyle */

/* createPath */

/* createTheme */

/* css */

/* default */

/* empty */

/* ensureQueryKeyArray */

/* eslint-disable */

/* eslint-disable @atlaskit/design-system/ensure-design-token-usage */

/* eslint-disable @atlaskit/design-system/no-nested-styles */

/* eslint-disable @repo/internal/react/consistent-props-definitions */

/* eslint-disable @repo/internal/react/no-clone-element */

/* eslint-disable @repo/internal/styles/no-nested-styles */

/* eslint-disable es/no-array-prototype-keys -- safe */

/* eslint-disable es/no-object-getownpropertynames -- safe */

/* eslint-disable es/no-string-prototype-matchall -- safe */

/* eslint-disable es/no-symbol -- required for testing */

/* eslint-disable es/no-symbol -- safe */

/* eslint-disable no-bitwise */

/* eslint-disable no-proto -- safe */

/* eslint-disable no-self-assign -- prototype methods protection */

/* eslint-disable no-unused-vars */

/* eslint-disable prefer-rest-params */

/* eslint-disable react/prop-types */

/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */

/* eslint-disable regexp/no-useless-quantifier -- testing */

/* eslint-disable-next-line jsx-a11y/anchor-has-content */

/* eslint-enable */

/* eslint-enable no-self-assign -- prototype methods protection */

/* focusManager */

/* fontFamily */

/* fontSize */

/* functionalUpdate */

/* generateUID */

/* generateVisitedPathsList */

/* get */

/* getAbortController */

/* getAppBaseUrl */

/* getBackground */

/* getContextPath */

/* getDefaultState */

/* getDocumentationLink */

/* getIconSize */

/* getIdpId */

/* getIdpIdFromSessionStorage */

/* getKrbToken */

/* getLogger */

/* getName */

/* getPlatform */

/* getPlatformFromPlatformId */

/* getPluginKeyBasePart */

/* getRegisteredStyles */

/* getServletUrl */

/* getUserCleanupApiUrl */

/* global ActiveXObject -- old IE, WSH */

/* global Bun, Deno -- detection */

/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */

/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */

/* global define */

/* gridSize */

/* h200 */

/* h600 */

/* harmony default export */

/* harmony export */

/* harmony import */

/* harmony reexport (checked) */

/* hashQueryKey */

/* hashQueryKeyByOptions */

/* headingSizes */

/* ignore */

/* importMetadataFromPaste */

/* importMetadataFromUrl */

/* initialDraft */

/* insertStyles */

/* isBlank */

/* isCancelable */

/* isCancelledError */

/* isNotBlank */

/* isServer */

/* isValidTimeout */

/* istanbul ignore next */

/* jsx */

/* k >>> r: */

/* keyframes */

/* layers */

/* mainReducer */

/* matchMutation */

/* matchQuery */

/* mergeSteps */

/* n */

/* noop */

/* notifyManager */

/* o */

/* onlineManager */

/* parseFilterArgs */

/* parseMutationArgs */

/* parseQueryArgs */

/* partialMatchKey */

/* post */

/* provided dependency */

/* queryClient */

/* reexport */

/* reexport safe */

/* registerStyles */

/* replaceEqualDeep */

/* resetIdpId */

/* serializeStyles */

/* set */

/* setAppBaseUrl */

/* setContextPath */

/* setIdpIdInSessionStorage */

/* setKrbToken */

/* setLogger */

/* setPlatform */

/* setPluginKey */

/* setPluginKeyBasePart */

/* setServletUrl */

/* setUserCleanupApiUrl */

/* shallowEqualObjects */

/* sizeStyleMap */

/* submitSamlConfig */

/* subtleHeading */

/* text */

/* timeUntilStale */

/* uid */

/* unused harmony export CancelledError */

/* unused harmony export FocusManager */

/* unused harmony export NotifyManager */

/* unused harmony export OnlineManager */

/* unused harmony export ValidMessage */

/* unused harmony export defaultDocumentationLink */

/* unused harmony export getApiInfo */

/* unused harmony export initialCommonWizardState */

/* unused harmony export provisioningMethods */

/* unused harmony export useNextAndPreviousSteps */

/* unused harmony exports BRAND, DIRTY, EMPTY_PATH, INVALID, NEVER, OK, ParseStatus, Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPipeline, ZodPromise, ZodReadonly, ZodRecord, ZodSchema, ZodSet, ZodString, ZodSymbol, ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, any, array, bigint, boolean, coerce, custom, date, datetimeRegex, default, defaultErrorMap, discriminatedUnion, effect, enum, function, getErrorMap, getParsedType, instanceof, intersection, isAborted, isAsync, isDirty, isValid, late, lazy, literal, makeIssue, map, nan, nativeEnum, never, null, nullable, number, object, objectUtil, oboolean, onumber, optional, ostring, pipeline, preprocess, promise, quotelessJson, record, set, setErrorMap, strictObject, string, symbol, transformer, tuple, undefined, union, unknown, util, void */

/* unused harmony exports CONTRAST_MODE_ATTRIBUTE, CUSTOM_THEME_ATTRIBUTE, DEFAULT_THEME, CSS_PREFIX, CSS_VAR_FULL, CURRENT_SURFACE_CSS_VAR */

/* unused harmony exports Form, FormProvider, useController, useFieldArray, useWatch */

/* unused harmony exports HashRouter, Link, NavLink */

/* unused harmony exports difference, replaceAt, parseMutationFilterArgs, mapQueryStatusFilter, stableValueHash, partialDeepEqual, isPlainObject, isQueryKey, isError */

/* unused harmony exports fontFallback, h900, h800, h700, h500, h400, h300, h100 */

/* unused harmony exports fontSizeSmall, focusRing, noFocusRing, visuallyHidden, assistive, skeletonShimmer */

/* unused harmony exports getPlatformDisplayName, getGroups */

/* useAnalyticsContext */

/* useAnalyticsEvents */

/* useDraft */

/* useDraftMutate */

/* useForm */

/* useFormContext */

/* useFormState */

/* useGetDraft */

/* useGlobalTheme */

/* useHistory */

/* useLocation */

/* usePlatformLeafEventHandler */

/* useResetDraftAndRequestDelete */

/* useSaveDraft */

/* useStepControl */

/* useTrackedRef */

/* useUrlParams */

/* useVisitedPaths */

/* zodResolver */

/*!
  Copyright (c) 2015 Jed Watson.
  Based on code that is Copyright 2013-2015, Facebook, Inc.
  All rights reserved.
*/

/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */

/*#__PURE__*/

/**
             * load each transition sequentially
             */

/**
             * load each transition sequentially in reverse
             */

/**
         * "Tooltip" classname is a hook used by tests to manipulate
         * and hide tooltips, including in VR snapshots
         **/

/**
         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
         * If you want to pass through unknown properties, use `.passthrough()` instead.
         */

/**
         * @deprecated Use `.extend` instead
         *  */

/**
         * The following parameters are optionally typed in final-form to indicate that not all parameters need
         * to be subscribed to. We cast them as booleans (using || false), since this is what they are semantically.
         */

/**
       * Do not update dirtySinceLastSubmit until submission has finished.
       */

/**
       * Do not update submitFailed until submission has finished.
       */

/**
     *
     * @param {number[]|string|number} every
     * @param {{}} config
     */

/**
     *  Change the variables --checkbox-background-color, --checkbox-border-color
     *  and --checkbox-tick-color according to user interactions.
     *  All other variables are constant.
     *  All styles from the input target the sibling svg.
     */

/**
     * @access private
     */

/**
     * @deprecated
     */

/**
     * Background
     */

/**
     * Between Time Frames
     * @param {number} start - Start
     * @param {number} end - End
     */

/**
     * Border
     */

/**
     * Checks if startDay and endDay follows a calendar sequence.
     * else throws error.
     * @param startDay
     * @param endDay
     */

/**
     * Equivalent to `.min(1)`
     */

/**
     * Every Day
     */

/**
     * Every Day At
     * @param {number|number[]} hoursOfTheDay - Hours of the day
     * @param {number|number[]} minutesOfTheHour - Minutes of the Hour
     */

/**
     * Every Friday
     */

/**
     * Every Friday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Hour
     */

/**
     * Every Hour At
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     * @returns {string}
     */

/**
     * Every Minute
     */

/**
     * Every Monday
     */

/**
     * Every Monday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Month
     */

/**
     * Every Month on
     * @param {number|number[]} daysOfTheMonth - Days of the month
     * @param {number|number[]} hoursOfTheDay - Hours of the day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour
     */

/**
     * Every Saturday
     */

/**
     * Every Saturday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Sunday
     */

/**
     * Every Sunday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Thursday
     */

/**
     * Every Thursday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Tuesday
     */

/**
     * Every Tuesday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Wednesday
     */

/**
     * Every Wednesday At
     * @param {number|number[]} hoursOfTheDay - Hours Of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every Week
     */

/**
     * Every Week At
     * @param {number|number[]|string|string[]} daysOfTheWeek - Days of the week
     * @param {number|number[]} hoursOfTheDay - Hours of the day.
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour
     */

/**
     * Every WeekDay
     * @param {number|string} startDay - Starting day (Monday=1, Sunday=0)
     * @param {number|string} endDay - Starting day (Monday=1, Sunday=0)
     * @returns {string}
     *
     * @example
     * CronTime.everyWeekDay()
     *  // Monday to Friday
     * CronTime.everyWeekDay('sunday', 'thursday')
     *  // Sunday to Thursday
     */

/**
     * Every WeekDay At
     * @param {number|number[]} hoursOfTheDay - Hours of the day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour
     * @param {number|string} startDay - Starting day
     * @param {number|string} endDay - Ending day
     * @returns {string}
     */

/**
     * Every Weekend
     * @param {number|string} startDay - Starting day (Monday=1, Sunday=0)
     * @param {number|string} endDay - Starting day (Monday=1, Sunday=0)
     * @returns {string}
     *
     * @example
     * CronTime.everyWeekend()
     *  // Saturday and Sunday
     * CronTime.everyWeekend('friday', 'saturday')
     *  // Friday and Saturday
     */

/**
     * Every Weekend At
     * @param {number|number[]} hoursOfTheDay - Hours of the day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour
     * @param {number|string} startDay - Starting day
     * @param {number|string} endDay - Ending day
     * @returns {string}
     */

/**
     * Every Year
     */

/**
     * Every Year In
     * @param {number|number[]} monthsOfTheYear  - Months of the year
     * @param daysOfTheMonth - Days of the month
     * @param hoursOfTheDay - Hours of the day
     * @param minutesOfTheHour - Minutes of the hour.
     */

/**
     * Every nth Days after
     * @param hoursOfDay
     * @param $minutesOfDay
     */

/**
     * Every nth Hour
     */

/**
     * Every nth Minute
     */

/**
     * Every nth Time
     * @return {EveryTime}
     * @param interval
     */

/**
     * Get Cron day string, with an option of setting: `hoursOfTheDay and minutesOfTheHour`
     * @param hoursOfTheDay
     * @param minutesOfTheHour
     */

/**
     * Get cron hour String.
     */

/**
     * Get cron minute string.
     */

/**
     * Get the integer representation of day string.
     * @param {string|number} day
     * @return {number}
     * @example
     *  Helpers.dayToInt('sunday') // 0
     *  Helpers.dayToInt('monday') // 1
     */

/**
     * Get the integer representation of multiple day strings.
     * @param days
     */

/**
     * It is not normally acceptable to add click and key handlers to non-interactive
     * elements as this is an accessibility anti-pattern. However, because this
     * instance is to enable light dismiss functionality instead of creating an
     * inaccessible custom element, we can add role="presentation" so that there
     * are no negative impacts to assistive technologies.
     */

/**
     * On Specific Days
     * @param {(string|number)[]} days
     */

/**
     * On Specific Days At
     * @param {(string|number)[]} days
     * @param {number|number[]} hoursOfTheDay - Hours of the Day
     * @param {number|number[]} minutesOfTheHour - Minutes of the hour
     */

/**
     * Parses out the # special character for the dayOfWeek field & adds it to options.
     *
     * @param {String} val
     * @return {String}
     * @private
     */

/**
     * Prior to zod@1.0.12 there was a bug in the
     * inferred type of merged objects. Please
     * upgrade if you are experiencing issues.
     */

/**
     * Put a character in a string using position.
     * @param {number} position
     * @param {*} char
     * @param {string} str
     */

/**
     * Similar as for setting initial state value.
     * Additionally we are checking if the default value is a function,
     * it is used in checkbox fields, where fields with same name and
     * defaultIsChecked should create array of values. In this situation we can't
     * override the default value on re-registering, but also we don't need to change
     * the key prop to re-run validation.
     */

/**
     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
     * have a different value for each object in the union.
     * @param discriminator the name of the discriminator property
     * @param types an array of object schemas
     * @param params
     */

/**
     * This span exists to off-load animations from the circle element,
     * which were causing performance issues (style recalculations)
     * on Safari and older versions of Chrome.
     *
     * This can be removed and styles placed back on the circle element once
     * Safari fixes this bug and off-loads rendering to the GPU from the CPU.
     */

/**
     * Tick
     */

/**
   * "Set" the DateTime's zone to UTC. Returns a newly-constructed DateTime.
   *
   * Equivalent to {@link DateTime#setZone}('utc')
   * @param {number} [offset=0] - optionally, an offset from UTC in minutes
   * @param {Object} [opts={}] - options to pass to `setZone()`
   * @return {DateTime}
   */

/**
   * "Set" the DateTime's zone to specified zone. Returns a newly-constructed DateTime.
   *
   * By default, the setter keeps the underlying time the same (as in, the same timestamp), but the new instance will report different local times and consider DSTs when making computations, as with {@link DateTime#plus}. You may wish to use {@link DateTime#toLocal} and {@link DateTime#toUTC} which provide simple convenience wrappers for commonly used zones.
   * @param {string|Zone} [zone='local'] - a zone identifier. As a string, that can be any IANA zone supported by the host environment, or a fixed-offset name of the form 'UTC+3', or the strings 'local' or 'utc'. You may also supply an instance of a {@link DateTime#Zone} class.
   * @param {Object} opts - options
   * @param {boolean} [opts.keepLocalTime=false] - If true, adjust the underlying time so that the local time stays the same, but in the target zone. You should rarely need this.
   * @return {DateTime}
   */

/**
   * "Set" the DateTime's zone to the host's local zone. Returns a newly-constructed DateTime.
   *
   * Equivalent to `setZone('local')`
   * @return {DateTime}
   */

/**
   * "Set" the locale and/or numberingSystem.  Returns a newly-constructed Duration.
   * @example dur.reconfigure({ locale: 'en-GB' })
   * @return {Duration}
   */

/**
   * "Set" the locale, numberingSystem, or outputCalendar. Returns a newly-constructed DateTime.
   * @param {Object} properties - the properties to set
   * @example DateTime.local(2017, 5, 25).reconfigure({ locale: 'en-GB' })
   * @return {DateTime}
   */

/**
   * "Set" the locale. Returns a newly-constructed DateTime.
   * Just a convenient alias for reconfigure({ locale })
   * @example DateTime.local(2017, 5, 25).setLocale('en-GB')
   * @return {DateTime}
   */

/**
   * "Set" the values of specified units. Return a newly-constructed Duration.
   * @param {Object} values - a mapping of units to numbers
   * @example dur.set({ years: 2017 })
   * @example dur.set({ hours: 8, minutes: 30 })
   * @return {Duration}
   */

/**
   * "Set" the values of specified units. Returns a newly-constructed DateTime.
   * You can only set units with this method; for "setting" metadata, see {@link DateTime#reconfigure} and {@link DateTime#setZone}.
   *
   * This method also supports setting locale-based week units, i.e. `localWeekday`, `localWeekNumber` and `localWeekYear`.
   * They cannot be mixed with ISO-week units like `weekday`.
   * @param {Object} values - a mapping of units to numbers
   * @example dt.set({ year: 2017 })
   * @example dt.set({ hour: 8, minute: 30 })
   * @example dt.set({ weekday: 5 })
   * @example dt.set({ year: 2005, ordinal: 234 })
   * @return {DateTime}
   */

/**
   * "Set" this DateTime to the beginning of a unit of time.
   * @param {string} unit - The unit to go to the beginning of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
   * @param {Object} opts - options
   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week
   * @example DateTime.local(2014, 3, 3).startOf('month').toISODate(); //=> '2014-03-01'
   * @example DateTime.local(2014, 3, 3).startOf('year').toISODate(); //=> '2014-01-01'
   * @example DateTime.local(2014, 3, 3).startOf('week').toISODate(); //=> '2014-03-03', weeks always start on Mondays
   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('day').toISOTime(); //=> '00:00.000-05:00'
   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('hour').toISOTime(); //=> '05:00:00.000-05:00'
   * @return {DateTime}
   */

/**
   * "Set" this DateTime to the end (meaning the last millisecond) of a unit of time
   * @param {string} unit - The unit to go to the end of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
   * @param {Object} opts - options
   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week
   * @example DateTime.local(2014, 3, 3).endOf('month').toISO(); //=> '2014-03-31T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3).endOf('year').toISO(); //=> '2014-12-31T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3).endOf('week').toISO(); // => '2014-03-09T23:59:59.999-05:00', weeks start on Mondays
   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('day').toISO(); //=> '2014-03-03T23:59:59.999-05:00'
   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('hour').toISO(); //=> '2014-03-03T05:59:59.999-05:00'
   * @return {DateTime}
   */

/**
   * "Sets" the start and/or end dates. Returns a newly-constructed Interval.
   * @param {Object} values - the values to set
   * @param {DateTime} values.start - the starting DateTime
   * @param {DateTime} values.end - the ending DateTime
   * @return {Interval}
   */

/**
   * @access private
   */

/**
   * @deprecated use fromFormat instead
   */

/**
   * @deprecated use fromFormatExplain instead
   */

/**
   * @param {string} name - Zone name
   * @return {IANAZone}
   */

/**
   * @private
   */

/**
   * @return {WeekSettings|null}
   */

/**
   * @typedef {Object} WeekSettings
   * @property {number} firstDay
   * @property {number} minimalDays
   * @property {number[]} weekend
   */

/**
   * Add a period of time to this DateTime and return the resulting DateTime
   *
   * Adding hours, minutes, seconds, or milliseconds increases the timestamp by the right number of milliseconds. Adding days, months, or years shifts the calendar, accounting for DSTs and leap years along the way. Thus, `dt.plus({ hours: 24 })` may result in a different time than `dt.plus({ days: 1 })` if there's a DST shift in between.
   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @example DateTime.now().plus(123) //~> in 123 milliseconds
   * @example DateTime.now().plus({ minutes: 15 }) //~> in 15 minutes
   * @example DateTime.now().plus({ days: 1 }) //~> this time tomorrow
   * @example DateTime.now().plus({ days: -1 }) //~> this time yesterday
   * @example DateTime.now().plus({ hours: 3, minutes: 13 }) //~> in 3 hr, 13 min
   * @example DateTime.now().plus(Duration.fromObject({ hours: 3, minutes: 13 })) //~> in 3 hr, 13 min
   * @return {DateTime}
   */

/**
   * Align better inline with text.
   */

/**
   * All calls to the wrapped function will be batched.
   */

/**
   * Allows overriding the default locale week settings, i.e. the start of the week, the weekend and
   * how many days are required in the first week of a year.
   * Does not affect existing instances.
   *
   * @param {WeekSettings|null} weekSettings
   */

/**
   * Build a parser for `fmt` using the given locale. This parser can be passed
   * to {@link DateTime.fromFormatParser} to a parse a date in this format. This
   * can be used to optimize cases where many dates need to be parsed in a
   * specific format.
   *
   * @param {String} fmt - the format the string is expected to be in (see
   * description)
   * @param {Object} options - options used to set locale and numberingSystem
   * for parser
   * @returns {TokenParser} - opaque object to be used
   */

/**
   * Check if an object is a Duration. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * Check if an object is an Interval. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * Check if an object is an instance of DateTime. Works across context boundaries
   * @param {object} o
   * @return {boolean}
   */

/**
   * Conditionally wrap ALL portal children with Suspense behind a feature gate for safe rollout.
   *
   * This is here because in React 18 concurrent, if you suspend from _within_ a portal to a
   * suspense boundary _outside_ a portal, our portal gets in an infinite loop of re-rendering.
   */

/**
   * Convert this Duration into its representation in a different set of units.
   * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
   * @return {Duration}
   */

/**
   * Converts the input into a {@link Zone} instance.
   *
   * * If `input` is already a Zone instance, it is returned unchanged.
   * * If `input` is a string containing a valid time zone name, a Zone instance
   *   with that name is returned.
   * * If `input` is a string that doesn't refer to a known time zone, a Zone
   *   instance with {@link Zone#isValid} == false is returned.
   * * If `input is a number, a Zone instance with the specified fixed offset
   *   in minutes is returned.
   * * If `input` is `null` or `undefined`, the default zone is returned.
   * @param {string|Zone|number} [input] - the value to be converted
   * @return {Zone}
   */

/**
   * Create Duration from a number of milliseconds.
   * @param {number} count of milliseconds
   * @param {Object} opts - options for parsing
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @return {Duration}
   */

/**
   * Create a DateTime for the current instant, in the system's time zone.
   *
   * Use Settings to override these default values if needed.
   * @example DateTime.now().toISO() //~> now in the ISO format
   * @return {DateTime}
   */

/**
   * Create a DateTime from a JavaScript Date object. Uses the default zone.
   * @param {Date} date - a JavaScript Date object
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @return {DateTime}
   */

/**
   * Create a DateTime from a JavaScript object with keys like 'year' and 'hour' with reasonable defaults.
   * @param {Object} obj - the object to create the DateTime from
   * @param {number} obj.year - a year, such as 1987
   * @param {number} obj.month - a month, 1-12
   * @param {number} obj.day - a day of the month, 1-31, depending on the month
   * @param {number} obj.ordinal - day of the year, 1-365 or 366
   * @param {number} obj.weekYear - an ISO week year
   * @param {number} obj.weekNumber - an ISO week number, between 1 and 52 or 53, depending on the year
   * @param {number} obj.weekday - an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday
   * @param {number} obj.localWeekYear - a week year, according to the locale
   * @param {number} obj.localWeekNumber - a week number, between 1 and 52 or 53, depending on the year, according to the locale
   * @param {number} obj.localWeekday - a weekday, 1-7, where 1 is the first and 7 is the last day of the week, according to the locale
   * @param {number} obj.hour - hour of the day, 0-23
   * @param {number} obj.minute - minute of the hour, 0-59
   * @param {number} obj.second - second of the minute, 0-59
   * @param {number} obj.millisecond - millisecond of the second, 0-999
   * @param {Object} opts - options for creating this DateTime
   * @param {string|Zone} [opts.zone='local'] - interpret the numbers in the context of a particular zone. Can take any value taken as the first argument to setZone()
   * @param {string} [opts.locale='system\'s locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
   * @example DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25'
   * @example DateTime.fromObject({ year: 1982 }).toISODate() //=> '1982-01-01'
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }) //~> today at 10:26:06
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'utc' }),
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'local' })
   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'America/New_York' })
   * @example DateTime.fromObject({ weekYear: 2016, weekNumber: 2, weekday: 3 }).toISODate() //=> '2016-01-13'
   * @example DateTime.fromObject({ localWeekYear: 2022, localWeekNumber: 1, localWeekday: 1 }, { locale: "en-US" }).toISODate() //=> '2021-12-26'
   * @return {DateTime}
   */

/**
   * Create a DateTime from a SQL date, time, or datetime
   * Defaults to en-US if no locale has been specified, regardless of the system's locale
   * @param {string} text - the string to parse
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @example DateTime.fromSQL('2017-05-15')
   * @example DateTime.fromSQL('2017-05-15 09:12:34')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342+06:00')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles')
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles', { setZone: true })
   * @example DateTime.fromSQL('2017-05-15 09:12:34.342', { zone: 'America/Los_Angeles' })
   * @example DateTime.fromSQL('09:12:34.342')
   * @return {DateTime}
   */

/**
   * Create a DateTime from a number of milliseconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
   * @param {number} milliseconds - a number of milliseconds since 1970 UTC
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @param {string} options.weekSettings - the week settings to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime from a number of seconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
   * @param {number} seconds - a number of seconds since 1970 UTC
   * @param {Object} options - configuration options for the DateTime
   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @param {string} options.weekSettings - the week settings to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime from an HTTP header date
   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
   * @param {string} text - the HTTP header date
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since HTTP dates are always in UTC, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
   * @param {boolean} [opts.setZone=false] - override the zone with the fixed-offset zone specified in the string. For HTTP dates, this is always UTC, so this option is equivalent to setting the `zone` option to 'utc', but this option is included for consistency with similar methods.
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
   * @example DateTime.fromHTTP('Sun, 06 Nov 1994 08:49:37 GMT')
   * @example DateTime.fromHTTP('Sunday, 06-Nov-94 08:49:37 GMT')
   * @example DateTime.fromHTTP('Sun Nov  6 08:49:37 1994')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an ISO 8601 string
   * @param {string} text - the ISO string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the time to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} [opts.outputCalendar] - the output calendar to set on the resulting DateTime instance
   * @param {string} [opts.numberingSystem] - the numbering system to set on the resulting DateTime instance
   * @param {string} [opts.weekSettings] - the week settings to set on the resulting DateTime instance
   * @example DateTime.fromISO('2016-05-25T09:08:34.123')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00')
   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true})
   * @example DateTime.fromISO('2016-05-25T09:08:34.123', {zone: 'utc'})
   * @example DateTime.fromISO('2016-W05-4')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an RFC 2822 string
   * @param {string} text - the RFC 2822 string
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since the offset is always specified in the string itself, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT')
   * @example DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600')
   * @example DateTime.fromRFC2822('25 Nov 2016 13:23 Z')
   * @return {DateTime}
   */

/**
   * Create a DateTime from an input string and format parser.
   *
   * The format parser must have been created with the same locale as this call.
   *
   * @param {String} text - the string to parse
   * @param {TokenParser} formatParser - parser from {@link DateTime.buildFormatParser}
   * @param {Object} opts - options taken by fromFormat()
   * @returns {DateTime}
   */

/**
   * Create a DateTime from an input string and format string.
   * Defaults to en-US if no locale has been specified, regardless of the system's locale. For a table of tokens and their interpretations, see [here](https://moment.github.io/luxon/#/parsing?id=table-of-tokens).
   * @param {string} text - the string to parse
   * @param {string} fmt - the format the string is expected to be in (see the link below for the formats)
   * @param {Object} opts - options to affect the creation
   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
   * @return {DateTime}
   */

/**
   * Create a DateTime in UTC
   * @param {number} [year] - The calendar year. If omitted (as in, call `utc()` with no arguments), the current time will be used
   * @param {number} [month=1] - The month, 1-indexed
   * @param {number} [day=1] - The day of the month
   * @param {number} [hour=0] - The hour of the day, in 24-hour time
   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
   * @param {Object} options - configuration options for the DateTime
   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
   * @param {string} [options.outputCalendar] - the output calendar to set on the resulting DateTime instance
   * @param {string} [options.numberingSystem] - the numbering system to set on the resulting DateTime instance
   * @param {string} [options.weekSettings] - the week settings to set on the resulting DateTime instance
   * @example DateTime.utc()                                              //~> now
   * @example DateTime.utc(2017)                                          //~> 2017-01-01T00:00:00Z
   * @example DateTime.utc(2017, 3)                                       //~> 2017-03-01T00:00:00Z
   * @example DateTime.utc(2017, 3, 12)                                   //~> 2017-03-12T00:00:00Z
   * @example DateTime.utc(2017, 3, 12, 5)                                //~> 2017-03-12T05:00:00Z
   * @example DateTime.utc(2017, 3, 12, 5, 45)                            //~> 2017-03-12T05:45:00Z
   * @example DateTime.utc(2017, 3, 12, 5, 45, { locale: "fr" })          //~> 2017-03-12T05:45:00Z with a French locale
   * @example DateTime.utc(2017, 3, 12, 5, 45, 10)                        //~> 2017-03-12T05:45:10Z
   * @example DateTime.utc(2017, 3, 12, 5, 45, 10, 765, { locale: "fr" }) //~> 2017-03-12T05:45:10.765Z with a French locale
   * @return {DateTime}
   */

/**
   * Create a Duration from DurationLike.
   *
   * @param {Object | number | Duration} durationLike
   * One of:
   * - object with keys like 'years' and 'hours'.
   * - number representing milliseconds
   * - Duration instance
   * @return {Duration}
   */

/**
   * Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
   * If this object is empty then a zero milliseconds duration is returned.
   * @param {Object} obj - the object to create the DateTime from
   * @param {number} obj.years
   * @param {number} obj.quarters
   * @param {number} obj.months
   * @param {number} obj.weeks
   * @param {number} obj.days
   * @param {number} obj.hours
   * @param {number} obj.minutes
   * @param {number} obj.seconds
   * @param {number} obj.milliseconds
   * @param {Object} [opts=[]] - options for creating this Duration
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
   * @param {string} [opts.matrix=Object] - the custom conversion system to use
   * @return {Duration}
   */

/**
   * Create a Duration from an ISO 8601 duration string.
   * @param {string} text - text to parse
   * @param {Object} opts - options for parsing
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
   * @param {string} [opts.matrix=Object] - the preset conversion system to use
   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
   * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
   * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
   * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
   * @return {Duration}
   */

/**
   * Create a Duration from an ISO 8601 time string.
   * @param {string} text - text to parse
   * @param {Object} opts - options for parsing
   * @param {string} [opts.locale='en-US'] - the locale to use
   * @param {string} opts.numberingSystem - the numbering system to use
   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
   * @param {string} [opts.matrix=Object] - the conversion system to use
   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
   * @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
   * @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
   * @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
   * @example Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
   * @example Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
   * @return {Duration}
   */

/**
   * Create a local DateTime
   * @param {number} [year] - The calendar year. If omitted (as in, call `local()` with no arguments), the current time will be used
   * @param {number} [month=1] - The month, 1-indexed
   * @param {number} [day=1] - The day of the month, 1-indexed
   * @param {number} [hour=0] - The hour of the day, in 24-hour time
   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
   * @example DateTime.local()                                  //~> now
   * @example DateTime.local({ zone: "America/New_York" })      //~> now, in US east coast time
   * @example DateTime.local(2017)                              //~> 2017-01-01T00:00:00
   * @example DateTime.local(2017, 3)                           //~> 2017-03-01T00:00:00
   * @example DateTime.local(2017, 3, 12, { locale: "fr" })     //~> 2017-03-12T00:00:00, with a French locale
   * @example DateTime.local(2017, 3, 12, 5)                    //~> 2017-03-12T05:00:00
   * @example DateTime.local(2017, 3, 12, 5, { zone: "utc" })   //~> 2017-03-12T05:00:00, in UTC
   * @example DateTime.local(2017, 3, 12, 5, 45)                //~> 2017-03-12T05:45:00
   * @example DateTime.local(2017, 3, 12, 5, 45, 10)            //~> 2017-03-12T05:45:10
   * @example DateTime.local(2017, 3, 12, 5, 45, 10, 765)       //~> 2017-03-12T05:45:10.765
   * @return {DateTime}
   */

/**
   * Create an Interval from a start DateTime and a Duration to extend to.
   * @param {DateTime|Date|Object} start
   * @param {Duration|Object|number} duration - the length of the Interval.
   * @return {Interval}
   */

/**
   * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.
   * @param {DateTime|Date|Object} start
   * @param {DateTime|Date|Object} end
   * @return {Interval}
   */

/**
   * Create an Interval from an ISO 8601 string.
   * Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.
   * @param {string} text - the ISO string to parse
   * @param {Object} [opts] - options to pass {@link DateTime#fromISO} and optionally {@link Duration#fromISO}
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @return {Interval}
   */

/**
   * Create an Interval from an end DateTime and a Duration to extend backwards to.
   * @param {DateTime|Date|Object} end
   * @param {Duration|Object|number} duration - the length of the Interval.
   * @return {Interval}
   */

/**
   * Create an invalid DateTime.
   * @param {string} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent.
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {DateTime}
   */

/**
   * Create an invalid Duration.
   * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {Duration}
   */

/**
   * Create an invalid Interval.
   * @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent
   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
   * @return {Interval}
   */

/**
   * Duplicated from @atlaskit/motion/accessibility
   * because @repo/internal/styles/consistent-style-ordering
   * doesn't work well with object spreading.
   */

/**
   * Equality check
   * Two DateTimes are equal if and only if they represent the same millisecond, have the same zone and location, and are both valid.
   * To compare just the millisecond values, use `+dt1 === +dt2`.
   * @param {DateTime} other - the other DateTime
   * @return {boolean}
   */

/**
   * Equality check
   * Two Durations are equal iff they have the same units and the same values for each unit.
   * @param {Duration} other
   * @return {boolean}
   */

/**
   * Explain how a string would be parsed by fromFormat()
   * @param {string} text - the string to parse
   * @param {string} fmt - the format the string is expected to be in (see description)
   * @param {Object} options - options taken by fromFormat()
   * @return {Object}
   */

/**
   * Get  the locale of a Duration, such 'en-GB'
   * @type {string}
   */

/**
   * Get a singleton instance of UTC
   * @return {FixedOffsetZone}
   */

/**
   * Get a singleton instance of the local zone
   * @return {SystemZone}
   */

/**
   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
   * @param {string} s - The offset string to parse
   * @example FixedOffsetZone.parseSpecifier("UTC+6")
   * @example FixedOffsetZone.parseSpecifier("UTC+06")
   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
   * @return {FixedOffsetZone}
   */

/**
   * Get an instance with a specified offset
   * @param {number} offset - The offset in minutes
   * @return {FixedOffsetZone}
   */

/**
   * Get the UTC offset of this DateTime in minutes
   * @example DateTime.now().offset //=> -240
   * @example DateTime.utc().offset //=> 0
   * @type {number}
   */

/**
   * Get the callback for returning the current timestamp.
   * @type {function}
   */

/**
   * Get the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
   * @type {number}
   */

/**
   * Get the day of the month (1-30ish).
   * @example DateTime.local(2017, 5, 25).day //=> 25
   * @type {number}
   */

/**
   * Get the day of the week according to the locale.
   * 1 is the first day of the week and 7 is the last day of the week.
   * If the locale assigns Sunday as the first day of the week, then a date which is a Sunday will return 1,
   * @returns {number}
   */

/**
   * Get the day of the week.
   * 1 is Monday and 7 is Sunday
   * @see https://en.wikipedia.org/wiki/ISO_week_date
   * @example DateTime.local(2014, 11, 31).weekday //=> 4
   * @type {number}
   */

/**
   * Get the days.
   * @type {number}
   */

/**
   * Get the default locale to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Get the default numbering system to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Get the default output calendar to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Get the default time zone object currently used to create DateTimes. Does not affect existing instances.
   * The default value is the system's time zone (the one set on the machine that runs this code).
   * @type {Zone}
   */

/**
   * Get the hour of the day (0-23).
   * @example DateTime.local(2017, 5, 25, 9).hour //=> 9
   * @type {number}
   */

/**
   * Get the hours.
   * @type {number}
   */

/**
   * Get the human readable long month name, such as 'October'.
   * Defaults to the system's locale if no locale has been specified
   * @example DateTime.local(2017, 10, 30).monthLong //=> October
   * @type {string}
   */

/**
   * Get the human readable long weekday, such as 'Monday'.
   * Defaults to the system's locale if no locale has been specified
   * @example DateTime.local(2017, 10, 30).weekdayLong //=> Monday
   * @type {string}
   */

/**
   * Get the human readable short month name, such as 'Oct'.
   * Defaults to the system's locale if no locale has been specified
   * @example DateTime.local(2017, 10, 30).monthShort //=> Oct
   * @type {string}
   */

/**
   * Get the human readable short weekday, such as 'Mon'.
   * Defaults to the system's locale if no locale has been specified
   * @example DateTime.local(2017, 10, 30).weekdayShort //=> Mon
   * @type {string}
   */

/**
   * Get the locale of a DateTime, such 'en-GB'. The locale is used when formatting the DateTime
   *
   * @type {string}
   */

/**
   * Get the long human name for the zone's current offset, for example "Eastern Standard Time" or "Eastern Daylight Time".
   * Defaults to the system's locale if no locale has been specified
   * @type {string}
   */

/**
   * Get the millisecond of the second (0-999).
   * @example DateTime.local(2017, 5, 25, 9, 30, 52, 654).millisecond //=> 654
   * @type {number}
   */

/**
   * Get the milliseconds.
   * @return {number}
   */

/**
   * Get the minimum number of days necessary in a week before it is considered part of the next year according
   * to the given locale.
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @returns {number}
   */

/**
   * Get the minute of the hour (0-59).
   * @example DateTime.local(2017, 5, 25, 9, 30).minute //=> 30
   * @type {number}
   */

/**
   * Get the minutes.
   * @type {number}
   */

/**
   * Get the month (1-12).
   * @example DateTime.local(2017, 5, 25).month //=> 5
   * @type {number}
   */

/**
   * Get the months.
   * @type {number}
   */

/**
   * Get the name of the time zone.
   * @type {string}
   */

/**
   * Get the numbering system of a DateTime, such 'beng'. The numbering system is used when formatting the DateTime
   *
   * @type {string}
   */

/**
   * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
   *
   * @type {string}
   */

/**
   * Get the ordinal (meaning the day of the year)
   * @example DateTime.local(2017, 5, 25).ordinal //=> 145
   * @type {number|DateTime}
   */

/**
   * Get the output calendar of a DateTime, such 'islamic'. The output calendar is used when formatting the DateTime
   *
   * @type {string}
   */

/**
   * Get the quarter
   * @example DateTime.local(2017, 5, 25).quarter //=> 2
   * @type {number}
   */

/**
   * Get the quarters.
   * @type {number}
   */

/**
   * Get the second of the minute (0-59).
   * @example DateTime.local(2017, 5, 25, 9, 30, 52).second //=> 52
   * @type {number}
   */

/**
   * Get the seconds.
   * @return {number}
   */

/**
   * Get the short human name for the zone's current offset, for example "EST" or "EDT".
   * Defaults to the system's locale if no locale has been specified
   * @type {string}
   */

/**
   * Get the time zone associated with this DateTime.
   * @type {Zone}
   */

/**
   * Get the value of unit.
   * @param {string} unit - a unit such as 'minute' or 'day'
   * @example DateTime.local(2017, 7, 4).get('month'); //=> 7
   * @example DateTime.local(2017, 7, 4).get('day'); //=> 4
   * @return {number}
   */

/**
   * Get the value of unit.
   * @param {string} unit - a unit such as 'minute' or 'day'
   * @example Duration.fromObject({years: 2, days: 3}).get('years') //=> 2
   * @example Duration.fromObject({years: 2, days: 3}).get('months') //=> 0
   * @example Duration.fromObject({years: 2, days: 3}).get('days') //=> 3
   * @return {number}
   */

/**
   * Get the week number of the week year (1-52ish).
   * @see https://en.wikipedia.org/wiki/ISO_week_date
   * @example DateTime.local(2017, 5, 25).weekNumber //=> 21
   * @type {number}
   */

/**
   * Get the week number of the week year according to the locale. Different locales assign week numbers differently,
   * because the week can start on different days of the week (see localWeekday) and because a different number of days
   * is required for a week to count as the first week of a year.
   * @returns {number}
   */

/**
   * Get the week year
   * @see https://en.wikipedia.org/wiki/ISO_week_date
   * @example DateTime.local(2014, 12, 31).weekYear //=> 2015
   * @type {number}
   */

/**
   * Get the week year according to the locale. Different locales assign week numbers (and therefor week years)
   * differently, see localWeekNumber.
   * @returns {number}
   */

/**
   * Get the weekday on which the week starts according to the given locale.
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @returns {number} the start of the week, 1 for Monday through 7 for Sunday
   */

/**
   * Get the weekdays, which are considered the weekend according to the given locale
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @returns {number[]} an array of weekdays, 1 for Monday through 7 for Sunday
   */

/**
   * Get the weeks
   * @type {number}
   */

/**
   * Get the year
   * @example DateTime.local(2017, 5, 25).year //=> 2017
   * @type {number}
   */

/**
   * Get the years.
   * @type {number}
   */

/**
   * Get those DateTimes which have the same local time as this DateTime, but a different offset from UTC
   * in this DateTime's zone. During DST changes local time can be ambiguous, for example
   * `2023-10-29T02:30:00` in `Europe/Berlin` can have offset `+01:00` or `+02:00`.
   * This method will return both possible DateTimes if this DateTime's local time is ambiguous.
   * @returns {DateTime[]}
   */

/**
   * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
   * @type {boolean}
   */

/**
   * Get whether the DateTime is in a DST.
   * @type {boolean}
   */

/**
   * Get whether this zone's offset ever changes, as in a DST.
   * @type {boolean}
   */

/**
   * Helper function that checks if 'L' is in the array
   *
   * @param {Array} expressions
   */

/**
   * Helps determine if the provided date is the correct nth occurence of the
   * desired day of week.
   *
   * @param {CronDate} date
   * @param {Number} nthDayOfWeek
   * @return {Boolean}
   * @private
   */

/**
   * If the text is already wrapped and applies no props we can just
   * render the children directly as a fragment.
   */

/**
   * Internally, Theme uses React Context, with internal providers and consumers.
   * The React Context passes only a function that gets props, and turns them into tokens. This
   * function gets mixed as more Providers with their own themes are added. This mixed function
   * is ultimately picked up by Consumers, which implement a context consumer internally to fetch
   * the theme.
   */

/**
   * Make this Duration longer by the specified amount. Return a newly-constructed Duration.
   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @return {Duration}
   */

/**
   * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   * @return {Duration}
   */

/**
   * Match field value
   *
   * @param {String} value
   * @param {Array} sequence
   * @return {Boolean}
   * @private
   */

/**
   * Merge an array of Intervals into a equivalent minimal set of Intervals.
   * Combines overlapping and adjacent Intervals.
   * @param {Array} intervals
   * @return {Array}
   */

/**
   * NOTE: This is a workaround for the test case written in Jira where the stateChildren is a boolean value because
   * useState is mocked to return a boolean value.
   */

/**
   * Parse range
   *
   * @param {String} val
   * @param {Number} repeatInterval Repetition interval
   * @return {Array}
   * @private
   */

/**
   * Parse repetition interval
   *
   * @param {String} val
   * @return {Array}
   */

/**
   * Parse sequence
   *
   * @param {String} val
   * @return {Array}
   * @private
   */

/**
   * Produce the format string for a set of options
   * @param formatOpts
   * @param localeOpts
   * @returns {string}
   */

/**
   * Produce the the fully expanded format token for the locale
   * Does NOT quote characters, so quoted tokens will not round trip correctly
   * @param fmt
   * @param localeOpts
   * @returns {string}
   */

/**
   * Reduce this Duration to its canonical representation in its current units.
   * Assuming the overall value of the Duration is positive, this means:
   * - excessive values for lower-order units are converted to higher-order units (if possible, see first and second example)
   * - negative lower-order units are converted to higher order units (there must be such a higher order unit, otherwise
   *   the overall value would be negative, see third example)
   * - fractional values for higher-order units are converted to lower-order units (if possible, see fourth example)
   *
   * If the overall value is negative, the result of this method is equivalent to `this.negate().normalize().negate()`.
   * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
   * @example Duration.fromObject({ days: 5000 }).normalize().toObject() //=> { days: 5000 }
   * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
   * @example Duration.fromObject({ years: 2.5, days: 0, hours: 0 }).normalize().toObject() //=> { years: 2, days: 182, hours: 12 }
   * @return {Duration}
   */

/**
   * Rescale units to its largest representation
   * @example Duration.fromObject({ milliseconds: 90000 }).rescale().toObject() //=> { minutes: 1, seconds: 30 }
   * @return {Duration}
   */

/**
   * Reset Luxon's global caches. Should only be necessary in testing scenarios.
   * @return {void}
   */

/**
   * Reset local caches. Should only be necessary in testing scenarios.
   * @return {void}
   */

/**
   * Return a Duration representing the time spanned by this interval.
   * @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }
   * @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }
   * @return {Duration}
   */

/**
   * Return an Interval representing the intersection of this Interval and the specified Interval.
   * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.
   * Returns null if the intersection is empty, meaning, the intervals don't intersect.
   * @param {Interval} other
   * @return {Interval}
   */

/**
   * Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.
   * @param {...Interval} intervals
   * @return {Array}
   */

/**
   * Return an Interval representing the union of this Interval and the specified Interval.
   * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.
   * @param {Interval} other
   * @return {Interval}
   */

/**
   * Return an Interval spanning between this DateTime and another DateTime
   * @param {DateTime} otherDateTime - the other end point of the Interval
   * @return {Interval}
   */

/**
   * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.
   * @param {Array} intervals
   * @return {Array}
   */

/**
   * Return an array of eras, such as ['BC', 'AD']. The locale can be specified, but the calendar system is always Gregorian.
   * @param {string} [length='short'] - the length of the era representation, such as "short" or "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @example Info.eras() //=> [ 'BC', 'AD' ]
   * @example Info.eras('long') //=> [ 'Before Christ', 'Anno Domini' ]
   * @example Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ]
   * @return {Array}
   */

/**
   * Return an array of format month names.
   * Format months differ from standalone months in that they're meant to appear next to the day of the month. In some languages, that
   * changes the string.
   * See {@link Info#months}
   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @param {string} [opts.outputCalendar='gregory'] - the calendar
   * @return {Array}
   */

/**
   * Return an array of format week names.
   * Format weekdays differ from standalone weekdays in that they're meant to appear next to more date information. In some languages, that
   * changes the string.
   * See {@link Info#weekdays}
   * @param {string} [length='long'] - the length of the month representation, such as "narrow", "short", "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale=null] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @return {Array}
   */

/**
   * Return an array of meridiems.
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @example Info.meridiems() //=> [ 'AM', 'PM' ]
   * @example Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ]
   * @return {Array}
   */

/**
   * Return an array of standalone month names.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @param {string} [opts.outputCalendar='gregory'] - the calendar
   * @example Info.months()[0] //=> 'January'
   * @example Info.months('short')[0] //=> 'Jan'
   * @example Info.months('numeric')[0] //=> '1'
   * @example Info.months('short', { locale: 'fr-CA' } )[0] //=> 'janv.'
   * @example Info.months('numeric', { locale: 'ar' })[0] //=> '١'
   * @example Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I'
   * @return {Array}
   */

/**
   * Return an array of standalone week names.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param {string} [length='long'] - the length of the weekday representation, such as "narrow", "short", "long".
   * @param {Object} opts - options
   * @param {string} [opts.locale] - the locale code
   * @param {string} [opts.numberingSystem=null] - the numbering system
   * @param {string} [opts.locObj=null] - an existing locale object to use
   * @example Info.weekdays()[0] //=> 'Monday'
   * @example Info.weekdays('short')[0] //=> 'Mon'
   * @example Info.weekdays('short', { locale: 'fr-CA' })[0] //=> 'lun.'
   * @example Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين'
   * @return {Array}
   */

/**
   * Return the difference between this DateTime and right now.
   * See {@link DateTime#diff}
   * @param {string|string[]} [unit=['milliseconds']] - the unit or units units (such as 'hours' or 'days') to include in the duration
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @return {Duration}
   */

/**
   * Return the difference between two DateTimes as a Duration.
   * @param {DateTime} otherDateTime - the DateTime to compare this one to
   * @param {string|string[]} [unit=['milliseconds']] - the unit or array of units (such as 'hours' or 'days') to include in the duration.
   * @param {Object} opts - options that affect the creation of the Duration
   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
   * @example
   * var i1 = DateTime.fromISO('1982-05-25T09:45'),
   *     i2 = DateTime.fromISO('1983-10-14T10:30');
   * i2.diff(i1).toObject() //=> { milliseconds: 43807500000 }
   * i2.diff(i1, 'hours').toObject() //=> { hours: 12168.75 }
   * i2.diff(i1, ['months', 'days']).toObject() //=> { months: 16, days: 19.03125 }
   * i2.diff(i1, ['months', 'days', 'hours']).toObject() //=> { months: 16, days: 19, hours: 0.75 }
   * @return {Duration}
   */

/**
   * Return the length of the duration in the specified unit.
   * @param {string} unit - a unit such as 'minutes' or 'days'
   * @example Duration.fromObject({years: 1}).as('days') //=> 365
   * @example Duration.fromObject({years: 1}).as('months') //=> 12
   * @example Duration.fromObject({hours: 60}).as('days') //=> 2.5
   * @return {number}
   */

/**
   * Return the max of several date times
   * @param {...DateTime} dateTimes - the DateTimes from which to choose the maximum
   * @return {DateTime} the max DateTime, or undefined if called with no argument
   */

/**
   * Return the min of several date times
   * @param {...DateTime} dateTimes - the DateTimes from which to choose the minimum
   * @return {DateTime} the min DateTime, or undefined if called with no argument
   */

/**
   * Return the negative of this Duration.
   * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
   * @return {Duration}
   */

/**
   * Return the offset in minutes for this zone at the specified timestamp.
   *
   * For fixed offset zones, this is constant and does not depend on a timestamp.
   * @override
   * @return {number}
   */

/**
   * Return the offset in minutes for this zone at the specified timestamp.
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to compute the offset
   * @return {number}
   */

/**
   * Return the offset in minutes for this zone at the specified timestamp.
   * @override
   * @param {number} ts - Epoch milliseconds for which to compute the offset
   * @return {number}
   */

/**
   * Return the set of available features in this environment.
   * Some features of Luxon are not available in all environments. For example, on older browsers, relative time formatting support is not available. Use this function to figure out if that's the case.
   * Keys:
   * * `relative`: whether this environment supports relative time formatting
   * * `localeWeek`: whether this environment supports different weekdays for the start of the week based on the locale
   * @example Info.features() //=> { relative: false, localeWeek: true }
   * @return {Object}
   */

/**
   * Return whether the specified zone contains a DST.
   * @param {string|Zone} [zone='local'] - Zone to check. Defaults to the environment's local zone.
   * @return {boolean}
   */

/**
   * Return whether the specified zone is a valid IANA specifier.
   * @param {string} zone - Zone to check
   * @return {boolean}
   */

/**
   * Return whether this DateTime is in the same unit of time as another DateTime.
   * Higher-order units must also be identical for this function to return `true`.
   * Note that time zones are **ignored** in this comparison, which compares the **local** calendar time. Use {@link DateTime#setZone} to convert one of the dates if needed.
   * @param {DateTime} otherDateTime - the other DateTime
   * @param {string} unit - the unit of time to check sameness on
   * @param {Object} opts - options
   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; only the locale of this DateTime is used
   * @example DateTime.now().hasSame(otherDT, 'day'); //~> true if otherDT is in the same current calendar day
   * @return {boolean}
   */

/**
   * Return whether this Interval contains the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Interval has the same start and end DateTimes.
   * @return {boolean}
   */

/**
   * Return whether this Interval has the same start and end as the specified Interval.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval overlaps with the specified Interval
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's end is adjacent to the specified Interval's start.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's end is before the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Interval's start is adjacent to the specified Interval's end.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Return whether this Interval's start is after the specified DateTime.
   * @param {DateTime} dateTime
   * @return {boolean}
   */

/**
   * Return whether this Zone is equal to another zone
   * @abstract
   * @param {Zone} otherZone - the zone to compare
   * @return {boolean}
   */

/**
   * Return whether this Zone is equal to another zone
   * @override
   * @param {Zone} otherZone - the zone to compare
   * @return {boolean}
   */

/**
   * Return whether this Zone is equal to another zone (i.e. also fixed and same offset)
   * @override
   * @param {Zone} otherZone - the zone to compare
   * @return {boolean}
   */

/**
   * Return whether this Zone is valid.
   * @abstract
   * @type {boolean}
   */

/**
   * Return whether this Zone is valid.
   * @override
   * @type {boolean}
   */

/**
   * Return whether this Zone is valid:
   * All fixed offset zones are valid.
   * @override
   * @type {boolean}
   */

/**
   * Returns a BSON serializable equivalent to this DateTime.
   * @return {Date}
   */

/**
   * Returns a JavaScript Date equivalent to this DateTime.
   * @return {Date}
   */

/**
   * Returns a JavaScript object with this DateTime's year, month, day, and so on.
   * @param opts - options for generating the object
   * @param {boolean} [opts.includeConfig=false] - include configuration attributes in the output
   * @example DateTime.now().toObject() //=> { year: 2017, month: 4, day: 22, hour: 20, minute: 49, second: 42, millisecond: 268 }
   * @return {Object}
   */

/**
   * Returns a JavaScript object with this Duration's values.
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 }
   * @return {Object}
   */

/**
   * Returns a localized string representing this Interval. Accepts the same options as the
   * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as
   * {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method
   * is browser-specific, but in general it will return an appropriate representation of the
   * Interval in the assigned locale. Defaults to the system's locale if no locale has been
   * specified.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param {Object} [formatOpts=DateTime.DATE_SHORT] - Either a DateTime preset or
   * Intl.DateTimeFormat constructor options.
   * @param {Object} opts - Options to override the configuration of the start DateTime.
   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022
   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022
   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022
   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM
   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> Mon, Nov 07, 6:00 – 8:00 p
   * @return {string}
   */

/**
   * Returns a localized string representing this date. Accepts the same options as the Intl.DateTimeFormat constructor and any presets defined by Luxon, such as `DateTime.DATE_FULL` or `DateTime.TIME_SIMPLE`.
   * The exact behavior of this method is browser-specific, but in general it will return an appropriate representation
   * of the DateTime in the assigned locale.
   * Defaults to the system's locale if no locale has been specified
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
   * @param formatOpts {Object} - Intl.DateTimeFormat constructor options and configuration options
   * @param {Object} opts - opts to override the configuration options on this DateTime
   * @example DateTime.now().toLocaleString(); //=> 4/20/2017
   * @example DateTime.now().setLocale('en-gb').toLocaleString(); //=> '20/04/2017'
   * @example DateTime.now().toLocaleString(DateTime.DATE_FULL); //=> 'April 20, 2017'
   * @example DateTime.now().toLocaleString(DateTime.DATE_FULL, { locale: 'fr' }); //=> '28 août 2022'
   * @example DateTime.now().toLocaleString(DateTime.TIME_SIMPLE); //=> '11:32 AM'
   * @example DateTime.now().toLocaleString(DateTime.DATETIME_SHORT); //=> '4/20/2017, 11:32 AM'
   * @example DateTime.now().toLocaleString({ weekday: 'long', month: 'long', day: '2-digit' }); //=> 'Thursday, April 20'
   * @example DateTime.now().toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> 'Thu, Apr 20, 11:27 AM'
   * @example DateTime.now().toLocaleString({ hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }); //=> '11:32'
   * @return {string}
   */

/**
   * Returns a string representation of a Duration with all units included.
   * To modify its behavior, use `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant.
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
   * @param {Object} opts - Formatting options. Accepts the same keys as the options parameter of the native `Intl.NumberFormat` constructor, as well as `listStyle`.
   * @param {string} [opts.listStyle='narrow'] - How to format the merged list. Corresponds to the `style` property of the options parameter of the native `Intl.ListFormat` constructor.
   * @example
   * ```js
   * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 })
   * dur.toHuman() //=> '1 day, 5 hours, 6 minutes'
   * dur.toHuman({ listStyle: "long" }) //=> '1 day, 5 hours, and 6 minutes'
   * dur.toHuman({ unitDisplay: "short" }) //=> '1 day, 5 hr, 6 min'
   * ```
   */

/**
   * Returns a string representation of a this time relative to now, such as "in two days". Can only internationalize if your
   * platform supports Intl.RelativeTimeFormat. Rounds down by default.
   * @param {Object} options - options that affect the output
   * @param {DateTime} [options.base=DateTime.now()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
   * @param {string} [options.style="long"] - the style of units, must be "long", "short", or "narrow"
   * @param {string|string[]} options.unit - use a specific unit or array of units; if omitted, or an array, the method will pick the best unit. Use an array or one of "years", "quarters", "months", "weeks", "days", "hours", "minutes", or "seconds"
   * @param {boolean} [options.round=true] - whether to round the numbers in the output.
   * @param {number} [options.padding=0] - padding in milliseconds. This allows you to round up the result if it fits inside the threshold. Don't use in combination with {round: false} because the decimal output will include the padding.
   * @param {string} options.locale - override the locale of this DateTime
   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
   * @example DateTime.now().plus({ days: 1 }).toRelative() //=> "in 1 day"
   * @example DateTime.now().setLocale("es").toRelative({ days: 1 }) //=> "dentro de 1 día"
   * @example DateTime.now().plus({ days: 1 }).toRelative({ locale: "fr" }) //=> "dans 23 heures"
   * @example DateTime.now().minus({ days: 2 }).toRelative() //=> "2 days ago"
   * @example DateTime.now().minus({ days: 2 }).toRelative({ unit: "hours" }) //=> "48 hours ago"
   * @example DateTime.now().minus({ hours: 36 }).toRelative({ round: false }) //=> "1.5 days ago"
   */

/**
   * Returns a string representation of this DateTime appropriate for debugging
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for the REPL.
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in HTTP headers. The output is always expressed in GMT.
   * Specifically, the string conforms to RFC 1123.
   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
   * @example DateTime.utc(2014, 7, 13).toHTTP() //=> 'Sun, 13 Jul 2014 00:00:00 GMT'
   * @example DateTime.utc(2014, 7, 13, 19).toHTTP() //=> 'Sun, 13 Jul 2014 19:00:00 GMT'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL Date
   * @example DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL DateTime
   * @param {Object} opts - options
   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {boolean} [opts.includeOffsetSpace=true] - include the space between the time and the offset, such as '05:15:16.345 -04:00'
   * @example DateTime.utc(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 Z'
   * @example DateTime.local(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 -04:00'
   * @example DateTime.local(2014, 7, 13).toSQL({ includeOffset: false }) //=> '2014-07-13 00:00:00.000'
   * @example DateTime.local(2014, 7, 13).toSQL({ includeZone: true }) //=> '2014-07-13 00:00:00.000 America/New_York'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime appropriate for use in SQL Time
   * @param {Object} opts - options
   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {boolean} [opts.includeOffsetSpace=true] - include the space between the time and the offset, such as '05:15:16.345 -04:00'
   * @example DateTime.utc().toSQL() //=> '05:15:16.345'
   * @example DateTime.now().toSQL() //=> '05:15:16.345 -04:00'
   * @example DateTime.now().toSQL({ includeOffset: false }) //=> '05:15:16.345'
   * @example DateTime.now().toSQL({ includeZone: false }) //=> '05:15:16.345 America/New_York'
   * @return {string}
   */

/**
   * Returns a string representation of this DateTime formatted according to the specified format string.
   * **You may not want this.** See {@link DateTime#toLocaleString} for a more flexible formatting tool. For a table of tokens and their interpretations, see [here](https://moment.github.io/luxon/#/formatting?id=table-of-tokens).
   * Defaults to en-US if no locale has been specified, regardless of the system's locale.
   * @param {string} fmt - the format string
   * @param {Object} opts - opts to override the configuration options on this DateTime
   * @example DateTime.now().toFormat('yyyy LLL dd') //=> '2017 Apr 22'
   * @example DateTime.now().setLocale('fr').toFormat('yyyy LLL dd') //=> '2017 avr. 22'
   * @example DateTime.now().toFormat('yyyy LLL dd', { locale: "fr" }) //=> '2017 avr. 22'
   * @example DateTime.now().toFormat("HH 'hours and' mm 'minutes'") //=> '20 hours and 55 minutes'
   * @return {string}
   */

/**
   * Returns a string representation of this Duration appropriate for the REPL.
   * @return {string}
   */

/**
   * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens:
   * * `S` for milliseconds
   * * `s` for seconds
   * * `m` for minutes
   * * `h` for hours
   * * `d` for days
   * * `w` for weeks
   * * `M` for months
   * * `y` for years
   * Notes:
   * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits
   * * Tokens can be escaped by wrapping with single quotes.
   * * The duration will be converted to the set of units in the format string using {@link Duration#shiftTo} and the Durations's conversion accuracy setting.
   * @param {string} fmt - the format string
   * @param {Object} opts - options
   * @param {boolean} [opts.floor=true] - floor numerical values
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
   * @return {string}
   */

/**
   * Returns a string representation of this Interval appropriate for debugging.
   * @return {string}
   */

/**
   * Returns a string representation of this Interval appropriate for the REPL.
   * @return {string}
   */

/**
   * Returns a string representation of this Interval formatted according to the specified format
   * string. **You may not want this.** See {@link Interval#toLocaleString} for a more flexible
   * formatting tool.
   * @param {string} dateFormat - The format string. This string formats the start and end time.
   * See {@link DateTime#toFormat} for details.
   * @param {Object} opts - Options.
   * @param {string} [opts.separator =  ' – '] - A separator to place between the start and end
   * representations.
   * @return {string}
   */

/**
   * Returns a string representation of this date relative to today, such as "yesterday" or "next month".
   * Only internationalizes on platforms that supports Intl.RelativeTimeFormat.
   * @param {Object} options - options that affect the output
   * @param {DateTime} [options.base=DateTime.now()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
   * @param {string} options.locale - override the locale of this DateTime
   * @param {string} options.unit - use a specific unit; if omitted, the method will pick the unit. Use one of "years", "quarters", "months", "weeks", or "days"
   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
   * @example DateTime.now().plus({ days: 1 }).toRelativeCalendar() //=> "tomorrow"
   * @example DateTime.now().setLocale("es").plus({ days: 1 }).toRelative() //=> ""mañana"
   * @example DateTime.now().plus({ days: 1 }).toRelativeCalendar({ locale: "fr" }) //=> "demain"
   * @example DateTime.now().minus({ days: 2 }).toRelativeCalendar() //=> "2 days ago"
   */

/**
   * Returns an ISO 8601 representation of this DateTime appropriate for use in JSON.
   * @return {string}
   */

/**
   * Returns an ISO 8601 representation of this Duration appropriate for use in JSON.
   * @return {string}
   */

/**
   * Returns an ISO 8601 representation of this Duration appropriate for use in debugging.
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of date of this Interval.
   * The time components are ignored.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime
   * @param {Object} opts - options
   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {boolean} [opts.extendedZone=false] - add the time zone format extension
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc(1983, 5, 25).toISO() //=> '1982-05-25T00:00:00.000Z'
   * @example DateTime.now().toISO() //=> '2017-04-22T20:47:05.335-04:00'
   * @example DateTime.now().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335'
   * @example DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's date component
   * @param {Object} opts - options
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25'
   * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's time component
   * @param {Object} opts - options
   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
   * @param {boolean} [opts.extendedZone=true] - add the time zone format extension
   * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime() //=> '07:34:19.361Z'
   * @example DateTime.utc().set({ hour: 7, minute: 34, seconds: 0, milliseconds: 0 }).toISOTime({ suppressSeconds: true }) //=> '07:34Z'
   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ format: 'basic' }) //=> '073419.361Z'
   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ includePrefix: true }) //=> 'T07:34:19.361Z'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this DateTime's week date
   * @example DateTime.utc(1982, 5, 25).toISOWeekDate() //=> '1982-W21-2'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this Duration, formatted as a time of day.
   * Note that this will return null if the duration is invalid, negative, or equal to or greater than 24 hours.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
   * @param {Object} opts - options
   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
   * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
   * @param {string} [opts.format='extended'] - choose between the basic and extended format
   * @example Duration.fromObject({ hours: 11 }).toISOTime() //=> '11:00:00.000'
   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressMilliseconds: true }) //=> '11:00:00'
   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressSeconds: true }) //=> '11:00'
   * @example Duration.fromObject({ hours: 11 }).toISOTime({ includePrefix: true }) //=> 'T11:00:00.000'
   * @example Duration.fromObject({ hours: 11 }).toISOTime({ format: 'basic' }) //=> '110000.000'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this Duration.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
   * @example Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S'
   * @example Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S'
   * @example Duration.fromObject({ months: 5 }).toISO() //=> 'P5M'
   * @example Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M'
   * @example Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S'
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of this Interval.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @param {Object} opts - The same options as {@link DateTime#toISO}
   * @return {string}
   */

/**
   * Returns an ISO 8601-compliant string representation of time of this Interval.
   * The date components are ignored.
   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
   * @param {Object} opts - The same options as {@link DateTime#toISO}
   * @return {string}
   */

/**
   * Returns an RFC 2822-compatible string representation of this DateTime
   * @example DateTime.utc(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 +0000'
   * @example DateTime.local(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 -0400'
   * @return {string}
   */

/**
   * Returns an array of format "parts", meaning individual tokens along with metadata. This is allows callers to post-process individual sections of the formatted output.
   * Defaults to the system's locale if no locale has been specified
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts
   * @param opts {Object} - Intl.DateTimeFormat constructor options, same as `toLocaleString`.
   * @example DateTime.now().toLocaleParts(); //=> [
   *                                   //=>   { type: 'day', value: '25' },
   *                                   //=>   { type: 'literal', value: '/' },
   *                                   //=>   { type: 'month', value: '05' },
   *                                   //=>   { type: 'literal', value: '/' },
   *                                   //=>   { type: 'year', value: '1982' }
   *                                   //=> ]
   */

/**
   * Returns an error code if this DateTime is invalid, or null if the DateTime is valid
   * @type {string}
   */

/**
   * Returns an error code if this Duration became invalid, or null if the Duration is valid
   * @return {string}
   */

/**
   * Returns an error code if this Interval is invalid, or null if the Interval is valid
   * @type {string}
   */

/**
   * Returns an explanation of why this DateTime became invalid, or null if the DateTime is valid
   * @type {string}
   */

/**
   * Returns an explanation of why this Duration became invalid, or null if the Duration is valid
   * @type {string}
   */

/**
   * Returns an explanation of why this Interval became invalid, or null if the Interval is valid
   * @type {string}
   */

/**
   * Returns an milliseconds value of this Duration.
   * @return {number}
   */

/**
   * Returns an milliseconds value of this Duration. Alias of {@link toMillis}
   * @return {number}
   */

/**
   * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.
   * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'
   * asks 'what dates are included in this interval?', not 'how many days long is this interval?'
   * @param {string} [unit='milliseconds'] - the unit of time to count.
   * @param {Object} opts - options
   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; this operation will always use the locale of the start DateTime
   * @return {number}
   */

/**
   * Returns the end of the Interval
   * @type {DateTime}
   */

/**
   * Returns the epoch milliseconds of this DateTime.
   * @return {number}
   */

/**
   * Returns the epoch milliseconds of this DateTime. Alias of {@link DateTime#toMillis}
   * @return {number}
   */

/**
   * Returns the epoch seconds (as a whole number) of this DateTime.
   * @return {number}
   */

/**
   * Returns the epoch seconds of this DateTime.
   * @return {number}
   */

/**
   * Returns the length of the Interval in the specified unit.
   * @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.
   * @return {number}
   */

/**
   * Returns the number of days in this DateTime's month
   * @example DateTime.local(2016, 2).daysInMonth //=> 29
   * @example DateTime.local(2016, 3).daysInMonth //=> 31
   * @type {number}
   */

/**
   * Returns the number of days in this DateTime's year
   * @example DateTime.local(2016).daysInYear //=> 366
   * @example DateTime.local(2013).daysInYear //=> 365
   * @type {number}
   */

/**
   * Returns the number of weeks in this DateTime's local week year
   * @example DateTime.local(2020, 6, {locale: 'en-US'}).weeksInLocalWeekYear //=> 52
   * @example DateTime.local(2020, 6, {locale: 'de-DE'}).weeksInLocalWeekYear //=> 53
   * @type {number}
   */

/**
   * Returns the number of weeks in this DateTime's year
   * @see https://en.wikipedia.org/wiki/ISO_week_date
   * @example DateTime.local(2004).weeksInWeekYear //=> 53
   * @example DateTime.local(2013).weeksInWeekYear //=> 52
   * @type {number}
   */

/**
   * Returns the offset's common name (such as EST) at the specified timestamp
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to get the name
   * @param {Object} opts - Options to affect the format
   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
   * @param {string} opts.locale - What locale to return the offset name in.
   * @return {string}
   */

/**
   * Returns the offset's common name (such as EST) at the specified timestamp
   * @override
   * @param {number} ts - Epoch milliseconds for which to get the name
   * @param {Object} opts - Options to affect the format
   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
   * @param {string} opts.locale - What locale to return the offset name in.
   * @return {string}
   */

/**
   * Returns the offset's common name at the specified timestamp.
   *
   * For fixed offset zones this equals to the zone name.
   * @override
   */

/**
   * Returns the offset's value as a string
   * @abstract
   * @param {number} ts - Epoch milliseconds for which to get the offset
   * @param {string} format - What style of offset to return.
   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
   * @return {string}
   */

/**
   * Returns the offset's value as a string
   * @override
   * @param {number} ts - Epoch milliseconds for which to get the offset
   * @param {string} format - What style of offset to return.
   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
   * @return {string}
   */

/**
   * Returns the resolved Intl options for this DateTime.
   * This is useful in understanding the behavior of formatting methods
   * @param {Object} opts - the same options as toLocaleString
   * @return {Object}
   */

/**
   * Returns the start of the Interval
   * @type {DateTime}
   */

/**
   * Returns true if this DateTime is in a leap year, false otherwise
   * @example DateTime.local(2016).isInLeapYear //=> true
   * @example DateTime.local(2013).isInLeapYear //=> false
   * @type {boolean}
   */

/**
   * Returns true if this Interval fully contains the specified Interval, specifically if the intersect (of this Interval and the other Interval) is equal to the other Interval; false otherwise.
   * @param {Interval} other
   * @return {boolean}
   */

/**
   * Returns true if this date is on a weekend according to the locale, false otherwise
   * @returns {boolean}
   */

/**
   * Returns whether the DateTime is valid. Invalid DateTimes occur when:
   * * The DateTime was created from invalid calendar information, such as the 13th month or February 30
   * * The DateTime was created by an operation on another invalid date
   * @type {boolean}
   */

/**
   * Returns whether the Duration is invalid. Invalid durations are returned by diff operations
   * on invalid DateTimes or Intervals.
   * @return {boolean}
   */

/**
   * Returns whether the offset is known to be fixed for the whole year.
   * @abstract
   * @type {boolean}
   */

/**
   * Returns whether the offset is known to be fixed for the whole year:
   * Always returns false for all IANA zones.
   * @override
   * @type {boolean}
   */

/**
   * Returns whether the offset is known to be fixed for the whole year:
   * Always returns true for all fixed offset zones.
   * @override
   * @type {boolean}
   */

/**
   * Returns whether the provided string identifies a real zone
   * @param {string} zone - The string to check
   * @example IANAZone.isValidZone("America/New_York") //=> true
   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
   * @return {boolean}
   */

/**
   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
   * @param {string} s - The string to check validity on
   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
   * @deprecated For backward compatibility, this forwards to isValidZone, better use `isValidZone()` directly instead.
   * @return {boolean}
   */

/**
   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
   * @type {boolean}
   */

/**
   * Returns whether this Interval's start and end are both in the same unit of time
   * @param {string} unit - the unit of time to check sameness on
   * @return {boolean}
   */

/**
   * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes
   * @param {function} mapFn
   * @return {Interval}
   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())
   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))
   */

/**
   * Scale this Duration by the specified amount. Return a newly-constructed Duration.
   * @param {function} fn - The function to apply to each unit. Arity is 1 or 2: the value of the unit and, optionally, the unit name. Must return a number.
   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits(x => x * 2) //=> { hours: 2, minutes: 60 }
   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits((x, u) => u === "hours" ? x * 2 : x) //=> { hours: 2, minutes: 30 }
   * @return {Duration}
   */

/**
   * Set the callback for returning the current timestamp.
   * The function should return a number, which will be interpreted as an Epoch millisecond count
   * @type {function}
   * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future
   * @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time
   */

/**
   * Set the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
   * @type {number}
   * @example Settings.twoDigitCutoffYear = 0 // all 'yy' are interpreted as 20th century
   * @example Settings.twoDigitCutoffYear = 99 // all 'yy' are interpreted as 21st century
   * @example Settings.twoDigitCutoffYear = 50 // '49' -> 2049; '50' -> 1950
   * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50
   * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50
   */

/**
   * Set the default locale to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Set the default numbering system to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Set the default output calendar to create DateTimes with. Does not affect existing instances.
   * @type {string}
   */

/**
   * Set the default time zone to create DateTimes in. Does not affect existing instances.
   * Use the value "system" to reset this value to the system's time zone.
   * @type {string}
   */

/**
   * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
   * @type {boolean}
   */

/**
   * Shift this Duration to all available units.
   * Same as shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds")
   * @return {Duration}
   */

/**
   * Split this Interval at each of the specified DateTimes
   * @param {...DateTime} dateTimes - the unit of time to count.
   * @return {Array}
   */

/**
   * Split this Interval into smaller Intervals, each of the specified length.
   * Left over time is grouped into a smaller interval
   * @param {Duration|Object|number} duration - The length of each resulting interval.
   * @return {Array}
   */

/**
   * Split this Interval into the specified number of smaller intervals.
   * @param {number} numberOfParts - The number of Intervals to divide the Interval into.
   * @return {Array}
   */

/**
   * Stop-color doesn't properly apply in chrome when the inherited/current color changes.
   * We have to initially set stop-color to inherit (either via DOM attribute or an initial CSS
   * rule) and then override it with currentColor for the color changes to be picked up.
   */

/**
   * Subtract a period of time to this DateTime and return the resulting DateTime
   * See {@link DateTime#plus}
   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
   @return {DateTime}
   */

/**
   * The IANA name of this zone, i.e. `Etc/UTC` or `Etc/GMT+/-nn`
   *
   * @override
   * @type {string}
   */

/**
   * The IANA name of this zone.
   * Defaults to `name` if not overwritten by a subclass.
   * @abstract
   * @type {string}
   */

/**
   * The Spinner animation uses a combination of two
   * css animations on two separate elements.
   */

/**
   * The Theme Provider takes regular nodes as its children, but also takes a *theme function*
   * - The theme function takes a set of props, as well as a function (getTokens) that can turn props into tokens.
   * - The getTokens function isn't called immediately - instead the props are passed
   *    through a mix of parent theming functions
   * Children of this provider will receive this mixed theme
   */

/**
   * The name of this zone (i.e. the IANA zone name).
   * @override
   * @type {string}
   */

/**
   * The name of this zone.
   * @abstract
   * @type {string}
   */

/**
   * The name of this zone.
   * All fixed zones' names always start with "UTC" (plus optional offset)
   * @override
   * @type {string}
   */

/**
   * The type of zone
   * @abstract
   * @type {string}
   */

/**
   * The type of zone. `fixed` for all instances of `FixedOffsetZone`.
   * @override
   * @type {string}
   */

/**
   * The type of zone. `iana` for all instances of `IANAZone`.
   * @override
   * @type {string}
   */

/**
   * This ensures that the element fills the viewport on mobile
   * while also allowing it to overflow if its height is larger than
   * the viewport.
   */

/**
   * This ensures that the element fills the whole header space
   * and its content does not overflow (since flex items don't
   * shrink past its content size by default).
   */

/**
   * This is to support scrolling if the modal's children are wrapped in
   * a form.
   */

/**
   * Use this method to set a custom function to batch notifications together into a single tick.
   * By default React Query will use the batch function provided by ReactDOM or React Native.
   */

/**
   * Use this method to set a custom notify function.
   * This can be used to for example wrap notifications with `React.act` while running tests.
   */

/**
   * We are going to animate this in.
   */

/**
   * When the animation completes, stay at the last frame of the animation.
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30', always 24-hour.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23 AM EDT'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23 AM Eastern Daylight Time'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23 EDT', always 24-hour.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23 Eastern Daylight Time', always 24-hour.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '09:30:23', always 24-hour.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '10/14/1983, 9:30 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like '10/14/1983, 9:30:33 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Fri, 14 Oct 1983, 9:30 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Fri, Oct 14, 1983'
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Friday, October 14, 1983, 9:30 AM Eastern Daylight Time'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Oct 14, 1983'
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Oct 14, 1983, 9:30 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Oct 14, 1983, 9:30:33 AM'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'October 14, 1983'
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'October 14, 1983, 9:30 AM EDT'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'October 14, 1983, 9:30:33 AM EDT'. Only 12-hour if the locale is.
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 'Tuesday, October 14, 1983'
   * @type {Object}
   */

/**
   * {@link DateTime#toLocaleString} format like 10/14/1983
   * @type {Object}
   */

/**
  @param t: time (elapsed)
  @param b: initial value
  @param c: amount of change
  @param d: duration
*/

/**
 *  ________________________________________________
 * | MAJOR VERSIONS WILL NOT KNOW ABOUT EACH OTHER! |
 *  ------------------------------------------------
 *
 * An array which holds references to all currently open modal dialogs.
 * This will only work for modal dialogs of the same major version,
 * as the reference will be different between them.
 *
 * E.g. V11 won't know about any from V12.
 */

/**
 * @deprecated
 *
 * Pass `fatal` into the params object instead:
 *
 * ```ts
 * z.string().custom((val) => val.length > 5, { fatal: false })
 * ```
 *
 */

/**
 * @deprecated Please use useCloseOnEscapePress from '@atlaskit/layering' instead.
 * Calls back when the escape key is pressed.
 * To be used exclusively for closing layered components.
 * Use the `isDisabled` argument to ignore closing events.
 *
 * ```js
 * useCloseOnEscapePress({
 *   onClose: () => {},
 *   isDisabled: false,
 * });
 * ```
 */

/**
 * @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-4693 Internal documentation for deprecation (no external access)}
 */

/**
 * @interface
 */

/**
 * @license React
 * react-is.production.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/**
 * @name uid
 * returns an UID associated with {item}
 * @param {Object} item - object to generate UID for
 * @param {Number} index, a fallback index
 * @example
 * uid(object) == 1;
 * uid(object) == 1;
 * uid(anotherObject) == 2;
 * uid("not object", 42) == 42
 *
 * @see {@link useUID}
 */

/**
 * @param token
 * @param {Locale} loc
 */

/**
 * @param {DateTime} dt
 */

/**
 * @private
 * @deprecated DSP-8009: This type is scheduled for deletion.
 * Please use `Box` from `@atlaskit/primitives` instead.
 */

/**
 * @private
 */

/**
 * A <Link> wrapper that knows if it's "active" or not.
 */

/**
 * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
 *
 * A DateTime comprises of:
 * * A timestamp. Each DateTime instance refers to a specific millisecond of the Unix epoch.
 * * A time zone. Each instance is considered in the context of a specific zone (by default the local system's zone).
 * * Configuration properties that effect how output strings are formatted, such as `locale`, `numberingSystem`, and `outputCalendar`.
 *
 * Here is a brief overview of the most commonly used functionality it provides:
 *
 * * **Creation**: To create a DateTime from its components, use one of its factory class methods: {@link DateTime.local}, {@link DateTime.utc}, and (most flexibly) {@link DateTime.fromObject}. To create one from a standard string format, use {@link DateTime.fromISO}, {@link DateTime.fromHTTP}, and {@link DateTime.fromRFC2822}. To create one from a custom string format, use {@link DateTime.fromFormat}. To create one from a native JS date, use {@link DateTime.fromJSDate}.
 * * **Gregorian calendar and time**: To examine the Gregorian properties of a DateTime individually (i.e as opposed to collectively through {@link DateTime#toObject}), use the {@link DateTime#year}, {@link DateTime#month},
 * {@link DateTime#day}, {@link DateTime#hour}, {@link DateTime#minute}, {@link DateTime#second}, {@link DateTime#millisecond} accessors.
 * * **Week calendar**: For ISO week calendar attributes, see the {@link DateTime#weekYear}, {@link DateTime#weekNumber}, and {@link DateTime#weekday} accessors.
 * * **Configuration** See the {@link DateTime#locale} and {@link DateTime#numberingSystem} accessors.
 * * **Transformation**: To transform the DateTime into other DateTimes, use {@link DateTime#set}, {@link DateTime#reconfigure}, {@link DateTime#setZone}, {@link DateTime#setLocale}, {@link DateTime.plus}, {@link DateTime#minus}, {@link DateTime#endOf}, {@link DateTime#startOf}, {@link DateTime#toUTC}, and {@link DateTime#toLocal}.
 * * **Output**: To convert the DateTime to other representations, use the {@link DateTime#toRelative}, {@link DateTime#toRelativeCalendar}, {@link DateTime#toJSON}, {@link DateTime#toISO}, {@link DateTime#toHTTP}, {@link DateTime#toObject}, {@link DateTime#toRFC2822}, {@link DateTime#toString}, {@link DateTime#toLocaleString}, {@link DateTime#toFormat}, {@link DateTime#toMillis} and {@link DateTime#toJSDate}.
 *
 * There's plenty others documented below. In addition, for more information on subtler topics like internationalization, time zones, alternative calendars, validity, and so on, see the external documentation.
 */

/**
 * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". Conceptually, it's just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime#plus} to add a Duration object to a DateTime, producing another DateTime.
 *
 * Here is a brief overview of commonly used methods and getters in Duration:
 *
 * * **Creation** To create a Duration, use {@link Duration.fromMillis}, {@link Duration.fromObject}, or {@link Duration.fromISO}.
 * * **Unit values** See the {@link Duration#years}, {@link Duration#months}, {@link Duration#weeks}, {@link Duration#days}, {@link Duration#hours}, {@link Duration#minutes}, {@link Duration#seconds}, {@link Duration#milliseconds} accessors.
 * * **Configuration** See  {@link Duration#locale} and {@link Duration#numberingSystem} accessors.
 * * **Transformation** To create new Durations out of old ones use {@link Duration#plus}, {@link Duration#minus}, {@link Duration#normalize}, {@link Duration#set}, {@link Duration#reconfigure}, {@link Duration#shiftTo}, and {@link Duration#negate}.
 * * **Output** To convert the Duration into other representations, see {@link Duration#as}, {@link Duration#toISO}, {@link Duration#toFormat}, and {@link Duration#toJSON}
 *
 * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation.
 */

/**
 * A provider component that propagates the `useForm` methods to all children components via [React Context](https://reactjs.org/docs/context.html) API. To be used with {@link useFormContext}.
 *
 * @remarks
 * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
 *
 * @param props - all useForm methods
 *
 * @example
 * ```tsx
 * function App() {
 *   const methods = useForm();
 *   const onSubmit = data => console.log(data);
 *
 *   return (
 *     <FormProvider {...methods} >
 *       <form onSubmit={methods.handleSubmit(onSubmit)}>
 *         <NestedInput />
 *         <input type="submit" />
 *       </form>
 *     </FormProvider>
 *   );
 * }
 *
 *  function NestedInput() {
 *   const { register } = useFormContext(); // retrieve all hook methods
 *   return <input {...register("test")} />;
 * }
 * ```
 */

/**
 * A specialized version of `_.map` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */

/**
 * A specialized version of `_.memoize` which clears the memoized function's
 * cache when it exceeds `MAX_MEMOIZE_SIZE`.
 *
 * @private
 * @param {Function} func The function to have its output memoized.
 * @returns {Function} Returns the new memoized function.
 */

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */

/**
 * A zone identified by an IANA identifier, like America/New_York
 * @implements {Zone}
 */

/**
 * A zone that failed to parse. You should never need to instantiate this.
 * @implements {Zone}
 */

/**
 * A zone with a fixed offset (meaning no DST)
 * @implements {Zone}
 */

/**
 * Adding the padding here avoids cropping the keyline on its sides.
 * The combined vertical spacing is maintained by subtracting the
 * keyline height from header and footer.
 */

/**
 * Adds a CSS class to a given element.
 * 
 * @param element the element
 * @param className the CSS class name
 */

/**
 * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.
 *
 * Here is a brief overview of the most commonly used methods and getters in Interval:
 *
 * * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}.
 * * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end.
 * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.
 * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.
 * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}
 * * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toLocaleString}, {@link Interval#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.
 */

/**
 * An empty function which does nothing.
 */

/**
 * Assigns `value` to `key` of `object` if the existing value is not equivalent
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */

/**
 * Assigns a value for a given ref, no matter of the ref format
 * @param {RefObject} ref - a callback function or ref object
 * @param value - a new value
 *
 * @see https://github.com/theKashey/use-callback-ref#assignref
 * @example
 * const refObject = useRef();
 * const refFn = (ref) => {....}
 *
 * assignRef(refObject, "refValue");
 * assignRef(refFn, "refValue");
 */

/**
 * Assigns the node to all the refs passed in the argument.
 *
 * @param refs: An array of refs (as function or ref object)
 */

/**
 * Attach the keys as a property of the regexp.
 *
 * @param  {!RegExp} re
 * @param  {Array}   keys
 * @return {!RegExp}
 */

/**
 * Automatically updates the position of the floating element when necessary.
 * Should only be called when the floating element is mounted on the DOM or
 * visible on the screen.
 * @returns cleanup function that should be invoked when the floating element is
 * removed from the DOM or hidden from the screen.
 * @see https://floating-ui.com/docs/autoUpdate
 */

/**
 * Cache for zone offset guesses (exposed for test).
 *
 * This optimizes quickDT via guessOffsetForZone to avoid repeated calls of
 * zone.offset().
 */

/**
 * Casts `value` to a path array if it's not one.
 *
 * @private
 * @param {*} value The value to inspect.
 * @param {Object} [object] The object to query keys on.
 * @returns {Array} Returns the cast property path array.
 */

/**
 * Check if local week units like localWeekday are used in obj.
 * If so, validates that they are not mixed with ISO week units and then copies them to the normal week unit properties.
 * Modifies obj in-place!
 * @param obj the object values
 */

/**
 * Check if next suitable date exists
 *
 * @public
 * @return {Boolean}
 */

/**
 * Check if previous suitable date exists
 *
 * @public
 * @return {Boolean}
 */

/**
 * Checks if `b` partially matches with `a`.
 */

/**
 * Checks if `func` has its source masked.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
 */

/**
 * Checks if `value` is a property name and not a property path.
 *
 * @private
 * @param {*} value The value to check.
 * @param {Object} [object] The object to query keys on.
 * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
 */

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */

/**
 * Checks if `value` is classified as a `Symbol` primitive or object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
 * @example
 *
 * _.isSymbol(Symbol.iterator);
 * // => true
 *
 * _.isSymbol('abc');
 * // => false
 */

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(document.body.children);
 * // => false
 *
 * _.isArray('abc');
 * // => false
 *
 * _.isArray(_.noop);
 * // => false
 */

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */

/**
 * Checks if `value` is suitable for use as unique object key.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
 */

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */

/**
 * Checks if a given element has a CSS class.
 * 
 * @param element the element
 * @param className the CSS class name
 */

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a list cache value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf ListCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if a map value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf MapCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */

/**
 * Checks if key `b` partially matches with key `a`.
 */

/**
 * Checks if there is a next page.
 * Returns `undefined` if it cannot be determined.
 */

/**
 * Compile a string to a template function for the path.
 *
 * @param  {string}             str
 * @param  {Object=}            options
 * @return {!function(Object=, Object=)}
 */

/**
 * Component based on `useController` hook to work with controlled component.
 *
 * @remarks
 * [API](https://react-hook-form.com/docs/usecontroller/controller) • [Demo](https://codesandbox.io/s/react-hook-form-v6-controller-ts-jwyzw) • [Video](https://www.youtube.com/watch?v=N2UNk_UCVyA)
 *
 * @param props - the path name to the form field value, and validation rules.
 *
 * @returns provide field handler functions, field and form state.
 *
 * @example
 * ```tsx
 * function App() {
 *   const { control } = useForm<FormValues>({
 *     defaultValues: {
 *       test: ""
 *     }
 *   });
 *
 *   return (
 *     <form>
 *       <Controller
 *         control={control}
 *         name="test"
 *         render={({ field: { onChange, onBlur, value, ref }, formState, fieldState }) => (
 *           <>
 *             <input
 *               onChange={onChange} // send value to hook form
 *               onBlur={onBlur} // notify when input is touched
 *               value={value} // return updated value
 *               ref={ref} // set ref for focus management
 *             />
 *             <p>{formState.isSubmitted ? "submitted" : ""}</p>
 *             <p>{fieldState.isTouched ? "touched" : ""}</p>
 *           </>
 *         )}
 *       />
 *     </form>
 *   );
 * }
 * ```
 */

/**
 * Construct a new expression parser
 *
 * Options:
 *   currentDate: iterator start date
 *   endDate: iterator end date
 *
 * @constructor
 * @private
 * @param {Object} fields  Expression fields parsed values
 * @param {Object} options Parser options
 */

/**
 * Convert cron fields back to Cron Expression
 *
 * @public
 * @param {Object} fields Input fields
 * @param {Object} [options] Parsing options
 * @return {Object}
 */

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to convert.
 * @returns {string} Returns the source code.
 */

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */

/**
 * Converts `value` to a string key if it's not a string or symbol.
 *
 * @private
 * @param {*} value The value to inspect.
 * @returns {string|symbol} Returns the key.
 */

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */

/**
 * Converts `value` to a string. An empty string is returned for `null`
 * and `undefined` values. The sign of `-0` is preserved.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 * @example
 *
 * _.toString(null);
 * // => ''
 *
 * _.toString(-0);
 * // => '-0'
 *
 * _.toString([1, 2, 3]);
 * // => '1,2,3'
 */

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */

/**
 * Create a path regexp from string input.
 *
 * @param  {string}  path
 * @param  {!Array}  keys
 * @param  {!Object} options
 * @return {!RegExp}
 */

/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed `func` invocations and a `flush` method to immediately invoke them.
 * Provide `options` to indicate whether `func` should be invoked on the
 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
 * with the last arguments provided to the debounced function. Subsequent
 * calls to the debounced function return the result of the last `func`
 * invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the debounced function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=false]
 *  Specify invoking on the leading edge of the timeout.
 * @param {number} [options.maxWait]
 *  The maximum time `func` is allowed to be delayed before it's invoked.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // Avoid costly calculations while the window size is in flux.
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
 * jQuery(element).on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', debounced);
 *
 * // Cancel the trailing debounced invocation.
 * jQuery(window).on('popstate', debounced.cancel);
 */

/**
 * Creates a function that memoizes the result of `func`. If `resolver` is
 * provided, it determines the cache key for storing the result based on the
 * arguments provided to the memoized function. By default, the first argument
 * provided to the memoized function is used as the map cache key. The `func`
 * is invoked with the `this` binding of the memoized function.
 *
 * **Note:** The cache is exposed as the `cache` property on the memoized
 * function. Its creation may be customized by replacing the `_.memoize.Cache`
 * constructor with one whose instances implement the
 * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
 * method interface of `clear`, `delete`, `get`, `has`, and `set`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to have its output memoized.
 * @param {Function} [resolver] The function to resolve the cache key.
 * @returns {Function} Returns the new memoized function.
 * @example
 *
 * var object = { 'a': 1, 'b': 2 };
 * var other = { 'c': 3, 'd': 4 };
 *
 * var values = _.memoize(_.values);
 * values(object);
 * // => [1, 2]
 *
 * values(other);
 * // => [3, 4]
 *
 * object.a = 2;
 * values(object);
 * // => [1, 2]
 *
 * // Modify the result cache.
 * values.cache.set(object, ['a', 'b']);
 * values(object);
 * // => ['a', 'b']
 *
 * // Replace `_.memoize.Cache`.
 * _.memoize.Cache = WeakMap;
 */

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Creates a history object that stores locations in memory.
 */

/**
 * Creates a history object that uses the HTML5 history API including
 * pushState, replaceState, and the popstate event.
 */

/**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */

/**
 * Cron Time Class
 */

/**
 * Custom hook to manage the entire form.
 *
 * @remarks
 * [API](https://react-hook-form.com/docs/useform) • [Demo](https://codesandbox.io/s/react-hook-form-get-started-ts-5ksmm) • [Video](https://www.youtube.com/watch?v=RkXv4AXXC_4)
 *
 * @param props - form configuration and validation parameters.
 *
 * @returns methods - individual functions to manage the form state. {@link UseFormReturn}
 *
 * @example
 * ```tsx
 * function App() {
 *   const { register, handleSubmit, watch, formState: { errors } } = useForm();
 *   const onSubmit = data => console.log(data);
 *
 *   console.log(watch("example"));
 *
 *   return (
 *     <form onSubmit={handleSubmit(onSubmit)}>
 *       <input defaultValue="test" {...register("example")} />
 *       <input {...register("exampleRequired", { required: true })} />
 *       {errors.exampleRequired && <span>This field is required</span>}
 *       <button>Submit</button>
 *     </form>
 *   );
 * }
 * ```
 */

/**
 * Custom hook to subscribe to field change and isolate re-rendering at the component level.
 *
 * @remarks
 *
 * [API](https://react-hook-form.com/docs/usewatch) • [Demo](https://codesandbox.io/s/react-hook-form-v7-ts-usewatch-h9i5e)
 *
 * @example
 * ```tsx
 * const { control } = useForm();
 * const values = useWatch({
 *   name: "fieldName"
 *   control,
 * })
 * ```
 */

/**
 * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
 *
 * @remarks
 * [API](https://react-hook-form.com/docs/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)
 *
 * @param props - the path name to the form field value, and validation rules.
 *
 * @returns field properties, field and form state. {@link UseControllerReturn}
 *
 * @example
 * ```tsx
 * function Input(props) {
 *   const { field, fieldState, formState } = useController(props);
 *   return (
 *     <div>
 *       <input {...field} placeholder={props.name} />
 *       <p>{fieldState.isTouched && "Touched"}</p>
 *       <p>{formState.isSubmitted ? "submitted" : ""}</p>
 *     </div>
 *   );
 * }
 * ```
 */

/**
 * Custom positioning reference element.
 * @see https://floating-ui.com/docs/virtual-elements
 */

/**
 * Days dictionary.
 */

/**
 * Days in month
 * @type {number[]}
 */

/**
 * Default query keys hash function.
 */

/**
 * Dispatches a custom event on window with given eventName, given zIndex and corresponding layer
 * @param {string} eventName - either of Mount or Unmount event name
 * @param {number} zIndex - z-index value which will be included in the event to be dispatched
 */

/**
 * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
 *
 * @param  {string}
 * @return {string}
 */

/**
 * Escape a regular expression string.
 *
 * @param  {string} str
 * @return {string}
 */

/**
 * Escape the capturing group by escaping special characters and meaning.
 *
 * @param  {string} group
 * @return {string}
 */

/**
 * Every Time Class
 */

/**
 * Executes the initializer function once and saves its result into a ref.
 *
 * ```js
 * const ref = useLazyRef(() => 10);
 * ```
 *
 * @param initializer
 */

/**
 * Expose `pathToRegexp`.
 */

/**
 * Expose a function for taking tokens and returning a RegExp.
 *
 * @param  {!Array}          tokens
 * @param  {(Array|Object)=} keys
 * @param  {Object=}         options
 * @return {!RegExp}
 */

/**
 * Expose a method for transforming tokens into the path function.
 */

/**
 * Field aliases
 * @type {Object}
 */

/**
 * Field defaults
 * @type {Array}
 */

/**
 * Field mappings
 * @type {Array}
 */

/**
 * Fields constraints
 * @type {Array}
 */

/**
 * Find next or previous matching schedule date
 *
 * @return {CronDate}
 * @private
 */

/**
 * Find next suitable date
 *
 * @public
 * @return {CronDate|Object}
 */

/**
 * Find previous suitable date
 *
 * @public
 * @return {CronDate|Object}
 */

/**
 * Focusing on the passed element ref after initial mount.
 * Will only focus on initial mount.
 *
 * https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement/autofocus
 *
 * ```tsx
 * import useAutoFocus from '@atlaskit/ds-lib/use-auto-focus';
 *
 * const elementRef = useRef();
 * useAutoFocus(elementRef, true);
 *
 * <button ref={elementRef} />;
 * ```
 *
 * @param ref
 * @param autoFocus
 */

/**
 * Font token fallbacks are verbose.
 * This object exists purely to make using fallbacks less cumbersome while we still need to use them.
 * Will be removed once fallbacks are no longer needed.
 *
 * This is referenced by the use-tokens-typography ESLint rule.
 */

/**
 * For windows high contrast mode
 */

/**
 * Functions similarly to `useState` however the return value is a ref.
 *
 * ```js
 * const [valueRef, setValue] = useStateRef(0);
 * ```
 *
 * @param initialState
 */

/**
 * Get the flags for a regexp from the options.
 *
 * @param  {Object} options
 * @return {string}
 */

/**
 * Gets the data for `map`.
 *
 * @private
 * @param {Object} map The map to query.
 * @param {string} key The reference key.
 * @returns {*} Returns the map data.
 */

/**
 * Gets the hash value for `key`.
 *
 * @private
 * @name get
 * @memberOf Hash
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */

/**
 * Gets the list cache value for `key`.
 *
 * @private
 * @name get
 * @memberOf ListCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the map value for `key`.
 *
 * @private
 * @name get
 * @memberOf MapCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */

/**
 * Gets the value at `key` of `object`.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */

/**
 * Hashes the value into a stable hash.
 */

/**
 * Iterate over expression iterator
 *
 * @public
 * @param {Number} steps Numbers of steps to iterate
 * @param {Function} callback Optional callback
 * @return {Array} Array of the iterated results
 */

/**
 * Merges two or more refs together providing a single interface to set their value
 * @param {RefObject|Ref} refs
 * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
 *
 * @see {@link mergeRefs} a version without buit-in memoization
 * @see https://github.com/theKashey/use-callback-ref#usemergerefs
 * @example
 * const Component = React.forwardRef((props, ref) => {
 *   const ownRef = useRef();
 *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together
 *   return <div ref={domRef}>...</div>
 * }
 */

/**
 * Needed to supress the SSR warning when running use layout effect on the server.
 */

/**
 * Normalize the given path string, returning a regular expression.
 *
 * An empty array can be passed in for the keys, which will hold the
 * placeholder key descriptions. For example, using `/user/:id`, `keys` will
 * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
 *
 * @param  {(string|RegExp|Array)} path
 * @param  {(Array|Object)=}       keys
 * @param  {Object=}               options
 * @return {!RegExp}
 */

/**
 * Parse a string for the raw tokens.
 *
 * @param  {string}  str
 * @param  {Object=} options
 * @return {!Array}
 */

/**
 * Parse content string
 *
 * @public
 * @param {String} data Crontab content
 * @return {Object}
 */

/**
 * Parse crontab entry
 *
 * @private
 * @param {String} entry Crontab file entry/line
 */

/**
 * Parse crontab file
 *
 * @public
 * @param {String} filePath Path to file
 * @param {Function} callback
 */

/**
 * Parse input expression (async)
 *
 * @public
 * @param {String} expression Input expression
 * @param {Object} [options] Parsing options
 */

/**
 * Parse input interval
 *
 * @param {String} field Field symbolic name
 * @param {String} value Field value
 * @param {Array} constraints Range upper and lower constraints
 * @return {Array} Sequence of sorted values
 * @private
 */

/**
 * Performs a
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * comparison between two values to determine if they are equivalent.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.eq(object, object);
 * // => true
 *
 * _.eq(object, other);
 * // => false
 *
 * _.eq('a', 'a');
 * // => true
 *
 * _.eq('a', Object('a'));
 * // => false
 *
 * _.eq(NaN, NaN);
 * // => true
 */

/**
 * Prefined intervals
 * @type {Object}
 */

/**
 * Prettier encoding of URI path segments.
 *
 * @param  {string}
 * @return {string}
 */

/**
 * Prevents programatic scrolling of the viewport with `scrollIntoView`.
 * Should be used in conjunction with a scroll lock to prevent a user from scrolling.
 *
 * @returns scroll top offset of the viewport
 */

/**
 * Public API for matching a URL pathname to a path.
 */

/**
 * Pull out keys from a regexp.
 *
 * @param  {!RegExp} path
 * @param  {!Array}  keys
 * @return {!RegExp}
 */

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes `key` and its value from the list cache.
 *
 * @private
 * @name delete
 * @memberOf ListCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes `key` and its value from the map.
 *
 * @private
 * @name delete
 * @memberOf MapCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */

/**
 * Removes a CSS class from a given element.
 * 
 * @param element the element
 * @param className the CSS class name
 */

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */

/**
 * Represents the local zone for this JavaScript environment.
 * @implements {Zone}
 */

/**
 * Reset expression iterator state
 *
 * @public
 */

/**
 * Resolves with an object of overflow side offsets that determine how much the
 * element is overflowing a given clipping boundary on each side.
 * - positive = overflowing the boundary by that number of pixels
 * - negative = how many pixels left before it will overflow
 * - 0 = lies flush with the boundary
 * @see https://floating-ui.com/docs/detectOverflow
 */

/**
 * Returns how far the body is scrolled from the top of the viewport.
 *
 *   ____
 * ||____|| <-- overflow
 *  |    |  <-- viewport
 *  |____|
 *
 * Scroll distance is the height of overflow outside the viewport.
 */

/**
 * Returns the appropriate circle stroke color.
 */

/**
 * Returns the background color depending on the passed through mode.
 * @param mode
 */

/**
 * Returns the offset's value as a string
 * @param {number} ts - Epoch milliseconds for which to get the offset
 * @param {string} format - What style of offset to return.
 *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
 * @return {string}
 */

/**
 * Returns the position of the calling modal dialog in the modal dialog stack.
 * Stack index of `0` is the highest position in the stack,
 * with every higher number being behind in the stack.
 */

/**
 * Returns the value of a feature flag. If the flag does not resolve, it returns the "false" as a default value.
 *
 * @deprecated Use {@link fg} function instead.
 * @param name
 */

/**
 * Returns the value of a feature flag. If the flag does not resolve, it returns the "false" as a default value.
 *
 * @param name
 */

/**
 * Returns true if a given popstate event is an extraneous WebKit event.
 * Accounts for the fact that Chrome on iOS fires real popstate events
 * containing undefined state when pressing the back button.
 */

/**
 * Returns true if the HTML5 history API is supported. Taken from Modernizr.
 *
 * https://github.com/Modernizr/Modernizr/blob/master/LICENSE
 * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
 * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586
 */

/**
 * Returns true when the current weekday is the last occurrence of this weekday
 * for the present month.
 */

/**
 * Saves the passed through `callback` to a ref to ensure stability between renders.
 * As a feature this callback will only be created **once**,
 * this means it will have a stale closure on subsequent render.
 *
 * If you need to access things in the parent scope make sure to do it with refs.
 *
 * ```js
 * const callback = useLazyCallback(() => 10);
 * ```
 *
 * @param callback
 */

/**
 * Schedules a microtask.
 * This can be useful to schedule state updates after rendering.
 */

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */

/**
 * Sets the list cache `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf ListCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the list cache instance.
 */

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */

/**
 * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
 * it's created. Arrays are created for missing index properties while objects
 * are created for all other missing properties. Use `_.setWith` to customize
 * `path` creation.
 *
 * **Note:** This method mutates `object`.
 *
 * @static
 * @memberOf _
 * @since 3.7.0
 * @category Object
 * @param {Object} object The object to modify.
 * @param {Array|string} path The path of the property to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns `object`.
 * @example
 *
 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
 *
 * _.set(object, 'a[0].b.c', 4);
 * console.log(object.a[0].b.c);
 * // => 4
 *
 * _.set(object, ['x', '0', 'y', 'z'], 5);
 * console.log(object.x[0].y.z);
 * // => 5
 */

/**
 * Settings contains static getters and setters that control Luxon's overall behavior. Luxon is a simple library with few options, but the ones it does have live here.
 */

/**
 * Shallow compare objects. Only works with objects that always have the same properties.
 */

/**
 * Stringify the expression
 *
 * @public
 * @param {Boolean} [includeSeconds] Should stringify seconds
 * @return {String}
 */

/**
 * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
 *
 * The color map is used to map a background color token to a matching text color that will meet contrast.
 *
 * @codegen <<SignedSource::f70c0e13112cb1620980353c239c14d8>>
 * @codegenCommand yarn codegen-styles
 * @codegenDependency ../../../tokens/src/artifacts/tokens-raw/atlassian-light.tsx <<SignedSource::f6a616f7ea03ec40c148fc83050d073b>>
 */

/**
 * THIS SECTION WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
 * @codegen <<SignedSource::14dcf59f69533f453ffa8a5c5d165d19>>
 * @codegenId typography
 * @codegenCommand yarn codegen-styles
 * @codegenParams ["fontSize", "fontWeight", "fontFamily", "lineHeight"]
 * @codegenDependency ../../../tokens/src/artifacts/tokens-raw/atlassian-typography.tsx <<SignedSource::b01e60e475c0cb12960865631f2b4e2c>>
 */

/**
 * Takes a dot-separated token name and an optional fallback, and returns the CSS custom property for the corresponding token.
 * This should be used to implement design decisions throughout your application.
 *
 * Note: With `@atlaskit/babel-plugin-tokens`, this function can be pre-compiled and a fallback value automatically inserted.
 *
 * @param {string} path - A dot-separated token name (example: `'color.background.brand'` or `'spacing.scale.100'`).
 * @param {string} [fallback] - The fallback value that should render when token CSS is not present in your app.
 *
 * @example
 * ```
 * <div
 *   css={{
 *     backgroundColor: token('elevation.surface.raised', N0),
 *     boxShadow: token('elevation.shadow.raised', `0 20px 32px -8px ${N50A}, 0 0 1px ${N60A}`),
 *     padding: token('spacing.scale.100', '8px'),
 *     fontWeight: token('font.weight.regular', '400'),
 *   }}
 * />
 * ```
 *
 */

/**
 * Takes a maybe-undefined function and arbitrary args and invokes the function
 * only if it is defined.
 */

/**
 * Takes an argument and if it's an array, returns the first item in the array,
 * otherwise returns the argument. Used for Preact compatibility.
 */

/**
 * The Info class contains static methods for retrieving general time and date related data. For example, it has methods for finding out if a time zone has a DST, for listing the months in any supported locale, and for discovering which of Luxon features are available in the current environment.
 */

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */

/**
 * The base implementation of `_.set`.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {Array|string} path The path of the property to set.
 * @param {*} value The value to set.
 * @param {Function} [customizer] The function to customize path creation.
 * @returns {Object} Returns `object`.
 */

/**
 * The base implementation of `_.toString` which doesn't convert nullish
 * values to empty strings.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {string} Returns the string.
 */

/**
 * The base implementation of `assignValue` and `assignMergeValue` without
 * value checks.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */

/**
 * The main path matching regexp utility.
 *
 * @type {RegExp}
 */

/**
 * The public API for a <Router> that stores location in memory.
 */

/**
 * The public API for a <Router> that uses window.location.hash.
 */

/**
 * The public API for matching a single path and rendering.
 */

/**
 * The public API for prompting the user before navigating away from a screen.
 */

/**
 * The public API for rendering a history-aware <a>.
 */

/**
 * The public API for rendering the first <Route> that matches.
 */

/**
 * The public top-level API for a "static" <Router>, so-called because it
 * can't actually change the current location. Instead, it just records
 * location changes in a context object. Useful mainly in testing and
 * server-rendering scenarios.
 */

/**
 * These are props that motions should use as their external props for consumers.
 * See [FadeIn](packages/helpers/motion/src/entering/fade-in.tsx) for an example usage.
 */

/**
 * This custom hook allows you to subscribe to each form state, and isolate the re-render at the custom hook level. It has its scope in terms of form state subscription, so it would not affect other useFormState and useForm. Using this hook can reduce the re-render impact on large and complex form application.
 *
 * @remarks
 * [API](https://react-hook-form.com/docs/useformstate) • [Demo](https://codesandbox.io/s/useformstate-75xly)
 *
 * @param props - include options on specify fields to subscribe. {@link UseFormStateReturn}
 *
 * @example
 * ```tsx
 * function App() {
 *   const { register, handleSubmit, control } = useForm({
 *     defaultValues: {
 *     firstName: "firstName"
 *   }});
 *   const { dirtyFields } = useFormState({
 *     control
 *   });
 *   const onSubmit = (data) => console.log(data);
 *
 *   return (
 *     <form onSubmit={handleSubmit(onSubmit)}>
 *       <input {...register("firstName")} placeholder="First Name" />
 *       {dirtyFields.firstName && <p>Field is dirty.</p>}
 *       <input type="submit" />
 *     </form>
 *   );
 * }
 * ```
 */

/**
 * This function returns `a` if `b` is deeply equal.
 * If not, it will replace any deeply equal children of `b` with those of `a`.
 * This can be used for structural sharing between JSON values for example.
 */

/**
 * Timestamp to use for cached zone offset guesses (exposed for test)
 */

/**
 * Transform an array into a regexp.
 *
 * @param  {!Array}  path
 * @param  {Array}   keys
 * @param  {!Object} options
 * @return {!RegExp}
 */

/**
 * Use for any programatic motions needed at runtime.
 * Will return `true` if the current user prefers reduced motion.
 * This is generally set through OS preferences/settings.
 */

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */

/**
 * Used to multiply the initial duration for exiting motions.
 */

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */

/**
 * We are hiding these props from consumers as they're used to
 * hack around icon sizing specifically for icon-file-type.
 */

/**
 * Wrapper for CronExpression.fieldsToExpression method
 *
 * @public
 * @param {Object} fields Input fields
 * @param {Object} [options] Parsing options
 * @return {Object}
 */

/**
 * Wrapper for CronExpression.parser method
 *
 * @public
 * @param {String} expression Input expression
 * @param {Object} [options] Parsing options
 * @return {Object}
 */

/**
 * __Box__
 *
 * Box is a primitive component that has the design decisions of the Atlassian Design System baked in.
 * Renders a `div` by default.
 *
 * @private
 * @deprecated DSP-8009: This primitive is scheduled for deletion.
 * Please use `Box` from `@atlaskit/primitives` instead.
 */

/**
 * __Checkbox icon__
 *
 * A checkbox icon is the visual representation of checkbox state,
 * which is shown instead of the native input.
 *
 * @internal
 */

/**
 * __Field id__
 *
 * A field id uses the context API. It provides the id of the field to message components. This links the message with the field of screenreaders.
 */

/**
 * __Loading button__
 *
 * A small wrapper around Button that allows you to show an @atlaskit/spinner as an overlay on the button when you set an isLoading prop to true.
 *
 * - [Examples](https://atlassian.design/components/button/examples#loading-button)
 */

/**
 * __Modal footer__
 *
 * A modal footer often contains a primary action and the ability to cancel and close the dialog, though can contain any React element.
 *
 * - [Examples](https://atlassian.design/components/modal-dialog/examples#modal-footer)
 * - [Code](https://atlassian.design/components/modal-dialog/code#modal-footer-props)
 * - [Usage](https://atlassian.design/components/modal-dialog/usage)
 */

/**
 * __Progress bar__
 *
 * A progress bar describes the horizontal tracking bar that traverses each individual step.
 *
 */

/**
 * __Progress marker__
 *
 * Similar to `@atlaskit/progress-indicator`, a small visual circle marker
 */

/**
 * __Tab__
 *
 * Tab represents an indivudal Tab displayed in a TabList.
 *
 * - [Examples](https://atlassian.design/components/tabs/examples)
 * - [Code](https://atlassian.design/components/tabs/code)
 * - [Usage](https://atlassian.design/components/tabs/usage)
 */

/**
 * __Textfield__
 *
 * A text field is an input that allows a user to write or edit text.
 *
 * - [Examples](https://atlassian.design/components/textfield/examples)
 * - [Code](https://atlassian.design/components/textfield/code)
 * - [Usage](https://atlassian.design/components/textfield/usage)
 */

/**
 * createTheme is used to create a set of Providers and Consumers for theming components.
 * - Takes a default theme function; this theme function gets a set of props, and returns tokens
 *  based on those props. An example of this default theme function is one that produces the standard
 *  appearance of the component
 * - Returns three things - a Provider that allow for additional themes to be applied, a Consumer
 *  that can get the current theme and fetch it, and a custom hook - useTheme which provides an alternate (although functionally the same) API
 *  to the Consumer.
 */

/**
 * generates a UID factory
 * @internal
 * @example
 * const uid = generateUID();
 * uid(object) = 1;
 * uid(object) = 1;
 * uid(anotherObject) = 2;
 */

/**
 * lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/**
 String representation of component state for styling with class names.

 Expects an array of strings OR a string/object pair:
 - className(['comp', 'comp-arg', 'comp-arg-2'])
   @returns 'react-select__comp react-select__comp-arg react-select__comp-arg-2'
 - className('comp', { some: true, state: false })
   @returns 'react-select__comp react-select__comp--some'
*/

/**  @jsx jsx */

/**  @private */

/** +FOCUS-FIGHTING prevention **/

/** @jsx jsx */

/** @license React v0.19.1
 * scheduler.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/** @license React v16.14.0
 * react-dom.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/** @license React v16.14.0
 * react-jsx-runtime.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/** @license React v16.14.0
 * react.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/** @override **/

/** @private **/

/** @type {!Array} */

/** @type {!Object} */

/** @type {string} */

/** Alias of safeParseAsync */

/** Built-in value references. */

/** Detect free variable `global` from Node.js. */

/** Detect free variable `self`. */

/** Error message constants. */

/** Used as references for various `Number` constants. */

/** Used as the `TypeError` message for "Functions" methods. */

/** Used as the maximum memoize cache size. */

/** Used for built-in method references. */

/** Used to detect methods masquerading as native. */

/** Used to detect overreaching core-js shims. */

/** Used to detect unsigned integer values. */

/** Used to match property names within property paths. */

/** Used to resolve the decompiled source of functions. */

/** Used to stand-in for `undefined` hash values. */

/** `Object#toString` result references. */

/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

/******/

/***/

//

//         ...augmentation,

//         ...def.shape(),

//         nextStatus = ENTERING

//         nextStatus = EXITING

//       ...augmentation,

//       ...def,

//       ...this._def.shape(),

//       : k extends keyof Input

//       : k extends keyof Output

//       : never;

//       ? Augmentation[k]["_input"]

//       ? Augmentation[k]["_output"]

//       ? Input[k]

//       ? Output[k]

//       if (status !== ENTERING && status !== ENTERED) {

//       if (status === ENTERING || status === ENTERED) {

//       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),

//       shape: () => ({

//       }

//       }),

//      - parseRange

//      if (!b.has(i.value[0])) return false;

//      if (!b.has(i[0])) return false;

//     ...this._def,

//     Def["catchall"]

//     Def["unknownKeys"],

//     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation

//     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation

//     augmentation: Augmentation

//     catchall: merging._def.catchall,

//     const { status } = this.state

//     extendShape<ReturnType<Def["shape"]>, Augmentation>,

//     if (this.props.in) {

//     return new ZodObject({

//     shape: () =>

//     shape: () => ({

//     typeName: ZodFirstPartyTypeKind.ZodObject,

//     unknownKeys: merging._def.unknownKeys,

//     }

//     } else {

//     }) as any;

//     }),

//    **Note**: `i` access switches to `i.value`.

//    - < Etc/GMT-14, > Etc/GMT+12, and 30-minute or 45-minute offsets are not part of tzdata

//    - parseRepeat

//    - some do not support Etc/

//    ... and convert to:

//    Basically, take:

//    ```

//    ```js

//    for (i of a.entries())

//    it = a.entries();

//    to co-exist with es5.

//    while (!(i = it.next()).done)

//   ): ZodObject<

//   //   merging._def.shape()

//   //   this._def.shape(),

//   // );

//   // const mergedShape = objectUtil.mergeShapes(

//   <Augmentation extends ZodRawShape>(

//   <Def extends ZodObjectDef>(def: Def) =>

//   > => {

//   Augmentation extends Incoming["shape"],

//   Augmentation extends ZodRawShape,

//   Catchall,

//   Incoming extends AnyZodObject,

//   Incoming["_def"]["catchall"]

//   Incoming["_def"]["catchall"],

//   Incoming["_def"]["unknownKeys"],

//   NewInput

//   NewInput extends util.flatten<{

//   NewInput extends {

//   NewOutput extends util.flatten<{

//   NewOutput extends {

//   NewOutput,

//   UnknownKeys,

//   augmentation: Augmentation

//   captures = result.slice(1).map(maybeToString)

//   const merged: any = new ZodObject({

//   extendShape<T, Augmentation>,

//   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,

//   https://github.com/zloirock/core-js/issues/1128

//   https://github.com/zloirock/core-js/issues/1130

//   if (prevProps !== this.props) {

//   let nextStatus = null

//   merging: Incoming

//   return merged;

//   return new ZodObject({

//   return { nextStatus }

//   }

//   }) as any;

//   },

//   };

//   }>

//   }>,

//  - parseSequence

//  0..25 map to ASCII a..z or A..Z

// "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]

// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]

// "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]

// "The day of a command's execution can be specified by two fields --

// "memoized" public interface

// "negative dropdown" (not in group, or inactive)

// "positive dropdown" (in group, or active)

// #68 Safari 14.1 dont have it yet

// $FlowFixMe

// $FlowFixMe we know it's not null

// $FlowFixMe[cannot-write]

// $FlowFixMe[incompatible-call]: HTMLElement is a Node

// $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here

// $FlowFixMe[incompatible-return]

// $FlowFixMe[incompatible-return]: assume body is always available

// $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414

// $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...

// $FlowFixMe[prop-missing]

// $FlowFixMe[prop-missing]: need a better way to handle this...

// '[role="button"]',

// 'm' and 'r' are mixing constants generated offline.

// (for example, `DOMQuad` and similar in FF41-)

// (gregorian data or ordinal) + (weekYear or weekNumber) -> error

// (gregorian month or day) + ordinal -> error

// (in contrast, the rest of the condition is used heavily)

// ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {

// ): ZodObject<

// - https://github.com/FormidableLabs/react-fast-compare/issues/64

// - https://github.com/epoberezkin/fast-deep-equal/issues/49

// ----

// ------------------------------

// .current should be assignable

// 0, NaN, or Infinity should always fallback to 1.

// 0px margin added to css-reset

// 1. Extra `has<Type> &&` helpers in initial condition allow es6 code

// 1. Representing offset 0 when UTC is used to maintain previous behavior and does not become GMT.

// 10px gutter

// 1: the menu will fit, do nothing

// 2 ** 53 - 1 == 9007199254740991

// 2. Replace `for of` with es5 compliant iteration using `for`.

// 2. Unsupported by the browser:

// 25.4.3.1 Promise(executor)

// 26..35 map to ASCII 0..9

// 2: the menu will fit, if scrolled

// 2px gutter

// 32px

// 3: the menu will fit, if constrained

// 4. Forked beviour when there isn't enough space below

// 4. not enough space, the browser WILL NOT increase scrollable area when

// <<< STYLES GO HERE >>>

// ==============================

// > {

// >(

// @@replace logic

// @@search logic

// @font-face, @page

// @import

// @import is generally only used for font faces from google fonts and etc.

// @ts-expect-error

// @ts-expect-error - Adding `data-testid` to the TriggerProps interface breaks Buttons.

// @ts-expect-error expected to work in the browser

// @ts-ignore

// @ts-ignore See issue for more info: https://github.com/Microsoft/TypeScript/issues/10727

// @ts-ignore: refs are writeable

// A "clipping parent" is an overflowable container with the characteristic of

// A hashchange doesn't always == location change.

// AUTO: flip the menu, render above

// About 1.5x faster than the two-arg version of Array#splice()

// Adapted from https://stackoverflow.com/a/3143231

// Add methods to `Hash`.

// Add methods to `ListCache`.

// Add methods to `MapCache`.

// Add or subtract day if day of week & nthDayOfWeek are set (and no match)

// Add or subtract day if not day of month is set (and no match) and day of week is wildcard

// Add or subtract day if not day of week is set (and no match) and day of month is wildcard

// Add or subtract day if select day not match with month (according to calendar)

// Add ourselves to the modal stack register!

// All non-basic code points < n have been handled already. Find the next larger one:

// Allow scroll on provided target

// Allow useErrorBoundary function to override throwing behavior on a per-error basis

// Allow useErrorBoundary to override suspense's throwing behavior

// Allowing tab so that a user can move focus away

// Allows consumers to extend a base Select with additional styles

// Always refetch after error or success:

// Always reset height to auto before calculating new height

// Always set stale time when using suspense to prevent

// Animated Scroll To

// Apply guards for `Object.create(null)` handling. See:

// Argument of type 'Pick<ThemeProps & { children: (tokens: ThemeTokens) => ReactNode; }, Exclude<keyof ThemeProps, "children">>' is not assignable to parameter of type 'ThemeProps'.ts(2345)

// Array#includes uses SameValueZero equality algorithm

// Array#indexOf ignores holes, Array#includes - not

// Array.prototype[@@unscopables]

// Assistive text to describe visual elements. Hidden for sighted users.

// Async and optimistically optimized update – it will not be executed if

// Attributes have the same specificity a pseudo classes so we are overriding :disabled here

// Avoid NodeJS experimental warning

// Avoid failures from read-only properties

// BOTTOM: allow browser to increase scrollable area and immediately set scroll

// Be sure to unsubscribe if a new handler is set

// Block option hover events when the user has just pressed a key

// Break the first item of the current range into a single element, and try to start a new range with the second item

// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`

// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

// Browsers where the left scrollbar doesn't cause an issue report `0` for

// Bun / IE9- setInterval additional parameters fix

// Bun / IE9- setTimeout additional parameters fix

// Button already has React.memo, so just leaning on that

// By explicitly using `prop-types` you are opting into new production behavior.

// CAPABILITIES

// CLASS

// COERCION

// COMPARE

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/events/AnalyticsEvent.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hocs/withAnalyticsContext.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/useAnalyticsEvents.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/usePatchedProps.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/usePlatformLeafSyntheticEventHandler.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/utils/createAndFireEvent.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/utils/isModernContextEnabledEnv.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/blanket/dist/esm/blanket.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/button/dist/esm/button.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/button/dist/esm/loading-button.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/button/dist/esm/shared/block-events.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/button/dist/esm/shared/css.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/button/dist/esm/shared/get-is-only-single-icon.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/checkbox.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/internal/checkbox-icon.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/internal/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/internal/label-text.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/internal/label.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/checkbox/dist/esm/internal/required-indicator.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-explorations/dist/esm/components/box.partial.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-explorations/dist/esm/components/text.partial.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-explorations/dist/esm/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-explorations/dist/esm/internal/color-map.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/hooks/use-close-on-escape-press.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/hooks/use-lazy-callback.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/hooks/use-lazy-ref.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/hooks/use-state-ref.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/utils/merge-refs.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/form/dist/esm/field.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/icon/dist/esm/components/icon.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/icon/dist/esm/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/icon/dist/esm/entry-points/base.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/hooks.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/components/modal-dialog.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/components/scroll-container.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/hooks/use-modal-stack.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/hooks/use-on-motion-finish.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/hooks/use-prevent-programmatic-scroll.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/hooks/use-scroll.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/internal/utils.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/modal-body.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/modal-footer.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/modal-title.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/modal-dialog/dist/esm/modal-wrapper.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/motion/dist/esm/entering/fade-in.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/motion/dist/esm/entering/keyframes-motion.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/motion/dist/esm/entering/staggered-entrance.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/motion/dist/esm/utils/accessibility.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/motion/dist/esm/utils/curves.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/platform-feature-flags/dist/esm/debug.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/popper/dist/esm/popper.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/internal/components/internal-portal-new.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/internal/components/internal-portal.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/internal/constants.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/internal/hooks/use-isomorphic-layout-effect.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/portal/dist/esm/portal.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/progress-tracker/dist/esm/internal/bar.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/progress-tracker/dist/esm/internal/marker.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/progress-tracker/dist/esm/internal/stage.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/progress-tracker/dist/esm/internal/utils.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/progress-tracker/dist/esm/progress-tracker.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/section-message/dist/esm/internal/appearance-icon.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/section-message/dist/esm/section-message.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/select/dist/esm/CreatableSelect.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/select/dist/esm/createSelect.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/select/dist/esm/styles.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/spinner/dist/esm/spinner.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/cell.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/header.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/headers.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/chevron.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/item.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/items.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/loader-item.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/overflow-container.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/internal/with-column-width.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/row.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/rows.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/components/table-tree.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/table-tree/dist/esm/utils/to-item-id.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tabs/dist/esm/components/tab.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tabs/dist/esm/components/tabs.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tabs/dist/esm/internal/styles.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/textarea/dist/esm/styles.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/textfield/dist/esm/styles.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/theme/dist/esm/colors.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/theme/dist/esm/utils/get-theme.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/theme/dist/esm/utils/themed.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/Tooltip.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/TooltipContainer.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/TooltipPrimitive.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/internal/tooltip-manager.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/internal/use-unique-id.js

// CONCATENATED MODULE: ./node_modules/@atlaskit/tooltip/dist/esm/utilities.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/get.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/superPropBase.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toArray.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js

// CONCATENATED MODULE: ./node_modules/@emotion/core/dist/core.browser.esm.js

// CONCATENATED MODULE: ./node_modules/@emotion/css/dist/css.browser.esm.js

// CONCATENATED MODULE: ./node_modules/@emotion/hash/dist/emotion-hash.esm.js

// CONCATENATED MODULE: ./node_modules/@emotion/sheet/dist/sheet.browser.esm.js

// CONCATENATED MODULE: ./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs

// CONCATENATED MODULE: ./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs

// CONCATENATED MODULE: ./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/createPopper.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/contains.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindow.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/enums.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/applyStyles.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/computeStyles.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/flip.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/hide.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/offset.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/preventOverflow.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/popper.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/computeOffsets.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/detectOverflow.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/expandToHashMap.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getBasePlacement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getVariation.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/math.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/orderModifiers.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/rectToClientRect.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/userAgent.js

// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/within.js

// CONCATENATED MODULE: ./node_modules/dom-helpers/esm/addClass.js

// CONCATENATED MODULE: ./node_modules/dom-helpers/esm/hasClass.js

// CONCATENATED MODULE: ./node_modules/dom-helpers/esm/removeClass.js

// CONCATENATED MODULE: ./node_modules/focus-lock/dist/es2015/return-focus.js

// CONCATENATED MODULE: ./node_modules/focus-lock/dist/es2015/utils/array.js

// CONCATENATED MODULE: ./node_modules/history/esm/history.js

// CONCATENATED MODULE: ./node_modules/react-clientside-effect/lib/index.es.js

// CONCATENATED MODULE: ./node_modules/react-focus-lock/dist/es2015/Combination.js

// CONCATENATED MODULE: ./node_modules/react-focus-lock/dist/es2015/FocusGuard.js

// CONCATENATED MODULE: ./node_modules/react-focus-lock/dist/es2015/medium.js

// CONCATENATED MODULE: ./node_modules/react-focus-lock/dist/es2015/util.js

// CONCATENATED MODULE: ./node_modules/react-popper/lib/esm/Manager.js

// CONCATENATED MODULE: ./node_modules/react-popper/lib/esm/utils.js

// CONCATENATED MODULE: ./node_modules/react-query/es/core/queryClient.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/QueryErrorResetBoundary.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/index.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/setBatchUpdatesFn.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/setLogger.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/useBaseQuery.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/useMutation.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/useQuery.js

// CONCATENATED MODULE: ./node_modules/react-query/es/react/utils.js

// CONCATENATED MODULE: ./node_modules/react-transition-group/esm/CSSTransition.js

// CONCATENATED MODULE: ./node_modules/react-transition-group/esm/config.js

// CONCATENATED MODULE: ./node_modules/react-transition-group/esm/utils/reflow.js

// CONCATENATED MODULE: ./node_modules/resolve-pathname/esm/resolve-pathname.js

// CONCATENATED MODULE: ./node_modules/use-callback-ref/dist/es2015/assignRef.js

// CONCATENATED MODULE: ./node_modules/use-callback-ref/dist/es2015/useMergeRef.js

// CONCATENATED MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js

// CONCATENATED MODULE: ./node_modules/use-sidecar/dist/es2015/medium.js

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/StepIndex.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/api/draftApi.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/api/scopeApi.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/api/setupIdpApi.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/api/staticApi.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/CertificateBox.module.css

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/CertificateBox.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/CopyButton.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/CopyButton.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/MessageBox.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/MessageBox.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/Modal.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/ProgressBar.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/RadioSelect.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/StepContainer.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/StepContainer.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/SummaryRow.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/SummaryRow.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/forms/CopyTextField.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/forms/FileInput.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/forms/FileInputField.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/components/forms/KssoTextField.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/contexts/reducers/CommonWizardReducer.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/contexts/reducers/OidcWizardReducer.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/contexts/reducers/SamlWizardReducer.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/hooks/draftHooks.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/hooks/staticDataHooks.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/adfs/Steps.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/adfs/saml/Metadata.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/adfs/saml/Prepare.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/adfs/saml/Prepare.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/adfs/saml/Summary.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/azure-ad/Steps.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/azure-ad/oidc/Metadata.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/github/GithubSteps.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/github/oidc/Summary.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/one-login/Steps.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/one-login/saml/Prepare.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/ChooseRedirectMode.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/DisplayName.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/DisplayName.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/StandardSteps.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/TestStep.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/TestStep.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/Credentials.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/Scope.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/Summary.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/metadata-url-certificate/CertVerifyBox.module.css

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/metadata/Metadata.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/metadata/MetadataHooks.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/metadata/MetadataResolver.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/oidc/metadata/utilities.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/PrepareIdp.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/SSORedirectUrl.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/Summary.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/certificate/CertUploadResolver.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/certificate/CertificateImported.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/certificate/CertificateManualUpload.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/certificate/CertificateStep.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata-url-certificate/CertVerifyBox.module.css

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata-url-certificate/CertVerifyBox.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata/Metadata.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata/Metadata.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata/MetadataResolver.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/steps/standard/saml/metadata/utilities.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/utilities/File.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/utilities/SummaryHooks.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/utilities/draftUtilities.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/utilities/oidc/MetadataUrlHint.ts

// CONCATENATED MODULE: ./src/main/frontend/src/idp-setup/src/utilities/saml/MetadataUrlHint.ts

// CONCATENATED MODULE: ./src/main/frontend/src/shared/api/apiGetServerTime.ts

// CONCATENATED MODULE: ./src/main/frontend/src/shared/components/ConfirmDialogue/ConfirmDialogue.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/shared/components/CronAttributesInput/CronAttributesInput.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/shared/components/EditableListInput/CustomGroupSelect.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/shared/components/error-box/ErrorBox.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/shared/utilities/generateCron.ts

// CONCATENATED MODULE: ./src/main/frontend/src/shared/utilities/useWindowSize.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/App.module.scss

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/App.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiDeleteCleanupResultFile.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiExecuteCleanup.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiExecuteCleanupSingleUser.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiGetCleanupExecuteStatus.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiGetCleanupLogs.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiGetCleanupMeta.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiGetCleanupRule.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiPostCleanupRule.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/api/apiResetCleanupStatus.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/common/tabs.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/CleanupExceptions.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/CleanupStatusMessages.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/ConfirmCleanupDialogue.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/InactiveUserCleanup.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/TestRunTableView.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/components/UnusedJSMCleanup.tsx

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/index.ts

// CONCATENATED MODULE: ./src/main/frontend/src/user-cleanup/src/utilities/QueryClient.ts

// CONSTRUCT

// CONTEXT

// CSS selector

// Cache the length.

// Call the onShow handler if it hasn't been called yet

// Change display to be none

// Check constraints

// Check for valid characters.

// Check if the transport layer support cancellation

// Check this by adding 7 days to the current date and seeing if it's

// Children WILL have a key after being forced into an array using the React.Children helper.

// Chrome 38 Symbol has incorrect toString conversion

// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances

// Chrome recently changed button so that they use 'arial' as the font family

// Class Name Prefixer

// Clean Common Props

// Clean Value

// Clean up no longer used handlers in cache

// Comment

// Compile all the patterns before compilation.

// Compile all the tokens into regexps.

// Composite means it takes into account transforms as well as layout.

// Composition Handlers

// Consider 0 and undefined as equal

// Consumer Handlers

// Continue fetch if currently paused

// Convert base64url to base64

// Convert the input in UCS-2 to an array of Unicode code points.

// Copied from: https://github.com/jonschlinkert/is-plain-object

// Create callback to cancel this fetch

// Create default global light theme

// Create fetch function

// Create range

// Cross browser auto focusing is pretty broken, so we are doing it ourselves

// Custom zones can have any offset / offsetName so we just manually

// Cycling focus to move from last to first and from first to last

// DATE BASICS

// DCE check should happen before ReactDOM bundle executes so that

// DO NOT scroll if position is fixed

// DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node

// DOM Element detected

// DOM Element detected.

// DSP-6470 we should style like Tag once we have the :has selector

// Day of month

// Day of month and week matching:

// Default appearance

// Default to 5 minutes if not cache time is set

// Delay

// Deno throws a ReferenceError on `location` access without `--location` flag

// Detect IE8's incomplete defineProperty implementation

// Detect buggy property enumeration order in older V8 versions.

// Detect correctness of subclassing with @@species support

// Determine which callbacks to trigger

// DevTools can report bad minification during injection.

// DevTools shouldn't crash React, no matter what.

// Disabling visited styles (just using the base colors)

// Do a few final mixes of the hash to ensure the last few

// Do not notify on updates because of changes in the options because

// Do nothing

// Do nothing if already resolved

// Do we need to retry the request?

// Document Helpers

// Don't apply any workarounds if a timeZone is explicitly provided in opts

// Don't enum bug & hidden keys

// Don't proceed if `reference` or `popper` are not valid elements

// Don't set `data-testid` unless it's defined, as it's not in the interface.

// Dropdown & Clear Icons

// E.g. a tooltip's position is on the 'right', it should enter from and exit to the 'left'

// END: Modifications

// END: fast-deep-equal

// END: react-fast-compare

// ES3:

// ESM COMPAT FLAG

// EXPORTS

// EXTERNAL MODULE: ./node_modules/@atlaskit/analytics-next-stable-react-context/dist/esm/index.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/useAnalyticsContext.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/useAnalyticsEvents.js + 5 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/analytics-next/dist/esm/hooks/useTrackedRef.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/button/dist/esm/button.js + 5 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/button/dist/esm/loading-button.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/hooks/use-auto-focus.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/ds-lib/dist/esm/utils/noop.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/dist/esm/components/styles.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/dist/esm/components/utils.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/backlog.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/check-circle.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/check.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/chevron-down.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/copy.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/cross-circle.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/error.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/info.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/icon/glyph/question-circle.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/spinner/dist/esm/spinner.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@atlaskit/theme/dist/esm/components/theme.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/theme/dist/esm/constants.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/theme/dist/esm/typography.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/tokens/dist/esm/constants.js

// EXTERNAL MODULE: ./node_modules/@atlaskit/tokens/dist/esm/get-token.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js

// EXTERNAL MODULE: ./node_modules/@emotion/cache/dist/cache.browser.esm.js + 1 modules

// EXTERNAL MODULE: ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js

// EXTERNAL MODULE: ./node_modules/@emotion/react/dist/emotion-react.browser.esm.js + 2 modules

// EXTERNAL MODULE: ./node_modules/@emotion/stylis/dist/stylis.browser.esm.js

// EXTERNAL MODULE: ./node_modules/@emotion/unitless/dist/unitless.browser.esm.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.concat.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.find.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.map.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.slice.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.some.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.splice.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.date.to-json.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.keys.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.symbol.description.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.symbol.js

// EXTERNAL MODULE: ./node_modules/lodash/set.js

// EXTERNAL MODULE: ./node_modules/react-dom/index.js

// EXTERNAL MODULE: ./node_modules/react-hook-form/dist/index.esm.mjs

// EXTERNAL MODULE: ./node_modules/react-is/cjs/react-is.production.js

// EXTERNAL MODULE: ./node_modules/react-query/es/core/focusManager.js

// EXTERNAL MODULE: ./node_modules/react-query/es/core/logger.js

// EXTERNAL MODULE: ./node_modules/react-query/es/core/notifyManager.js

// EXTERNAL MODULE: ./node_modules/react-query/es/core/retryer.js

// EXTERNAL MODULE: ./node_modules/react-query/es/core/utils.js

// EXTERNAL MODULE: ./node_modules/react-query/es/index.js

// EXTERNAL MODULE: ./node_modules/react-scrolllock/dist/index.js

// EXTERNAL MODULE: ./node_modules/react-uid/dist/es2015/uid.js

// EXTERNAL MODULE: ./node_modules/react/index.js

// EXTERNAL MODULE: ./node_modules/react/jsx-runtime.js

// EXTERNAL MODULE: ./node_modules/tiny-invariant/dist/esm/tiny-invariant.js

// EXTERNAL MODULE: ./node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js

// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/components/forms/forms.module.scss

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/contexts/actions/CommonWizardActions.ts

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/contexts/actions/OidcWizardActions.ts

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/contexts/actions/SamlWizardActions.ts

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/hooks/draftHooks.ts + 1 modules

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/scss-modules/margins.module.scss

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/utilities/Protocols.ts

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/utilities/UrlParams.ts

// EXTERNAL MODULE: ./src/main/frontend/src/idp-setup/src/utilities/combineClass.ts

// EXTERNAL MODULE: ./src/main/frontend/src/shared/utilities/KSSOError.ts

// EXTERNAL MODULE: ./src/main/frontend/src/shared/utilities/SessionStorage.ts

// Either this is the first call, activity has stopped and we're at the

// Elements may need animation styles back after initial mount (they could animate out)

// Ensure tabPanel exists in case it has been removed

// Ensure the hash is encoded properly before doing anything else.

// Ensure we always have a properly-encoded hash.

// Event captured by dropdown indicator

// Execute query

// Exit early for strings to avoid a performance hit in some environments.

// Export types from PopperJS / React Popper

// Expose `MapCache`.

// Expression?

// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it

// FF44- legacy iterators case

// FIXME: remove in 2025

// FORMAT PRESETS

// FUNCTIONS

// Fallback.

// Fetch

// Fetch first page

// Fetch first page?

// Fetch if there are subscribers

// Fetch previous page?

// Fetch remaining pages

// Field name

// Field value

// Filter out any day of month value that is larger than given month expects

// Final cleanup just in case this modal dialog did not have a wrapping modal transition.

// Finish the basic string with a delimiter unless it's empty.

// Fire all registered modal dialogs to update their position in the stack.

// Fire the callback

// Firefox wants us to check `-x` and `-y` variations as well

// First trigger the configuration callbacks

// First trigger the mutate callbacks

// First, attempt with faster native method

// Fix browsers whose `exec` methods don't consistently return `undefined`

// Fixes https://github.com/popperjs/popper-core/issues/1223

// Flex-grow set to 0 to prevent this element from filling its parent flexbox container

// Flip the menu, render below

// Flow doesn't support to extend this property, but it's the most

// Focus styles used when :focus-visible isn't supported

// For any further changes, ensure that the container does not have a

// For high frequency updates (e.g. `resize` and `scroll` events), always

// For that scenario we cleanup when the component unmounts.

// Function instances `.name` property

// Get Scroll Parent

// Get all the valid discriminator values

// Get bounding client object

// Get theme from the user's props

// Gets the closest ancestor positioned element. Handles some edge cases,

// Gets the entire size of the scrollable document area, even extending outside

// Gets the maximum area that the element is visible in due to any number of

// Getters

// Give up, the result is false

// Giving disabled styles preference over active by listing them after.

// Guess that the current item starts a range

// HOOK

// Handle <iframe>s

// Handle case when range contains 7 instead of 0 and translate this value to 0

// Handle error boundary

// Handle invocations in a tight loop.

// Handle result property usage tracking

// Handle suspense

// Handle the basic code points.

// Handle the last few bytes of the input array

// Helper for a popular repeating case of the spec:

// Hide TabLine on focus

// Hide the clear indicator on Edge (Windows only)

// Hour

// Hour is specified

// I really want to avoid writing a BCP 47 parser

// I'm just going to ignore that

// IE 11 has no ShadowRoot

// IE 11 sometimes throws when accessing window.history.state

// IE8 returns string on undefined

// IE8- don't enum bug keys

// IE9- / Bun 0.3.0- setTimeout / setInterval / setImmediate additional parameters fix

// INFO

// ISO and SQL parsing

// ISO duration parsing

// ISO time parsing

// If <html> has a CSS width greater than the viewport, then this will be

// If `value` or `defaultValue` props are not empty then announce them

// If a panel has already been visited, don't unmount it

// If an offset has been passed and we have not been called from

// If constructor does not have an Object-specific method

// If format not supported (or no theme provided), return standard theme

// If has modified constructor

// If has modified prototype

// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).

// If it's different, we're in a hole time. The offset has changed, but the we don't adjust the time

// If not, change the ts by the difference in the offset

// If so, offset didn't change and we're done

// If that gives us the local time we want, we're done

// If the 'initial-input-focus' action has been set already

// If the mutation fails, use the context returned from onMutate to roll back

// If the path exists, push it onto the end.

// If the reference is clipped, the ratio is 0. Throttle the refresh

// If the theme prop is a function, assume the function

// If the transport layer does not support cancellation

// If there is no container element, we should exit early, because that

// If there was an active tooltip; we tell it to remove itself at once!

// If these status codes are returned, attempt to handle response further

// If we used the selected variable this would regenerate each time

// If we were not showing yet anyway; finish straight away

// If you are going to have child components that require analytics use withAnalytics

// Ignore already escaped sequences.

// Ignore extraneous popstate events in WebKit.

// Ignore this change; we already setState in push/replace.

// Ignoring events from the container ref

// Ignoring this warning will mean the analytics context of child components will not

// Important!

// In development mode we want to capture any feature flag checks that happen using the default resolver and log this result when the resolver is replaced.

// In non-strict mode we allow a slash at the end of match. If the path to

// In testing environments, the `width` and `height` properties are empty

// In the context of a TransitionGroup all enters are really appears

// In theory there could be aribitrary day periods. We're gonna assume there are exactly two

// Include callbacks in batch renders

// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.

// Increase a second in case in the first iteration the currentDate was not

// Initialize the hash

// Initialize the state.

// Inline parsing functions

// Inspired by https://github.com/garycourt/murmurhash-js

// Instead, we just default to 0 for keys we don't know.

// Instead, we just default to 0 for paths we don't know.

// Instead, we'll do this:

// Invalid range, return value

// Invert the entrance and exit directions.

// Invoke the leading edge.

// Is input expression predefined?

// It's a high surrogate, and there is a next character.

// It's an unmatched surrogate; only append this code unit, in case the

// Iterate over the tokens and create our regexp string.

// JS DOW is in range of 0-6 (SUN-SAT) but we also support 7 in the expression

// JSON[@@toStringTag] property

// Jumped into a not existent date due to a DST transition

// Just smashing the existing onClick for good measure

// Keep previous data if needed

// Keep previous query key if the user does not supply one

// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.

// Let integer be ? ToInteger(index).

// Lifecycle

// Listen to all scroll events, and filter them out inside of 'onScroll'

// Listen to online

// Listen to visibillitychange and focus

// Load Date class extensions

// Log error

// Log the error to an error reporting service

// Lose focus when becoming disabled (standard button behaviour)

// Low surrogate.

// MISC

// MS Edge converts symbol values to JSON as {}

// Main encoding loop:

// Make sequence linear

// Make sure results are optimistically set in fetching state before subscribing or updating options

// Make sure we reference the latest query as the current one might have been removed

// Match Express-style parameters and un-named parameters with a prefix

// Match any characters still remaining.

// Match anything that isn't a dot or bracket.

// Match escaped characters that would otherwise appear in future matches.

// Match hour

// Match minute

// Match month

// Match second

// Math is off by 1 when dayOfWeek isn't divisible by 7

// Math[@@toStringTag] property

// Memoize placeholder data

// Memoize select result

// Menu Component

// Merge Utility

// Methods

// Mimic the behavior of DOM histories by

// Minute

// Misc.

// Misc. Instance Properties

// Mix 4 bytes at a time into the hash

// Mobile Device Detector

// Mobile Safari ignores { overflow: hidden } declaration on the body,

// Mobile Safari ignores { overflow: hidden } declaration on the body.

// Mocked nodes in testing environments may not be instances of Node. By

// Modifiers have the ability to reset the current update cycle. The

// Month

// Motions will always appear if not inside a exiting persistence component.

// Mouse Handlers

// NAMESPACE OBJECT: ./node_modules/@atlaskit/select/dist/esm/components/index.js

// NB: This can be resolved if this component, composes base SVG / and/or skeleton

// NB: mutates parameters

// NOTE: Modal dialogs that don't have a wrapping modal transition component won't flow through here!

// NOTE: This is equivalent to

// NUMBERS AND STRINGS

// Name the function so it is clearer in the documentation

// Nashorn bug:

// Needed to position overlay

// Needing to add !important to overcome specificity issue caused by deprecated AtlaskitThemeProvider

// Node.js 0.8-

// Node.js 0.9+ & IE10+ has setImmediate, otherwise:

// Normalized Scroll Top

// Normalized scrollTo & scrollTop

// Not all fixed-offset zones like Etc/+4:30 are present in tzdata so

// Not using '&:disabled' because :disabled is not a valid state for all element types

// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js

// Note: this new 'context'

// Note: we cannot disable pointer events when there is an overlay.

// Notify cache callback

// Notify on fail

// Number('+0x1') should be NaN, old V8 fix

// OBJECTS AND ARRAYS

// OUTPUT

// Offsets are the actual position the popper needs to have to be

// Offsets can be applied only to the popper element

// Older browsers don't support a `document` as the root and will throw an

// On each update cycle, the `modifiersData` property for each modifier

// On initial mount if elements aren't set to animate on appear, we return early and callback

// On visiting object, check for its dependencies and visit them recursively

// One-arg form: push(location)

// Only call onHideHandler if we have called onShowHandler

// Only invoke if we have `lastArgs` which means `func` has been

// Only multiselects support value focusing

// Only notify if something has changed

// Only styles that affect the TabList itself have been applied via primitives.

// Only styles that affect the Tabs container itself have been applied via primitives.

// Optimistically set result in fetching state if needed

// Optimistically update state if needed

// Optimistically update to the new value

// Orders the modifiers based on their dependencies and `phase`

// Our UTC time is just a guess because our offset is just a guess

// PARSING

// Parser path:

// Passive Event Detector

// Persist the current range and start a new one with current item

// PhantomJS / old WebKit fails here:

// PhantomJS / old WebKit has a broken implementations

// Popper 1 is broken in this case and never had a bug report so let's assume

// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86

// Preact uses an empty array as children by

// Prefer 0-6 range when serializing day of week field

// Prepend partial segment prefixes.

// Prevent retrying failed query if the error boundary has not been reset yet

// Prevent update loops when using the `size` middleware.

// Previously they may have been able to pass in undefined without things blowing up.

// Promise.resolve without an argument throws an error in LG WebOS 2

// Public interface

// Push the current path onto the tokens.

// Putting all children in the center

// RFC 2822/5322

// RFC2822-like format without the required timezone offset (used in tests)

// React 15 compat

// React v16.11 and below

// React v16.12 and above

// Recursively convert values (susceptible to call stack limits).

// Reds

// Refetch pages

// Refs

// RegExp[@@split] doesn't call the regex's exec method, but first creates

// Remove all properties with a value of 0 from an object

// Remove animation props not meant for HTML elements

// Remove comments and folding whitespace and replace multiple-spaces with a single space

// Remove default focus styles for mouse interactions if :focus-visible is supported

// Remove ourselves from the modal stack register!

// Remove query after fetching if cache time is 0

// Remove surrounding spaces

// Render any custom fallback UI

// Renderers

// Replace '*' and '?'

// Replace aliases

// Represent delta as a generalized variable-length integer.

// Reset any `maxWait` timer.

// Resolve fields

// Resolve incomplete/relative pathname relative to current location.

// Resolves the different types of theme objects in the current API

// Restart the timer.

// Return a context object with the snapshotted value

// Return corresponding String value for RedirectPolicy

// Return current promise if we are already fetching

// Return false from a transition hook to cancel the transition.

// Return the mutation object so you can access isLoading, isError, etc.

// Return undefined (instead of 0) in these cases, where fraction is not set

// Returns the composite rect of an element relative to its offsetParent.

// Returns the layout rect of an element relative to its offsetParent. Layout

// Round the offsets to the nearest suitable subpixel based on the DPR.

// Runtime labeling is an opt-in feature because:

// START: Modifications:

// START: fast-deep-equal

// START: fast-deep-equal es6/index.js 3.1.3

// START: react-fast-compare

// SVG-related properties

// Safari (WebKit) adds a -webkit-text-fill-color style to disabled inputs

// Safari 12 bug

// Safari 8 has buggy iterators w/o `next`

// Scalar value

// Scroll Helpers

// Scroll Into View

// Scroll focusedOption into view if menuIsOpen is set on mount (e.g. defaultMenuIsOpen)

// Second

// See https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context

// See https://github.com/ReactTraining/history/pull/289

// See: https://github.com/atlassian/extract-react-types/issues/201

// Select option if option is not disabled

// Set @@toStringTag to native iterators

// Set cache time to 1 if the option has been set to 0

// Set data and mark it as cached

// Set focusedOption if menuIsOpen is set on init (e.g. defaultMenuIsOpen)

// Set to fetching state if not already in it

// ShadowRoot detected

// ShadowRoot detected.

// Shouldn't skip holes

// Show placeholder data if needed

// Side effects

// Silently cancel current fetch if the user wants to cancel refetches

// Snapshot the previous value

// Some versions of I.E. have different rules for clearTimeout vs setTimeout

// Split fields

// Start a new range

// Start loop

// Start the timer for the trailing edge.

// Starting DST

// Step into the shadow DOM of the parent of a slotted node.

// Stop if the fetch is already resolved

// Stop the query from being garbage collected

// Store state in case the current fetch needs to be reverted

// Store the reference and popper rects to be read by modifiers

// String elements can't form a range

// String methods call symbol-named RegExp methods

// Strip out disabled modifiers

// Structurally share data between prev and new data if needed

// Style Sheets

// Support anchored sticky behavior.

// Symbol-named RegExp methods call .exec

// Sync update – it will always be executed, even if not necessary. This

// TODO

// TODO: If another transition starts while we're still confirming

// TODO: Internal Option Type here

// TODO: Remove from `core-js@4`

// TODO: Remove from `core-js@4` since it's moved to entry points

// TODO: Remove this module from `core-js@4` since it's replaced to module below

// TODO: Remove this module from `core-js@4` since it's split to modules listed below

// TODO: We could probably make this more reliable by

// TODO: add assert here?

// TODO: ideally not recalculating this object each time

// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`

// TODO: interaction states will be reviewed in DSP-1438

// TODO: remove fallback for next major

// TODO: uncomment the next line when cleaning up validationState prop so it has a default value

// TRANSFORM

// TS believes value can be undefined

// TYPES

// Take a list of functions and return a function that applies the list of

// Tell the tooltip to keep showing

// Test for A's keys different from B.

// Test whether the zone matches the offset for this ts

// Thanks to IE8 for its funny defineProperty

// That is why fixed-offset TZ is set to that unless it is:

// That would be easy for styling, but it would start letting events through on disabled buttons

// The Theme Consumer takes a function as its child - this function takes tokens, and the

// The above generic is used to let ERTC know what props to extract.

// The current range can't be continued

// The first character represents the weekday

// The hidden attribute doesn't work on flex elements

// The other styles applied through the CSS prop are there for styling children

// The timeout is sometimes triggered 1 ms before the stale time expiration.

// The use of `Object#toString` avoids issues with the `typeof` operator

// The user might have explicitly specified hour12 or hourCycle

// Theme is the global Atlaskit theme

// Then the cache listeners

// Then trigger the listeners

// There might be multiple expressions and not all of them will contain

// These are a little braindead. EDT *should* tell us that we're in, say, America/New_York

// These are strings and won't change

// They're not really 'magic', they just happen to work well.

// This allows the user to escape special characters that won't transform.

// This can happen when the query is hydrated or created with setQueryData.

// This file is a singleton for managing tooltips

// This function is memoized in the context

// This gives the effect the tooltip is appearing from the target

// This implementation is based heavily on node's url.parse

// This is a bit of a hack. We have to start listening for location

// This is a blunder on the part of @types/react

// This is because evaluating feature flags when the resolver/FF client is loaded asynchronously could cause unexpected issues.

// This is in the render method instead of useEffect so that

// This is non-exhaustive but covers the most common CSS properties that

// This is problematic. Different calendars are going to define eras totally differently. What I need is the minimum set of dates

// This is safe for quickDT (used by local() and utc()) because we don't fill in

// This is the actual call to server

// This is the most basic placement, and will be adjusted by

// This is to force a repaint,

// This line is a border so it is visible in high contrast mode

// This line is not a border so the selected line is visible in high contrast mode

// This may look unwieldy but means we skip applying styles / cloning if no className is applicable

// This modifier takes the styles prepared by the `computeStyles` modifier

// This shouldn't be necessary, but there are weird race conditions with

// This useEffect is purely for managing the aria attribute when using the

// This will cover both props for invalid state while giving priority to isInvalid. When cleaning up validationState, we can just keep the inner condition.

// This will insert the new element after the previous element.

// To avoid wrapping this component in AnalyticsContext we manually

// To ensure persistent data, use `${name}#persistent`

// To make the animation happen,  we have to separate each rendering and avoid being processed as batched.

// To mitigate this issue we always add 1 ms to the timeout.

// Tools including enzyme rely on components having a display name

// Touch Capability Detector

// Touch Handlers

// Touch Helpers

// Tracking this to prevent changing state on an unmounted component

// Trigger behavior hook

// Try to fetch the data

// Try to return ES6 compatible iterator

// Try to use displayName of wrapped component

// Turn pointer events off when disabled - this makes it so hover etc don't work.

// Two elements do not form a range so split them into 2 single elements

// Two-arg form: push(path, state)

// Types

// UNUSED EXPORTS: CacheProvider, ClassNames, Global, ThemeContext, createElement, keyframes, withEmotionCache

// UNUSED EXPORTS: CacheProvider, Global, ThemeContext, ThemeProvider, __unsafe_useEmotionCache, createElement, useTheme, withEmotionCache, withTheme

// UNUSED EXPORTS: DN100A, DN10A, DN200A, DN20A, DN300A, DN30A, DN400A, DN40A, DN50, DN500A, DN50A, DN600A, DN60A, DN700, DN700A, DN70A, DN800, DN800A, DN80A, G100, G200, G300, G75, N10A, N200A, N300A, N400A, N40A, N50, N500A, N50A, N60, N600, N600A, N700A, N70A, N800A, N80A, N90A, P100, P200, P300, P400, P75, R200, T100, T200, T300, T400, T50, T500, T75, Y100, Y75, background, backgroundActive, backgroundHover, backgroundOnLayer, blue, codeBlock, green, link, linkActive, linkHover, linkOutline, placeholderText, primary, purple, red, skeleton, subtleText, teal, textActive, textHover, yellow

// UNUSED EXPORTS: Grid, GridColumn

// UNUSED EXPORTS: Hydrate, QueryErrorResetBoundary, useHydrate, useInfiniteQuery, useIsFetching, useIsMutating, useQueries, useQueryClient, useQueryErrorResetBoundary

// UNUSED EXPORTS: L

// UNUSED EXPORTS: MemoryRouter, Prompt, Redirect, StaticRouter, __HistoryContext, generatePath, withRouter

// UNUSED EXPORTS: ServerStyleSheet, StyleSheetConsumer, StyleSheetContext, StyleSheetManager, ThemeConsumer, ThemeContext, ThemeProvider, __PRIVATE__, css, isStyledComponent, keyframes, useTheme, version, withTheme

// UNUSED EXPORTS: a, c, d

// UNUSED EXPORTS: locationsAreEqual, parsePath

// UTC-8 or Etc/UTC-8 are not part of tzdata, only Etc/GMT+8 and the like.

// UTILS

// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test

// Units in the supported calendars, sorted by bigness

// Unpack custom variants, and get correct value for the current theme

// Update config if passed, otherwise the config from the last execution is used

// Update refetch interval if needed

// Update result

// Update result to make sure we did not miss any query updates

// Update scope after draft has been loaded

// Update stale interval if needed

// Update state so the next render will show the fallback UI.

// Updates dropdown to fit with chosen values

// Use "clip" overflow to allow ellipses on x-axis without clipping descenders

// Use `internal/copy-constructor-properties` helper in `core-js@4`

// Use a negative lookahead to match only capturing groups.

// Use default value

// Use global "process" variable and process.env['FLAG_NAME'] syntax, so it can be replaced by webpack DefinePlugin

// Use prev data if an isDataEqual function is defined and returns `true`

// Use the clientRect sizes if it's not been transformed.

// Use the default theme if there are no customisations.

// Use the options from the first observer with a query function if no function is found.

// User isn't required to provide both light and dark values

// Using lastState here because motion is not picking up the latest value

// Using prevent default as a signal that parent tooltips

// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables

// V8 ~ Chrome 36-

// V8 ~ Chrome 45- bug

// V8 ~ Chromium 42- fails only with 5+ elements

// Validate range

// Validate timespan

// Variable

// Verify that the code above has been dead code eliminated (DCE'd).

// WARNING: This hook will only function correctly for leaf node components - as in

// WSH

// We access the stack index ref instead of state because this closure will always only

// We add a fragment to ensure we don't break people upgrading.

// We are closing the modal dialog using a wrapping modal transition component.

// We are done if the query does not need to be retried

// We are opening the modal dialog.

// We can remove it whenever the bug is fixed.

// We can't detect it synchronously, so just check versions

// We can't rely on NODE_ENV === 'test' if its value is already configured by the consumer to some other value, so better to use JEST_WORKER_ID

// We can't use @@species feature detection in V8 since it causes

// We can't use real regex here since it causes deoptimization

// We can't use this feature detection in V8 since it causes

// We can't use window.location.hash here because it's not

// We cannot tell if a hashchange was caused by a PUSH, so we'd

// We cannot tell if a hashchange was caused by a REPLACE, so we'd

// We convert children to an array using this helper method as it will add keys to children that do not

// We could then simplify how common styles are dealt with simply by encapsualting them

// We don't expect any of the above to throw, but better to be safe.

// We dynamically set this so we either clean up on the next effect - or on unmount.

// We found another item that matches the current range

// We ignore any boolean children to make our code a little more simple later on,

// We ignore this for onFinishMotion as consumers could potentially inline the function

// We need Promise#{ catch, finally } in the pure version for preventing prototype pollution

// We override this and make the inner container turn it off instead.

// We should still report in case we break this code.

// We use React.Children.forEach instead of React.Children.toArray().find()

// We use aria-posinset so we don't rely on the selected variable

// We use event bubbling here to listen to any child element mouse down event.

// We want to make it easier for consumers so we go down this path unfortunately.

// When a user supplies  a ref to focus we enable this hook

// When handling many dates, calculating the offset for now every time is

// When mutate is called:

// When there is no prior location and pathname is empty, set it to /

// When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally

// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally

// Where possible: https://cldr.unicode.org/translation/date-time/date-time-symbols

// Whether to use backwards directionality when searching

// With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.

// Without this type annotation on Box we don't get autocomplete for props due to forwardRef types

// Works with __proto__ only. Old v8 can't work with null proto objects.

// Would love a way to avoid disabling this rule, but we need

// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`

// ZodObject<

// Zooming can change the DPR, but it seems to report a value that will

// \d\d?

// ^(? + rx + ) is needed, in combination with some str slicing, to

// ^--- the above values aren't used directly they remain because its exposed by the `textFieldColors` export

// _usually_(not always since there could be multiple style tags)

// `%ArrayIteratorPrototype%.next` method

// `%IteratorPrototype%[@@iterator]()` method

// `%StringIteratorPrototype%.next` method

// `.offsetParent` reports `null` for fixed elements, while absolute elements

// `2` may be desired in some cases – research later

// `AdvanceStringIndex` abstract operation

// `Array.from` method

// `Array.from` method implementation

// `Array.isArray` method

// `Array.prototype.concat` method

// `Array.prototype.entries` method

// `Array.prototype.every` method

// `Array.prototype.filterReject` method

// `Array.prototype.filter` method

// `Array.prototype.findIndex` method

// `Array.prototype.find` method

// `Array.prototype.flatMap` method

// `Array.prototype.forEach` method

// `Array.prototype.forEach` method implementation

// `Array.prototype.includes` method

// `Array.prototype.indexOf` method

// `Array.prototype.join` method

// `Array.prototype.keys` method

// `Array.prototype.map` method

// `Array.prototype.reduceRight` method

// `Array.prototype.reduce` method

// `Array.prototype.reverse` method

// `Array.prototype.slice` method

// `Array.prototype.some` method

// `Array.prototype.splice` method

// `Array.prototype.values` method

// `Array.prototype[@@iterator]` method

// `ArraySpeciesCreate` abstract operation

// `Assert: IsCallable(argument) is true`

// `Assert: IsConstructor(argument) is true`

// `Assert: Type(argument) is Object`

// `CreateArrayIterator` internal method

// `CreateHTML` abstract operation

// `CreateIterResultObject` abstract operation

// `Date.prototype.toISOString` method

// `Date.prototype.toISOString` method implementation

// `Date.prototype.toJSON` method

// `Date.prototype.toString` method

// `Date.prototype[@@toPrimitive](hint)` method implementation

// `Date.prototype[@@toPrimitive]` method

// `Function#toString` throws on some built-it function in some legacy engines

// `Function.prototype.bind` method

// `Function.prototype.bind` method implementation

// `GetMethod` abstract operation

// `GetSubstitution` abstract operation

// `HasOwnProperty` abstract operation

// `IsArray` abstract operation

// `IsCallable` abstract operation

// `IsConstructor` abstract operation

// `IsRegExp` abstract operation

// `JSON.stringify` method

// `LengthOfArrayLike` abstract operation

// `Map.prototype.get(key)` method

// `Map.prototype.set(key, value)` method

// `Map` constructor

// `Math.trunc` method

// `NewPromiseCapability` abstract operation

// `Number.isNaN` method

// `Number.parseInt` method

// `Object.assign` method

// `Object.create` method

// `Object.defineProperties` method

// `Object.defineProperty` method

// `Object.entries` method

// `Object.freeze` method

// `Object.getOwnPropertyDescriptor` method

// `Object.getOwnPropertyDescriptors` method

// `Object.getOwnPropertyNames` method

// `Object.getOwnPropertySymbols` method

// `Object.getPrototypeOf` method

// `Object.isExtensible` method

// `Object.keys` method

// `Object.prototype.propertyIsEnumerable` method implementation

// `Object.prototype.toString` method

// `Object.prototype.toString` method implementation

// `Object.setPrototypeOf` method

// `Object.values` method

// `OrdinaryToPrimitive` abstract operation

// `Promise.all` method

// `Promise.prototype.catch` method

// `Promise.prototype.then` method

// `Promise.race` method

// `Promise.reject` method

// `Promise.resolve` method

// `Promise` constructor

// `RegExp.prototype.exec` method

// `RegExp.prototype.flags` getter implementation

// `RegExp.prototype.toString` method

// `RegExp.prototype[@@replace]` method

// `RegExp.prototype[@@search]` method

// `RegExpExec` abstract operation

// `RequireObjectCoercible` abstract operation

// `SameValue` abstract operation

// `Set.prototype.add(value)` method

// `SpeciesConstructor` abstract operation

// `String.fromCodePoint` method

// `String.prototype.at` method

// `String.prototype.bold` method

// `String.prototype.codePointAt` method

// `String.prototype.endsWith` method

// `String.prototype.includes` method

// `String.prototype.matchAll` method

// `String.prototype.padEnd` method

// `String.prototype.padStart` method

// `String.prototype.repeat` method implementation

// `String.prototype.replace` method

// `String.prototype.search` method

// `String.prototype.small` method

// `String.prototype.trim` method

// `String.prototype.{ trimLeft, trimStart }` methods

// `String.prototype.{ trimRight, trimEnd }` methods

// `String.prototype[@@iterator]` method

// `Symbol.asyncIterator` well-known symbol

// `Symbol.for` method

// `Symbol.iterator` well-known symbol

// `Symbol.keyFor` method

// `Symbol.prototype.description` getter

// `Symbol.prototype[@@toPrimitive]` method

// `Symbol.prototype[@@toStringTag]` property

// `Symbol.toPrimitive` well-known symbol

// `Symbol.toStringTag` well-known symbol

// `Symbol` constructor

// `ToIntegerOrInfinity` abstract operation

// `ToLength` abstract operation

// `ToObject` abstract operation

// `ToPrimitive` abstract operation

// `ToPropertyKey` abstract operation

// `URL.createObjectURL` method

// `URL.prototype.hash` accessors pair

// `URL.prototype.host` accessors pair

// `URL.prototype.hostname` accessors pair

// `URL.prototype.href` accessors pair

// `URL.prototype.origin` getter

// `URL.prototype.password` accessors pair

// `URL.prototype.pathname` accessors pair

// `URL.prototype.port` accessors pair

// `URL.prototype.protocol` accessors pair

// `URL.prototype.searchParams` getter

// `URL.prototype.search` accessors pair

// `URL.prototype.toJSON` method

// `URL.prototype.toString` method

// `URL.prototype.username` accessors pair

// `URL.revokeObjectURL` method

// `URLSearchParams.prototype.append` method

// `URLSearchParams.prototype.delete` method

// `URLSearchParams.prototype.entries` method

// `URLSearchParams.prototype.forEach` method

// `URLSearchParams.prototype.getAll` method

// `URLSearchParams.prototype.get` method

// `URLSearchParams.prototype.has` method

// `URLSearchParams.prototype.keys` method

// `URLSearchParams.prototype.set` method

// `URLSearchParams.prototype.size` getter

// `URLSearchParams.prototype.sort` method

// `URLSearchParams.prototype.toString` method

// `URLSearchParams.prototype.values` method

// `URLSearchParams.prototype[@@iterator]` method

// `URLSearchParams` constructor

// `URL` constructor

// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances

// `initial`

// `maxTouchPoints` works on IE10/11 and Surface

// `ontouchstart` check works on most browsers

// `parseInt` method

// `thisNumberValue` abstract operation

// `undefined` case is a Chromium 117 bug

// `webpack` dev server bug on IE global methods - use bind(fn, global)

// `{ Map, Set }.prototype.clear()` methods

// `{ Map, Set }.prototype.delete(key)` methods

// `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods

// `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods

// `{ Map, Set }.prototype[@@species]` accessors

// `{ Map, Set}.prototype.has(key)` methods

// a different month

// a new one. We need to return the patched regex when creating the new one.

// a part of `ArraySpeciesCreate` abstract operation

// a string of all valid unicode whitespaces

// a) if the string has no -u extensions, just leave it alone

// aborting a wait to hide

// aborting hide animation

// absolutely positioned element rendered above the viewport (only below).

// account for possible declaration `width: 100%;` on body

// account for touch devices

// adapted from moment.js: https://github.com/moment/moment/blob/000ac1800e620f770f4eb31b5ae908f6167b0ab2/src/lib/units/week-calendar-utils.js

// add "__proto__" for Object.getPrototypeOf polyfill

// add a flag to not completely full polyfills

// add a key to Array.prototype[@@unscopables]

// add all tabbables inside and within shadow DOMs in DOM order

// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative

// add if node is tabbable itself

// add issues from dirty option

// add missing metadata

// add to index

// adjust scroll if the window has been resized since the lock was engaged

// aliased for consumers

// all object keys, includes non-enumerable and symbols

// all other properties should be traversed as usual

// all use the same **instance** of context, regardless

// allows focus to reach elements outside the modal if they contain the data-atlas-extension attribute

// allows for nested Transitions

// already waiting to hide

// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898

// an alias (using an arrow function was what caused 2651).

// an edge case with no tabbable elements

// and also filter out any falsies (empty strings, nulls, and undefined).

// and applies them to the HTMLElements such as popper and arrow

// and create an unstable reference

// and not just that we're in -240 *right now*. But since I don't think these are used that often

// and optional suffixes. Matches appear as:

// and serious performance degradation in V8

// and there will be very few iterations of this generally

// and we could have a special build just for that

// and we're not properly parsing this, so just strip out the

// and you can only have one source map per style tag

// anymore

// anything leftover becomes the decimal for the last unit

// anything we haven't boiled down yet should get boiled to this unit

// anyway.

// apply the lock styles and padding if this is the first scroll lock

// apply the offset and substitute the zone as needed.

// are present, and so on.

// are right on a time change boundary (we'll just correct in the other

// aren't  *),  the command will be run when either field matches the cur-

// argumentsList[@@iterator] is %ArrayProto_values%

// arrow is optional + virtual elements

// as the second character will happen less often than

// assume we have the higher-order units

// at their appropriate level and/or having a singular approach to css variables in the package

// at-rule

// attach the stylesheet and inject styles on [un]mount

// attribute back into the tooltipTriggerProps and make it required

// b) if it does, use Intl to resolve everything

// background, box-shadow

// backtrack cursor by 1

// bail early if no element is available to attach to

// bail early if no element is available to detach from

// bail early if required elements aren't present

// base64url encoding is a modification of base64 that can safely be used in URLs and filenames

// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js

// be the first ones in prod and generally later in dev

// because this calculation ignores time zones

// because this module is primarily intended for the browser and node

// because we don't have any way to figure out what they are

// because we have tabIndex = -1 when disabled,

// because we're using hour12 and https://bugs.chromium.org/p/chromium/issues/detail?id=1025564&can=2&q=%2224%3A00%22%20datetimeformat

// best way to handle this.

// between creating the observer and subscribing to it.

// bottom limit

// browsers currently implement this as a property, but spec says it should be a getter function

// browsers give this different errors name and messages:

// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339

// but ToNumber should return NaN if a string contains unavailable symbols

// but doesn't do any validation, makes a bunch of assumptions about what units

// but for some reason `nativeSlice.call(result, 1, result.length)` (called in

// but it's also required in react native and similar environments sometimes

// but their correct versions are not interesting for us

// but this is much easier and the native packages

// by handling the zone options

// bytes are well-incorporated.

// c) if Intl fails, try again without the -u

// cache of {numberingSystem: {append: regex}}

// cache offsets for zones based on the current timestamp when this function is

// cached from whatever global is present so that test runners that stub it

// call something on iterator step with safe closing on error

// can throw

// can't set metadata to uncaught frozen object

// cancel mouse events when disabled

// cancel scroll

// cannot get keys using array notation with DOMRect

// cases:

// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.

// causing a render after a cancelled POP.

// change existing entry

// changes here in the constructor in case there are any <Redirect>s

// charcode for b

// charcode for l

// check for visited object

// check on default Array iterator

// check that a method works with the correct list

// check the existence of a method, lowercase

// checks if the start is equal to or before the end

// chrome/safari: "RangeError", "Maximum call stack size exceeded"

// class name could be used further down

// cleanly divide the values into the appropriate subpixels.

// clear cherrypick actions map on new test run

// clipping (or hiding) overflowing elements with a position different from

// clipping parents

// clone really means "create another instance just like this one, but with these changes"

// clone really means, "make a new object with these modifications". all "setters" really use this

// clone(), we can trust it and avoid the offset calculation.

// close the menu if the user taps outside

// component at different URLs.

// compute the actual time

// configure ourselves to deal with gregorian dates or week stuff

// consider others as "visible"

// consistent across browsers - Firefox will pre-decode it!

// const AugmentFactory =

// const activeElement = document && getActiveElement();

// const instanceOfType = <T extends new (...args: any[]) => any>(

// const m = 0x5bd1e995;

// const r = 24;

// constructor polyfill

// contained in target

// content can grow and shrink

// contentDocument of iframe will be null if current origin cannot access it

// contextual error map is first priority

// convert a calendar object to a epoch timestamp

// convert a calendar object to a local timestamp (epoch, but with the offset baked in)

// convert an epoch timestamp into a calendar object with the given offset

// copy the array, because we cache it internally

// create a containing block.

// create a new DT instance by adding a duration, adjusting for DSTs

// create collection constructor

// cross-realm fallback

// custom handling for DOM elements

// custom handling for React/Preact

// dates

// day of month, and day of week.  If  both	 fields	 are  restricted  (ie,

// debounced at least once.

// deep merge for vals

// default, so use null if that's the case.

// defaults for unspecified units in the supported calendars

// define iterator

// deoptimization and performance degradation

// deoptimization and serious performance degradation

// different bundles or microfrontends they will

// different way. If there is no target element yet or tooltipId, we also

// direction). Using a timestamp from first read is a slight optimization for

// disabling browser focus outline

// disabling hover and active color changes when there is an overlay, but the button is not disabled

// document global can be unavailable in react native

// don't break things.  But we need to wrap it in a try catch in case it is

// don't capture the event if the menu opens on focus and the focused

// don't cycle from the start to the end

// don't hoist over string (html) components

// don't || this because we want to preserve -0

// e.g. invalidateQueries({ active: false }), we don't want to refetch active queries

// e.g. mobile safari dynamic chrome heights

// early implementations not supports chaining

// edge: "Error", "Out of stack space"

// effective way to apply styles to an HTMLElement

// elements with explicit roles will also use explicit tabindex

// ellipsis for overflow text

// empty string to avoid regexp issues

// end fast-deep-equal

// ensure focus is on the Input when the menu opens

// ensure focus is restored correctly when the control becomes enabled

// ensure select state gets blurred in case Select is programmatically disabled while focused

// ensure select state gets focused in case Select is programatically re-enabled while focused (Firefox)

// era

// eras

// error.

// eslint-disable-line no-alert

// eslint-disable-line no-new-wrappers

// eslint-disable-line no-unused-vars -- required for `.length`

// eslint-disable-next-line @atlaskit/design-system/ensure-design-token-usage

// eslint-disable-next-line @atlaskit/design-system/ensure-design-token-usage-spacing

// eslint-disable-next-line @atlaskit/design-system/use-tokens-space

// eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix

// eslint-disable-next-line @atlaskit/ui-styling-standard/no-unsafe-selectors

// eslint-disable-next-line @atlaskit/ui-styling-standard/no-unsafe-values

// eslint-disable-next-line @atlaskit/ui-styling-standard/no-unsafe-values -- Ignored via go/DSP-18766

// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766

// eslint-disable-next-line @repo/internal/react/consistent-css-prop-usage

// eslint-disable-next-line @repo/internal/react/disallow-unstable-values

// eslint-disable-next-line @repo/internal/react/no-clone-element

// eslint-disable-next-line @repo/internal/react/no-unsafe-spread-props

// eslint-disable-next-line @repo/internal/react/require-jsdoc

// eslint-disable-next-line @repo/internal/react/use-noop

// eslint-disable-next-line @repo/internal/styles/no-exported-styles

// eslint-disable-next-line @repo/internal/styles/no-nested-styles

// eslint-disable-next-line @typescript-eslint/ban-types

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types

// eslint-disable-next-line @typescript-eslint/no-explicit-any

// eslint-disable-next-line @typescript-eslint/no-this-alias

// eslint-disable-next-line ban/ban

// eslint-disable-next-line es/no-array-from -- required for testing

// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing

// eslint-disable-next-line es/no-array-isarray -- safe

// eslint-disable-next-line es/no-array-prototype-find -- testing

// eslint-disable-next-line es/no-array-prototype-findindex -- testing

// eslint-disable-next-line es/no-array-prototype-foreach -- safe

// eslint-disable-next-line es/no-array-prototype-includes -- detection

// eslint-disable-next-line es/no-function-prototype-bind -- detection

// eslint-disable-next-line es/no-function-prototype-bind -- safe

// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe

// eslint-disable-next-line es/no-global-this -- safe

// eslint-disable-next-line es/no-math-trunc -- safe

// eslint-disable-next-line es/no-number-parseint -- required for testing

// eslint-disable-next-line es/no-object-create -- safe

// eslint-disable-next-line es/no-object-defineproperties -- safe

// eslint-disable-next-line es/no-object-defineproperty -- required for testing

// eslint-disable-next-line es/no-object-defineproperty -- safe

// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe

// eslint-disable-next-line es/no-object-getownpropertynames -- safe

// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing

// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe

// eslint-disable-next-line es/no-object-getprototypeof -- required for testing

// eslint-disable-next-line es/no-object-getprototypeof -- safe

// eslint-disable-next-line es/no-object-hasown -- safe

// eslint-disable-next-line es/no-object-is -- safe

// eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe

// eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing

// eslint-disable-next-line es/no-object-keys -- safe

// eslint-disable-next-line es/no-object-setprototypeof -- safe

// eslint-disable-next-line import/no-unused-modules

// eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex

// eslint-disable-next-line jsx-a11y/no-static-element-interactions

// eslint-disable-next-line max-statements -- TODO

// eslint-disable-next-line no-console

// eslint-disable-next-line no-console -- safe

// eslint-disable-next-line no-extend-native -- required

// eslint-disable-next-line no-new-func -- fallback

// eslint-disable-next-line no-prototype-builtins -- safe

// eslint-disable-next-line no-restricted-globals -- safe

// eslint-disable-next-line no-self-assign -- dirty hack

// eslint-disable-next-line no-self-compare -- NaN check

// eslint-disable-next-line no-underscore-dangle

// eslint-disable-next-line no-unused-vars -- required for .length

// eslint-disable-next-line no-unused-vars -- required for `.length`

// eslint-disable-next-line no-useless-assignment -- avoid memory leak

// eslint-disable-next-line no-useless-call -- required for testing

// eslint-disable-next-line prefer-rest-params

// eslint-disable-next-line react-hooks/exhaustive-deps

// eslint-disable-next-line react/no-array-index-key

// eslint-disable-next-line react/no-did-update-set-state

// eslint-disable-next-line react/prop-types

// eslint-disable-next-line redos/no-vulnerable -- safe

// eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive

// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing

// eslint-disable-next-line unicorn/relative-url-style -- required for testing

// event if clicking in the button's own padding

// every

// example message: '[OIDC-MW1EJY4X7F] Failed performing OIDC GET reque…om/{tenant}/v2.0/.well-known/openid-configuration'

// example, if we handle a date in June while we're in December in a zone that

// exclude `base` from the options

// expensive. It's just a guess, so we can cache the offset to use even if we

// export additional methods

// extend<

// extracted by mini-css-extract-plugin

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window

// fallback for non-array-like ES3 and non-enumerable old V8 strings

// fallback for not array-like ES3 strings and DOM objects

// falls through

// fast case

// fast equal of /^0b[01]+$/i

// fast equal of /^0o[0-7]+$/i

// faster, simpler, safer

// fetching again when directly mounting after suspending

// filter

// filter nulls

// filterReject

// finalize string values (regular strings and functions interpolated into css calls)

// find

// find the right offset a given local time. The o input is our guess, which determines which

// findIndex

// fire an event on the atlaskit channel

// firefox: "InternalError", too much recursion"

// first called. When we are handling a datetime from components like (year,

// first element

// first try only tabbable, and the fallback to all focusable, as long as at least one element should be picked for focus

// fix Array.prototype.{ values, @@iterator }.name in V8 / FF

// fix for Safari 12.0 bug

// fix native

// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods

// focus above lock

// focus below lock

// focus is inside

// for AM and PM. This is probably wrong, but it's makes parsing way easier.

// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/

// for a tiny bit of correctness that won't matter in the real world

// for example for { years: 2.5, days: 0, seconds: 0 } we want to get { years: 2, days: 182, hours: 12 }

// for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that

// force css to recompute when value change due to @emotion bug.

// foreground

// fractional seconds

// frozen object case

// function because try/catches deoptimize in certain engines.

// functions from left to right

// get a new location before the <Router> is mounted.

// get next entry

// get rid of any default styles

// getSnapshotBeforeUpdate(prevProps) {

// getting tag from ES6+ `Object.prototype.toString`

// giving active styles preference by listing them after focus

// global local side effect to countain recursive lock activation and resolve focus-fighting

// gregorian data + weekday serves only to validate

// handle refs changes - added or removed

// handles 'first'

// handling dates close to the current date, since those dates will usually be

// have the initial state and not any of the later values.

// have them, such as when we have hardcoded children that are conditionally rendered.

// having "@" as the first character

// helper useful in turning the results of parsing into real dates

// helps handle the details

// here because toArray adds keys to all child elements and we do not want

// higher-order units from tsNow (as we do in fromObject, this requires that

// hours

// http date

// http://fb.me/prop-types-in-prod

// http://unixhelp.ed.ac.uk/CGI/man-cgi?crontab+5

// https://bugs.chromium.org/p/chromium/issues/detail?id=830565

// https://bugs.chromium.org/p/v8/issues/detail?id=14222

// https://bugs.chromium.org/p/v8/issues/detail?id=3056

// https://bugs.chromium.org/p/v8/issues/detail?id=3334

// https://bugs.chromium.org/p/v8/issues/detail?id=4118

// https://bugs.webkit.org/show_bug.cgi?id=188794

// https://bugzilla.mozilla.org/show_bug.cgi?id=773687

// https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL

// https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL

// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block

// https://esbench.com/bench/5b809c2cf2949800a0f61fb5

// https://github.com/DefinitelyTyped/DefinitelyTyped/issues/31065

// https://github.com/floating-ui/floating-ui/issues/1740

// https://github.com/floating-ui/floating-ui/issues/2317

// https://github.com/mathiasbynens/String.prototype.at

// https://github.com/oven-sh/bun/issues/1633

// https://github.com/popperjs/popper-core/issues/1078

// https://github.com/popperjs/popper-core/issues/837

// https://github.com/rafgraph/detect-it/blob/main/src/index.ts#L19-L36

// https://github.com/reactjs/react-transition-group/pull/749

// https://github.com/tannerlinsley/react-query/issues/652

// https://github.com/tc39/proposal-array-filtering

// https://github.com/whatwg/url/pull/734

// https://github.com/zloirock/core-js/issues/306

// https://github.com/zloirock/core-js/issues/475

// https://github.com/zloirock/core-js/issues/640

// https://github.com/zloirock/core-js/issues/677

// https://github.com/zloirock/core-js/issues/679

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028

// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval

// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout

// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers

// https://jestjs.io/docs/environment-variables#jest_worker_id

// https://samthor.au/2021/observing-dom/

// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034

// https://stackoverflow.com/questions/588004/is-floating-point-math-broken

// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next

// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator

// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next

// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot

// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec

// https://tc39.es/ecma262/#sec-advancestringindex

// https://tc39.es/ecma262/#sec-array.from

// https://tc39.es/ecma262/#sec-array.isarray

// https://tc39.es/ecma262/#sec-array.prototype-@@iterator

// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables

// https://tc39.es/ecma262/#sec-array.prototype.concat

// https://tc39.es/ecma262/#sec-array.prototype.entries

// https://tc39.es/ecma262/#sec-array.prototype.every

// https://tc39.es/ecma262/#sec-array.prototype.filter

// https://tc39.es/ecma262/#sec-array.prototype.find

// https://tc39.es/ecma262/#sec-array.prototype.findIndex

// https://tc39.es/ecma262/#sec-array.prototype.findindex

// https://tc39.es/ecma262/#sec-array.prototype.flatmap

// https://tc39.es/ecma262/#sec-array.prototype.foreach

// https://tc39.es/ecma262/#sec-array.prototype.includes

// https://tc39.es/ecma262/#sec-array.prototype.indexof

// https://tc39.es/ecma262/#sec-array.prototype.join

// https://tc39.es/ecma262/#sec-array.prototype.keys

// https://tc39.es/ecma262/#sec-array.prototype.map

// https://tc39.es/ecma262/#sec-array.prototype.reduce

// https://tc39.es/ecma262/#sec-array.prototype.reduceright

// https://tc39.es/ecma262/#sec-array.prototype.reverse

// https://tc39.es/ecma262/#sec-array.prototype.slice

// https://tc39.es/ecma262/#sec-array.prototype.some

// https://tc39.es/ecma262/#sec-array.prototype.splice

// https://tc39.es/ecma262/#sec-array.prototype.values

// https://tc39.es/ecma262/#sec-arrayspeciescreate

// https://tc39.es/ecma262/#sec-createarrayiterator

// https://tc39.es/ecma262/#sec-createhtml

// https://tc39.es/ecma262/#sec-createiterresultobject

// https://tc39.es/ecma262/#sec-createmappedargumentsobject

// https://tc39.es/ecma262/#sec-createunmappedargumentsobject

// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive

// https://tc39.es/ecma262/#sec-date.prototype.toisostring

// https://tc39.es/ecma262/#sec-date.prototype.tojson

// https://tc39.es/ecma262/#sec-date.prototype.tostring

// https://tc39.es/ecma262/#sec-function-instances-name

// https://tc39.es/ecma262/#sec-function.prototype.bind

// https://tc39.es/ecma262/#sec-get-map-@@species

// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags

// https://tc39.es/ecma262/#sec-get-set-@@species

// https://tc39.es/ecma262/#sec-getmethod

// https://tc39.es/ecma262/#sec-getsubstitution

// https://tc39.es/ecma262/#sec-hasownproperty

// https://tc39.es/ecma262/#sec-isarray

// https://tc39.es/ecma262/#sec-iscallable

// https://tc39.es/ecma262/#sec-isconstructor

// https://tc39.es/ecma262/#sec-isregexp

// https://tc39.es/ecma262/#sec-json-@@tostringtag

// https://tc39.es/ecma262/#sec-json.stringify

// https://tc39.es/ecma262/#sec-lengthofarraylike

// https://tc39.es/ecma262/#sec-map-objects

// https://tc39.es/ecma262/#sec-map.prototype-@@iterator

// https://tc39.es/ecma262/#sec-map.prototype.clear

// https://tc39.es/ecma262/#sec-map.prototype.delete

// https://tc39.es/ecma262/#sec-map.prototype.entries

// https://tc39.es/ecma262/#sec-map.prototype.foreach

// https://tc39.es/ecma262/#sec-map.prototype.get

// https://tc39.es/ecma262/#sec-map.prototype.has

// https://tc39.es/ecma262/#sec-map.prototype.keys

// https://tc39.es/ecma262/#sec-map.prototype.set

// https://tc39.es/ecma262/#sec-map.prototype.values

// https://tc39.es/ecma262/#sec-math-@@tostringtag

// https://tc39.es/ecma262/#sec-math.trunc

// https://tc39.es/ecma262/#sec-newpromisecapability

// https://tc39.es/ecma262/#sec-number.isnan

// https://tc39.es/ecma262/#sec-number.parseint

// https://tc39.es/ecma262/#sec-object.assign

// https://tc39.es/ecma262/#sec-object.create

// https://tc39.es/ecma262/#sec-object.defineproperties

// https://tc39.es/ecma262/#sec-object.defineproperty

// https://tc39.es/ecma262/#sec-object.entries

// https://tc39.es/ecma262/#sec-object.freeze

// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor

// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors

// https://tc39.es/ecma262/#sec-object.getownpropertynames

// https://tc39.es/ecma262/#sec-object.getownpropertysymbols

// https://tc39.es/ecma262/#sec-object.getprototypeof

// https://tc39.es/ecma262/#sec-object.isextensible

// https://tc39.es/ecma262/#sec-object.keys

// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable

// https://tc39.es/ecma262/#sec-object.prototype.tostring

// https://tc39.es/ecma262/#sec-object.setprototypeof

// https://tc39.es/ecma262/#sec-object.values

// https://tc39.es/ecma262/#sec-ordinarytoprimitive

// https://tc39.es/ecma262/#sec-parseint-string-radix

// https://tc39.es/ecma262/#sec-promise-executor

// https://tc39.es/ecma262/#sec-promise.all

// https://tc39.es/ecma262/#sec-promise.prototype.catch

// https://tc39.es/ecma262/#sec-promise.prototype.then

// https://tc39.es/ecma262/#sec-promise.race

// https://tc39.es/ecma262/#sec-promise.reject

// https://tc39.es/ecma262/#sec-promise.resolve

// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace

// https://tc39.es/ecma262/#sec-regexp.prototype-@@search

// https://tc39.es/ecma262/#sec-regexp.prototype.exec

// https://tc39.es/ecma262/#sec-regexp.prototype.tostring

// https://tc39.es/ecma262/#sec-regexpexec

// https://tc39.es/ecma262/#sec-requireobjectcoercible

// https://tc39.es/ecma262/#sec-samevalue

// https://tc39.es/ecma262/#sec-set.prototype-@@iterator

// https://tc39.es/ecma262/#sec-set.prototype.add

// https://tc39.es/ecma262/#sec-set.prototype.clear

// https://tc39.es/ecma262/#sec-set.prototype.delete

// https://tc39.es/ecma262/#sec-set.prototype.entries

// https://tc39.es/ecma262/#sec-set.prototype.foreach

// https://tc39.es/ecma262/#sec-set.prototype.has

// https://tc39.es/ecma262/#sec-set.prototype.keys

// https://tc39.es/ecma262/#sec-set.prototype.values

// https://tc39.es/ecma262/#sec-speciesconstructor

// https://tc39.es/ecma262/#sec-string.fromcodepoint

// https://tc39.es/ecma262/#sec-string.prototype-@@iterator

// https://tc39.es/ecma262/#sec-string.prototype.bold

// https://tc39.es/ecma262/#sec-string.prototype.codepointat

// https://tc39.es/ecma262/#sec-string.prototype.endswith

// https://tc39.es/ecma262/#sec-string.prototype.includes

// https://tc39.es/ecma262/#sec-string.prototype.matchall

// https://tc39.es/ecma262/#sec-string.prototype.padend

// https://tc39.es/ecma262/#sec-string.prototype.padstart

// https://tc39.es/ecma262/#sec-string.prototype.repeat

// https://tc39.es/ecma262/#sec-string.prototype.replace

// https://tc39.es/ecma262/#sec-string.prototype.search

// https://tc39.es/ecma262/#sec-string.prototype.small

// https://tc39.es/ecma262/#sec-string.prototype.trim

// https://tc39.es/ecma262/#sec-string.prototype.trimend

// https://tc39.es/ecma262/#sec-string.prototype.trimstart

// https://tc39.es/ecma262/#sec-symbol-constructor

// https://tc39.es/ecma262/#sec-symbol.asynciterator

// https://tc39.es/ecma262/#sec-symbol.for

// https://tc39.es/ecma262/#sec-symbol.iterator

// https://tc39.es/ecma262/#sec-symbol.keyfor

// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive

// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag

// https://tc39.es/ecma262/#sec-symbol.prototype.description

// https://tc39.es/ecma262/#sec-symbol.toprimitive

// https://tc39.es/ecma262/#sec-symbol.tostringtag

// https://tc39.es/ecma262/#sec-thisnumbervalue

// https://tc39.es/ecma262/#sec-tointegerorinfinity

// https://tc39.es/ecma262/#sec-tolength

// https://tc39.es/ecma262/#sec-toobject

// https://tc39.es/ecma262/#sec-toprimitive

// https://tc39.es/ecma262/#sec-topropertykey

// https://url.spec.whatwg.org/#URL-stringification-behavior

// https://url.spec.whatwg.org/#cannot-have-a-username-password-port

// https://url.spec.whatwg.org/#concept-url-serializer

// https://url.spec.whatwg.org/#dom-url-hash

// https://url.spec.whatwg.org/#dom-url-host

// https://url.spec.whatwg.org/#dom-url-hostname

// https://url.spec.whatwg.org/#dom-url-href

// https://url.spec.whatwg.org/#dom-url-origin

// https://url.spec.whatwg.org/#dom-url-password

// https://url.spec.whatwg.org/#dom-url-pathname

// https://url.spec.whatwg.org/#dom-url-port

// https://url.spec.whatwg.org/#dom-url-protocol

// https://url.spec.whatwg.org/#dom-url-search

// https://url.spec.whatwg.org/#dom-url-searchparams

// https://url.spec.whatwg.org/#dom-url-tojson

// https://url.spec.whatwg.org/#dom-url-username

// https://url.spec.whatwg.org/#dom-urlsearchparams-append

// https://url.spec.whatwg.org/#dom-urlsearchparams-delete

// https://url.spec.whatwg.org/#dom-urlsearchparams-get

// https://url.spec.whatwg.org/#dom-urlsearchparams-getall

// https://url.spec.whatwg.org/#dom-urlsearchparams-has

// https://url.spec.whatwg.org/#dom-urlsearchparams-set

// https://url.spec.whatwg.org/#dom-urlsearchparams-sort

// https://url.spec.whatwg.org/#host-parsing

// https://url.spec.whatwg.org/#include-credentials

// https://url.spec.whatwg.org/#interface-urlsearchparams

// https://url.spec.whatwg.org/#is-special

// https://url.spec.whatwg.org/#shorten-a-urls-path

// https://url.spec.whatwg.org/#url-class

// https://url.spec.whatwg.org/#url-parsing

// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior

// iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.

// icon size cannot grow and shrink

// if "group" or "active" filter is checked

// if "licensed group" filter is checked

// if clearTimeout wasn't available but was latter defined

// if contextSharing is on, we share the first and at least one

// if filters.refetchActive is not provided and filters.active is explicitly false,

// if its a function call it

// if not, refer back to the resolvedOpts, which are based on the locale

// if parent contains a focusable - move there

// if setTimeout wasn't available but was latter defined

// if so, respect their decision

// if the primaryColor is the same as the secondaryColor we

// if the target is not iterable or it's an array with the default iterator - use a simple case

// if the token is not found - replacing it with variable name without any value, to avoid it being undefined which would result in invalid css

// if this is not the case, factor is used to make it so

// if we are mounting and running this it means appear _must_ be set

// if we are still overshooting now, we need to backtrack again

// if we didn't set the day but we ended up on an overflow date,

// if you want to output a technical format (e.g. RFC 2822), this helper

// ignore everything but left clicks

// ignore mouse events that weren't triggered by the primary button

// ignore the keydown event from an Input Method Editor(IME)

// important! this hides the flashing cursor

// important! without `width` browsers won't allow focus

// in Safari 9 which returns 'object' for typed arrays and other constructors.

// in non-ending mode, where "/test/" shouldn't match "/test//route".

// in old Chrome, versions of V8 isn't V8 = Chrome / 10

// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`

// in popular engines, so it's moved to a separate module

// in the same offset (we could set the timestamp statically, instead). We use a

// in this case we accept any non-newline white-space

// include the context of this component, .e.g, lost data.

// incorrect for RTL.

// increment active scroll locks

// index is inside tab order, but outside Lock

// initialize with source styles

// inline-flex child

// insertion sort

// instance of the context across the window

// instead of optional in `types`

// into a smaller unit later

// ipv4

// ipv6

// is filled with the initial data specified by the modifier. This means

// is it still here?

// is that other hash histories in the page will consider it a POP.

// is useful for low frequency updates where sync behavior simplifies the

// is valid at the end of a path match, not in the middle. This is important

// isInvalid: false,

// it as the trailing edge, or we've hit the `maxWait` limit.

// it can work only with native `setPrototypeOf`

// it doesn't persist and is fresh on each update.

// it's 1 in dev because we insert source maps that map a single rule to a location

// it's not an issue. I don't think anyone ever specifies width on <html>

// iterable DOM collections

// its own modifications.

// jump out, but not on the guard

// just a weekday -> this week's instance of that weekday, no worries

// just in case

// justifyContent required for shouldFitContainer buttons with an icon inside

// keep the "overshot by 1" around as highWater

// keeping a list of keys we've seen in sessionStorage.

// keeping a list of paths we've seen in sessionStorage.

// key is the value of the data-emotion attribute, it's used to identify different sheets

// keyboard events can only occur when there is an overlay

// known fallback

// knows how to merge the passed-in default theme with

// last callback

// last element

// lastUnit must be defined since units is not empty

// let regex = `\\d{2}:\\d{2}:\\d{2}`;

// let's get started!

// like 'T'

// like 'Tues'

// like 'Tuesday'

// like +0600

// like +06:00

// like +6

// like 000012

// like 0012

// like 01

// like 01, doesn't seem to work

// like 1

// like 14

// like 2014

// like AD

// like America/New_York

// like Anno Domini

// like EST

// like Eastern Standard Time

// like J

// like Jan

// like January

// logic was previously ran for the previous placement and is therefore

// logic.

// make `.constructor === Promise` work for native promise-based APIs

// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs

// make `instanceof Promise` work for native promise-based APIs

// make certain babel optimisations not possible

// make dots optional and also make them literal

// make space and non breakable space characters interchangeable

// make sure that retries that were potentially cancelled due to unmounts can continue

// make sure the values we have are in range

// makes no sense without proper strict mode support

// makes subclassing work correct for wrapped built-ins

// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`

// map

// margin for button has been applied to css reset

// massage in target styles

// match already ends with a slash, we remove it for consistency. The slash

// may need to be constrained after flipping

// means it doesn't take into account transforms.

// means they are using the render prop API, and that is implemented in a

// merge sort

// merge<

// merge<Incoming extends AnyZodObject>(

// meridiem

// meridiems

// might use a different theme context in the future anyway

// minutes

// modern V8 bug

// modern engines have queueMicrotask method

// modified

// month, day, hour) in a time zone, we need a guess about what the timezone

// months

// months - format

// months - standalone

// most common use case for this is the `flip` modifier changing the

// ms

// multi select, by default, IS clearable

// multiSelected items are usually items that have already been selected

// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,

// new focus, nothing to calculate

// newCtx is used to not collect issues from inner types in ctx

// next code unit is the high surrogate of a surrogate pair.

// next index

// nextStatus will always be ENTERING or EXITING.

// no Set(dstNodes) for IE11 :(

// no active focus (or focus is on the body)

// no children inside the component will require analytics themselves.

// no default, invalid units throw in normalizeUnit()

// no enter animation skip right to ENTERED

// no exit animation skip right to EXITED

// no need to re-apply context if the text is already wrapped

// no tabbable elements, autofocus is not possible

// not memoizing themeStyles as `tokens` is an unstable reference

// not necessary (debounced to run at most once-per-tick)

// not necessary to add metadata

// not passing the registered cache to serializeStyles because it would

// not the most efficient thing ever but this is a pretty rare case

// nothing matched

// number of basic code points.

// number of code points that have been handled;

// object ID

// observes DST), but we can check and adjust that.

// of a tag and escaping quotes in arguments

// of course, fail.

// of module scoping.

// of the `<html>` and `<body>` rect bounds if horizontally scrollable

// of whitespaces and has a correct name

// offset

// offset is calculated from tsNow).

// offset is so that we can convert into a UTC timestamp. One way is to find the

// offset of now in the zone. The actual date may have a different offset (for

// offset we'll pick in ambiguous cases (e.g. there are two 3 AMs b/c Fallback DST)

// offset/zone

// old engines have not location.origin

// old focus

// on events on child elements, not the document (which we've attached this handler to).

// on the initial render. If there are, they will replace/push when

// onClick prevented default

// once we deprecate the wrapped approach, we can put the aria

// only keep the integer part for now in the hopes of putting any decimal part

// only scroll if the menu isn't already open

// optimisation for array iterators

// option is already selected; it breaks the flow of navigation

// optional / simple context binding

// or AnalyticsContext component instead.

// or finish the iteration

// or set by the user as a default value so we assume they are not disabled

// or somebody to the left, something?

// or somebody to the right, still close enough

// or something in it's place

// order based on dependencies

// order based on phase

// ordinals

// otherwise just use weeks or ordinals or gregorian, depending on what's specified

// otherwise there will be an error

// override it with the color we want.

// parent besides the portal parent.

// parseInt parses a string to a first unavailable symbol

// placement, which then needs to re-run all the modifiers, because the

// plus anything that's already in this unit

// positioning behaviour is almost identical for portalled and fixed,

// prefer the async Popper#update method

// prevent exposing of metadata key

// preventDefault prevents regular active styles from applying in Firefox

// preventing horizontal or vertical scroll

// private ones if they exist.

// private subtags and unicode subtags have ordering requirements,

// properly positioned near its reference element

// properties

// property

// props must be spread first to stop `components` being overridden

// provide some affordance on touch devices

// push the parent context's meta data into the context.

// rather setState here and ignore the hashchange. The caveat here

// react-select disables pointer events when isDisabled is true.

// reapply original body styles, if any

// ref. https://www.w3.org/TR/uievents/#determine-keydown-keyup-keyCode

// reference, so return the new value at the same index

// registration has to happen here as the result of this might get consumed by `cx`

// remove cursor on desktop

// remove cursor on mobile whilst maintaining "scroll into view" behaviour

// remove touch listeners

// rent time.  For example, "30 4 1,15 * 5" would cause a command to be

// required

// required for offset[Height, Top] > keyboard scroll

// reset bottom/top flags

// reset move vars

// reset the initial height in case this scroll lock is used again

// return a primitive with prefix

// return first issue-free validation if it exists

// return invalid

// return step by kind

// return the containing block

// return the existing current (pre render)

// return the last focusable one

// return value is generally a set of nodes with the tokens applied appropriately.

// return value is ignored

// returning `#document` an infinite loop won't occur.

// reverse-compat since 1.2; we always round down now, never up, and we do it by default

// revert to the last existing entry

// run at 4:30 am on the  1st and 15th of each month, plus every Friday."

// run catchall validation

// safely decrement active scroll locks

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.

// same wrapper element whether fixed or portalled

// scroll the focused option into view if necessary

// scrollbars occur only if the user passes in a custom component with overflow: scroll

// seconds

// see, e.g. https://github.com/wooorm/bcp-47

// select-option when !isMulti does not return option so we assume selected option is value

// selector

// separator doesn't make sense without the dropdown indicator

// set default values for missing stuff

// set the --icon-primary-color to Canvas

// set the month and day again, this is necessary because year 2000 is a leap year, but year 100 is not

// set touch start so we can calculate touchmove delta

// setState callbacks and unmounting in testing, so always make sure that

// shim for using process in browser

// should have correct order of operations (Edge bug)

// should work with symbols and should have deterministic property order (V8 bug)

// shouldn't do anything because there is nothing to operate on or with.

// signedOffset('-5', '30') -> -330

// simulate the 'y' flag.

// single select, by default, IS NOT clearable

// single timestamp for all zones to make things a bit more predictable.

// so check `userAgent` even if `.v8` exists, but 0

// so give them whatever is available below rather than the minHeight.

// so if obj.year is in 99, but obj.day makes it roll over into year 100,

// so that using `css` from `emotion` and passing the result to the css prop works

// so we are targeting the attribute

// so we don't have to add it to registered cache.

// so we have to prevent touchmove events via JS

// so we use the same component. the actual portalling logic is forked

// so while this could be technically correct then it would be slower and larger

// some

// some Chrome versions have non-configurable methods on DOMTokenList

// some old implementations (like WebKit) could pass numbers as keys

// some other error. we should definitely know about these

// some updates should toggle the state of the input visibility

// something went wrong, return default state

// source: https://stackoverflow.com/questions/49875255

// space

// stale/incorrect

// standardize case and plurality in units

// step into the shadow DOM of the parent of a slotted node

// store any styles already applied to the body

// stretching to full width / height of button

// strings for SVG elements, returning NaN. Fallback to `0` in this case.

// such as table ancestors and cross browser bugs.

// target

// technically this means that the @import rules will

// that could have changed the offset by going over a DST, but we want to keep the ts the same

// that is element itself

// the " " token has a special meaning (see unitForToken)

// the "L".

// the big drawback is that the css won't be editable in devtools

// the cache will never be null in the browser

// the calculations done by Date.UTC are using year 2000 - which is incorrect

// the focused value is still in the selectValue, return it

// the focusedValue is not present in the next selectValue array by

// the logic below assumes the overall value of the duration is positive

// the matched portion of the URL

// the max length is how many rules we have per style tag, it's 65000 in speedy mode

// the menu is rendered

// the modifiers in the next step

// the path used to match

// the portal will be added to the DOM before the children render.

// the previous one, we may end up in a weird state. Figure out the

// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and

// the system locale is useful for human-readable strings but annoying for parsing/formatting known formats

// the tree but if it's a string tag, we know it won't

// then global override map

// then reset the ariaSelection to null

// then schema-bound map if available

// these are a stable ref because of the useTrackedRef hook

// these aren't really private, but nor are they really useful to document

// these changes should already be reflected in the optimistic result.

// they mount and since cDM fires in children before parents, we may

// this (e.g. Edge 2019, IE11, Safari)

// this does not support setting FOCUS_ALLOW within shadow dom

// this forcesimple option is never used (the only caller short-circuits on it, but it seems safer to leave)

// this happens in certain situations when diffing times in different zones,

// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper

// this ignores label

// this improves memory usage since we can avoid storing the whole style string

// this is a dumbed down version of fromObject() that runs about 60% faster

// this is a quicker (but less type safe) way to save quite some bytes from the bundle

// this is a really hot path

// this is important as we need it to still block

// this is the ultrafast version, works across browsers

// this is usually to convey state i.e. Checkbox checked -> not checked

// this method was added to unscopables after implementation

// this shouldn't really matter in the real world though

// this special-case "token" represents a place where a macro-token expanded into a white-space literal

// this tooltip is now the active tooltip

// this weirdness brought to you by firefox

// this will handle "floating point madness" by removing extra decimal places

// through inheritance. This is important for custom cases that use the useTab(),

// through inheritance. This is important for custom cases that use the useTabPanel(),

// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346

// time

// to create a new object while only changing some of the properties

// to definitely enumerate them.

// to ensure that if React Query is used across

// to is absolute

// to is relative, drop the filename

// to prevent an infinite loop of updates.

// to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.

// to trigger an unmount/remount for two <Route>s that render the same

// toObject with fallback for non-array-like ES3 strings

// todo - remap caching

// trailing edge, the system time has gone backwards and we're treating

// trigger revalidation after cert confirmed

// try to convert any decimals into smaller units if possible

// try {

// tslint:disable-next-line:prefer-for-of

// unit conversion constants

// update callback

// update visited steps with currentStep

// use the last day of the right month

// using a global regex with .exec is stateful so lastIndex has to be reset each time

// v8 likes predictible objects

// value

// w/o altered newTarget, lot of arguments case

// w/o altered newTarget, optimization for 0-4 arguments

// warn on circular references, don't crash

// we are 'disabling' input with a button when there is an overlay

// we are setting display to flex because we want each portal to create a new stacking context

// we cache week data on the DT object and this intermediates the cache

// we can cancel any pending setState callbacks after we unmount.

// we can measure only "elements"

// we can't check .prototype since constructors produced by .bind haven't it

// we can't trust `scrollParent.scrollHeight` --> it may increase when

// we can't use just `it == null` since of `document.all` special case

// we check the second character first because having "i"

// we could use the formatter, but this is an easier way to get the minimum string

// we don't support ZZZZ (PST) or ZZZZZ (Pacific Standard Time) in parsing

// we get some perf out of doing this here, annoyingly

// we have recursive entered back the lock activation

// we haven't completely correct pre-ES6 way for getting `new.target`, so use this

// we manually apply the offset and substitute the zone as needed.

// we need to insert @import rules before anything else

// we only need to add the styles to the registered cache if the

// we overshot the end point, backtrack cursor by 1

// we start at 1 since we've already handled the first arg

// we want to provide as much of the menu as possible to the user,

// we'll let the query continue so the result can be cached

// we're checking on event.target here instead of event.currentTarget, because we want to assert information

// we're doing this to avoid preconstruct's dead code elimination in this one case

// weak collections should not contains .clear method

// webpackRuntimeModules

// weekNumber (W)

// weekYear (k)

// weekdays

// weekdays - format

// weekdays - standalone

// when the Select is initially focused

// when the select value should change, we should reset focusedValue

// when using suspense to prevent infinite loop of fetches

// when when somebody has screwed with setTimeout but no I.E. maddness

// whether or not we matched exactly

// which applies accessibility atributes that we use as a styling hook.

// which is necessary in order to transition styles when adding a class name.

// which takes priority over color and makes the text unreadable. Need to

// which would then trigger this effect every re-render.

// white-space is always considered a literal in user-provided formats

// will be updated on the next render

// with a scroll distance, we perform scroll on the element

// with adding support of @@isConcatSpreadable and @@species

// with adding support of @@species

// with altered newTarget, not support built-in constructors

// with some probability this will prevent focus from cycling across the lock, but there is no tabbale elements to cycle to

// within the component based on `menuPosition`

// workaround of WebKit ~ iOS Safari 10.1 bug

// workaround of old WebKit + `eval` bug

// wrap Symbol constructor for correct work with undefined description

// wrapped children approach.

// wrapped in strict mode code which doesn't define any globals.  It's inside a

// x % n but takes the sign of n instead of x

// years

// zone

// }

//# sourceMappingURL=context.js.map

//# sourceMappingURL=index.esm.mjs.map

//# sourceMappingURL=index.js.map

//# sourceMappingURL=luxon.js.map

//# sourceMappingURL=react-router-dom.js.map

//# sourceMappingURL=react-router.js.map

//# sourceMappingURL=styled-components.browser.esm.js.map

//# sourceMappingURL=zod.module.js.map

/// <reference types="user-agent-data-types" />

//////////                                 //////////

//////////      ZodDiscriminatedUnion      //////////

/////////////////////////////////////////////////////

//@ts-expect-error TODO Fix legit TypeScript 3.9.6 improved inference error

//TODO create interface with structure gotten from backend

//Update discoveryUrl based on firstField and secondField

//atlaskit-portal div

//atlaskit-portal-container div

//className

//next day

//normal enviroments in sane situations

//used to find new state
