@opengeoweb/webmap 8.0.0 → 8.1.0

package/index.esm.js

@@ -17755,7 +17755,7 @@ var DebugType;
   DebugType[DebugType["Warning"] = 1] = "Warning";
   DebugType[DebugType["Error"] = 2] = "Error";
 })(DebugType || (DebugType = {}));
-var debug = function debug(type, message) {
+var debugLogger = function debugLogger(type, message) {
 };
 /**
  * Checks if variable is defined or not
@@ -17853,7 +17853,7 @@ var URLEncode = function URLEncode(plaintext) {
     } else {
       var charCode = ch.charCodeAt(0);
       if (charCode > 255) {
-        debug(DebugType.Warning);
+        debugLogger(DebugType.Warning);
         encoded += '+';
       } else {
         encoded += '%';
@@ -18317,7 +18317,7 @@ var WMImage = /*#__PURE__*/function () {
     key: "setSource",
     value: function setSource(src, options) {
       if (this._isLoading) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return;
       }
       this.srcToLoad = src;
@@ -18404,9 +18404,9 @@ var WMImage = /*#__PURE__*/function () {
           _this2.getElement().src = base64Flag + imageStr;
         });
       })["catch"](function () {
-        debug(DebugType.Error, "Unable to fetch image ".concat(url, " with headers [").concat(JSON.stringify(headers), "]"));
+        debugLogger(DebugType.Error, "Unable to fetch image ".concat(url, " with headers [").concat(JSON.stringify(headers), "]"));
         if (url.startsWith('http://')) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         }
         _this2._loadEvent(true);
       });
