@tylertech/forge 2.8.0 → 2.10.0

package/dist/esm/chunks/chunk.2NMHSTAO.js

@@ -1,1473 +0,0 @@
-/**
- * @license
- * Copyright 2022 Tyler Technologies, Inc. 
- * License: Apache-2.0
- */
-import {
-  DialogComponent
-} from "./chunk.RL7ZFLMG.js";
-import {
-  TEXT_FIELD_CONSTANTS,
-  TextFieldComponentDelegate
-} from "./chunk.Q4YMHFRY.js";
-import {
-  ListDropdown
-} from "./chunk.IGBDDH3J.js";
-import {
-  ListComponent
-} from "./chunk.5U6ZT6MC.js";
-import {
-  ListItemComponent
-} from "./chunk.GWNR3UUX.js";
-import {
-  PopupComponent
-} from "./chunk.DLF5JAQO.js";
-import {
-  ICON_BUTTON_CONSTANTS,
-  IconButtonComponent
-} from "./chunk.EBC2HGO3.js";
-import {
-  tylIconClose
-} from "./chunk.GS2AXUCN.js";
-import {
-  Platform
-} from "./chunk.BYN27JXZ.js";
-import {
-  ICON_CONSTANTS,
-  IconComponent,
-  IconRegistry
-} from "./chunk.WSH4S3GM.js";
-import {
-  FormFieldComponentDelegate
-} from "./chunk.HZISALRH.js";
-import {
-  TimeInputMask
-} from "./chunk.WIYLQTSX.js";
-import {
-  TWELVE_HOUR_TIME_REGEX,
-  TWENTY_FOUR_HOUR_TIME_REGEX,
-  isSupportedTimeFormat,
-  tokenize12HourTimeString,
-  tokenize24HourTimeString,
-  tryCoerceTimeString
-} from "./chunk.PM7D2SUE.js";
-import {
-  BaseAdapter
-} from "./chunk.KZATVOA6.js";
-import {
-  FoundationProperty
-} from "./chunk.MMIZOYAS.js";
-import {
-  COMPONENT_NAME_PREFIX,
-  CustomElement
-} from "./chunk.35U3UPDV.js";
-import {
-  BaseComponent
-} from "./chunk.VK6LIH3B.js";
-import {
-  attachShadowTemplate,
-  defineCustomElement,
-  emitEvent,
-  getShadowElement
-} from "./chunk.K2PCTUVN.js";
-import {
-  ensureChild,
-  getActiveElement,
-  toggleAttribute
-} from "./chunk.4JURZYE4.js";
-import {
-  coerceBoolean,
-  coerceNumber,
-  debounce,
-  randomChars
-} from "./chunk.MEFT5FQC.js";
-import {
-  __decorateClass,
-  __spreadValues
-} from "./chunk.LM5TVNZY.js";
-
-// node_modules/@tylertech/tyler-icons/extended/index.js
-var tylIconClockOutline = {
-  name: "clock_outline",
-  data: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 20a8 8 0 008-8 8 8 0 00-8-8 8 8 0 00-8 8 8 8 0 008 8m0-18a10 10 0 0110 10 10 10 0 01-10 10C6.47 22 2 17.5 2 12A10 10 0 0112 2m.5 5v5.25l4.5 2.67-.75 1.23L11 13V7h1.5z"/></svg>'
-};
-
-// dist/build/lib/staging/src/time-picker/time-picker-constants.ts
-var elementName = `${COMPONENT_NAME_PREFIX}time-picker`;
-var attributes = {
-  TOGGLE: "forge-time-picker-toggle",
-  VALUE: "value",
-  OPEN: "open",
-  ALLOW_SECONDS: "allow-seconds",
-  MASKED: "masked",
-  SHOW_MASK_FORMAT: "show-mask-format",
-  USE_24_HOUR_TIME: "use-24-hour-time",
-  ALLOW_INVALID_TIME: "allow-invalid-time",
-  MIN: "min",
-  MAX: "max",
-  START_TIME: "start-time",
-  STEP: "step",
-  ALLOW_INPUT: "allow-input",
-  SHOW_NOW: "show-now",
-  SHOW_HOUR_OPTIONS: "show-hour-options",
-  DISABLED: "disabled",
-  POPUP_CLASSES: "popup-classes",
-  ALLOW_DROPDOWN: "allow-dropdown"
-};
-var selectors = {
-  INPUT: "input, input[forge-time-picker-input]",
-  TOGGLE: `[${attributes.TOGGLE}]`
-};
-var events = {
-  OPEN: `${elementName}-open`,
-  CLOSE: `${elementName}-close`,
-  INPUT: `${elementName}-input`,
-  CHANGE: `${elementName}-change`
-};
-var numbers = {
-  DEFAULT_MINUTE_STEP: 60,
-  MAX_DAY_MILLIS: 864e5,
-  MAX_DAY_MINUTES: 1440
-};
-var TIME_PICKER_CONSTANTS = {
-  elementName,
-  attributes,
-  selectors,
-  events,
-  numbers
-};
-
-// dist/build/lib/staging/src/time-picker/time-picker-adapter.ts
-var TimePickerAdapter = class extends BaseAdapter {
-  constructor(component) {
-    super(component);
-  }
-  initialize() {
-    this._inputElement = this._component.querySelector(TIME_PICKER_CONSTANTS.selectors.INPUT);
-  }
-  initializeMask(options) {
-    if (this._inputMask) {
-      this._inputMask.destroy();
-    }
-    this._inputMask = new TimeInputMask(this._inputElement, options);
-  }
-  destroy() {
-    this._targetElement = void 0;
-    this._toggleElement = void 0;
-    this._inputElement = void 0;
-  }
-  destroyMask() {
-    if (this._inputMask) {
-      this._inputMask.destroy();
-      this._inputMask = void 0;
-    }
-  }
-  initializeAccessibility(identifier) {
-    this._inputElement.setAttribute("autocomplete", "off");
-    this._inputElement.setAttribute("autocorrect", "off");
-    this._inputElement.setAttribute("autocapitalize", "off");
-    this._inputElement.setAttribute("spellcheck", "false");
-    this._inputElement.setAttribute("role", "combobox");
-    this._inputElement.setAttribute("aria-live", "assertive");
-    this._inputElement.setAttribute("aria-atomic", "true");
-    this._inputElement.setAttribute("aria-haspopup", "true");
-    this._inputElement.setAttribute("aria-expanded", "false");
-  }
-  addInputListener(type, listener, capture) {
-    this._inputElement.addEventListener(type, listener, { capture });
-  }
-  removeInputListener(type, listener, capture) {
-    if (this._inputElement) {
-      this._inputElement.removeEventListener(type, listener, { capture });
-    }
-  }
-  addToggleListener(type, listener) {
-    if (this._toggleElement) {
-      this._toggleElement.addEventListener(type, listener);
-    }
-  }
-  removeToggleListener(type, listener) {
-    if (this._toggleElement) {
-      this._toggleElement.removeEventListener(type, listener);
-    }
-  }
-  hasInputElement() {
-    return !!this._inputElement;
-  }
-  tryCreateToggle() {
-    const textField = this._component.querySelector(TEXT_FIELD_CONSTANTS.elementName);
-    const toggleElement = this._component.querySelector(TIME_PICKER_CONSTANTS.selectors.TOGGLE);
-    if (textField) {
-      const existingIconButton = textField.querySelector(`${ICON_BUTTON_CONSTANTS.elementName}[slot=trailing]`);
-      if (existingIconButton || toggleElement) {
-        this._toggleElement = existingIconButton || toggleElement;
-        return;
-      }
-      const iconButtonElement = document.createElement(ICON_BUTTON_CONSTANTS.elementName);
-      iconButtonElement.slot = "trailing";
-      iconButtonElement.dense = true;
-      iconButtonElement.densityLevel = 3;
-      iconButtonElement.style.marginRight = "4px";
-      const buttonElement = document.createElement("button");
-      buttonElement.type = "button";
-      buttonElement.tabIndex = -1;
-      buttonElement.setAttribute("aria-label", "Toggle time dropdown");
-      const iconElement = document.createElement(ICON_CONSTANTS.elementName);
-      iconElement.name = "clock_outline";
-      buttonElement.appendChild(iconElement);
-      iconButtonElement.appendChild(buttonElement);
-      textField.appendChild(iconButtonElement);
-      this._toggleElement = iconButtonElement;
-    } else if (toggleElement) {
-      this._toggleElement = toggleElement;
-    }
-  }
-  tryFocusInput() {
-    this._inputElement.select();
-  }
-  tryBlurInput() {
-    this._inputElement.blur();
-  }
-  selectInputText() {
-    this._inputElement.select();
-  }
-  isInputDisabled() {
-    return this._inputElement.disabled;
-  }
-  isInputFocused() {
-    return getActiveElement() === this._inputElement;
-  }
-  setInputValue(value, emitEvents) {
-    if (this._inputElement.value === value) {
-      return;
-    }
-    this._inputElement.value = value;
-    if (this._inputMask) {
-      this._inputMask.update();
-    }
-    if (emitEvents) {
-      this._emitInputEvent("change");
-      this._emitInputEvent("input");
-    }
-  }
-  getInputValue() {
-    return this._inputMask ? this._inputMask.maskedValue : this._inputElement.value;
-  }
-  setDisabled(isDisabled) {
-    this._inputElement.disabled = isDisabled;
-    this._inputElement.setAttribute("aria-disabled", isDisabled.toString());
-    this.setToggleDisabled(isDisabled);
-  }
-  attachDropdown(config) {
-    this._listDropdown = new ListDropdown(this._inputElement, config);
-    this._listDropdown.open();
-    this._inputElement.setAttribute("aria-controls", `list-dropdown-popup-${config.id}`);
-  }
-  detachDropdown() {
-    if (this._listDropdown) {
-      this._listDropdown.close();
-      this._listDropdown.destroy();
-      this._listDropdown = void 0;
-    }
-    this._inputElement.removeAttribute("aria-controls");
-  }
-  propagateKey(key) {
-    var _a;
-    (_a = this._listDropdown) == null ? void 0 : _a.handleKey(key);
-  }
-  setActiveDescendant(id) {
-    toggleAttribute(this._inputElement, !!id, "aria-activedescendant", id);
-  }
-  getTargetElementWidth(selector) {
-    const targetElement = this._getTargetElement(selector);
-    return targetElement.getBoundingClientRect().width;
-  }
-  _emitInputEvent(type) {
-    this._inputElement.dispatchEvent(new Event(type));
-  }
-  emitInputEvent(type, data) {
-    emitEvent(this._inputElement, type, data);
-  }
-  setInputReadonly(value) {
-    this._inputElement.readOnly = value;
-  }
-  setToggleDisabled(value) {
-    if (this._toggleElement) {
-      this._toggleElement.setAttribute("aria-disabled", value.toString());
-      if ("disabled" in this._toggleElement) {
-        this._toggleElement.disabled = value;
-      } else {
-        const button = this._toggleElement.querySelector("button");
-        if (button) {
-          button.disabled = value;
-        }
-      }
-    }
-  }
-  activateFirstOption() {
-    var _a;
-    (_a = this._listDropdown) == null ? void 0 : _a.activateFirstOption();
-  }
-  getActiveOption() {
-    var _a;
-    return (_a = this._listDropdown) == null ? void 0 : _a.getActiveOption();
-  }
-  _getTargetElement(selector) {
-    if (this._targetElement) {
-      return this._targetElement;
-    }
-    this._targetElement = selector ? this._component.querySelector(selector) || this._getDefaultTargetElement() : this._getDefaultTargetElement();
-    return this._targetElement;
-  }
-  _getDefaultTargetElement() {
-    const textField = this._component.querySelector(TEXT_FIELD_CONSTANTS.elementName);
-    if (textField && textField.shadowRoot) {
-      const textFieldRoot = getShadowElement(textField, TEXT_FIELD_CONSTANTS.selectors.ROOT);
-      if (textFieldRoot) {
-        return textFieldRoot;
-      }
-    }
-    return this._component;
-  }
-};
-
-// dist/build/lib/staging/src/time-picker/time-picker-utils.ts
-function timeStringToMillis(time, use24HourTime, allowSeconds) {
-  if (!time || /^\s*$/.test(time)) {
-    return null;
-  }
-  let hours = 0;
-  let minutes = 0;
-  let seconds = 0;
-  if (TWENTY_FOUR_HOUR_TIME_REGEX.test(time)) {
-    const tokens = tokenize24HourTimeString(time);
-    hours = +tokens.hours || 0;
-    minutes = +tokens.minutes || 0;
-    seconds = +tokens.seconds || 0;
-  } else if (TWELVE_HOUR_TIME_REGEX.test(time)) {
-    const tokens = tokenize12HourTimeString(time);
-    hours = +tokens.hours || 0;
-    minutes = +tokens.minutes || 0;
-    seconds = +tokens.seconds || 0;
-    if (hours === 12 && tokens.meridiem === "AM") {
-      hours = 0;
-    }
-    if (hours < 12 && tokens.meridiem === "PM") {
-      hours += 12;
-    }
-  } else {
-    return null;
-  }
-  return hoursToMillis(hours) + minutesToMillis(minutes) + (allowSeconds ? secondsToMillis(seconds) : 0);
-}
-function millisToTimeString(value, use24HourTime, allowSeconds) {
-  if (typeof value !== "number" || value < 0) {
-    return null;
-  }
-  let hours = Math.min(millisToHours(value), 23);
-  const minutes = Math.min(millisToMinutesClamped(value), 59);
-  const totalMinutes = value / (1e3 * 60);
-  const meridiem = totalMinutes < 720 ? "AM" : "PM";
-  if (!use24HourTime) {
-    hours = hours <= 12 ? hours : hours - 12;
-    if (hours === 0) {
-      hours = 12;
-    }
-  }
-  let time = `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
-  if (allowSeconds) {
-    const seconds = Math.min(millisToSecondsClamped(value), 59);
-    time += `:${String(seconds).padStart(2, "0")}`;
-  }
-  if (!use24HourTime) {
-    time += ` ${meridiem}`;
-  }
-  return time;
-}
-function millisToHours(millis) {
-  return Math.abs(Math.floor(millis / (1e3 * 60 * 60)));
-}
-function millisToMinutesClamped(millis) {
-  return Math.abs(Math.floor(millisToMinutes(millis) % 60));
-}
-function millisToMinutes(millis) {
-  return millis / (1e3 * 60);
-}
-function millisToSecondsClamped(millis) {
-  return Math.abs(Math.floor(millisToSeconds(millis) % 60));
-}
-function millisToSeconds(millis) {
-  return millis / 1e3;
-}
-function hoursToMillis(hours) {
-  return hours * 60 * 60 * 1e3;
-}
-function minutesToMillis(minutes) {
-  return minutes * 60 * 1e3;
-}
-function secondsToMillis(seconds) {
-  return seconds * 1e3;
-}
-function stripSecondsFromMillis(millis) {
-  return millis - secondsToMillis(millisToSecondsClamped(millis));
-}
-function getCurrentTimeOfDayMillis(allowSeconds) {
-  const date = new Date();
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  return hoursToMillis(hours) + minutesToMillis(minutes) + (allowSeconds ? secondsToMillis(date.getSeconds()) : 0);
-}
-function mergeDateWithTime(date, time, useSeconds = false) {
-  if (!date) {
-    date = new Date();
-  }
-  const millis = timeStringToMillis(time, true, useSeconds);
-  if (!millis) {
-    date.setHours(0, 0, 0);
-    return date;
-  }
-  let hours = millisToHours(millis);
-  const twentyThreeHoursInMillis = 828e5;
-  if (hours > twentyThreeHoursInMillis) {
-    hours = twentyThreeHoursInMillis;
-  } else if (hours < 0) {
-    hours = 0;
-  }
-  const minutes = millisToMinutesClamped(millis);
-  const seconds = useSeconds ? millisToSecondsClamped(millis) : 0;
-  date.setHours(hours, minutes, seconds);
-  return date;
-}
-
-// dist/build/lib/staging/src/time-picker/time-picker-foundation.ts
-var TimePickerFoundation = class {
-  constructor(_adapter) {
-    this._adapter = _adapter;
-    this._value = null;
-    this._masked = true;
-    this._use24HourTime = false;
-    this._showMaskFormat = false;
-    this._min = null;
-    this._max = null;
-    this._restrictedTimes = [];
-    this._startTime = null;
-    this._step = TIME_PICKER_CONSTANTS.numbers.DEFAULT_MINUTE_STEP;
-    this._allowInput = true;
-    this._open = false;
-    this._allowSeconds = false;
-    this._allowInvalidTime = false;
-    this._showNow = false;
-    this._showHourOptions = true;
-    this._customOptions = [];
-    this._disabled = false;
-    this._popupClasses = [];
-    this._allowDropdown = true;
-    this._isInitialized = false;
-    this._identifier = randomChars();
-    this._inputListener = (evt) => this._onInput(evt);
-    this._inputKeydownListener = (evt) => this._onInputKeydown(evt);
-    this._toggleMousedownListener = (evt) => this._onToggleMousedown(evt);
-    this._inputFocusListener = (evt) => this._onInputFocus(evt);
-    this._inputBlurListener = (evt) => this._onInputBlur(evt);
-    this._inputMousedownListener = (evt) => this._onInputMousedown(evt);
-  }
-  initialize() {
-    this._adapter.initialize();
-    if (!this._adapter.hasInputElement()) {
-      throw new Error("Unable to locate <input> element to attach to.");
-    }
-    this._adapter.initializeAccessibility(this._identifier);
-    if (!this._value) {
-      const inputValue = this._adapter.getInputValue();
-      this._setValue(this._convertTimeStringToMillis(inputValue, this._use24HourTime, this._allowSeconds));
-    }
-    this._adapter.addInputListener("focus", this._inputFocusListener);
-    this._adapter.addInputListener("blur", this._inputBlurListener);
-    this._adapter.addInputListener("keydown", this._inputKeydownListener, true);
-    this._formatInputValue(false);
-    if (typeof this._value === "number") {
-      this._applyValue(this._value, false);
-    }
-    this._applyAllowInput();
-    this._applyAllowDropdown();
-    this._applyDisabled();
-    this._applyMask();
-    this._isInitialized = true;
-  }
-  disconnect() {
-    this._isInitialized = false;
-    this._adapter.removeInputListener("input", this._inputListener);
-    this._adapter.removeInputListener("focus", this._inputFocusListener);
-    this._adapter.removeInputListener("blur", this._inputBlurListener);
-    this._adapter.removeToggleListener("mousedown", this._toggleMousedownListener);
-    this._adapter.removeInputListener("keydown", this._inputKeydownListener, true);
-    if (this._masked) {
-      this._adapter.destroyMask();
-    }
-    this._closeDropdown();
-    this._adapter.destroy();
-  }
-  _onInput(evt) {
-    this._handleInput(this._adapter.getInputValue());
-  }
-  _onInputKeydown(evt) {
-    if (evt.shiftKey) {
-      switch (evt.code) {
-        case "Backspace":
-        case "Delete":
-          evt.preventDefault();
-          const result = this._trySetValue(null);
-          if (result) {
-            this._formatInputValue();
-          }
-          return;
-      }
-    }
-    switch (evt.code) {
-      case "Tab":
-        if (this._open) {
-          this._selectActiveOption();
-        }
-        break;
-      case "Esc":
-      case "Escape":
-        if (this._open) {
-          evt.preventDefault();
-          this._closeDropdown(true);
-        }
-        break;
-      case "Down":
-      case "ArrowDown":
-        if (this._allowDropdown) {
-          evt.preventDefault();
-          if (!this._open) {
-            this._openDropdown();
-            this._adapter.activateFirstOption();
-          } else {
-            this._adapter.propagateKey(evt.code);
-          }
-        }
-        break;
-      case "Up":
-      case "ArrowUp":
-        if (this._allowDropdown) {
-          evt.preventDefault();
-          if (this._open) {
-            this._adapter.propagateKey(evt.code);
-          } else {
-          }
-        }
-        break;
-      case "Enter":
-      case "Home":
-      case "End":
-        if (this._open) {
-          if (evt.code === "Enter") {
-            evt.stopPropagation();
-          }
-          evt.preventDefault();
-          this._adapter.propagateKey(evt.code);
-        }
-        break;
-      case "KeyN":
-        evt.preventDefault();
-        const nowMillis = getCurrentTimeOfDayMillis(this._allowSeconds);
-        if (this._value !== nowMillis) {
-          const timeString = millisToTimeString(nowMillis, true, this._allowSeconds);
-          const canContinue = this._emitChangeEvent(timeString);
-          if (canContinue) {
-            this._applyValue(nowMillis);
-            this._selectInputText();
-          }
-        }
-        break;
-    }
-  }
-  _selectActiveOption() {
-    const activeOption = this._adapter.getActiveOption();
-    if (activeOption) {
-      this._onSelect(activeOption.value);
-    }
-  }
-  _onToggleMousedown(evt) {
-    if (this._disabled || !this.allowDropdown) {
-      return;
-    }
-    evt.stopPropagation();
-    if (this._adapter.isInputDisabled()) {
-      return;
-    }
-    evt.preventDefault();
-    if (this._open) {
-      this._closeDropdown(true);
-    } else {
-      if (!Platform.isMobile) {
-        this._adapter.tryFocusInput();
-      } else {
-        this._adapter.tryBlurInput();
-      }
-      this._openDropdown();
-    }
-  }
-  _onInputFocus(evt) {
-    if (this._allowInput) {
-      this._adapter.selectInputText();
-    }
-  }
-  _onInputBlur(evt) {
-    this._formatInputValue();
-    if (this._open && !this._adapter.isInputFocused()) {
-      this._closeDropdown(true);
-    }
-  }
-  _onInputMousedown(evt) {
-    if (!this._allowInput && !this._open) {
-      this._openDropdown();
-      this._adapter.tryFocusInput();
-      window.requestAnimationFrame(() => this._adapter.selectInputText());
-    }
-  }
-  _applyDisabled() {
-    this._adapter.setDisabled(this._disabled);
-  }
-  _applyMask() {
-    if (this._masked && this._allowInput) {
-      const options = {
-        showMaskFormat: this._showMaskFormat,
-        use24HourTime: this._use24HourTime,
-        showSeconds: this._allowSeconds,
-        prepareCallback: this._prepareMaskCallback,
-        onChange: debounce((value) => this._handleInput(value), 0, true)
-      };
-      this._adapter.initializeMask(options);
-    } else {
-      this._adapter.destroyMask();
-      this._formatInputValue();
-    }
-  }
-  _applyAllowInput() {
-    this._adapter.setInputReadonly(!this._allowInput);
-    if (this._allowInput) {
-      this._adapter.removeInputListener("mousedown", this._inputMousedownListener);
-      if (!this._masked) {
-        this._adapter.addInputListener("input", this._inputListener);
-      }
-    } else {
-      this._adapter.addInputListener("mousedown", this._inputMousedownListener);
-      this._adapter.removeInputListener("input", this._inputListener);
-    }
-  }
-  _applyAllowDropdown() {
-    this._adapter.setToggleDisabled(!this._allowDropdown);
-    if (this._allowDropdown) {
-      this._adapter.removeToggleListener("mousedown", this._toggleMousedownListener);
-      this._adapter.tryCreateToggle();
-      this._adapter.addToggleListener("mousedown", this._toggleMousedownListener);
-    } else if (this._open) {
-      this._closeDropdown(true);
-    }
-  }
-  _applyAllowSeconds() {
-    const originalValue = this._value;
-    if (!this._allowSeconds) {
-      if (typeof this._value !== "number") {
-        return;
-      }
-      this._setValue(stripSecondsFromMillis(this._value));
-      if (this._isInitialized && originalValue !== this._value) {
-        const timeString = millisToTimeString(this._value, true, false);
-        this._emitChangeEvent(timeString);
-      }
-    } else if (this._isInitialized && originalValue !== this._value) {
-      const timeString = millisToTimeString(this._value, true, true);
-      this._emitChangeEvent(timeString);
-    }
-  }
-  _handleInput(value) {
-    const rawValue = value;
-    if (!this._allowInput) {
-      return;
-    }
-    if (this._open) {
-      this._closeDropdown(true);
-    }
-    value = tryCoerceTimeString(value, this._use24HourTime, this._allowSeconds);
-    if (typeof this._coercionCallback === "function") {
-      value = this._coercionCallback.call(null, rawValue, value, this._allowSeconds);
-    }
-    if (!this._isValidTimeFormat(value)) {
-      value = "";
-    }
-    let millis;
-    if (!this._masked && typeof this._parseCallback === "function") {
-      millis = this._parseCallback.call(null, value);
-    } else {
-      millis = this._convertTimeStringToMillis(value, this._use24HourTime, this._allowSeconds);
-    }
-    millis = this._validateMillis(millis);
-    this._trySetValue(millis);
-  }
-  _emitChangeEvent(value, force = false) {
-    return this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.CHANGE, value, true, !force);
-  }
-  _trySetValue(millis) {
-    if (millis === this._value) {
-      return false;
-    }
-    const timeString = millisToTimeString(millis, true, this._allowSeconds);
-    if (this._masked) {
-      this._adapter.emitInputEvent(TIME_PICKER_CONSTANTS.events.INPUT, timeString);
-    }
-    if (this._value !== millis) {
-      const canContinue = this._emitChangeEvent(timeString);
-      if (canContinue) {
-        this._setValue(millis);
-        return true;
-      }
-    }
-    return false;
-  }
-  _setValue(value) {
-    this._value = this._normalizeTimeValue(value);
-  }
-  _validateMillis(millis) {
-    if (typeof millis === "number") {
-      const isBelowMin = typeof this._min === "number" && millis < this._min;
-      const isAboveMax = typeof this._max === "number" && millis > this._max;
-      if (isBelowMin || isAboveMax) {
-        millis = null;
-      }
-    }
-    if (typeof millis === "number" && this._restrictedTimes.length) {
-      if (this._restrictedTimes.includes(millis)) {
-        millis = null;
-      }
-    }
-    return millis;
-  }
-  _isValidTimeFormat(value) {
-    if (!this._masked && typeof this._validationCallback === "function") {
-      return this._validationCallback.call(this, value);
-    }
-    return isSupportedTimeFormat(value);
-  }
-  _isValidInputValue(value) {
-    return TWENTY_FOUR_HOUR_TIME_REGEX.test(value);
-  }
-  _onSelect(value) {
-    this._closeDropdown(true);
-    if (!value.isCustom && value.metadata === "now") {
-      value.time = getCurrentTimeOfDayMillis(this._allowSeconds);
-    }
-    if (value.isCustom) {
-      if (typeof value.customCallback === "function") {
-        const result = value.customCallback.call(null, value.metadata);
-        if (typeof result !== "number") {
-          throw new Error("Custom options must provide a time of day value in milliseconds.");
-        }
-        value.time = result;
-      } else {
-        throw new Error("You must implement a `toMilliseconds` callback that returns the time value to use for this custom option.");
-      }
-    }
-    if (this._value === value.time) {
-      return;
-    }
-    const timeString = millisToTimeString(value.time, true, this._allowSeconds);
-    const canContinue = this._emitChangeEvent(timeString);
-    if (!canContinue) {
-      return;
-    }
-    this._applyValue(value.time);
-    this._selectInputText();
-  }
-  _selectInputText() {
-    window.requestAnimationFrame(() => {
-      window.requestAnimationFrame(() => {
-        if (this._adapter.isInputFocused()) {
-          this._adapter.selectInputText();
-        }
-      });
-    });
-  }
-  _applyValue(value, emitEvents = true) {
-    this._setValue(value);
-    const formattedValue = this._formatValue(this._value);
-    if (this._adapter.getInputValue() !== formattedValue) {
-      this._adapter.setInputValue(formattedValue, emitEvents);
-    }
-  }
-  _normalizeTimeValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    } else if (value < 0) {
-      return 0;
-    } else if (value > TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MILLIS) {
-      return TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MILLIS;
-    }
-    return value;
-  }
-  _openDropdown() {
-    const options = this._generateTimeOptions();
-    if (!this.allowDropdown || !options.length) {
-      return;
-    }
-    this._formatInputValue();
-    this._open = true;
-    this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.OPEN);
-    const selectableOptions = options.filter((o) => !o.divider && !o.disabled);
-    let selectedValues = [];
-    let activeStartIndex;
-    if (options.length) {
-      if (this._value !== null) {
-        const optionIndex = this._findClosestOptionIndex(this._value, selectableOptions);
-        if (optionIndex >= 0) {
-          const isExactMatch = selectableOptions[optionIndex].value.time === this._value;
-          if (isExactMatch) {
-            selectedValues = [selectableOptions[optionIndex].value];
-          } else {
-            activeStartIndex = optionIndex;
-          }
-        }
-      } else if (typeof this._startTime === "number") {
-        const optionIndex = this._findClosestOptionIndex(this._startTime, selectableOptions);
-        if (optionIndex >= 0 && optionIndex < selectableOptions.length) {
-          activeStartIndex = optionIndex;
-        }
-      }
-    }
-    const config = {
-      id: `forge-time-picker-${this._identifier}`,
-      selectedValues,
-      syncWidth: true,
-      activeStartIndex,
-      popupClasses: this._popupClasses,
-      popupStatic: true,
-      type: "standard" /* Standard */,
-      options,
-      selectCallback: (value) => this._onSelect(value),
-      closeCallback: () => this._closeDropdown(true),
-      activeChangeCallback: (id) => this._adapter.setActiveDescendant(id),
-      targetWidthCallback: () => this._adapter.getTargetElementWidth(this._popupTarget)
-    };
-    this._adapter.attachDropdown(config);
-    this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.OPEN, void 0, false);
-  }
-  _closeDropdown(emitCloseEvent = false) {
-    this._open = false;
-    this._adapter.removeHostAttribute(TIME_PICKER_CONSTANTS.attributes.OPEN);
-    this._adapter.detachDropdown();
-    if (emitCloseEvent) {
-      this._adapter.emitHostEvent(TIME_PICKER_CONSTANTS.events.CLOSE, true, false);
-    }
-  }
-  _findClosestOptionIndex(value, options) {
-    const closestItem = options.reduce((prev, curr) => {
-      return Math.abs((curr.value.time || 0) - value) < Math.abs((prev.value.time || 0) - value) ? curr : prev;
-    });
-    return options.indexOf(closestItem);
-  }
-  _formatInputValue(emitEvents = true) {
-    const inputValue = this._adapter.getInputValue();
-    if (this._allowInvalidTime && !this._masked && inputValue && !this._value) {
-      return;
-    }
-    const formattedValue = this._formatValue(this._value);
-    if (inputValue !== formattedValue) {
-      this._adapter.setInputValue(formattedValue, emitEvents);
-    }
-  }
-  _generateTimeOptions() {
-    const minMinutes = this._min !== null ? Math.max(millisToMinutes(this._min), 0) : 0;
-    const maxMinutes = this._max !== null ? Math.min(millisToMinutes(this._max), TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES) : TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES;
-    const minuteStep = this._step;
-    const times = [];
-    let leadingOptions = [];
-    if (this._showHourOptions) {
-      for (let totalMinutes = minMinutes; totalMinutes <= maxMinutes; totalMinutes += minuteStep) {
-        if (totalMinutes === TIME_PICKER_CONSTANTS.numbers.MAX_DAY_MINUTES) {
-          break;
-        }
-        const millis = minutesToMillis(totalMinutes);
-        const disabled = this._restrictedTimes.includes(millis);
-        const label = millisToTimeString(millis, this._use24HourTime, false) || "";
-        const value = { time: millis };
-        times.push({ label, value, disabled });
-      }
-      const firstPmIndex = times.findIndex((t) => t.value.time / 1e3 / 60 >= 720);
-      if (firstPmIndex >= 0 && firstPmIndex < times.length - 1) {
-        times.splice(firstPmIndex, 0, { label: "", value: null, divider: true });
-      }
-    }
-    if (this._showNow) {
-      const value = { time: null, metadata: "now" };
-      leadingOptions.push({ label: "Now", value });
-    }
-    if (Array.isArray(this._customOptions) && this._customOptions.length) {
-      const options = this._customOptions.map((o) => {
-        const value = { time: null, metadata: o.value, isCustom: true, customCallback: o.toMilliseconds };
-        return { label: o.label, value };
-      });
-      leadingOptions = [...leadingOptions, ...options];
-    }
-    if (leadingOptions.length) {
-      if (times.length) {
-        times.splice(0, 0, { label: "", value: null, divider: true });
-      }
-      leadingOptions.forEach((o, index) => times.splice(index, 0, o));
-    }
-    return times;
-  }
-  _convertTimeStringToMillis(value, use24HourTime, allowSeconds) {
-    if (!value || !this._isValidTimeFormat(value)) {
-      value = "";
-    }
-    return timeStringToMillis(value, use24HourTime, allowSeconds);
-  }
-  _formatValue(value) {
-    if (!this._masked && typeof this._formatCallback === "function") {
-      return this._formatCallback.call(null, value, this._use24HourTime, this._allowSeconds);
-    }
-    return millisToTimeString(this._value, this._use24HourTime, this._allowSeconds) || "";
-  }
-  _warnInvalidFormat(value) {
-    console.warn(`The specified value "${value}" does not conform to the required format. The format is "HH:mm", "HH:mm:ss" where HH is 00-23, mm is 00-59, and ss is 00-59.`);
-  }
-  get open() {
-    return this._open;
-  }
-  set open(value) {
-    if (this._open !== value) {
-      if (this._isInitialized) {
-        this._open = value;
-        if (this._open) {
-          this._openDropdown();
-        } else {
-          this._closeDropdown();
-        }
-      }
-    }
-  }
-  get masked() {
-    return this._masked;
-  }
-  set masked(value) {
-    if (this._masked !== value) {
-      this._masked = value;
-      if (this._isInitialized) {
-        if (this._masked) {
-          this._adapter.removeInputListener("input", this._inputListener);
-          this._applyMask();
-        } else {
-          this._adapter.destroyMask();
-          this._formatInputValue();
-          this._adapter.addInputListener("input", this._inputListener);
-        }
-      }
-    }
-  }
-  get showMaskFormat() {
-    return this._showMaskFormat;
-  }
-  set showMaskFormat(value) {
-    if (this._showMaskFormat !== value) {
-      this._showMaskFormat = value;
-      if (this._isInitialized) {
-        this._applyMask();
-      }
-    }
-  }
-  get allowSeconds() {
-    return this._allowSeconds;
-  }
-  set allowSeconds(value) {
-    if (this._allowSeconds !== value) {
-      this._allowSeconds = !!value;
-      this._applyAllowSeconds();
-      if (this._isInitialized) {
-        this._applyMask();
-        this._formatInputValue();
-      }
-      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS, `${!!value}`);
-    }
-  }
-  get use24HourTime() {
-    return this._use24HourTime;
-  }
-  set use24HourTime(value) {
-    if (this._use24HourTime !== value) {
-      this._use24HourTime = !!value;
-      if (this._isInitialized) {
-        this._adapter.destroyMask();
-        this._formatInputValue();
-        this._applyMask();
-      }
-      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME, `${!!value}`);
-    }
-  }
-  get allowInvalidTime() {
-    return this._allowInvalidTime;
-  }
-  set allowInvalidTime(value) {
-    if (this._allowInvalidTime !== value) {
-      this._allowInvalidTime = !!value;
-      this._adapter.setHostAttribute(TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME, `${!!value}`);
-    }
-  }
-  get value() {
-    return millisToTimeString(this._value, true, this._allowSeconds);
-  }
-  set value(value) {
-    if (value && !this._isValidInputValue(value)) {
-      this._warnInvalidFormat(value);
-      return;
-    }
-    const millis = this._validateMillis(this._convertTimeStringToMillis(value, true, true));
-    this._setValue(millis);
-    if (this._isInitialized) {
-      this._applyValue(this._value);
-    }
-  }
-  get min() {
-    return millisToTimeString(this._min, true, this._allowSeconds);
-  }
-  set min(value) {
-    if (this._min !== value) {
-      if (value && !this._isValidInputValue(value)) {
-        this._warnInvalidFormat(value);
-        return;
-      }
-      this._min = this._convertTimeStringToMillis(value, true, this._allowSeconds);
-      const millis = this._validateMillis(this._value);
-      this._setValue(millis);
-      if (this._isInitialized) {
-        this._applyValue(millis);
-      }
-    }
-  }
-  get max() {
-    return millisToTimeString(this._max, true, this._allowSeconds);
-  }
-  set max(value) {
-    if (this._max !== value) {
-      if (value && !this._isValidInputValue(value)) {
-        this._warnInvalidFormat(value);
-        return;
-      }
-      this._max = this._convertTimeStringToMillis(value, true, this._allowSeconds);
-      const millis = this._validateMillis(this._value);
-      this._setValue(millis);
-      if (this._isInitialized) {
-        this._applyValue(millis);
-      }
-    }
-  }
-  get restrictedTimes() {
-    return this._restrictedTimes.map((t) => millisToTimeString(t, true, this._allowSeconds)).filter((v) => typeof v === "string");
-  }
-  set restrictedTimes(value) {
-    if (!Array.isArray(value)) {
-      value = [];
-    }
-    this._restrictedTimes = value.filter((v) => typeof v === "string").map((v) => this._convertTimeStringToMillis(v, true, true)).filter((v) => typeof v === "number");
-  }
-  get startTime() {
-    return millisToTimeString(this._startTime, true, this._allowSeconds);
-  }
-  set startTime(value) {
-    if (this._startTime !== value) {
-      if (value && !this._isValidInputValue(value)) {
-        this._warnInvalidFormat(value);
-        return;
-      }
-      this._startTime = this._convertTimeStringToMillis(value, true, this._allowSeconds);
-    }
-  }
-  get step() {
-    return this._step;
-  }
-  set step(value) {
-    this._step = value;
-  }
-  get allowInput() {
-    return this._allowInput;
-  }
-  set allowInput(value) {
-    if (this._allowInput !== value) {
-      this._allowInput = value;
-      if (this._isInitialized) {
-        this._applyAllowInput();
-        this._applyMask();
-      }
-    }
-  }
-  get popupTarget() {
-    return this._popupTarget;
-  }
-  set popupTarget(value) {
-    if (this._popupTarget !== value) {
-      this._popupTarget = value;
-    }
-  }
-  get showNow() {
-    return this._showNow;
-  }
-  set showNow(value) {
-    if (this._showNow !== value) {
-      this._showNow = value;
-    }
-  }
-  get showHourOptions() {
-    return this._showHourOptions;
-  }
-  set showHourOptions(value) {
-    if (this._showHourOptions !== value) {
-      this._showHourOptions = value;
-    }
-  }
-  get customOptions() {
-    return this._customOptions;
-  }
-  set customOptions(value) {
-    this._customOptions = Array.isArray(value) ? value : [];
-  }
-  set validationCallback(cb) {
-    this._validationCallback = cb;
-    if (this._isInitialized) {
-      this._applyMask();
-    }
-  }
-  set parseCallback(cb) {
-    this._parseCallback = cb;
-  }
-  set formatCallback(cb) {
-    this._formatCallback = cb;
-  }
-  set coercionCallback(cb) {
-    this._coercionCallback = cb;
-  }
-  set prepareMaskCallback(cb) {
-    this._prepareMaskCallback = cb;
-    if (this._isInitialized) {
-      this._applyMask();
-    }
-  }
-  get disabled() {
-    return this._disabled;
-  }
-  set disabled(value) {
-    if (this._disabled !== value) {
-      this._disabled = !!value;
-      if (this._isInitialized) {
-        this._applyDisabled();
-      }
-      this._adapter.toggleHostAttribute(TIME_PICKER_CONSTANTS.attributes.DISABLED, this._disabled);
-    }
-  }
-  get popupClasses() {
-    if (Array.isArray(this._popupClasses)) {
-      return [...this._popupClasses];
-    }
-    return this._popupClasses;
-  }
-  set popupClasses(value) {
-    if (Array.isArray(value)) {
-      this._popupClasses = [...value];
-    } else {
-      this._popupClasses = [value];
-    }
-  }
-  get allowDropdown() {
-    return this._allowDropdown;
-  }
-  set allowDropdown(value) {
-    if (this._allowDropdown !== value) {
-      this._allowDropdown = value;
-      if (this._isInitialized) {
-        this._applyAllowDropdown();
-      }
-    }
-  }
-};
-
-// dist/build/lib/staging/src/time-picker/time-picker.ts
-var template = "<template><slot></slot></template>";
-var styles = ":host{display:block}:host([hidden]){display:none}";
-var TimePickerComponent = class extends BaseComponent {
-  constructor() {
-    super();
-    IconRegistry.define([tylIconClockOutline, tylIconClose]);
-    attachShadowTemplate(this, template, styles);
-    this._foundation = new TimePickerFoundation(new TimePickerAdapter(this));
-  }
-  static get observedAttributes() {
-    return [
-      TIME_PICKER_CONSTANTS.attributes.VALUE,
-      TIME_PICKER_CONSTANTS.attributes.OPEN,
-      TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS,
-      TIME_PICKER_CONSTANTS.attributes.MASKED,
-      TIME_PICKER_CONSTANTS.attributes.SHOW_MASK_FORMAT,
-      TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME,
-      TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME,
-      TIME_PICKER_CONSTANTS.attributes.MIN,
-      TIME_PICKER_CONSTANTS.attributes.MAX,
-      TIME_PICKER_CONSTANTS.attributes.START_TIME,
-      TIME_PICKER_CONSTANTS.attributes.STEP,
-      TIME_PICKER_CONSTANTS.attributes.ALLOW_INPUT,
-      TIME_PICKER_CONSTANTS.attributes.SHOW_NOW,
-      TIME_PICKER_CONSTANTS.attributes.SHOW_HOUR_OPTIONS,
-      TIME_PICKER_CONSTANTS.attributes.DISABLED,
-      TIME_PICKER_CONSTANTS.attributes.POPUP_CLASSES,
-      TIME_PICKER_CONSTANTS.attributes.ALLOW_DROPDOWN
-    ];
-  }
-  connectedCallback() {
-    if (this.querySelector(TIME_PICKER_CONSTANTS.selectors.INPUT)) {
-      this._foundation.initialize();
-    } else {
-      ensureChild(this, TIME_PICKER_CONSTANTS.selectors.INPUT).then(() => this._foundation.initialize());
-    }
-  }
-  disconnectedCallback() {
-    this._foundation.disconnect();
-  }
-  attributeChangedCallback(name, oldValue, newValue) {
-    switch (name) {
-      case TIME_PICKER_CONSTANTS.attributes.VALUE:
-        this.value = newValue;
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.OPEN:
-        this.open = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.ALLOW_SECONDS:
-        this.allowSeconds = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.MASKED:
-        this.masked = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.SHOW_MASK_FORMAT:
-        this.showMaskFormat = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.USE_24_HOUR_TIME:
-        this.use24HourTime = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.ALLOW_INVALID_TIME:
-        this.allowInvalidTime = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.SHOW_NOW:
-        this.showNow = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.SHOW_HOUR_OPTIONS:
-        this.showHourOptions = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.MIN:
-        this.min = newValue;
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.MAX:
-        this.max = newValue;
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.START_TIME:
-        this.startTime = newValue;
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.STEP:
-        this.step = coerceNumber(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.ALLOW_INPUT:
-        this.allowInput = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.DISABLED:
-        this.disabled = coerceBoolean(newValue);
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.POPUP_CLASSES:
-        this.popupClasses = newValue;
-        break;
-      case TIME_PICKER_CONSTANTS.attributes.ALLOW_DROPDOWN:
-        this.allowDropdown = coerceBoolean(newValue);
-        break;
-    }
-  }
-};
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "value", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "open", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "allowSeconds", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "masked", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "showMaskFormat", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "use24HourTime", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "allowInvalidTime", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "min", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "max", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "restrictedTimes", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "startTime", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "step", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "allowInput", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "showNow", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "showHourOptions", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "customOptions", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "validationCallback", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "parseCallback", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "formatCallback", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "coercionCallback", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "prepareMaskCallback", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "disabled", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "popupClasses", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "allowDropdown", 2);
-__decorateClass([
-  FoundationProperty()
-], TimePickerComponent.prototype, "popupTarget", 2);
-TimePickerComponent = __decorateClass([
-  CustomElement({
-    name: TIME_PICKER_CONSTANTS.elementName,
-    dependencies: [
-      ListComponent,
-      ListItemComponent,
-      IconButtonComponent,
-      IconComponent,
-      PopupComponent,
-      IconComponent,
-      DialogComponent
-    ]
-  })
-], TimePickerComponent);
-
-// dist/build/lib/staging/src/time-picker/time-picker-component-delegate.ts
-var TimePickerComponentDelegate = class extends FormFieldComponentDelegate {
-  constructor(config) {
-    super(config);
-  }
-  _build() {
-    const timePicker = document.createElement(TIME_PICKER_CONSTANTS.elementName);
-    this._attachTextField(timePicker);
-    return timePicker;
-  }
-  get inputElement() {
-    return this._textFieldDelegate.inputElement;
-  }
-  get textFieldElement() {
-    return this._textFieldDelegate.element;
-  }
-  get value() {
-    return this._element.value;
-  }
-  set value(value) {
-    this._element.value = value;
-  }
-  get disabled() {
-    return this._element.disabled;
-  }
-  set disabled(value) {
-    this._element.disabled = value;
-  }
-  get invalid() {
-    return this._textFieldDelegate.invalid || false;
-  }
-  set invalid(value) {
-    this._textFieldDelegate.invalid = value;
-  }
-  onChange(listener) {
-    this._element.addEventListener(TIME_PICKER_CONSTANTS.events.CHANGE, (evt) => {
-      var _a;
-      return listener((_a = evt.detail) != null ? _a : "");
-    });
-  }
-  onInput(listener) {
-    if (this._element.masked) {
-      this._element.addEventListener(TIME_PICKER_CONSTANTS.events.INPUT, (evt) => {
-        var _a;
-        return listener((_a = evt.detail) != null ? _a : "");
-      });
-    } else {
-      this._textFieldDelegate.inputElement.addEventListener("input", (evt) => listener(evt.target.value));
-    }
-  }
-  onFocus(listener) {
-    this._textFieldDelegate.inputElement.addEventListener("focus", (evt) => listener(evt));
-  }
-  onBlur(listener) {
-    this._textFieldDelegate.inputElement.addEventListener("blur", (evt) => listener(evt));
-  }
-  _attachTextField(component) {
-    var _a, _b, _c, _d;
-    const textFieldConfig = {
-      props: __spreadValues({}, (_b = (_a = this._config.options) == null ? void 0 : _a.textFieldDelegateConfig) == null ? void 0 : _b.props),
-      options: __spreadValues({}, (_d = (_c = this._config.options) == null ? void 0 : _c.textFieldDelegateConfig) == null ? void 0 : _d.options)
-    };
-    this._textFieldDelegate = new TextFieldComponentDelegate(textFieldConfig);
-    component.appendChild(this._textFieldDelegate.element);
-  }
-};
-
-// dist/build/lib/staging/src/time-picker/index.ts
-function defineTimePickerComponent() {
-  defineCustomElement(TimePickerComponent);
-}
-
-export {
-  TIME_PICKER_CONSTANTS,
-  TimePickerAdapter,
-  timeStringToMillis,
-  millisToTimeString,
-  millisToHours,
-  millisToMinutesClamped,
-  millisToMinutes,
-  millisToSecondsClamped,
-  millisToSeconds,
-  hoursToMillis,
-  minutesToMillis,
-  secondsToMillis,
-  stripSecondsFromMillis,
-  getCurrentTimeOfDayMillis,
-  mergeDateWithTime,
-  TimePickerFoundation,
-  TimePickerComponent,
-  TimePickerComponentDelegate,
-  defineTimePickerComponent
-};
-//# sourceMappingURL=chunk.2NMHSTAO.js.map