@tylertech/forge 2.8.0 → 2.10.0

package/dist/esm/chunks/chunk.CLEUHAZ6.js

@@ -1,732 +0,0 @@
-/**
- * @license
- * Copyright 2022 Tyler Technologies, Inc. 
- * License: Apache-2.0
- */
-import {
-  STEP_CONSTANTS,
-  StepComponent
-} from "./chunk.67B6JDOJ.js";
-import {
-  getEventPath
-} from "./chunk.EY57VTRF.js";
-import {
-  Platform
-} from "./chunk.BYN27JXZ.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,
-  getShadowElement
-} from "./chunk.K2PCTUVN.js";
-import {
-  ensureChildren,
-  getActiveElement,
-  toggleClass
-} from "./chunk.4JURZYE4.js";
-import {
-  coerceBoolean,
-  isDefined,
-  isNumber
-} from "./chunk.MEFT5FQC.js";
-import {
-  __decorateClass,
-  __spreadValues
-} from "./chunk.LM5TVNZY.js";
-
-// dist/build/lib/staging/src/stepper/stepper/stepper-constants.ts
-var elementName = `${COMPONENT_NAME_PREFIX}stepper`;
-var classes = {
-  STEPPER: "forge-stepper",
-  LINEAR: "forge-stepper--linear",
-  ALTERNATIVE: "forge-stepper--alternative",
-  CLUSTERED: "forge-stepper--clustered",
-  FIXED: "forge-stepper--fixed",
-  ALIGN_LEFT: "forge-stepper--align-left",
-  ALIGN_CENTER: "forge-stepper--align-center",
-  ALIGN_RIGHT: "forge-stepper--align-right",
-  VERTICAL: "forge-stepper--vertical",
-  FOCUSED: "forge-stepper--focused"
-};
-var selectors = {
-  STEPPER: `.${classes.STEPPER}`
-};
-var attributes = {
-  SELECTED_INDEX: "selected-index",
-  LINEAR: "linear",
-  ALTERNATIVE: "alternative",
-  LAYOUT_MODE: "layout-mode",
-  LAYOUT_ALIGN: "layout-align",
-  DISABLED: "disabled",
-  VERTICAL: "vertical"
-};
-var strings = {
-  ARROW_LEFT_KEY: "ArrowLeft",
-  ARROW_RIGHT_KEY: "ArrowRight",
-  ARROW_UP_KEY: "ArrowUp",
-  ARROW_DOWN_KEY: "ArrowDown",
-  END_KEY: "End",
-  ENTER_KEY: "Enter",
-  HOME_KEY: "Home",
-  SPACE_KEY: "Space",
-  TAB_KEY: "Tab"
-};
-var numbers = {
-  ARROW_LEFT_KEYCODE: 37,
-  ARROW_RIGHT_KEYCODE: 39,
-  END_KEYCODE: 35,
-  HOME_KEYCODE: 36,
-  ENTER_KEYCODE: 13,
-  SPACE_KEYCODE: 32
-};
-var ACCEPTABLE_KEYS = [
-  strings.ARROW_LEFT_KEY,
-  strings.ARROW_RIGHT_KEY,
-  strings.ARROW_DOWN_KEY,
-  strings.ARROW_UP_KEY,
-  strings.END_KEY,
-  strings.HOME_KEY,
-  strings.ENTER_KEY,
-  strings.SPACE_KEY,
-  strings.TAB_KEY
-];
-var KEYCODE_MAP = {
-  [numbers.ARROW_LEFT_KEYCODE]: strings.ARROW_LEFT_KEY,
-  [numbers.ARROW_RIGHT_KEYCODE]: strings.ARROW_RIGHT_KEY,
-  [numbers.END_KEYCODE]: strings.END_KEY,
-  [numbers.HOME_KEYCODE]: strings.HOME_KEY,
-  [numbers.ENTER_KEYCODE]: strings.ENTER_KEY,
-  [numbers.SPACE_KEYCODE]: strings.SPACE_KEY
-};
-var STEPPER_CONSTANTS = {
-  elementName,
-  classes,
-  selectors,
-  attributes,
-  numbers,
-  strings,
-  ACCEPTABLE_KEYS,
-  KEYCODE_MAP
-};
-
-// dist/build/lib/staging/src/stepper/core/stepper-utils.ts
-var StepperUtils = class {
-  static createStepElement(step, index, stepperConfig) {
-    const stepElement = document.createElement(STEP_CONSTANTS.elementName);
-    stepElement.index = index;
-    stepElement.completed = step.completed || false;
-    stepElement.editable = step.editable || false;
-    stepElement.selected = stepperConfig.selectedIndex === index;
-    stepElement.alternative = stepperConfig.alternative;
-    stepElement.error = step.error || false;
-    stepElement.disabled = step.disabled || false;
-    stepElement.vertical = step.vertical || false;
-    stepElement.ignoreUserExpansion = step.ignoreUserExpansion || false;
-    stepElement.expanded = step.expanded || false;
-    if (stepperConfig.linear && index > stepperConfig.selectedIndex) {
-      stepElement.tabIndex = -1;
-    }
-    stepElement.textContent = step.label;
-    if (step.optionalLabel) {
-      stepElement.appendChild(this.createStepOptionalLabel(step.optionalLabel));
-    }
-    return stepElement;
-  }
-  static createStepOptionalLabel(labelText) {
-    const label = document.createElement("span");
-    label.slot = "optional";
-    label.textContent = labelText || "";
-    return label;
-  }
-  static setLinearState(stepperElement, isLinear) {
-    let hasLinearClass = stepperElement.classList.contains(STEPPER_CONSTANTS.classes.LINEAR);
-    if (hasLinearClass && !isLinear) {
-      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.LINEAR);
-      hasLinearClass = false;
-    }
-    if (!hasLinearClass && isLinear) {
-      stepperElement.classList.add(STEPPER_CONSTANTS.classes.LINEAR);
-    }
-  }
-  static setAlternativeState(stepperElement, isAlternative) {
-    let hasAlternativeClass = stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALTERNATIVE);
-    if (hasAlternativeClass && !isAlternative) {
-      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALTERNATIVE);
-      hasAlternativeClass = false;
-    }
-    if (!hasAlternativeClass && isAlternative) {
-      stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALTERNATIVE);
-    }
-  }
-  static setLayoutMode(stepperElement, mode) {
-    switch (mode) {
-      case "clustered":
-        if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.FIXED)) {
-          stepperElement.classList.remove(STEPPER_CONSTANTS.classes.FIXED);
-        }
-        stepperElement.classList.add(STEPPER_CONSTANTS.classes.CLUSTERED);
-        break;
-      case "fixed":
-        if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.CLUSTERED)) {
-          stepperElement.classList.remove(STEPPER_CONSTANTS.classes.CLUSTERED);
-        }
-        stepperElement.classList.add(STEPPER_CONSTANTS.classes.FIXED);
-        break;
-    }
-  }
-  static setLayoutAlign(stepperElement, mode) {
-    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_LEFT)) {
-      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_LEFT);
-    }
-    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_CENTER)) {
-      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_CENTER);
-    }
-    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_RIGHT)) {
-      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_RIGHT);
-    }
-    switch (mode) {
-      case "left":
-        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_LEFT);
-        break;
-      case "center":
-        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_CENTER);
-        break;
-      case "right":
-        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_RIGHT);
-        break;
-    }
-  }
-  static createSteps(stepperConfiguration) {
-    const steps = [];
-    stepperConfiguration.steps.forEach((step, index) => {
-      const stepElement = StepperUtils.createStepElement(step, index, stepperConfiguration);
-      steps.push(stepElement);
-    });
-    steps[0].setAttribute(STEP_CONSTANTS.attributes.FIRST, "");
-    steps[steps.length - 1].setAttribute(STEP_CONSTANTS.attributes.LAST, "");
-    return steps;
-  }
-};
-
-// dist/build/lib/staging/src/stepper/stepper/stepper-adapter.ts
-var StepperAdapter = class extends BaseAdapter {
-  constructor(component) {
-    super(component);
-    this._rootElement = getShadowElement(component, STEPPER_CONSTANTS.selectors.STEPPER);
-    this._slotElement = this._rootElement.querySelector("slot");
-  }
-  initializeAccessibility() {
-    if (!this._component.hasAttribute("role")) {
-      this._component.setAttribute("role", "tablist");
-    }
-  }
-  patchSafari() {
-    this._applyToSteps((s) => s.setAttribute("safari", ""));
-  }
-  addSlotChangeListener(listener) {
-    this._slotElement.addEventListener("slotchange", listener);
-  }
-  removeSlotChangeListener(listener) {
-    this._slotElement.addEventListener("slotchange", listener);
-  }
-  getLastStep() {
-    const steps = this._getSteps();
-    return steps.item(steps.length - 1);
-  }
-  setSelected(step) {
-    this._getSteps().forEach((s) => {
-      if (s === step) {
-        s.selected = true;
-      } else {
-        s.selected = false;
-      }
-    });
-  }
-  assignIndices() {
-    const steps = this._getSteps();
-    steps.forEach((tab, index) => {
-      tab.index = index;
-    });
-  }
-  assignFirstLastStep() {
-    const steps = this._getSteps();
-    if (steps && steps.length > 1) {
-      steps[0].setAttribute("first", "");
-      steps[steps.length - 1].setAttribute("last", "");
-    }
-  }
-  setLayoutAlign(layoutAlign) {
-    StepperUtils.setLayoutAlign(this._rootElement, layoutAlign);
-  }
-  setLayoutMode(layoutMode) {
-    StepperUtils.setLayoutMode(this._rootElement, layoutMode);
-    this._applyToSteps((s) => s.setAttribute(STEP_CONSTANTS.attributes.CLUSTERED, ""));
-  }
-  setAlternativeState(alternative) {
-    StepperUtils.setAlternativeState(this._rootElement, alternative);
-    this._applyToSteps((step) => step.alternative = alternative);
-  }
-  setVertical(vertical) {
-    toggleClass(this._rootElement, vertical, STEPPER_CONSTANTS.classes.VERTICAL);
-    this._applyToSteps((step) => step.vertical = vertical);
-  }
-  setLinearState(linear) {
-    StepperUtils.setLinearState(this._rootElement, linear);
-  }
-  removeRootListener(event, listener) {
-    this._rootElement.removeEventListener("click", listener);
-  }
-  addRootListener(event, listener) {
-    this._rootElement.addEventListener(event, listener);
-  }
-  setSelectedByIndex(index) {
-    this._applyToSteps((step) => {
-      if (step.selected && step.index !== index) {
-        step.selected = false;
-      }
-      if (step.index === index) {
-        step.selected = true;
-      }
-    });
-  }
-  applyConfiguredSteps(steps) {
-    this._component.querySelectorAll(STEP_CONSTANTS.elementName).forEach((n) => {
-      this._component.removeChild(n);
-    });
-    steps.forEach((s) => this._component.appendChild(s));
-  }
-  tryGetFocusedStep() {
-    let focusedStep = void 0;
-    const activeElement = getActiveElement();
-    this._applyToSteps((step) => {
-      if (activeElement === getShadowElement(step, STEP_CONSTANTS.selectors.STEP)) {
-        focusedStep = step;
-      }
-    });
-    return focusedStep;
-  }
-  getFocusedOrSelectedStep() {
-    let focusedStep = this.tryGetFocusedStep();
-    if (!focusedStep) {
-      focusedStep = this._getSteps()[0];
-      focusedStep.focus();
-    }
-    return focusedStep;
-  }
-  getStep(index) {
-    let realIndex = 0;
-    const steps = this._getSteps();
-    if (index < 0) {
-      return steps.item(steps.length - 1);
-    }
-    if (steps.length > index) {
-      realIndex = index;
-    }
-    return steps.item(realIndex);
-  }
-  toggleDisabled(disabled) {
-    this._applyToSteps((s) => s.disabled = disabled);
-  }
-  toggleRootClass(className, show) {
-    toggleClass(this._rootElement, show, className);
-  }
-  isStepperFocused() {
-    return this._rootElement.classList.contains(STEPPER_CONSTANTS.classes.FOCUSED);
-  }
-  setStepsListener(event, listener) {
-    this._applyToSteps((s) => s.addEventListener(event, listener));
-  }
-  removeStepsListener(event, listener) {
-    this._applyToSteps((s) => s.removeEventListener(event, listener));
-  }
-  _applyToSteps(action) {
-    this._getSteps().forEach(action);
-  }
-  _getSteps() {
-    return this._component.querySelectorAll(STEP_CONSTANTS.elementName);
-  }
-};
-
-// dist/build/lib/staging/src/stepper/stepper/stepper-foundation.ts
-var StepperFoundation = class {
-  constructor(_adapter) {
-    this._adapter = _adapter;
-    this._steps = [];
-    this._selectedIndex = 0;
-    this._linear = false;
-    this._alternative = false;
-    this._layoutMode = "fixed";
-    this._layoutAlign = "center";
-    this._initialize = false;
-    this._clickListener = (event) => this._handleClick(event);
-    this._keyListener = (event) => this._onKeydown(event);
-    this._stepFocusListener = () => this._onStepFocus();
-    this._stepBlurListener = () => this._onStepBlur();
-    this._stepExpandedContentFocusInListener = (event) => this._onStepExpandedContentFocusIn(event);
-    this._stepExpandedContentFocusOutListener = (event) => this._onStepExpandedContentFocusOut(event);
-    this._slotChangeListener = (event) => this._onSlotChange(event);
-  }
-  initialize() {
-    this._adapter.initializeAccessibility();
-    this._adapter.assignIndices();
-    this._adapter.setLinearState(this._linear);
-    this._adapter.setAlternativeState(this._alternative);
-    this._adapter.setLayoutAlign(this._layoutAlign);
-    this._adapter.setLayoutMode(this._layoutMode);
-    this._adapter.addRootListener("click", this._clickListener);
-    this._adapter.addHostListener("keydown", this._keyListener);
-    this._adapter.assignFirstLastStep();
-    this._adapter.addRootListener(STEP_CONSTANTS.events.EXPANDED_CONTENT_FOCUSIN, this._stepExpandedContentFocusInListener);
-    this._adapter.addRootListener(STEP_CONSTANTS.events.EXPANDED_CONTENT_FOCUSOUT, this._stepExpandedContentFocusOutListener);
-    this._applySelectedIndex();
-    this._patchBrowser();
-    this._adapter.setStepsListener("blur", this._stepBlurListener);
-    this._adapter.setStepsListener("focus", this._stepFocusListener);
-    if (!this._initialize) {
-      this._adapter.addSlotChangeListener(this._slotChangeListener);
-    }
-    this._initialize = true;
-  }
-  disconnect() {
-    this._adapter.removeRootListener("click", this._clickListener);
-    this._adapter.removeHostListener("keydown", this._keyListener);
-    this._adapter.removeSlotChangeListener(this._slotChangeListener);
-    this._adapter.removeStepsListener("blur", this._stepBlurListener);
-    this._adapter.removeStepsListener("focus", this._stepFocusListener);
-  }
-  get steps() {
-    return JSON.parse(JSON.stringify(this._steps));
-  }
-  set steps(value) {
-    if (Array.isArray(value) && value.length > 0) {
-      this._steps = [...value.map((s) => __spreadValues({}, s))];
-    } else {
-      this._steps = [];
-      return;
-    }
-    this._renderConfiguration();
-  }
-  get selectedIndex() {
-    return this._selectedIndex;
-  }
-  set selectedIndex(value) {
-    if (!isDefined(value)) {
-      value = 0;
-    } else if (!isNumber(value)) {
-      const v = Number(value);
-      value = !isNaN(v) ? v : 0;
-    }
-    if (this._selectedIndex !== value) {
-      this._selectedIndex = value;
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.SELECTED_INDEX, this._selectedIndex.toString());
-      this._applySelectedIndex();
-    }
-  }
-  get linear() {
-    return this._linear;
-  }
-  set linear(value) {
-    value = Boolean(value);
-    if (this._linear !== value) {
-      this._linear = value;
-      this._adapter.setLinearState(this._linear);
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LINEAR, this._linear.toString());
-    }
-  }
-  get alternative() {
-    return this._alternative;
-  }
-  set alternative(value) {
-    value = Boolean(value);
-    if (this._alternative !== value) {
-      this._alternative = value;
-      this._adapter.setAlternativeState(this._alternative);
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.ALTERNATIVE, this._alternative.toString());
-    }
-  }
-  get layoutMode() {
-    return this._layoutMode;
-  }
-  set layoutMode(value) {
-    if (!/^(fixed|clustered)$/.test(value)) {
-      return;
-    }
-    if (this._layoutMode !== value) {
-      this._layoutMode = value;
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LAYOUT_MODE, this._layoutMode);
-      this._adapter.setLayoutMode(this._layoutMode);
-    }
-  }
-  get layoutAlign() {
-    return this._layoutAlign;
-  }
-  set layoutAlign(value) {
-    if (!/^(left|center|right)$/.test(value)) {
-      return;
-    }
-    if (this._layoutAlign !== value) {
-      this._layoutAlign = value;
-      this._adapter.setLayoutAlign(this._layoutAlign);
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN, this._layoutAlign);
-    }
-  }
-  get disabled() {
-    return this._disabled;
-  }
-  set disabled(value) {
-    if (value !== this._disabled) {
-      this._disabled = value;
-      this._applyDisabled();
-    }
-  }
-  get vertical() {
-    return this._vertical;
-  }
-  set vertical(value) {
-    if (value !== this._vertical) {
-      this._vertical = value;
-      this._applyVertical();
-      this._adapter.toggleHostAttribute(STEPPER_CONSTANTS.attributes.VERTICAL, this._vertical);
-    }
-  }
-  _applyVertical() {
-    this._adapter.setVertical(this._vertical);
-  }
-  _applyDisabled() {
-    if (this._disabled) {
-      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.DISABLED, "disabled");
-    } else {
-      this._adapter.removeHostAttribute(STEPPER_CONSTANTS.attributes.DISABLED);
-    }
-    this._adapter.toggleDisabled(this._disabled);
-  }
-  _applySelectedIndex() {
-    this._adapter.setSelectedByIndex(this._selectedIndex);
-  }
-  _handleClick(event) {
-    event.preventDefault();
-    if (this._linear) {
-      return;
-    }
-    const eventPath = getEventPath(event);
-    const stepRoot = eventPath.find((el) => el.classList && el.classList.contains(STEP_CONSTANTS.classes.STEP));
-    const step = eventPath.find((el) => el.localName === STEP_CONSTANTS.elementName);
-    if (stepRoot && step && !step.selected && !step.disabled && this._adapter.emitHostEvent(STEP_CONSTANTS.events.SELECT, step.index, true, true)) {
-      this._adapter.setSelected(step);
-      this.selectedIndex = step.index;
-    }
-  }
-  _renderConfiguration() {
-    const steps = StepperUtils.createSteps({
-      steps: this._steps,
-      selectedIndex: this._selectedIndex,
-      alternative: this._alternative,
-      layoutAlign: this._layoutAlign,
-      layoutMode: this._layoutMode,
-      linear: this._linear
-    });
-    this.disconnect();
-    this._adapter.applyConfiguredSteps(steps);
-    this.initialize();
-  }
-  _onKeydown(event) {
-    if (this._linear) {
-      return;
-    }
-    const key = this._getKeyFromEvent(event);
-    if (!this._adapter.isStepperFocused()) {
-      return;
-    }
-    if (!key) {
-      return;
-    }
-    if ([STEP_CONSTANTS.strings.HOME_KEY, STEP_CONSTANTS.strings.END_KEY, STEP_CONSTANTS.strings.ARROW_DOWN_KEY, STEPPER_CONSTANTS.strings.ARROW_UP_KEY].includes(key)) {
-      event.preventDefault();
-    }
-    const step = this._vertical ? this._determineVerticalMoveTarget(key) : this._determineMoveTarget(key);
-    if (step) {
-      this._moveFocusTo(step);
-    }
-  }
-  _moveFocusTo(step) {
-    getShadowElement(step, STEP_CONSTANTS.selectors.STEP).focus();
-  }
-  _getKeyFromEvent(evt) {
-    if (STEPPER_CONSTANTS.ACCEPTABLE_KEYS.includes(evt.key)) {
-      return evt.key;
-    }
-    return STEPPER_CONSTANTS.KEYCODE_MAP[evt.keyCode];
-  }
-  _determineMoveTarget(key) {
-    const step = this._adapter.getFocusedOrSelectedStep();
-    if (step) {
-      switch (key) {
-        case STEPPER_CONSTANTS.strings.ARROW_RIGHT_KEY:
-          return this._adapter.getStep(step.index + 1);
-        case STEPPER_CONSTANTS.strings.ARROW_LEFT_KEY:
-          return this._adapter.getStep(step.index - 1);
-        case STEPPER_CONSTANTS.strings.HOME_KEY:
-          return this._adapter.getStep(0);
-        case STEPPER_CONSTANTS.strings.END_KEY:
-          return this._adapter.getLastStep();
-      }
-    }
-    return step;
-  }
-  _determineVerticalMoveTarget(key) {
-    const step = this._adapter.getFocusedOrSelectedStep();
-    if (step) {
-      switch (key) {
-        case STEPPER_CONSTANTS.strings.ARROW_DOWN_KEY:
-          return this._adapter.getStep(step.index + 1);
-        case STEPPER_CONSTANTS.strings.ARROW_UP_KEY:
-          return this._adapter.getStep(step.index - 1);
-        case STEPPER_CONSTANTS.strings.HOME_KEY:
-          return this._adapter.getStep(0);
-        case STEPPER_CONSTANTS.strings.END_KEY:
-          return this._adapter.getLastStep();
-      }
-    }
-    return step;
-  }
-  _onSlotChange(event) {
-    this.disconnect();
-    this.initialize();
-  }
-  _onStepExpandedContentFocusIn(event) {
-    const step = this._adapter.getStep(event.detail.index + 1);
-    if (step) {
-      step.setStepTabIndex(0);
-    }
-    event.detail.setStepTabIndex(0);
-  }
-  _onStepExpandedContentFocusOut(event) {
-    const focusOutStep = event.target;
-    const step = this._adapter.getStep(focusOutStep.index + 1);
-    if (step) {
-      step.setStepTabIndex(-1);
-    }
-    focusOutStep.setStepTabIndex(-1);
-  }
-  _onStepFocus() {
-    this._adapter.toggleRootClass(STEPPER_CONSTANTS.classes.FOCUSED, true);
-  }
-  _onStepBlur() {
-    this._adapter.toggleRootClass(STEPPER_CONSTANTS.classes.FOCUSED, false);
-  }
-  _patchBrowser() {
-    if (new Platform().SAFARI()) {
-      this._adapter.patchSafari();
-    }
-  }
-};
-
-// dist/build/lib/staging/src/stepper/stepper/stepper.ts
-var template = '<template><div class="forge-stepper" part="root"><slot></slot></div></template>';
-var styles = ".forge-stepper{display:-webkit-box;display:flex;-webkit-box-align:center;align-items:center;white-space:nowrap;overflow:hidden}.forge-stepper:not(.forge-stepper--vertical) ::slotted(*){display:-webkit-box;display:flex;-webkit-box-align:center;align-items:center;position:relative;min-width:112px}.forge-stepper--fixed ::slotted(*){-webkit-box-flex:1;flex:1}.forge-stepper--alternative{-webkit-box-align:start;align-items:flex-start}.forge-stepper--alternative ::slotted(*){min-width:160px}.forge-stepper--align-left{-webkit-box-pack:start;justify-content:flex-start}.forge-stepper--align-center{-webkit-box-pack:center;justify-content:center}.forge-stepper--align-right{-webkit-box-pack:end;justify-content:flex-end}:host{display:block}:host([hidden]){display:none}:host([vertical]) .forge-stepper{display:unset;-webkit-box-align:unset;align-items:unset;white-space:unset;overflow:unset}";
-var StepperComponent = class extends BaseComponent {
-  constructor() {
-    super();
-    attachShadowTemplate(this, template, styles);
-    this._foundation = new StepperFoundation(new StepperAdapter(this));
-  }
-  static get observedAttributes() {
-    return [
-      STEPPER_CONSTANTS.attributes.SELECTED_INDEX,
-      STEPPER_CONSTANTS.attributes.LINEAR,
-      STEPPER_CONSTANTS.attributes.ALTERNATIVE,
-      STEPPER_CONSTANTS.attributes.LAYOUT_MODE,
-      STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN,
-      STEPPER_CONSTANTS.attributes.DISABLED,
-      STEPPER_CONSTANTS.attributes.VERTICAL
-    ];
-  }
-  async connectedCallback() {
-    await ensureChildren(this);
-    this._foundation.initialize();
-  }
-  disconnectedCallback() {
-    this._foundation.disconnect();
-  }
-  attributeChangedCallback(name, oldValue, newValue) {
-    switch (name) {
-      case STEPPER_CONSTANTS.attributes.SELECTED_INDEX:
-        this.selectedIndex = Number(newValue) || 0;
-        break;
-      case STEPPER_CONSTANTS.attributes.LINEAR:
-        this.linear = coerceBoolean(newValue);
-        break;
-      case STEPPER_CONSTANTS.attributes.ALTERNATIVE:
-        this.alternative = coerceBoolean(newValue);
-        break;
-      case STEPPER_CONSTANTS.attributes.LAYOUT_MODE:
-        this.layoutMode = newValue;
-        break;
-      case STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN:
-        this.layoutAlign = newValue;
-        break;
-      case STEPPER_CONSTANTS.attributes.DISABLED:
-        this.disabled = coerceBoolean(newValue);
-        break;
-      case STEPPER_CONSTANTS.attributes.VERTICAL:
-        this.vertical = coerceBoolean(newValue);
-        break;
-    }
-  }
-};
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "steps", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "selectedIndex", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "linear", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "alternative", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "layoutMode", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "layoutAlign", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "disabled", 2);
-__decorateClass([
-  FoundationProperty()
-], StepperComponent.prototype, "vertical", 2);
-StepperComponent = __decorateClass([
-  CustomElement({
-    name: STEPPER_CONSTANTS.elementName,
-    dependencies: [StepComponent]
-  })
-], StepperComponent);
-
-// dist/build/lib/staging/src/stepper/stepper/index.ts
-function defineStepperComponent() {
-  defineCustomElement(StepperComponent);
-}
-
-export {
-  STEPPER_CONSTANTS,
-  StepperAdapter,
-  StepperFoundation,
-  StepperComponent,
-  defineStepperComponent
-};
-//# sourceMappingURL=chunk.CLEUHAZ6.js.map