@@ -18558,11 +18558,11 @@ var WMImageStore = /*#__PURE__*/function () {
     key: "addImageEventCallback",
     value: function addImageEventCallback(callback, id) {
       if (!id) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return;
       }
       if (!callback) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return;
       }
       this._loadEventCallbackList.push({
@@ -18903,7 +18903,7 @@ var WMListener = /*#__PURE__*/function () {
             try {
               returnList.push(this._callBacks[j].functionpointer(param, this));
             } catch (e) {
-              debug(DebugType.Error);
+              debugLogger(DebugType.Error);
             }
           }
         }
@@ -19159,7 +19159,7 @@ var WMCanvasBuffer = /*#__PURE__*/function () {
         this._ctx.drawImage(imageElement, imageX, imageY, imageW, imageH);
         if (enableConsoleDebugging) ;
       } catch (e) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
     }
   }, {
@@ -19220,7 +19220,7 @@ var WMCanvasBuffer = /*#__PURE__*/function () {
       for (var j = 0; j < this.layers.length; j += 1) {
         var image = this._imageStore.getImageForSrc(this.layers[j].imageSource);
         if (image.hasError()) {
-          debug(DebugType.Error, "image error: ".concat(image.getSrc()));
+          debugLogger(DebugType.Error, "image error: ".concat(image.getSrc()));
         }
       }
       try {
@@ -19228,7 +19228,7 @@ var WMCanvasBuffer = /*#__PURE__*/function () {
           this.onLoadReadyFunction(this);
         }
       } catch (e) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
     }
   }, {
@@ -19261,7 +19261,7 @@ var WMCanvasBuffer = /*#__PURE__*/function () {
     value: function setSrc(layerIndex, imageSource, linkedInfo, opacity, bbox) {
       var _a, _b;
       if (!isDefined(imageSource)) {
-        debug(DebugType.Warning);
+        debugLogger(DebugType.Warning);
         return;
       }
       /* HTTP Headers for the image, necessary in case of certain authentication forms */
@@ -19319,29 +19319,835 @@ var WMCanvasBuffer = /*#__PURE__*/function () {
   return WMCanvasBuffer;
 }();
 
-/**
- * Prefetches given requests
- *
- * @param requests An array of requests to prefetch
- * @return The list of images in prefetch
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function toInteger(dirtyNumber) {
+  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
+    return NaN;
+  }
+  var number = Number(dirtyNumber);
+  if (isNaN(number)) {
+    return number;
+  }
+  return number < 0 ? Math.ceil(number) : Math.floor(number);
+}
+
+function requiredArgs(required, args) {
+  if (args.length < required) {
+    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
+  }
+}
+
+/**
+ * @name toDate
+ * @category Common Helpers
+ * @summary Convert the given argument to an instance of Date.
+ *
+ * @description
+ * Convert the given argument to an instance of Date.
+ *
+ * If the argument is an instance of Date, the function returns its clone.
+ *
+ * If the argument is a number, it is treated as a timestamp.
+ *
+ * If the argument is none of the above, the function returns Invalid Date.
+ *
+ * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+ *
+ * @param {Date|Number} argument - the value to convert
+ * @returns {Date} the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Clone the date:
+ * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert the timestamp to date:
+ * const result = toDate(1392098430000)
+ * //=> Tue Feb 11 2014 11:30:30
+ */
+function toDate(argument) {
+  requiredArgs(1, arguments);
+  var argStr = Object.prototype.toString.call(argument);
+
+  // Clone the date
+  if (argument instanceof Date || _typeof(argument) === 'object' && argStr === '[object Date]') {
+    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+    return new Date(argument.getTime());
+  } else if (typeof argument === 'number' || argStr === '[object Number]') {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
+      // eslint-disable-next-line no-console
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments");
+      // eslint-disable-next-line no-console
+      console.warn(new Error().stack);
+    }
+    return new Date(NaN);
+  }
+}
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} - the new date with the days added
+ * @throws {TypeError} - 2 arguments required
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+function addDays(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var date = toDate(dirtyDate);
+  var amount = toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return new Date(NaN);
+  }
+  if (!amount) {
+    // If 0 days, no-op to avoid changing times in the hour before end of DST
+    return date;
+  }
+  date.setDate(date.getDate() + amount);
+  return date;
+}
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of months to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the months added
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ */
+function addMonths(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var date = toDate(dirtyDate);
+  var amount = toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return new Date(NaN);
+  }
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return date;
+  }
+  var dayOfMonth = date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  var endOfDesiredMonth = new Date(date.getTime());
+  endOfDesiredMonth.setMonth(date.getMonth() + amount + 1, 0);
+  var daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    date.setFullYear(endOfDesiredMonth.getFullYear(), endOfDesiredMonth.getMonth(), dayOfMonth);
+    return date;
+  }
+}
+
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Duration} duration - the object with years, months, weeks, days, hours, minutes and seconds to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ *
+ * | Key            | Description                        |
+ * |----------------|------------------------------------|
+ * | years          | Amount of years to be added        |
+ * | months         | Amount of months to be added       |
+ * | weeks          | Amount of weeks to be added        |
+ * | days           | Amount of days to be added         |
+ * | hours          | Amount of hours to be added        |
+ * | minutes        | Amount of minutes to be added      |
+ * | seconds        | Amount of seconds to be added      |
+ *
+ * All values default to 0
+ *
+ * @returns {Date} the new date with the seconds added
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+function add(dirtyDate, duration) {
+  requiredArgs(2, arguments);
+  if (!duration || _typeof(duration) !== 'object') return new Date(NaN);
+  var years = duration.years ? toInteger(duration.years) : 0;
+  var months = duration.months ? toInteger(duration.months) : 0;
+  var weeks = duration.weeks ? toInteger(duration.weeks) : 0;
+  var days = duration.days ? toInteger(duration.days) : 0;
+  var hours = duration.hours ? toInteger(duration.hours) : 0;
+  var minutes = duration.minutes ? toInteger(duration.minutes) : 0;
+  var seconds = duration.seconds ? toInteger(duration.seconds) : 0;
+
+  // Add years and months
+  var date = toDate(dirtyDate);
+  var dateWithMonths = months || years ? addMonths(date, months + years * 12) : date;
+
+  // Add weeks and days
+  var dateWithDays = days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths;
+
+  // Add days, hours, minutes and seconds
+  var minutesToAdd = minutes + hours * 60;
+  var secondsToAdd = seconds + minutesToAdd * 60;
+  var msToAdd = secondsToAdd * 1000;
+  var finalDate = new Date(dateWithDays.getTime() + msToAdd);
+  return finalDate;
+}
+
+/**
+ * Days in 1 week.
+ *
+ * @name daysInWeek
+ * @constant
+ * @type {number}
+ * @default
+ */
+
+/**
+ * Milliseconds in 1 minute
+ *
+ * @name millisecondsInMinute
+ * @constant
+ * @type {number}
+ * @default
+ */
+var millisecondsInMinute = 60000;
+
+/**
+ * Milliseconds in 1 hour
+ *
+ * @name millisecondsInHour
+ * @constant
+ * @type {number}
+ * @default
+ */
+var millisecondsInHour = 3600000;
+
+/**
+ * @name isDate
+ * @category Common Helpers
+ * @summary Is the given value a date?
+ *
+ * @description
+ * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+ *
+ * @param {*} value - the value to check
+ * @returns {boolean} true if the given value is a date
+ * @throws {TypeError} 1 arguments required
+ *
+ * @example
+ * // For a valid date:
+ * const result = isDate(new Date())
+ * //=> true
+ *
+ * @example
+ * // For an invalid date:
+ * const result = isDate(new Date(NaN))
+ * //=> true
+ *
+ * @example
+ * // For some value:
+ * const result = isDate('2014-02-31')
+ * //=> false
+ *
+ * @example
+ * // For an object:
+ * const result = isDate({})
+ * //=> false
+ */
+function isDate(value) {
+  requiredArgs(1, arguments);
+  return value instanceof Date || _typeof(value) === 'object' && Object.prototype.toString.call(value) === '[object Date]';
+}
+
+/**
+ * @name isValid
+ * @category Common Helpers
+ * @summary Is the given date valid?
+ *
+ * @description
+ * Returns false if argument is Invalid Date and true otherwise.
+ * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * Invalid Date is a Date, whose time value is NaN.
+ *
+ * Time value of Date: http://es5.github.io/#x15.9.1.1
+ *
+ * @param {*} date - the date to check
+ * @returns {Boolean} the date is valid
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // For the valid date:
+ * const result = isValid(new Date(2014, 1, 31))
+ * //=> true
+ *
+ * @example
+ * // For the value, convertable into a date:
+ * const result = isValid(1393804800000)
+ * //=> true
+ *
+ * @example
+ * // For the invalid date:
+ * const result = isValid(new Date(''))
+ * //=> false
+ */
+function isValid(dirtyDate) {
+  requiredArgs(1, arguments);
+  if (!isDate(dirtyDate) && typeof dirtyDate !== 'number') {
+    return false;
+  }
+  var date = toDate(dirtyDate);
+  return !isNaN(Number(date));
+}
+
+/**
+ * @name isWithinInterval
+ * @category Interval Helpers
+ * @summary Is the given date within the interval?
+ *
+ * @description
+ * Is the given date within the interval? (Including start and end.)
+ *
+ * @param {Date|Number} date - the date to check
+ * @param {Interval} interval - the interval to check
+ * @returns {Boolean} the date is within the interval
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} The start of an interval cannot be after its end
+ * @throws {RangeError} Date in interval cannot be `Invalid Date`
+ *
+ * @example
+ * // For the date within the interval:
+ * isWithinInterval(new Date(2014, 0, 3), {
+ *   start: new Date(2014, 0, 1),
+ *   end: new Date(2014, 0, 7)
+ * })
+ * //=> true
+ *
+ * @example
+ * // For the date outside of the interval:
+ * isWithinInterval(new Date(2014, 0, 10), {
+ *   start: new Date(2014, 0, 1),
+ *   end: new Date(2014, 0, 7)
+ * })
+ * //=> false
+ *
+ * @example
+ * // For date equal to interval start:
+ * isWithinInterval(date, { start, end: date }) // => true
+ *
+ * @example
+ * // For date equal to interval end:
+ * isWithinInterval(date, { start: date, end }) // => true
+ */
+function isWithinInterval(dirtyDate, interval) {
+  requiredArgs(2, arguments);
+  var time = toDate(dirtyDate).getTime();
+  var startTime = toDate(interval.start).getTime();
+  var endTime = toDate(interval.end).getTime();
+
+  // Throw an exception if start date is after end date or if any date is `Invalid Date`
+  if (!(startTime <= endTime)) {
+    throw new RangeError('Invalid interval');
+  }
+  return time >= startTime && time <= endTime;
+}
+
+/**
+ * @name subDays
+ * @category Day Helpers
+ * @summary Subtract the specified number of days from the given date.
+ *
+ * @description
+ * Subtract the specified number of days from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of days to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the days subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 10 days from 1 September 2014:
+ * const result = subDays(new Date(2014, 8, 1), 10)
+ * //=> Fri Aug 22 2014 00:00:00
+ */
+function subDays(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addDays(dirtyDate, -amount);
+}
+
+/**
+ * @name parseISO
+ * @category Common Helpers
+ * @summary Parse ISO string
+ *
+ * @description
+ * Parse the given string in ISO 8601 format and return an instance of Date.
+ *
+ * Function accepts complete ISO 8601 formats as well as partial implementations.
+ * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+ *
+ * If the argument isn't a string, the function cannot parse the string or
+ * the values are invalid, it returns Invalid Date.
+ *
+ * @param {String} argument - the value to convert
+ * @param {Object} [options] - an object with options.
+ * @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
+ * @returns {Date} the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Convert string '2014-02-11T11:30:30' to date:
+ * const result = parseISO('2014-02-11T11:30:30')
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert string '+02014101' to date,
+ * // if the additional number of digits in the extended year format is 1:
+ * const result = parseISO('+02014101', { additionalDigits: 1 })
+ * //=> Fri Apr 11 2014 00:00:00
+ */
+function parseISO(argument, options) {
+  var _options$additionalDi;
+  requiredArgs(1, arguments);
+  var additionalDigits = toInteger((_options$additionalDi = options === null || options === void 0 ? void 0 : options.additionalDigits) !== null && _options$additionalDi !== void 0 ? _options$additionalDi : 2);
+  if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
+    throw new RangeError('additionalDigits must be 0, 1 or 2');
+  }
+  if (!(typeof argument === 'string' || Object.prototype.toString.call(argument) === '[object String]')) {
+    return new Date(NaN);
+  }
+  var dateStrings = splitDateString(argument);
+  var date;
+  if (dateStrings.date) {
+    var parseYearResult = parseYear(dateStrings.date, additionalDigits);
+    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+  }
+  if (!date || isNaN(date.getTime())) {
+    return new Date(NaN);
+  }
+  var timestamp = date.getTime();
+  var time = 0;
+  var offset;
+  if (dateStrings.time) {
+    time = parseTime(dateStrings.time);
+    if (isNaN(time)) {
+      return new Date(NaN);
+    }
+  }
+  if (dateStrings.timezone) {
+    offset = parseTimezone(dateStrings.timezone);
+    if (isNaN(offset)) {
+      return new Date(NaN);
+    }
+  } else {
+    var dirtyDate = new Date(timestamp + time);
+    // js parsed string assuming it's in UTC timezone
+    // but we need it to be parsed in our timezone
+    // so we use utc values to build date in our timezone.
+    // Year values from 0 to 99 map to the years 1900 to 1999
+    // so set year explicitly with setFullYear.
+    var result = new Date(0);
+    result.setFullYear(dirtyDate.getUTCFullYear(), dirtyDate.getUTCMonth(), dirtyDate.getUTCDate());
+    result.setHours(dirtyDate.getUTCHours(), dirtyDate.getUTCMinutes(), dirtyDate.getUTCSeconds(), dirtyDate.getUTCMilliseconds());
+    return result;
+  }
+  return new Date(timestamp + time + offset);
+}
+var patterns = {
+  dateTimeDelimiter: /[T ]/,
+  timeZoneDelimiter: /[Z ]/i,
+  timezone: /([Z+-].*)$/
+};
+var dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+var timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+var timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function splitDateString(dateString) {
+  var dateStrings = {};
+  var array = dateString.split(patterns.dateTimeDelimiter);
+  var timeString;
+
+  // The regex match should only return at maximum two array elements.
+  // [date], [time], or [date, time].
+  if (array.length > 2) {
+    return dateStrings;
+  }
+  if (/:/.test(array[0])) {
+    timeString = array[0];
+  } else {
+    dateStrings.date = array[0];
+    timeString = array[1];
+    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+      timeString = dateString.substr(dateStrings.date.length, dateString.length);
+    }
+  }
+  if (timeString) {
+    var token = patterns.timezone.exec(timeString);
+    if (token) {
+      dateStrings.time = timeString.replace(token[1], '');
+      dateStrings.timezone = token[1];
+    } else {
+      dateStrings.time = timeString;
+    }
+  }
+  return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+  var regex = new RegExp('^(?:(\\d{4}|[+-]\\d{' + (4 + additionalDigits) + '})|(\\d{2}|[+-]\\d{' + (2 + additionalDigits) + '})$)');
+  var captures = dateString.match(regex);
+  // Invalid ISO-formatted year
+  if (!captures) return {
+    year: NaN,
+    restDateString: ''
+  };
+  var year = captures[1] ? parseInt(captures[1]) : null;
+  var century = captures[2] ? parseInt(captures[2]) : null;
+
+  // either year or century is null, not both
+  return {
+    year: century === null ? year : century * 100,
+    restDateString: dateString.slice((captures[1] || captures[2]).length)
+  };
+}
+function parseDate(dateString, year) {
+  // Invalid ISO-formatted year
+  if (year === null) return new Date(NaN);
+  var captures = dateString.match(dateRegex);
+  // Invalid ISO-formatted string
+  if (!captures) return new Date(NaN);
+  var isWeekDate = !!captures[4];
+  var dayOfYear = parseDateUnit(captures[1]);
+  var month = parseDateUnit(captures[2]) - 1;
+  var day = parseDateUnit(captures[3]);
+  var week = parseDateUnit(captures[4]);
+  var dayOfWeek = parseDateUnit(captures[5]) - 1;
+  if (isWeekDate) {
+    if (!validateWeekDate(year, week, dayOfWeek)) {
+      return new Date(NaN);
+    }
+    return dayOfISOWeekYear(year, week, dayOfWeek);
+  } else {
+    var date = new Date(0);
+    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
+      return new Date(NaN);
+    }
+    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+    return date;
+  }
+}
+function parseDateUnit(value) {
+  return value ? parseInt(value) : 1;
+}
+function parseTime(timeString) {
+  var captures = timeString.match(timeRegex);
+  if (!captures) return NaN; // Invalid ISO-formatted time
+
+  var hours = parseTimeUnit(captures[1]);
+  var minutes = parseTimeUnit(captures[2]);
+  var seconds = parseTimeUnit(captures[3]);
+  if (!validateTime(hours, minutes, seconds)) {
+    return NaN;
+  }
+  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1000;
+}
+function parseTimeUnit(value) {
+  return value && parseFloat(value.replace(',', '.')) || 0;
+}
+function parseTimezone(timezoneString) {
+  if (timezoneString === 'Z') return 0;
+  var captures = timezoneString.match(timezoneRegex);
+  if (!captures) return 0;
+  var sign = captures[1] === '+' ? -1 : 1;
+  var hours = parseInt(captures[2]);
+  var minutes = captures[3] && parseInt(captures[3]) || 0;
+  if (!validateTimezone(hours, minutes)) {
+    return NaN;
+  }
+  return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+  var date = new Date(0);
+  date.setUTCFullYear(isoWeekYear, 0, 4);
+  var fourthOfJanuaryDay = date.getUTCDay() || 7;
+  var diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+  date.setUTCDate(date.getUTCDate() + diff);
+  return date;
+}
+
+// Validation functions
+
+// February is null to handle the leap year (using ||)
+var daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYearIndex(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date) {
+  return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+}
+function validateDayOfYearDate(year, dayOfYear) {
+  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+}
+function validateWeekDate(_year, week, day) {
+  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+}
+function validateTime(hours, minutes, seconds) {
+  if (hours === 24) {
+    return minutes === 0 && seconds === 0;
+  }
+  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+}
+function validateTimezone(_hours, minutes) {
+  return minutes >= 0 && minutes <= 59;
+}
+
+/**
+ * @name subMonths
+ * @category Month Helpers
+ * @summary Subtract the specified number of months from the given date.
+ *
+ * @description
+ * Subtract the specified number of months from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of months to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the months subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 5 months from 1 February 2015:
+ * const result = subMonths(new Date(2015, 1, 1), 5)
+ * //=> Mon Sep 01 2014 00:00:00
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-var prefetch = function prefetch(requests) {
-  var prefetching = [];
+function subMonths(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addMonths(dirtyDate, -amount);
+}
+
+/**
+ * @name sub
+ * @category Common Helpers
+ * @summary Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
+ *
+ * @description
+ * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Duration} duration - the object with years, months, weeks, days, hours, minutes and seconds to be subtracted
+ *
+ * | Key     | Description                        |
+ * |---------|------------------------------------|
+ * | years   | Amount of years to be subtracted   |
+ * | months  | Amount of months to be subtracted  |
+ * | weeks   | Amount of weeks to be subtracted   |
+ * | days    | Amount of days to be subtracted    |
+ * | hours   | Amount of hours to be subtracted   |
+ * | minutes | Amount of minutes to be subtracted |
+ * | seconds | Amount of seconds to be subtracted |
+ *
+ * All values default to 0
+ *
+ * @returns {Date} the new date with the seconds subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract the following duration from 15 June 2017 15:29:20
+ * const result = sub(new Date(2017, 5, 15, 15, 29, 20), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30
+ * })
+ * //=> Mon Sep 1 2014 10:19:50
+ */
+function sub(date, duration) {
+  requiredArgs(2, arguments);
+  if (!duration || _typeof(duration) !== 'object') return new Date(NaN);
+  var years = duration.years ? toInteger(duration.years) : 0;
+  var months = duration.months ? toInteger(duration.months) : 0;
+  var weeks = duration.weeks ? toInteger(duration.weeks) : 0;
+  var days = duration.days ? toInteger(duration.days) : 0;
+  var hours = duration.hours ? toInteger(duration.hours) : 0;
+  var minutes = duration.minutes ? toInteger(duration.minutes) : 0;
+  var seconds = duration.seconds ? toInteger(duration.seconds) : 0;
+
+  // Subtract years and months
+  var dateWithoutMonths = subMonths(date, months + years * 12);
+
+  // Subtract weeks and days
+  var dateWithoutDays = subDays(dateWithoutMonths, days + weeks * 7);
+
+  // Subtract hours, minutes and seconds
+  var minutestoSub = minutes + hours * 60;
+  var secondstoSub = seconds + minutestoSub * 60;
+  var mstoSub = secondstoSub * 1000;
+  var finalDate = new Date(dateWithoutDays.getTime() - mstoSub);
+  return finalDate;
+}
+
+var MAX_IMAGES_TO_PREFETCH_DEFAULT = 8;
+function prefetchImagesForAnimation(wmMap) {
+  var maxImagesToPrefetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : MAX_IMAGES_TO_PREFETCH_DEFAULT;
+  var animationSteps = wmMap.animationList;
+  var countAnimationSteps = animationSteps.length;
+  var timesToPrefetchInOrder = lodash.exports.range(0, countAnimationSteps).map(function (offset) {
+    // start prefecthing images for the next animation step first
+    // when reaching end of animation, start from the beginning
+    var indexOfNextAnimationStep = (wmMap.currentAnimationStep + offset) % countAnimationSteps;
+    return animationSteps[indexOfNextAnimationStep].value;
+  });
+  var currentTime = animationSteps[wmMap.currentAnimationStep].value;
+  prefetchLayerImagesInOrder(wmMap, timesToPrefetchInOrder, maxImagesToPrefetch, currentTime);
+}
+function prefetchLayerImagesInOrder(wmMap, timesToPrefetchInOrder, maxImagesToPrefetch, currentTime) {
+  var _iterator = _createForOfIteratorHelper(timesToPrefetchInOrder),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var timeToPrefetch = _step.value;
+      // dont prefetch if already prefetching too many images
+      var countImagesLoading = getMapImageStore.getNumImagesLoading();
+      if (countImagesLoading > maxImagesToPrefetch - 1) {
+        break;
+      }
+      var layersImageUrls = getLayersImageUrlsForTime(wmMap, timeToPrefetch, currentTime);
+      prefetchLayerImagesForTime(layersImageUrls);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function getLayersImageUrlsForTime(wmMap, timeToPrefetch, currentTime) {
+  // get urls for layers at time
+  wmMap.setTimeDimension(timeToPrefetch, false);
+  var layersImageUrls = wmMap.getWMSRequests();
+  // set map back to correct time
+  wmMap.setTimeDimension(currentTime, false);
+  return layersImageUrls;
+}
+function prefetchLayerImagesForTime(requests) {
   requests.forEach(function (request) {
     var image = getMapImageStore.getImage(request.url, {
       headers: request.headers
     });
     if (image.hasNotStartedLoading()) {
-      prefetching.push(image);
       image.load();
     }
   });
-  return prefetching;
-};
+}
+function prefetchImagesForNonAnimation(wmMap) {
+  var maxImagesToPrefetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : MAX_IMAGES_TO_PREFETCH_DEFAULT;
+  var timestepInMinutes = wmMap.timestepInMinutes;
+  var timeDimension = wmMap.getDimension('time');
+  if (!timeDimension || !timestepInMinutes) {
+    return;
+  }
+  var currentValue = timeDimension.currentValue;
+  var currentTimeIsoString = timeDimension.getClosestValue(currentValue);
+  var currentTime = parseISO(currentTimeIsoString);
+  if (!isValid(currentTime)) {
+    return;
+  }
+  var maxTimesToPrefetchIfOneLayer = maxImagesToPrefetch / 2;
+  var timesToPrefetchInOrder = lodash.exports.range(0, maxTimesToPrefetchIfOneLayer).flatMap(function (offset) {
+    var duration = {
+      minutes: timestepInMinutes * offset
+    };
+    var nextTime = add(currentTime, duration).toISOString();
+    var previousTime = sub(currentTime, duration).toISOString();
+    return [nextTime, previousTime];
+  });
+  prefetchLayerImagesInOrder(wmMap, timesToPrefetchInOrder, maxImagesToPrefetch, currentTime.toISOString());
+}
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2020 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2020 - Finnish Meteorological Institute (FMI)
+ * */
+var _WMJSAnimate_instances, _WMJSAnimate_animate;
 var WMJSAnimate = /*#__PURE__*/function () {
   function WMJSAnimate(_map) {
     _classCallCheck(this, WMJSAnimate);
+    _WMJSAnimate_instances.add(this);
     this._imageStore = getMapImageStore;
     this.isNextTimeCloseToWallClockTime = false;
     _map.animationDelay = 100;
@@ -19367,15 +20173,11 @@ var WMJSAnimate = /*#__PURE__*/function () {
     this._divAnimationInfo.style.fontFamily = '"Courier New", "Lucida Console", Monospace';
     this._divAnimationInfo.style.fontSize = '10px';
     _map.getBaseElement().append(this._divAnimationInfo);
-    _map.isAnimatingLoopRunning = false;
     this._map = _map;
     /* Bind */
-    this._animate = this._animate.bind(this);
-    this._animateLoop = this._animateLoop.bind(this);
-    this.prefetchImagesForAnimationSteps = this.prefetchImagesForAnimationSteps.bind(this);
+    this.loopAnimation = this.loopAnimation.bind(this);
     this.stopAnimating = this.stopAnimating.bind(this);
     _map.stopAnimating = this.stopAnimating;
-    _map.checkAnimation = this.prefetchImagesForAnimationSteps;
   }
   _createClass(WMJSAnimate, [{
     key: "isCurrentAnimationTimeCloseToWallClockTime",
@@ -19403,31 +20205,10 @@ var WMJSAnimate = /*#__PURE__*/function () {
       return false;
     }
   }, {
-    key: "_animate",
-    value: function _animate() {
-      if (this._map.isAnimating === false) {
-        return;
-      }
-      if (this._map.animateBusy === true) {
-        return;
-      }
-      var animationStep = this._map.animationList[this._map.currentAnimationStep];
-      if (!animationStep) {
-        debug(DebugType.Error, "No animation step for ".concat(this._map.currentAnimationStep));
-        return;
-      }
-      this._map.setDimension(animationStep.name, animationStep.value, false);
-      this._callBack.triggerEvent('ondimchange');
-      this._callBack.triggerEvent('onnextanimationstep', this._map);
-      this._map.addLayersToCanvasAndDisplayThem();
-      this._map.animateBusy = false;
-    }
-  }, {
-    key: "_animateLoop",
-    value: function _animateLoop() {
+    key: "loopAnimation",
+    value: function loopAnimation() {
       var _this = this;
       if (this._map.isAnimating === false) {
-        this._map.isAnimatingLoopRunning = false;
         return;
       }
       var animationDelay = this._map.animationDelay;
@@ -19440,23 +20221,22 @@ var WMJSAnimate = /*#__PURE__*/function () {
         animationDelay *= 5;
       }
       // set up timer for next animation step
-      this._map.animationTimer.init(animationDelay, this._animateLoop);
-      this.prefetchImagesForAnimationSteps();
+      this._map.animationTimer.init(animationDelay, this.loopAnimation);
+      prefetchImagesForAnimation(this._map);
       if (this._map.mouseHoverAnimationBox !== false) {
         return;
       }
-      this._animate();
+      __classPrivateFieldGet(this, _WMJSAnimate_instances, "m", _WMJSAnimate_animate).call(this);
       var nextAnimationStepIndex = this._map.currentAnimationStep + 1;
       if (nextAnimationStepIndex >= animationSteps.length) {
         nextAnimationStepIndex = 0;
       }
       // get urls for images in next animation step
-      var nextAnimationStep = animationSteps[nextAnimationStepIndex];
-      nextAnimationStep.requests = this.getRequestsForAnimationStep(animationSteps, nextAnimationStepIndex);
+      var layersImageUrls = getLayersImageUrlsForTime(this._map, animationSteps[nextAnimationStepIndex].value, animationSteps[this._map.currentAnimationStep].value);
       // if images for next animation step is ready or haven't started loading
       // change map animation step to next step
       var numberOfImagesReadyForNextAnimationStep = 0;
-      nextAnimationStep.requests.forEach(function (request) {
+      layersImageUrls.forEach(function (request) {
         var url = request.url;
         var image = getMapImageStore.getImageForSrc(url);
         /* Get a loaded image which has no error */
@@ -19470,57 +20250,14 @@ var WMJSAnimate = /*#__PURE__*/function () {
           numberOfImagesReadyForNextAnimationStep += 1;
           return;
         }
-        var imageHasntStartedLoading = !(image === null || image === void 0 ? void 0 : image.isLoading());
-        if (imageHasntStartedLoading) {
-          /* No alternatives and current image is not loading, so lets continue the animation */
-          numberOfImagesReadyForNextAnimationStep += 1;
-        }
-      });
-      if (numberOfImagesReadyForNextAnimationStep >= nextAnimationStep.requests.length) {
-        this._map.currentAnimationStep = nextAnimationStepIndex;
-      }
-    }
-  }, {
-    key: "prefetchImagesForAnimationSteps",
-    value: function prefetchImagesForAnimationSteps() {
-      if (this._map.isAnimating === false) {
-        this._map.isAnimatingLoopRunning = false;
-        return;
-      }
-      if (!this._map.animationTimer) {
-        this._map.animationTimer = new WMTimer();
-      }
-      var animationSteps = this._map.animationList;
-      var countAnimationSteps = animationSteps === null || animationSteps === void 0 ? void 0 : animationSteps.length;
-      if (countAnimationSteps && this._map.mouseHoverAnimationBox === false) {
-        for (var j = 0; j < countAnimationSteps; j += 1) {
-          // dont prefetch if already prefetching too many images
-          var maxSimultaneousLoads = 4;
-          var countImagesLoading = this._imageStore.getNumImagesLoading();
-          if (countImagesLoading > maxSimultaneousLoads - 1) {
-            break;
-          }
-          // start prefecthing images for the next animation step first
-          var index = j + this._map.currentAnimationStep;
-          while (index < 0) {
-            index += countAnimationSteps;
-          }
-          while (index >= countAnimationSteps) {
-            index -= countAnimationSteps;
-          }
-          if (index < 0) {
-            index = 0;
-          }
-          // get urls for animation step
-          var animationStep = animationSteps[index];
-          animationStep.requests = this.getRequestsForAnimationStep(animationSteps, index);
-          // prefetch images for animation step
-          animationStep.imagesInPrefetch = prefetch(animationStep.requests);
+        var imageHasntStartedLoading = !(image === null || image === void 0 ? void 0 : image.isLoading());
+        if (imageHasntStartedLoading) {
+          /* No alternatives and current image is not loading, so lets continue the animation */
+          numberOfImagesReadyForNextAnimationStep += 1;
         }
-      }
-      if (this._map.isAnimatingLoopRunning === false) {
-        this._map.isAnimatingLoopRunning = true;
-        this._animateLoop();
+      });
+      if (numberOfImagesReadyForNextAnimationStep >= layersImageUrls.length) {
+        this._map.currentAnimationStep = nextAnimationStepIndex;
       }
     }
   }, {
@@ -19536,21 +20273,27 @@ var WMJSAnimate = /*#__PURE__*/function () {
       this._map.rebuildMapDimensions();
       this._callBack.triggerEvent('onstopanimation', this._map);
     }
-  }, {
-    key: "getRequestsForAnimationStep",
-    value: function getRequestsForAnimationStep(animationSteps, index) {
-      // get urls for animation step
-      var animationStep = animationSteps[index];
-      this._map.setDimension(animationStep.name, animationStep.value, false);
-      var requests = this._map.getWMSRequests();
-      // set map back to correct dimension
-      var animationStepShownOnMap = animationSteps[this._map.currentAnimationStep];
-      this._map.setDimension(animationStepShownOnMap.name, animationStepShownOnMap.value, false);
-      return requests;
-    }
   }]);
   return WMJSAnimate;
 }();
+_WMJSAnimate_instances = new WeakSet(), _WMJSAnimate_animate = function _WMJSAnimate_animate() {
+  if (this._map.isAnimating === false) {
+    return;
+  }
+  if (this._map.animateBusy === true) {
+    return;
+  }
+  var animationStep = this._map.animationList[this._map.currentAnimationStep];
+  if (!animationStep) {
+    debugLogger(DebugType.Error, "No animation step for ".concat(this._map.currentAnimationStep));
+    return;
+  }
+  this._map.setDimension(animationStep.name, animationStep.value, false);
+  this._callBack.triggerEvent('ondimchange');
+  this._callBack.triggerEvent('onnextanimationstep', this._map);
+  this._map.addLayersToCanvasAndDisplayThem();
+  this._map.animateBusy = false;
+};
 
 var WMTileRenderer = /*#__PURE__*/function () {
   function WMTileRenderer() {
@@ -19564,7 +20307,7 @@ var WMTileRenderer = /*#__PURE__*/function () {
       var renderedURLs = {};
       var imagesToRender = [];
       if (!layerName) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return undefined;
       }
       /* Temporal mappings from bgmaps.cgi service names to names defined here */
@@ -19579,7 +20322,7 @@ var WMTileRenderer = /*#__PURE__*/function () {
       }
       var tileLayer = tileOptions[layerName];
       if (!tileLayer) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return undefined;
       }
       var tileSettings = tileLayer[srs];
@@ -19769,11 +20512,11 @@ var WMTileRenderer = /*#__PURE__*/function () {
           tilenright = numTilesAtLevelX;
         }
         if (tilentop - tilenbottom > 20) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
           return;
         }
         if (tilenright - tilenleft > 20) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
           return;
         }
         for (var ty = tilenbottom - 1; ty < tilentop; ty += 1) {
@@ -19895,7 +20638,7 @@ var drawLegend = function drawLegend(canvasContext, width, height, layers) {
             try {
               ctx.drawImage(el, legendX, legendY);
             } catch (e) {
-              debug(DebugType.Error);
+              debugLogger(DebugType.Error);
             }
           }
         }
@@ -25011,1043 +25754,581 @@ var moment$1 = {exports: {}};
 
         for (i = 0; i < 7; i++) {
             out[i] = get$1(format, (i + shift) % 7, field, 'day');
-        }
-        return out;
-    }
-
-    function listMonths(format, index) {
-        return listMonthsImpl(format, index, 'months');
-    }
-
-    function listMonthsShort(format, index) {
-        return listMonthsImpl(format, index, 'monthsShort');
-    }
-
-    function listWeekdays(localeSorted, format, index) {
-        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
-    }
-
-    function listWeekdaysShort(localeSorted, format, index) {
-        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
-    }
-
-    function listWeekdaysMin(localeSorted, format, index) {
-        return listWeekdaysImpl(localeSorted, format, 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 (number) {
-            var b = number % 10,
-                output =
-                    toInt((number % 100) / 10) === 1
-                        ? 'th'
-                        : b === 1
-                        ? 'st'
-                        : b === 2
-                        ? 'nd'
-                        : b === 3
-                        ? 'rd'
-                        : 'th';
-            return number + output;
-        },
-    });
-
-    // Side effect imports
-
-    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();
-    }
-
-    // supports only 2.0-style add(1, 's') or add(duration)
-    function add$1(input, value) {
-        return addSubtract$1(this, input, value, 1);
-    }
-
-    // supports only 2.0-style subtract(1, 's') or subtract(duration)
-    function subtract$1(input, value) {
-        return addSubtract$1(this, input, value, -1);
-    }
-
-    function absCeil(number) {
-        if (number < 0) {
-            return Math.floor(number);
-        } else {
-            return Math.ceil(number);
-        }
-    }
-
-    function bubble() {
-        var milliseconds = this._milliseconds,
-            days = this._days,
-            months = this._months,
-            data = this._data,
-            seconds,
-            minutes,
-            hours,
-            years,
-            monthsFromDays;
-
-        // if we have a mix of positive and negative values, bubble down first
-        // check: https://github.com/moment/moment/issues/2166
-        if (
-            !(
-                (milliseconds >= 0 && days >= 0 && months >= 0) ||
-                (milliseconds <= 0 && days <= 0 && months <= 0)
-            )
-        ) {
-            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
-            days = 0;
-            months = 0;
-        }
-
-        // The following code bubbles up values, see the tests for
-        // examples of what that means.
-        data.milliseconds = milliseconds % 1000;
-
-        seconds = absFloor(milliseconds / 1000);
-        data.seconds = seconds % 60;
-
-        minutes = absFloor(seconds / 60);
-        data.minutes = minutes % 60;
-
-        hours = absFloor(minutes / 60);
-        data.hours = hours % 24;
-
-        days += absFloor(hours / 24);
-
-        // convert days to months
-        monthsFromDays = absFloor(daysToMonths(days));
-        months += monthsFromDays;
-        days -= absCeil(monthsToDays(monthsFromDays));
-
-        // 12 months -> 1 year
-        years = absFloor(months / 12);
-        months %= 12;
-
-        data.days = days;
-        data.months = months;
-        data.years = years;
-
-        return this;
-    }
-
-    function daysToMonths(days) {
-        // 400 years have 146097 days (taking into account leap year rules)
-        // 400 years have 12 months === 4800
-        return (days * 4800) / 146097;
-    }
-
-    function monthsToDays(months) {
-        // the reverse of daysToMonths
-        return (months * 146097) / 4800;
-    }
-
-    function as(units) {
-        if (!this.isValid()) {
-            return NaN;
-        }
-        var days,
-            months,
-            milliseconds = this._milliseconds;
-
-        units = normalizeUnits(units);
-
-        if (units === 'month' || units === 'quarter' || units === 'year') {
-            days = this._days + milliseconds / 864e5;
-            months = this._months + daysToMonths(days);
-            switch (units) {
-                case 'month':
-                    return months;
-                case 'quarter':
-                    return months / 3;
-                case 'year':
-                    return months / 12;
-            }
-        } else {
-            // handle milliseconds separately because of floating point math errors (issue #1867)
-            days = this._days + Math.round(monthsToDays(this._months));
-            switch (units) {
-                case 'week':
-                    return days / 7 + milliseconds / 6048e5;
-                case 'day':
-                    return days + milliseconds / 864e5;
-                case 'hour':
-                    return days * 24 + milliseconds / 36e5;
-                case 'minute':
-                    return days * 1440 + milliseconds / 6e4;
-                case 'second':
-                    return days * 86400 + milliseconds / 1000;
-                // Math.floor prevents floating point math errors here
-                case 'millisecond':
-                    return Math.floor(days * 864e5) + milliseconds;
-                default:
-                    throw new Error('Unknown unit ' + units);
-            }
-        }
-    }
-
-    // TODO: Use this.as('ms')?
-    function valueOf$1() {
-        if (!this.isValid()) {
-            return NaN;
-        }
-        return (
-            this._milliseconds +
-            this._days * 864e5 +
-            (this._months % 12) * 2592e6 +
-            toInt(this._months / 12) * 31536e6
-        );
+        }
+        return out;
     }
 
