@creopse/react 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,4 +1,4 @@
-var CreopseReactToolkit = function(exports, React2) {
+var CreopseReactToolkit = function(exports, React2, reactDom) {
   "use strict";
   function _interopNamespaceDefault(e) {
     const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -241,15 +241,15 @@ var CreopseReactToolkit = function(exports, React2) {
           else validateChildKeys(children);
         if (hasOwnProperty.call(config, "key")) {
           children = getComponentNameFromType(type);
-          var keys = Object.keys(config).filter(function(k) {
+          var keys2 = Object.keys(config).filter(function(k) {
             return "key" !== k;
           });
-          isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
-          didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          isStaticChildren = 0 < keys2.length ? "{key: someKey, " + keys2.join(": ..., ") + ": ...}" : "{key: someKey}";
+          didWarnAboutKeySpread[children + isStaticChildren] || (keys2 = 0 < keys2.length ? "{" + keys2.join(": ..., ") + ": ...}" : "{}", console.error(
             'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
             isStaticChildren,
             children,
-            keys,
+            keys2,
             children
           ), didWarnAboutKeySpread[children + isStaticChildren] = true);
         }
@@ -392,11 +392,11 @@ var CreopseReactToolkit = function(exports, React2) {
     if (index > -1)
       arr.splice(index, 1);
   }
-  const clamp = (min, max, v) => {
-    if (v > max)
-      return max;
-    if (v < min)
-      return min;
+  const clamp = (min2, max2, v) => {
+    if (v > max2)
+      return max2;
+    if (v < min2)
+      return min2;
     return v;
   };
   function formatErrorMessage(message, errorCode) {
@@ -420,7 +420,7 @@ var CreopseReactToolkit = function(exports, React2) {
   }
   const MotionGlobalConfig = {};
   const isNumericalString = (v) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(v);
-  function isObject(value) {
+  function isObject$1(value) {
     return typeof value === "object" && value !== null;
   }
   const isZeroValueString = (v) => /^0[^.\s]+$/u.test(v);
@@ -436,9 +436,9 @@ var CreopseReactToolkit = function(exports, React2) {
   const noop = /* @__NO_SIDE_EFFECTS__ */ (any) => any;
   const combineFunctions = (a, b) => (v) => b(a(v));
   const pipe = (...transformers) => transformers.reduce(combineFunctions);
-  const progress = /* @__NO_SIDE_EFFECTS__ */ (from, to, value) => {
-    const toFromDifference = to - from;
-    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;
+  const progress = /* @__NO_SIDE_EFFECTS__ */ (from2, to2, value) => {
+    const toFromDifference = to2 - from2;
+    return toFromDifference === 0 ? 1 : (value - from2) / toFromDifference;
   };
   class SubscriptionManager {
     constructor() {
@@ -468,8 +468,8 @@ var CreopseReactToolkit = function(exports, React2) {
       this.subscriptions.length = 0;
     }
   }
-  const secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (seconds) => seconds * 1e3;
-  const millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (milliseconds) => milliseconds / 1e3;
+  const secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (seconds2) => seconds2 * 1e3;
+  const millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (milliseconds2) => milliseconds2 / 1e3;
   function velocityPerSecond(velocity, frameDuration) {
     return frameDuration ? velocity * (1e3 / frameDuration) : 0;
   }
@@ -686,23 +686,23 @@ var CreopseReactToolkit = function(exports, React2) {
     return { schedule, cancel, state, steps };
   }
   const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
-  let now;
+  let now$1;
   function clearTime() {
-    now = void 0;
+    now$1 = void 0;
   }
   const time = {
     now: () => {
-      if (now === void 0) {
+      if (now$1 === void 0) {
         time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
       }
-      return now;
+      return now$1;
     },
     set: (newTime) => {
-      now = newTime;
+      now$1 = newTime;
       queueMicrotask(clearTime);
     }
   };
-  const checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
+  const checkStringStartsWith = (token2) => (key) => typeof key === "string" && key.startsWith(token2);
   const isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--");
   const startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--");
   const isCSSVariableToken = (value) => {
@@ -944,12 +944,12 @@ var CreopseReactToolkit = function(exports, React2) {
   function mixImmediate(a, b) {
     return (p) => p > 0 ? b : a;
   }
-  const mixNumber$1 = (from, to, progress2) => {
-    return from + (to - from) * progress2;
+  const mixNumber$1 = (from2, to2, progress2) => {
+    return from2 + (to2 - from2) * progress2;
   };
-  const mixLinearColor = (from, to, v) => {
-    const fromExpo = from * from;
-    const expo = v * (to * to - fromExpo) + fromExpo;
+  const mixLinearColor = (from2, to2, v) => {
+    const fromExpo = from2 * from2;
+    const expo = v * (to2 * to2 - fromExpo) + fromExpo;
     return expo < 0 ? 0 : Math.sqrt(expo);
   };
   const colorTypes = [hex, rgba, hsla];
@@ -965,11 +965,11 @@ var CreopseReactToolkit = function(exports, React2) {
     }
     return model;
   }
-  const mixColor = (from, to) => {
-    const fromRGBA = asRGBA(from);
-    const toRGBA = asRGBA(to);
+  const mixColor = (from2, to2) => {
+    const fromRGBA = asRGBA(from2);
+    const toRGBA = asRGBA(to2);
     if (!fromRGBA || !toRGBA) {
-      return mixImmediate(from, to);
+      return mixImmediate(from2, to2);
     }
     const blended = { ...fromRGBA };
     return (v) => {
@@ -1056,12 +1056,12 @@ var CreopseReactToolkit = function(exports, React2) {
       return mixImmediate(origin, target);
     }
   };
-  function mix(from, to, p) {
-    if (typeof from === "number" && typeof to === "number" && typeof p === "number") {
-      return mixNumber$1(from, to, p);
+  function mix(from2, to2, p) {
+    if (typeof from2 === "number" && typeof to2 === "number" && typeof p === "number") {
+      return mixNumber$1(from2, to2, p);
     }
-    const mixer = getMixer(from);
-    return mixer(from, to);
+    const mixer = getMixer(from2);
+    return mixer(from2, to2);
   }
   const frameloopDriver = (update) => {
     const passTimestamp = ({ timestamp }) => update(timestamp);
@@ -1209,8 +1209,8 @@ var CreopseReactToolkit = function(exports, React2) {
   }
   const durationKeys = ["duration", "bounce"];
   const physicsKeys = ["stiffness", "damping", "mass"];
-  function isSpringType(options, keys) {
-    return keys.some((key) => options[key] !== void 0);
+  function isSpringType(options, keys2) {
+    return keys2.some((key) => options[key] !== void 0);
   }
   function getSpringOptions(options) {
     let springOptions = {
@@ -1318,19 +1318,19 @@ var CreopseReactToolkit = function(exports, React2) {
     options.type = "keyframes";
     return options;
   };
-  function inertia({ keyframes: keyframes2, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed }) {
+  function inertia({ keyframes: keyframes2, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min: min2, max: max2, restDelta = 0.5, restSpeed }) {
     const origin = keyframes2[0];
     const state = {
       done: false,
       value: origin
     };
-    const isOutOfBounds = (v) => min !== void 0 && v < min || max !== void 0 && v > max;
+    const isOutOfBounds = (v) => min2 !== void 0 && v < min2 || max2 !== void 0 && v > max2;
     const nearestBoundary = (v) => {
-      if (min === void 0)
-        return max;
-      if (max === void 0)
-        return min;
-      return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+      if (min2 === void 0)
+        return max2;
+      if (max2 === void 0)
+        return min2;
+      return Math.abs(min2 - v) < Math.abs(max2 - v) ? min2 : max2;
     };
     let amplitude = power * velocity;
     const ideal = origin + amplitude;
@@ -1423,20 +1423,20 @@ var CreopseReactToolkit = function(exports, React2) {
     };
     return isClamp ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v)) : interpolator;
   }
-  function fillOffset(offset, remaining) {
-    const min = offset[offset.length - 1];
+  function fillOffset(offset2, remaining) {
+    const min2 = offset2[offset2.length - 1];
     for (let i = 1; i <= remaining; i++) {
       const offsetProgress = /* @__PURE__ */ progress(0, remaining, i);
-      offset.push(mixNumber$1(min, 1, offsetProgress));
+      offset2.push(mixNumber$1(min2, 1, offsetProgress));
     }
   }
   function defaultOffset(arr) {
-    const offset = [0];
-    fillOffset(offset, arr.length - 1);
-    return offset;
+    const offset2 = [0];
+    fillOffset(offset2, arr.length - 1);
+    return offset2;
   }
-  function convertOffsetToTimes(offset, duration) {
-    return offset.map((o) => o * duration);
+  function convertOffsetToTimes(offset2, duration) {
+    return offset2.map((o) => o * duration);
   }
   function defaultEasing(values, easing) {
     return values.map(() => easing || easeInOut).splice(0, values.length - 1);
@@ -2458,10 +2458,10 @@ var CreopseReactToolkit = function(exports, React2) {
   const maxDepth = 4;
   function getVariableValue(current, element, depth = 1) {
     invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
-    const [token, fallback] = parseCSSVariable(current);
-    if (!token)
+    const [token2, fallback] = parseCSSVariable(current);
+    if (!token2)
       return;
-    const resolved = window.getComputedStyle(element).getPropertyValue(token);
+    const resolved = window.getComputedStyle(element).getPropertyValue(token2);
     if (resolved) {
       const trimmed = resolved.trim();
       return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
@@ -2736,7 +2736,7 @@ var CreopseReactToolkit = function(exports, React2) {
     return type && typeof value === "number" ? type.transform(value) : value;
   };
   function isHTMLElement(element) {
-    return isObject(element) && "offsetHeight" in element;
+    return isObject$1(element) && "offsetHeight" in element;
   }
   const MAX_VELOCITY_DELTA = 30;
   const isFloat = (value) => {
@@ -3181,7 +3181,7 @@ var CreopseReactToolkit = function(exports, React2) {
     return cancelEvents;
   }
   function isSVGElement(element) {
-    return isObject(element) && "ownerSVGElement" in element;
+    return isObject$1(element) && "ownerSVGElement" in element;
   }
   function isSVGSVGElement(element) {
     return isSVGElement(element) && element.tagName === "svg";
@@ -3661,13 +3661,13 @@ var CreopseReactToolkit = function(exports, React2) {
     offset: "strokeDashoffset",
     array: "strokeDasharray"
   };
-  function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
+  function buildSVGPath(attrs, length, spacing = 1, offset2 = 0, useDashCase = true) {
     attrs.pathLength = 1;
-    const keys = useDashCase ? dashKeys : camelKeys;
-    attrs[keys.offset] = px.transform(-offset);
+    const keys2 = useDashCase ? dashKeys : camelKeys;
+    attrs[keys2.offset] = px.transform(-offset2);
     const pathLength = px.transform(length);
     const pathSpacing = px.transform(spacing);
-    attrs[keys.array] = `${pathLength} ${pathSpacing}`;
+    attrs[keys2.array] = `${pathLength} ${pathSpacing}`;
   }
   function buildSVGAttrs(state, {
     attrX,
@@ -4841,7 +4841,7 @@ var CreopseReactToolkit = function(exports, React2) {
     }
     return ease;
   };
-  function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {
+  function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from: from2, elapsed, ...transition }) {
     return !!Object.keys(transition).length;
   }
   const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
@@ -5504,18 +5504,18 @@ var CreopseReactToolkit = function(exports, React2) {
     }
     return currentVelocity;
   }
-  function applyConstraints(point, { min, max }, elastic) {
-    if (min !== void 0 && point < min) {
-      point = elastic ? mixNumber$1(min, point, elastic.min) : Math.max(point, min);
-    } else if (max !== void 0 && point > max) {
-      point = elastic ? mixNumber$1(max, point, elastic.max) : Math.min(point, max);
+  function applyConstraints(point, { min: min2, max: max2 }, elastic) {
+    if (min2 !== void 0 && point < min2) {
+      point = elastic ? mixNumber$1(min2, point, elastic.min) : Math.max(point, min2);
+    } else if (max2 !== void 0 && point > max2) {
+      point = elastic ? mixNumber$1(max2, point, elastic.max) : Math.min(point, max2);
     }
     return point;
   }
-  function calcRelativeAxisConstraints(axis, min, max) {
+  function calcRelativeAxisConstraints(axis, min2, max2) {
     return {
-      min: min !== void 0 ? axis.min + min : void 0,
-      max: max !== void 0 ? axis.max + max - (axis.max - axis.min) : void 0
+      min: min2 !== void 0 ? axis.min + min2 : void 0,
+      max: max2 !== void 0 ? axis.max + max2 - (axis.max - axis.min) : void 0
     };
   }
   function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
@@ -5525,12 +5525,12 @@ var CreopseReactToolkit = function(exports, React2) {
     };
   }
   function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
-    let min = constraintsAxis.min - layoutAxis.min;
-    let max = constraintsAxis.max - layoutAxis.max;
+    let min2 = constraintsAxis.min - layoutAxis.min;
+    let max2 = constraintsAxis.max - layoutAxis.max;
     if (constraintsAxis.max - constraintsAxis.min < layoutAxis.max - layoutAxis.min) {
-      [min, max] = [max, min];
+      [min2, max2] = [max2, min2];
     }
-    return { min, max };
+    return { min: min2, max: max2 };
   }
   function calcViewportConstraints(layoutBox, constraintsBox) {
     return {
@@ -5650,16 +5650,16 @@ var CreopseReactToolkit = function(exports, React2) {
         const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag } = this.getProps();
         if (!dragPropagation && !this.openDragLock)
           return;
-        const { offset } = info;
+        const { offset: offset2 } = info;
         if (dragDirectionLock && this.currentDirection === null) {
-          this.currentDirection = getCurrentDirection(offset);
+          this.currentDirection = getCurrentDirection(offset2);
           if (this.currentDirection !== null) {
             onDirectionLock && onDirectionLock(this.currentDirection);
           }
           return;
         }
-        this.updateAxis("x", info.point, offset);
-        this.updateAxis("y", info.point, offset);
+        this.updateAxis("x", info.point, offset2);
+        this.updateAxis("y", info.point, offset2);
         this.visualElement.render();
         onDrag && onDrag(event, info);
       };
@@ -5720,12 +5720,12 @@ var CreopseReactToolkit = function(exports, React2) {
       }
       animationState && animationState.setActive("whileDrag", false);
     }
-    updateAxis(axis, _point, offset) {
+    updateAxis(axis, _point, offset2) {
       const { drag: drag2 } = this.getProps();
-      if (!offset || !shouldDrag(axis, drag2, this.currentDirection))
+      if (!offset2 || !shouldDrag(axis, drag2, this.currentDirection))
         return;
       const axisValue = this.getAxisMotionValue(axis);
-      let next = this.originPoint[axis] + offset[axis];
+      let next = this.originPoint[axis] + offset2[axis];
       if (this.constraints && this.constraints[axis]) {
         next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);
       }
@@ -5836,8 +5836,8 @@ var CreopseReactToolkit = function(exports, React2) {
         const { projection } = this.visualElement;
         const axisValue = this.getAxisMotionValue(axis);
         if (projection && projection.layout) {
-          const { min, max } = projection.layout.layoutBox[axis];
-          axisValue.set(point[axis] - mixNumber$1(min, max, 0.5));
+          const { min: min2, max: max2 } = projection.layout.layoutBox[axis];
+          axisValue.set(point[axis] - mixNumber$1(min2, max2, 0.5));
         }
       });
     }
@@ -5871,8 +5871,8 @@ var CreopseReactToolkit = function(exports, React2) {
         if (!shouldDrag(axis, drag2, null))
           return;
         const axisValue = this.getAxisMotionValue(axis);
-        const { min, max } = this.constraints[axis];
-        axisValue.set(mixNumber$1(min, max, boxProgress[axis]));
+        const { min: min2, max: max2 } = this.constraints[axis];
+        axisValue.set(mixNumber$1(min2, max2, boxProgress[axis]));
       });
     }
     addListeners() {
@@ -5934,11 +5934,11 @@ var CreopseReactToolkit = function(exports, React2) {
   function shouldDrag(direction, drag2, currentDirection) {
     return (drag2 === true || drag2 === direction) && (currentDirection === null || currentDirection === direction);
   }
-  function getCurrentDirection(offset, lockThreshold = 10) {
+  function getCurrentDirection(offset2, lockThreshold = 10) {
     let direction = null;
-    if (Math.abs(offset.y) > lockThreshold) {
+    if (Math.abs(offset2.y) > lockThreshold) {
       direction = "y";
-    } else if (Math.abs(offset.x) > lockThreshold) {
+    } else if (Math.abs(offset2.x) > lockThreshold) {
       direction = "x";
     }
     return direction;
@@ -6043,16 +6043,16 @@ var CreopseReactToolkit = function(exports, React2) {
       if (shadow.length > 5)
         return original;
       const template = complex.createTransformer(latest);
-      const offset = typeof shadow[0] !== "number" ? 1 : 0;
+      const offset2 = typeof shadow[0] !== "number" ? 1 : 0;
       const xScale = projectionDelta.x.scale * treeScale.x;
       const yScale = projectionDelta.y.scale * treeScale.y;
-      shadow[0 + offset] /= xScale;
-      shadow[1 + offset] /= yScale;
+      shadow[0 + offset2] /= xScale;
+      shadow[1 + offset2] /= yScale;
       const averageScale = mixNumber$1(xScale, yScale, 0.5);
-      if (typeof shadow[2 + offset] === "number")
-        shadow[2 + offset] /= averageScale;
-      if (typeof shadow[3 + offset] === "number")
-        shadow[3 + offset] /= averageScale;
+      if (typeof shadow[2 + offset2] === "number")
+        shadow[2 + offset2] /= averageScale;
+      if (typeof shadow[3 + offset2] === "number")
+        shadow[3 + offset2] /= averageScale;
       return template(shadow);
     }
   };
@@ -6238,13 +6238,13 @@ var CreopseReactToolkit = function(exports, React2) {
   }
   const easeCrossfadeIn = /* @__PURE__ */ compress(0, 0.5, circOut);
   const easeCrossfadeOut = /* @__PURE__ */ compress(0.5, 0.95, noop);
-  function compress(min, max, easing) {
+  function compress(min2, max2, easing) {
     return (p) => {
-      if (p < min)
+      if (p < min2)
         return 0;
-      if (p > max)
+      if (p > max2)
         return 1;
-      return easing(/* @__PURE__ */ progress(min, max, p));
+      return easing(/* @__PURE__ */ progress(min2, max2, p));
     };
   }
   function copyAxisInto(axis, originAxis) {
@@ -7448,13 +7448,13 @@ var CreopseReactToolkit = function(exports, React2) {
     output.origin = delta.origin;
     output.originPoint = delta.originPoint;
   }
-  function mixAxis(output, from, to, p) {
-    output.min = mixNumber$1(from.min, to.min, p);
-    output.max = mixNumber$1(from.max, to.max, p);
+  function mixAxis(output, from2, to2, p) {
+    output.min = mixNumber$1(from2.min, to2.min, p);
+    output.max = mixNumber$1(from2.max, to2.max, p);
   }
-  function mixBox(output, from, to, p) {
-    mixAxis(output.x, from.x, to.x, p);
-    mixAxis(output.y, from.y, to.y, p);
+  function mixBox(output, from2, to2, p) {
+    mixAxis(output.x, from2.x, to2.x, p);
+    mixAxis(output.y, from2.y, to2.y, p);
   }
   function hasOpacityCrossfade(node) {
     return node.animationValues && node.animationValues.opacityExit !== void 0;
@@ -7780,8 +7780,4505 @@ var CreopseReactToolkit = function(exports, React2) {
       }
     );
   };
+  const MountedTeleport = ({
+    to: to2,
+    children,
+    disabled = false
+  }) => {
+    const [isMounted, setIsMounted] = React2.useState(false);
+    const [targetElement, setTargetElement] = React2.useState(null);
+    React2.useEffect(() => {
+      setIsMounted(true);
+      return () => {
+        setIsMounted(false);
+      };
+    }, []);
+    React2.useEffect(() => {
+      if (!isMounted || disabled) {
+        setTargetElement(null);
+        return;
+      }
+      let target = null;
+      if (typeof to2 === "string") {
+        target = document.querySelector(to2);
+        if (!target) {
+          console.warn(
+            `MountedTeleport: Target element not found for selector "${to2}"`
+          );
+          setTargetElement(null);
+          return;
+        }
+      } else if (to2 instanceof HTMLElement) {
+        target = to2;
+      } else {
+        console.warn(
+          "MountedTeleport: Invalid target type. Expected string selector or HTMLElement."
+        );
+        setTargetElement(null);
+        return;
+      }
+      setTargetElement(target);
+    }, [to2, isMounted, disabled]);
+    if (!isMounted || disabled || !targetElement) {
+      return null;
+    }
+    return reactDom.createPortal(children, targetElement);
+  };
+  const ReadMore = ({
+    moreStr = "Read more",
+    lessStr = "Read less",
+    link = "#",
+    maxChars = 100,
+    text,
+    className = "",
+    linkClassName = ""
+  }) => {
+    const [isExpanded, setIsExpanded] = React2.useState(false);
+    const formattedText = () => {
+      if (!isExpanded && text.length > maxChars) {
+        return text.substring(0, maxChars).trim() + "...";
+      }
+      return text;
+    };
+    const handleToggle = (event) => {
+      event.preventDefault();
+      setIsExpanded(!isExpanded);
+    };
+    if (!text) {
+      return null;
+    }
+    const shouldShowToggle = text.length > maxChars;
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: formattedText() }),
+      shouldShowToggle && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+        " ",
+        !isExpanded ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "a",
+          {
+            href: link,
+            onClick: handleToggle,
+            className: linkClassName,
+            role: "button",
+            tabIndex: 0,
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                setIsExpanded(true);
+              }
+            },
+            children: moreStr
+          }
+        ) : lessStr && /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "a",
+          {
+            href: link,
+            onClick: handleToggle,
+            className: linkClassName,
+            role: "button",
+            tabIndex: 0,
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                setIsExpanded(false);
+              }
+            },
+            children: lessStr
+          }
+        )
+      ] })
+    ] });
+  };
+  const StickyBottom = ({
+    bottom = 0,
+    zIndex = 1,
+    className = "",
+    children = /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Sticky Bottom" })
+  }) => {
+    const elRef = React2.useRef(null);
+    const [isSticky, setIsSticky] = React2.useState(false);
+    const [width, setWidth] = React2.useState("auto");
+    const [height, setHeight] = React2.useState("auto");
+    React2.useEffect(() => {
+      const handleScroll = () => {
+        if (!elRef.current) return;
+        const rect = elRef.current.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        const shouldStick = rect.bottom <= viewportHeight - bottom;
+        if (shouldStick && !isSticky) {
+          setWidth(rect.width + "px");
+          setHeight(rect.height + "px");
+          setIsSticky(true);
+        } else if (!shouldStick && isSticky) {
+          setIsSticky(false);
+          setWidth("auto");
+        }
+      };
+      const handleResize = () => {
+        if (!isSticky && elRef.current) {
+          const rect = elRef.current.getBoundingClientRect();
+          setHeight(rect.height + "px");
+        }
+      };
+      if (elRef.current) {
+        const rect = elRef.current.getBoundingClientRect();
+        setHeight(rect.height + "px");
+      }
+      window.addEventListener("scroll", handleScroll);
+      window.addEventListener("resize", handleResize);
+      handleScroll();
+      return () => {
+        window.removeEventListener("scroll", handleScroll);
+        window.removeEventListener("resize", handleResize);
+      };
+    }, [bottom, isSticky]);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "div",
+      {
+        ref: elRef,
+        style: {
+          height: isSticky ? height : "auto",
+          zIndex
+        },
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "div",
+          {
+            className,
+            style: {
+              position: isSticky ? "fixed" : "static",
+              bottom: isSticky ? `${bottom}px` : "auto",
+              width: isSticky ? width : "auto",
+              zIndex
+            },
+            children
+          }
+        )
+      }
+    );
+  };
+  const StickyTop = ({
+    top = 0,
+    zIndex = 1,
+    className = "",
+    children = /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Sticky Top" })
+  }) => {
+    const elRef = React2.useRef(null);
+    const [isSticky, setIsSticky] = React2.useState(false);
+    const [width, setWidth] = React2.useState("auto");
+    const [height, setHeight] = React2.useState("auto");
+    React2.useEffect(() => {
+      const handleScroll = () => {
+        if (!elRef.current) return;
+        const rect = elRef.current.getBoundingClientRect();
+        const shouldStick = rect.top <= top;
+        if (shouldStick && !isSticky) {
+          setWidth(rect.width + "px");
+          setHeight(rect.height + "px");
+          setIsSticky(true);
+        } else if (!shouldStick && isSticky) {
+          setIsSticky(false);
+          setWidth("auto");
+        }
+      };
+      const handleResize = () => {
+        if (!isSticky && elRef.current) {
+          const rect = elRef.current.getBoundingClientRect();
+          setHeight(rect.height + "px");
+        }
+      };
+      if (elRef.current) {
+        const rect = elRef.current.getBoundingClientRect();
+        setHeight(rect.height + "px");
+      }
+      window.addEventListener("scroll", handleScroll);
+      window.addEventListener("resize", handleResize);
+      handleScroll();
+      return () => {
+        window.removeEventListener("scroll", handleScroll);
+        window.removeEventListener("resize", handleResize);
+      };
+    }, [top, isSticky]);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "div",
+      {
+        ref: elRef,
+        style: {
+          height: isSticky ? height : "auto",
+          zIndex
+        },
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "div",
+          {
+            className,
+            style: {
+              position: isSticky ? "fixed" : "static",
+              top: isSticky ? `${top}px` : "auto",
+              width: isSticky ? width : "auto",
+              zIndex
+            },
+            children
+          }
+        )
+      }
+    );
+  };
+  var MediaFileType;
+  (function(MediaFileType2) {
+    MediaFileType2[MediaFileType2["DOCUMENT"] = 1] = "DOCUMENT";
+    MediaFileType2[MediaFileType2["IMAGE"] = 2] = "IMAGE";
+    MediaFileType2[MediaFileType2["VIDEO"] = 3] = "VIDEO";
+    MediaFileType2[MediaFileType2["AUDIO"] = 4] = "AUDIO";
+    MediaFileType2[MediaFileType2["OTHER"] = 5] = "OTHER";
+  })(MediaFileType || (MediaFileType = {}));
+  var NewsArticleStatus;
+  (function(NewsArticleStatus2) {
+    NewsArticleStatus2[NewsArticleStatus2["DRAFT"] = 1] = "DRAFT";
+    NewsArticleStatus2[NewsArticleStatus2["PENDING"] = 2] = "PENDING";
+    NewsArticleStatus2[NewsArticleStatus2["PUBLISHED"] = 3] = "PUBLISHED";
+    NewsArticleStatus2[NewsArticleStatus2["TRASH"] = 4] = "TRASH";
+  })(NewsArticleStatus || (NewsArticleStatus = {}));
+  var VideoDisplayType;
+  (function(VideoDisplayType2) {
+    VideoDisplayType2["VERTICAL"] = "vertical";
+    VideoDisplayType2["HORIZONTAL"] = "horizontal";
+  })(VideoDisplayType || (VideoDisplayType = {}));
+  var VideoItemSource;
+  (function(VideoItemSource2) {
+    VideoItemSource2["SELF_HOSTED"] = "self-hosted";
+    VideoItemSource2["YOUTUBE"] = "youtube";
+  })(VideoItemSource || (VideoItemSource = {}));
+  function slideToId(id2) {
+    const element = document.getElementById(id2);
+    if (element) {
+      element.scrollIntoView({ behavior: "smooth", block: "start" });
+    } else {
+      console.error(`Element with ID "${id2}" not found.`);
+    }
+  }
+  //! moment.js
+  //! version : 2.30.1
+  //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+  //! license : MIT
+  //! momentjs.com
+  var hookCallback;
+  function hooks() {
+    return hookCallback.apply(null, arguments);
+  }
+  function setHookCallback(callback) {
+    hookCallback = callback;
+  }
+  function isArray(input) {
+    return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]";
+  }
+  function isObject(input) {
+    return input != null && Object.prototype.toString.call(input) === "[object Object]";
+  }
+  function hasOwnProp(a, b) {
+    return Object.prototype.hasOwnProperty.call(a, b);
+  }
+  function isObjectEmpty(obj) {
+    if (Object.getOwnPropertyNames) {
+      return Object.getOwnPropertyNames(obj).length === 0;
+    } else {
+      var k;
+      for (k in obj) {
+        if (hasOwnProp(obj, k)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+  function isUndefined(input) {
+    return input === void 0;
+  }
+  function isNumber(input) {
+    return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]";
+  }
+  function isDate(input) {
+    return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+  }
+  function map(arr, fn) {
+    var res = [], i, arrLen = arr.length;
+    for (i = 0; i < arrLen; ++i) {
+      res.push(fn(arr[i], i));
+    }
+    return res;
+  }
+  function extend(a, b) {
+    for (var i in b) {
+      if (hasOwnProp(b, i)) {
+        a[i] = b[i];
+      }
+    }
+    if (hasOwnProp(b, "toString")) {
+      a.toString = b.toString;
+    }
+    if (hasOwnProp(b, "valueOf")) {
+      a.valueOf = b.valueOf;
+    }
+    return a;
+  }
+  function createUTC(input, format2, locale2, strict) {
+    return createLocalOrUTC(input, format2, locale2, strict, true).utc();
+  }
+  function defaultParsingFlags() {
+    return {
+      empty: false,
+      unusedTokens: [],
+      unusedInput: [],
+      overflow: -2,
+      charsLeftOver: 0,
+      nullInput: false,
+      invalidEra: null,
+      invalidMonth: null,
+      invalidFormat: false,
+      userInvalidated: false,
+      iso: false,
+      parsedDateParts: [],
+      era: null,
+      meridiem: null,
+      rfc2822: false,
+      weekdayMismatch: false
+    };
+  }
+  function getParsingFlags(m) {
+    if (m._pf == null) {
+      m._pf = defaultParsingFlags();
+    }
+    return m._pf;
+  }
+  var some;
+  if (Array.prototype.some) {
+    some = Array.prototype.some;
+  } else {
+    some = function(fun) {
+      var t = Object(this), len = t.length >>> 0, i;
+      for (i = 0; i < len; i++) {
+        if (i in t && fun.call(this, t[i], i, t)) {
+          return true;
+        }
+      }
+      return false;
+    };
+  }
+  function isValid(m) {
+    var flags = null, parsedParts = false, isNowValid = m._d && !isNaN(m._d.getTime());
+    if (isNowValid) {
+      flags = getParsingFlags(m);
+      parsedParts = some.call(flags.parsedDateParts, function(i) {
+        return i != null;
+      });
+      isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
+      if (m._strict) {
+        isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0;
+      }
+    }
+    if (Object.isFrozen == null || !Object.isFrozen(m)) {
+      m._isValid = isNowValid;
+    } else {
+      return isNowValid;
+    }
+    return m._isValid;
+  }
+  function createInvalid(flags) {
+    var m = createUTC(NaN);
+    if (flags != null) {
+      extend(getParsingFlags(m), flags);
+    } else {
+      getParsingFlags(m).userInvalidated = true;
+    }
+    return m;
+  }
+  var momentProperties = hooks.momentProperties = [], updateInProgress = false;
+  function copyConfig(to2, from2) {
+    var i, prop, val, momentPropertiesLen = momentProperties.length;
+    if (!isUndefined(from2._isAMomentObject)) {
+      to2._isAMomentObject = from2._isAMomentObject;
+    }
+    if (!isUndefined(from2._i)) {
+      to2._i = from2._i;
+    }
+    if (!isUndefined(from2._f)) {
+      to2._f = from2._f;
+    }
+    if (!isUndefined(from2._l)) {
+      to2._l = from2._l;
+    }
+    if (!isUndefined(from2._strict)) {
+      to2._strict = from2._strict;
+    }
+    if (!isUndefined(from2._tzm)) {
+      to2._tzm = from2._tzm;
+    }
+    if (!isUndefined(from2._isUTC)) {
+      to2._isUTC = from2._isUTC;
+    }
+    if (!isUndefined(from2._offset)) {
+      to2._offset = from2._offset;
+    }
+    if (!isUndefined(from2._pf)) {
+      to2._pf = getParsingFlags(from2);
+    }
+    if (!isUndefined(from2._locale)) {
+      to2._locale = from2._locale;
+    }
+    if (momentPropertiesLen > 0) {
+      for (i = 0; i < momentPropertiesLen; i++) {
+        prop = momentProperties[i];
+        val = from2[prop];
+        if (!isUndefined(val)) {
+          to2[prop] = val;
+        }
+      }
+    }
+    return to2;
+  }
+  function Moment(config) {
+    copyConfig(this, config);
+    this._d = new Date(config._d != null ? config._d.getTime() : NaN);
+    if (!this.isValid()) {
+      this._d = /* @__PURE__ */ new Date(NaN);
+    }
+    if (updateInProgress === false) {
+      updateInProgress = true;
+      hooks.updateOffset(this);
+      updateInProgress = false;
+    }
+  }
+  function isMoment(obj) {
+    return obj instanceof Moment || obj != null && obj._isAMomentObject != null;
+  }
+  function warn(msg) {
+    if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) {
+      console.warn("Deprecation warning: " + msg);
+    }
+  }
+  function deprecate(msg, fn) {
+    var firstTime = true;
+    return extend(function() {
+      if (hooks.deprecationHandler != null) {
+        hooks.deprecationHandler(null, msg);
+      }
+      if (firstTime) {
+        var args = [], arg, i, key, argLen = arguments.length;
+        for (i = 0; i < argLen; i++) {
+          arg = "";
+          if (typeof arguments[i] === "object") {
+            arg += "\n[" + i + "] ";
+            for (key in arguments[0]) {
+              if (hasOwnProp(arguments[0], key)) {
+                arg += key + ": " + arguments[0][key] + ", ";
+              }
+            }
+            arg = arg.slice(0, -2);
+          } else {
+            arg = arguments[i];
+          }
+          args.push(arg);
+        }
+        warn(
+          msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack
+        );
+        firstTime = false;
+      }
+      return fn.apply(this, arguments);
+    }, fn);
+  }
+  var deprecations = {};
+  function deprecateSimple(name, msg) {
+    if (hooks.deprecationHandler != null) {
+      hooks.deprecationHandler(name, msg);
+    }
+    if (!deprecations[name]) {
+      warn(msg);
+      deprecations[name] = true;
+    }
+  }
+  hooks.suppressDeprecationWarnings = false;
+  hooks.deprecationHandler = null;
+  function isFunction(input) {
+    return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
+  }
+  function set(config) {
+    var prop, i;
+    for (i in config) {
+      if (hasOwnProp(config, i)) {
+        prop = config[i];
+        if (isFunction(prop)) {
+          this[i] = prop;
+        } else {
+          this["_" + i] = prop;
+        }
+      }
+    }
+    this._config = config;
+    this._dayOfMonthOrdinalParseLenient = new RegExp(
+      (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source
+    );
+  }
+  function mergeConfigs(parentConfig, childConfig) {
+    var res = extend({}, parentConfig), prop;
+    for (prop in childConfig) {
+      if (hasOwnProp(childConfig, prop)) {
+        if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+          res[prop] = {};
+          extend(res[prop], parentConfig[prop]);
+          extend(res[prop], childConfig[prop]);
+        } else if (childConfig[prop] != null) {
+          res[prop] = childConfig[prop];
+        } else {
+          delete res[prop];
+        }
+      }
+    }
+    for (prop in parentConfig) {
+      if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
+        res[prop] = extend({}, res[prop]);
+      }
+    }
+    return res;
+  }
+  function Locale(config) {
+    if (config != null) {
+      this.set(config);
+    }
+  }
+  var keys;
+  if (Object.keys) {
+    keys = Object.keys;
+  } else {
+    keys = function(obj) {
+      var i, res = [];
+      for (i in obj) {
+        if (hasOwnProp(obj, i)) {
+          res.push(i);
+        }
+      }
+      return res;
+    };
+  }
+  var defaultCalendar = {
+    sameDay: "[Today at] LT",
+    nextDay: "[Tomorrow at] LT",
+    nextWeek: "dddd [at] LT",
+    lastDay: "[Yesterday at] LT",
+    lastWeek: "[Last] dddd [at] LT",
+    sameElse: "L"
+  };
+  function calendar(key, mom, now2) {
+    var output = this._calendar[key] || this._calendar["sameElse"];
+    return isFunction(output) ? output.call(mom, now2) : output;
+  }
+  function zeroFill(number2, targetLength, forceSign) {
+    var absNumber = "" + Math.abs(number2), zerosToFill = targetLength - absNumber.length, sign2 = number2 >= 0;
+    return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
+  }
+  var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
+  function addFormatToken(token2, padded, ordinal2, callback) {
+    var func = callback;
+    if (typeof callback === "string") {
+      func = function() {
+        return this[callback]();
+      };
+    }
+    if (token2) {
+      formatTokenFunctions[token2] = func;
+    }
+    if (padded) {
+      formatTokenFunctions[padded[0]] = function() {
+        return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+      };
+    }
+    if (ordinal2) {
+      formatTokenFunctions[ordinal2] = function() {
+        return this.localeData().ordinal(
+          func.apply(this, arguments),
+          token2
+        );
+      };
+    }
+  }
+  function removeFormattingTokens(input) {
+    if (input.match(/\[[\s\S]/)) {
+      return input.replace(/^\[|\]$/g, "");
+    }
+    return input.replace(/\\/g, "");
+  }
+  function makeFormatFunction(format2) {
+    var array = format2.match(formattingTokens), i, length;
+    for (i = 0, length = array.length; i < length; i++) {
+      if (formatTokenFunctions[array[i]]) {
+        array[i] = formatTokenFunctions[array[i]];
+      } else {
+        array[i] = removeFormattingTokens(array[i]);
+      }
+    }
+    return function(mom) {
+      var output = "", i2;
+      for (i2 = 0; i2 < length; i2++) {
+        output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2];
+      }
+      return output;
+    };
+  }
+  function formatMoment(m, format2) {
+    if (!m.isValid()) {
+      return m.localeData().invalidDate();
+    }
+    format2 = expandFormat(format2, m.localeData());
+    formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
+    return formatFunctions[format2](m);
+  }
+  function expandFormat(format2, locale2) {
+    var i = 5;
+    function replaceLongDateFormatTokens(input) {
+      return locale2.longDateFormat(input) || input;
+    }
+    localFormattingTokens.lastIndex = 0;
+    while (i >= 0 && localFormattingTokens.test(format2)) {
+      format2 = format2.replace(
+        localFormattingTokens,
+        replaceLongDateFormatTokens
+      );
+      localFormattingTokens.lastIndex = 0;
+      i -= 1;
+    }
+    return format2;
+  }
+  var defaultLongDateFormat = {
+    LTS: "h:mm:ss A",
+    LT: "h:mm A",
+    L: "MM/DD/YYYY",
+    LL: "MMMM D, YYYY",
+    LLL: "MMMM D, YYYY h:mm A",
+    LLLL: "dddd, MMMM D, YYYY h:mm A"
+  };
+  function longDateFormat(key) {
+    var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
+    if (format2 || !formatUpper) {
+      return format2;
+    }
+    this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
+      if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
+        return tok.slice(1);
+      }
+      return tok;
+    }).join("");
+    return this._longDateFormat[key];
+  }
+  var defaultInvalidDate = "Invalid date";
+  function invalidDate() {
+    return this._invalidDate;
+  }
+  var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+  function ordinal(number2) {
+    return this._ordinal.replace("%d", number2);
+  }
+  var defaultRelativeTime = {
+    future: "in %s",
+    past: "%s ago",
+    s: "a few seconds",
+    ss: "%d seconds",
+    m: "a minute",
+    mm: "%d minutes",
+    h: "an hour",
+    hh: "%d hours",
+    d: "a day",
+    dd: "%d days",
+    w: "a week",
+    ww: "%d weeks",
+    M: "a month",
+    MM: "%d months",
+    y: "a year",
+    yy: "%d years"
+  };
+  function relativeTime(number2, withoutSuffix, string, isFuture) {
+    var output = this._relativeTime[string];
+    return isFunction(output) ? output(number2, withoutSuffix, string, isFuture) : output.replace(/%d/i, number2);
+  }
+  function pastFuture(diff2, output) {
+    var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
+    return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
+  }
+  var aliases = {
+    D: "date",
+    dates: "date",
+    date: "date",
+    d: "day",
+    days: "day",
+    day: "day",
+    e: "weekday",
+    weekdays: "weekday",
+    weekday: "weekday",
+    E: "isoWeekday",
+    isoweekdays: "isoWeekday",
+    isoweekday: "isoWeekday",
+    DDD: "dayOfYear",
+    dayofyears: "dayOfYear",
+    dayofyear: "dayOfYear",
+    h: "hour",
+    hours: "hour",
+    hour: "hour",
+    ms: "millisecond",
+    milliseconds: "millisecond",
+    millisecond: "millisecond",
+    m: "minute",
+    minutes: "minute",
+    minute: "minute",
+    M: "month",
+    months: "month",
+    month: "month",
+    Q: "quarter",
+    quarters: "quarter",
+    quarter: "quarter",
+    s: "second",
+    seconds: "second",
+    second: "second",
+    gg: "weekYear",
+    weekyears: "weekYear",
+    weekyear: "weekYear",
+    GG: "isoWeekYear",
+    isoweekyears: "isoWeekYear",
+    isoweekyear: "isoWeekYear",
+    w: "week",
+    weeks: "week",
+    week: "week",
+    W: "isoWeek",
+    isoweeks: "isoWeek",
+    isoweek: "isoWeek",
+    y: "year",
+    years: "year",
+    year: "year"
+  };
+  function normalizeUnits(units) {
+    return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0;
+  }
+  function normalizeObjectUnits(inputObject) {
+    var normalizedInput = {}, normalizedProp, prop;
+    for (prop in inputObject) {
+      if (hasOwnProp(inputObject, prop)) {
+        normalizedProp = normalizeUnits(prop);
+        if (normalizedProp) {
+          normalizedInput[normalizedProp] = inputObject[prop];
+        }
+      }
+    }
+    return normalizedInput;
+  }
+  var priorities = {
+    date: 9,
+    day: 11,
+    weekday: 11,
+    isoWeekday: 11,
+    dayOfYear: 4,
+    hour: 13,
+    millisecond: 16,
+    minute: 14,
+    month: 8,
+    quarter: 7,
+    second: 15,
+    weekYear: 1,
+    isoWeekYear: 1,
+    week: 5,
+    isoWeek: 5,
+    year: 1
+  };
+  function getPrioritizedUnits(unitsObj) {
+    var units = [], u;
+    for (u in unitsObj) {
+      if (hasOwnProp(unitsObj, u)) {
+        units.push({ unit: u, priority: priorities[u] });
+      }
+    }
+    units.sort(function(a, b) {
+      return a.priority - b.priority;
+    });
+    return units;
+  }
+  var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes;
+  regexes = {};
+  function addRegexToken(token2, regex, strictRegex) {
+    regexes[token2] = isFunction(regex) ? regex : function(isStrict, localeData2) {
+      return isStrict && strictRegex ? strictRegex : regex;
+    };
+  }
+  function getParseRegexForToken(token2, config) {
+    if (!hasOwnProp(regexes, token2)) {
+      return new RegExp(unescapeFormat(token2));
+    }
+    return regexes[token2](config._strict, config._locale);
+  }
+  function unescapeFormat(s) {
+    return regexEscape(
+      s.replace("\\", "").replace(
+        /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
+        function(matched, p1, p2, p3, p4) {
+          return p1 || p2 || p3 || p4;
+        }
+      )
+    );
+  }
+  function regexEscape(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+  }
+  function absFloor(number2) {
+    if (number2 < 0) {
+      return Math.ceil(number2) || 0;
+    } else {
+      return Math.floor(number2);
+    }
+  }
+  function toInt(argumentForCoercion) {
+    var coercedNumber = +argumentForCoercion, value = 0;
+    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+      value = absFloor(coercedNumber);
+    }
+    return value;
+  }
+  var tokens = {};
+  function addParseToken(token2, callback) {
+    var i, func = callback, tokenLen;
+    if (typeof token2 === "string") {
+      token2 = [token2];
+    }
+    if (isNumber(callback)) {
+      func = function(input, array) {
+        array[callback] = toInt(input);
+      };
+    }
+    tokenLen = token2.length;
+    for (i = 0; i < tokenLen; i++) {
+      tokens[token2[i]] = func;
+    }
+  }
+  function addWeekParseToken(token2, callback) {
+    addParseToken(token2, function(input, array, config, token3) {
+      config._w = config._w || {};
+      callback(input, config._w, config, token3);
+    });
+  }
+  function addTimeToArrayFromToken(token2, input, config) {
+    if (input != null && hasOwnProp(tokens, token2)) {
+      tokens[token2](input, config._a, config, token2);
+    }
+  }
+  function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+  }
+  var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8;
+  addFormatToken("Y", 0, 0, function() {
+    var y = this.year();
+    return y <= 9999 ? zeroFill(y, 4) : "+" + y;
+  });
+  addFormatToken(0, ["YY", 2], 0, function() {
+    return this.year() % 100;
+  });
+  addFormatToken(0, ["YYYY", 4], 0, "year");
+  addFormatToken(0, ["YYYYY", 5], 0, "year");
+  addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
+  addRegexToken("Y", matchSigned);
+  addRegexToken("YY", match1to2, match2);
+  addRegexToken("YYYY", match1to4, match4);
+  addRegexToken("YYYYY", match1to6, match6);
+  addRegexToken("YYYYYY", match1to6, match6);
+  addParseToken(["YYYYY", "YYYYYY"], YEAR);
+  addParseToken("YYYY", function(input, array) {
+    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+  });
+  addParseToken("YY", function(input, array) {
+    array[YEAR] = hooks.parseTwoDigitYear(input);
+  });
+  addParseToken("Y", function(input, array) {
+    array[YEAR] = parseInt(input, 10);
+  });
+  function daysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
+  }
+  hooks.parseTwoDigitYear = function(input) {
+    return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3);
+  };
+  var getSetYear = makeGetSet("FullYear", true);
+  function getIsLeapYear() {
+    return isLeapYear(this.year());
+  }
+  function makeGetSet(unit, keepTime) {
+    return function(value) {
+      if (value != null) {
+        set$1(this, unit, value);
+        hooks.updateOffset(this, keepTime);
+        return this;
+      } else {
+        return get(this, unit);
+      }
+    };
+  }
+  function get(mom, unit) {
+    if (!mom.isValid()) {
+      return NaN;
+    }
+    var d = mom._d, isUTC = mom._isUTC;
+    switch (unit) {
+      case "Milliseconds":
+        return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds();
+      case "Seconds":
+        return isUTC ? d.getUTCSeconds() : d.getSeconds();
+      case "Minutes":
+        return isUTC ? d.getUTCMinutes() : d.getMinutes();
+      case "Hours":
+        return isUTC ? d.getUTCHours() : d.getHours();
+      case "Date":
+        return isUTC ? d.getUTCDate() : d.getDate();
+      case "Day":
+        return isUTC ? d.getUTCDay() : d.getDay();
+      case "Month":
+        return isUTC ? d.getUTCMonth() : d.getMonth();
+      case "FullYear":
+        return isUTC ? d.getUTCFullYear() : d.getFullYear();
+      default:
+        return NaN;
+    }
+  }
+  function set$1(mom, unit, value) {
+    var d, isUTC, year, month, date;
+    if (!mom.isValid() || isNaN(value)) {
+      return;
+    }
+    d = mom._d;
+    isUTC = mom._isUTC;
+    switch (unit) {
+      case "Milliseconds":
+        return void (isUTC ? d.setUTCMilliseconds(value) : d.setMilliseconds(value));
+      case "Seconds":
+        return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value));
+      case "Minutes":
+        return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value));
+      case "Hours":
+        return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
+      case "Date":
+        return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
+      // case 'Day': // Not real
+      //    return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
+      // case 'Month': // Not used because we need to pass two variables
+      //     return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
+      case "FullYear":
+        break;
+      // See below ...
+      default:
+        return;
+    }
+    year = value;
+    month = mom.month();
+    date = mom.date();
+    date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
+    void (isUTC ? d.setUTCFullYear(year, month, date) : d.setFullYear(year, month, date));
+  }
+  function stringGet(units) {
+    units = normalizeUnits(units);
+    if (isFunction(this[units])) {
+      return this[units]();
+    }
+    return this;
+  }
+  function stringSet(units, value) {
+    if (typeof units === "object") {
+      units = normalizeObjectUnits(units);
+      var prioritized = getPrioritizedUnits(units), i, prioritizedLen = prioritized.length;
+      for (i = 0; i < prioritizedLen; i++) {
+        this[prioritized[i].unit](units[prioritized[i].unit]);
+      }
+    } else {
+      units = normalizeUnits(units);
+      if (isFunction(this[units])) {
+        return this[units](value);
+      }
+    }
+    return this;
+  }
+  function mod(n, x) {
+    return (n % x + x) % x;
+  }
+  var indexOf;
+  if (Array.prototype.indexOf) {
+    indexOf = Array.prototype.indexOf;
+  } else {
+    indexOf = function(o) {
+      var i;
+      for (i = 0; i < this.length; ++i) {
+        if (this[i] === o) {
+          return i;
+        }
+      }
+      return -1;
+    };
+  }
+  function daysInMonth(year, month) {
+    if (isNaN(year) || isNaN(month)) {
+      return NaN;
+    }
+    var modMonth = mod(month, 12);
+    year += (month - modMonth) / 12;
+    return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
+  }
+  addFormatToken("M", ["MM", 2], "Mo", function() {
+    return this.month() + 1;
+  });
+  addFormatToken("MMM", 0, 0, function(format2) {
+    return this.localeData().monthsShort(this, format2);
+  });
+  addFormatToken("MMMM", 0, 0, function(format2) {
+    return this.localeData().months(this, format2);
+  });
+  addRegexToken("M", match1to2, match1to2NoLeadingZero);
+  addRegexToken("MM", match1to2, match2);
+  addRegexToken("MMM", function(isStrict, locale2) {
+    return locale2.monthsShortRegex(isStrict);
+  });
+  addRegexToken("MMMM", function(isStrict, locale2) {
+    return locale2.monthsRegex(isStrict);
+  });
+  addParseToken(["M", "MM"], function(input, array) {
+    array[MONTH] = toInt(input) - 1;
+  });
+  addParseToken(["MMM", "MMMM"], function(input, array, config, token2) {
+    var month = config._locale.monthsParse(input, token2, config._strict);
+    if (month != null) {
+      array[MONTH] = month;
+    } else {
+      getParsingFlags(config).invalidMonth = input;
+    }
+  });
+  var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
+    "_"
+  ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
+  function localeMonths(m, format2) {
+    if (!m) {
+      return isArray(this._months) ? this._months : this._months["standalone"];
+    }
+    return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m.month()];
+  }
+  function localeMonthsShort(m, format2) {
+    if (!m) {
+      return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"];
+    }
+    return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m.month()];
+  }
+  function handleStrictParse(monthName, format2, strict) {
+    var i, ii, mom, llc = monthName.toLocaleLowerCase();
+    if (!this._monthsParse) {
+      this._monthsParse = [];
+      this._longMonthsParse = [];
+      this._shortMonthsParse = [];
+      for (i = 0; i < 12; ++i) {
+        mom = createUTC([2e3, i]);
+        this._shortMonthsParse[i] = this.monthsShort(
+          mom,
+          ""
+        ).toLocaleLowerCase();
+        this._longMonthsParse[i] = this.months(mom, "").toLocaleLowerCase();
+      }
+    }
+    if (strict) {
+      if (format2 === "MMM") {
+        ii = indexOf.call(this._shortMonthsParse, llc);
+        return ii !== -1 ? ii : null;
+      } else {
+        ii = indexOf.call(this._longMonthsParse, llc);
+        return ii !== -1 ? ii : null;
+      }
+    } else {
+      if (format2 === "MMM") {
+        ii = indexOf.call(this._shortMonthsParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._longMonthsParse, llc);
+        return ii !== -1 ? ii : null;
+      } else {
+        ii = indexOf.call(this._longMonthsParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._shortMonthsParse, llc);
+        return ii !== -1 ? ii : null;
+      }
+    }
+  }
+  function localeMonthsParse(monthName, format2, strict) {
+    var i, mom, regex;
+    if (this._monthsParseExact) {
+      return handleStrictParse.call(this, monthName, format2, strict);
+    }
+    if (!this._monthsParse) {
+      this._monthsParse = [];
+      this._longMonthsParse = [];
+      this._shortMonthsParse = [];
+    }
+    for (i = 0; i < 12; i++) {
+      mom = createUTC([2e3, i]);
+      if (strict && !this._longMonthsParse[i]) {
+        this._longMonthsParse[i] = new RegExp(
+          "^" + this.months(mom, "").replace(".", "") + "$",
+          "i"
+        );
+        this._shortMonthsParse[i] = new RegExp(
+          "^" + this.monthsShort(mom, "").replace(".", "") + "$",
+          "i"
+        );
+      }
+      if (!strict && !this._monthsParse[i]) {
+        regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
+        this._monthsParse[i] = new RegExp(regex.replace(".", ""), "i");
+      }
+      if (strict && format2 === "MMMM" && this._longMonthsParse[i].test(monthName)) {
+        return i;
+      } else if (strict && format2 === "MMM" && this._shortMonthsParse[i].test(monthName)) {
+        return i;
+      } else if (!strict && this._monthsParse[i].test(monthName)) {
+        return i;
+      }
+    }
+  }
+  function setMonth(mom, value) {
+    if (!mom.isValid()) {
+      return mom;
+    }
+    if (typeof value === "string") {
+      if (/^\d+$/.test(value)) {
+        value = toInt(value);
+      } else {
+        value = mom.localeData().monthsParse(value);
+        if (!isNumber(value)) {
+          return mom;
+        }
+      }
+    }
+    var month = value, date = mom.date();
+    date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
+    void (mom._isUTC ? mom._d.setUTCMonth(month, date) : mom._d.setMonth(month, date));
+    return mom;
+  }
+  function getSetMonth(value) {
+    if (value != null) {
+      setMonth(this, value);
+      hooks.updateOffset(this, true);
+      return this;
+    } else {
+      return get(this, "Month");
+    }
+  }
+  function getDaysInMonth() {
+    return daysInMonth(this.year(), this.month());
+  }
+  function monthsShortRegex(isStrict) {
+    if (this._monthsParseExact) {
+      if (!hasOwnProp(this, "_monthsRegex")) {
+        computeMonthsParse.call(this);
+      }
+      if (isStrict) {
+        return this._monthsShortStrictRegex;
+      } else {
+        return this._monthsShortRegex;
+      }
+    } else {
+      if (!hasOwnProp(this, "_monthsShortRegex")) {
+        this._monthsShortRegex = defaultMonthsShortRegex;
+      }
+      return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
+    }
+  }
+  function monthsRegex$1(isStrict) {
+    if (this._monthsParseExact) {
+      if (!hasOwnProp(this, "_monthsRegex")) {
+        computeMonthsParse.call(this);
+      }
+      if (isStrict) {
+        return this._monthsStrictRegex;
+      } else {
+        return this._monthsRegex;
+      }
+    } else {
+      if (!hasOwnProp(this, "_monthsRegex")) {
+        this._monthsRegex = defaultMonthsRegex;
+      }
+      return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
+    }
+  }
+  function computeMonthsParse() {
+    function cmpLenRev(a, b) {
+      return b.length - a.length;
+    }
+    var shortPieces = [], longPieces = [], mixedPieces = [], i, mom, shortP, longP;
+    for (i = 0; i < 12; i++) {
+      mom = createUTC([2e3, i]);
+      shortP = regexEscape(this.monthsShort(mom, ""));
+      longP = regexEscape(this.months(mom, ""));
+      shortPieces.push(shortP);
+      longPieces.push(longP);
+      mixedPieces.push(longP);
+      mixedPieces.push(shortP);
+    }
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+    this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
+    this._monthsShortRegex = this._monthsRegex;
+    this._monthsStrictRegex = new RegExp(
+      "^(" + longPieces.join("|") + ")",
+      "i"
+    );
+    this._monthsShortStrictRegex = new RegExp(
+      "^(" + shortPieces.join("|") + ")",
+      "i"
+    );
+  }
+  function createDate(y, m, d, h, M, s, ms) {
+    var date;
+    if (y < 100 && y >= 0) {
+      date = new Date(y + 400, m, d, h, M, s, ms);
+      if (isFinite(date.getFullYear())) {
+        date.setFullYear(y);
+      }
+    } else {
+      date = new Date(y, m, d, h, M, s, ms);
+    }
+    return date;
+  }
+  function createUTCDate(y) {
+    var date, args;
+    if (y < 100 && y >= 0) {
+      args = Array.prototype.slice.call(arguments);
+      args[0] = y + 400;
+      date = new Date(Date.UTC.apply(null, args));
+      if (isFinite(date.getUTCFullYear())) {
+        date.setUTCFullYear(y);
+      }
+    } else {
+      date = new Date(Date.UTC.apply(null, arguments));
+    }
+    return date;
+  }
+  function firstWeekOffset(year, dow, doy) {
+    var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+    return -fwdlw + fwd - 1;
+  }
+  function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+    var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
+    if (dayOfYear <= 0) {
+      resYear = year - 1;
+      resDayOfYear = daysInYear(resYear) + dayOfYear;
+    } else if (dayOfYear > daysInYear(year)) {
+      resYear = year + 1;
+      resDayOfYear = dayOfYear - daysInYear(year);
+    } else {
+      resYear = year;
+      resDayOfYear = dayOfYear;
+    }
+    return {
+      year: resYear,
+      dayOfYear: resDayOfYear
+    };
+  }
+  function weekOfYear(mom, dow, doy) {
+    var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
+    if (week < 1) {
+      resYear = mom.year() - 1;
+      resWeek = week + weeksInYear(resYear, dow, doy);
+    } else if (week > weeksInYear(mom.year(), dow, doy)) {
+      resWeek = week - weeksInYear(mom.year(), dow, doy);
+      resYear = mom.year() + 1;
+    } else {
+      resYear = mom.year();
+      resWeek = week;
+    }
+    return {
+      week: resWeek,
+      year: resYear
+    };
+  }
+  function weeksInYear(year, dow, doy) {
+    var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+  }
+  addFormatToken("w", ["ww", 2], "wo", "week");
+  addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
+  addRegexToken("w", match1to2, match1to2NoLeadingZero);
+  addRegexToken("ww", match1to2, match2);
+  addRegexToken("W", match1to2, match1to2NoLeadingZero);
+  addRegexToken("WW", match1to2, match2);
+  addWeekParseToken(
+    ["w", "ww", "W", "WW"],
+    function(input, week, config, token2) {
+      week[token2.substr(0, 1)] = toInt(input);
+    }
+  );
+  function localeWeek(mom) {
+    return weekOfYear(mom, this._week.dow, this._week.doy).week;
+  }
+  var defaultLocaleWeek = {
+    dow: 0,
+    // Sunday is the first day of the week.
+    doy: 6
+    // The week that contains Jan 6th is the first week of the year.
+  };
+  function localeFirstDayOfWeek() {
+    return this._week.dow;
+  }
+  function localeFirstDayOfYear() {
+    return this._week.doy;
+  }
+  function getSetWeek(input) {
+    var week = this.localeData().week(this);
+    return input == null ? week : this.add((input - week) * 7, "d");
+  }
+  function getSetISOWeek(input) {
+    var week = weekOfYear(this, 1, 4).week;
+    return input == null ? week : this.add((input - week) * 7, "d");
+  }
+  addFormatToken("d", 0, "do", "day");
+  addFormatToken("dd", 0, 0, function(format2) {
+    return this.localeData().weekdaysMin(this, format2);
+  });
+  addFormatToken("ddd", 0, 0, function(format2) {
+    return this.localeData().weekdaysShort(this, format2);
+  });
+  addFormatToken("dddd", 0, 0, function(format2) {
+    return this.localeData().weekdays(this, format2);
+  });
+  addFormatToken("e", 0, 0, "weekday");
+  addFormatToken("E", 0, 0, "isoWeekday");
+  addRegexToken("d", match1to2);
+  addRegexToken("e", match1to2);
+  addRegexToken("E", match1to2);
+  addRegexToken("dd", function(isStrict, locale2) {
+    return locale2.weekdaysMinRegex(isStrict);
+  });
+  addRegexToken("ddd", function(isStrict, locale2) {
+    return locale2.weekdaysShortRegex(isStrict);
+  });
+  addRegexToken("dddd", function(isStrict, locale2) {
+    return locale2.weekdaysRegex(isStrict);
+  });
+  addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config, token2) {
+    var weekday = config._locale.weekdaysParse(input, token2, config._strict);
+    if (weekday != null) {
+      week.d = weekday;
+    } else {
+      getParsingFlags(config).invalidWeekday = input;
+    }
+  });
+  addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) {
+    week[token2] = toInt(input);
+  });
+  function parseWeekday(input, locale2) {
+    if (typeof input !== "string") {
+      return input;
+    }
+    if (!isNaN(input)) {
+      return parseInt(input, 10);
+    }
+    input = locale2.weekdaysParse(input);
+    if (typeof input === "number") {
+      return input;
+    }
+    return null;
+  }
+  function parseIsoWeekday(input, locale2) {
+    if (typeof input === "string") {
+      return locale2.weekdaysParse(input) % 7 || 7;
+    }
+    return isNaN(input) ? null : input;
+  }
+  function shiftWeekdays(ws, n) {
+    return ws.slice(n, 7).concat(ws.slice(0, n));
+  }
+  var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
+  function localeWeekdays(m, format2) {
+    var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
+    return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;
+  }
+  function localeWeekdaysShort(m) {
+    return m === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m ? this._weekdaysShort[m.day()] : this._weekdaysShort;
+  }
+  function localeWeekdaysMin(m) {
+    return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin;
+  }
+  function handleStrictParse$1(weekdayName, format2, strict) {
+    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
+    if (!this._weekdaysParse) {
+      this._weekdaysParse = [];
+      this._shortWeekdaysParse = [];
+      this._minWeekdaysParse = [];
+      for (i = 0; i < 7; ++i) {
+        mom = createUTC([2e3, 1]).day(i);
+        this._minWeekdaysParse[i] = this.weekdaysMin(
+          mom,
+          ""
+        ).toLocaleLowerCase();
+        this._shortWeekdaysParse[i] = this.weekdaysShort(
+          mom,
+          ""
+        ).toLocaleLowerCase();
+        this._weekdaysParse[i] = this.weekdays(mom, "").toLocaleLowerCase();
+      }
+    }
+    if (strict) {
+      if (format2 === "dddd") {
+        ii = indexOf.call(this._weekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      } else if (format2 === "ddd") {
+        ii = indexOf.call(this._shortWeekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      } else {
+        ii = indexOf.call(this._minWeekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      }
+    } else {
+      if (format2 === "dddd") {
+        ii = indexOf.call(this._weekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._shortWeekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._minWeekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      } else if (format2 === "ddd") {
+        ii = indexOf.call(this._shortWeekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._weekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._minWeekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      } else {
+        ii = indexOf.call(this._minWeekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._weekdaysParse, llc);
+        if (ii !== -1) {
+          return ii;
+        }
+        ii = indexOf.call(this._shortWeekdaysParse, llc);
+        return ii !== -1 ? ii : null;
+      }
+    }
+  }
+  function localeWeekdaysParse(weekdayName, format2, strict) {
+    var i, mom, regex;
+    if (this._weekdaysParseExact) {
+      return handleStrictParse$1.call(this, weekdayName, format2, strict);
+    }
+    if (!this._weekdaysParse) {
+      this._weekdaysParse = [];
+      this._minWeekdaysParse = [];
+      this._shortWeekdaysParse = [];
+      this._fullWeekdaysParse = [];
+    }
+    for (i = 0; i < 7; i++) {
+      mom = createUTC([2e3, 1]).day(i);
+      if (strict && !this._fullWeekdaysParse[i]) {
+        this._fullWeekdaysParse[i] = new RegExp(
+          "^" + this.weekdays(mom, "").replace(".", "\\.?") + "$",
+          "i"
+        );
+        this._shortWeekdaysParse[i] = new RegExp(
+          "^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$",
+          "i"
+        );
+        this._minWeekdaysParse[i] = new RegExp(
+          "^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$",
+          "i"
+        );
+      }
+      if (!this._weekdaysParse[i]) {
+        regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, "");
+        this._weekdaysParse[i] = new RegExp(regex.replace(".", ""), "i");
+      }
+      if (strict && format2 === "dddd" && this._fullWeekdaysParse[i].test(weekdayName)) {
+        return i;
+      } else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i].test(weekdayName)) {
+        return i;
+      } else if (strict && format2 === "dd" && this._minWeekdaysParse[i].test(weekdayName)) {
+        return i;
+      } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+        return i;
+      }
+    }
+  }
+  function getSetDayOfWeek(input) {
+    if (!this.isValid()) {
+      return input != null ? this : NaN;
+    }
+    var day = get(this, "Day");
+    if (input != null) {
+      input = parseWeekday(input, this.localeData());
+      return this.add(input - day, "d");
+    } else {
+      return day;
+    }
+  }
+  function getSetLocaleDayOfWeek(input) {
+    if (!this.isValid()) {
+      return input != null ? this : NaN;
+    }
+    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+    return input == null ? weekday : this.add(input - weekday, "d");
+  }
+  function getSetISODayOfWeek(input) {
+    if (!this.isValid()) {
+      return input != null ? this : NaN;
+    }
+    if (input != null) {
+      var weekday = parseIsoWeekday(input, this.localeData());
+      return this.day(this.day() % 7 ? weekday : weekday - 7);
+    } else {
+      return this.day() || 7;
+    }
+  }
+  function weekdaysRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+      if (!hasOwnProp(this, "_weekdaysRegex")) {
+        computeWeekdaysParse.call(this);
+      }
+      if (isStrict) {
+        return this._weekdaysStrictRegex;
+      } else {
+        return this._weekdaysRegex;
+      }
+    } else {
+      if (!hasOwnProp(this, "_weekdaysRegex")) {
+        this._weekdaysRegex = defaultWeekdaysRegex;
+      }
+      return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
+    }
+  }
+  function weekdaysShortRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+      if (!hasOwnProp(this, "_weekdaysRegex")) {
+        computeWeekdaysParse.call(this);
+      }
+      if (isStrict) {
+        return this._weekdaysShortStrictRegex;
+      } else {
+        return this._weekdaysShortRegex;
+      }
+    } else {
+      if (!hasOwnProp(this, "_weekdaysShortRegex")) {
+        this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+      }
+      return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
+    }
+  }
+  function weekdaysMinRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+      if (!hasOwnProp(this, "_weekdaysRegex")) {
+        computeWeekdaysParse.call(this);
+      }
+      if (isStrict) {
+        return this._weekdaysMinStrictRegex;
+      } else {
+        return this._weekdaysMinRegex;
+      }
+    } else {
+      if (!hasOwnProp(this, "_weekdaysMinRegex")) {
+        this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+      }
+      return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
+    }
+  }
+  function computeWeekdaysParse() {
+    function cmpLenRev(a, b) {
+      return b.length - a.length;
+    }
+    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp;
+    for (i = 0; i < 7; i++) {
+      mom = createUTC([2e3, 1]).day(i);
+      minp = regexEscape(this.weekdaysMin(mom, ""));
+      shortp = regexEscape(this.weekdaysShort(mom, ""));
+      longp = regexEscape(this.weekdays(mom, ""));
+      minPieces.push(minp);
+      shortPieces.push(shortp);
+      longPieces.push(longp);
+      mixedPieces.push(minp);
+      mixedPieces.push(shortp);
+      mixedPieces.push(longp);
+    }
+    minPieces.sort(cmpLenRev);
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+    this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
+    this._weekdaysShortRegex = this._weekdaysRegex;
+    this._weekdaysMinRegex = this._weekdaysRegex;
+    this._weekdaysStrictRegex = new RegExp(
+      "^(" + longPieces.join("|") + ")",
+      "i"
+    );
+    this._weekdaysShortStrictRegex = new RegExp(
+      "^(" + shortPieces.join("|") + ")",
+      "i"
+    );
+    this._weekdaysMinStrictRegex = new RegExp(
+      "^(" + minPieces.join("|") + ")",
+      "i"
+    );
+  }
+  function hFormat() {
+    return this.hours() % 12 || 12;
+  }
+  function kFormat() {
+    return this.hours() || 24;
+  }
+  addFormatToken("H", ["HH", 2], 0, "hour");
+  addFormatToken("h", ["hh", 2], 0, hFormat);
+  addFormatToken("k", ["kk", 2], 0, kFormat);
+  addFormatToken("hmm", 0, 0, function() {
+    return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+  });
+  addFormatToken("hmmss", 0, 0, function() {
+    return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
+  });
+  addFormatToken("Hmm", 0, 0, function() {
+    return "" + this.hours() + zeroFill(this.minutes(), 2);
+  });
+  addFormatToken("Hmmss", 0, 0, function() {
+    return "" + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
+  });
+  function meridiem(token2, lowercase) {
+    addFormatToken(token2, 0, 0, function() {
+      return this.localeData().meridiem(
+        this.hours(),
+        this.minutes(),
+        lowercase
+      );
+    });
+  }
+  meridiem("a", true);
+  meridiem("A", false);
+  function matchMeridiem(isStrict, locale2) {
+    return locale2._meridiemParse;
+  }
+  addRegexToken("a", matchMeridiem);
+  addRegexToken("A", matchMeridiem);
+  addRegexToken("H", match1to2, match1to2HasZero);
+  addRegexToken("h", match1to2, match1to2NoLeadingZero);
+  addRegexToken("k", match1to2, match1to2NoLeadingZero);
+  addRegexToken("HH", match1to2, match2);
+  addRegexToken("hh", match1to2, match2);
+  addRegexToken("kk", match1to2, match2);
+  addRegexToken("hmm", match3to4);
+  addRegexToken("hmmss", match5to6);
+  addRegexToken("Hmm", match3to4);
+  addRegexToken("Hmmss", match5to6);
+  addParseToken(["H", "HH"], HOUR);
+  addParseToken(["k", "kk"], function(input, array, config) {
+    var kInput = toInt(input);
+    array[HOUR] = kInput === 24 ? 0 : kInput;
+  });
+  addParseToken(["a", "A"], function(input, array, config) {
+    config._isPm = config._locale.isPM(input);
+    config._meridiem = input;
+  });
+  addParseToken(["h", "hh"], function(input, array, config) {
+    array[HOUR] = toInt(input);
+    getParsingFlags(config).bigHour = true;
+  });
+  addParseToken("hmm", function(input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+    getParsingFlags(config).bigHour = true;
+  });
+  addParseToken("hmmss", function(input, array, config) {
+    var pos1 = input.length - 4, pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+    getParsingFlags(config).bigHour = true;
+  });
+  addParseToken("Hmm", function(input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+  });
+  addParseToken("Hmmss", function(input, array, config) {
+    var pos1 = input.length - 4, pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+  });
+  function localeIsPM(input) {
+    return (input + "").toLowerCase().charAt(0) === "p";
+  }
+  var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true);
+  function localeMeridiem(hours2, minutes2, isLower) {
+    if (hours2 > 11) {
+      return isLower ? "pm" : "PM";
+    } else {
+      return isLower ? "am" : "AM";
+    }
+  }
+  var baseConfig = {
+    calendar: defaultCalendar,
+    longDateFormat: defaultLongDateFormat,
+    invalidDate: defaultInvalidDate,
+    ordinal: defaultOrdinal,
+    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+    relativeTime: defaultRelativeTime,
+    months: defaultLocaleMonths,
+    monthsShort: defaultLocaleMonthsShort,
+    week: defaultLocaleWeek,
+    weekdays: defaultLocaleWeekdays,
+    weekdaysMin: defaultLocaleWeekdaysMin,
+    weekdaysShort: defaultLocaleWeekdaysShort,
+    meridiemParse: defaultLocaleMeridiemParse
+  };
+  var locales = {}, localeFamilies = {}, globalLocale;
+  function commonPrefix(arr1, arr2) {
+    var i, minl = Math.min(arr1.length, arr2.length);
+    for (i = 0; i < minl; i += 1) {
+      if (arr1[i] !== arr2[i]) {
+        return i;
+      }
+    }
+    return minl;
+  }
+  function normalizeLocale(key) {
+    return key ? key.toLowerCase().replace("_", "-") : key;
+  }
+  function chooseLocale(names) {
+    var i = 0, j, next, locale2, split;
+    while (i < names.length) {
+      split = normalizeLocale(names[i]).split("-");
+      j = split.length;
+      next = normalizeLocale(names[i + 1]);
+      next = next ? next.split("-") : null;
+      while (j > 0) {
+        locale2 = loadLocale(split.slice(0, j).join("-"));
+        if (locale2) {
+          return locale2;
+        }
+        if (next && next.length >= j && commonPrefix(split, next) >= j - 1) {
+          break;
+        }
+        j--;
+      }
+      i++;
+    }
+    return globalLocale;
+  }
+  function isLocaleNameSane(name) {
+    return !!(name && name.match("^[^/\\\\]*$"));
+  }
+  function loadLocale(name) {
+    var oldLocale = null, aliasedRequire;
+    if (locales[name] === void 0 && typeof module !== "undefined" && module && module.exports && isLocaleNameSane(name)) {
+      try {
+        oldLocale = globalLocale._abbr;
+        aliasedRequire = require;
+        aliasedRequire("./locale/" + name);
+        getSetGlobalLocale(oldLocale);
+      } catch (e) {
+        locales[name] = null;
+      }
+    }
+    return locales[name];
+  }
+  function getSetGlobalLocale(key, values) {
+    var data;
+    if (key) {
+      if (isUndefined(values)) {
+        data = getLocale(key);
+      } else {
+        data = defineLocale(key, values);
+      }
+      if (data) {
+        globalLocale = data;
+      } else {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(
+            "Locale " + key + " not found. Did you forget to load it?"
+          );
+        }
+      }
+    }
+    return globalLocale._abbr;
+  }
+  function defineLocale(name, config) {
+    if (config !== null) {
+      var locale2, parentConfig = baseConfig;
+      config.abbr = name;
+      if (locales[name] != null) {
+        deprecateSimple(
+          "defineLocaleOverride",
+          "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."
+        );
+        parentConfig = locales[name]._config;
+      } else if (config.parentLocale != null) {
+        if (locales[config.parentLocale] != null) {
+          parentConfig = locales[config.parentLocale]._config;
+        } else {
+          locale2 = loadLocale(config.parentLocale);
+          if (locale2 != null) {
+            parentConfig = locale2._config;
+          } else {
+            if (!localeFamilies[config.parentLocale]) {
+              localeFamilies[config.parentLocale] = [];
+            }
+            localeFamilies[config.parentLocale].push({
+              name,
+              config
+            });
+            return null;
+          }
+        }
+      }
+      locales[name] = new Locale(mergeConfigs(parentConfig, config));
+      if (localeFamilies[name]) {
+        localeFamilies[name].forEach(function(x) {
+          defineLocale(x.name, x.config);
+        });
+      }
+      getSetGlobalLocale(name);
+      return locales[name];
+    } else {
+      delete locales[name];
+      return null;
+    }
+  }
+  function updateLocale(name, config) {
+    if (config != null) {
+      var locale2, tmpLocale, parentConfig = baseConfig;
+      if (locales[name] != null && locales[name].parentLocale != null) {
+        locales[name].set(mergeConfigs(locales[name]._config, config));
+      } else {
+        tmpLocale = loadLocale(name);
+        if (tmpLocale != null) {
+          parentConfig = tmpLocale._config;
+        }
+        config = mergeConfigs(parentConfig, config);
+        if (tmpLocale == null) {
+          config.abbr = name;
+        }
+        locale2 = new Locale(config);
+        locale2.parentLocale = locales[name];
+        locales[name] = locale2;
+      }
+      getSetGlobalLocale(name);
+    } else {
+      if (locales[name] != null) {
+        if (locales[name].parentLocale != null) {
+          locales[name] = locales[name].parentLocale;
+          if (name === getSetGlobalLocale()) {
+            getSetGlobalLocale(name);
+          }
+        } else if (locales[name] != null) {
+          delete locales[name];
+        }
+      }
+    }
+    return locales[name];
+  }
+  function getLocale(key) {
+    var locale2;
+    if (key && key._locale && key._locale._abbr) {
+      key = key._locale._abbr;
+    }
+    if (!key) {
+      return globalLocale;
+    }
+    if (!isArray(key)) {
+      locale2 = loadLocale(key);
+      if (locale2) {
+        return locale2;
+      }
+      key = [key];
+    }
+    return chooseLocale(key);
+  }
+  function listLocales() {
+    return keys(locales);
+  }
+  function checkOverflow(m) {
+    var overflow, a = m._a;
+    if (a && getParsingFlags(m).overflow === -2) {
+      overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
+      if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+        overflow = DATE;
+      }
+      if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+        overflow = WEEK;
+      }
+      if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+        overflow = WEEKDAY;
+      }
+      getParsingFlags(m).overflow = overflow;
+    }
+    return m;
+  }
+  var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [
+    ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
+    ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
+    ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
+    ["GGGG-[W]WW", /\d{4}-W\d\d/, false],
+    ["YYYY-DDD", /\d{4}-\d{3}/],
+    ["YYYY-MM", /\d{4}-\d\d/, false],
+    ["YYYYYYMMDD", /[+-]\d{10}/],
+    ["YYYYMMDD", /\d{8}/],
+    ["GGGG[W]WWE", /\d{4}W\d{3}/],
+    ["GGGG[W]WW", /\d{4}W\d{2}/, false],
+    ["YYYYDDD", /\d{7}/],
+    ["YYYYMM", /\d{6}/, false],
+    ["YYYY", /\d{4}/, false]
+  ], isoTimes = [
+    ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
+    ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
+    ["HH:mm:ss", /\d\d:\d\d:\d\d/],
+    ["HH:mm", /\d\d:\d\d/],
+    ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
+    ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
+    ["HHmmss", /\d\d\d\d\d\d/],
+    ["HHmm", /\d\d\d\d/],
+    ["HH", /\d\d/]
+  ], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, obsOffsets = {
+    UT: 0,
+    GMT: 0,
+    EDT: -4 * 60,
+    EST: -5 * 60,
+    CDT: -5 * 60,
+    CST: -6 * 60,
+    MDT: -6 * 60,
+    MST: -7 * 60,
+    PDT: -7 * 60,
+    PST: -8 * 60
+  };
+  function configFromISO(config) {
+    var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
+    if (match) {
+      getParsingFlags(config).iso = true;
+      for (i = 0, l = isoDatesLen; i < l; i++) {
+        if (isoDates[i][1].exec(match[1])) {
+          dateFormat = isoDates[i][0];
+          allowTime = isoDates[i][2] !== false;
+          break;
+        }
+      }
+      if (dateFormat == null) {
+        config._isValid = false;
+        return;
+      }
+      if (match[3]) {
+        for (i = 0, l = isoTimesLen; i < l; i++) {
+          if (isoTimes[i][1].exec(match[3])) {
+            timeFormat = (match[2] || " ") + isoTimes[i][0];
+            break;
+          }
+        }
+        if (timeFormat == null) {
+          config._isValid = false;
+          return;
+        }
+      }
+      if (!allowTime && timeFormat != null) {
+        config._isValid = false;
+        return;
+      }
+      if (match[4]) {
+        if (tzRegex.exec(match[4])) {
+          tzFormat = "Z";
+        } else {
+          config._isValid = false;
+          return;
+        }
+      }
+      config._f = dateFormat + (timeFormat || "") + (tzFormat || "");
+      configFromStringAndFormat(config);
+    } else {
+      config._isValid = false;
+    }
+  }
+  function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+    var result = [
+      untruncateYear(yearStr),
+      defaultLocaleMonthsShort.indexOf(monthStr),
+      parseInt(dayStr, 10),
+      parseInt(hourStr, 10),
+      parseInt(minuteStr, 10)
+    ];
+    if (secondStr) {
+      result.push(parseInt(secondStr, 10));
+    }
+    return result;
+  }
+  function untruncateYear(yearStr) {
+    var year = parseInt(yearStr, 10);
+    if (year <= 49) {
+      return 2e3 + year;
+    } else if (year <= 999) {
+      return 1900 + year;
+    }
+    return year;
+  }
+  function preprocessRFC2822(s) {
+    return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
+  }
+  function checkWeekday(weekdayStr, parsedInput, config) {
+    if (weekdayStr) {
+      var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(
+        parsedInput[0],
+        parsedInput[1],
+        parsedInput[2]
+      ).getDay();
+      if (weekdayProvided !== weekdayActual) {
+        getParsingFlags(config).weekdayMismatch = true;
+        config._isValid = false;
+        return false;
+      }
+    }
+    return true;
+  }
+  function calculateOffset(obsOffset, militaryOffset, numOffset) {
+    if (obsOffset) {
+      return obsOffsets[obsOffset];
+    } else if (militaryOffset) {
+      return 0;
+    } else {
+      var hm = parseInt(numOffset, 10), m = hm % 100, h = (hm - m) / 100;
+      return h * 60 + m;
+    }
+  }
+  function configFromRFC2822(config) {
+    var match = rfc2822.exec(preprocessRFC2822(config._i)), parsedArray;
+    if (match) {
+      parsedArray = extractFromRFC2822Strings(
+        match[4],
+        match[3],
+        match[2],
+        match[5],
+        match[6],
+        match[7]
+      );
+      if (!checkWeekday(match[1], parsedArray, config)) {
+        return;
+      }
+      config._a = parsedArray;
+      config._tzm = calculateOffset(match[8], match[9], match[10]);
+      config._d = createUTCDate.apply(null, config._a);
+      config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+      getParsingFlags(config).rfc2822 = true;
+    } else {
+      config._isValid = false;
+    }
+  }
+  function configFromString(config) {
+    var matched = aspNetJsonRegex.exec(config._i);
+    if (matched !== null) {
+      config._d = /* @__PURE__ */ new Date(+matched[1]);
+      return;
+    }
+    configFromISO(config);
+    if (config._isValid === false) {
+      delete config._isValid;
+    } else {
+      return;
+    }
+    configFromRFC2822(config);
+    if (config._isValid === false) {
+      delete config._isValid;
+    } else {
+      return;
+    }
+    if (config._strict) {
+      config._isValid = false;
+    } else {
+      hooks.createFromInputFallback(config);
+    }
+  }
+  hooks.createFromInputFallback = deprecate(
+    "value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",
+    function(config) {
+      config._d = /* @__PURE__ */ new Date(config._i + (config._useUTC ? " UTC" : ""));
+    }
+  );
+  function defaults(a, b, c) {
+    if (a != null) {
+      return a;
+    }
+    if (b != null) {
+      return b;
+    }
+    return c;
+  }
+  function currentDateArray(config) {
+    var nowValue = new Date(hooks.now());
+    if (config._useUTC) {
+      return [
+        nowValue.getUTCFullYear(),
+        nowValue.getUTCMonth(),
+        nowValue.getUTCDate()
+      ];
+    }
+    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+  }
+  function configFromArray(config) {
+    var i, date, input = [], currentDate, expectedWeekday, yearToUse;
+    if (config._d) {
+      return;
+    }
+    currentDate = currentDateArray(config);
+    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+      dayOfYearFromWeekInfo(config);
+    }
+    if (config._dayOfYear != null) {
+      yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+      if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+        getParsingFlags(config)._overflowDayOfYear = true;
+      }
+      date = createUTCDate(yearToUse, 0, config._dayOfYear);
+      config._a[MONTH] = date.getUTCMonth();
+      config._a[DATE] = date.getUTCDate();
+    }
+    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+      config._a[i] = input[i] = currentDate[i];
+    }
+    for (; i < 7; i++) {
+      config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i];
+    }
+    if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
+      config._nextDay = true;
+      config._a[HOUR] = 0;
+    }
+    config._d = (config._useUTC ? createUTCDate : createDate).apply(
+      null,
+      input
+    );
+    expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
+    if (config._tzm != null) {
+      config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    }
+    if (config._nextDay) {
+      config._a[HOUR] = 24;
+    }
+    if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) {
+      getParsingFlags(config).weekdayMismatch = true;
+    }
+  }
+  function dayOfYearFromWeekInfo(config) {
+    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
+    w = config._w;
+    if (w.GG != null || w.W != null || w.E != null) {
+      dow = 1;
+      doy = 4;
+      weekYear = defaults(
+        w.GG,
+        config._a[YEAR],
+        weekOfYear(createLocal(), 1, 4).year
+      );
+      week = defaults(w.W, 1);
+      weekday = defaults(w.E, 1);
+      if (weekday < 1 || weekday > 7) {
+        weekdayOverflow = true;
+      }
+    } else {
+      dow = config._locale._week.dow;
+      doy = config._locale._week.doy;
+      curWeek = weekOfYear(createLocal(), dow, doy);
+      weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+      week = defaults(w.w, curWeek.week);
+      if (w.d != null) {
+        weekday = w.d;
+        if (weekday < 0 || weekday > 6) {
+          weekdayOverflow = true;
+        }
+      } else if (w.e != null) {
+        weekday = w.e + dow;
+        if (w.e < 0 || w.e > 6) {
+          weekdayOverflow = true;
+        }
+      } else {
+        weekday = dow;
+      }
+    }
+    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+      getParsingFlags(config)._overflowWeeks = true;
+    } else if (weekdayOverflow != null) {
+      getParsingFlags(config)._overflowWeekday = true;
+    } else {
+      temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+      config._a[YEAR] = temp.year;
+      config._dayOfYear = temp.dayOfYear;
+    }
+  }
+  hooks.ISO_8601 = function() {
+  };
+  hooks.RFC_2822 = function() {
+  };
+  function configFromStringAndFormat(config) {
+    if (config._f === hooks.ISO_8601) {
+      configFromISO(config);
+      return;
+    }
+    if (config._f === hooks.RFC_2822) {
+      configFromRFC2822(config);
+      return;
+    }
+    config._a = [];
+    getParsingFlags(config).empty = true;
+    var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
+    tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+    tokenLen = tokens2.length;
+    for (i = 0; i < tokenLen; i++) {
+      token2 = tokens2[i];
+      parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0];
+      if (parsedInput) {
+        skipped = string.substr(0, string.indexOf(parsedInput));
+        if (skipped.length > 0) {
+          getParsingFlags(config).unusedInput.push(skipped);
+        }
+        string = string.slice(
+          string.indexOf(parsedInput) + parsedInput.length
+        );
+        totalParsedInputLength += parsedInput.length;
+      }
+      if (formatTokenFunctions[token2]) {
+        if (parsedInput) {
+          getParsingFlags(config).empty = false;
+        } else {
+          getParsingFlags(config).unusedTokens.push(token2);
+        }
+        addTimeToArrayFromToken(token2, parsedInput, config);
+      } else if (config._strict && !parsedInput) {
+        getParsingFlags(config).unusedTokens.push(token2);
+      }
+    }
+    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
+    if (string.length > 0) {
+      getParsingFlags(config).unusedInput.push(string);
+    }
+    if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
+      getParsingFlags(config).bigHour = void 0;
+    }
+    getParsingFlags(config).parsedDateParts = config._a.slice(0);
+    getParsingFlags(config).meridiem = config._meridiem;
+    config._a[HOUR] = meridiemFixWrap(
+      config._locale,
+      config._a[HOUR],
+      config._meridiem
+    );
+    era = getParsingFlags(config).era;
+    if (era !== null) {
+      config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
+    }
+    configFromArray(config);
+    checkOverflow(config);
+  }
+  function meridiemFixWrap(locale2, hour, meridiem2) {
+    var isPm;
+    if (meridiem2 == null) {
+      return hour;
+    }
+    if (locale2.meridiemHour != null) {
+      return locale2.meridiemHour(hour, meridiem2);
+    } else if (locale2.isPM != null) {
+      isPm = locale2.isPM(meridiem2);
+      if (isPm && hour < 12) {
+        hour += 12;
+      }
+      if (!isPm && hour === 12) {
+        hour = 0;
+      }
+      return hour;
+    } else {
+      return hour;
+    }
+  }
+  function configFromStringAndArray(config) {
+    var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
+    if (configfLen === 0) {
+      getParsingFlags(config).invalidFormat = true;
+      config._d = /* @__PURE__ */ new Date(NaN);
+      return;
+    }
+    for (i = 0; i < configfLen; i++) {
+      currentScore = 0;
+      validFormatFound = false;
+      tempConfig = copyConfig({}, config);
+      if (config._useUTC != null) {
+        tempConfig._useUTC = config._useUTC;
+      }
+      tempConfig._f = config._f[i];
+      configFromStringAndFormat(tempConfig);
+      if (isValid(tempConfig)) {
+        validFormatFound = true;
+      }
+      currentScore += getParsingFlags(tempConfig).charsLeftOver;
+      currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+      getParsingFlags(tempConfig).score = currentScore;
+      if (!bestFormatIsValid) {
+        if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {
+          scoreToBeat = currentScore;
+          bestMoment = tempConfig;
+          if (validFormatFound) {
+            bestFormatIsValid = true;
+          }
+        }
+      } else {
+        if (currentScore < scoreToBeat) {
+          scoreToBeat = currentScore;
+          bestMoment = tempConfig;
+        }
+      }
+    }
+    extend(config, bestMoment || tempConfig);
+  }
+  function configFromObject(config) {
+    if (config._d) {
+      return;
+    }
+    var i = normalizeObjectUnits(config._i), dayOrDate = i.day === void 0 ? i.date : i.day;
+    config._a = map(
+      [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
+      function(obj) {
+        return obj && parseInt(obj, 10);
+      }
+    );
+    configFromArray(config);
+  }
+  function createFromConfig(config) {
+    var res = new Moment(checkOverflow(prepareConfig(config)));
+    if (res._nextDay) {
+      res.add(1, "d");
+      res._nextDay = void 0;
+    }
+    return res;
+  }
+  function prepareConfig(config) {
+    var input = config._i, format2 = config._f;
+    config._locale = config._locale || getLocale(config._l);
+    if (input === null || format2 === void 0 && input === "") {
+      return createInvalid({ nullInput: true });
+    }
+    if (typeof input === "string") {
+      config._i = input = config._locale.preparse(input);
+    }
+    if (isMoment(input)) {
+      return new Moment(checkOverflow(input));
+    } else if (isDate(input)) {
+      config._d = input;
+    } else if (isArray(format2)) {
+      configFromStringAndArray(config);
+    } else if (format2) {
+      configFromStringAndFormat(config);
+    } else {
+      configFromInput(config);
+    }
+    if (!isValid(config)) {
+      config._d = null;
+    }
+    return config;
+  }
+  function configFromInput(config) {
+    var input = config._i;
+    if (isUndefined(input)) {
+      config._d = new Date(hooks.now());
+    } else if (isDate(input)) {
+      config._d = new Date(input.valueOf());
+    } else if (typeof input === "string") {
+      configFromString(config);
+    } else if (isArray(input)) {
+      config._a = map(input.slice(0), function(obj) {
+        return parseInt(obj, 10);
+      });
+      configFromArray(config);
+    } else if (isObject(input)) {
+      configFromObject(config);
+    } else if (isNumber(input)) {
+      config._d = new Date(input);
+    } else {
+      hooks.createFromInputFallback(config);
+    }
+  }
+  function createLocalOrUTC(input, format2, locale2, strict, isUTC) {
+    var c = {};
+    if (format2 === true || format2 === false) {
+      strict = format2;
+      format2 = void 0;
+    }
+    if (locale2 === true || locale2 === false) {
+      strict = locale2;
+      locale2 = void 0;
+    }
+    if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {
+      input = void 0;
+    }
+    c._isAMomentObject = true;
+    c._useUTC = c._isUTC = isUTC;
+    c._l = locale2;
+    c._i = input;
+    c._f = format2;
+    c._strict = strict;
+    return createFromConfig(c);
+  }
+  function createLocal(input, format2, locale2, strict) {
+    return createLocalOrUTC(input, format2, locale2, strict, false);
+  }
+  var prototypeMin = deprecate(
+    "moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
+    function() {
+      var other = createLocal.apply(null, arguments);
+      if (this.isValid() && other.isValid()) {
+        return other < this ? this : other;
+      } else {
+        return createInvalid();
+      }
+    }
+  ), prototypeMax = deprecate(
+    "moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
+    function() {
+      var other = createLocal.apply(null, arguments);
+      if (this.isValid() && other.isValid()) {
+        return other > this ? this : other;
+      } else {
+        return createInvalid();
+      }
+    }
+  );
+  function pickBy(fn, moments) {
+    var res, i;
+    if (moments.length === 1 && isArray(moments[0])) {
+      moments = moments[0];
+    }
+    if (!moments.length) {
+      return createLocal();
+    }
+    res = moments[0];
+    for (i = 1; i < moments.length; ++i) {
+      if (!moments[i].isValid() || moments[i][fn](res)) {
+        res = moments[i];
+      }
+    }
+    return res;
+  }
+  function min() {
+    var args = [].slice.call(arguments, 0);
+    return pickBy("isBefore", args);
+  }
+  function max() {
+    var args = [].slice.call(arguments, 0);
+    return pickBy("isAfter", args);
+  }
+  var now = function() {
+    return Date.now ? Date.now() : +/* @__PURE__ */ new Date();
+  };
+  var ordering = [
+    "year",
+    "quarter",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second",
+    "millisecond"
+  ];
+  function isDurationValid(m) {
+    var key, unitHasDecimal = false, i, orderLen = ordering.length;
+    for (key in m) {
+      if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
+        return false;
+      }
+    }
+    for (i = 0; i < orderLen; ++i) {
+      if (m[ordering[i]]) {
+        if (unitHasDecimal) {
+          return false;
+        }
+        if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+          unitHasDecimal = true;
+        }
+      }
+    }
+    return true;
+  }
+  function isValid$1() {
+    return this._isValid;
+  }
+  function createInvalid$1() {
+    return createDuration(NaN);
+  }
+  function Duration(duration) {
+    var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0;
+    this._isValid = isDurationValid(normalizedInput);
+    this._milliseconds = +milliseconds2 + seconds2 * 1e3 + // 1000
+    minutes2 * 6e4 + // 1000 * 60
+    hours2 * 1e3 * 60 * 60;
+    this._days = +days2 + weeks2 * 7;
+    this._months = +months2 + quarters * 3 + years2 * 12;
+    this._data = {};
+    this._locale = getLocale();
+    this._bubble();
+  }
+  function isDuration(obj) {
+    return obj instanceof Duration;
+  }
+  function absRound(number2) {
+    if (number2 < 0) {
+      return Math.round(-1 * number2) * -1;
+    } else {
+      return Math.round(number2);
+    }
+  }
+  function compareArrays(array1, array2, dontConvert) {
+    var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i;
+    for (i = 0; i < len; i++) {
+      if (toInt(array1[i]) !== toInt(array2[i])) {
+        diffs++;
+      }
+    }
+    return diffs + lengthDiff;
+  }
+  function offset(token2, separator) {
+    addFormatToken(token2, 0, 0, function() {
+      var offset2 = this.utcOffset(), sign2 = "+";
+      if (offset2 < 0) {
+        offset2 = -offset2;
+        sign2 = "-";
+      }
+      return sign2 + zeroFill(~~(offset2 / 60), 2) + separator + zeroFill(~~offset2 % 60, 2);
+    });
+  }
+  offset("Z", ":");
+  offset("ZZ", "");
+  addRegexToken("Z", matchShortOffset);
+  addRegexToken("ZZ", matchShortOffset);
+  addParseToken(["Z", "ZZ"], function(input, array, config) {
+    config._useUTC = true;
+    config._tzm = offsetFromString(matchShortOffset, input);
+  });
+  var chunkOffset = /([\+\-]|\d\d)/gi;
+  function offsetFromString(matcher, string) {
+    var matches = (string || "").match(matcher), chunk, parts, minutes2;
+    if (matches === null) {
+      return null;
+    }
+    chunk = matches[matches.length - 1] || [];
+    parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
+    minutes2 = +(parts[1] * 60) + toInt(parts[2]);
+    return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
+  }
+  function cloneWithOffset(input, model) {
+    var res, diff2;
+    if (model._isUTC) {
+      res = model.clone();
+      diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
+      res._d.setTime(res._d.valueOf() + diff2);
+      hooks.updateOffset(res, false);
+      return res;
+    } else {
+      return createLocal(input).local();
+    }
+  }
+  function getDateOffset(m) {
+    return -Math.round(m._d.getTimezoneOffset());
+  }
+  hooks.updateOffset = function() {
+  };
+  function getSetOffset(input, keepLocalTime, keepMinutes) {
+    var offset2 = this._offset || 0, localAdjust;
+    if (!this.isValid()) {
+      return input != null ? this : NaN;
+    }
+    if (input != null) {
+      if (typeof input === "string") {
+        input = offsetFromString(matchShortOffset, input);
+        if (input === null) {
+          return this;
+        }
+      } else if (Math.abs(input) < 16 && !keepMinutes) {
+        input = input * 60;
+      }
+      if (!this._isUTC && keepLocalTime) {
+        localAdjust = getDateOffset(this);
+      }
+      this._offset = input;
+      this._isUTC = true;
+      if (localAdjust != null) {
+        this.add(localAdjust, "m");
+      }
+      if (offset2 !== input) {
+        if (!keepLocalTime || this._changeInProgress) {
+          addSubtract(
+            this,
+            createDuration(input - offset2, "m"),
+            1,
+            false
+          );
+        } else if (!this._changeInProgress) {
+          this._changeInProgress = true;
+          hooks.updateOffset(this, true);
+          this._changeInProgress = null;
+        }
+      }
+      return this;
+    } else {
+      return this._isUTC ? offset2 : getDateOffset(this);
+    }
+  }
+  function getSetZone(input, keepLocalTime) {
+    if (input != null) {
+      if (typeof input !== "string") {
+        input = -input;
+      }
+      this.utcOffset(input, keepLocalTime);
+      return this;
+    } else {
+      return -this.utcOffset();
+    }
+  }
+  function setOffsetToUTC(keepLocalTime) {
+    return this.utcOffset(0, keepLocalTime);
+  }
+  function setOffsetToLocal(keepLocalTime) {
+    if (this._isUTC) {
+      this.utcOffset(0, keepLocalTime);
+      this._isUTC = false;
+      if (keepLocalTime) {
+        this.subtract(getDateOffset(this), "m");
+      }
+    }
+    return this;
+  }
+  function setOffsetToParsedOffset() {
+    if (this._tzm != null) {
+      this.utcOffset(this._tzm, false, true);
+    } else if (typeof this._i === "string") {
+      var tZone = offsetFromString(matchOffset, this._i);
+      if (tZone != null) {
+        this.utcOffset(tZone);
+      } else {
+        this.utcOffset(0, true);
+      }
+    }
+    return this;
+  }
+  function hasAlignedHourOffset(input) {
+    if (!this.isValid()) {
+      return false;
+    }
+    input = input ? createLocal(input).utcOffset() : 0;
+    return (this.utcOffset() - input) % 60 === 0;
+  }
+  function isDaylightSavingTime() {
+    return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();
+  }
+  function isDaylightSavingTimeShifted() {
+    if (!isUndefined(this._isDSTShifted)) {
+      return this._isDSTShifted;
+    }
+    var c = {}, other;
+    copyConfig(c, this);
+    c = prepareConfig(c);
+    if (c._a) {
+      other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+      this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0;
+    } else {
+      this._isDSTShifted = false;
+    }
+    return this._isDSTShifted;
+  }
+  function isLocal() {
+    return this.isValid() ? !this._isUTC : false;
+  }
+  function isUtcOffset() {
+    return this.isValid() ? this._isUTC : false;
+  }
+  function isUtc() {
+    return this.isValid() ? this._isUTC && this._offset === 0 : false;
+  }
+  var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+  function createDuration(input, key) {
+    var duration = input, match = null, sign2, ret, diffRes;
+    if (isDuration(input)) {
+      duration = {
+        ms: input._milliseconds,
+        d: input._days,
+        M: input._months
+      };
+    } else if (isNumber(input) || !isNaN(+input)) {
+      duration = {};
+      if (key) {
+        duration[key] = +input;
+      } else {
+        duration.milliseconds = +input;
+      }
+    } else if (match = aspNetRegex.exec(input)) {
+      sign2 = match[1] === "-" ? -1 : 1;
+      duration = {
+        y: 0,
+        d: toInt(match[DATE]) * sign2,
+        h: toInt(match[HOUR]) * sign2,
+        m: toInt(match[MINUTE]) * sign2,
+        s: toInt(match[SECOND]) * sign2,
+        ms: toInt(absRound(match[MILLISECOND] * 1e3)) * sign2
+        // the millisecond decimal point is included in the match
+      };
+    } else if (match = isoRegex.exec(input)) {
+      sign2 = match[1] === "-" ? -1 : 1;
+      duration = {
+        y: parseIso(match[2], sign2),
+        M: parseIso(match[3], sign2),
+        w: parseIso(match[4], sign2),
+        d: parseIso(match[5], sign2),
+        h: parseIso(match[6], sign2),
+        m: parseIso(match[7], sign2),
+        s: parseIso(match[8], sign2)
+      };
+    } else if (duration == null) {
+      duration = {};
+    } else if (typeof duration === "object" && ("from" in duration || "to" in duration)) {
+      diffRes = momentsDifference(
+        createLocal(duration.from),
+        createLocal(duration.to)
+      );
+      duration = {};
+      duration.ms = diffRes.milliseconds;
+      duration.M = diffRes.months;
+    }
+    ret = new Duration(duration);
+    if (isDuration(input) && hasOwnProp(input, "_locale")) {
+      ret._locale = input._locale;
+    }
+    if (isDuration(input) && hasOwnProp(input, "_isValid")) {
+      ret._isValid = input._isValid;
+    }
+    return ret;
+  }
+  createDuration.fn = Duration.prototype;
+  createDuration.invalid = createInvalid$1;
+  function parseIso(inp, sign2) {
+    var res = inp && parseFloat(inp.replace(",", "."));
+    return (isNaN(res) ? 0 : res) * sign2;
+  }
+  function positiveMomentsDifference(base, other) {
+    var res = {};
+    res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
+    if (base.clone().add(res.months, "M").isAfter(other)) {
+      --res.months;
+    }
+    res.milliseconds = +other - +base.clone().add(res.months, "M");
+    return res;
+  }
+  function momentsDifference(base, other) {
+    var res;
+    if (!(base.isValid() && other.isValid())) {
+      return { milliseconds: 0, months: 0 };
+    }
+    other = cloneWithOffset(other, base);
+    if (base.isBefore(other)) {
+      res = positiveMomentsDifference(base, other);
+    } else {
+      res = positiveMomentsDifference(other, base);
+      res.milliseconds = -res.milliseconds;
+      res.months = -res.months;
+    }
+    return res;
+  }
+  function createAdder(direction, name) {
+    return function(val, period) {
+      var dur, tmp;
+      if (period !== null && !isNaN(+period)) {
+        deprecateSimple(
+          name,
+          "moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
+        );
+        tmp = val;
+        val = period;
+        period = tmp;
+      }
+      dur = createDuration(val, period);
+      addSubtract(this, dur, direction);
+      return this;
+    };
+  }
+  function addSubtract(mom, duration, isAdding, updateOffset) {
+    var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
+    if (!mom.isValid()) {
+      return;
+    }
+    updateOffset = updateOffset == null ? true : updateOffset;
+    if (months2) {
+      setMonth(mom, get(mom, "Month") + months2 * isAdding);
+    }
+    if (days2) {
+      set$1(mom, "Date", get(mom, "Date") + days2 * isAdding);
+    }
+    if (milliseconds2) {
+      mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
+    }
+    if (updateOffset) {
+      hooks.updateOffset(mom, days2 || months2);
+    }
+  }
+  var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
+  function isString(input) {
+    return typeof input === "string" || input instanceof String;
+  }
+  function isMomentInput(input) {
+    return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0;
+  }
+  function isMomentInputObject(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
+      "years",
+      "year",
+      "y",
+      "months",
+      "month",
+      "M",
+      "days",
+      "day",
+      "d",
+      "dates",
+      "date",
+      "D",
+      "hours",
+      "hour",
+      "h",
+      "minutes",
+      "minute",
+      "m",
+      "seconds",
+      "second",
+      "s",
+      "milliseconds",
+      "millisecond",
+      "ms"
+    ], i, property, propertyLen = properties.length;
+    for (i = 0; i < propertyLen; i += 1) {
+      property = properties[i];
+      propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+    return objectTest && propertyTest;
+  }
+  function isNumberOrStringArray(input) {
+    var arrayTest = isArray(input), dataTypeTest = false;
+    if (arrayTest) {
+      dataTypeTest = input.filter(function(item) {
+        return !isNumber(item) && isString(input);
+      }).length === 0;
+    }
+    return arrayTest && dataTypeTest;
+  }
+  function isCalendarSpec(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
+      "sameDay",
+      "nextDay",
+      "lastDay",
+      "nextWeek",
+      "lastWeek",
+      "sameElse"
+    ], i, property;
+    for (i = 0; i < properties.length; i += 1) {
+      property = properties[i];
+      propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+    return objectTest && propertyTest;
+  }
+  function getCalendarFormat(myMoment, now2) {
+    var diff2 = myMoment.diff(now2, "days", true);
+    return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
+  }
+  function calendar$1(time2, formats) {
+    if (arguments.length === 1) {
+      if (!arguments[0]) {
+        time2 = void 0;
+        formats = void 0;
+      } else if (isMomentInput(arguments[0])) {
+        time2 = arguments[0];
+        formats = void 0;
+      } else if (isCalendarSpec(arguments[0])) {
+        formats = arguments[0];
+        time2 = void 0;
+      }
+    }
+    var now2 = time2 || createLocal(), sod = cloneWithOffset(now2, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now2) : formats[format2]);
+    return this.format(
+      output || this.localeData().calendar(format2, this, createLocal(now2))
+    );
+  }
+  function clone() {
+    return new Moment(this);
+  }
+  function isAfter(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+      return false;
+    }
+    units = normalizeUnits(units) || "millisecond";
+    if (units === "millisecond") {
+      return this.valueOf() > localInput.valueOf();
+    } else {
+      return localInput.valueOf() < this.clone().startOf(units).valueOf();
+    }
+  }
+  function isBefore(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+      return false;
+    }
+    units = normalizeUnits(units) || "millisecond";
+    if (units === "millisecond") {
+      return this.valueOf() < localInput.valueOf();
+    } else {
+      return this.clone().endOf(units).valueOf() < localInput.valueOf();
+    }
+  }
+  function isBetween(from2, to2, units, inclusivity) {
+    var localFrom = isMoment(from2) ? from2 : createLocal(from2), localTo = isMoment(to2) ? to2 : createLocal(to2);
+    if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
+      return false;
+    }
+    inclusivity = inclusivity || "()";
+    return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
+  }
+  function isSame(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input), inputMs;
+    if (!(this.isValid() && localInput.isValid())) {
+      return false;
+    }
+    units = normalizeUnits(units) || "millisecond";
+    if (units === "millisecond") {
+      return this.valueOf() === localInput.valueOf();
+    } else {
+      inputMs = localInput.valueOf();
+      return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
+    }
+  }
+  function isSameOrAfter(input, units) {
+    return this.isSame(input, units) || this.isAfter(input, units);
+  }
+  function isSameOrBefore(input, units) {
+    return this.isSame(input, units) || this.isBefore(input, units);
+  }
+  function diff(input, units, asFloat) {
+    var that, zoneDelta, output;
+    if (!this.isValid()) {
+      return NaN;
+    }
+    that = cloneWithOffset(input, this);
+    if (!that.isValid()) {
+      return NaN;
+    }
+    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+    units = normalizeUnits(units);
+    switch (units) {
+      case "year":
+        output = monthDiff(this, that) / 12;
+        break;
+      case "month":
+        output = monthDiff(this, that);
+        break;
+      case "quarter":
+        output = monthDiff(this, that) / 3;
+        break;
+      case "second":
+        output = (this - that) / 1e3;
+        break;
+      // 1000
+      case "minute":
+        output = (this - that) / 6e4;
+        break;
+      // 1000 * 60
+      case "hour":
+        output = (this - that) / 36e5;
+        break;
+      // 1000 * 60 * 60
+      case "day":
+        output = (this - that - zoneDelta) / 864e5;
+        break;
+      // 1000 * 60 * 60 * 24, negate dst
+      case "week":
+        output = (this - that - zoneDelta) / 6048e5;
+        break;
+      // 1000 * 60 * 60 * 24 * 7, negate dst
+      default:
+        output = this - that;
+    }
+    return asFloat ? output : absFloor(output);
+  }
+  function monthDiff(a, b) {
+    if (a.date() < b.date()) {
+      return -monthDiff(b, a);
+    }
+    var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), anchor = a.clone().add(wholeMonthDiff, "months"), anchor2, adjust;
+    if (b - anchor < 0) {
+      anchor2 = a.clone().add(wholeMonthDiff - 1, "months");
+      adjust = (b - anchor) / (anchor - anchor2);
+    } else {
+      anchor2 = a.clone().add(wholeMonthDiff + 1, "months");
+      adjust = (b - anchor) / (anchor2 - anchor);
+    }
+    return -(wholeMonthDiff + adjust) || 0;
+  }
+  hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
+  hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
+  function toString() {
+    return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
+  }
+  function toISOString(keepOffset) {
+    if (!this.isValid()) {
+      return null;
+    }
+    var utc = keepOffset !== true, m = utc ? this.clone().utc() : this;
+    if (m.year() < 0 || m.year() > 9999) {
+      return formatMoment(
+        m,
+        utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
+      );
+    }
+    if (isFunction(Date.prototype.toISOString)) {
+      if (utc) {
+        return this.toDate().toISOString();
+      } else {
+        return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m, "Z"));
+      }
+    }
+    return formatMoment(
+      m,
+      utc ? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYY-MM-DD[T]HH:mm:ss.SSSZ"
+    );
+  }
+  function inspect() {
+    if (!this.isValid()) {
+      return "moment.invalid(/* " + this._i + " */)";
+    }
+    var func = "moment", zone = "", prefix, year, datetime, suffix;
+    if (!this.isLocal()) {
+      func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone";
+      zone = "Z";
+    }
+    prefix = "[" + func + '("]';
+    year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY";
+    datetime = "-MM-DD[T]HH:mm:ss.SSS";
+    suffix = zone + '[")]';
+    return this.format(prefix + year + datetime + suffix);
+  }
+  function format(inputString) {
+    if (!inputString) {
+      inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
+    }
+    var output = formatMoment(this, inputString);
+    return this.localeData().postformat(output);
+  }
+  function from(time2, withoutSuffix) {
+    if (this.isValid() && (isMoment(time2) && time2.isValid() || createLocal(time2).isValid())) {
+      return createDuration({ to: this, from: time2 }).locale(this.locale()).humanize(!withoutSuffix);
+    } else {
+      return this.localeData().invalidDate();
+    }
+  }
+  function fromNow(withoutSuffix) {
+    return this.from(createLocal(), withoutSuffix);
+  }
+  function to(time2, withoutSuffix) {
+    if (this.isValid() && (isMoment(time2) && time2.isValid() || createLocal(time2).isValid())) {
+      return createDuration({ from: this, to: time2 }).locale(this.locale()).humanize(!withoutSuffix);
+    } else {
+      return this.localeData().invalidDate();
+    }
+  }
+  function toNow(withoutSuffix) {
+    return this.to(createLocal(), withoutSuffix);
+  }
+  function locale(key) {
+    var newLocaleData;
+    if (key === void 0) {
+      return this._locale._abbr;
+    } else {
+      newLocaleData = getLocale(key);
+      if (newLocaleData != null) {
+        this._locale = newLocaleData;
+      }
+      return this;
+    }
+  }
+  var lang = deprecate(
+    "moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
+    function(key) {
+      if (key === void 0) {
+        return this.localeData();
+      } else {
+        return this.locale(key);
+      }
+    }
+  );
+  function localeData() {
+    return this._locale;
+  }
+  var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
+  function mod$1(dividend, divisor) {
+    return (dividend % divisor + divisor) % divisor;
+  }
+  function localStartOfDate(y, m, d) {
+    if (y < 100 && y >= 0) {
+      return new Date(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+      return new Date(y, m, d).valueOf();
+    }
+  }
+  function utcStartOfDate(y, m, d) {
+    if (y < 100 && y >= 0) {
+      return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+      return Date.UTC(y, m, d);
+    }
+  }
+  function startOf(units) {
+    var time2, startOfDate;
+    units = normalizeUnits(units);
+    if (units === void 0 || units === "millisecond" || !this.isValid()) {
+      return this;
+    }
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+    switch (units) {
+      case "year":
+        time2 = startOfDate(this.year(), 0, 1);
+        break;
+      case "quarter":
+        time2 = startOfDate(
+          this.year(),
+          this.month() - this.month() % 3,
+          1
+        );
+        break;
+      case "month":
+        time2 = startOfDate(this.year(), this.month(), 1);
+        break;
+      case "week":
+        time2 = startOfDate(
+          this.year(),
+          this.month(),
+          this.date() - this.weekday()
+        );
+        break;
+      case "isoWeek":
+        time2 = startOfDate(
+          this.year(),
+          this.month(),
+          this.date() - (this.isoWeekday() - 1)
+        );
+        break;
+      case "day":
+      case "date":
+        time2 = startOfDate(this.year(), this.month(), this.date());
+        break;
+      case "hour":
+        time2 = this._d.valueOf();
+        time2 -= mod$1(
+          time2 + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+          MS_PER_HOUR
+        );
+        break;
+      case "minute":
+        time2 = this._d.valueOf();
+        time2 -= mod$1(time2, MS_PER_MINUTE);
+        break;
+      case "second":
+        time2 = this._d.valueOf();
+        time2 -= mod$1(time2, MS_PER_SECOND);
+        break;
+    }
+    this._d.setTime(time2);
+    hooks.updateOffset(this, true);
+    return this;
+  }
+  function endOf(units) {
+    var time2, startOfDate;
+    units = normalizeUnits(units);
+    if (units === void 0 || units === "millisecond" || !this.isValid()) {
+      return this;
+    }
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+    switch (units) {
+      case "year":
+        time2 = startOfDate(this.year() + 1, 0, 1) - 1;
+        break;
+      case "quarter":
+        time2 = startOfDate(
+          this.year(),
+          this.month() - this.month() % 3 + 3,
+          1
+        ) - 1;
+        break;
+      case "month":
+        time2 = startOfDate(this.year(), this.month() + 1, 1) - 1;
+        break;
+      case "week":
+        time2 = startOfDate(
+          this.year(),
+          this.month(),
+          this.date() - this.weekday() + 7
+        ) - 1;
+        break;
+      case "isoWeek":
+        time2 = startOfDate(
+          this.year(),
+          this.month(),
+          this.date() - (this.isoWeekday() - 1) + 7
+        ) - 1;
+        break;
+      case "day":
+      case "date":
+        time2 = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
+        break;
+      case "hour":
+        time2 = this._d.valueOf();
+        time2 += MS_PER_HOUR - mod$1(
+          time2 + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+          MS_PER_HOUR
+        ) - 1;
+        break;
+      case "minute":
+        time2 = this._d.valueOf();
+        time2 += MS_PER_MINUTE - mod$1(time2, MS_PER_MINUTE) - 1;
+        break;
+      case "second":
+        time2 = this._d.valueOf();
+        time2 += MS_PER_SECOND - mod$1(time2, MS_PER_SECOND) - 1;
+        break;
+    }
+    this._d.setTime(time2);
+    hooks.updateOffset(this, true);
+    return this;
+  }
+  function valueOf() {
+    return this._d.valueOf() - (this._offset || 0) * 6e4;
+  }
+  function unix() {
+    return Math.floor(this.valueOf() / 1e3);
+  }
+  function toDate() {
+    return new Date(this.valueOf());
+  }
+  function toArray() {
+    var m = this;
+    return [
+      m.year(),
+      m.month(),
+      m.date(),
+      m.hour(),
+      m.minute(),
+      m.second(),
+      m.millisecond()
+    ];
+  }
+  function toObject() {
+    var m = this;
+    return {
+      years: m.year(),
+      months: m.month(),
+      date: m.date(),
+      hours: m.hours(),
+      minutes: m.minutes(),
+      seconds: m.seconds(),
+      milliseconds: m.milliseconds()
+    };
+  }
+  function toJSON() {
+    return this.isValid() ? this.toISOString() : null;
+  }
+  function isValid$2() {
+    return isValid(this);
+  }
+  function parsingFlags() {
+    return extend({}, getParsingFlags(this));
+  }
+  function invalidAt() {
+    return getParsingFlags(this).overflow;
+  }
+  function creationData() {
+    return {
+      input: this._i,
+      format: this._f,
+      locale: this._locale,
+      isUTC: this._isUTC,
+      strict: this._strict
+    };
+  }
+  addFormatToken("N", 0, 0, "eraAbbr");
+  addFormatToken("NN", 0, 0, "eraAbbr");
+  addFormatToken("NNN", 0, 0, "eraAbbr");
+  addFormatToken("NNNN", 0, 0, "eraName");
+  addFormatToken("NNNNN", 0, 0, "eraNarrow");
+  addFormatToken("y", ["y", 1], "yo", "eraYear");
+  addFormatToken("y", ["yy", 2], 0, "eraYear");
+  addFormatToken("y", ["yyy", 3], 0, "eraYear");
+  addFormatToken("y", ["yyyy", 4], 0, "eraYear");
+  addRegexToken("N", matchEraAbbr);
+  addRegexToken("NN", matchEraAbbr);
+  addRegexToken("NNN", matchEraAbbr);
+  addRegexToken("NNNN", matchEraName);
+  addRegexToken("NNNNN", matchEraNarrow);
+  addParseToken(
+    ["N", "NN", "NNN", "NNNN", "NNNNN"],
+    function(input, array, config, token2) {
+      var era = config._locale.erasParse(input, token2, config._strict);
+      if (era) {
+        getParsingFlags(config).era = era;
+      } else {
+        getParsingFlags(config).invalidEra = input;
+      }
+    }
+  );
+  addRegexToken("y", matchUnsigned);
+  addRegexToken("yy", matchUnsigned);
+  addRegexToken("yyy", matchUnsigned);
+  addRegexToken("yyyy", matchUnsigned);
+  addRegexToken("yo", matchEraYearOrdinal);
+  addParseToken(["y", "yy", "yyy", "yyyy"], YEAR);
+  addParseToken(["yo"], function(input, array, config, token2) {
+    var match;
+    if (config._locale._eraYearOrdinalRegex) {
+      match = input.match(config._locale._eraYearOrdinalRegex);
+    }
+    if (config._locale.eraYearOrdinalParse) {
+      array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
+    } else {
+      array[YEAR] = parseInt(input, 10);
+    }
+  });
+  function localeEras(m, format2) {
+    var i, l, date, eras = this._eras || getLocale("en")._eras;
+    for (i = 0, l = eras.length; i < l; ++i) {
+      switch (typeof eras[i].since) {
+        case "string":
+          date = hooks(eras[i].since).startOf("day");
+          eras[i].since = date.valueOf();
+          break;
+      }
+      switch (typeof eras[i].until) {
+        case "undefined":
+          eras[i].until = Infinity;
+          break;
+        case "string":
+          date = hooks(eras[i].until).startOf("day").valueOf();
+          eras[i].until = date.valueOf();
+          break;
+      }
+    }
+    return eras;
+  }
+  function localeErasParse(eraName, format2, strict) {
+    var i, l, eras = this.eras(), name, abbr, narrow;
+    eraName = eraName.toUpperCase();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      name = eras[i].name.toUpperCase();
+      abbr = eras[i].abbr.toUpperCase();
+      narrow = eras[i].narrow.toUpperCase();
+      if (strict) {
+        switch (format2) {
+          case "N":
+          case "NN":
+          case "NNN":
+            if (abbr === eraName) {
+              return eras[i];
+            }
+            break;
+          case "NNNN":
+            if (name === eraName) {
+              return eras[i];
+            }
+            break;
+          case "NNNNN":
+            if (narrow === eraName) {
+              return eras[i];
+            }
+            break;
+        }
+      } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
+        return eras[i];
+      }
+    }
+  }
+  function localeErasConvertYear(era, year) {
+    var dir = era.since <= era.until ? 1 : -1;
+    if (year === void 0) {
+      return hooks(era.since).year();
+    } else {
+      return hooks(era.since).year() + (year - era.offset) * dir;
+    }
+  }
+  function getEraName() {
+    var i, l, val, eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      val = this.clone().startOf("day").valueOf();
+      if (eras[i].since <= val && val <= eras[i].until) {
+        return eras[i].name;
+      }
+      if (eras[i].until <= val && val <= eras[i].since) {
+        return eras[i].name;
+      }
+    }
+    return "";
+  }
+  function getEraNarrow() {
+    var i, l, val, eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      val = this.clone().startOf("day").valueOf();
+      if (eras[i].since <= val && val <= eras[i].until) {
+        return eras[i].narrow;
+      }
+      if (eras[i].until <= val && val <= eras[i].since) {
+        return eras[i].narrow;
+      }
+    }
+    return "";
+  }
+  function getEraAbbr() {
+    var i, l, val, eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      val = this.clone().startOf("day").valueOf();
+      if (eras[i].since <= val && val <= eras[i].until) {
+        return eras[i].abbr;
+      }
+      if (eras[i].until <= val && val <= eras[i].since) {
+        return eras[i].abbr;
+      }
+    }
+    return "";
+  }
+  function getEraYear() {
+    var i, l, dir, val, eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      dir = eras[i].since <= eras[i].until ? 1 : -1;
+      val = this.clone().startOf("day").valueOf();
+      if (eras[i].since <= val && val <= eras[i].until || eras[i].until <= val && val <= eras[i].since) {
+        return (this.year() - hooks(eras[i].since).year()) * dir + eras[i].offset;
+      }
+    }
+    return this.year();
+  }
+  function erasNameRegex(isStrict) {
+    if (!hasOwnProp(this, "_erasNameRegex")) {
+      computeErasParse.call(this);
+    }
+    return isStrict ? this._erasNameRegex : this._erasRegex;
+  }
+  function erasAbbrRegex(isStrict) {
+    if (!hasOwnProp(this, "_erasAbbrRegex")) {
+      computeErasParse.call(this);
+    }
+    return isStrict ? this._erasAbbrRegex : this._erasRegex;
+  }
+  function erasNarrowRegex(isStrict) {
+    if (!hasOwnProp(this, "_erasNarrowRegex")) {
+      computeErasParse.call(this);
+    }
+    return isStrict ? this._erasNarrowRegex : this._erasRegex;
+  }
+  function matchEraAbbr(isStrict, locale2) {
+    return locale2.erasAbbrRegex(isStrict);
+  }
+  function matchEraName(isStrict, locale2) {
+    return locale2.erasNameRegex(isStrict);
+  }
+  function matchEraNarrow(isStrict, locale2) {
+    return locale2.erasNarrowRegex(isStrict);
+  }
+  function matchEraYearOrdinal(isStrict, locale2) {
+    return locale2._eraYearOrdinalRegex || matchUnsigned;
+  }
+  function computeErasParse() {
+    var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i, l, erasName, erasAbbr, erasNarrow, eras = this.eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+      erasName = regexEscape(eras[i].name);
+      erasAbbr = regexEscape(eras[i].abbr);
+      erasNarrow = regexEscape(eras[i].narrow);
+      namePieces.push(erasName);
+      abbrPieces.push(erasAbbr);
+      narrowPieces.push(erasNarrow);
+      mixedPieces.push(erasName);
+      mixedPieces.push(erasAbbr);
+      mixedPieces.push(erasNarrow);
+    }
+    this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
+    this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i");
+    this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i");
+    this._erasNarrowRegex = new RegExp(
+      "^(" + narrowPieces.join("|") + ")",
+      "i"
+    );
+  }
+  addFormatToken(0, ["gg", 2], 0, function() {
+    return this.weekYear() % 100;
+  });
+  addFormatToken(0, ["GG", 2], 0, function() {
+    return this.isoWeekYear() % 100;
+  });
+  function addWeekYearFormatToken(token2, getter) {
+    addFormatToken(0, [token2, token2.length], 0, getter);
+  }
+  addWeekYearFormatToken("gggg", "weekYear");
+  addWeekYearFormatToken("ggggg", "weekYear");
+  addWeekYearFormatToken("GGGG", "isoWeekYear");
+  addWeekYearFormatToken("GGGGG", "isoWeekYear");
+  addRegexToken("G", matchSigned);
+  addRegexToken("g", matchSigned);
+  addRegexToken("GG", match1to2, match2);
+  addRegexToken("gg", match1to2, match2);
+  addRegexToken("GGGG", match1to4, match4);
+  addRegexToken("gggg", match1to4, match4);
+  addRegexToken("GGGGG", match1to6, match6);
+  addRegexToken("ggggg", match1to6, match6);
+  addWeekParseToken(
+    ["gggg", "ggggg", "GGGG", "GGGGG"],
+    function(input, week, config, token2) {
+      week[token2.substr(0, 2)] = toInt(input);
+    }
+  );
+  addWeekParseToken(["gg", "GG"], function(input, week, config, token2) {
+    week[token2] = hooks.parseTwoDigitYear(input);
+  });
+  function getSetWeekYear(input) {
+    return getSetWeekYearHelper.call(
+      this,
+      input,
+      this.week(),
+      this.weekday() + this.localeData()._week.dow,
+      this.localeData()._week.dow,
+      this.localeData()._week.doy
+    );
+  }
+  function getSetISOWeekYear(input) {
+    return getSetWeekYearHelper.call(
+      this,
+      input,
+      this.isoWeek(),
+      this.isoWeekday(),
+      1,
+      4
+    );
+  }
+  function getISOWeeksInYear() {
+    return weeksInYear(this.year(), 1, 4);
+  }
+  function getISOWeeksInISOWeekYear() {
+    return weeksInYear(this.isoWeekYear(), 1, 4);
+  }
+  function getWeeksInYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+  }
+  function getWeeksInWeekYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
+  }
+  function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+    var weeksTarget;
+    if (input == null) {
+      return weekOfYear(this, dow, doy).year;
+    } else {
+      weeksTarget = weeksInYear(input, dow, doy);
+      if (week > weeksTarget) {
+        week = weeksTarget;
+      }
+      return setWeekAll.call(this, input, week, weekday, dow, doy);
+    }
+  }
+  function setWeekAll(weekYear, week, weekday, dow, doy) {
+    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+    this.year(date.getUTCFullYear());
+    this.month(date.getUTCMonth());
+    this.date(date.getUTCDate());
+    return this;
+  }
+  addFormatToken("Q", 0, "Qo", "quarter");
+  addRegexToken("Q", match1);
+  addParseToken("Q", function(input, array) {
+    array[MONTH] = (toInt(input) - 1) * 3;
+  });
+  function getSetQuarter(input) {
+    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
+  }
+  addFormatToken("D", ["DD", 2], "Do", "date");
+  addRegexToken("D", match1to2, match1to2NoLeadingZero);
+  addRegexToken("DD", match1to2, match2);
+  addRegexToken("Do", function(isStrict, locale2) {
+    return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient;
+  });
+  addParseToken(["D", "DD"], DATE);
+  addParseToken("Do", function(input, array) {
+    array[DATE] = toInt(input.match(match1to2)[0]);
+  });
+  var getSetDayOfMonth = makeGetSet("Date", true);
+  addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
+  addRegexToken("DDD", match1to3);
+  addRegexToken("DDDD", match3);
+  addParseToken(["DDD", "DDDD"], function(input, array, config) {
+    config._dayOfYear = toInt(input);
+  });
+  function getSetDayOfYear(input) {
+    var dayOfYear = Math.round(
+      (this.clone().startOf("day") - this.clone().startOf("year")) / 864e5
+    ) + 1;
+    return input == null ? dayOfYear : this.add(input - dayOfYear, "d");
+  }
+  addFormatToken("m", ["mm", 2], 0, "minute");
+  addRegexToken("m", match1to2, match1to2HasZero);
+  addRegexToken("mm", match1to2, match2);
+  addParseToken(["m", "mm"], MINUTE);
+  var getSetMinute = makeGetSet("Minutes", false);
+  addFormatToken("s", ["ss", 2], 0, "second");
+  addRegexToken("s", match1to2, match1to2HasZero);
+  addRegexToken("ss", match1to2, match2);
+  addParseToken(["s", "ss"], SECOND);
+  var getSetSecond = makeGetSet("Seconds", false);
+  addFormatToken("S", 0, 0, function() {
+    return ~~(this.millisecond() / 100);
+  });
+  addFormatToken(0, ["SS", 2], 0, function() {
+    return ~~(this.millisecond() / 10);
+  });
+  addFormatToken(0, ["SSS", 3], 0, "millisecond");
+  addFormatToken(0, ["SSSS", 4], 0, function() {
+    return this.millisecond() * 10;
+  });
+  addFormatToken(0, ["SSSSS", 5], 0, function() {
+    return this.millisecond() * 100;
+  });
+  addFormatToken(0, ["SSSSSS", 6], 0, function() {
+    return this.millisecond() * 1e3;
+  });
+  addFormatToken(0, ["SSSSSSS", 7], 0, function() {
+    return this.millisecond() * 1e4;
+  });
+  addFormatToken(0, ["SSSSSSSS", 8], 0, function() {
+    return this.millisecond() * 1e5;
+  });
+  addFormatToken(0, ["SSSSSSSSS", 9], 0, function() {
+    return this.millisecond() * 1e6;
+  });
+  addRegexToken("S", match1to3, match1);
+  addRegexToken("SS", match1to3, match2);
+  addRegexToken("SSS", match1to3, match3);
+  var token, getSetMillisecond;
+  for (token = "SSSS"; token.length <= 9; token += "S") {
+    addRegexToken(token, matchUnsigned);
+  }
+  function parseMs(input, array) {
+    array[MILLISECOND] = toInt(("0." + input) * 1e3);
+  }
+  for (token = "S"; token.length <= 9; token += "S") {
+    addParseToken(token, parseMs);
+  }
+  getSetMillisecond = makeGetSet("Milliseconds", false);
+  addFormatToken("z", 0, 0, "zoneAbbr");
+  addFormatToken("zz", 0, 0, "zoneName");
+  function getZoneAbbr() {
+    return this._isUTC ? "UTC" : "";
+  }
+  function getZoneName() {
+    return this._isUTC ? "Coordinated Universal Time" : "";
+  }
+  var proto = Moment.prototype;
+  proto.add = add;
+  proto.calendar = calendar$1;
+  proto.clone = clone;
+  proto.diff = diff;
+  proto.endOf = endOf;
+  proto.format = format;
+  proto.from = from;
+  proto.fromNow = fromNow;
+  proto.to = to;
+  proto.toNow = toNow;
+  proto.get = stringGet;
+  proto.invalidAt = invalidAt;
+  proto.isAfter = isAfter;
+  proto.isBefore = isBefore;
+  proto.isBetween = isBetween;
+  proto.isSame = isSame;
+  proto.isSameOrAfter = isSameOrAfter;
+  proto.isSameOrBefore = isSameOrBefore;
+  proto.isValid = isValid$2;
+  proto.lang = lang;
+  proto.locale = locale;
+  proto.localeData = localeData;
+  proto.max = prototypeMax;
+  proto.min = prototypeMin;
+  proto.parsingFlags = parsingFlags;
+  proto.set = stringSet;
+  proto.startOf = startOf;
+  proto.subtract = subtract;
+  proto.toArray = toArray;
+  proto.toObject = toObject;
+  proto.toDate = toDate;
+  proto.toISOString = toISOString;
+  proto.inspect = inspect;
+  if (typeof Symbol !== "undefined" && Symbol.for != null) {
+    proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
+      return "Moment<" + this.format() + ">";
+    };
+  }
+  proto.toJSON = toJSON;
+  proto.toString = toString;
+  proto.unix = unix;
+  proto.valueOf = valueOf;
+  proto.creationData = creationData;
+  proto.eraName = getEraName;
+  proto.eraNarrow = getEraNarrow;
+  proto.eraAbbr = getEraAbbr;
+  proto.eraYear = getEraYear;
+  proto.year = getSetYear;
+  proto.isLeapYear = getIsLeapYear;
+  proto.weekYear = getSetWeekYear;
+  proto.isoWeekYear = getSetISOWeekYear;
+  proto.quarter = proto.quarters = getSetQuarter;
+  proto.month = getSetMonth;
+  proto.daysInMonth = getDaysInMonth;
+  proto.week = proto.weeks = getSetWeek;
+  proto.isoWeek = proto.isoWeeks = getSetISOWeek;
+  proto.weeksInYear = getWeeksInYear;
+  proto.weeksInWeekYear = getWeeksInWeekYear;
+  proto.isoWeeksInYear = getISOWeeksInYear;
+  proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
+  proto.date = getSetDayOfMonth;
+  proto.day = proto.days = getSetDayOfWeek;
+  proto.weekday = getSetLocaleDayOfWeek;
+  proto.isoWeekday = getSetISODayOfWeek;
+  proto.dayOfYear = getSetDayOfYear;
+  proto.hour = proto.hours = getSetHour;
+  proto.minute = proto.minutes = getSetMinute;
+  proto.second = proto.seconds = getSetSecond;
+  proto.millisecond = proto.milliseconds = getSetMillisecond;
+  proto.utcOffset = getSetOffset;
+  proto.utc = setOffsetToUTC;
+  proto.local = setOffsetToLocal;
+  proto.parseZone = setOffsetToParsedOffset;
+  proto.hasAlignedHourOffset = hasAlignedHourOffset;
+  proto.isDST = isDaylightSavingTime;
+  proto.isLocal = isLocal;
+  proto.isUtcOffset = isUtcOffset;
+  proto.isUtc = isUtc;
+  proto.isUTC = isUtc;
+  proto.zoneAbbr = getZoneAbbr;
+  proto.zoneName = getZoneName;
+  proto.dates = deprecate(
+    "dates accessor is deprecated. Use date instead.",
+    getSetDayOfMonth
+  );
+  proto.months = deprecate(
+    "months accessor is deprecated. Use month instead",
+    getSetMonth
+  );
+  proto.years = deprecate(
+    "years accessor is deprecated. Use year instead",
+    getSetYear
+  );
+  proto.zone = deprecate(
+    "moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
+    getSetZone
+  );
+  proto.isDSTShifted = deprecate(
+    "isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
+    isDaylightSavingTimeShifted
+  );
+  function createUnix(input) {
+    return createLocal(input * 1e3);
+  }
+  function createInZone() {
+    return createLocal.apply(null, arguments).parseZone();
+  }
+  function preParsePostFormat(string) {
+    return string;
+  }
+  var proto$1 = Locale.prototype;
+  proto$1.calendar = calendar;
+  proto$1.longDateFormat = longDateFormat;
+  proto$1.invalidDate = invalidDate;
+  proto$1.ordinal = ordinal;
+  proto$1.preparse = preParsePostFormat;
+  proto$1.postformat = preParsePostFormat;
+  proto$1.relativeTime = relativeTime;
+  proto$1.pastFuture = pastFuture;
+  proto$1.set = set;
+  proto$1.eras = localeEras;
+  proto$1.erasParse = localeErasParse;
+  proto$1.erasConvertYear = localeErasConvertYear;
+  proto$1.erasAbbrRegex = erasAbbrRegex;
+  proto$1.erasNameRegex = erasNameRegex;
+  proto$1.erasNarrowRegex = erasNarrowRegex;
+  proto$1.months = localeMonths;
+  proto$1.monthsShort = localeMonthsShort;
+  proto$1.monthsParse = localeMonthsParse;
+  proto$1.monthsRegex = monthsRegex$1;
+  proto$1.monthsShortRegex = monthsShortRegex;
+  proto$1.week = localeWeek;
+  proto$1.firstDayOfYear = localeFirstDayOfYear;
+  proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+  proto$1.weekdays = localeWeekdays;
+  proto$1.weekdaysMin = localeWeekdaysMin;
+  proto$1.weekdaysShort = localeWeekdaysShort;
+  proto$1.weekdaysParse = localeWeekdaysParse;
+  proto$1.weekdaysRegex = weekdaysRegex;
+  proto$1.weekdaysShortRegex = weekdaysShortRegex;
+  proto$1.weekdaysMinRegex = weekdaysMinRegex;
+  proto$1.isPM = localeIsPM;
+  proto$1.meridiem = localeMeridiem;
+  function get$1(format2, index, field, setter) {
+    var locale2 = getLocale(), utc = createUTC().set(setter, index);
+    return locale2[field](utc, format2);
+  }
+  function listMonthsImpl(format2, index, field) {
+    if (isNumber(format2)) {
+      index = format2;
+      format2 = void 0;
+    }
+    format2 = format2 || "";
+    if (index != null) {
+      return get$1(format2, index, field, "month");
+    }
+    var i, out = [];
+    for (i = 0; i < 12; i++) {
+      out[i] = get$1(format2, i, field, "month");
+    }
+    return out;
+  }
+  function listWeekdaysImpl(localeSorted, format2, index, field) {
+    if (typeof localeSorted === "boolean") {
+      if (isNumber(format2)) {
+        index = format2;
+        format2 = void 0;
+      }
+      format2 = format2 || "";
+    } else {
+      format2 = localeSorted;
+      index = format2;
+      localeSorted = false;
+      if (isNumber(format2)) {
+        index = format2;
+        format2 = void 0;
+      }
+      format2 = format2 || "";
+    }
+    var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i, out = [];
+    if (index != null) {
+      return get$1(format2, (index + shift) % 7, field, "day");
+    }
+    for (i = 0; i < 7; i++) {
+      out[i] = get$1(format2, (i + shift) % 7, field, "day");
+    }
+    return out;
+  }
+  function listMonths(format2, index) {
+    return listMonthsImpl(format2, index, "months");
+  }
+  function listMonthsShort(format2, index) {
+    return listMonthsImpl(format2, index, "monthsShort");
+  }
+  function listWeekdays(localeSorted, format2, index) {
+    return listWeekdaysImpl(localeSorted, format2, index, "weekdays");
+  }
+  function listWeekdaysShort(localeSorted, format2, index) {
+    return listWeekdaysImpl(localeSorted, format2, index, "weekdaysShort");
+  }
+  function listWeekdaysMin(localeSorted, format2, index) {
+    return listWeekdaysImpl(localeSorted, format2, index, "weekdaysMin");
+  }
+  getSetGlobalLocale("en", {
+    eras: [
+      {
+        since: "0001-01-01",
+        until: Infinity,
+        offset: 1,
+        name: "Anno Domini",
+        narrow: "AD",
+        abbr: "AD"
+      },
+      {
+        since: "0000-12-31",
+        until: -Infinity,
+        offset: 1,
+        name: "Before Christ",
+        narrow: "BC",
+        abbr: "BC"
+      }
+    ],
+    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+    ordinal: function(number2) {
+      var b = number2 % 10, output = toInt(number2 % 100 / 10) === 1 ? "th" : b === 1 ? "st" : b === 2 ? "nd" : b === 3 ? "rd" : "th";
+      return number2 + output;
+    }
+  });
+  hooks.lang = deprecate(
+    "moment.lang is deprecated. Use moment.locale instead.",
+    getSetGlobalLocale
+  );
+  hooks.langData = deprecate(
+    "moment.langData is deprecated. Use moment.localeData instead.",
+    getLocale
+  );
+  var mathAbs = Math.abs;
+  function abs() {
+    var data = this._data;
+    this._milliseconds = mathAbs(this._milliseconds);
+    this._days = mathAbs(this._days);
+    this._months = mathAbs(this._months);
+    data.milliseconds = mathAbs(data.milliseconds);
+    data.seconds = mathAbs(data.seconds);
+    data.minutes = mathAbs(data.minutes);
+    data.hours = mathAbs(data.hours);
+    data.months = mathAbs(data.months);
+    data.years = mathAbs(data.years);
+    return this;
+  }
+  function addSubtract$1(duration, input, value, direction) {
+    var other = createDuration(input, value);
+    duration._milliseconds += direction * other._milliseconds;
+    duration._days += direction * other._days;
+    duration._months += direction * other._months;
+    return duration._bubble();
+  }
+  function add$1(input, value) {
+    return addSubtract$1(this, input, value, 1);
+  }
+  function subtract$1(input, value) {
+    return addSubtract$1(this, input, value, -1);
+  }
+  function absCeil(number2) {
+    if (number2 < 0) {
+      return Math.floor(number2);
+    } else {
+      return Math.ceil(number2);
+    }
+  }
+  function bubble() {
+    var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays;
+    if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) {
+      milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5;
+      days2 = 0;
+      months2 = 0;
+    }
+    data.milliseconds = milliseconds2 % 1e3;
+    seconds2 = absFloor(milliseconds2 / 1e3);
+    data.seconds = seconds2 % 60;
+    minutes2 = absFloor(seconds2 / 60);
+    data.minutes = minutes2 % 60;
+    hours2 = absFloor(minutes2 / 60);
+    data.hours = hours2 % 24;
+    days2 += absFloor(hours2 / 24);
+    monthsFromDays = absFloor(daysToMonths(days2));
+    months2 += monthsFromDays;
+    days2 -= absCeil(monthsToDays(monthsFromDays));
+    years2 = absFloor(months2 / 12);
+    months2 %= 12;
+    data.days = days2;
+    data.months = months2;
+    data.years = years2;
+    return this;
+  }
+  function daysToMonths(days2) {
+    return days2 * 4800 / 146097;
+  }
+  function monthsToDays(months2) {
+    return months2 * 146097 / 4800;
+  }
+  function as(units) {
+    if (!this.isValid()) {
+      return NaN;
+    }
+    var days2, months2, milliseconds2 = this._milliseconds;
+    units = normalizeUnits(units);
+    if (units === "month" || units === "quarter" || units === "year") {
+      days2 = this._days + milliseconds2 / 864e5;
+      months2 = this._months + daysToMonths(days2);
+      switch (units) {
+        case "month":
+          return months2;
+        case "quarter":
+          return months2 / 3;
+        case "year":
+          return months2 / 12;
+      }
+    } else {
+      days2 = this._days + Math.round(monthsToDays(this._months));
+      switch (units) {
+        case "week":
+          return days2 / 7 + milliseconds2 / 6048e5;
+        case "day":
+          return days2 + milliseconds2 / 864e5;
+        case "hour":
+          return days2 * 24 + milliseconds2 / 36e5;
+        case "minute":
+          return days2 * 1440 + milliseconds2 / 6e4;
+        case "second":
+          return days2 * 86400 + milliseconds2 / 1e3;
+        // Math.floor prevents floating point math errors here
+        case "millisecond":
+          return Math.floor(days2 * 864e5) + milliseconds2;
+        default:
+          throw new Error("Unknown unit " + units);
+      }
+    }
+  }
+  function makeAs(alias) {
+    return function() {
+      return this.as(alias);
+    };
+  }
+  var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds;
+  function clone$1() {
+    return createDuration(this);
+  }
+  function get$2(units) {
+    units = normalizeUnits(units);
+    return this.isValid() ? this[units + "s"]() : NaN;
+  }
+  function makeGetter(name) {
+    return function() {
+      return this.isValid() ? this._data[name] : NaN;
+    };
+  }
+  var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years");
+  function weeks() {
+    return absFloor(this.days() / 7);
+  }
+  var round = Math.round, thresholds = {
+    ss: 44,
+    // a few seconds to seconds
+    s: 45,
+    // seconds to minute
+    m: 45,
+    // minutes to hour
+    h: 22,
+    // hours to day
+    d: 26,
+    // days to month/week
+    w: null,
+    // weeks to month
+    M: 11
+    // months to year
+  };
+  function substituteTimeAgo(string, number2, withoutSuffix, isFuture, locale2) {
+    return locale2.relativeTime(number2 || 1, !!withoutSuffix, string, isFuture);
+  }
+  function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
+    var duration = createDuration(posNegDuration).abs(), seconds2 = round(duration.as("s")), minutes2 = round(duration.as("m")), hours2 = round(duration.as("h")), days2 = round(duration.as("d")), months2 = round(duration.as("M")), weeks2 = round(duration.as("w")), years2 = round(duration.as("y")), a = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
+    if (thresholds2.w != null) {
+      a = a || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
+    }
+    a = a || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2];
+    a[2] = withoutSuffix;
+    a[3] = +posNegDuration > 0;
+    a[4] = locale2;
+    return substituteTimeAgo.apply(null, a);
+  }
+  function getSetRelativeTimeRounding(roundingFunction) {
+    if (roundingFunction === void 0) {
+      return round;
+    }
+    if (typeof roundingFunction === "function") {
+      round = roundingFunction;
+      return true;
+    }
+    return false;
+  }
+  function getSetRelativeTimeThreshold(threshold, limit) {
+    if (thresholds[threshold] === void 0) {
+      return false;
+    }
+    if (limit === void 0) {
+      return thresholds[threshold];
+    }
+    thresholds[threshold] = limit;
+    if (threshold === "s") {
+      thresholds.ss = limit - 1;
+    }
+    return true;
+  }
+  function humanize(argWithSuffix, argThresholds) {
+    if (!this.isValid()) {
+      return this.localeData().invalidDate();
+    }
+    var withSuffix = false, th = thresholds, locale2, output;
+    if (typeof argWithSuffix === "object") {
+      argThresholds = argWithSuffix;
+      argWithSuffix = false;
+    }
+    if (typeof argWithSuffix === "boolean") {
+      withSuffix = argWithSuffix;
+    }
+    if (typeof argThresholds === "object") {
+      th = Object.assign({}, thresholds, argThresholds);
+      if (argThresholds.s != null && argThresholds.ss == null) {
+        th.ss = argThresholds.s - 1;
+      }
+    }
+    locale2 = this.localeData();
+    output = relativeTime$1(this, !withSuffix, th, locale2);
+    if (withSuffix) {
+      output = locale2.pastFuture(+this, output);
+    }
+    return locale2.postformat(output);
+  }
+  var abs$1 = Math.abs;
+  function sign(x) {
+    return (x > 0) - (x < 0) || +x;
+  }
+  function toISOString$1() {
+    if (!this.isValid()) {
+      return this.localeData().invalidDate();
+    }
+    var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
+    if (!total) {
+      return "P0D";
+    }
+    minutes2 = absFloor(seconds2 / 60);
+    hours2 = absFloor(minutes2 / 60);
+    seconds2 %= 60;
+    minutes2 %= 60;
+    years2 = absFloor(months2 / 12);
+    months2 %= 12;
+    s = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : "";
+    totalSign = total < 0 ? "-" : "";
+    ymSign = sign(this._months) !== sign(total) ? "-" : "";
+    daysSign = sign(this._days) !== sign(total) ? "-" : "";
+    hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : "";
+    return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s + "S" : "");
+  }
+  var proto$2 = Duration.prototype;
+  proto$2.isValid = isValid$1;
+  proto$2.abs = abs;
+  proto$2.add = add$1;
+  proto$2.subtract = subtract$1;
+  proto$2.as = as;
+  proto$2.asMilliseconds = asMilliseconds;
+  proto$2.asSeconds = asSeconds;
+  proto$2.asMinutes = asMinutes;
+  proto$2.asHours = asHours;
+  proto$2.asDays = asDays;
+  proto$2.asWeeks = asWeeks;
+  proto$2.asMonths = asMonths;
+  proto$2.asQuarters = asQuarters;
+  proto$2.asYears = asYears;
+  proto$2.valueOf = valueOf$1;
+  proto$2._bubble = bubble;
+  proto$2.clone = clone$1;
+  proto$2.get = get$2;
+  proto$2.milliseconds = milliseconds;
+  proto$2.seconds = seconds;
+  proto$2.minutes = minutes;
+  proto$2.hours = hours;
+  proto$2.days = days;
+  proto$2.weeks = weeks;
+  proto$2.months = months;
+  proto$2.years = years;
+  proto$2.humanize = humanize;
+  proto$2.toISOString = toISOString$1;
+  proto$2.toString = toISOString$1;
+  proto$2.toJSON = toISOString$1;
+  proto$2.locale = locale;
+  proto$2.localeData = localeData;
+  proto$2.toIsoString = deprecate(
+    "toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
+    toISOString$1
+  );
+  proto$2.lang = lang;
+  addFormatToken("X", 0, 0, "unix");
+  addFormatToken("x", 0, 0, "valueOf");
+  addRegexToken("x", matchSigned);
+  addRegexToken("X", matchTimestamp);
+  addParseToken("X", function(input, array, config) {
+    config._d = new Date(parseFloat(input) * 1e3);
+  });
+  addParseToken("x", function(input, array, config) {
+    config._d = new Date(toInt(input));
+  });
+  //! moment.js
+  hooks.version = "2.30.1";
+  setHookCallback(createLocal);
+  hooks.fn = proto;
+  hooks.min = min;
+  hooks.max = max;
+  hooks.now = now;
+  hooks.utc = createUTC;
+  hooks.unix = createUnix;
+  hooks.months = listMonths;
+  hooks.isDate = isDate;
+  hooks.locale = getSetGlobalLocale;
+  hooks.invalid = createInvalid;
+  hooks.duration = createDuration;
+  hooks.isMoment = isMoment;
+  hooks.weekdays = listWeekdays;
+  hooks.parseZone = createInZone;
+  hooks.localeData = getLocale;
+  hooks.isDuration = isDuration;
+  hooks.monthsShort = listMonthsShort;
+  hooks.weekdaysMin = listWeekdaysMin;
+  hooks.defineLocale = defineLocale;
+  hooks.updateLocale = updateLocale;
+  hooks.locales = listLocales;
+  hooks.weekdaysShort = listWeekdaysShort;
+  hooks.normalizeUnits = normalizeUnits;
+  hooks.relativeTimeRounding = getSetRelativeTimeRounding;
+  hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
+  hooks.calendarFormat = getCalendarFormat;
+  hooks.prototype = proto;
+  hooks.HTML5_FMT = {
+    DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
+    // <input type="datetime-local" />
+    DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
+    // <input type="datetime-local" step="1" />
+    DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS",
+    // <input type="datetime-local" step="0.001" />
+    DATE: "YYYY-MM-DD",
+    // <input type="date" />
+    TIME: "HH:mm",
+    // <input type="time" />
+    TIME_SECONDS: "HH:mm:ss",
+    // <input type="time" step="1" />
+    TIME_MS: "HH:mm:ss.SSS",
+    // <input type="time" step="0.001" />
+    WEEK: "GGGG-[W]WW",
+    // <input type="week" />
+    MONTH: "YYYY-MM"
+    // <input type="month" />
+  };
+  //! moment.js locale configuration
+  //! locale : French [fr]
+  //! author : John Fischer : https://github.com/jfroffice
+  var monthsStrictRegex = /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i, monthsShortStrictRegex = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i, monthsRegex = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i, monthsParse = [
+    /^janv/i,
+    /^févr/i,
+    /^mars/i,
+    /^avr/i,
+    /^mai/i,
+    /^juin/i,
+    /^juil/i,
+    /^août/i,
+    /^sept/i,
+    /^oct/i,
+    /^nov/i,
+    /^déc/i
+  ];
+  hooks.defineLocale("fr", {
+    months: "janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split(
+      "_"
+    ),
+    monthsShort: "janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split(
+      "_"
+    ),
+    monthsRegex,
+    monthsShortRegex: monthsRegex,
+    monthsStrictRegex,
+    monthsShortStrictRegex,
+    monthsParse,
+    longMonthsParse: monthsParse,
+    shortMonthsParse: monthsParse,
+    weekdays: "dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),
+    weekdaysShort: "dim._lun._mar._mer._jeu._ven._sam.".split("_"),
+    weekdaysMin: "di_lu_ma_me_je_ve_sa".split("_"),
+    weekdaysParseExact: true,
+    longDateFormat: {
+      LT: "HH:mm",
+      LTS: "HH:mm:ss",
+      L: "DD/MM/YYYY",
+      LL: "D MMMM YYYY",
+      LLL: "D MMMM YYYY HH:mm",
+      LLLL: "dddd D MMMM YYYY HH:mm"
+    },
+    calendar: {
+      sameDay: "[Aujourd’hui à] LT",
+      nextDay: "[Demain à] LT",
+      nextWeek: "dddd [à] LT",
+      lastDay: "[Hier à] LT",
+      lastWeek: "dddd [dernier à] LT",
+      sameElse: "L"
+    },
+    relativeTime: {
+      future: "dans %s",
+      past: "il y a %s",
+      s: "quelques secondes",
+      ss: "%d secondes",
+      m: "une minute",
+      mm: "%d minutes",
+      h: "une heure",
+      hh: "%d heures",
+      d: "un jour",
+      dd: "%d jours",
+      w: "une semaine",
+      ww: "%d semaines",
+      M: "un mois",
+      MM: "%d mois",
+      y: "un an",
+      yy: "%d ans"
+    },
+    dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
+    ordinal: function(number2, period) {
+      switch (period) {
+        // TODO: Return 'e' when day of month > 1. Move this case inside
+        // block for masculine words below.
+        // See https://github.com/moment/moment/issues/3375
+        case "D":
+          return number2 + (number2 === 1 ? "er" : "");
+        // Words with masculine grammatical gender: mois, trimestre, jour
+        default:
+        case "M":
+        case "Q":
+        case "DDD":
+        case "d":
+          return number2 + (number2 === 1 ? "er" : "e");
+        // Words with feminine grammatical gender: semaine
+        case "w":
+        case "W":
+          return number2 + (number2 === 1 ? "re" : "e");
+      }
+    },
+    week: {
+      dow: 1,
+      // Monday is the first day of the week.
+      doy: 4
+      // The week that contains Jan 4th is the first week of the year.
+    }
+  });
+  var AccountStatus;
+  (function(AccountStatus2) {
+    AccountStatus2[AccountStatus2["DISABLED"] = 0] = "DISABLED";
+    AccountStatus2[AccountStatus2["ENABLED"] = 1] = "ENABLED";
+  })(AccountStatus || (AccountStatus = {}));
+  var AdContentType;
+  (function(AdContentType2) {
+    AdContentType2["IMAGE"] = "image";
+    AdContentType2["VIDEO"] = "video";
+  })(AdContentType || (AdContentType = {}));
+  var AuthType;
+  (function(AuthType2) {
+    AuthType2[AuthType2["UNDEFINED"] = 0] = "UNDEFINED";
+    AuthType2[AuthType2["EMAIL_PASSWORD"] = 1] = "EMAIL_PASSWORD";
+    AuthType2[AuthType2["PHONE"] = 2] = "PHONE";
+    AuthType2[AuthType2["GOOGLE"] = 3] = "GOOGLE";
+    AuthType2[AuthType2["FACEBOOK"] = 4] = "FACEBOOK";
+    AuthType2[AuthType2["TWITTER"] = 5] = "TWITTER";
+  })(AuthType || (AuthType = {}));
+  var Bool;
+  (function(Bool2) {
+    Bool2[Bool2["FALSE"] = 0] = "FALSE";
+    Bool2[Bool2["TRUE"] = 1] = "TRUE";
+  })(Bool || (Bool = {}));
+  var ContentType;
+  (function(ContentType2) {
+    ContentType2["NEWS_TAG"] = "news-tag";
+    ContentType2["NEWS_CATEGORY"] = "news-category";
+    ContentType2["NEWS_ARTICLE"] = "news-article";
+    ContentType2["CONTENT_MODEL"] = "content-model";
+  })(ContentType || (ContentType = {}));
+  var MenuItemTargetType;
+  (function(MenuItemTargetType2) {
+    MenuItemTargetType2["EXTERNAL_LINK"] = "external-link";
+    MenuItemTargetType2["PAGE_LINK"] = "page-link";
+    MenuItemTargetType2["CONTENT_LINK"] = "content-link";
+  })(MenuItemTargetType || (MenuItemTargetType = {}));
+  var NotificationSource;
+  (function(NotificationSource2) {
+    NotificationSource2[NotificationSource2["SYSTEM"] = 1] = "SYSTEM";
+    NotificationSource2[NotificationSource2["USER"] = 2] = "USER";
+  })(NotificationSource || (NotificationSource = {}));
+  var NotificationType;
+  (function(NotificationType2) {
+    NotificationType2["WELCOME_USER"] = "App\\Notifications\\WelcomeUser";
+  })(NotificationType || (NotificationType = {}));
+  var PermalinkContentType;
+  (function(PermalinkContentType2) {
+    PermalinkContentType2["NEWS_TAG"] = "news-tag";
+    PermalinkContentType2["NEWS_CATEGORY"] = "news-category";
+    PermalinkContentType2["NEWS_ARTICLE"] = "news-article";
+    PermalinkContentType2["CONTENT_MODEL"] = "content-model";
+  })(PermalinkContentType || (PermalinkContentType = {}));
+  var ProfileType;
+  (function(ProfileType2) {
+    ProfileType2["SUBSCRIBER"] = "App\\Models\\SubscriberProfile";
+  })(ProfileType || (ProfileType = {}));
+  var ResponseErrorCode;
+  (function(ResponseErrorCode2) {
+    ResponseErrorCode2["FORM_INVALID_DATA"] = "form/invalid_data";
+    ResponseErrorCode2["AUTH_LOGIN_FAILED"] = "auth/login_failed";
+    ResponseErrorCode2["AUTH_REGISTRATION_FAILED"] = "auth/registration_failed";
+    ResponseErrorCode2["AUTH_MISSING_DATA"] = "auth/missing_data";
+    ResponseErrorCode2["AUTH_WRONG_PASSWORD"] = "auth/wrong_password";
+    ResponseErrorCode2["AUTH_USER_DISABLED"] = "auth/user_disabled";
+    ResponseErrorCode2["AUTH_USER_NOT_FOUND"] = "auth/user_not_found";
+    ResponseErrorCode2["AUTH_PROFILE_TYPE_NOT_FOUND"] = "auth/profile_type_not_found";
+    ResponseErrorCode2["AUTH_EMAIL_ALREADY_USED"] = "auth/email_already_used";
+    ResponseErrorCode2["AUTH_EMAIL_ALREADY_VERIFIED"] = "auth/email_already_verified";
+    ResponseErrorCode2["AUTH_PROFILE_ALREADY_EXISTS"] = "auth/profile_already_exists";
+    ResponseErrorCode2["AUTH_PROFILE_NOT_FOUND"] = "auth/profile_not_found";
+    ResponseErrorCode2["AUTH_INVALID_TOKEN"] = "auth/invalid_token";
+    ResponseErrorCode2["AUTH_CODE_SENDING_FAILED"] = "auth/code_sending_failed";
+    ResponseErrorCode2["AUTH_CODE_VERIFICATION_FAILED"] = "auth/code_verification_failed";
+    ResponseErrorCode2["AUTH_CODE_EXPIRED"] = "auth/code_expired";
+  })(ResponseErrorCode || (ResponseErrorCode = {}));
+  var UserRole;
+  (function(UserRole2) {
+    UserRole2["SUPER_ADMIN"] = "super-admin";
+    UserRole2["ADMIN"] = "admin";
+    UserRole2["USER"] = "user";
+  })(UserRole || (UserRole = {}));
+  const RootContainer = ({
+    page,
+    sections = [],
+    components = {}
+  }) => {
+    React2.useEffect(() => {
+      const timeout = setTimeout(() => {
+        const sectionData = page.props?.sectionData;
+        if (sectionData && sections.find(
+          (section) => section.slug === sectionData.slug && section.pivot?.linkId === sectionData.pivot?.linkId
+        )) {
+          slideToId(`${sectionData.slug}__${sectionData.pivot?.linkId}-container`);
+        }
+      }, 1e3);
+      return () => clearTimeout(timeout);
+    }, [page, sections]);
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: sections.map((section, i) => {
+      const Component = components[section.name];
+      if (!Component) return null;
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "section",
+        {
+          id: `${section.slug}__${section.pivot?.linkId}-container`,
+          className: "reset-styles",
+          children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+            Component,
+            {
+              data: section.pivot?.data,
+              settings: section.pivot?.settings,
+              sectionKey: `${section.slug}__${section.pivot?.linkId}`,
+              metadata: {
+                slug: section.slug,
+                name: section.name,
+                title: section.title,
+                linkId: section.pivot?.linkId,
+                createdAt: section.createdAt,
+                updatedAt: section.updatedAt
+              }
+            }
+          )
+        },
+        `section-${i}`
+      );
+    }) });
+  };
   exports.AsyncImg = AsyncImg;
   exports.CustomTransition = CustomTransition;
+  exports.MountedTeleport = MountedTeleport;
+  exports.ReadMore = ReadMore;
+  exports.RootContainer = RootContainer;
+  exports.StickyBottom = StickyBottom;
+  exports.StickyTop = StickyTop;
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   return exports;
-}({}, React);
+}({}, React, ReactDOM);