@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.4HQ5VELO.js

@@ -0,0 +1,793 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  MDCComponent,
+  MDCFoundation,
+  __assign,
+  __extends,
+  __values
+} from "./chunk.5VKAVHLM.js";
+
+// node_modules/@material/ripple/constants.js
+var cssClasses = {
+  BG_FOCUSED: "mdc-ripple-upgraded--background-focused",
+  FG_ACTIVATION: "mdc-ripple-upgraded--foreground-activation",
+  FG_DEACTIVATION: "mdc-ripple-upgraded--foreground-deactivation",
+  ROOT: "mdc-ripple-upgraded",
+  UNBOUNDED: "mdc-ripple-upgraded--unbounded"
+};
+var strings = {
+  VAR_FG_SCALE: "--mdc-ripple-fg-scale",
+  VAR_FG_SIZE: "--mdc-ripple-fg-size",
+  VAR_FG_TRANSLATE_END: "--mdc-ripple-fg-translate-end",
+  VAR_FG_TRANSLATE_START: "--mdc-ripple-fg-translate-start",
+  VAR_LEFT: "--mdc-ripple-left",
+  VAR_TOP: "--mdc-ripple-top"
+};
+var numbers = {
+  DEACTIVATION_TIMEOUT_MS: 225,
+  FG_DEACTIVATION_MS: 150,
+  INITIAL_ORIGIN_SCALE: 0.6,
+  PADDING: 10,
+  TAP_DELAY_MS: 300
+};
+
+// node_modules/@material/ripple/util.js
+var supportsCssVariables_;
+function supportsCssVariables(windowObj, forceRefresh) {
+  if (forceRefresh === void 0) {
+    forceRefresh = false;
+  }
+  var CSS = windowObj.CSS;
+  var supportsCssVars = supportsCssVariables_;
+  if (typeof supportsCssVariables_ === "boolean" && !forceRefresh) {
+    return supportsCssVariables_;
+  }
+  var supportsFunctionPresent = CSS && typeof CSS.supports === "function";
+  if (!supportsFunctionPresent) {
+    return false;
+  }
+  var explicitlySupportsCssVars = CSS.supports("--css-vars", "yes");
+  var weAreFeatureDetectingSafari10plus = CSS.supports("(--css-vars: yes)") && CSS.supports("color", "#00000000");
+  supportsCssVars = explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;
+  if (!forceRefresh) {
+    supportsCssVariables_ = supportsCssVars;
+  }
+  return supportsCssVars;
+}
+function getNormalizedEventCoords(evt, pageOffset, clientRect) {
+  if (!evt) {
+    return { x: 0, y: 0 };
+  }
+  var x = pageOffset.x, y = pageOffset.y;
+  var documentX = x + clientRect.left;
+  var documentY = y + clientRect.top;
+  var normalizedX;
+  var normalizedY;
+  if (evt.type === "touchstart") {
+    var touchEvent = evt;
+    normalizedX = touchEvent.changedTouches[0].pageX - documentX;
+    normalizedY = touchEvent.changedTouches[0].pageY - documentY;
+  } else {
+    var mouseEvent = evt;
+    normalizedX = mouseEvent.pageX - documentX;
+    normalizedY = mouseEvent.pageY - documentY;
+  }
+  return { x: normalizedX, y: normalizedY };
+}
+
+// node_modules/@material/ripple/foundation.js
+var ACTIVATION_EVENT_TYPES = [
+  "touchstart",
+  "pointerdown",
+  "mousedown",
+  "keydown"
+];
+var POINTER_DEACTIVATION_EVENT_TYPES = [
+  "touchend",
+  "pointerup",
+  "mouseup",
+  "contextmenu"
+];
+var activatedTargets = [];
+var MDCRippleFoundation = function(_super) {
+  __extends(MDCRippleFoundation2, _super);
+  function MDCRippleFoundation2(adapter) {
+    var _this = _super.call(this, __assign(__assign({}, MDCRippleFoundation2.defaultAdapter), adapter)) || this;
+    _this.activationAnimationHasEnded = false;
+    _this.activationTimer = 0;
+    _this.fgDeactivationRemovalTimer = 0;
+    _this.fgScale = "0";
+    _this.frame = { width: 0, height: 0 };
+    _this.initialSize = 0;
+    _this.layoutFrame = 0;
+    _this.maxRadius = 0;
+    _this.unboundedCoords = { left: 0, top: 0 };
+    _this.activationState = _this.defaultActivationState();
+    _this.activationTimerCallback = function() {
+      _this.activationAnimationHasEnded = true;
+      _this.runDeactivationUXLogicIfReady();
+    };
+    _this.activateHandler = function(e) {
+      _this.activateImpl(e);
+    };
+    _this.deactivateHandler = function() {
+      _this.deactivateImpl();
+    };
+    _this.focusHandler = function() {
+      _this.handleFocus();
+    };
+    _this.blurHandler = function() {
+      _this.handleBlur();
+    };
+    _this.resizeHandler = function() {
+      _this.layout();
+    };
+    return _this;
+  }
+  Object.defineProperty(MDCRippleFoundation2, "cssClasses", {
+    get: function() {
+      return cssClasses;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(MDCRippleFoundation2, "strings", {
+    get: function() {
+      return strings;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(MDCRippleFoundation2, "numbers", {
+    get: function() {
+      return numbers;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(MDCRippleFoundation2, "defaultAdapter", {
+    get: function() {
+      return {
+        addClass: function() {
+          return void 0;
+        },
+        browserSupportsCssVars: function() {
+          return true;
+        },
+        computeBoundingRect: function() {
+          return { top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 };
+        },
+        containsEventTarget: function() {
+          return true;
+        },
+        deregisterDocumentInteractionHandler: function() {
+          return void 0;
+        },
+        deregisterInteractionHandler: function() {
+          return void 0;
+        },
+        deregisterResizeHandler: function() {
+          return void 0;
+        },
+        getWindowPageOffset: function() {
+          return { x: 0, y: 0 };
+        },
+        isSurfaceActive: function() {
+          return true;
+        },
+        isSurfaceDisabled: function() {
+          return true;
+        },
+        isUnbounded: function() {
+          return true;
+        },
+        registerDocumentInteractionHandler: function() {
+          return void 0;
+        },
+        registerInteractionHandler: function() {
+          return void 0;
+        },
+        registerResizeHandler: function() {
+          return void 0;
+        },
+        removeClass: function() {
+          return void 0;
+        },
+        updateCssVariable: function() {
+          return void 0;
+        }
+      };
+    },
+    enumerable: false,
+    configurable: true
+  });
+  MDCRippleFoundation2.prototype.init = function() {
+    var _this = this;
+    var supportsPressRipple = this.supportsPressRipple();
+    this.registerRootHandlers(supportsPressRipple);
+    if (supportsPressRipple) {
+      var _a = MDCRippleFoundation2.cssClasses, ROOT_1 = _a.ROOT, UNBOUNDED_1 = _a.UNBOUNDED;
+      requestAnimationFrame(function() {
+        _this.adapter.addClass(ROOT_1);
+        if (_this.adapter.isUnbounded()) {
+          _this.adapter.addClass(UNBOUNDED_1);
+          _this.layoutInternal();
+        }
+      });
+    }
+  };
+  MDCRippleFoundation2.prototype.destroy = function() {
+    var _this = this;
+    if (this.supportsPressRipple()) {
+      if (this.activationTimer) {
+        clearTimeout(this.activationTimer);
+        this.activationTimer = 0;
+        this.adapter.removeClass(MDCRippleFoundation2.cssClasses.FG_ACTIVATION);
+      }
+      if (this.fgDeactivationRemovalTimer) {
+        clearTimeout(this.fgDeactivationRemovalTimer);
+        this.fgDeactivationRemovalTimer = 0;
+        this.adapter.removeClass(MDCRippleFoundation2.cssClasses.FG_DEACTIVATION);
+      }
+      var _a = MDCRippleFoundation2.cssClasses, ROOT_2 = _a.ROOT, UNBOUNDED_2 = _a.UNBOUNDED;
+      requestAnimationFrame(function() {
+        _this.adapter.removeClass(ROOT_2);
+        _this.adapter.removeClass(UNBOUNDED_2);
+        _this.removeCssVars();
+      });
+    }
+    this.deregisterRootHandlers();
+    this.deregisterDeactivationHandlers();
+  };
+  MDCRippleFoundation2.prototype.activate = function(evt) {
+    this.activateImpl(evt);
+  };
+  MDCRippleFoundation2.prototype.deactivate = function() {
+    this.deactivateImpl();
+  };
+  MDCRippleFoundation2.prototype.layout = function() {
+    var _this = this;
+    if (this.layoutFrame) {
+      cancelAnimationFrame(this.layoutFrame);
+    }
+    this.layoutFrame = requestAnimationFrame(function() {
+      _this.layoutInternal();
+      _this.layoutFrame = 0;
+    });
+  };
+  MDCRippleFoundation2.prototype.setUnbounded = function(unbounded) {
+    var UNBOUNDED = MDCRippleFoundation2.cssClasses.UNBOUNDED;
+    if (unbounded) {
+      this.adapter.addClass(UNBOUNDED);
+    } else {
+      this.adapter.removeClass(UNBOUNDED);
+    }
+  };
+  MDCRippleFoundation2.prototype.handleFocus = function() {
+    var _this = this;
+    requestAnimationFrame(function() {
+      return _this.adapter.addClass(MDCRippleFoundation2.cssClasses.BG_FOCUSED);
+    });
+  };
+  MDCRippleFoundation2.prototype.handleBlur = function() {
+    var _this = this;
+    requestAnimationFrame(function() {
+      return _this.adapter.removeClass(MDCRippleFoundation2.cssClasses.BG_FOCUSED);
+    });
+  };
+  MDCRippleFoundation2.prototype.supportsPressRipple = function() {
+    return this.adapter.browserSupportsCssVars();
+  };
+  MDCRippleFoundation2.prototype.defaultActivationState = function() {
+    return {
+      activationEvent: void 0,
+      hasDeactivationUXRun: false,
+      isActivated: false,
+      isProgrammatic: false,
+      wasActivatedByPointer: false,
+      wasElementMadeActive: false
+    };
+  };
+  MDCRippleFoundation2.prototype.registerRootHandlers = function(supportsPressRipple) {
+    var e_1, _a;
+    if (supportsPressRipple) {
+      try {
+        for (var ACTIVATION_EVENT_TYPES_1 = __values(ACTIVATION_EVENT_TYPES), ACTIVATION_EVENT_TYPES_1_1 = ACTIVATION_EVENT_TYPES_1.next(); !ACTIVATION_EVENT_TYPES_1_1.done; ACTIVATION_EVENT_TYPES_1_1 = ACTIVATION_EVENT_TYPES_1.next()) {
+          var evtType = ACTIVATION_EVENT_TYPES_1_1.value;
+          this.adapter.registerInteractionHandler(evtType, this.activateHandler);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (ACTIVATION_EVENT_TYPES_1_1 && !ACTIVATION_EVENT_TYPES_1_1.done && (_a = ACTIVATION_EVENT_TYPES_1.return))
+            _a.call(ACTIVATION_EVENT_TYPES_1);
+        } finally {
+          if (e_1)
+            throw e_1.error;
+        }
+      }
+      if (this.adapter.isUnbounded()) {
+        this.adapter.registerResizeHandler(this.resizeHandler);
+      }
+    }
+    this.adapter.registerInteractionHandler("focus", this.focusHandler);
+    this.adapter.registerInteractionHandler("blur", this.blurHandler);
+  };
+  MDCRippleFoundation2.prototype.registerDeactivationHandlers = function(evt) {
+    var e_2, _a;
+    if (evt.type === "keydown") {
+      this.adapter.registerInteractionHandler("keyup", this.deactivateHandler);
+    } else {
+      try {
+        for (var POINTER_DEACTIVATION_EVENT_TYPES_1 = __values(POINTER_DEACTIVATION_EVENT_TYPES), POINTER_DEACTIVATION_EVENT_TYPES_1_1 = POINTER_DEACTIVATION_EVENT_TYPES_1.next(); !POINTER_DEACTIVATION_EVENT_TYPES_1_1.done; POINTER_DEACTIVATION_EVENT_TYPES_1_1 = POINTER_DEACTIVATION_EVENT_TYPES_1.next()) {
+          var evtType = POINTER_DEACTIVATION_EVENT_TYPES_1_1.value;
+          this.adapter.registerDocumentInteractionHandler(evtType, this.deactivateHandler);
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (POINTER_DEACTIVATION_EVENT_TYPES_1_1 && !POINTER_DEACTIVATION_EVENT_TYPES_1_1.done && (_a = POINTER_DEACTIVATION_EVENT_TYPES_1.return))
+            _a.call(POINTER_DEACTIVATION_EVENT_TYPES_1);
+        } finally {
+          if (e_2)
+            throw e_2.error;
+        }
+      }
+    }
+  };
+  MDCRippleFoundation2.prototype.deregisterRootHandlers = function() {
+    var e_3, _a;
+    try {
+      for (var ACTIVATION_EVENT_TYPES_2 = __values(ACTIVATION_EVENT_TYPES), ACTIVATION_EVENT_TYPES_2_1 = ACTIVATION_EVENT_TYPES_2.next(); !ACTIVATION_EVENT_TYPES_2_1.done; ACTIVATION_EVENT_TYPES_2_1 = ACTIVATION_EVENT_TYPES_2.next()) {
+        var evtType = ACTIVATION_EVENT_TYPES_2_1.value;
+        this.adapter.deregisterInteractionHandler(evtType, this.activateHandler);
+      }
+    } catch (e_3_1) {
+      e_3 = { error: e_3_1 };
+    } finally {
+      try {
+        if (ACTIVATION_EVENT_TYPES_2_1 && !ACTIVATION_EVENT_TYPES_2_1.done && (_a = ACTIVATION_EVENT_TYPES_2.return))
+          _a.call(ACTIVATION_EVENT_TYPES_2);
+      } finally {
+        if (e_3)
+          throw e_3.error;
+      }
+    }
+    this.adapter.deregisterInteractionHandler("focus", this.focusHandler);
+    this.adapter.deregisterInteractionHandler("blur", this.blurHandler);
+    if (this.adapter.isUnbounded()) {
+      this.adapter.deregisterResizeHandler(this.resizeHandler);
+    }
+  };
+  MDCRippleFoundation2.prototype.deregisterDeactivationHandlers = function() {
+    var e_4, _a;
+    this.adapter.deregisterInteractionHandler("keyup", this.deactivateHandler);
+    try {
+      for (var POINTER_DEACTIVATION_EVENT_TYPES_2 = __values(POINTER_DEACTIVATION_EVENT_TYPES), POINTER_DEACTIVATION_EVENT_TYPES_2_1 = POINTER_DEACTIVATION_EVENT_TYPES_2.next(); !POINTER_DEACTIVATION_EVENT_TYPES_2_1.done; POINTER_DEACTIVATION_EVENT_TYPES_2_1 = POINTER_DEACTIVATION_EVENT_TYPES_2.next()) {
+        var evtType = POINTER_DEACTIVATION_EVENT_TYPES_2_1.value;
+        this.adapter.deregisterDocumentInteractionHandler(evtType, this.deactivateHandler);
+      }
+    } catch (e_4_1) {
+      e_4 = { error: e_4_1 };
+    } finally {
+      try {
+        if (POINTER_DEACTIVATION_EVENT_TYPES_2_1 && !POINTER_DEACTIVATION_EVENT_TYPES_2_1.done && (_a = POINTER_DEACTIVATION_EVENT_TYPES_2.return))
+          _a.call(POINTER_DEACTIVATION_EVENT_TYPES_2);
+      } finally {
+        if (e_4)
+          throw e_4.error;
+      }
+    }
+  };
+  MDCRippleFoundation2.prototype.removeCssVars = function() {
+    var _this = this;
+    var rippleStrings = MDCRippleFoundation2.strings;
+    var keys = Object.keys(rippleStrings);
+    keys.forEach(function(key) {
+      if (key.indexOf("VAR_") === 0) {
+        _this.adapter.updateCssVariable(rippleStrings[key], null);
+      }
+    });
+  };
+  MDCRippleFoundation2.prototype.activateImpl = function(evt) {
+    var _this = this;
+    if (this.adapter.isSurfaceDisabled()) {
+      return;
+    }
+    var activationState = this.activationState;
+    if (activationState.isActivated) {
+      return;
+    }
+    var previousActivationEvent = this.previousActivationEvent;
+    var isSameInteraction = previousActivationEvent && evt !== void 0 && previousActivationEvent.type !== evt.type;
+    if (isSameInteraction) {
+      return;
+    }
+    activationState.isActivated = true;
+    activationState.isProgrammatic = evt === void 0;
+    activationState.activationEvent = evt;
+    activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== void 0 && (evt.type === "mousedown" || evt.type === "touchstart" || evt.type === "pointerdown");
+    var hasActivatedChild = evt !== void 0 && activatedTargets.length > 0 && activatedTargets.some(function(target) {
+      return _this.adapter.containsEventTarget(target);
+    });
+    if (hasActivatedChild) {
+      this.resetActivationState();
+      return;
+    }
+    if (evt !== void 0) {
+      activatedTargets.push(evt.target);
+      this.registerDeactivationHandlers(evt);
+    }
+    activationState.wasElementMadeActive = this.checkElementMadeActive(evt);
+    if (activationState.wasElementMadeActive) {
+      this.animateActivation();
+    }
+    requestAnimationFrame(function() {
+      activatedTargets = [];
+      if (!activationState.wasElementMadeActive && evt !== void 0 && (evt.key === " " || evt.keyCode === 32)) {
+        activationState.wasElementMadeActive = _this.checkElementMadeActive(evt);
+        if (activationState.wasElementMadeActive) {
+          _this.animateActivation();
+        }
+      }
+      if (!activationState.wasElementMadeActive) {
+        _this.activationState = _this.defaultActivationState();
+      }
+    });
+  };
+  MDCRippleFoundation2.prototype.checkElementMadeActive = function(evt) {
+    return evt !== void 0 && evt.type === "keydown" ? this.adapter.isSurfaceActive() : true;
+  };
+  MDCRippleFoundation2.prototype.animateActivation = function() {
+    var _this = this;
+    var _a = MDCRippleFoundation2.strings, VAR_FG_TRANSLATE_START = _a.VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END = _a.VAR_FG_TRANSLATE_END;
+    var _b = MDCRippleFoundation2.cssClasses, FG_DEACTIVATION = _b.FG_DEACTIVATION, FG_ACTIVATION = _b.FG_ACTIVATION;
+    var DEACTIVATION_TIMEOUT_MS = MDCRippleFoundation2.numbers.DEACTIVATION_TIMEOUT_MS;
+    this.layoutInternal();
+    var translateStart = "";
+    var translateEnd = "";
+    if (!this.adapter.isUnbounded()) {
+      var _c = this.getFgTranslationCoordinates(), startPoint = _c.startPoint, endPoint = _c.endPoint;
+      translateStart = startPoint.x + "px, " + startPoint.y + "px";
+      translateEnd = endPoint.x + "px, " + endPoint.y + "px";
+    }
+    this.adapter.updateCssVariable(VAR_FG_TRANSLATE_START, translateStart);
+    this.adapter.updateCssVariable(VAR_FG_TRANSLATE_END, translateEnd);
+    clearTimeout(this.activationTimer);
+    clearTimeout(this.fgDeactivationRemovalTimer);
+    this.rmBoundedActivationClasses();
+    this.adapter.removeClass(FG_DEACTIVATION);
+    this.adapter.computeBoundingRect();
+    this.adapter.addClass(FG_ACTIVATION);
+    this.activationTimer = setTimeout(function() {
+      _this.activationTimerCallback();
+    }, DEACTIVATION_TIMEOUT_MS);
+  };
+  MDCRippleFoundation2.prototype.getFgTranslationCoordinates = function() {
+    var _a = this.activationState, activationEvent = _a.activationEvent, wasActivatedByPointer = _a.wasActivatedByPointer;
+    var startPoint;
+    if (wasActivatedByPointer) {
+      startPoint = getNormalizedEventCoords(activationEvent, this.adapter.getWindowPageOffset(), this.adapter.computeBoundingRect());
+    } else {
+      startPoint = {
+        x: this.frame.width / 2,
+        y: this.frame.height / 2
+      };
+    }
+    startPoint = {
+      x: startPoint.x - this.initialSize / 2,
+      y: startPoint.y - this.initialSize / 2
+    };
+    var endPoint = {
+      x: this.frame.width / 2 - this.initialSize / 2,
+      y: this.frame.height / 2 - this.initialSize / 2
+    };
+    return { startPoint, endPoint };
+  };
+  MDCRippleFoundation2.prototype.runDeactivationUXLogicIfReady = function() {
+    var _this = this;
+    var FG_DEACTIVATION = MDCRippleFoundation2.cssClasses.FG_DEACTIVATION;
+    var _a = this.activationState, hasDeactivationUXRun = _a.hasDeactivationUXRun, isActivated = _a.isActivated;
+    var activationHasEnded = hasDeactivationUXRun || !isActivated;
+    if (activationHasEnded && this.activationAnimationHasEnded) {
+      this.rmBoundedActivationClasses();
+      this.adapter.addClass(FG_DEACTIVATION);
+      this.fgDeactivationRemovalTimer = setTimeout(function() {
+        _this.adapter.removeClass(FG_DEACTIVATION);
+      }, numbers.FG_DEACTIVATION_MS);
+    }
+  };
+  MDCRippleFoundation2.prototype.rmBoundedActivationClasses = function() {
+    var FG_ACTIVATION = MDCRippleFoundation2.cssClasses.FG_ACTIVATION;
+    this.adapter.removeClass(FG_ACTIVATION);
+    this.activationAnimationHasEnded = false;
+    this.adapter.computeBoundingRect();
+  };
+  MDCRippleFoundation2.prototype.resetActivationState = function() {
+    var _this = this;
+    this.previousActivationEvent = this.activationState.activationEvent;
+    this.activationState = this.defaultActivationState();
+    setTimeout(function() {
+      return _this.previousActivationEvent = void 0;
+    }, MDCRippleFoundation2.numbers.TAP_DELAY_MS);
+  };
+  MDCRippleFoundation2.prototype.deactivateImpl = function() {
+    var _this = this;
+    var activationState = this.activationState;
+    if (!activationState.isActivated) {
+      return;
+    }
+    var state = __assign({}, activationState);
+    if (activationState.isProgrammatic) {
+      requestAnimationFrame(function() {
+        _this.animateDeactivation(state);
+      });
+      this.resetActivationState();
+    } else {
+      this.deregisterDeactivationHandlers();
+      requestAnimationFrame(function() {
+        _this.activationState.hasDeactivationUXRun = true;
+        _this.animateDeactivation(state);
+        _this.resetActivationState();
+      });
+    }
+  };
+  MDCRippleFoundation2.prototype.animateDeactivation = function(_a) {
+    var wasActivatedByPointer = _a.wasActivatedByPointer, wasElementMadeActive = _a.wasElementMadeActive;
+    if (wasActivatedByPointer || wasElementMadeActive) {
+      this.runDeactivationUXLogicIfReady();
+    }
+  };
+  MDCRippleFoundation2.prototype.layoutInternal = function() {
+    var _this = this;
+    this.frame = this.adapter.computeBoundingRect();
+    var maxDim = Math.max(this.frame.height, this.frame.width);
+    var getBoundedRadius = function() {
+      var hypotenuse = Math.sqrt(Math.pow(_this.frame.width, 2) + Math.pow(_this.frame.height, 2));
+      return hypotenuse + MDCRippleFoundation2.numbers.PADDING;
+    };
+    this.maxRadius = this.adapter.isUnbounded() ? maxDim : getBoundedRadius();
+    var initialSize = Math.floor(maxDim * MDCRippleFoundation2.numbers.INITIAL_ORIGIN_SCALE);
+    if (this.adapter.isUnbounded() && initialSize % 2 !== 0) {
+      this.initialSize = initialSize - 1;
+    } else {
+      this.initialSize = initialSize;
+    }
+    this.fgScale = "" + this.maxRadius / this.initialSize;
+    this.updateLayoutCssVars();
+  };
+  MDCRippleFoundation2.prototype.updateLayoutCssVars = function() {
+    var _a = MDCRippleFoundation2.strings, VAR_FG_SIZE = _a.VAR_FG_SIZE, VAR_LEFT = _a.VAR_LEFT, VAR_TOP = _a.VAR_TOP, VAR_FG_SCALE = _a.VAR_FG_SCALE;
+    this.adapter.updateCssVariable(VAR_FG_SIZE, this.initialSize + "px");
+    this.adapter.updateCssVariable(VAR_FG_SCALE, this.fgScale);
+    if (this.adapter.isUnbounded()) {
+      this.unboundedCoords = {
+        left: Math.round(this.frame.width / 2 - this.initialSize / 2),
+        top: Math.round(this.frame.height / 2 - this.initialSize / 2)
+      };
+      this.adapter.updateCssVariable(VAR_LEFT, this.unboundedCoords.left + "px");
+      this.adapter.updateCssVariable(VAR_TOP, this.unboundedCoords.top + "px");
+    }
+  };
+  return MDCRippleFoundation2;
+}(MDCFoundation);
+
+// node_modules/@material/dom/events.js
+function applyPassive(globalObj) {
+  if (globalObj === void 0) {
+    globalObj = window;
+  }
+  return supportsPassiveOption(globalObj) ? { passive: true } : false;
+}
+function supportsPassiveOption(globalObj) {
+  if (globalObj === void 0) {
+    globalObj = window;
+  }
+  var passiveSupported = false;
+  try {
+    var options = {
+      get passive() {
+        passiveSupported = true;
+        return false;
+      }
+    };
+    var handler = function() {
+    };
+    globalObj.document.addEventListener("test", handler, options);
+    globalObj.document.removeEventListener("test", handler, options);
+  } catch (err) {
+    passiveSupported = false;
+  }
+  return passiveSupported;
+}
+
+// node_modules/@material/dom/ponyfill.js
+function matches(element, selector) {
+  var nativeMatches = element.matches || element.webkitMatchesSelector || element.msMatchesSelector;
+  return nativeMatches.call(element, selector);
+}
+
+// node_modules/@material/ripple/component.js
+var MDCRipple = function(_super) {
+  __extends(MDCRipple2, _super);
+  function MDCRipple2() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.disabled = false;
+    return _this;
+  }
+  MDCRipple2.attachTo = function(root, opts) {
+    if (opts === void 0) {
+      opts = {
+        isUnbounded: void 0
+      };
+    }
+    var ripple = new MDCRipple2(root);
+    if (opts.isUnbounded !== void 0) {
+      ripple.unbounded = opts.isUnbounded;
+    }
+    return ripple;
+  };
+  MDCRipple2.createAdapter = function(instance) {
+    return {
+      addClass: function(className) {
+        return instance.root.classList.add(className);
+      },
+      browserSupportsCssVars: function() {
+        return supportsCssVariables(window);
+      },
+      computeBoundingRect: function() {
+        return instance.root.getBoundingClientRect();
+      },
+      containsEventTarget: function(target) {
+        return instance.root.contains(target);
+      },
+      deregisterDocumentInteractionHandler: function(evtType, handler) {
+        return document.documentElement.removeEventListener(evtType, handler, applyPassive());
+      },
+      deregisterInteractionHandler: function(evtType, handler) {
+        return instance.root.removeEventListener(evtType, handler, applyPassive());
+      },
+      deregisterResizeHandler: function(handler) {
+        return window.removeEventListener("resize", handler);
+      },
+      getWindowPageOffset: function() {
+        return { x: window.pageXOffset, y: window.pageYOffset };
+      },
+      isSurfaceActive: function() {
+        return matches(instance.root, ":active");
+      },
+      isSurfaceDisabled: function() {
+        return Boolean(instance.disabled);
+      },
+      isUnbounded: function() {
+        return Boolean(instance.unbounded);
+      },
+      registerDocumentInteractionHandler: function(evtType, handler) {
+        return document.documentElement.addEventListener(evtType, handler, applyPassive());
+      },
+      registerInteractionHandler: function(evtType, handler) {
+        return instance.root.addEventListener(evtType, handler, applyPassive());
+      },
+      registerResizeHandler: function(handler) {
+        return window.addEventListener("resize", handler);
+      },
+      removeClass: function(className) {
+        return instance.root.classList.remove(className);
+      },
+      updateCssVariable: function(varName, value) {
+        return instance.root.style.setProperty(varName, value);
+      }
+    };
+  };
+  Object.defineProperty(MDCRipple2.prototype, "unbounded", {
+    get: function() {
+      return Boolean(this.isUnbounded);
+    },
+    set: function(unbounded) {
+      this.isUnbounded = Boolean(unbounded);
+      this.setUnbounded();
+    },
+    enumerable: false,
+    configurable: true
+  });
+  MDCRipple2.prototype.activate = function() {
+    this.foundation.activate();
+  };
+  MDCRipple2.prototype.deactivate = function() {
+    this.foundation.deactivate();
+  };
+  MDCRipple2.prototype.layout = function() {
+    this.foundation.layout();
+  };
+  MDCRipple2.prototype.getDefaultFoundation = function() {
+    return new MDCRippleFoundation(MDCRipple2.createAdapter(this));
+  };
+  MDCRipple2.prototype.initialSyncWithDOM = function() {
+    var root = this.root;
+    this.isUnbounded = "mdcRippleIsUnbounded" in root.dataset;
+  };
+  MDCRipple2.prototype.setUnbounded = function() {
+    this.foundation.setUnbounded(Boolean(this.isUnbounded));
+  };
+  return MDCRipple2;
+}(MDCComponent);
+
+export {
+  applyPassive,
+  matches,
+  MDCRippleFoundation,
+  MDCRipple
+};
+/**
+ * @license
+ * Copyright 2016 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+//# sourceMappingURL=chunk.4HQ5VELO.js.map