-    function makeAs(alias) {
-        return function () {
-            return this.as(alias);
-        };
+    function listMonths(format, index) {
+        return listMonthsImpl(format, index, 'months');
     }
 
-    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');
+    function listMonthsShort(format, index) {
+        return listMonthsImpl(format, index, 'monthsShort');
+    }
 
-    function clone$1() {
-        return createDuration(this);
+    function listWeekdays(localeSorted, format, index) {
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
     }
 
-    function get$2(units) {
-        units = normalizeUnits(units);
-        return this.isValid() ? this[units + 's']() : NaN;
+    function listWeekdaysShort(localeSorted, format, index) {
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
     }
 
-    function makeGetter(name) {
-        return function () {
-            return this.isValid() ? this._data[name] : NaN;
-        };
+    function listWeekdaysMin(localeSorted, format, index) {
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
     }
 
-    var milliseconds = makeGetter('milliseconds'),
-        seconds = makeGetter('seconds'),
-        minutes = makeGetter('minutes'),
-        hours = makeGetter('hours'),
-        days = makeGetter('days'),
-        months = makeGetter('months'),
-        years = makeGetter('years');
+    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 (number) {
+            var b = number % 10,
+                output =
+                    toInt((number % 100) / 10) === 1
+                        ? 'th'
+                        : b === 1
+                        ? 'st'
+                        : b === 2
+                        ? 'nd'
+                        : b === 3
+                        ? 'rd'
+                        : 'th';
+            return number + output;
+        },
+    });
 
-    function weeks() {
-        return absFloor(this.days() / 7);
-    }
+    // Side effect imports
 
-    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
-        };
+    hooks.lang = deprecate(
+        'moment.lang is deprecated. Use moment.locale instead.',
+        getSetGlobalLocale
+    );
+    hooks.langData = deprecate(
+        'moment.langData is deprecated. Use moment.localeData instead.',
+        getLocale
+    );
 
-    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
-    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
-        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
-    }
+    var mathAbs = Math.abs;
 
-    function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
-        var duration = createDuration(posNegDuration).abs(),
-            seconds = round(duration.as('s')),
-            minutes = round(duration.as('m')),
-            hours = round(duration.as('h')),
-            days = round(duration.as('d')),
-            months = round(duration.as('M')),
-            weeks = round(duration.as('w')),
-            years = round(duration.as('y')),
-            a =
-                (seconds <= thresholds.ss && ['s', seconds]) ||
-                (seconds < thresholds.s && ['ss', seconds]) ||
-                (minutes <= 1 && ['m']) ||
-                (minutes < thresholds.m && ['mm', minutes]) ||
-                (hours <= 1 && ['h']) ||
-                (hours < thresholds.h && ['hh', hours]) ||
-                (days <= 1 && ['d']) ||
-                (days < thresholds.d && ['dd', days]);
+    function abs() {
+        var data = this._data;
 
-        if (thresholds.w != null) {
-            a =
-                a ||
-                (weeks <= 1 && ['w']) ||
-                (weeks < thresholds.w && ['ww', weeks]);
-        }
-        a = a ||
-            (months <= 1 && ['M']) ||
-            (months < thresholds.M && ['MM', months]) ||
-            (years <= 1 && ['y']) || ['yy', years];
+        this._milliseconds = mathAbs(this._milliseconds);
+        this._days = mathAbs(this._days);
+        this._months = mathAbs(this._months);
 
-        a[2] = withoutSuffix;
-        a[3] = +posNegDuration > 0;
-        a[4] = locale;
-        return substituteTimeAgo.apply(null, a);
-    }
+        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);
 
-    // This function allows you to set the rounding function for relative time strings
-    function getSetRelativeTimeRounding(roundingFunction) {
-        if (roundingFunction === undefined) {
-            return round;
-        }
-        if (typeof roundingFunction === 'function') {
-            round = roundingFunction;
-            return true;
-        }
-        return false;
+        return this;
     }
 
-    // This function allows you to set a threshold for relative time strings
-    function getSetRelativeTimeThreshold(threshold, limit) {
-        if (thresholds[threshold] === undefined) {
-            return false;
-        }
-        if (limit === undefined) {
-            return thresholds[threshold];
-        }
-        thresholds[threshold] = limit;
-        if (threshold === 's') {
-            thresholds.ss = limit - 1;
-        }
-        return true;
-    }
+    function addSubtract$1(duration, input, value, direction) {
+        var other = createDuration(input, value);
 
-    function humanize(argWithSuffix, argThresholds) {
-        if (!this.isValid()) {
-            return this.localeData().invalidDate();
-        }
+        duration._milliseconds += direction * other._milliseconds;
+        duration._days += direction * other._days;
+        duration._months += direction * other._months;
 
-        var withSuffix = false,
-            th = thresholds,
-            locale,
-            output;
+        return duration._bubble();
+    }
 
-        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;
-            }
-        }
+    // supports only 2.0-style add(1, 's') or add(duration)
+    function add$1(input, value) {
+        return addSubtract$1(this, input, value, 1);
+    }
 
-        locale = this.localeData();
-        output = relativeTime$1(this, !withSuffix, th, locale);
+    // supports only 2.0-style subtract(1, 's') or subtract(duration)
+    function subtract$1(input, value) {
+        return addSubtract$1(this, input, value, -1);
+    }
 
-        if (withSuffix) {
-            output = locale.pastFuture(+this, output);
+    function absCeil(number) {
+        if (number < 0) {
+            return Math.floor(number);
+        } else {
+            return Math.ceil(number);
         }
-
-        return locale.postformat(output);
     }
 
-    var abs$1 = Math.abs;
-
-    function sign(x) {
-        return (x > 0) - (x < 0) || +x;
-    }
+    function bubble() {
+        var milliseconds = this._milliseconds,
+            days = this._days,
+            months = this._months,
+            data = this._data,
+            seconds,
+            minutes,
+            hours,
+            years,
+            monthsFromDays;
 
-    function toISOString$1() {
-        // for ISO strings we do not use the normal bubbling rules:
-        //  * milliseconds bubble up until they become hours
-        //  * days do not bubble at all
-        //  * months bubble up until they become years
-        // This is because there is no context-free conversion between hours and days
-        // (think of clock changes)
-        // and also not between days and months (28-31 days per month)
-        if (!this.isValid()) {
-            return this.localeData().invalidDate();
+        // if we have a mix of positive and negative values, bubble down first
+        // check: https://github.com/moment/moment/issues/2166
+        if (
+            !(
+                (milliseconds >= 0 && days >= 0 && months >= 0) ||
+                (milliseconds <= 0 && days <= 0 && months <= 0)
+            )
+        ) {
+            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+            days = 0;
+            months = 0;
         }
 
-        var seconds = abs$1(this._milliseconds) / 1000,
-            days = abs$1(this._days),
-            months = abs$1(this._months),
-            minutes,
-            hours,
-            years,
-            s,
-            total = this.asSeconds(),
-            totalSign,
-            ymSign,
-            daysSign,
-            hmsSign;
+        // The following code bubbles up values, see the tests for
+        // examples of what that means.
+        data.milliseconds = milliseconds % 1000;
 
-        if (!total) {
-            // this is the same as C#'s (Noda) and python (isodate)...
-            // but not other JS (goog.date)
-            return 'P0D';
-        }
+        seconds = absFloor(milliseconds / 1000);
+        data.seconds = seconds % 60;
 
-        // 3600 seconds -> 60 minutes -> 1 hour
         minutes = absFloor(seconds / 60);
+        data.minutes = minutes % 60;
+
         hours = absFloor(minutes / 60);
-        seconds %= 60;
-        minutes %= 60;
+        data.hours = hours % 24;
+
+        days += absFloor(hours / 24);
+
+        // convert days to months
+        monthsFromDays = absFloor(daysToMonths(days));
+        months += monthsFromDays;
+        days -= absCeil(monthsToDays(monthsFromDays));
 
         // 12 months -> 1 year
         years = absFloor(months / 12);
         months %= 12;
 
-        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
-        s = seconds ? seconds.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) ? '-' : '';
+        data.days = days;
+        data.months = months;
+        data.years = years;
 
-        return (
-            totalSign +
-            'P' +
-            (years ? ymSign + years + 'Y' : '') +
-            (months ? ymSign + months + 'M' : '') +
-            (days ? daysSign + days + 'D' : '') +
-            (hours || minutes || seconds ? 'T' : '') +
-            (hours ? hmsSign + hours + 'H' : '') +
-            (minutes ? hmsSign + minutes + 'M' : '') +
-            (seconds ? hmsSign + s + 'S' : '')
-        );
+        return this;
     }
 
-    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;
-
-    // FORMATTING
+    function daysToMonths(days) {
+        // 400 years have 146097 days (taking into account leap year rules)
+        // 400 years have 12 months === 4800
+        return (days * 4800) / 146097;
+    }
 
-    addFormatToken('X', 0, 0, 'unix');
-    addFormatToken('x', 0, 0, 'valueOf');
+    function monthsToDays(months) {
+        // the reverse of daysToMonths
+        return (months * 146097) / 4800;
+    }
 
-    // PARSING
+    function as(units) {
+        if (!this.isValid()) {
+            return NaN;
+        }
+        var days,
+            months,
+            milliseconds = this._milliseconds;
 
-    addRegexToken('x', matchSigned);
-    addRegexToken('X', matchTimestamp);
-    addParseToken('X', function (input, array, config) {
-        config._d = new Date(parseFloat(input) * 1000);
-    });
-    addParseToken('x', function (input, array, config) {
-        config._d = new Date(toInt(input));
-    });
+        units = normalizeUnits(units);
 
-    //! moment.js
+        if (units === 'month' || units === 'quarter' || units === 'year') {
+            days = this._days + milliseconds / 864e5;
+            months = this._months + daysToMonths(days);
+            switch (units) {
+                case 'month':
+                    return months;
+                case 'quarter':
+                    return months / 3;
+                case 'year':
+                    return months / 12;
+            }
+        } else {
+            // handle milliseconds separately because of floating point math errors (issue #1867)
+            days = this._days + Math.round(monthsToDays(this._months));
+            switch (units) {
+                case 'week':
+                    return days / 7 + milliseconds / 6048e5;
+                case 'day':
+                    return days + milliseconds / 864e5;
+                case 'hour':
+                    return days * 24 + milliseconds / 36e5;
+                case 'minute':
+                    return days * 1440 + milliseconds / 6e4;
+                case 'second':
+                    return days * 86400 + milliseconds / 1000;
+                // Math.floor prevents floating point math errors here
+                case 'millisecond':
+                    return Math.floor(days * 864e5) + milliseconds;
+                default:
+                    throw new Error('Unknown unit ' + units);
+            }
+        }
+    }
 
-    hooks.version = '2.29.4';
+    // TODO: Use this.as('ms')?
+    function valueOf$1() {
+        if (!this.isValid()) {
+            return NaN;
+        }
+        return (
+            this._milliseconds +
+            this._days * 864e5 +
+            (this._months % 12) * 2592e6 +
+            toInt(this._months / 12) * 31536e6
+        );
+    }
 
-    setHookCallback(createLocal);
+    function makeAs(alias) {
+        return function () {
+            return this.as(alias);
+        };
+    }
 
-    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;
+    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');
 
-    // currently HTML5 input type only supports 24-hour formats
-    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" />
-    };
+    function clone$1() {
+        return createDuration(this);
+    }
 
-    return hooks;
+    function get$2(units) {
+        units = normalizeUnits(units);
+        return this.isValid() ? this[units + 's']() : NaN;
+    }
 
-})));
-}(moment$1));
+    function makeGetter(name) {
+        return function () {
+            return this.isValid() ? this._data[name] : NaN;
+        };
+    }
 
-var moment = moment$1.exports;
+    var milliseconds = makeGetter('milliseconds'),
+        seconds = makeGetter('seconds'),
+        minutes = makeGetter('minutes'),
+        hours = makeGetter('hours'),
+        days = makeGetter('days'),
+        months = makeGetter('months'),
+        years = makeGetter('years');
 
-function _typeof(o) {
-  "@babel/helpers - typeof";
+    function weeks() {
+        return absFloor(this.days() / 7);
+    }
 
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-    return typeof o;
-  } : function (o) {
-    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-  }, _typeof(o);
-}
+    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 toInteger(dirtyNumber) {
-  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
-    return NaN;
-  }
-  var number = Number(dirtyNumber);
-  if (isNaN(number)) {
-    return number;
-  }
-  return number < 0 ? Math.ceil(number) : Math.floor(number);
-}
+    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+    }
 
-function requiredArgs(required, args) {
-  if (args.length < required) {
-    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
-  }
-}
+    function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
+        var duration = createDuration(posNegDuration).abs(),
+            seconds = round(duration.as('s')),
+            minutes = round(duration.as('m')),
+            hours = round(duration.as('h')),
+            days = round(duration.as('d')),
+            months = round(duration.as('M')),
+            weeks = round(duration.as('w')),
+            years = round(duration.as('y')),
+            a =
+                (seconds <= thresholds.ss && ['s', seconds]) ||
+                (seconds < thresholds.s && ['ss', seconds]) ||
+                (minutes <= 1 && ['m']) ||
+                (minutes < thresholds.m && ['mm', minutes]) ||
+                (hours <= 1 && ['h']) ||
+                (hours < thresholds.h && ['hh', hours]) ||
+                (days <= 1 && ['d']) ||
+                (days < thresholds.d && ['dd', days]);
 
-/**
- * @name toDate
- * @category Common Helpers
- * @summary Convert the given argument to an instance of Date.
- *
- * @description
- * Convert the given argument to an instance of Date.
- *
- * If the argument is an instance of Date, the function returns its clone.
- *
- * If the argument is a number, it is treated as a timestamp.
- *
- * If the argument is none of the above, the function returns Invalid Date.
- *
- * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
- *
- * @param {Date|Number} argument - the value to convert
- * @returns {Date} the parsed date in the local time zone
- * @throws {TypeError} 1 argument required
- *
- * @example
- * // Clone the date:
- * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
- * //=> Tue Feb 11 2014 11:30:30
- *
- * @example
- * // Convert the timestamp to date:
- * const result = toDate(1392098430000)
- * //=> Tue Feb 11 2014 11:30:30
- */
-function toDate(argument) {
-  requiredArgs(1, arguments);
-  var argStr = Object.prototype.toString.call(argument);
+        if (thresholds.w != null) {
+            a =
+                a ||
+                (weeks <= 1 && ['w']) ||
+                (weeks < thresholds.w && ['ww', weeks]);
+        }
+        a = a ||
+            (months <= 1 && ['M']) ||
+            (months < thresholds.M && ['MM', months]) ||
+            (years <= 1 && ['y']) || ['yy', years];
 
-  // Clone the date
-  if (argument instanceof Date || _typeof(argument) === 'object' && argStr === '[object Date]') {
-    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
-    return new Date(argument.getTime());
-  } else if (typeof argument === 'number' || argStr === '[object Number]') {
-    return new Date(argument);
-  } else {
-    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
-      // eslint-disable-next-line no-console
-      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments");
-      // eslint-disable-next-line no-console
-      console.warn(new Error().stack);
+        a[2] = withoutSuffix;
+        a[3] = +posNegDuration > 0;
+        a[4] = locale;
+        return substituteTimeAgo.apply(null, a);
     }
-    return new Date(NaN);
-  }
-}
 
-/**
- * Days in 1 week.
- *
- * @name daysInWeek
- * @constant
- * @type {number}
- * @default
- */
+    // This function allows you to set the rounding function for relative time strings
+    function getSetRelativeTimeRounding(roundingFunction) {
+        if (roundingFunction === undefined) {
+            return round;
+        }
+        if (typeof roundingFunction === 'function') {
+            round = roundingFunction;
+            return true;
+        }
+        return false;
+    }
 
-/**
- * Milliseconds in 1 minute
- *
- * @name millisecondsInMinute
- * @constant
- * @type {number}
- * @default
- */
-var millisecondsInMinute = 60000;
+    // This function allows you to set a threshold for relative time strings
+    function getSetRelativeTimeThreshold(threshold, limit) {
+        if (thresholds[threshold] === undefined) {
+            return false;
+        }
+        if (limit === undefined) {
+            return thresholds[threshold];
+        }
+        thresholds[threshold] = limit;
+        if (threshold === 's') {
+            thresholds.ss = limit - 1;
+        }
+        return true;
+    }
 
-/**
- * Milliseconds in 1 hour
- *
- * @name millisecondsInHour
- * @constant
- * @type {number}
- * @default
- */
-var millisecondsInHour = 3600000;
+    function humanize(argWithSuffix, argThresholds) {
+        if (!this.isValid()) {
+            return this.localeData().invalidDate();
+        }
 
-/**
- * @name isDate
- * @category Common Helpers
- * @summary Is the given value a date?
- *
- * @description
- * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
- *
- * @param {*} value - the value to check
- * @returns {boolean} true if the given value is a date
- * @throws {TypeError} 1 arguments required
- *
- * @example
- * // For a valid date:
- * const result = isDate(new Date())
- * //=> true
- *
- * @example
- * // For an invalid date:
- * const result = isDate(new Date(NaN))
- * //=> true
- *
- * @example
- * // For some value:
- * const result = isDate('2014-02-31')
- * //=> false
- *
- * @example
- * // For an object:
- * const result = isDate({})
- * //=> false
- */
-function isDate(value) {
-  requiredArgs(1, arguments);
-  return value instanceof Date || _typeof(value) === 'object' && Object.prototype.toString.call(value) === '[object Date]';
-}
+        var withSuffix = false,
+            th = thresholds,
+            locale,
+            output;
 
-/**
- * @name isValid
- * @category Common Helpers
- * @summary Is the given date valid?
- *
- * @description
- * Returns false if argument is Invalid Date and true otherwise.
- * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
- * Invalid Date is a Date, whose time value is NaN.
- *
- * Time value of Date: http://es5.github.io/#x15.9.1.1
- *
- * @param {*} date - the date to check
- * @returns {Boolean} the date is valid
- * @throws {TypeError} 1 argument required
- *
- * @example
- * // For the valid date:
- * const result = isValid(new Date(2014, 1, 31))
- * //=> true
- *
- * @example
- * // For the value, convertable into a date:
- * const result = isValid(1393804800000)
- * //=> true
- *
- * @example
- * // For the invalid date:
- * const result = isValid(new Date(''))
- * //=> false
- */
-function isValid(dirtyDate) {
-  requiredArgs(1, arguments);
-  if (!isDate(dirtyDate) && typeof dirtyDate !== 'number') {
-    return false;
-  }
-  var date = toDate(dirtyDate);
-  return !isNaN(Number(date));
-}
+        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;
+            }
+        }
 
-/**
- * @name isWithinInterval
- * @category Interval Helpers
- * @summary Is the given date within the interval?
- *
- * @description
- * Is the given date within the interval? (Including start and end.)
- *
- * @param {Date|Number} date - the date to check
- * @param {Interval} interval - the interval to check
- * @returns {Boolean} the date is within the interval
- * @throws {TypeError} 2 arguments required
- * @throws {RangeError} The start of an interval cannot be after its end
- * @throws {RangeError} Date in interval cannot be `Invalid Date`
- *
- * @example
- * // For the date within the interval:
- * isWithinInterval(new Date(2014, 0, 3), {
- *   start: new Date(2014, 0, 1),
- *   end: new Date(2014, 0, 7)
- * })
- * //=> true
- *
- * @example
- * // For the date outside of the interval:
- * isWithinInterval(new Date(2014, 0, 10), {
- *   start: new Date(2014, 0, 1),
- *   end: new Date(2014, 0, 7)
- * })
- * //=> false
- *
- * @example
- * // For date equal to interval start:
- * isWithinInterval(date, { start, end: date }) // => true
- *
- * @example
- * // For date equal to interval end:
- * isWithinInterval(date, { start: date, end }) // => true
- */
-function isWithinInterval(dirtyDate, interval) {
-  requiredArgs(2, arguments);
-  var time = toDate(dirtyDate).getTime();
-  var startTime = toDate(interval.start).getTime();
-  var endTime = toDate(interval.end).getTime();
+        locale = this.localeData();
+        output = relativeTime$1(this, !withSuffix, th, locale);
 
-  // Throw an exception if start date is after end date or if any date is `Invalid Date`
-  if (!(startTime <= endTime)) {
-    throw new RangeError('Invalid interval');
-  }
-  return time >= startTime && time <= endTime;
-}
+        if (withSuffix) {
+            output = locale.pastFuture(+this, output);
+        }
 
-/**
- * @name parseISO
- * @category Common Helpers
- * @summary Parse ISO string
- *
- * @description
- * Parse the given string in ISO 8601 format and return an instance of Date.
- *
- * Function accepts complete ISO 8601 formats as well as partial implementations.
- * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
- *
- * If the argument isn't a string, the function cannot parse the string or
- * the values are invalid, it returns Invalid Date.
- *
- * @param {String} argument - the value to convert
- * @param {Object} [options] - an object with options.
- * @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
- * @returns {Date} the parsed date in the local time zone
- * @throws {TypeError} 1 argument required
- * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
- *
- * @example
- * // Convert string '2014-02-11T11:30:30' to date:
- * const result = parseISO('2014-02-11T11:30:30')
- * //=> Tue Feb 11 2014 11:30:30
- *
- * @example
- * // Convert string '+02014101' to date,
- * // if the additional number of digits in the extended year format is 1:
- * const result = parseISO('+02014101', { additionalDigits: 1 })
- * //=> Fri Apr 11 2014 00:00:00
- */
-function parseISO(argument, options) {
-  var _options$additionalDi;
-  requiredArgs(1, arguments);
-  var additionalDigits = toInteger((_options$additionalDi = options === null || options === void 0 ? void 0 : options.additionalDigits) !== null && _options$additionalDi !== void 0 ? _options$additionalDi : 2);
-  if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
-    throw new RangeError('additionalDigits must be 0, 1 or 2');
-  }
-  if (!(typeof argument === 'string' || Object.prototype.toString.call(argument) === '[object String]')) {
-    return new Date(NaN);
-  }
-  var dateStrings = splitDateString(argument);
-  var date;
-  if (dateStrings.date) {
-    var parseYearResult = parseYear(dateStrings.date, additionalDigits);
-    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
-  }
-  if (!date || isNaN(date.getTime())) {
-    return new Date(NaN);
-  }
-  var timestamp = date.getTime();
-  var time = 0;
-  var offset;
-  if (dateStrings.time) {
-    time = parseTime(dateStrings.time);
-    if (isNaN(time)) {
-      return new Date(NaN);
+        return locale.postformat(output);
     }
-  }
-  if (dateStrings.timezone) {
-    offset = parseTimezone(dateStrings.timezone);
-    if (isNaN(offset)) {
-      return new Date(NaN);
+
+    var abs$1 = Math.abs;
+
+    function sign(x) {
+        return (x > 0) - (x < 0) || +x;
     }
-  } else {
-    var dirtyDate = new Date(timestamp + time);
-    // js parsed string assuming it's in UTC timezone
-    // but we need it to be parsed in our timezone
-    // so we use utc values to build date in our timezone.
-    // Year values from 0 to 99 map to the years 1900 to 1999
-    // so set year explicitly with setFullYear.
-    var result = new Date(0);
-    result.setFullYear(dirtyDate.getUTCFullYear(), dirtyDate.getUTCMonth(), dirtyDate.getUTCDate());
-    result.setHours(dirtyDate.getUTCHours(), dirtyDate.getUTCMinutes(), dirtyDate.getUTCSeconds(), dirtyDate.getUTCMilliseconds());
-    return result;
-  }
-  return new Date(timestamp + time + offset);
-}
-var patterns = {
-  dateTimeDelimiter: /[T ]/,
-  timeZoneDelimiter: /[Z ]/i,
-  timezone: /([Z+-].*)$/
-};
-var dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
-var timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
-var timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
-function splitDateString(dateString) {
-  var dateStrings = {};
-  var array = dateString.split(patterns.dateTimeDelimiter);
-  var timeString;
 
-  // The regex match should only return at maximum two array elements.
-  // [date], [time], or [date, time].
-  if (array.length > 2) {
-    return dateStrings;
-  }
-  if (/:/.test(array[0])) {
-    timeString = array[0];
-  } else {
-    dateStrings.date = array[0];
-    timeString = array[1];
-    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
-      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
-      timeString = dateString.substr(dateStrings.date.length, dateString.length);
-    }
-  }
-  if (timeString) {
-    var token = patterns.timezone.exec(timeString);
-    if (token) {
-      dateStrings.time = timeString.replace(token[1], '');
-      dateStrings.timezone = token[1];
-    } else {
-      dateStrings.time = timeString;
-    }
-  }
-  return dateStrings;
-}
-function parseYear(dateString, additionalDigits) {
-  var regex = new RegExp('^(?:(\\d{4}|[+-]\\d{' + (4 + additionalDigits) + '})|(\\d{2}|[+-]\\d{' + (2 + additionalDigits) + '})$)');
-  var captures = dateString.match(regex);
-  // Invalid ISO-formatted year
-  if (!captures) return {
-    year: NaN,
-    restDateString: ''
-  };
-  var year = captures[1] ? parseInt(captures[1]) : null;
-  var century = captures[2] ? parseInt(captures[2]) : null;
+    function toISOString$1() {
+        // for ISO strings we do not use the normal bubbling rules:
+        //  * milliseconds bubble up until they become hours
+        //  * days do not bubble at all
+        //  * months bubble up until they become years
+        // This is because there is no context-free conversion between hours and days
+        // (think of clock changes)
+        // and also not between days and months (28-31 days per month)
+        if (!this.isValid()) {
+            return this.localeData().invalidDate();
+        }
+
+        var seconds = abs$1(this._milliseconds) / 1000,
+            days = abs$1(this._days),
+            months = abs$1(this._months),
+            minutes,
+            hours,
+            years,
+            s,
+            total = this.asSeconds(),
+            totalSign,
+            ymSign,
+            daysSign,
+            hmsSign;
+
+        if (!total) {
+            // this is the same as C#'s (Noda) and python (isodate)...
+            // but not other JS (goog.date)
+            return 'P0D';
+        }
+
+        // 3600 seconds -> 60 minutes -> 1 hour
+        minutes = absFloor(seconds / 60);
+        hours = absFloor(minutes / 60);
+        seconds %= 60;
+        minutes %= 60;
+
+        // 12 months -> 1 year
+        years = absFloor(months / 12);
+        months %= 12;
+
+        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+        s = seconds ? seconds.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' +
+            (years ? ymSign + years + 'Y' : '') +
+            (months ? ymSign + months + 'M' : '') +
+            (days ? daysSign + days + 'D' : '') +
+            (hours || minutes || seconds ? 'T' : '') +
+            (hours ? hmsSign + hours + 'H' : '') +
+            (minutes ? hmsSign + minutes + 'M' : '') +
+            (seconds ? 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;
+
+    // FORMATTING
 
-  // either year or century is null, not both
-  return {
-    year: century === null ? year : century * 100,
-    restDateString: dateString.slice((captures[1] || captures[2]).length)
-  };
-}
-function parseDate(dateString, year) {
-  // Invalid ISO-formatted year
-  if (year === null) return new Date(NaN);
-  var captures = dateString.match(dateRegex);
-  // Invalid ISO-formatted string
-  if (!captures) return new Date(NaN);
-  var isWeekDate = !!captures[4];
-  var dayOfYear = parseDateUnit(captures[1]);
-  var month = parseDateUnit(captures[2]) - 1;
-  var day = parseDateUnit(captures[3]);
-  var week = parseDateUnit(captures[4]);
-  var dayOfWeek = parseDateUnit(captures[5]) - 1;
-  if (isWeekDate) {
-    if (!validateWeekDate(year, week, dayOfWeek)) {
-      return new Date(NaN);
-    }
-    return dayOfISOWeekYear(year, week, dayOfWeek);
-  } else {
-    var date = new Date(0);
-    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
-      return new Date(NaN);
-    }
-    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
-    return date;
-  }
-}
-function parseDateUnit(value) {
-  return value ? parseInt(value) : 1;
-}
-function parseTime(timeString) {
-  var captures = timeString.match(timeRegex);
-  if (!captures) return NaN; // Invalid ISO-formatted time
+    addFormatToken('X', 0, 0, 'unix');
+    addFormatToken('x', 0, 0, 'valueOf');
 
-  var hours = parseTimeUnit(captures[1]);
-  var minutes = parseTimeUnit(captures[2]);
-  var seconds = parseTimeUnit(captures[3]);
-  if (!validateTime(hours, minutes, seconds)) {
-    return NaN;
-  }
-  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1000;
-}
-function parseTimeUnit(value) {
-  return value && parseFloat(value.replace(',', '.')) || 0;
-}
-function parseTimezone(timezoneString) {
-  if (timezoneString === 'Z') return 0;
-  var captures = timezoneString.match(timezoneRegex);
-  if (!captures) return 0;
-  var sign = captures[1] === '+' ? -1 : 1;
-  var hours = parseInt(captures[2]);
-  var minutes = captures[3] && parseInt(captures[3]) || 0;
-  if (!validateTimezone(hours, minutes)) {
-    return NaN;
-  }
-  return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
-}
-function dayOfISOWeekYear(isoWeekYear, week, day) {
-  var date = new Date(0);
-  date.setUTCFullYear(isoWeekYear, 0, 4);
-  var fourthOfJanuaryDay = date.getUTCDay() || 7;
-  var diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
-  date.setUTCDate(date.getUTCDate() + diff);
-  return date;
-}
+    // PARSING
 
-// Validation functions
+    addRegexToken('x', matchSigned);
+    addRegexToken('X', matchTimestamp);
+    addParseToken('X', function (input, array, config) {
+        config._d = new Date(parseFloat(input) * 1000);
+    });
+    addParseToken('x', function (input, array, config) {
+        config._d = new Date(toInt(input));
+    });
 
-// February is null to handle the leap year (using ||)
-var daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-function isLeapYearIndex(year) {
-  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
-}
-function validateDate(year, month, date) {
-  return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
-}
-function validateDayOfYearDate(year, dayOfYear) {
-  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
-}
-function validateWeekDate(_year, week, day) {
-  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
-}
-function validateTime(hours, minutes, seconds) {
-  if (hours === 24) {
-    return minutes === 0 && seconds === 0;
-  }
-  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
-}
-function validateTimezone(_hours, minutes) {
-  return minutes >= 0 && minutes <= 59;
-}
+    //! moment.js
+
+    hooks.version = '2.29.4';
+
+    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;
+
+    // currently HTML5 input type only supports 24-hour formats
+    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" />
+    };
+
+    return hooks;
+
+})));
+}(moment$1));
+
+var moment = moment$1.exports;
 
 /** ************************************************ */
 /* Object to store a time duration / time interval */
@@ -26178,7 +26459,7 @@ var parseISO8601DateToDate = function parseISO8601DateToDate(unvalidatedIsotime)
   };
   var isotime = makeISO8601StringFromFlexibleWMSDateString(unvalidatedIsotime);
   if (!isValidISOTime(isotime)) {
-    debug(DebugType.Warning);
+    debugLogger(DebugType.Warning);
     return undefined;
   }
   var _getTimeValues = getTimeValues(isotime),
@@ -26430,14 +26711,14 @@ var ParseISOTimeRangeDuration = /*#__PURE__*/function () {
     this.startTime = parseISO8601DateToDate(times[0]);
     this.stopTime = parseISO8601DateToDate(times[1]);
     if (!this.startTime || !this.stopTime) {
-      debug(DebugType.Warning);
+      debugLogger(DebugType.Warning);
       return;
     }
     /* Try to get the time interval. If not available default to 1 minute */
     var timeIntervalString = times[2] || 'PT1M';
     this.timeInterval = parseISO8601IntervalToDateInterval(timeIntervalString);
     if (!this.timeInterval) {
-      debug(DebugType.Warning);
+      debugLogger(DebugType.Warning);
       return;
     }
     // Calculate the number if steps
@@ -26463,7 +26744,7 @@ var ParseISOTimeRangeDuration = /*#__PURE__*/function () {
         return null;
       }
       if (!this.timeInterval) {
-        debug(DebugType.Warning);
+        debugLogger(DebugType.Warning);
         return null;
       }
       if (this.timeInterval.isRegularInterval === false) {
@@ -26656,7 +26937,7 @@ var WMJSDimension = /*#__PURE__*/function () {
       if (!referenceTimeValueToSet) {
         this.reInitializeValues(this.values);
         this.setClosestValue(null);
-        debug(DebugType.Warning);
+        debugLogger(DebugType.Warning);
         return;
       }
       /*
@@ -26952,7 +27233,7 @@ var WMJSDimension = /*#__PURE__*/function () {
         value = this.getValueForIndex(index);
       } catch (e) {
         if (typeof e.message === 'number') {
-          if (e.message === 0) {
+          if (e.message === '0') {
             value = WMDateTooEarlyString;
           } else {
             value = WMDateTooLateString;
@@ -27117,7 +27398,7 @@ var WMJSDimension = /*#__PURE__*/function () {
           }
           return foundIndex;
         } catch (e) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
           return -1;
         }
       }
@@ -27256,7 +27537,7 @@ var MapPin = /*#__PURE__*/function () {
       _this.redrawMap();
     };
     this.positionMapPinByLatLon = function (coord) {
-      debug(DebugType.Log, "positionMapPinByLatLon at ".concat(coord.x, ",").concat(coord.y));
+      debugLogger(DebugType.Log, "positionMapPinByLatLon at ".concat(coord.x, ",").concat(coord.y));
       var newpos = _this._map.getPixelCoordFromLatLong(coord);
       _this.setMapPin(newpos.x, newpos.y);
     };
@@ -28256,7 +28537,7 @@ var WMJSMap = /*#__PURE__*/function () {
       }, this.internalMapId);
       this.callBack.addToCallback('display', this.display, true);
       this.callBack.addToCallback('draw', function () {
-        debug(DebugType.Log);
+        debugLogger(DebugType.Log);
       }, true);
       bgMapImageStore.addImageEventCallback(function (image, id, imageEventType) {
         if (imageEventType === WMImageEventType.Loaded) {
@@ -28271,16 +28552,16 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "rebuildMapDimensions",
     value: function rebuildMapDimensions() {
-      for (var i = 0; i < this.layers.length; i += 1) {
-        for (var j = 0; j < this.layers[i].dimensions.length; j += 1) {
-          var dim = this.layers[i].dimensions[j];
-          var mapdim = this.getDimension(dim.name);
+      var _this4 = this;
+      this.layers.forEach(function (layer) {
+        layer.dimensions.forEach(function (dim) {
+          var mapdim = _this4.getDimension(dim.name);
           if (!isDefined(mapdim)) {
             var newdim = dim.clone();
-            this.mapdimensions.push(newdim);
+            _this4.mapdimensions.push(newdim);
           }
-        }
-      }
+        });
+      });
       this.callBack.triggerEvent('onmapdimupdate');
     }
   }, {
@@ -28439,9 +28720,9 @@ var WMJSMap = /*#__PURE__*/function () {
         }
       } else {
         try {
-          debug(DebugType.Error, "WebMapJS warning: moveLayerDown: layer '".concat(layerToMove.name, "' not found."));
+          debugLogger(DebugType.Error, "WebMapJS warning: moveLayerDown: layer '".concat(layerToMove.name, "' not found."));
         } catch (e) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         }
       }
     }
@@ -28459,9 +28740,9 @@ var WMJSMap = /*#__PURE__*/function () {
         }
       } else {
         try {
-          debug(DebugType.Error, "WebMapJS: moveLayers: layer '".concat(_layerA.name, "' not found."));
+          debugLogger(DebugType.Error, "WebMapJS: moveLayers: layer '".concat(_layerA.name, "' not found."));
         } catch (e) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         }
       }
     }
@@ -28478,19 +28759,19 @@ var WMJSMap = /*#__PURE__*/function () {
         }
       } else {
         try {
-          debug(DebugType.Error, "WebMapJS: moveLayerUp: layer '".concat(layerToMove.name, "' not found."));
+          debugLogger(DebugType.Error, "WebMapJS: moveLayerUp: layer '".concat(layerToMove.name, "' not found."));
         } catch (e) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         }
       }
     }
   }, {
     key: "configureMapDimensions",
     value: function configureMapDimensions(layer) {
-      var _this4 = this;
+      var _this5 = this;
       layer.dimensions.forEach(function (dimension) {
-        var mapDim = _this4.getDimension(dimension.name);
-        if (isDefined(mapDim) && isDefined(mapDim.currentValue) && dimension.linked) {
+        var mapDim = _this5.getDimension(dimension.name);
+        if ((mapDim === null || mapDim === void 0 ? void 0 : mapDim.currentValue) !== undefined && dimension.linked) {
           dimension.setClosestValue(mapDim.currentValue);
         }
       });
@@ -28502,25 +28783,25 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "addLayer",
     value: function addLayer(layer) {
-      var _this5 = this;
+      var _this6 = this;
       return new Promise(function (resolve, reject) {
         if (!isDefined(layer)) {
-          debug(DebugType.Warning);
+          debugLogger(DebugType.Warning);
           reject(new Error('undefined layer'));
           return;
         }
         if (!layer.constructor) {
-          debug(DebugType.Warning);
+          debugLogger(DebugType.Warning);
           reject(new Error('layer has no constructor'));
           return;
         }
         /* Set a reference in the layer to this map */
-        layer.parentMap = _this5;
-        _this5.layers.push(layer);
+        layer.parentMap = _this6;
+        _this6.layers.push(layer);
         var done = function done(layerCallback) {
-          _this5.configureMapDimensions(layerCallback);
-          _this5.callBack.triggerEvent('onlayeradd');
-          resolve(_this5);
+          _this6.configureMapDimensions(layerCallback);
+          _this6.callBack.triggerEvent('onlayeradd');
+          resolve(_this6);
         };
         layer.parseLayer(done, undefined, 'WMJSMap addLayer');
       });
@@ -28610,8 +28891,8 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "setSize",
     value: function setSize(w, h) {
-      var _this6 = this;
-      debug(DebugType.Log, 'setSize', w, h, this.initialized);
+      var _this7 = this;
+      debugLogger(DebugType.Log, 'setSize', w, h, this.initialized);
       if (w < 4 || h < 4 || this.initialized === false) {
         return;
       }
@@ -28627,9 +28908,9 @@ var WMJSMap = /*#__PURE__*/function () {
         return;
       }
       this._resizeTimer.init(200, function () {
-        _this6._resizeTimerBusy = false;
-        _this6._setSize(_this6.resizeWidth, _this6.resizeHeight);
-        _this6.draw('resizeTimer');
+        _this7._resizeTimerBusy = false;
+        _this7._setSize(_this7.resizeWidth, _this7.resizeHeight);
+        _this7.draw('resizeTimer');
       });
     }
   }, {
@@ -28641,7 +28922,7 @@ var WMJSMap = /*#__PURE__*/function () {
       if (w < 4 || h < 4) {
         return;
       }
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       var projinfo = this.getProjection();
       this.width = w;
       this.height = h;
@@ -28652,7 +28933,7 @@ var WMJSMap = /*#__PURE__*/function () {
         this.height = 4;
       }
       if (!projinfo.srs || !projinfo.bbox) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         projinfo.srs = 'EPSG:4326';
         projinfo.bbox.left = -180;
         projinfo.bbox.bottom = -90;
@@ -28750,7 +29031,7 @@ var WMJSMap = /*#__PURE__*/function () {
           this.divDimInfo.style.display = 'none';
         }
       } catch (e) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
     }
   }, {
@@ -28794,7 +29075,7 @@ var WMJSMap = /*#__PURE__*/function () {
         }
       }
       if (this.isAnimating) {
-        debug(DebugType.Log);
+        debugLogger(DebugType.Log);
         return;
       }
       this._draw(this._animationList);
@@ -28805,7 +29086,7 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "_draw",
     value: function _draw(animationList) {
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.drawnBBOX.setBBOX(this.bbox);
       this._drawAndLoad(animationList);
     }
@@ -28821,7 +29102,7 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "_drawAndLoad",
     value: function _drawAndLoad(animationList) {
-      var _this7 = this;
+      var _this8 = this;
       if (this.width < 4 || this.height < 4) {
         this._drawReady();
         return;
@@ -28841,19 +29122,20 @@ var WMJSMap = /*#__PURE__*/function () {
         this.mouseHoverAnimationBox = false;
         animationList.forEach(function (animationStepWithoutRequests, j) {
           if (selectedTime && animationStepWithoutRequests.value === selectedTime) {
-            _this7.currentAnimationStep = j;
+            _this8.currentAnimationStep = j;
           }
           var animationStep = {
             name: animationStepWithoutRequests.name,
             value: animationStepWithoutRequests.value,
             requests: []
           };
-          _this7.setDimension(animationStepWithoutRequests.name, animationStepWithoutRequests.value, false);
-          animationStep.requests = _this7.getWMSRequests();
-          _this7.animationList.push(animationStep);
+          _this8.setDimension(animationStepWithoutRequests.name, animationStepWithoutRequests.value, false);
+          animationStep.requests = _this8.getWMSRequests();
+          _this8.animationList.push(animationStep);
         });
         this.setDimension(this.animationList[this.currentAnimationStep].name, this.animationList[this.currentAnimationStep].value, false);
-        this.wmAnimate.prefetchImagesForAnimationSteps();
+        this.animationTimer = new WMTimer();
+        this.wmAnimate.loopAnimation();
       }
       this.addLayersToCanvasAndDisplayThem();
     }
@@ -28865,7 +29147,7 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "_onMapReadyCallbackFunction",
     value: function _onMapReadyCallbackFunction() {
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.draw('onmapready callback');
     }
   }, {
@@ -28876,11 +29158,11 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "getWMSRequests",
     value: function getWMSRequests() {
-      var _this8 = this;
+      var _this9 = this;
       var requests = [];
       this.layers.forEach(function (layer) {
         if (layer.service && layer.enabled) {
-          var request = buildWMSGetMapRequest(_this8, layer);
+          var request = buildWMSGetMapRequest(_this9, layer);
           if (request === null || request === void 0 ? void 0 : request.url) {
             requests.push(request);
           }
@@ -28891,35 +29173,37 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "addLayersToCanvasAndDisplayThem",
     value: function addLayersToCanvasAndDisplayThem() {
-      var _this9 = this;
+      var _this10 = this;
       var _a, _b, _c;
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.divBuffer.reset();
       var currentLayerIndex = 0;
       this.numBaseLayers = 0;
       (_a = this.baseLayers) === null || _a === void 0 ? void 0 : _a.forEach(function (baseLayer) {
         var _a;
         if (baseLayer.enabled && baseLayer.keepOnTop === false && baseLayer.type && baseLayer.type !== 'twms') {
-          _this9.numBaseLayers += 1;
-          var requestURL = (_a = buildWMSGetMapRequest(_this9, baseLayer)) === null || _a === void 0 ? void 0 : _a.url;
+          _this10.numBaseLayers += 1;
+          var requestURL = (_a = buildWMSGetMapRequest(_this10, baseLayer)) === null || _a === void 0 ? void 0 : _a.url;
           if (requestURL) {
-            _this9.divBuffer.setSrc(currentLayerIndex, requestURL, {
+            _this10.divBuffer.setSrc(currentLayerIndex, requestURL, {
               layer: baseLayer
-            }, baseLayer.opacity, _this9.getDrawBBOX());
+            }, baseLayer.opacity, _this10.getDrawBBOX());
             currentLayerIndex += 1;
           }
         }
       });
+      if (!this.isAnimating) {
+        prefetchImagesForNonAnimation(this);
+      }
       /* Loop through all layers */
       (_b = this.layers) === null || _b === void 0 ? void 0 : _b.forEach(function (layer) {
         var _a;
         if (layer.service && layer.enabled && layer.isConfigured) {
-          layer.prefetchImages();
-          var requestURL = (_a = buildWMSGetMapRequest(_this9, layer)) === null || _a === void 0 ? void 0 : _a.url;
+          var requestURL = (_a = buildWMSGetMapRequest(_this10, layer)) === null || _a === void 0 ? void 0 : _a.url;
           if (requestURL) {
-            _this9.divBuffer.setSrc(currentLayerIndex, requestURL, {
+            _this10.divBuffer.setSrc(currentLayerIndex, requestURL, {
               layer: layer
-            }, layer.opacity, _this9.getDrawBBOX());
+            }, layer.opacity, _this10.getDrawBBOX());
             currentLayerIndex += 1;
           }
         }
@@ -28927,11 +29211,11 @@ var WMJSMap = /*#__PURE__*/function () {
       (_c = this.baseLayers) === null || _c === void 0 ? void 0 : _c.forEach(function (baseLayer) {
         var _a;
         if (baseLayer.enabled && baseLayer.keepOnTop === true) {
-          var requestURL = (_a = buildWMSGetMapRequest(_this9, baseLayer)) === null || _a === void 0 ? void 0 : _a.url;
+          var requestURL = (_a = buildWMSGetMapRequest(_this10, baseLayer)) === null || _a === void 0 ? void 0 : _a.url;
           if (requestURL) {
-            _this9.divBuffer.setSrc(currentLayerIndex, requestURL, {
+            _this10.divBuffer.setSrc(currentLayerIndex, requestURL, {
               layer: baseLayer
-            }, baseLayer.opacity, _this9.getDrawBBOX());
+            }, baseLayer.opacity, _this10.getDrawBBOX());
             currentLayerIndex += 1;
           }
         }
@@ -28963,7 +29247,7 @@ var WMJSMap = /*#__PURE__*/function () {
     key: "redrawBuffer",
     value: function redrawBuffer() {
       this.divBuffer.display();
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.drawnBBOX.setBBOX(this.bbox);
       this.draw();
     }
@@ -29125,20 +29409,20 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "_buildLayerDims",
     value: function _buildLayerDims() {
-      var _this10 = this;
+      var _this11 = this;
       if (this.buildLayerDimsBusy === true) {
         return;
       }
       this.mapdimensions.forEach(function (mapDim) {
-        _this10.layers.forEach(function (layer) {
+        _this11.layers.forEach(function (layer) {
           layer.dimensions.forEach(function (layerDim) {
             if (layerDim.linked === true && layerDim.name === mapDim.name) {
               if (mapDim.currentValue === 'current' || mapDim.currentValue === 'default' || mapDim.currentValue === '' || mapDim.currentValue === 'earliest' || mapDim.currentValue === 'middle' || mapDim.currentValue === 'latest') {
                 mapDim.currentValue = layerDim.getClosestValue(mapDim.currentValue);
               }
-              _this10.buildLayerDimsBusy = true;
+              _this11.buildLayerDimsBusy = true;
               layerDim.setClosestValue(mapDim.currentValue);
-              _this10.buildLayerDimsBusy = false;
+              _this11.buildLayerDimsBusy = false;
             }
           });
         });
@@ -29181,7 +29465,7 @@ var WMJSMap = /*#__PURE__*/function () {
       } catch (e) {
         return undefined;
       }
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       return request;
     }
     /* End of GetFeature info handling */
@@ -29532,7 +29816,7 @@ var WMJSMap = /*#__PURE__*/function () {
           this.callBack.triggerEvent('onmousemove', [undefined, undefined]);
           this.updateMouseCursorCoordinates(undefined);
         } catch (e) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         }
         this.mouseUpX = this.mouseX;
         this.mouseUpY = this.mouseY;
@@ -29672,7 +29956,7 @@ var WMJSMap = /*#__PURE__*/function () {
         this.gfiDialogList[j].origY = this.gfiDialogList[j].y;
       }
       this.mapPanning = 1;
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.bbox.setBBOX(this.drawnBBOX);
       this.updateBBOX.setBBOX(this.drawnBBOX);
       this.mapPanStartGeoCoords = this.getGeoCoordFromPixelCoord({
@@ -29854,8 +30138,8 @@ var WMJSMap = /*#__PURE__*/function () {
   }, {
     key: "zoomTo",
     value: function zoomTo(_newbbox) {
-      var _this11 = this;
-      debug(DebugType.Log);
+      var _this12 = this;
+      debugLogger(DebugType.Log);
       var setOrigBox = false;
       var newbbox = new WMBBOX(_newbbox);
       // Maintain aspect ratio
@@ -29870,7 +30154,7 @@ var WMJSMap = /*#__PURE__*/function () {
         setOrigBox = true;
       }
       if (setOrigBox === true) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         ratio = 1;
       }
       if (ratio < 0) {
@@ -29895,14 +30179,14 @@ var WMJSMap = /*#__PURE__*/function () {
       this._updateBoundingBox(this.bbox);
       this.drawnBBOX.setBBOX(this.bbox);
       var resetMapPinAndDialogs = function resetMapPinAndDialogs() {
-        for (var j = 0; j < _this11.gfiDialogList.length; j += 1) {
-          var newpos = _this11.getPixelCoordFromGeoCoord({
-            x: _this11.gfiDialogList[j].geoPosX,
-            y: _this11.gfiDialogList[j].geoPosY
+        for (var j = 0; j < _this12.gfiDialogList.length; j += 1) {
+          var newpos = _this12.getPixelCoordFromGeoCoord({
+            x: _this12.gfiDialogList[j].geoPosX,
+            y: _this12.gfiDialogList[j].geoPosY
           });
-          if (_this11.gfiDialogList[j].hasBeenDragged === false) {
-            if (_this11.gfiDialogList[j].moveToMouseCursor === true) {
-              _this11.gfiDialogList[j].setXY(_this11.gfiDialogList[j].origX + newpos.x, _this11.gfiDialogList[j].origY + newpos.y);
+          if (_this12.gfiDialogList[j].hasBeenDragged === false) {
+            if (_this12.gfiDialogList[j].moveToMouseCursor === true) {
+              _this12.gfiDialogList[j].setXY(_this12.gfiDialogList[j].origX + newpos.x, _this12.gfiDialogList[j].origY + newpos.y);
             }
           }
         }
@@ -29971,7 +30255,7 @@ var WMJSMap = /*#__PURE__*/function () {
         }
         result = proj4(this.longlat, this.proj4.projection, [p.x, p.y]);
       } catch (e) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return undefined;
       }
       return this.getPixelCoordFromGeoCoord({
@@ -30100,14 +30384,19 @@ var WMJSMap = /*#__PURE__*/function () {
       }
       return undefined;
     }
+  }, {
+    key: "setTimeDimension",
+    value: function setTimeDimension(value, triggerEvent) {
+      this.setDimension('time', value, triggerEvent);
+    }
   }, {
     key: "setDimension",
     value: function setDimension(name, value) {
       var triggerEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       var adjustLayerDims = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       if (!isDefined(name) || !isDefined(value)) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
         return;
       }
       var dim = this.getDimension(name);
@@ -30156,14 +30445,14 @@ var WMJSMap = /*#__PURE__*/function () {
           return;
         }
       }
-      debug(DebugType.Error, "WebMapJS: Unable to find the correct bbox with current map projection ".concat(this.srs, " for layer ").concat(layer.title, ". Using default bbox instead."));
+      debugLogger(DebugType.Error, "WebMapJS: Unable to find the correct bbox with current map projection ".concat(this.srs, " for layer ").concat(layer.title, ". Using default bbox instead."));
       this.zoomTo(this.defaultBBOX);
       this.draw('zoomTolayer');
     }
   }, {
     key: "setBBOX",
     value: function setBBOX(left, bottom, right, top) {
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       this.bbox.setBBOX(left, bottom, right, top);
       this.resizeBBOX.setBBOX(this.bbox);
       this.wMFlyToBBox.flyZoomToBBOXFly.setBBOX(this.bbox);
@@ -30830,7 +31119,7 @@ var loadGetCapabilitiesViaProxy = function loadGetCapabilitiesViaProxy(url, succ
     fetch(getcapreq, {}).then(function (result) {
       return result.text();
     }).then(function (result) {
-      debug(DebugType.Log, 'loadGetCapabilitiesViaProxy succesfully finished');
+      debugLogger(DebugType.Log, 'loadGetCapabilitiesViaProxy succesfully finished');
       succes(result);
     })["catch"](function () {
       fail("Request failed for ".concat(getcapreq));
@@ -30862,7 +31151,7 @@ var WMJSGetCapabilities = function WMJSGetCapabilities(service, succes, fail, op
     return;
   }
   if (service.length === 0) {
-    debug(DebugType.Error);
+    debugLogger(DebugType.Error);
     fail(I18n.service_url_empty.text);
     return;
   }
@@ -30876,7 +31165,7 @@ var WMJSGetCapabilities = function WMJSGetCapabilities(service, succes, fail, op
     service = hostName + service;
   }
   if (!service.startsWith('http://') && !service.startsWith('https:') && !service.startsWith('//')) {
-    debug(DebugType.Error);
+    debugLogger(DebugType.Error);
     fail(I18n.service_url_empty.text);
     return;
   }
@@ -30884,7 +31173,7 @@ var WMJSGetCapabilities = function WMJSGetCapabilities(service, succes, fail, op
     // eslint-disable-next-line no-param-reassign
     service += '?';
   }
-  debug(DebugType.Log);
+  debugLogger(DebugType.Log);
   var addParams = disableCache ? {
     random: Math.random()
   } : {};
@@ -30893,7 +31182,7 @@ var WMJSGetCapabilities = function WMJSGetCapabilities(service, succes, fail, op
     try {
       succes(data);
     } catch (e) {
-      debug(DebugType.Error);
+      debugLogger(DebugType.Error, e.message);
     }
   })["catch"](function () {
     loadGetCapabilitiesViaProxy(url, succes, function () {
@@ -31177,7 +31466,7 @@ var WMJSService = /*#__PURE__*/function () {
       if (!failure) {
         // eslint-disable-next-line no-param-reassign
         failure = function failure(msg) {
-          debug(DebugType.Error);
+          debugLogger(DebugType.Error);
         };
       }
       var parse = function parse(jsonData) {
@@ -31185,7 +31474,7 @@ var WMJSService = /*#__PURE__*/function () {
         try {
           _this2.version = _this2.checkVersion(jsonData);
         } catch (e) {
-          failure(e);
+          failure(e.message);
           return;
         }
         var layerTreeStructure = buildLayerTreeFromNestedWMSLayer(rootLayer);
@@ -31250,23 +31539,6 @@ var WMGetServiceFromStore = function WMGetServiceFromStore(serviceName) {
   return service;
 };
 
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2020 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2020 - Finnish Meteorological Institute (FMI)
- * */
-var _WMLayer_instances, _WMLayer_prefetchImage;
 var LayerType;
 (function (LayerType) {
   LayerType["mapLayer"] = "mapLayer";
@@ -31407,7 +31679,6 @@ var WMLayer = /*#__PURE__*/function () {
     var _this = this;
     _classCallCheck(this, WMLayer);
     var _a;
-    _WMLayer_instances.add(this);
     this.init = this.init.bind(this);
     this.getLayerName = this.getLayerName.bind(this);
     this.toggleAutoUpdate = this.toggleAutoUpdate.bind(this);
@@ -31711,7 +31982,7 @@ var WMLayer = /*#__PURE__*/function () {
           }
         }
       } catch (e) {
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
       if (this.name === undefined || this.name.length < 1) {
         this.title = WMEmptyLayerTitle;
@@ -31727,7 +31998,7 @@ var WMLayer = /*#__PURE__*/function () {
       }
       if (!isDefined(this.getmapURL)) {
         this.getmapURL = this.service;
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
       this.getfeatureinfoURL = undefined;
       try {
@@ -31737,7 +32008,7 @@ var WMLayer = /*#__PURE__*/function () {
       }
       if (!isDefined(this.getfeatureinfoURL)) {
         this.getfeatureinfoURL = this.service;
-        debug(DebugType.Error);
+        debugLogger(DebugType.Error);
       }
       this.getlegendgraphicURL = undefined;
       try {
@@ -31844,7 +32115,7 @@ var WMLayer = /*#__PURE__*/function () {
             _layerDoneCallback(__layer);
             // console.timeEnd(origin);
           } catch (e) {
-            debug(DebugType.Error);
+            debugLogger(DebugType.Error, e.message);
           }
         }
       };
@@ -31889,7 +32160,7 @@ var WMLayer = /*#__PURE__*/function () {
       return new Promise(function (resolve, reject) {
         _this6.parseLayer(function (layer) {
           if (layer.hasError === true) {
-            debug(DebugType.Error, "[ERROR] Parse layer failed, Reason [".concat(layer.lastError, "]"));
+            debugLogger(DebugType.Error, "[ERROR] Parse layer failed, Reason [".concat(layer.lastError, "]"));
             reject(layer);
           } else {
             resolve(layer);
@@ -31900,7 +32171,7 @@ var WMLayer = /*#__PURE__*/function () {
   }, {
     key: "cloneLayer",
     value: function cloneLayer() {
-      return new WMLayer(this);
+      return new WMLayer(this._options);
     }
     /**
      * Set or change the name of this layer. This involves re-parsing the WMS GetCapabilities document and updating the affected layer properties. When done, it resolves the WMLayer
@@ -31920,11 +32191,11 @@ var WMLayer = /*#__PURE__*/function () {
   }, {
     key: "setStyle",
     value: function setStyle(styleName) {
-      debug(DebugType.Log);
+      debugLogger(DebugType.Log);
       if (!this.styles || this.styles.length === 0) {
         this.currentStyle = '';
         this.legendGraphic = '';
-        debug(DebugType.Log);
+        debugLogger(DebugType.Log);
         return;
       }
       var styleFound = false;
@@ -31936,7 +32207,7 @@ var WMLayer = /*#__PURE__*/function () {
         }
       }
       if (!styleFound) {
-        debug(DebugType.Log, "WMLayer::setStyle: Style ".concat(styleName, " not found, setting style ").concat(this.styles[0].name));
+        debugLogger(DebugType.Log, "WMLayer::setStyle: Style ".concat(styleName, " not found, setting style ").concat(this.styles[0].name));
         this.currentStyle = this.styles[0].name;
         this.legendGraphic = this.styles[0].legendURL;
       }
@@ -32064,51 +32335,9 @@ var WMLayer = /*#__PURE__*/function () {
         this.parentMap.displayLayer(this, this.enabled);
       }
     }
-  }, {
-    key: "prefetchImages",
-    value: function prefetchImages() {
-      var _this7 = this;
-      var timeDimension = this.getDimension('time');
-      if (!timeDimension) {
-        return;
-      }
-      var currentTime = timeDimension.currentValue;
-      var currentTimeIndex = timeDimension.getIndexForValue(currentTime);
-      var lastIndex = timeDimension.size();
-      if (currentTimeIndex < 0 || lastIndex <= 0) {
-        return;
-      }
-      var COUNT_IMAGES_TO_PRELOAD_BEFORE_AND_AFTER_CURRENT_TIME = 10;
-      lodash.exports.range(1, COUNT_IMAGES_TO_PRELOAD_BEFORE_AND_AFTER_CURRENT_TIME).forEach(function (offset) {
-        var nextImageIndex = currentTimeIndex + offset;
-        if (nextImageIndex < lastIndex) {
-          __classPrivateFieldGet(_this7, _WMLayer_instances, "m", _WMLayer_prefetchImage).call(_this7, timeDimension, nextImageIndex, currentTime);
-        }
-        var previousImageIndex = currentTimeIndex - offset;
-        if (previousImageIndex >= 0) {
-          __classPrivateFieldGet(_this7, _WMLayer_instances, "m", _WMLayer_prefetchImage).call(_this7, timeDimension, previousImageIndex, currentTime);
-        }
-      });
-    }
   }]);
   return WMLayer;
 }();
-_WMLayer_instances = new WeakSet(), _WMLayer_prefetchImage = function _WMLayer_prefetchImage(timeDimension, index, currentTime) {
-  var time = timeDimension.getValueForIndex(index);
-  var timeIsNotAValidIsoString = typeof time !== 'string' || !isValid(parseISO(time));
-  if (timeIsNotAValidIsoString) {
-    return;
-  }
-  timeDimension.setValue(time);
-  var request = buildWMSGetMapRequest(this.parentMap, this);
-  if (request) {
-    var image = getMapImageStore.getImage(request.url);
-    if (image.hasNotStartedLoading()) {
-      image.load();
-    }
-  }
-  timeDimension.setValue(currentTime);
-};
 
 /* *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -33324,4 +33553,4 @@ var getCapabilities = /*#__PURE__*/Object.freeze({
   getLayersFlattenedFromService: getLayersFlattenedFromService
 });
 
-export { DateInterval, DebugType, EPSGCode, I18n, LayerType, ParseISOTimeRangeDuration, URLDecode, URLEncode, WMBBOX, WMDateOutSideRange, WMDateTooEarlyString, WMDateTooLateString, WMEmptyLayerName, WMEmptyLayerTitle, WMGetServiceFromStore, WMImage, WMImageEventType, WMJSDimension, WMJSMap, WMJSService, WMJScheckURL, WMLayer, WMTimer, clearImageCache, debug, generateLayerId, generateMapId, generateTimesliderId, getCapabilities, getLegendGraphicURLForLayer, getMapImageStore, getWMJSDimensionForLayerAndDimension, getWMJSMapById, getWMJSTimeDimensionForLayerId, getWMLayerById, isDefined, legendImageStore, mockGetCapabilities, parseISO8601DateToDate, parseISO8601IntervalToDateInterval, registerWMJSMap, registerWMLayer, tilesettings, toArray, unRegisterAllWMJSLayersAndMaps, unRegisterWMJSLayer, unRegisterWMJSMap, testSettings as webmapTestSettings, utils as webmapUtils };
+export { DateInterval, DebugType, EPSGCode, I18n, LayerType, ParseISOTimeRangeDuration, URLDecode, URLEncode, WMBBOX, WMDateOutSideRange, WMDateTooEarlyString, WMDateTooLateString, WMEmptyLayerName, WMEmptyLayerTitle, WMGetServiceFromStore, WMImage, WMImageEventType, WMJSDimension, WMJSMap, WMJSService, WMJScheckURL, WMLayer, WMTimer, clearImageCache, debugLogger, generateLayerId, generateMapId, generateTimesliderId, getCapabilities, getLegendGraphicURLForLayer, getMapImageStore, getWMJSDimensionForLayerAndDimension, getWMJSMapById, getWMJSTimeDimensionForLayerId, getWMLayerById, isDefined, legendImageStore, mockGetCapabilities, parseISO8601DateToDate, parseISO8601IntervalToDateInterval, registerWMJSMap, registerWMLayer, tilesettings, toArray, unRegisterAllWMJSLayersAndMaps, unRegisterWMJSLayer, unRegisterWMJSMap, testSettings as webmapTestSettings, utils as webmapUtils };