https://www.better.org.uk/library/assets/application-f2fc7c11.js

43// node_modules/@rails/actioncable/src/adapters.js
44  var adapters_default;
45  var init_adapters = __esm({
46    "node_modules/@rails/actioncable/src/adapters.js"() {
47      adapters_default = {
48        logger: typeof console !== "undefined" ? console : void 0,
49        WebSocket: typeof WebSocket !== "undefined" ? WebSocket : void 0
50      };
51    }
52  });
53
54  

54// node_modules/@rails/actioncable/src/logger.js
55  var logger_default;
56  var init_logger = __esm({
57    "node_modules/@rails/actioncable/src/logger.js"() {
58      init_adapters();
59      logger_default = {
60        log(...messages) {
61          if (this.enabled) {
62            messages.push(Date.now());
63            adapters_default.logger.log("[ActionCable]", ...messages);
64          }
65        }
66      };
67    }
68  });
69
70  

70// node_modules/@rails/actioncable/src/connection_monitor.js
71  var now, secondsSince, ConnectionMonitor, connection_monitor_default;
72  var init_connection_monitor = __esm({
73    "node_modules/@rails/actioncable/src/connection_monitor.js"() {
74      init_logger();
75      now = () => new Date().getTime();
76      secondsSince = (time) => (now() - time) / 1e3;
77      ConnectionMonitor = class {
78        constructor(connection) {
79          this.visibilityDidChange = this.visibilityDidChange.bind(this);
80          this.connection = connection;
81          this.reconnectAttempts = 0;
82        }
83        start() {
84          if (!this.isRunning()) {
85            this.startedAt = now();
86            delete this.stoppedAt;
87            this.startPolling();
88            addEventListener("visibilitychange", this.visibilityDidChange);
89            logger_default.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
90          }
91        }
92        stop() {
93          if (this.isRunning()) {
94            this.stoppedAt = now();
95            this.stopPolling();
96            removeEventListener("visibilitychange", this.visibilityDidChange);
97            logger_default.log("ConnectionMonitor stopped");
98          }
99        }
100        isRunning() {
101          return this.startedAt && !this.stoppedAt;
102        }
103        recordMessage() {
104          this.pingedAt = now();
105        }
106        recordConnect() {
107          this.reconnectAttempts = 0;
108          delete this.disconnectedAt;
109          logger_default.log("ConnectionMonitor recorded connect");
110        }
111        recordDisconnect() {
112          this.disconnectedAt = now();
113          logger_default.log("ConnectionMonitor recorded disconnect");
114        }
115        startPolling() {
116          this.stopPolling();
117          this.poll();
118        }
119        stopPolling() {
120          clearTimeout(this.pollTimeout);
121        }
122        poll() {
123          this.pollTimeout = setTimeout(
124            () => {
125              this.reconnectIfStale();
126              this.poll();
127            },
128            this.getPollInterval()
129          );
130        }
131        getPollInterval() {
132          const { staleThreshold, reconnectionBackoffRate } = this.constructor;
133          const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
134          const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
135          const jitter = jitterMax * Math.random();
136          return staleThreshold * 1e3 * backoff * (1 + jitter);
137        }
138        reconnectIfStale() {
139          if (this.connectionIsStale()) {
140            logger_default.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
141            this.reconnectAttempts++;
142            if (this.disconnectedRecently()) {
143              logger_default.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
144            } else {
145              logger_default.log("ConnectionMonitor reopening");
146              this.connection.reopen();
147            }
148          }
149        }
150        get refreshedAt() {
151          return this.pingedAt ? this.pingedAt : this.startedAt;
152        }
153        connectionIsStale() {
154          return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
155        }
156        disconnectedRecently() {
157          return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
158        }
159        visibilityDidChange() {
160          if (document.visibilityState === "visible") {
161            setTimeout(
162              () => {
163                if (this.connectionIsStale() || !this.connection.isOpen()) {
164                  logger_default.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
165                  this.connection.reopen();
166                }
167              },
168              200
169            );
170          }
171        }
172      };
173      ConnectionMonitor.staleThreshold = 6;
174      ConnectionMonitor.reconnectionBackoffRate = 0.15;
175      connection_monitor_default = ConnectionMonitor;
176    }
177  });
178
179  

179// node_modules/@rails/actioncable/src/internal.js
180  var internal_default;
181  var init_internal = __esm({
182    "node_modules/@rails/actioncable/src/internal.js"() {
183      internal_default = {
184        "message_types": {
185          "welcome": "welcome",
186          "disconnect": "disconnect",
187          "ping": "ping",
188          "confirmation": "confirm_subscription",
189          "rejection": "reject_subscription"
190        },
191        "disconnect_reasons": {
192          "unauthorized": "unauthorized",
193          "invalid_request": "invalid_request",
194          "server_restart": "server_restart",
195          "remote": "remote"
196        },
197        "default_mount_path": "/cable",
198        "protocols": [
199          "actioncable-v1-json",
200          "actioncable-unsupported"
201        ]
202      };
203    }
204  });
205
206  

206// node_modules/@rails/actioncable/src/connection.js
207  var message_types, protocols, supportedProtocols, indexOf, Connection, connection_default;
208  var init_connection = __esm({
209    "node_modules/@rails/actioncable/src/connection.js"() {
210      init_adapters();
211      init_connection_monitor();
212      init_internal();
213      init_logger();
214      ({ message_types, protocols } = internal_default);
215      supportedProtocols = protocols.slice(0, protocols.length - 1);
216      indexOf = [].indexOf;
217      Connection = class {
218        constructor(consumer2) {
219          this.open = this.open.bind(this);
220          this.consumer = consumer2;
221          this.subscriptions = this.consumer.subscriptions;
222          this.monitor = new connection_monitor_default(this);
223          this.disconnected = true;
224        }
225        send(data) {
226          if (this.isOpen()) {
227            this.webSocket.send(JSON.stringify(data));
228            return true;
229          } else {
230            return false;
231          }
232        }
233        open() {
234          if (this.isActive()) {
235            logger_default.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
236            return false;
237          } else {
238            const socketProtocols = [...protocols, ...this.consumer.subprotocols || []];
239            logger_default.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
240            if (this.webSocket) {
241              this.uninstallEventHandlers();
242            }
243            this.webSocket = new adapters_default.WebSocket(this.consumer.url, socketProtocols);
244            this.installEventHandlers();
245            this.monitor.start();
246            return true;
247          }
248        }
249        close({ allowReconnect } = { allowReconnect: true }) {
250          if (!allowReconnect) {
251            this.monitor.stop();
252          }
253          if (this.isOpen()) {
254            return this.webSocket.close();
255          }
256        }
257        reopen() {
258          logger_default.log(`Reopening WebSocket, current state is ${this.getState()}`);
259          if (this.isActive()) {
260            try {
261              return this.close();
262            } catch (error2) {
263              logger_default.log("Failed to reopen WebSocket", error2);
264            } finally {
265              logger_default.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
266              setTimeout(this.open, this.constructor.reopenDelay);
267            }
268          } else {
269            return this.open();
270          }
271        }
272        getProtocol() {
273          if (this.webSocket) {
274            return this.webSocket.protocol;
275          }
276        }
277        isOpen() {
278          return this.isState("open");
279        }
280        isActive() {
281          return this.isState("open", "connecting");
282        }
283        triedToReconnect() {
284          return this.monitor.reconnectAttempts > 0;
285        }
286        isProtocolSupported() {
287          return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
288        }
289        isState(...states) {
290          return indexOf.call(states, this.getState()) >= 0;
291        }
292        getState() {
293          if (this.webSocket) {
294            for (let state in adapters_default.WebSocket) {
295              if (adapters_default.WebSocket[state] === this.webSocket.readyState) {
296                return state.toLowerCase();
297              }
298            }
299          }
300          return null;
301        }
302        installEventHandlers() {
303          for (let eventName in this.events) {
304            const handler = this.events[eventName].bind(this);
305            this.webSocket[`on${eventName}`] = handler;
306          }
307        }
308        uninstallEventHandlers() {
309          for (let eventName in this.events) {
310            this.webSocket[`on${eventName}`] = function() {
311            };
312          }
313        }
314      };
315      Connection.reopenDelay = 500;
316      Connection.prototype.events = {
317        message(event2) {
318          if (!this.isProtocolSupported()) {
319            return;
320          }
321          const { identifier, message, reason, reconnect, type } = JSON.parse(event2.data);
322          this.monitor.recordMessage();
323          switch (type) {
324            case message_types.welcome:
325              if (this.triedToReconnect()) {
326                this.reconnectAttempted = true;
327              }
328              this.monitor.recordConnect();
329              return this.subscriptions.reload();
330            case message_types.disconnect:
331              logger_default.log(`Disconnecting. Reason: ${reason}`);
332              return this.close({ allowReconnect: reconnect });
333            case message_types.ping:
334              return null;
335            case message_types.confirmation:
336              this.subscriptions.confirmSubscription(identifier);
337              if (this.reconnectAttempted) {
338                this.reconnectAttempted = false;
339                return this.subscriptions.notify(identifier, "connected", { reconnected: true });
340              } else {
341                return this.subscriptions.notify(identifier, "connected", { reconnected: false });
342              }
343            case message_types.rejection:
344              return this.subscriptions.reject(identifier);
345            default:
346              return this.subscriptions.notify(identifier, "received", message);
347          }
348        },
349        open() {
350          logger_default.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
351          this.disconnected = false;
352          if (!this.isProtocolSupported()) {
353            logger_default.log("Protocol is unsupported. Stopping monitor and disconnecting.");
354            return this.close({ allowReconnect: false });
355          }
356        },
357        close(event2) {
358          logger_default.log("WebSocket onclose event");
359          if (this.disconnected) {
360            return;
361          }
362          this.disconnected = true;
363          this.monitor.recordDisconnect();
364          return this.subscriptions.notifyAll("disconnected", { willAttemptReconnect: this.monitor.isRunning() });
365        },
366        error() {
367          logger_default.log("WebSocket onerror event");
368        }
369      };
370      connection_default = Connection;
371    }
372  });
373
374  

374// node_modules/@rails/actioncable/src/subscription.js
375  var extend, Subscription;
376  var init_subscription = __esm({
377    "node_modules/@rails/actioncable/src/subscription.js"() {
378      extend = function(object, properties) {
379        if (properties != null) {
380          for (let key in properties) {
381            const value = properties[key];
382            object[key] = value;
383          }
384        }
385        return object;
386      };
387      Subscription = class {
388        constructor(consumer2, params = {}, mixin) {
389          this.consumer = consumer2;
390          this.identifier = JSON.stringify(params);
391          extend(this, mixin);
392        }
393        perform(action, data = {}) {
394          data.action = action;
395          return this.send(data);
396        }
397        send(data) {
398          return this.consumer.send({ command: "message", identifier: this.identifier, data: JSON.stringify(data) });
399        }
400        unsubscribe() {
401          return this.consumer.subscriptions.remove(this);
402        }
403      };
404    }
405  });
406
407  

407// node_modules/@rails/actioncable/src/subscription_guarantor.js
408  var SubscriptionGuarantor, subscription_guarantor_default;
409  var init_subscription_guarantor = __esm({
410    "node_modules/@rails/actioncable/src/subscription_guarantor.js"() {
411      init_logger();
412      SubscriptionGuarantor = class {
413        constructor(subscriptions) {
414          this.subscriptions = subscriptions;
415          this.pendingSubscriptions = [];
416        }
417        guarantee(subscription) {
418          if (this.pendingSubscriptions.indexOf(subscription) == -1) {
419            logger_default.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
420            this.pendingSubscriptions.push(subscription);
421          } else {
422            logger_default.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
423          }
424          this.startGuaranteeing();
425        }
426        forget(subscription) {
427          logger_default.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
428          this.pendingSubscriptions = this.pendingSubscriptions.filter((s4) => s4 !== subscription);
429        }
430        startGuaranteeing() {
431          this.stopGuaranteeing();
432          this.retrySubscribing();
433        }
434        stopGuaranteeing() {
435          clearTimeout(this.retryTimeout);
436        }
437        retrySubscribing() {
438          this.retryTimeout = setTimeout(
439            () => {
440              if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
441                this.pendingSubscriptions.map((subscription) => {
442                  logger_default.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
443                  this.subscriptions.subscribe(subscription);
444                });
445              }
446            },
447            500
448          );
449        }
450      };
451      subscription_guarantor_default = SubscriptionGuarantor;
452    }
453  });
454
455  

455// node_modules/@rails/actioncable/src/subscriptions.js
456  var Subscriptions;
457  var init_subscriptions = __esm({
458    "node_modules/@rails/actioncable/src/subscriptions.js"() {
459      init_subscription();
460      init_subscription_guarantor();
461      init_logger();
462      Subscriptions = class {
463        constructor(consumer2) {
464          this.consumer = consumer2;
465          this.guarantor = new subscription_guarantor_default(this);
466          this.subscriptions = [];
467        }
468        create(channelName, mixin) {
469          const channel = channelName;
470          const params = typeof channel === "object" ? channel : { channel };
471          const subscription = new Subscription(this.consumer, params, mixin);
472          return this.add(subscription);
473        }
474        add(subscription) {
475          this.subscriptions.push(subscription);
476          this.consumer.ensureActiveConnection();
477          this.notify(subscription, "initialized");
478          this.subscribe(subscription);
479          return subscription;
480        }
481        remove(subscription) {
482          this.forget(subscription);
483          if (!this.findAll(subscription.identifier).length) {
484            this.sendCommand(subscription, "unsubscribe");
485          }
486          return subscription;
487        }
488        reject(identifier) {
489          return this.findAll(identifier).map((subscription) => {
490            this.forget(subscription);
491            this.notify(subscription, "rejected");
492            return subscription;
493          });
494        }
495        forget(subscription) {
496          this.guarantor.forget(subscription);
497          this.subscriptions = this.subscriptions.filter((s4) => s4 !== subscription);
498          return subscription;
499        }
500        findAll(identifier) {
501          return this.subscriptions.filter((s4) => s4.identifier === identifier);
502        }
503        reload() {
504          return this.subscriptions.map((subscription) => this.subscribe(subscription));
505        }
506        notifyAll(callbackName, ...args) {
507          return this.subscriptions.map((subscription) => this.notify(subscription, callbackName, ...args));
508        }
509        notify(subscription, callbackName, ...args) {
510          let subscriptions;
511          if (typeof subscription === "string") {
512            subscriptions = this.findAll(subscription);
513          } else {
514            subscriptions = [subscription];
515          }
516          return subscriptions.map((subscription2) => typeof subscription2[callbackName] === "function" ? subscription2[callbackName](...args) : void 0);
517        }
518        subscribe(subscription) {
519          if (this.sendCommand(subscription, "subscribe")) {
520            this.guarantor.guarantee(subscription);
521          }
522        }
523        confirmSubscription(identifier) {
524          logger_default.log(`Subscription confirmed ${identifier}`);
525          this.findAll(identifier).map((subscription) => this.guarantor.forget(subscription));
526        }
527        sendCommand(subscription, command) {
528          const { identifier } = subscription;
529          return this.consumer.send({ command, identifier });
530        }
531      };
532    }
533  });
534
535  

535// node_modules/@rails/actioncable/src/consumer.js
536  function createWebSocketURL(url) {
537    if (typeof url === "function") {
538      url = url();
539    }
540    if (url && !/^wss?:/i.test(url)) {
541      const a4 = document.createElement("a");
542      a4.href = url;
543      a4.href = a4.href;
544      a4.protocol = a4.protocol.replace("http", "ws");
545      return a4.href;
546    } else {
547      return url;
548    }
549  }
550  var Consumer;
551  var init_consumer = __esm({
552    "node_modules/@rails/actioncable/src/consumer.js"() {
553      init_connection();
554      init_subscriptions();
555      Consumer = class {
556        constructor(url) {
557          this._url = url;
558          this.subscriptions = new Subscriptions(this);
559          this.connection = new connection_default(this);
560          this.subprotocols = [];
561        }
562        get url() {
563          return createWebSocketURL(this._url);
564        }
565        send(data) {
566          return this.connection.send(data);
567        }
568        connect() {
569          return this.connection.open();
570        }
571        disconnect() {
572          return this.connection.close({ allowReconnect: false });
573        }
574        ensureActiveConnection() {
575          if (!this.connection.isActive()) {
576            return this.connection.open();
577          }
578        }
579        addSubProtocol(subprotocol) {
580          this.subprotocols = [...this.subprotocols, subprotocol];
581        }
582      };
583    }
584  });
585
586  

586// node_modules/@rails/actioncable/src/index.js
587  var src_exports = {};
588  __export(src_exports, {
589    Connection: () => connection_default,
590    ConnectionMonitor: () => connection_monitor_default,
591    Consumer: () => Consumer,
592    INTERNAL: () => internal_default,
593    Subscription: () => Subscription,
594    SubscriptionGuarantor: () => subscription_guarantor_default,
595    Subscriptions: () => Subscriptions,
596    adapters: () => adapters_default,
597    createConsumer: () => createConsumer,
598    createWebSocketURL: () => createWebSocketURL,
599    getConfig: () => getConfig,
600    logger: () => logger_default
601  });
602  function createConsumer(url = getConfig("url") || internal_default.default_mount_path) {
603    return new Consumer(url);
604  }
605  function getConfig(name) {
606    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
607    if (element) {
608      return element.getAttribute("content");
609    }
610  }
611  var init_src = __esm({
612    "node_modules/@rails/actioncable/src/index.js"() {
613      init_connection();
614      init_connection_monitor();
615      init_consumer();
616      init_internal();
617      init_subscription();
618      init_subscriptions();
619      init_subscription_guarantor();
620      init_adapters();
621      init_logger();
622    }
623  });
624
625  

625// node_modules/moment/moment.js
626  var require_moment = __commonJS({
627    "node_modules/moment/moment.js"(exports, module) {
628      (function(global, factory) {
629        typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global.moment = factory();
630      })(exports, function() {
631        "use strict";
632        var hookCallback;
633        function hooks() {
634          return hookCallback.apply(null, arguments);
635        }
636        function setHookCallback(callback) {
637          hookCallback = callback;
638        }
639        function isArray(input) {
640          return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]";
641        }
642        function isObject3(input) {
643          return input != null && Object.prototype.toString.call(input) === "[object Object]";
644        }
645        function hasOwnProp(a4, b4) {
646          return Object.prototype.hasOwnProperty.call(a4, b4);
647        }
648        function isObjectEmpty(obj) {
649          if (Object.getOwnPropertyNames) {
650            return Object.getOwnPropertyNames(obj).length === 0;
651          } else {
652            var k4;
653            for (k4 in obj) {
654              if (hasOwnProp(obj, k4)) {
655                return false;
656              }
657            }
658            return true;
659          }
660        }
661        function isUndefined(input) {
662          return input === void 0;
663        }
664        function isNumber(input) {
665          return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]";
666        }
667        function isDate(input) {
668          return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
669        }
670        function map(arr, fn3) {
671          var res = [], i4, arrLen = arr.length;
672          for (i4 = 0; i4 < arrLen; ++i4) {
673            res.push(fn3(arr[i4], i4));
674          }
675          return res;
676        }
677        function extend5(a4, b4) {
678          for (var i4 in b4) {
679            if (hasOwnProp(b4, i4)) {
680              a4[i4] = b4[i4];
681            }
682          }
683          if (hasOwnProp(b4, "toString")) {
684            a4.toString = b4.toString;
685          }
686          if (hasOwnProp(b4, "valueOf")) {
687            a4.valueOf = b4.valueOf;
688          }
689          return a4;
690        }
691        function createUTC(input, format2, locale2, strict) {
692          return createLocalOrUTC(input, format2, locale2, strict, true).utc();
693        }
694        function defaultParsingFlags() {
695          return {
696            empty: false,
697            unusedTokens: [],
698            unusedInput: [],
699            overflow: -2,
700            charsLeftOver: 0,
701            nullInput: false,
702            invalidEra: null,
703            invalidMonth: null,
704            invalidFormat: false,
705            userInvalidated: false,
706            iso: false,
707            parsedDateParts: [],
708            era: null,
709            meridiem: null,
710            rfc2822: false,
711            weekdayMismatch: false
712          };
713        }
714        function getParsingFlags(m5) {
715          if (m5._pf == null) {
716            m5._pf = defaultParsingFlags();
717          }
718          return m5._pf;
719        }
720        var some;
721        if (Array.prototype.some) {
722          some = Array.prototype.some;
723        } else {
724          some = function(fun) {
725            var t5 = Object(this), len = t5.length >>> 0, i4;
726            for (i4 = 0; i4 < len; i4++) {
727              if (i4 in t5 && fun.call(this, t5[i4], i4, t5)) {
728                return true;
729              }
730            }
731            return false;
732          };
733        }
734        function isValid(m5) {
735          var flags = null, parsedParts = false, isNowValid = m5._d && !isNaN(m5._d.getTime());
736          if (isNowValid) {
737            flags = getParsingFlags(m5);
738            parsedParts = some.call(flags.parsedDateParts, function(i4) {
739              return i4 != null;
740            });
741            isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
742            if (m5._strict) {
743              isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0;
744            }
745          }
746          if (Object.isFrozen == null || !Object.isFrozen(m5)) {
747            m5._isValid = isNowValid;
748          } else {
749            return isNowValid;
750          }
751          return m5._isValid;
752        }
753        function createInvalid(flags) {
754          var m5 = createUTC(NaN);
755          if (flags != null) {
756            extend5(getParsingFlags(m5), flags);
757          } else {
758            getParsingFlags(m5).userInvalidated = true;
759          }
760          return m5;
761        }
762        var momentProperties = hooks.momentProperties = [], updateInProgress = false;
763        function copyConfig(to3, from2) {
764          var i4, prop, val, momentPropertiesLen = momentProperties.length;
765          if (!isUndefined(from2._isAMomentObject)) {
766            to3._isAMomentObject = from2._isAMomentObject;
767          }
768          if (!isUndefined(from2._i)) {
769            to3._i = from2._i;
770          }
771          if (!isUndefined(from2._f)) {
772            to3._f = from2._f;
773          }
774          if (!isUndefined(from2._l)) {
775            to3._l = from2._l;
776          }
777          if (!isUndefined(from2._strict)) {
778            to3._strict = from2._strict;
779          }
780          if (!isUndefined(from2._tzm)) {
781            to3._tzm = from2._tzm;
782          }
783          if (!isUndefined(from2._isUTC)) {
784            to3._isUTC = from2._isUTC;
785          }
786          if (!isUndefined(from2._offset)) {
787            to3._offset = from2._offset;
788          }
789          if (!isUndefined(from2._pf)) {
790            to3._pf = getParsingFlags(from2);
791          }
792          if (!isUndefined(from2._locale)) {
793            to3._locale = from2._locale;
794          }
795          if (momentPropertiesLen > 0) {
796            for (i4 = 0; i4 < momentPropertiesLen; i4++) {
797              prop = momentProperties[i4];
798              val = from2[prop];
799              if (!isUndefined(val)) {
800                to3[prop] = val;
801              }
802            }
803          }
804          return to3;
805        }
806        function Moment3(config2) {
807          copyConfig(this, config2);
808          this._d = new Date(config2._d != null ? config2._d.getTime() : NaN);
809          if (!this.isValid()) {
810            this._d = new Date(NaN);
811          }
812          if (updateInProgress === false) {
813            updateInProgress = true;
814            hooks.updateOffset(this);
815            updateInProgress = false;
816          }
817        }
818        function isMoment(obj) {
819          return obj instanceof Moment3 || obj != null && obj._isAMomentObject != null;
820        }
821        function warn(msg) {
822          if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) {
823            console.warn("Deprecation warning: " + msg);
824          }
825        }
826        function deprecate(msg, fn3) {
827          var firstTime = true;
828          return extend5(function() {
829            if (hooks.deprecationHandler != null) {
830              hooks.deprecationHandler(null, msg);
831            }
832            if (firstTime) {
833              var args = [], arg, i4, key, argLen = arguments.length;
834              for (i4 = 0; i4 < argLen; i4++) {
835                arg = "";
836                if (typeof arguments[i4] === "object") {
837                  arg += "\n[" + i4 + "] ";
838                  for (key in arguments[0]) {
839                    if (hasOwnProp(arguments[0], key)) {
840                      arg += key + ": " + arguments[0][key] + ", ";
841                    }
842                  }
843                  arg = arg.slice(0, -2);
844                } else {
845                  arg = arguments[i4];
846                }
847                args.push(arg);
848              }
849              warn(
850                msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack
851              );
852              firstTime = false;
853            }
854            return fn3.apply(this, arguments);
855          }, fn3);
856        }
857        var deprecations = {};
858        function deprecateSimple(name, msg) {
859          if (hooks.deprecationHandler != null) {
860            hooks.deprecationHandler(name, msg);
861          }
862          if (!deprecations[name]) {
863            warn(msg);
864            deprecations[name] = true;
865          }
866        }
867        hooks.suppressDeprecationWarnings = false;
868        hooks.deprecationHandler = null;
869        function isFunction(input) {
870          return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
871        }
872        function set(config2) {
873          var prop, i4;
874          for (i4 in config2) {
875            if (hasOwnProp(config2, i4)) {
876              prop = config2[i4];
877              if (isFunction(prop)) {
878                this[i4] = prop;
879              } else {
880                this["_" + i4] = prop;
881              }
882            }
883          }
884          this._config = config2;
885          this._dayOfMonthOrdinalParseLenient = new RegExp(
886            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source
887          );
888        }
889        function mergeConfigs(parentConfig, childConfig) {
890          var res = extend5({}, parentConfig), prop;
891          for (prop in childConfig) {
892            if (hasOwnProp(childConfig, prop)) {
893              if (isObject3(parentConfig[prop]) && isObject3(childConfig[prop])) {
894                res[prop] = {};
895                extend5(res[prop], parentConfig[prop]);
896                extend5(res[prop], childConfig[prop]);
897              } else if (childConfig[prop] != null) {
898                res[prop] = childConfig[prop];
899              } else {
900                delete res[prop];
901              }
902            }
903          }
904          for (prop in parentConfig) {
905            if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject3(parentConfig[prop])) {
906              res[prop] = extend5({}, res[prop]);
907            }
908          }
909          return res;
910        }
911        function Locale(config2) {
912          if (config2 != null) {
913            this.set(config2);
914          }
915        }
916        var keys;
917        if (Object.keys) {
918          keys = Object.keys;
919        } else {
920          keys = function(obj) {
921            var i4, res = [];
922            for (i4 in obj) {
923              if (hasOwnProp(obj, i4)) {
924                res.push(i4);
925              }
926            }
927            return res;
928          };
929        }
930        var defaultCalendar = {
931          sameDay: "[Today at] LT",
932          nextDay: "[Tomorrow at] LT",
933          nextWeek: "dddd [at] LT",
934          lastDay: "[Yesterday at] LT",
935          lastWeek: "[Last] dddd [at] LT",
936          sameElse: "L"
937        };
938        function calendar(key, mom, now4) {
939          var output = this._calendar[key] || this._calendar["sameElse"];
940          return isFunction(output) ? output.call(mom, now4) : output;
941        }
942        function zeroFill(number, targetLength, forceSign) {
943          var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0;
944          return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
945        }
946        var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
947        function addFormatToken(token2, padded, ordinal2, callback) {
948          var func = callback;
949          if (typeof callback === "string") {
950            func = function() {
951              return this[callback]();
952            };
953          }
954          if (token2) {
955            formatTokenFunctions[token2] = func;
956          }
957          if (padded) {
958            formatTokenFunctions[padded[0]] = function() {
959              return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
960            };
961          }
962          if (ordinal2) {
963            formatTokenFunctions[ordinal2] = function() {
964              return this.localeData().ordinal(
965                func.apply(this, arguments),
966                token2
967              );
968            };
969          }
970        }
971        function removeFormattingTokens(input) {
972          if (input.match(/\[[\s\S]/)) {
973            return input.replace(/^\[|\]$/g, "");
974          }
975          return input.replace(/\\/g, "");
976        }
977        function makeFormatFunction(format2) {
978          var array = format2.match(formattingTokens), i4, length;
979          for (i4 = 0, length = array.length; i4 < length; i4++) {
980            if (formatTokenFunctions[array[i4]]) {
981              array[i4] = formatTokenFunctions[array[i4]];
982            } else {
983              array[i4] = removeFormattingTokens(array[i4]);
984            }
985          }
986          return function(mom) {
987            var output = "", i5;
988            for (i5 = 0; i5 < length; i5++) {
989              output += isFunction(array[i5]) ? array[i5].call(mom, format2) : array[i5];
990            }
991            return output;
992          };
993        }
994        function formatMoment(m5, format2) {
995          if (!m5.isValid()) {
996            return m5.localeData().invalidDate();
997          }
998          format2 = expandFormat(format2, m5.localeData());
999          formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
1000          return formatFunctions[format2](m5);
1001        }
1002        function expandFormat(format2, locale2) {
1003          var i4 = 5;
1004          function replaceLongDateFormatTokens(input) {
1005            return locale2.longDateFormat(input) || input;
1006          }
1007          localFormattingTokens.lastIndex = 0;
1008          while (i4 >= 0 && localFormattingTokens.test(format2)) {
1009            format2 = format2.replace(
1010              localFormattingTokens,
1011              replaceLongDateFormatTokens
1012            );
1013            localFormattingTokens.lastIndex = 0;
1014            i4 -= 1;
1015          }
1016          return format2;
1017        }
1018        var defaultLongDateFormat = {
1019          LTS: "h:mm:ss A",
1020          LT: "h:mm A",
1021          L: "MM/DD/YYYY",
1022          LL: "MMMM D, YYYY",
1023          LLL: "MMMM D, YYYY h:mm A",
1024          LLLL: "dddd, MMMM D, YYYY h:mm A"
1025        };
1026        function longDateFormat(key) {
1027          var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
1028          if (format2 || !formatUpper) {
1029            return format2;
1030          }
1031          this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
1032            if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
1033              return tok.slice(1);
1034            }
1035            return tok;
1036          }).join("");
1037          return this._longDateFormat[key];
1038        }
1039        var defaultInvalidDate = "Invalid date";
1040        function invalidDate() {
1041          return this._invalidDate;
1042        }
1043        var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
1044        function ordinal(number) {
1045          return this._ordinal.replace("%d", number);
1046        }
1047        var defaultRelativeTime = {
1048          future: "in %s",
1049          past: "%s ago",
1050          s: "a few seconds",
1051          ss: "%d seconds",
1052          m: "a minute",
1053          mm: "%d minutes",
1054          h: "an hour",
1055          hh: "%d hours",
1056          d: "a day",
1057          dd: "%d days",
1058          w: "a week",
1059          ww: "%d weeks",
1060          M: "a month",
1061          MM: "%d months",
1062          y: "a year",
1063          yy: "%d years"
1064        };
1065        function relativeTime(number, withoutSuffix, string, isFuture) {
1066          var output = this._relativeTime[string];
1067          return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
1068        }
1069        function pastFuture(diff2, output) {
1070          var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
1071          return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
1072        }
1073        var aliases = {
1074          D: "date",
1075          dates: "date",
1076          date: "date",
1077          d: "day",
1078          days: "day",
1079          day: "day",
1080          e: "weekday",
1081          weekdays: "weekday",
1082          weekday: "weekday",
1083          E: "isoWeekday",
1084          isoweekdays: "isoWeekday",
1085          isoweekday: "isoWeekday",
1086          DDD: "dayOfYear",
1087          dayofyears: "dayOfYear",
1088          dayofyear: "dayOfYear",
1089          h: "hour",
1090          hours: "hour",
1091          hour: "hour",
1092          ms: "millisecond",
1093          milliseconds: "millisecond",
1094          millisecond: "millisecond",
1095          m: "minute",
1096          minutes: "minute",
1097          minute: "minute",
1098          M: "month",
1099          months: "month",
1100          month: "month",
1101          Q: "quarter",
1102          quarters: "quarter",
1103          quarter: "quarter",
1104          s: "second",
1105          seconds: "second",
1106          second: "second",
1107          gg: "weekYear",
1108          weekyears: "weekYear",
1109          weekyear: "weekYear",
1110          GG: "isoWeekYear",
1111          isoweekyears: "isoWeekYear",
1112          isoweekyear: "isoWeekYear",
1113          w: "week",
1114          weeks: "week",
1115          week: "week",
1116          W: "isoWeek",
1117          isoweeks: "isoWeek",
1118          isoweek: "isoWeek",
1119          y: "year",
1120          years: "year",
1121          year: "year"
1122        };
1123        function normalizeUnits(units) {
1124          return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0;
1125        }
1126        function normalizeObjectUnits(inputObject) {
1127          var normalizedInput = {}, normalizedProp, prop;
1128          for (prop in inputObject) {
1129            if (hasOwnProp(inputObject, prop)) {
1130              normalizedProp = normalizeUnits(prop);
1131              if (normalizedProp) {
1132                normalizedInput[normalizedProp] = inputObject[prop];
1133              }
1134            }
1135          }
1136          return normalizedInput;
1137        }
1138        var priorities = {
1139          date: 9,
1140          day: 11,
1141          weekday: 11,
1142          isoWeekday: 11,
1143          dayOfYear: 4,
1144          hour: 13,
1145          millisecond: 16,
1146          minute: 14,
1147          month: 8,
1148          quarter: 7,
1149          second: 15,
1150          weekYear: 1,
1151          isoWeekYear: 1,
1152          week: 5,
1153          isoWeek: 5,
1154          year: 1
1155        };
1156        function getPrioritizedUnits(unitsObj) {
1157          var units = [], u4;
1158          for (u4 in unitsObj) {
1159            if (hasOwnProp(unitsObj, u4)) {
1160              units.push({ unit: u4, priority: priorities[u4] });
1161            }
1162          }
1163          units.sort(function(a4, b4) {
1164            return a4.priority - b4.priority;
1165          });
1166          return units;
1167        }
1168        var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes;
1169        regexes = {};
1170        function addRegexToken(token2, regex, strictRegex) {
1171          regexes[token2] = isFunction(regex) ? regex : function(isStrict, localeData2) {
1172            return isStrict && strictRegex ? strictRegex : regex;
1173          };
1174        }
1175        function getParseRegexForToken(token2, config2) {
1176          if (!hasOwnProp(regexes, token2)) {
1177            return new RegExp(unescapeFormat(token2));
1178          }
1179          return regexes[token2](config2._strict, config2._locale);
1180        }
1181        function unescapeFormat(s4) {
1182          return regexEscape(
1183            s4.replace("\\", "").replace(
1184              /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
1185              function(matched, p1, p22, p32, p4) {
1186                return p1 || p22 || p32 || p4;
1187              }
1188            )
1189          );
1190        }
1191        function regexEscape(s4) {
1192          return s4.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
1193        }
1194        function absFloor(number) {
1195          if (number < 0) {
1196            return Math.ceil(number) || 0;
1197          } else {
1198            return Math.floor(number);
1199          }
1200        }
1201        function toInt(argumentForCoercion) {
1202          var coercedNumber = +argumentForCoercion, value = 0;
1203          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
1204            value = absFloor(coercedNumber);
1205          }
1206          return value;
1207        }
1208        var tokens = {};
1209        function addParseToken(token2, callback) {
1210          var i4, func = callback, tokenLen;
1211          if (typeof token2 === "string") {
1212            token2 = [token2];
1213          }
1214          if (isNumber(callback)) {
1215            func = function(input, array) {
1216              array[callback] = toInt(input);
1217            };
1218          }
1219          tokenLen = token2.length;
1220          for (i4 = 0; i4 < tokenLen; i4++) {
1221            tokens[token2[i4]] = func;
1222          }
1223        }
1224        function addWeekParseToken(token2, callback) {
1225          addParseToken(token2, function(input, array, config2, token3) {
1226            config2._w = config2._w || {};
1227            callback(input, config2._w, config2, token3);
1228          });
1229        }
1230        function addTimeToArrayFromToken(token2, input, config2) {
1231          if (input != null && hasOwnProp(tokens, token2)) {
1232            tokens[token2](input, config2._a, config2, token2);
1233          }
1234        }
1235        function isLeapYear(year) {
1236          return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
1237        }
1238        var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8;
1239        addFormatToken("Y", 0, 0, function() {
1240          var y4 = this.year();
1241          return y4 <= 9999 ? zeroFill(y4, 4) : "+" + y4;
1242        });
1243        addFormatToken(0, ["YY", 2], 0, function() {
1244          return this.year() % 100;
1245        });
1246        addFormatToken(0, ["YYYY", 4], 0, "year");
1247        addFormatToken(0, ["YYYYY", 5], 0, "year");
1248        addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
1249        addRegexToken("Y", matchSigned);
1250        addRegexToken("YY", match1to2, match2);
1251        addRegexToken("YYYY", match1to4, match4);
1252        addRegexToken("YYYYY", match1to6, match6);
1253        addRegexToken("YYYYYY", match1to6, match6);
1254        addParseToken(["YYYYY", "YYYYYY"], YEAR);
1255        addParseToken("YYYY", function(input, array) {
1256          array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
1257        });
1258        addParseToken("YY", function(input, array) {
1259          array[YEAR] = hooks.parseTwoDigitYear(input);
1260        });
1261        addParseToken("Y", function(input, array) {
1262          array[YEAR] = parseInt(input, 10);
1263        });
1264        function daysInYear(year) {
1265          return isLeapYear(year) ? 366 : 365;
1266        }
1267        hooks.parseTwoDigitYear = function(input) {
1268          return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3);
1269        };
1270        var getSetYear = makeGetSet("FullYear", true);
1271        function getIsLeapYear() {
1272          return isLeapYear(this.year());
1273        }
1274        function makeGetSet(unit, keepTime) {
1275          return function(value) {
1276            if (value != null) {
1277              set$1(this, unit, value);
1278              hooks.updateOffset(this, keepTime);
1279              return this;
1280            } else {
1281              return get2(this, unit);
1282            }
1283          };
1284        }
1285        function get2(mom, unit) {
1286          if (!mom.isValid()) {
1287            return NaN;
1288          }
1289          var d3 = mom._d, isUTC = mom._isUTC;
1290          switch (unit) {
1291            case "Milliseconds":
1292              return isUTC ? d3.getUTCMilliseconds() : d3.getMilliseconds();
1293            case "Seconds":
1294              return isUTC ? d3.getUTCSeconds() : d3.getSeconds();
1295            case "Minutes":
1296              return isUTC ? d3.getUTCMinutes() : d3.getMinutes();
1297            case "Hours":
1298              return isUTC ? d3.getUTCHours() : d3.getHours();
1299            case "Date":
1300              return isUTC ? d3.getUTCDate() : d3.getDate();
1301            case "Day":
1302              return isUTC ? d3.getUTCDay() : d3.getDay();
1303            case "Month":
1304              return isUTC ? d3.getUTCMonth() : d3.getMonth();
1305            case "FullYear":
1306              return isUTC ? d3.getUTCFullYear() : d3.getFullYear();
1307            default:
1308              return NaN;
1309          }
1310        }
1311        function set$1(mom, unit, value) {
1312          var d3, isUTC, year, month, date;
1313          if (!mom.isValid() || isNaN(value)) {
1314            return;
1315          }
1316          d3 = mom._d;
1317          isUTC = mom._isUTC;
1318          switch (unit) {
1319            case "Milliseconds":
1320              return void (isUTC ? d3.setUTCMilliseconds(value) : d3.setMilliseconds(value));
1321            case "Seconds":
1322              return void (isUTC ? d3.setUTCSeconds(value) : d3.setSeconds(value));
1323            case "Minutes":
1324              return void (isUTC ? d3.setUTCMinutes(value) : d3.setMinutes(value));
1325            case "Hours":
1326              return void (isUTC ? d3.setUTCHours(value) : d3.setHours(value));
1327            case "Date":
1328              return void (isUTC ? d3.setUTCDate(value) : d3.setDate(value));
1329            case "FullYear":
1330              break;
1331            default:
1332              return;
1333          }
1334          year = value;
1335          month = mom.month();
1336          date = mom.date();
1337          date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
1338          void (isUTC ? d3.setUTCFullYear(year, month, date) : d3.setFullYear(year, month, date));
1339        }
1340        function stringGet(units) {
1341          units = normalizeUnits(units);
1342          if (isFunction(this[units])) {
1343            return this[units]();
1344          }
1345          return this;
1346        }
1347        function stringSet(units, value) {
1348          if (typeof units === "object") {
1349            units = normalizeObjectUnits(units);
1350            var prioritized = getPrioritizedUnits(units), i4, prioritizedLen = prioritized.length;
1351            for (i4 = 0; i4 < prioritizedLen; i4++) {
1352              this[prioritized[i4].unit](units[prioritized[i4].unit]);
1353            }
1354          } else {
1355            units = normalizeUnits(units);
1356            if (isFunction(this[units])) {
1357              return this[units](value);
1358            }
1359          }
1360          return this;
1361        }
1362        function mod(n3, x5) {
1363          return (n3 % x5 + x5) % x5;
1364        }
1365        var indexOf2;
1366        if (Array.prototype.indexOf) {
1367          indexOf2 = Array.prototype.indexOf;
1368        } else {
1369          indexOf2 = function(o3) {
1370            var i4;
1371            for (i4 = 0; i4 < this.length; ++i4) {
1372              if (this[i4] === o3) {
1373                return i4;
1374              }
1375            }
1376            return -1;
1377          };
1378        }
1379        function daysInMonth(year, month) {
1380          if (isNaN(year) || isNaN(month)) {
1381            return NaN;
1382          }
1383          var modMonth = mod(month, 12);
1384          year += (month - modMonth) / 12;
1385          return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
1386        }
1387        addFormatToken("M", ["MM", 2], "Mo", function() {
1388          return this.month() + 1;
1389        });
1390        addFormatToken("MMM", 0, 0, function(format2) {
1391          return this.localeData().monthsShort(this, format2);
1392        });
1393        addFormatToken("MMMM", 0, 0, function(format2) {
1394          return this.localeData().months(this, format2);
1395        });
1396        addRegexToken("M", match1to2, match1to2NoLeadingZero);
1397        addRegexToken("MM", match1to2, match2);
1398        addRegexToken("MMM", function(isStrict, locale2) {
1399          return locale2.monthsShortRegex(isStrict);
1400        });
1401        addRegexToken("MMMM", function(isStrict, locale2) {
1402          return locale2.monthsRegex(isStrict);
1403        });
1404        addParseToken(["M", "MM"], function(input, array) {
1405          array[MONTH] = toInt(input) - 1;
1406        });
1407        addParseToken(["MMM", "MMMM"], function(input, array, config2, token2) {
1408          var month = config2._locale.monthsParse(input, token2, config2._strict);
1409          if (month != null) {
1410            array[MONTH] = month;
1411          } else {
1412            getParsingFlags(config2).invalidMonth = input;
1413          }
1414        });
1415        var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
1416          "_"
1417        ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
1418        function localeMonths(m5, format2) {
1419          if (!m5) {
1420            return isArray(this._months) ? this._months : this._months["standalone"];
1421          }
1422          return isArray(this._months) ? this._months[m5.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m5.month()];
1423        }
1424        function localeMonthsShort(m5, format2) {
1425          if (!m5) {
1426            return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"];
1427          }
1428          return isArray(this._monthsShort) ? this._monthsShort[m5.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m5.month()];
1429        }
1430        function handleStrictParse(monthName, format2, strict) {
1431          var i4, ii2, mom, llc = monthName.toLocaleLowerCase();
1432          if (!this._monthsParse) {
1433            this._monthsParse = [];
1434            this._longMonthsParse = [];
1435            this._shortMonthsParse = [];
1436            for (i4 = 0; i4 < 12; ++i4) {
1437              mom = createUTC([2e3, i4]);
1438              this._shortMonthsParse[i4] = this.monthsShort(
1439                mom,
1440                ""
1441              ).toLocaleLowerCase();
1442              this._longMonthsParse[i4] = this.months(mom, "").toLocaleLowerCase();
1443            }
1444          }
1445          if (strict) {
1446            if (format2 === "MMM") {
1447              ii2 = indexOf2.call(this._shortMonthsParse, llc);
1448              return ii2 !== -1 ? ii2 : null;
1449            } else {
1450              ii2 = indexOf2.call(this._longMonthsParse, llc);
1451              return ii2 !== -1 ? ii2 : null;
1452            }
1453          } else {
1454            if (format2 === "MMM") {
1455              ii2 = indexOf2.call(this._shortMonthsParse, llc);
1456              if (ii2 !== -1) {
1457                return ii2;
1458              }
1459              ii2 = indexOf2.call(this._longMonthsParse, llc);
1460              return ii2 !== -1 ? ii2 : null;
1461            } else {
1462              ii2 = indexOf2.call(this._longMonthsParse, llc);
1463              if (ii2 !== -1) {
1464                return ii2;
1465              }
1466              ii2 = indexOf2.call(this._shortMonthsParse, llc);
1467              return ii2 !== -1 ? ii2 : null;
1468            }
1469          }
1470        }
1471        function localeMonthsParse(monthName, format2, strict) {
1472          var i4, mom, regex;
1473          if (this._monthsParseExact) {
1474            return handleStrictParse.call(this, monthName, format2, strict);
1475          }
1476          if (!this._monthsParse) {
1477            this._monthsParse = [];
1478            this._longMonthsParse = [];
1479            this._shortMonthsParse = [];
1480          }
1481          for (i4 = 0; i4 < 12; i4++) {
1482            mom = createUTC([2e3, i4]);
1483            if (strict && !this._longMonthsParse[i4]) {
1484              this._longMonthsParse[i4] = new RegExp(
1485                "^" + this.months(mom, "").replace(".", "") + "$",
1486                "i"
1487              );
1488              this._shortMonthsParse[i4] = new RegExp(
1489                "^" + this.monthsShort(mom, "").replace(".", "") + "$",
1490                "i"
1491              );
1492            }
1493            if (!strict && !this._monthsParse[i4]) {
1494              regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
1495              this._monthsParse[i4] = new RegExp(regex.replace(".", ""), "i");
1496            }
1497            if (strict && format2 === "MMMM" && this._longMonthsParse[i4].test(monthName)) {
1498              return i4;
1499            } else if (strict && format2 === "MMM" && this._shortMonthsParse[i4].test(monthName)) {
1500              return i4;
1501            } else if (!strict && this._monthsParse[i4].test(monthName)) {
1502              return i4;
1503            }
1504          }
1505        }
1506        function setMonth(mom, value) {
1507          if (!mom.isValid()) {
1508            return mom;
1509          }
1510          if (typeof value === "string") {
1511            if (/^\d+$/.test(value)) {
1512              value = toInt(value);
1513            } else {
1514              value = mom.localeData().monthsParse(value);
1515              if (!isNumber(value)) {
1516                return mom;
1517              }
1518            }
1519          }
1520          var month = value, date = mom.date();
1521          date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
1522          void (mom._isUTC ? mom._d.setUTCMonth(month, date) : mom._d.setMonth(month, date));
1523          return mom;
1524        }
1525        function getSetMonth(value) {
1526          if (value != null) {
1527            setMonth(this, value);
1528            hooks.updateOffset(this, true);
1529            return this;
1530          } else {
1531            return get2(this, "Month");
1532          }
1533        }
1534        function getDaysInMonth() {
1535          return daysInMonth(this.year(), this.month());
1536        }
1537        function monthsShortRegex(isStrict) {
1538          if (this._monthsParseExact) {
1539            if (!hasOwnProp(this, "_monthsRegex")) {
1540              computeMonthsParse.call(this);
1541            }
1542            if (isStrict) {
1543              return this._monthsShortStrictRegex;
1544            } else {
1545              return this._monthsShortRegex;
1546            }
1547          } else {
1548            if (!hasOwnProp(this, "_monthsShortRegex")) {
1549              this._monthsShortRegex = defaultMonthsShortRegex;
1550            }
1551            return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
1552          }
1553        }
1554        function monthsRegex(isStrict) {
1555          if (this._monthsParseExact) {
1556            if (!hasOwnProp(this, "_monthsRegex")) {
1557              computeMonthsParse.call(this);
1558            }
1559            if (isStrict) {
1560              return this._monthsStrictRegex;
1561            } else {
1562              return this._monthsRegex;
1563            }
1564          } else {
1565            if (!hasOwnProp(this, "_monthsRegex")) {
1566              this._monthsRegex = defaultMonthsRegex;
1567            }
1568            return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
1569          }
1570        }
1571        function computeMonthsParse() {
1572          function cmpLenRev(a4, b4) {
1573            return b4.length - a4.length;
1574          }
1575          var shortPieces = [], longPieces = [], mixedPieces = [], i4, mom, shortP, longP;
1576          for (i4 = 0; i4 < 12; i4++) {
1577            mom = createUTC([2e3, i4]);
1578            shortP = regexEscape(this.monthsShort(mom, ""));
1579            longP = regexEscape(this.months(mom, ""));
1580            shortPieces.push(shortP);
1581            longPieces.push(longP);
1582            mixedPieces.push(longP);
1583            mixedPieces.push(shortP);
1584          }
1585          shortPieces.sort(cmpLenRev);
1586          longPieces.sort(cmpLenRev);
1587          mixedPieces.sort(cmpLenRev);
1588          this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
1589          this._monthsShortRegex = this._monthsRegex;
1590          this._monthsStrictRegex = new RegExp(
1591            "^(" + longPieces.join("|") + ")",
1592            "i"
1593          );
1594          this._monthsShortStrictRegex = new RegExp(
1595            "^(" + shortPieces.join("|") + ")",
1596            "i"
1597          );
1598        }
1599        function createDate(y4, m5, d3, h4, M3, s4, ms) {
1600          var date;
1601          if (y4 < 100 && y4 >= 0) {
1602            date = new Date(y4 + 400, m5, d3, h4, M3, s4, ms);
1603            if (isFinite(date.getFullYear())) {
1604              date.setFullYear(y4);
1605            }
1606          } else {
1607            date = new Date(y4, m5, d3, h4, M3, s4, ms);
1608          }
1609          return date;
1610        }
1611        function createUTCDate(y4) {
1612          var date, args;
1613          if (y4 < 100 && y4 >= 0) {
1614            args = Array.prototype.slice.call(arguments);
1615            args[0] = y4 + 400;
1616            date = new Date(Date.UTC.apply(null, args));
1617            if (isFinite(date.getUTCFullYear())) {
1618              date.setUTCFullYear(y4);
1619            }
1620          } else {
1621            date = new Date(Date.UTC.apply(null, arguments));
1622          }
1623          return date;
1624        }
1625        function firstWeekOffset2(year, dow, doy) {
1626          var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1627          return -fwdlw + fwd - 1;
1628        }
1629        function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1630          var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset2(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
1631          if (dayOfYear <= 0) {
1632            resYear = year - 1;
1633            resDayOfYear = daysInYear(resYear) + dayOfYear;
1634          } else if (dayOfYear > daysInYear(year)) {
1635            resYear = year + 1;
1636            resDayOfYear = dayOfYear - daysInYear(year);
1637          } else {
1638            resYear = year;
1639            resDayOfYear = dayOfYear;
1640          }
1641          return {
1642            year: resYear,
1643            dayOfYear: resDayOfYear
1644          };
1645        }
1646        function weekOfYear2(mom, dow, doy) {
1647          var weekOffset = firstWeekOffset2(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
1648          if (week < 1) {
1649            resYear = mom.year() - 1;
1650            resWeek = week + weeksInYear(resYear, dow, doy);
1651          } else if (week > weeksInYear(mom.year(), dow, doy)) {
1652            resWeek = week - weeksInYear(mom.year(), dow, doy);
1653            resYear = mom.year() + 1;
1654          } else {
1655            resYear = mom.year();
1656            resWeek = week;
1657          }
1658          return {
1659            week: resWeek,
1660            year: resYear
1661          };
1662        }
1663        function weeksInYear(year, dow, doy) {
1664          var weekOffset = firstWeekOffset2(year, dow, doy), weekOffsetNext = firstWeekOffset2(year + 1, dow, doy);
1665          return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1666        }
1667        addFormatToken("w", ["ww", 2], "wo", "week");
1668        addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
1669        addRegexToken("w", match1to2, match1to2NoLeadingZero);
1670        addRegexToken("ww", match1to2, match2);
1671        addRegexToken("W", match1to2, match1to2NoLeadingZero);
1672        addRegexToken("WW", match1to2, match2);
1673        addWeekParseToken(
1674          ["w", "ww", "W", "WW"],
1675          function(input, week, config2, token2) {
1676            week[token2.substr(0, 1)] = toInt(input);
1677          }
1678        );
1679        function localeWeek(mom) {
1680          return weekOfYear2(mom, this._week.dow, this._week.doy).week;
1681        }
1682        var defaultLocaleWeek = {
1683          dow: 0,
1684          doy: 6
1685        };
1686        function localeFirstDayOfWeek() {
1687          return this._week.dow;
1688        }
1689        function localeFirstDayOfYear() {
1690          return this._week.doy;
1691        }
1692        function getSetWeek(input) {
1693          var week = this.localeData().week(this);
1694          return input == null ? week : this.add((input - week) * 7, "d");
1695        }
1696        function getSetISOWeek(input) {
1697          var week = weekOfYear2(this, 1, 4).week;
1698          return input == null ? week : this.add((input - week) * 7, "d");
1699        }
1700        addFormatToken("d", 0, "do", "day");
1701        addFormatToken("dd", 0, 0, function(format2) {
1702          return this.localeData().weekdaysMin(this, format2);
1703        });
1704        addFormatToken("ddd", 0, 0, function(format2) {
1705          return this.localeData().weekdaysShort(this, format2);
1706        });
1707        addFormatToken("dddd", 0, 0, function(format2) {
1708          return this.localeData().weekdays(this, format2);
1709        });
1710        addFormatToken("e", 0, 0, "weekday");
1711        addFormatToken("E", 0, 0, "isoWeekday");
1712        addRegexToken("d", match1to2);
1713        addRegexToken("e", match1to2);
1714        addRegexToken("E", match1to2);
1715        addRegexToken("dd", function(isStrict, locale2) {
1716          return locale2.weekdaysMinRegex(isStrict);
1717        });
1718        addRegexToken("ddd", function(isStrict, locale2) {
1719          return locale2.weekdaysShortRegex(isStrict);
1720        });
1721        addRegexToken("dddd", function(isStrict, locale2) {
1722          return locale2.weekdaysRegex(isStrict);
1723        });
1724        addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config2, token2) {
1725          var weekday = config2._locale.weekdaysParse(input, token2, config2._strict);
1726          if (weekday != null) {
1727            week.d = weekday;
1728          } else {
1729            getParsingFlags(config2).invalidWeekday = input;
1730          }
1731        });
1732        addWeekParseToken(["d", "e", "E"], function(input, week, config2, token2) {
1733          week[token2] = toInt(input);
1734        });
1735        function parseWeekday(input, locale2) {
1736          if (typeof input !== "string") {
1737            return input;
1738          }
1739          if (!isNaN(input)) {
1740            return parseInt(input, 10);
1741          }
1742          input = locale2.weekdaysParse(input);
1743          if (typeof input === "number") {
1744            return input;
1745          }
1746          return null;
1747        }
1748        function parseIsoWeekday(input, locale2) {
1749          if (typeof input === "string") {
1750            return locale2.weekdaysParse(input) % 7 || 7;
1751          }
1752          return isNaN(input) ? null : input;
1753        }
1754        function shiftWeekdays(ws, n3) {
1755          return ws.slice(n3, 7).concat(ws.slice(0, n3));
1756        }
1757        var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
1758        function localeWeekdays(m5, format2) {
1759          var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m5 && m5 !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
1760          return m5 === true ? shiftWeekdays(weekdays, this._week.dow) : m5 ? weekdays[m5.day()] : weekdays;
1761        }
1762        function localeWeekdaysShort(m5) {
1763          return m5 === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m5 ? this._weekdaysShort[m5.day()] : this._weekdaysShort;
1764        }
1765        function localeWeekdaysMin(m5) {
1766          return m5 === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m5 ? this._weekdaysMin[m5.day()] : this._weekdaysMin;
1767        }
1768        function handleStrictParse$1(weekdayName, format2, strict) {
1769          var i4, ii2, mom, llc = weekdayName.toLocaleLowerCase();
1770          if (!this._weekdaysParse) {
1771            this._weekdaysParse = [];
1772            this._shortWeekdaysParse = [];
1773            this._minWeekdaysParse = [];
1774            for (i4 = 0; i4 < 7; ++i4) {
1775              mom = createUTC([2e3, 1]).day(i4);
1776              this._minWeekdaysParse[i4] = this.weekdaysMin(
1777                mom,
1778                ""
1779              ).toLocaleLowerCase();
1780              this._shortWeekdaysParse[i4] = this.weekdaysShort(
1781                mom,
1782                ""
1783              ).toLocaleLowerCase();
1784              this._weekdaysParse[i4] = this.weekdays(mom, "").toLocaleLowerCase();
1785            }
1786          }
1787          if (strict) {
1788            if (format2 === "dddd") {
1789              ii2 = indexOf2.call(this._weekdaysParse, llc);
1790              return ii2 !== -1 ? ii2 : null;
1791            } else if (format2 === "ddd") {
1792              ii2 = indexOf2.call(this._shortWeekdaysParse, llc);
1793              return ii2 !== -1 ? ii2 : null;
1794            } else {
1795              ii2 = indexOf2.call(this._minWeekdaysParse, llc);
1796              return ii2 !== -1 ? ii2 : null;
1797            }
1798          } else {
1799            if (format2 === "dddd") {
1800              ii2 = indexOf2.call(this._weekdaysParse, llc);
1801              if (ii2 !== -1) {
1802                return ii2;
1803              }
1804              ii2 = indexOf2.call(this._shortWeekdaysParse, llc);
1805              if (ii2 !== -1) {
1806                return ii2;
1807              }
1808              ii2 = indexOf2.call(this._minWeekdaysParse, llc);
1809              return ii2 !== -1 ? ii2 : null;
1810            } else if (format2 === "ddd") {
1811              ii2 = indexOf2.call(this._shortWeekdaysParse, llc);
1812              if (ii2 !== -1) {
1813                return ii2;
1814              }
1815              ii2 = indexOf2.call(this._weekdaysParse, llc);
1816              if (ii2 !== -1) {
1817                return ii2;
1818              }
1819              ii2 = indexOf2.call(this._minWeekdaysParse, llc);
1820              return ii2 !== -1 ? ii2 : null;
1821            } else {
1822              ii2 = indexOf2.call(this._minWeekdaysParse, llc);
1823              if (ii2 !== -1) {
1824                return ii2;
1825              }
1826              ii2 = indexOf2.call(this._weekdaysParse, llc);
1827              if (ii2 !== -1) {
1828                return ii2;
1829              }
1830              ii2 = indexOf2.call(this._shortWeekdaysParse, llc);
1831              return ii2 !== -1 ? ii2 : null;
1832            }
1833          }
1834        }
1835        function localeWeekdaysParse(weekdayName, format2, strict) {
1836          var i4, mom, regex;
1837          if (this._weekdaysParseExact) {
1838            return handleStrictParse$1.call(this, weekdayName, format2, strict);
1839          }
1840          if (!this._weekdaysParse) {
1841            this._weekdaysParse = [];
1842            this._minWeekdaysParse = [];
1843            this._shortWeekdaysParse = [];
1844            this._fullWeekdaysParse = [];
1845          }
1846          for (i4 = 0; i4 < 7; i4++) {
1847            mom = createUTC([2e3, 1]).day(i4);
1848            if (strict && !this._fullWeekdaysParse[i4]) {
1849              this._fullWeekdaysParse[i4] = new RegExp(
1850                "^" + this.weekdays(mom, "").replace(".", "\\.?") + "$",
1851                "i"
1852              );
1853              this._shortWeekdaysParse[i4] = new RegExp(
1854                "^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$",
1855                "i"
1856              );
1857              this._minWeekdaysParse[i4] = new RegExp(
1858                "^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$",
1859                "i"
1860              );
1861            }
1862            if (!this._weekdaysParse[i4]) {
1863              regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, "");
1864              this._weekdaysParse[i4] = new RegExp(regex.replace(".", ""), "i");
1865            }
1866            if (strict && format2 === "dddd" && this._fullWeekdaysParse[i4].test(weekdayName)) {
1867              return i4;
1868            } else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i4].test(weekdayName)) {
1869              return i4;
1870            } else if (strict && format2 === "dd" && this._minWeekdaysParse[i4].test(weekdayName)) {
1871              return i4;
1872            } else if (!strict && this._weekdaysParse[i4].test(weekdayName)) {
1873              return i4;
1874            }
1875          }
1876        }
1877        function getSetDayOfWeek(input) {
1878          if (!this.isValid()) {
1879            return input != null ? this : NaN;
1880          }
1881          var day = get2(this, "Day");
1882          if (input != null) {
1883            input = parseWeekday(input, this.localeData());
1884            return this.add(input - day, "d");
1885          } else {
1886            return day;
1887          }
1888        }
1889        function getSetLocaleDayOfWeek(input) {
1890          if (!this.isValid()) {
1891            return input != null ? this : NaN;
1892          }
1893          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1894          return input == null ? weekday : this.add(input - weekday, "d");
1895        }
1896        function getSetISODayOfWeek(input) {
1897          if (!this.isValid()) {
1898            return input != null ? this : NaN;
1899          }
1900          if (input != null) {
1901            var weekday = parseIsoWeekday(input, this.localeData());
1902            return this.day(this.day() % 7 ? weekday : weekday - 7);
1903          } else {
1904            return this.day() || 7;
1905          }
1906        }
1907        function weekdaysRegex(isStrict) {
1908          if (this._weekdaysParseExact) {
1909            if (!hasOwnProp(this, "_weekdaysRegex")) {
1910              computeWeekdaysParse.call(this);
1911            }
1912            if (isStrict) {
1913              return this._weekdaysStrictRegex;
1914            } else {
1915              return this._weekdaysRegex;
1916            }
1917          } else {
1918            if (!hasOwnProp(this, "_weekdaysRegex")) {
1919              this._weekdaysRegex = defaultWeekdaysRegex;
1920            }
1921            return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
1922          }
1923        }
1924        function weekdaysShortRegex(isStrict) {
1925          if (this._weekdaysParseExact) {
1926            if (!hasOwnProp(this, "_weekdaysRegex")) {
1927              computeWeekdaysParse.call(this);
1928            }
1929            if (isStrict) {
1930              return this._weekdaysShortStrictRegex;
1931            } else {
1932              return this._weekdaysShortRegex;
1933            }
1934          } else {
1935            if (!hasOwnProp(this, "_weekdaysShortRegex")) {
1936              this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1937            }
1938            return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1939          }
1940        }
1941        function weekdaysMinRegex(isStrict) {
1942          if (this._weekdaysParseExact) {
1943            if (!hasOwnProp(this, "_weekdaysRegex")) {
1944              computeWeekdaysParse.call(this);
1945            }
1946            if (isStrict) {
1947              return this._weekdaysMinStrictRegex;
1948            } else {
1949              return this._weekdaysMinRegex;
1950            }
1951          } else {
1952            if (!hasOwnProp(this, "_weekdaysMinRegex")) {
1953              this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1954            }
1955            return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1956          }
1957        }
1958        function computeWeekdaysParse() {
1959          function cmpLenRev(a4, b4) {
1960            return b4.length - a4.length;
1961          }
1962          var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i4, mom, minp, shortp, longp;
1963          for (i4 = 0; i4 < 7; i4++) {
1964            mom = createUTC([2e3, 1]).day(i4);
1965            minp = regexEscape(this.weekdaysMin(mom, ""));
1966            shortp = regexEscape(this.weekdaysShort(mom, ""));
1967            longp = regexEscape(this.weekdays(mom, ""));
1968            minPieces.push(minp);
1969            shortPieces.push(shortp);
1970            longPieces.push(longp);
1971            mixedPieces.push(minp);
1972            mixedPieces.push(shortp);
1973            mixedPieces.push(longp);
1974          }
1975          minPieces.sort(cmpLenRev);
1976          shortPieces.sort(cmpLenRev);
1977          longPieces.sort(cmpLenRev);
1978          mixedPieces.sort(cmpLenRev);
1979          this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
1980          this._weekdaysShortRegex = this._weekdaysRegex;
1981          this._weekdaysMinRegex = this._weekdaysRegex;
1982          this._weekdaysStrictRegex = new RegExp(
1983            "^(" + longPieces.join("|") + ")",
1984            "i"
1985          );
1986          this._weekdaysShortStrictRegex = new RegExp(
1987            "^(" + shortPieces.join("|") + ")",
1988            "i"
1989          );
1990          this._weekdaysMinStrictRegex = new RegExp(
1991            "^(" + minPieces.join("|") + ")",
1992            "i"
1993          );
1994        }
1995        function hFormat() {
1996          return this.hours() % 12 || 12;
1997        }
1998        function kFormat() {
1999          return this.hours() || 24;
2000        }
2001        addFormatToken("H", ["HH", 2], 0, "hour");
2002        addFormatToken("h", ["hh", 2], 0, hFormat);
2003        addFormatToken("k", ["kk", 2], 0, kFormat);
2004        addFormatToken("hmm", 0, 0, function() {
2005          return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2);
2006        });
2007        addFormatToken("hmmss", 0, 0, function() {
2008          return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
2009        });
2010        addFormatToken("Hmm", 0, 0, function() {
2011          return "" + this.hours() + zeroFill(this.minutes(), 2);
2012        });
2013        addFormatToken("Hmmss", 0, 0, function() {
2014          return "" + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
2015        });
2016        function meridiem(token2, lowercase) {
2017          addFormatToken(token2, 0, 0, function() {
2018            return this.localeData().meridiem(
2019              this.hours(),
2020              this.minutes(),
2021              lowercase
2022            );
2023          });
2024        }
2025        meridiem("a", true);
2026        meridiem("A", false);
2027        function matchMeridiem(isStrict, locale2) {
2028          return locale2._meridiemParse;
2029        }
2030        addRegexToken("a", matchMeridiem);
2031        addRegexToken("A", matchMeridiem);
2032        addRegexToken("H", match1to2, match1to2HasZero);
2033        addRegexToken("h", match1to2, match1to2NoLeadingZero);
2034        addRegexToken("k", match1to2, match1to2NoLeadingZero);
2035        addRegexToken("HH", match1to2, match2);
2036        addRegexToken("hh", match1to2, match2);
2037        addRegexToken("kk", match1to2, match2);
2038        addRegexToken("hmm", match3to4);
2039        addRegexToken("hmmss", match5to6);
2040        addRegexToken("Hmm", match3to4);
2041        addRegexToken("Hmmss", match5to6);
2042        addParseToken(["H", "HH"], HOUR);
2043        addParseToken(["k", "kk"], function(input, array, config2) {
2044          var kInput = toInt(input);
2045          array[HOUR] = kInput === 24 ? 0 : kInput;
2046        });
2047        addParseToken(["a", "A"], function(input, array, config2) {
2048          config2._isPm = config2._locale.isPM(input);
2049          config2._meridiem = input;
2050        });
2051        addParseToken(["h", "hh"], function(input, array, config2) {
2052          array[HOUR] = toInt(input);
2053          getParsingFlags(config2).bigHour = true;
2054        });
2055        addParseToken("hmm", function(input, array, config2) {
2056          var pos = input.length - 2;
2057          array[HOUR] = toInt(input.substr(0, pos));
2058          array[MINUTE] = toInt(input.substr(pos));
2059          getParsingFlags(config2).bigHour = true;
2060        });
2061        addParseToken("hmmss", function(input, array, config2) {
2062          var pos1 = input.length - 4, pos2 = input.length - 2;
2063          array[HOUR] = toInt(input.substr(0, pos1));
2064          array[MINUTE] = toInt(input.substr(pos1, 2));
2065          array[SECOND] = toInt(input.substr(pos2));
2066          getParsingFlags(config2).bigHour = true;
2067        });
2068        addParseToken("Hmm", function(input, array, config2) {
2069          var pos = input.length - 2;
2070          array[HOUR] = toInt(input.substr(0, pos));
2071          array[MINUTE] = toInt(input.substr(pos));
2072        });
2073        addParseToken("Hmmss", function(input, array, config2) {
2074          var pos1 = input.length - 4, pos2 = input.length - 2;
2075          array[HOUR] = toInt(input.substr(0, pos1));
2076          array[MINUTE] = toInt(input.substr(pos1, 2));
2077          array[SECOND] = toInt(input.substr(pos2));
2078        });
2079        function localeIsPM(input) {
2080          return (input + "").toLowerCase().charAt(0) === "p";
2081        }
2082        var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true);
2083        function localeMeridiem(hours2, minutes2, isLower) {
2084          if (hours2 > 11) {
2085            return isLower ? "pm" : "PM";
2086          } else {
2087            return isLower ? "am" : "AM";
2088          }
2089        }
2090        var baseConfig = {
2091          calendar: defaultCalendar,
2092          longDateFormat: defaultLongDateFormat,
2093          invalidDate: defaultInvalidDate,
2094          ordinal: defaultOrdinal,
2095          dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
2096          relativeTime: defaultRelativeTime,
2097          months: defaultLocaleMonths,
2098          monthsShort: defaultLocaleMonthsShort,
2099          week: defaultLocaleWeek,
2100          weekdays: defaultLocaleWeekdays,
2101          weekdaysMin: defaultLocaleWeekdaysMin,
2102          weekdaysShort: defaultLocaleWeekdaysShort,
2103          meridiemParse: defaultLocaleMeridiemParse
2104        };
2105        var locales = {}, localeFamilies = {}, globalLocale;
2106        function commonPrefix(arr1, arr2) {
2107          var i4, minl = Math.min(arr1.length, arr2.length);
2108          for (i4 = 0; i4 < minl; i4 += 1) {
2109            if (arr1[i4] !== arr2[i4]) {
2110              return i4;
2111            }
2112          }
2113          return minl;
2114        }
2115        function normalizeLocale(key) {
2116          return key ? key.toLowerCase().replace("_", "-") : key;
2117        }
2118        function chooseLocale(names) {
2119          var i4 = 0, j5, next, locale2, split;
2120          while (i4 < names.length) {
2121            split = normalizeLocale(names[i4]).split("-");
2122            j5 = split.length;
2123            next = normalizeLocale(names[i4 + 1]);
2124            next = next ? next.split("-") : null;
2125            while (j5 > 0) {
2126              locale2 = loadLocale(split.slice(0, j5).join("-"));
2127              if (locale2) {
2128                return locale2;
2129              }
2130              if (next && next.length >= j5 && commonPrefix(split, next) >= j5 - 1) {
2131                break;
2132              }
2133              j5--;
2134            }
2135            i4++;
2136          }
2137          return globalLocale;
2138        }
2139        function isLocaleNameSane(name) {
2140          return !!(name && name.match("^[^/\\\\]*$"));
2141        }
2142        function loadLocale(name) {
2143          var oldLocale = null, aliasedRequire;
2144          if (locales[name] === void 0 && typeof module !== "undefined" && module && module.exports && isLocaleNameSane(name)) {
2145            try {
2146              oldLocale = globalLocale._abbr;
2147              aliasedRequire = __require;
2148              aliasedRequire("./locale/" + name);
2149              getSetGlobalLocale(oldLocale);
2150            } catch (e4) {
2151              locales[name] = null;
2152            }
2153          }
2154          return locales[name];
2155        }
2156        function getSetGlobalLocale(key, values) {
2157          var data;
2158          if (key) {
2159            if (isUndefined(values)) {
2160              data = getLocale(key);
2161            } else {
2162              data = defineLocale(key, values);
2163            }
2164            if (data) {
2165              globalLocale = data;
2166            } else {
2167              if (typeof console !== "undefined" && console.warn) {
2168                console.warn(
2169                  "Locale " + key + " not found. Did you forget to load it?"
2170                );
2171              }
2172            }
2173          }
2174          return globalLocale._abbr;
2175        }
2176        function defineLocale(name, config2) {
2177          if (config2 !== null) {
2178            var locale2, parentConfig = baseConfig;
2179            config2.abbr = name;
2180            if (locales[name] != null) {
2181              deprecateSimple(
2182                "defineLocaleOverride",
2183                "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."
2184              );
2185              parentConfig = locales[name]._config;
2186            } else if (config2.parentLocale != null) {
2187              if (locales[config2.parentLocale] != null) {
2188                parentConfig = locales[config2.parentLocale]._config;
2189              } else {
2190                locale2 = loadLocale(config2.parentLocale);
2191                if (locale2 != null) {
2192                  parentConfig = locale2._config;
2193                } else {
2194                  if (!localeFamilies[config2.parentLocale]) {
2195                    localeFamilies[config2.parentLocale] = [];
2196                  }
2197                  localeFamilies[config2.parentLocale].push({
2198                    name,
2199                    config: config2
2200                  });
2201                  return null;
2202                }
2203              }
2204            }
2205            locales[name] = new Locale(mergeConfigs(parentConfig, config2));
2206            if (localeFamilies[name]) {
2207              localeFamilies[name].forEach(function(x5) {
2208                defineLocale(x5.name, x5.config);
2209              });
2210            }
2211            getSetGlobalLocale(name);
2212            return locales[name];
2213          } else {
2214            delete locales[name];
2215            return null;
2216          }
2217        }
2218        function updateLocale(name, config2) {
2219          if (config2 != null) {
2220            var locale2, tmpLocale, parentConfig = baseConfig;
2221            if (locales[name] != null && locales[name].parentLocale != null) {
2222              locales[name].set(mergeConfigs(locales[name]._config, config2));
2223            } else {
2224              tmpLocale = loadLocale(name);
2225              if (tmpLocale != null) {
2226                parentConfig = tmpLocale._config;
2227              }
2228              config2 = mergeConfigs(parentConfig, config2);
2229              if (tmpLocale == null) {
2230                config2.abbr = name;
2231              }
2232              locale2 = new Locale(config2);
2233              locale2.parentLocale = locales[name];
2234              locales[name] = locale2;
2235            }
2236            getSetGlobalLocale(name);
2237          } else {
2238            if (locales[name] != null) {
2239              if (locales[name].parentLocale != null) {
2240                locales[name] = locales[name].parentLocale;
2241                if (name === getSetGlobalLocale()) {
2242                  getSetGlobalLocale(name);
2243                }
2244              } else if (locales[name] != null) {
2245                delete locales[name];
2246              }
2247            }
2248          }
2249          return locales[name];
2250        }
2251        function getLocale(key) {
2252          var locale2;
2253          if (key && key._locale && key._locale._abbr) {
2254            key = key._locale._abbr;
2255          }
2256          if (!key) {
2257            return globalLocale;
2258          }
2259          if (!isArray(key)) {
2260            locale2 = loadLocale(key);
2261            if (locale2) {
2262              return locale2;
2263            }
2264            key = [key];
2265          }
2266          return chooseLocale(key);
2267        }
2268        function listLocales() {
2269          return keys(locales);
2270        }
2271        function checkOverflow2(m5) {
2272          var overflow, a4 = m5._a;
2273          if (a4 && getParsingFlags(m5).overflow === -2) {
2274            overflow = a4[MONTH] < 0 || a4[MONTH] > 11 ? MONTH : a4[DATE] < 1 || a4[DATE] > daysInMonth(a4[YEAR], a4[MONTH]) ? DATE : a4[HOUR] < 0 || a4[HOUR] > 24 || a4[HOUR] === 24 && (a4[MINUTE] !== 0 || a4[SECOND] !== 0 || a4[MILLISECOND] !== 0) ? HOUR : a4[MINUTE] < 0 || a4[MINUTE] > 59 ? MINUTE : a4[SECOND] < 0 || a4[SECOND] > 59 ? SECOND : a4[MILLISECOND] < 0 || a4[MILLISECOND] > 999 ? MILLISECOND : -1;
2275            if (getParsingFlags(m5)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2276              overflow = DATE;
2277            }
2278            if (getParsingFlags(m5)._overflowWeeks && overflow === -1) {
2279              overflow = WEEK;
2280            }
2281            if (getParsingFlags(m5)._overflowWeekday && overflow === -1) {
2282              overflow = WEEKDAY;
2283            }
2284            getParsingFlags(m5).overflow = overflow;
2285          }
2286          return m5;
2287        }
2288        var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [
2289          ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
2290          ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
2291          ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
2292          ["GGGG-[W]WW", /\d{4}-W\d\d/, false],
2293          ["YYYY-DDD", /\d{4}-\d{3}/],
2294          ["YYYY-MM", /\d{4}-\d\d/, false],
2295          ["YYYYYYMMDD", /[+-]\d{10}/],
2296          ["YYYYMMDD", /\d{8}/],
2297          ["GGGG[W]WWE", /\d{4}W\d{3}/],
2298          ["GGGG[W]WW", /\d{4}W\d{2}/, false],
2299          ["YYYYDDD", /\d{7}/],
2300          ["YYYYMM", /\d{6}/, false],
2301          ["YYYY", /\d{4}/, false]
2302        ], isoTimes = [
2303          ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
2304          ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
2305          ["HH:mm:ss", /\d\d:\d\d:\d\d/],
2306          ["HH:mm", /\d\d:\d\d/],
2307          ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
2308          ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
2309          ["HHmmss", /\d\d\d\d\d\d/],
2310          ["HHmm", /\d\d\d\d/],
2311          ["HH", /\d\d/]
2312        ], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, obsOffsets = {
2313          UT: 0,
2314          GMT: 0,
2315          EDT: -4 * 60,
2316          EST: -5 * 60,
2317          CDT: -5 * 60,
2318          CST: -6 * 60,
2319          MDT: -6 * 60,
2320          MST: -7 * 60,
2321          PDT: -7 * 60,
2322          PST: -8 * 60
2323        };
2324        function configFromISO(config2) {
2325          var i4, l4, string = config2._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
2326          if (match) {
2327            getParsingFlags(config2).iso = true;
2328            for (i4 = 0, l4 = isoDatesLen; i4 < l4; i4++) {
2329              if (isoDates[i4][1].exec(match[1])) {
2330                dateFormat = isoDates[i4][0];
2331                allowTime = isoDates[i4][2] !== false;
2332                break;
2333              }
2334            }
2335            if (dateFormat == null) {
2336              config2._isValid = false;
2337              return;
2338            }
2339            if (match[3]) {
2340              for (i4 = 0, l4 = isoTimesLen; i4 < l4; i4++) {
2341                if (isoTimes[i4][1].exec(match[3])) {
2342                  timeFormat = (match[2] || " ") + isoTimes[i4][0];
2343                  break;
2344                }
2345              }
2346              if (timeFormat == null) {
2347                config2._isValid = false;
2348                return;
2349              }
2350            }
2351            if (!allowTime && timeFormat != null) {
2352              config2._isValid = false;
2353              return;
2354            }
2355            if (match[4]) {
2356              if (tzRegex.exec(match[4])) {
2357                tzFormat = "Z";
2358              } else {
2359                config2._isValid = false;
2360                return;
2361              }
2362            }
2363            config2._f = dateFormat + (timeFormat || "") + (tzFormat || "");
2364            configFromStringAndFormat(config2);
2365          } else {
2366            config2._isValid = false;
2367          }
2368        }
2369        function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
2370          var result = [
2371            untruncateYear(yearStr),
2372            defaultLocaleMonthsShort.indexOf(monthStr),
2373            parseInt(dayStr, 10),
2374            parseInt(hourStr, 10),
2375            parseInt(minuteStr, 10)
2376          ];
2377          if (secondStr) {
2378            result.push(parseInt(secondStr, 10));
2379          }
2380          return result;
2381        }
2382        function untruncateYear(yearStr) {
2383          var year = parseInt(yearStr, 10);
2384          if (year <= 49) {
2385            return 2e3 + year;
2386          } else if (year <= 999) {
2387            return 1900 + year;
2388          }
2389          return year;
2390        }
2391        function preprocessRFC2822(s4) {
2392          return s4.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
2393        }
2394        function checkWeekday(weekdayStr, parsedInput, config2) {
2395          if (weekdayStr) {
2396            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(
2397              parsedInput[0],
2398              parsedInput[1],
2399              parsedInput[2]
2400            ).getDay();
2401            if (weekdayProvided !== weekdayActual) {
2402              getParsingFlags(config2).weekdayMismatch = true;
2403              config2._isValid = false;
2404              return false;
2405            }
2406          }
2407          return true;
2408        }
2409        function calculateOffset(obsOffset, militaryOffset, numOffset) {
2410          if (obsOffset) {
2411            return obsOffsets[obsOffset];
2412          } else if (militaryOffset) {
2413            return 0;
2414          } else {
2415            var hm = parseInt(numOffset, 10), m5 = hm % 100, h4 = (hm - m5) / 100;
2416            return h4 * 60 + m5;
2417          }
2418        }
2419        function configFromRFC2822(config2) {
2420          var match = rfc2822.exec(preprocessRFC2822(config2._i)), parsedArray;
2421          if (match) {
2422            parsedArray = extractFromRFC2822Strings(
2423              match[4],
2424              match[3],
2425              match[2],
2426              match[5],
2427              match[6],
2428              match[7]
2429            );
2430            if (!checkWeekday(match[1], parsedArray, config2)) {
2431              return;
2432            }
2433            config2._a = parsedArray;
2434            config2._tzm = calculateOffset(match[8], match[9], match[10]);
2435            config2._d = createUTCDate.apply(null, config2._a);
2436            config2._d.setUTCMinutes(config2._d.getUTCMinutes() - config2._tzm);
2437            getParsingFlags(config2).rfc2822 = true;
2438          } else {
2439            config2._isValid = false;
2440          }
2441        }
2442        function configFromString(config2) {
2443          var matched = aspNetJsonRegex.exec(config2._i);
2444          if (matched !== null) {
2445            config2._d = new Date(+matched[1]);
2446            return;
2447          }
2448          configFromISO(config2);
2449          if (config2._isValid === false) {
2450            delete config2._isValid;
2451          } else {
2452            return;
2453          }
2454          configFromRFC2822(config2);
2455          if (config2._isValid === false) {
2456            delete config2._isValid;
2457          } else {
2458            return;
2459          }
2460          if (config2._strict) {
2461            config2._isValid = false;
2462          } else {
2463            hooks.createFromInputFallback(config2);
2464          }
2465        }
2466        hooks.createFromInputFallback = deprecate(
2467          "value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",
2468          function(config2) {
2469            config2._d = new Date(config2._i + (config2._useUTC ? " UTC" : ""));
2470          }
2471        );
2472        function defaults2(a4, b4, c4) {
2473          if (a4 != null) {
2474            return a4;
2475          }
2476          if (b4 != null) {
2477            return b4;
2478          }
2479          return c4;
2480        }
2481        function currentDateArray(config2) {
2482          var nowValue = new Date(hooks.now());
2483          if (config2._useUTC) {
2484            return [
2485              nowValue.getUTCFullYear(),
2486              nowValue.getUTCMonth(),
2487              nowValue.getUTCDate()
2488            ];
2489          }
2490          return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2491        }
2492        function configFromArray(config2) {
2493          var i4, date, input = [], currentDate, expectedWeekday, yearToUse;
2494          if (config2._d) {
2495            return;
2496          }
2497          currentDate = currentDateArray(config2);
2498          if (config2._w && config2._a[DATE] == null && config2._a[MONTH] == null) {
2499            dayOfYearFromWeekInfo(config2);
2500          }
2501          if (config2._dayOfYear != null) {
2502            yearToUse = defaults2(config2._a[YEAR], currentDate[YEAR]);
2503            if (config2._dayOfYear > daysInYear(yearToUse) || config2._dayOfYear === 0) {
2504              getParsingFlags(config2)._overflowDayOfYear = true;
2505            }
2506            date = createUTCDate(yearToUse, 0, config2._dayOfYear);
2507            config2._a[MONTH] = date.getUTCMonth();
2508            config2._a[DATE] = date.getUTCDate();
2509          }
2510          for (i4 = 0; i4 < 3 && config2._a[i4] == null; ++i4) {
2511            config2._a[i4] = input[i4] = currentDate[i4];
2512          }
2513          for (; i4 < 7; i4++) {
2514            config2._a[i4] = input[i4] = config2._a[i4] == null ? i4 === 2 ? 1 : 0 : config2._a[i4];
2515          }
2516          if (config2._a[HOUR] === 24 && config2._a[MINUTE] === 0 && config2._a[SECOND] === 0 && config2._a[MILLISECOND] === 0) {
2517            config2._nextDay = true;
2518            config2._a[HOUR] = 0;
2519          }
2520          config2._d = (config2._useUTC ? createUTCDate : createDate).apply(
2521            null,
2522            input
2523          );
2524          expectedWeekday = config2._useUTC ? config2._d.getUTCDay() : config2._d.getDay();
2525          if (config2._tzm != null) {
2526            config2._d.setUTCMinutes(config2._d.getUTCMinutes() - config2._tzm);
2527          }
2528          if (config2._nextDay) {
2529            config2._a[HOUR] = 24;
2530          }
2531          if (config2._w && typeof config2._w.d !== "undefined" && config2._w.d !== expectedWeekday) {
2532            getParsingFlags(config2).weekdayMismatch = true;
2533          }
2534        }
2535        function dayOfYearFromWeekInfo(config2) {
2536          var w5, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
2537          w5 = config2._w;
2538          if (w5.GG != null || w5.W != null || w5.E != null) {
2539            dow = 1;
2540            doy = 4;
2541            weekYear = defaults2(
2542              w5.GG,
2543              config2._a[YEAR],
2544              weekOfYear2(createLocal(), 1, 4).year
2545            );
2546            week = defaults2(w5.W, 1);
2547            weekday = defaults2(w5.E, 1);
2548            if (weekday < 1 || weekday > 7) {
2549              weekdayOverflow = true;
2550            }
2551          } else {
2552            dow = config2._locale._week.dow;
2553            doy = config2._locale._week.doy;
2554            curWeek = weekOfYear2(createLocal(), dow, doy);
2555            weekYear = defaults2(w5.gg, config2._a[YEAR], curWeek.year);
2556            week = defaults2(w5.w, curWeek.week);
2557            if (w5.d != null) {
2558              weekday = w5.d;
2559              if (weekday < 0 || weekday > 6) {
2560                weekdayOverflow = true;
2561              }
2562            } else if (w5.e != null) {
2563              weekday = w5.e + dow;
2564              if (w5.e < 0 || w5.e > 6) {
2565                weekdayOverflow = true;
2566              }
2567            } else {
2568              weekday = dow;
2569            }
2570          }
2571          if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2572            getParsingFlags(config2)._overflowWeeks = true;
2573          } else if (weekdayOverflow != null) {
2574            getParsingFlags(config2)._overflowWeekday = true;
2575          } else {
2576            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2577            config2._a[YEAR] = temp.year;
2578            config2._dayOfYear = temp.dayOfYear;
2579          }
2580        }
2581        hooks.ISO_8601 = function() {
2582        };
2583        hooks.RFC_2822 = function() {
2584        };
2585        function configFromStringAndFormat(config2) {
2586          if (config2._f === hooks.ISO_8601) {
2587            configFromISO(config2);
2588            return;
2589          }
2590          if (config2._f === hooks.RFC_2822) {
2591            configFromRFC2822(config2);
2592            return;
2593          }
2594          config2._a = [];
2595          getParsingFlags(config2).empty = true;
2596          var string = "" + config2._i, i4, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
2597          tokens2 = expandFormat(config2._f, config2._locale).match(formattingTokens) || [];
2598          tokenLen = tokens2.length;
2599          for (i4 = 0; i4 < tokenLen; i4++) {
2600            token2 = tokens2[i4];
2601            parsedInput = (string.match(getParseRegexForToken(token2, config2)) || [])[0];
2602            if (parsedInput) {
2603              skipped = string.substr(0, string.indexOf(parsedInput));
2604              if (skipped.length > 0) {
2605                getParsingFlags(config2).unusedInput.push(skipped);
2606              }
2607              string = string.slice(
2608                string.indexOf(parsedInput) + parsedInput.length
2609              );
2610              totalParsedInputLength += parsedInput.length;
2611            }
2612            if (formatTokenFunctions[token2]) {
2613              if (parsedInput) {
2614                getParsingFlags(config2).empty = false;
2615              } else {
2616                getParsingFlags(config2).unusedTokens.push(token2);
2617              }
2618              addTimeToArrayFromToken(token2, parsedInput, config2);
2619            } else if (config2._strict && !parsedInput) {
2620              getParsingFlags(config2).unusedTokens.push(token2);
2621            }
2622          }
2623          getParsingFlags(config2).charsLeftOver = stringLength - totalParsedInputLength;
2624          if (string.length > 0) {
2625            getParsingFlags(config2).unusedInput.push(string);
2626          }
2627          if (config2._a[HOUR] <= 12 && getParsingFlags(config2).bigHour === true && config2._a[HOUR] > 0) {
2628            getParsingFlags(config2).bigHour = void 0;
2629          }
2630          getParsingFlags(config2).parsedDateParts = config2._a.slice(0);
2631          getParsingFlags(config2).meridiem = config2._meridiem;
2632          config2._a[HOUR] = meridiemFixWrap(
2633            config2._locale,
2634            config2._a[HOUR],
2635            config2._meridiem
2636          );
2637          era = getParsingFlags(config2).era;
2638          if (era !== null) {
2639            config2._a[YEAR] = config2._locale.erasConvertYear(era, config2._a[YEAR]);
2640          }
2641          configFromArray(config2);
2642          checkOverflow2(config2);
2643        }
2644        function meridiemFixWrap(locale2, hour, meridiem2) {
2645          var isPm;
2646          if (meridiem2 == null) {
2647            return hour;
2648          }
2649          if (locale2.meridiemHour != null) {
2650            return locale2.meridiemHour(hour, meridiem2);
2651          } else if (locale2.isPM != null) {
2652            isPm = locale2.isPM(meridiem2);
2653            if (isPm && hour < 12) {
2654              hour += 12;
2655            }
2656            if (!isPm && hour === 12) {
2657              hour = 0;
2658            }
2659            return hour;
2660          } else {
2661            return hour;
2662          }
2663        }
2664        function configFromStringAndArray(config2) {
2665          var tempConfig, bestMoment, scoreToBeat, i4, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config2._f.length;
2666          if (configfLen === 0) {
2667            getParsingFlags(config2).invalidFormat = true;
2668            config2._d = new Date(NaN);
2669            return;
2670          }
2671          for (i4 = 0; i4 < configfLen; i4++) {
2672            currentScore = 0;
2673            validFormatFound = false;
2674            tempConfig = copyConfig({}, config2);
2675            if (config2._useUTC != null) {
2676              tempConfig._useUTC = config2._useUTC;
2677            }
2678            tempConfig._f = config2._f[i4];
2679            configFromStringAndFormat(tempConfig);
2680            if (isValid(tempConfig)) {
2681              validFormatFound = true;
2682            }
2683            currentScore += getParsingFlags(tempConfig).charsLeftOver;
2684            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2685            getParsingFlags(tempConfig).score = currentScore;
2686            if (!bestFormatIsValid) {
2687              if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {
2688                scoreToBeat = currentScore;
2689                bestMoment = tempConfig;
2690                if (validFormatFound) {
2691                  bestFormatIsValid = true;
2692                }
2693              }
2694            } else {
2695              if (currentScore < scoreToBeat) {
2696                scoreToBeat = currentScore;
2697                bestMoment = tempConfig;
2698              }
2699            }
2700          }
2701          extend5(config2, bestMoment || tempConfig);
2702        }
2703        function configFromObject(config2) {
2704          if (config2._d) {
2705            return;
2706          }
2707          var i4 = normalizeObjectUnits(config2._i), dayOrDate = i4.day === void 0 ? i4.date : i4.day;
2708          config2._a = map(
2709            [i4.year, i4.month, dayOrDate, i4.hour, i4.minute, i4.second, i4.millisecond],
2710            function(obj) {
2711              return obj && parseInt(obj, 10);
2712            }
2713          );
2714          configFromArray(config2);
2715        }
2716        function createFromConfig(config2) {
2717          var res = new Moment3(checkOverflow2(prepareConfig(config2)));
2718          if (res._nextDay) {
2719            res.add(1, "d");
2720            res._nextDay = void 0;
2721          }
2722          return res;
2723        }
2724        function prepareConfig(config2) {
2725          var input = config2._i, format2 = config2._f;
2726          config2._locale = config2._locale || getLocale(config2._l);
2727          if (input === null || format2 === void 0 && input === "") {
2728            return createInvalid({ nullInput: true });
2729          }
2730          if (typeof input === "string") {
2731            config2._i = input = config2._locale.preparse(input);
2732          }
2733          if (isMoment(input)) {
2734            return new Moment3(checkOverflow2(input));
2735          } else if (isDate(input)) {
2736            config2._d = input;
2737          } else if (isArray(format2)) {
2738            configFromStringAndArray(config2);
2739          } else if (format2) {
2740            configFromStringAndFormat(config2);
2741          } else {
2742            configFromInput(config2);
2743          }
2744          if (!isValid(config2)) {
2745            config2._d = null;
2746          }
2747          return config2;
2748        }
2749        function configFromInput(config2) {
2750          var input = config2._i;
2751          if (isUndefined(input)) {
2752            config2._d = new Date(hooks.now());
2753          } else if (isDate(input)) {
2754            config2._d = new Date(input.valueOf());
2755          } else if (typeof input === "string") {
2756            configFromString(config2);
2757          } else if (isArray(input)) {
2758            config2._a = map(input.slice(0), function(obj) {
2759              return parseInt(obj, 10);
2760            });
2761            configFromArray(config2);
2762          } else if (isObject3(input)) {
2763            configFromObject(config2);
2764          } else if (isNumber(input)) {
2765            config2._d = new Date(input);
2766          } else {
2767            hooks.createFromInputFallback(config2);
2768          }
2769        }
2770        function createLocalOrUTC(input, format2, locale2, strict, isUTC) {
2771          var c4 = {};
2772          if (format2 === true || format2 === false) {
2773            strict = format2;
2774            format2 = void 0;
2775          }
2776          if (locale2 === true || locale2 === false) {
2777            strict = locale2;
2778            locale2 = void 0;
2779          }
2780          if (isObject3(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {
2781            input = void 0;
2782          }
2783          c4._isAMomentObject = true;
2784          c4._useUTC = c4._isUTC = isUTC;
2785          c4._l = locale2;
2786          c4._i = input;
2787          c4._f = format2;
2788          c4._strict = strict;
2789          return createFromConfig(c4);
2790        }
2791        function createLocal(input, format2, locale2, strict) {
2792          return createLocalOrUTC(input, format2, locale2, strict, false);
2793        }
2794        var prototypeMin = deprecate(
2795          "moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
2796          function() {
2797            var other = createLocal.apply(null, arguments);
2798            if (this.isValid() && other.isValid()) {
2799              return other < this ? this : other;
2800            } else {
2801              return createInvalid();
2802            }
2803          }
2804        ), prototypeMax = deprecate(
2805          "moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
2806          function() {
2807            var other = createLocal.apply(null, arguments);
2808            if (this.isValid() && other.isValid()) {
2809              return other > this ? this : other;
2810            } else {
2811              return createInvalid();
2812            }
2813          }
2814        );
2815        function pickBy(fn3, moments) {
2816          var res, i4;
2817          if (moments.length === 1 && isArray(moments[0])) {
2818            moments = moments[0];
2819          }
2820          if (!moments.length) {
2821            return createLocal();
2822          }
2823          res = moments[0];
2824          for (i4 = 1; i4 < moments.length; ++i4) {
2825            if (!moments[i4].isValid() || moments[i4][fn3](res)) {
2826              res = moments[i4];
2827            }
2828          }
2829          return res;
2830        }
2831        function min2() {
2832          var args = [].slice.call(arguments, 0);
2833          return pickBy("isBefore", args);
2834        }
2835        function max2() {
2836          var args = [].slice.call(arguments, 0);
2837          return pickBy("isAfter", args);
2838        }
2839        var now3 = function() {
2840          return Date.now ? Date.now() : +new Date();
2841        };
2842        var ordering = [
2843          "year",
2844          "quarter",
2845          "month",
2846          "week",
2847          "day",
2848          "hour",
2849          "minute",
2850          "second",
2851          "millisecond"
2852        ];
2853        function isDurationValid(m5) {
2854          var key, unitHasDecimal = false, i4, orderLen = ordering.length;
2855          for (key in m5) {
2856            if (hasOwnProp(m5, key) && !(indexOf2.call(ordering, key) !== -1 && (m5[key] == null || !isNaN(m5[key])))) {
2857              return false;
2858            }
2859          }
2860          for (i4 = 0; i4 < orderLen; ++i4) {
2861            if (m5[ordering[i4]]) {
2862              if (unitHasDecimal) {
2863                return false;
2864              }
2865              if (parseFloat(m5[ordering[i4]]) !== toInt(m5[ordering[i4]])) {
2866                unitHasDecimal = true;
2867              }
2868            }
2869          }
2870          return true;
2871        }
2872        function isValid$1() {
2873          return this._isValid;
2874        }
2875        function createInvalid$1() {
2876          return createDuration2(NaN);
2877        }
2878        function Duration(duration) {
2879          var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0;
2880          this._isValid = isDurationValid(normalizedInput);
2881          this._milliseconds = +milliseconds2 + seconds2 * 1e3 + minutes2 * 6e4 + hours2 * 1e3 * 60 * 60;
2882          this._days = +days2 + weeks2 * 7;
2883          this._months = +months2 + quarters * 3 + years2 * 12;
2884          this._data = {};
2885          this._locale = getLocale();
2886          this._bubble();
2887        }
2888        function isDuration(obj) {
2889          return obj instanceof Duration;
2890        }
2891        function absRound(number) {
2892          if (number < 0) {
2893            return Math.round(-1 * number) * -1;
2894          } else {
2895            return Math.round(number);
2896          }
2897        }
2898        function compareArrays(array1, array2, dontConvert) {
2899          var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i4;
2900          for (i4 = 0; i4 < len; i4++) {
2901            if (dontConvert && array1[i4] !== array2[i4] || !dontConvert && toInt(array1[i4]) !== toInt(array2[i4])) {
2902              diffs++;
2903            }
2904          }
2905          return diffs + lengthDiff;
2906        }
2907        function offset2(token2, separator) {
2908          addFormatToken(token2, 0, 0, function() {
2909            var offset3 = this.utcOffset(), sign2 = "+";
2910            if (offset3 < 0) {
2911              offset3 = -offset3;
2912              sign2 = "-";
2913            }
2914            return sign2 + zeroFill(~~(offset3 / 60), 2) + separator + zeroFill(~~offset3 % 60, 2);
2915          });
2916        }
2917        offset2("Z", ":");
2918        offset2("ZZ", "");
2919        addRegexToken("Z", matchShortOffset);
2920        addRegexToken("ZZ", matchShortOffset);
2921        addParseToken(["Z", "ZZ"], function(input, array, config2) {
2922          config2._useUTC = true;
2923          config2._tzm = offsetFromString(matchShortOffset, input);
2924        });
2925        var chunkOffset = /([\+\-]|\d\d)/gi;
2926        function offsetFromString(matcher, string) {
2927          var matches2 = (string || "").match(matcher), chunk, parts, minutes2;
2928          if (matches2 === null) {
2929            return null;
2930          }
2931          chunk = matches2[matches2.length - 1] || [];
2932          parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
2933          minutes2 = +(parts[1] * 60) + toInt(parts[2]);
2934          return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
2935        }
2936        function cloneWithOffset(input, model) {
2937          var res, diff2;
2938          if (model._isUTC) {
2939            res = model.clone();
2940            diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
2941            res._d.setTime(res._d.valueOf() + diff2);
2942            hooks.updateOffset(res, false);
2943            return res;
2944          } else {
2945            return createLocal(input).local();
2946          }
2947        }
2948        function getDateOffset(m5) {
2949          return -Math.round(m5._d.getTimezoneOffset());
2950        }
2951        hooks.updateOffset = function() {
2952        };
2953        function getSetOffset(input, keepLocalTime, keepMinutes) {
2954          var offset3 = this._offset || 0, localAdjust;
2955          if (!this.isValid()) {
2956            return input != null ? this : NaN;
2957          }
2958          if (input != null) {
2959            if (typeof input === "string") {
2960              input = offsetFromString(matchShortOffset, input);
2961              if (input === null) {
2962                return this;
2963              }
2964            } else if (Math.abs(input) < 16 && !keepMinutes) {
2965              input = input * 60;
2966            }
2967            if (!this._isUTC && keepLocalTime) {
2968              localAdjust = getDateOffset(this);
2969            }
2970            this._offset = input;
2971            this._isUTC = true;
2972            if (localAdjust != null) {
2973              this.add(localAdjust, "m");
2974            }
2975            if (offset3 !== input) {
2976              if (!keepLocalTime || this._changeInProgress) {
2977                addSubtract(
2978                  this,
2979                  createDuration2(input - offset3, "m"),
2980                  1,
2981                  false
2982                );
2983              } else if (!this._changeInProgress) {
2984                this._changeInProgress = true;
2985                hooks.updateOffset(this, true);
2986                this._changeInProgress = null;
2987              }
2988            }
2989            return this;
2990          } else {
2991            return this._isUTC ? offset3 : getDateOffset(this);
2992          }
2993        }
2994        function getSetZone(input, keepLocalTime) {
2995          if (input != null) {
2996            if (typeof input !== "string") {
2997              input = -input;
2998            }
2999            this.utcOffset(input, keepLocalTime);
3000            return this;
3001          } else {
3002            return -this.utcOffset();
3003          }
3004        }
3005        function setOffsetToUTC(keepLocalTime) {
3006          return this.utcOffset(0, keepLocalTime);
3007        }
3008        function setOffsetToLocal(keepLocalTime) {
3009          if (this._isUTC) {
3010            this.utcOffset(0, keepLocalTime);
3011            this._isUTC = false;
3012            if (keepLocalTime) {
3013              this.subtract(getDateOffset(this), "m");
3014            }
3015          }
3016          return this;
3017        }
3018        function setOffsetToParsedOffset() {
3019          if (this._tzm != null) {
3020            this.utcOffset(this._tzm, false, true);
3021          } else if (typeof this._i === "string") {
3022            var tZone = offsetFromString(matchOffset, this._i);
3023            if (tZone != null) {
3024              this.utcOffset(tZone);
3025            } else {
3026              this.utcOffset(0, true);
3027            }
3028          }
3029          return this;
3030        }
3031        function hasAlignedHourOffset(input) {
3032          if (!this.isValid()) {
3033            return false;
3034          }
3035          input = input ? createLocal(input).utcOffset() : 0;
3036          return (this.utcOffset() - input) % 60 === 0;
3037        }
3038        function isDaylightSavingTime() {
3039          return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();
3040        }
3041        function isDaylightSavingTimeShifted() {
3042          if (!isUndefined(this._isDSTShifted)) {
3043            return this._isDSTShifted;
3044          }
3045          var c4 = {}, other;
3046          copyConfig(c4, this);
3047          c4 = prepareConfig(c4);
3048          if (c4._a) {
3049            other = c4._isUTC ? createUTC(c4._a) : createLocal(c4._a);
3050            this._isDSTShifted = this.isValid() && compareArrays(c4._a, other.toArray()) > 0;
3051          } else {
3052            this._isDSTShifted = false;
3053          }
3054          return this._isDSTShifted;
3055        }
3056        function isLocal() {
3057          return this.isValid() ? !this._isUTC : false;
3058        }
3059        function isUtcOffset() {
3060          return this.isValid() ? this._isUTC : false;
3061        }
3062        function isUtc() {
3063          return this.isValid() ? this._isUTC && this._offset === 0 : false;
3064        }
3065        var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3066        function createDuration2(input, key) {
3067          var duration = input, match = null, sign2, ret, diffRes;
3068          if (isDuration(input)) {
3069            duration = {
3070              ms: input._milliseconds,
3071              d: input._days,
3072              M: input._months
3073            };
3074          } else if (isNumber(input) || !isNaN(+input)) {
3075            duration = {};
3076            if (key) {
3077              duration[key] = +input;
3078            } else {
3079              duration.milliseconds = +input;
3080            }
3081          } else if (match = aspNetRegex.exec(input)) {
3082            sign2 = match[1] === "-" ? -1 : 1;
3083            duration = {
3084              y: 0,
3085              d: toInt(match[DATE]) * sign2,
3086              h: toInt(match[HOUR]) * sign2,
3087              m: toInt(match[MINUTE]) * sign2,
3088              s: toInt(match[SECOND]) * sign2,
3089              ms: toInt(absRound(match[MILLISECOND] * 1e3)) * sign2
3090            };
3091          } else if (match = isoRegex.exec(input)) {
3092            sign2 = match[1] === "-" ? -1 : 1;
3093            duration = {
3094              y: parseIso(match[2], sign2),
3095              M: parseIso(match[3], sign2),
3096              w: parseIso(match[4], sign2),
3097              d: parseIso(match[5], sign2),
3098              h: parseIso(match[6], sign2),
3099              m: parseIso(match[7], sign2),
3100              s: parseIso(match[8], sign2)
3101            };
3102          } else if (duration == null) {
3103            duration = {};
3104          } else if (typeof duration === "object" && ("from" in duration || "to" in duration)) {
3105            diffRes = momentsDifference(
3106              createLocal(duration.from),
3107              createLocal(duration.to)
3108            );
3109            duration = {};
3110            duration.ms = diffRes.milliseconds;
3111            duration.M = diffRes.months;
3112          }
3113          ret = new Duration(duration);
3114          if (isDuration(input) && hasOwnProp(input, "_locale")) {
3115            ret._locale = input._locale;
3116          }
3117          if (isDuration(input) && hasOwnProp(input, "_isValid")) {
3118            ret._isValid = input._isValid;
3119          }
3120          return ret;
3121        }
3122        createDuration2.fn = Duration.prototype;
3123        createDuration2.invalid = createInvalid$1;
3124        function parseIso(inp, sign2) {
3125          var res = inp && parseFloat(inp.replace(",", "."));
3126          return (isNaN(res) ? 0 : res) * sign2;
3127        }
3128        function positiveMomentsDifference(base, other) {
3129          var res = {};
3130          res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
3131          if (base.clone().add(res.months, "M").isAfter(other)) {
3132            --res.months;
3133          }
3134          res.milliseconds = +other - +base.clone().add(res.months, "M");
3135          return res;
3136        }
3137        function momentsDifference(base, other) {
3138          var res;
3139          if (!(base.isValid() && other.isValid())) {
3140            return { milliseconds: 0, months: 0 };
3141          }
3142          other = cloneWithOffset(other, base);
3143          if (base.isBefore(other)) {
3144            res = positiveMomentsDifference(base, other);
3145          } else {
3146            res = positiveMomentsDifference(other, base);
3147            res.milliseconds = -res.milliseconds;
3148            res.months = -res.months;
3149          }
3150          return res;
3151        }
3152        function createAdder(direction, name) {
3153          return function(val, period) {
3154            var dur, tmp;
3155            if (period !== null && !isNaN(+period)) {
3156              deprecateSimple(
3157                name,
3158                "moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
3159              );
3160              tmp = val;
3161              val = period;
3162              period = tmp;
3163            }
3164            dur = createDuration2(val, period);
3165            addSubtract(this, dur, direction);
3166            return this;
3167          };
3168        }
3169        function addSubtract(mom, duration, isAdding, updateOffset) {
3170          var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
3171          if (!mom.isValid()) {
3172            return;
3173          }
3174          updateOffset = updateOffset == null ? true : updateOffset;
3175          if (months2) {
3176            setMonth(mom, get2(mom, "Month") + months2 * isAdding);
3177          }
3178          if (days2) {
3179            set$1(mom, "Date", get2(mom, "Date") + days2 * isAdding);
3180          }
3181          if (milliseconds2) {
3182            mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
3183          }
3184          if (updateOffset) {
3185            hooks.updateOffset(mom, days2 || months2);
3186          }
3187        }
3188        var add2 = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
3189        function isString(input) {
3190          return typeof input === "string" || input instanceof String;
3191        }
3192        function isMomentInput(input) {
3193          return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0;
3194        }
3195        function isMomentInputObject(input) {
3196          var objectTest = isObject3(input) && !isObjectEmpty(input), propertyTest = false, properties = [
3197            "years",
3198            "year",
3199            "y",
3200            "months",
3201            "month",
3202            "M",
3203            "days",
3204            "day",
3205            "d",
3206            "dates",
3207            "date",
3208            "D",
3209            "hours",
3210            "hour",
3211            "h",
3212            "minutes",
3213            "minute",
3214            "m",
3215            "seconds",
3216            "second",
3217            "s",
3218            "milliseconds",
3219            "millisecond",
3220            "ms"
3221          ], i4, property, propertyLen = properties.length;
3222          for (i4 = 0; i4 < propertyLen; i4 += 1) {
3223            property = properties[i4];
3224            propertyTest = propertyTest || hasOwnProp(input, property);
3225          }
3226          return objectTest && propertyTest;
3227        }
3228        function isNumberOrStringArray(input) {
3229          var arrayTest = isArray(input), dataTypeTest = false;
3230          if (arrayTest) {
3231            dataTypeTest = input.filter(function(item) {
3232              return !isNumber(item) && isString(input);
3233            }).length === 0;
3234          }
3235          return arrayTest && dataTypeTest;
3236        }
3237        function isCalendarSpec(input) {
3238          var objectTest = isObject3(input) && !isObjectEmpty(input), propertyTest = false, properties = [
3239            "sameDay",
3240            "nextDay",
3241            "lastDay",
3242            "nextWeek",
3243            "lastWeek",
3244            "sameElse"
3245          ], i4, property;
3246          for (i4 = 0; i4 < properties.length; i4 += 1) {
3247            property = properties[i4];
3248            propertyTest = propertyTest || hasOwnProp(input, property);
3249          }
3250          return objectTest && propertyTest;
3251        }
3252        function getCalendarFormat(myMoment, now4) {
3253          var diff2 = myMoment.diff(now4, "days", true);
3254          return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
3255        }
3256        function calendar$1(time, formats) {
3257          if (arguments.length === 1) {
3258            if (!arguments[0]) {
3259              time = void 0;
3260              formats = void 0;
3261            } else if (isMomentInput(arguments[0])) {
3262              time = arguments[0];
3263              formats = void 0;
3264            } else if (isCalendarSpec(arguments[0])) {
3265              formats = arguments[0];
3266              time = void 0;
3267            }
3268          }
3269          var now4 = time || createLocal(), sod = cloneWithOffset(now4, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now4) : formats[format2]);
3270          return this.format(
3271            output || this.localeData().calendar(format2, this, createLocal(now4))
3272          );
3273        }
3274        function clone() {
3275          return new Moment3(this);
3276        }
3277        function isAfter(input, units) {
3278          var localInput = isMoment(input) ? input : createLocal(input);
3279          if (!(this.isValid() && localInput.isValid())) {
3280            return false;
3281          }
3282          units = normalizeUnits(units) || "millisecond";
3283          if (units === "millisecond") {
3284            return this.valueOf() > localInput.valueOf();
3285          } else {
3286            return localInput.valueOf() < this.clone().startOf(units).valueOf();
3287          }
3288        }
3289        function isBefore(input, units) {
3290          var localInput = isMoment(input) ? input : createLocal(input);
3291          if (!(this.isValid() && localInput.isValid())) {
3292            return false;
3293          }
3294          units = normalizeUnits(units) || "millisecond";
3295          if (units === "millisecond") {
3296            return this.valueOf() < localInput.valueOf();
3297          } else {
3298            return this.clone().endOf(units).valueOf() < localInput.valueOf();
3299          }
3300        }
3301        function isBetween(from2, to3, units, inclusivity) {
3302          var localFrom = isMoment(from2) ? from2 : createLocal(from2), localTo = isMoment(to3) ? to3 : createLocal(to3);
3303          if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
3304            return false;
3305          }
3306          inclusivity = inclusivity || "()";
3307          return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
3308        }
3309        function isSame(input, units) {
3310          var localInput = isMoment(input) ? input : createLocal(input), inputMs;
3311          if (!(this.isValid() && localInput.isValid())) {
3312            return false;
3313          }
3314          units = normalizeUnits(units) || "millisecond";
3315          if (units === "millisecond") {
3316            return this.valueOf() === localInput.valueOf();
3317          } else {
3318            inputMs = localInput.valueOf();
3319            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
3320          }
3321        }
3322        function isSameOrAfter(input, units) {
3323          return this.isSame(input, units) || this.isAfter(input, units);
3324        }
3325        function isSameOrBefore(input, units) {
3326          return this.isSame(input, units) || this.isBefore(input, units);
3327        }
3328        function diff(input, units, asFloat) {
3329          var that, zoneDelta, output;
3330          if (!this.isValid()) {
3331            return NaN;
3332          }
3333          that = cloneWithOffset(input, this);
3334          if (!that.isValid()) {
3335            return NaN;
3336          }
3337          zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3338          units = normalizeUnits(units);
3339          switch (units) {
3340            case "year":
3341              output = monthDiff(this, that) / 12;
3342              break;
3343            case "month":
3344              output = monthDiff(this, that);
3345              break;
3346            case "quarter":
3347              output = monthDiff(this, that) / 3;
3348              break;
3349            case "second":
3350              output = (this - that) / 1e3;
3351              break;
3352            case "minute":
3353              output = (this - that) / 6e4;
3354              break;
3355            case "hour":
3356              output = (this - that) / 36e5;
3357              break;
3358            case "day":
3359              output = (this - that - zoneDelta) / 864e5;
3360              break;
3361            case "week":
3362              output = (this - that - zoneDelta) / 6048e5;
3363              break;
3364            default:
3365              output = this - that;
3366          }
3367          return asFloat ? output : absFloor(output);
3368        }
3369        function monthDiff(a4, b4) {
3370          if (a4.date() < b4.date()) {
3371            return -monthDiff(b4, a4);
3372          }
3373          var wholeMonthDiff = (b4.year() - a4.year()) * 12 + (b4.month() - a4.month()), anchor = a4.clone().add(wholeMonthDiff, "months"), anchor2, adjust;
3374          if (b4 - anchor < 0) {
3375            anchor2 = a4.clone().add(wholeMonthDiff - 1, "months");
3376            adjust = (b4 - anchor) / (anchor - anchor2);
3377          } else {
3378            anchor2 = a4.clone().add(wholeMonthDiff + 1, "months");
3379            adjust = (b4 - anchor) / (anchor2 - anchor);
3380          }
3381          return -(wholeMonthDiff + adjust) || 0;
3382        }
3383        hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
3384        hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
3385        function toString() {
3386          return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
3387        }
3388        function toISOString(keepOffset) {
3389          if (!this.isValid()) {
3390            return null;
3391          }
3392          var utc = keepOffset !== true, m5 = utc ? this.clone().utc() : this;
3393          if (m5.year() < 0 || m5.year() > 9999) {
3394            return formatMoment(
3395              m5,
3396              utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
3397            );
3398          }
3399          if (isFunction(Date.prototype.toISOString)) {
3400            if (utc) {
3401              return this.toDate().toISOString();
3402            } else {
3403              return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m5, "Z"));
3404            }
3405          }
3406          return formatMoment(
3407            m5,
3408            utc ? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYY-MM-DD[T]HH:mm:ss.SSSZ"
3409          );
3410        }
3411        function inspect() {
3412          if (!this.isValid()) {
3413            return "moment.invalid(/* " + this._i + " */)";
3414          }
3415          var func = "moment", zone = "", prefix, year, datetime, suffix;
3416          if (!this.isLocal()) {
3417            func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone";
3418            zone = "Z";
3419          }
3420          prefix = "[" + func + '("]';
3421          year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY";
3422          datetime = "-MM-DD[T]HH:mm:ss.SSS";
3423          suffix = zone + '[")]';
3424          return this.format(prefix + year + datetime + suffix);
3425        }
3426        function format(inputString) {
3427          if (!inputString) {
3428            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
3429          }
3430          var output = formatMoment(this, inputString);
3431          return this.localeData().postformat(output);
3432        }
3433        function from(time, withoutSuffix) {
3434          if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
3435            return createDuration2({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix);
3436          } else {
3437            return this.localeData().invalidDate();
3438          }
3439        }
3440        function fromNow(withoutSuffix) {
3441          return this.from(createLocal(), withoutSuffix);
3442        }
3443        function to2(time, withoutSuffix) {
3444          if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
3445            return createDuration2({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix);
3446          } else {
3447            return this.localeData().invalidDate();
3448          }
3449        }
3450        function toNow(withoutSuffix) {
3451          return this.to(createLocal(), withoutSuffix);
3452        }
3453        function locale(key) {
3454          var newLocaleData;
3455          if (key === void 0) {
3456            return this._locale._abbr;
3457          } else {
3458            newLocaleData = getLocale(key);
3459            if (newLocaleData != null) {
3460              this._locale = newLocaleData;
3461            }
3462            return this;
3463          }
3464        }
3465        var lang2 = deprecate(
3466          "moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
3467          function(key) {
3468            if (key === void 0) {
3469              return this.localeData();
3470            } else {
3471              return this.locale(key);
3472            }
3473          }
3474        );
3475        function localeData() {
3476          return this._locale;
3477        }
3478        var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
3479        function mod$1(dividend, divisor) {
3480          return (dividend % divisor + divisor) % divisor;
3481        }
3482        function localStartOfDate(y4, m5, d3) {
3483          if (y4 < 100 && y4 >= 0) {
3484            return new Date(y4 + 400, m5, d3) - MS_PER_400_YEARS;
3485          } else {
3486            return new Date(y4, m5, d3).valueOf();
3487          }
3488        }
3489        function utcStartOfDate(y4, m5, d3) {
3490          if (y4 < 100 && y4 >= 0) {
3491            return Date.UTC(y4 + 400, m5, d3) - MS_PER_400_YEARS;
3492          } else {
3493            return Date.UTC(y4, m5, d3);
3494          }
3495        }
3496        function startOf(units) {
3497          var time, startOfDate;
3498          units = normalizeUnits(units);
3499          if (units === void 0 || units === "millisecond" || !this.isValid()) {
3500            return this;
3501          }
3502          startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
3503          switch (units) {
3504            case "year":
3505              time = startOfDate(this.year(), 0, 1);
3506              break;
3507            case "quarter":
3508              time = startOfDate(
3509                this.year(),
3510                this.month() - this.month() % 3,
3511                1
3512              );
3513              break;
3514            case "month":
3515              time = startOfDate(this.year(), this.month(), 1);
3516              break;
3517            case "week":
3518              time = startOfDate(
3519                this.year(),
3520                this.month(),
3521                this.date() - this.weekday()
3522              );
3523              break;
3524            case "isoWeek":
3525              time = startOfDate(
3526                this.year(),
3527                this.month(),
3528                this.date() - (this.isoWeekday() - 1)
3529              );
3530              break;
3531            case "day":
3532            case "date":
3533              time = startOfDate(this.year(), this.month(), this.date());
3534              break;
3535            case "hour":
3536              time = this._d.valueOf();
3537              time -= mod$1(
3538                time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
3539                MS_PER_HOUR
3540              );
3541              break;
3542            case "minute":
3543              time = this._d.valueOf();
3544              time -= mod$1(time, MS_PER_MINUTE);
3545              break;
3546            case "second":
3547              time = this._d.valueOf();
3548              time -= mod$1(time, MS_PER_SECOND);
3549              break;
3550          }
3551          this._d.setTime(time);
3552          hooks.updateOffset(this, true);
3553          return this;
3554        }
3555        function endOf(units) {
3556          var time, startOfDate;
3557          units = normalizeUnits(units);
3558          if (units === void 0 || units === "millisecond" || !this.isValid()) {
3559            return this;
3560          }
3561          startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
3562          switch (units) {
3563            case "year":
3564              time = startOfDate(this.year() + 1, 0, 1) - 1;
3565              break;
3566            case "quarter":
3567              time = startOfDate(
3568                this.year(),
3569                this.month() - this.month() % 3 + 3,
3570                1
3571              ) - 1;
3572              break;
3573            case "month":
3574              time = startOfDate(this.year(), this.month() + 1, 1) - 1;
3575              break;
3576            case "week":
3577              time = startOfDate(
3578                this.year(),
3579                this.month(),
3580                this.date() - this.weekday() + 7
3581              ) - 1;
3582              break;
3583            case "isoWeek":
3584              time = startOfDate(
3585                this.year(),
3586                this.month(),
3587                this.date() - (this.isoWeekday() - 1) + 7
3588              ) - 1;
3589              break;
3590            case "day":
3591            case "date":
3592              time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
3593              break;
3594            case "hour":
3595              time = this._d.valueOf();
3596              time += MS_PER_HOUR - mod$1(
3597                time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
3598                MS_PER_HOUR
3599              ) - 1;
3600              break;
3601            case "minute":
3602              time = this._d.valueOf();
3603              time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
3604              break;
3605            case "second":
3606              time = this._d.valueOf();
3607              time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
3608              break;
3609          }
3610          this._d.setTime(time);
3611          hooks.updateOffset(this, true);
3612          return this;
3613        }
3614        function valueOf() {
3615          return this._d.valueOf() - (this._offset || 0) * 6e4;
3616        }
3617        function unix() {
3618          return Math.floor(this.valueOf() / 1e3);
3619        }
3620        function toDate() {
3621          return new Date(this.valueOf());
3622        }
3623        function toArray3() {
3624          var m5 = this;
3625          return [
3626            m5.year(),
3627            m5.month(),
3628            m5.date(),
3629            m5.hour(),
3630            m5.minute(),
3631            m5.second(),
3632            m5.millisecond()
3633          ];
3634        }
3635        function toObject() {
3636          var m5 = this;
3637          return {
3638            years: m5.year(),
3639            months: m5.month(),
3640            date: m5.date(),
3641            hours: m5.hours(),
3642            minutes: m5.minutes(),
3643            seconds: m5.seconds(),
3644            milliseconds: m5.milliseconds()
3645          };
3646        }
3647        function toJSON() {
3648          return this.isValid() ? this.toISOString() : null;
3649        }
3650        function isValid$2() {
3651          return isValid(this);
3652        }
3653        function parsingFlags() {
3654          return extend5({}, getParsingFlags(this));
3655        }
3656        function invalidAt() {
3657          return getParsingFlags(this).overflow;
3658        }
3659        function creationData() {
3660          return {
3661            input: this._i,
3662            format: this._f,
3663            locale: this._locale,
3664            isUTC: this._isUTC,
3665            strict: this._strict
3666          };
3667        }
3668        addFormatToken("N", 0, 0, "eraAbbr");
3669        addFormatToken("NN", 0, 0, "eraAbbr");
3670        addFormatToken("NNN", 0, 0, "eraAbbr");
3671        addFormatToken("NNNN", 0, 0, "eraName");
3672        addFormatToken("NNNNN", 0, 0, "eraNarrow");
3673        addFormatToken("y", ["y", 1], "yo", "eraYear");
3674        addFormatToken("y", ["yy", 2], 0, "eraYear");
3675        addFormatToken("y", ["yyy", 3], 0, "eraYear");
3676        addFormatToken("y", ["yyyy", 4], 0, "eraYear");
3677        addRegexToken("N", matchEraAbbr);
3678        addRegexToken("NN", matchEraAbbr);
3679        addRegexToken("NNN", matchEraAbbr);
3680        addRegexToken("NNNN", matchEraName);
3681        addRegexToken("NNNNN", matchEraNarrow);
3682        addParseToken(
3683          ["N", "NN", "NNN", "NNNN", "NNNNN"],
3684          function(input, array, config2, token2) {
3685            var era = config2._locale.erasParse(input, token2, config2._strict);
3686            if (era) {
3687              getParsingFlags(config2).era = era;
3688            } else {
3689              getParsingFlags(config2).invalidEra = input;
3690            }
3691          }
3692        );
3693        addRegexToken("y", matchUnsigned);
3694        addRegexToken("yy", matchUnsigned);
3695        addRegexToken("yyy", matchUnsigned);
3696        addRegexToken("yyyy", matchUnsigned);
3697        addRegexToken("yo", matchEraYearOrdinal);
3698        addParseToken(["y", "yy", "yyy", "yyyy"], YEAR);
3699        addParseToken(["yo"], function(input, array, config2, token2) {
3700          var match;
3701          if (config2._locale._eraYearOrdinalRegex) {
3702            match = input.match(config2._locale._eraYearOrdinalRegex);
3703          }
3704          if (config2._locale.eraYearOrdinalParse) {
3705            array[YEAR] = config2._locale.eraYearOrdinalParse(input, match);
3706          } else {
3707            array[YEAR] = parseInt(input, 10);
3708          }
3709        });
3710        function localeEras(m5, format2) {
3711          var i4, l4, date, eras = this._eras || getLocale("en")._eras;
3712          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3713            switch (typeof eras[i4].since) {
3714              case "string":
3715                date = hooks(eras[i4].since).startOf("day");
3716                eras[i4].since = date.valueOf();
3717                break;
3718            }
3719            switch (typeof eras[i4].until) {
3720              case "undefined":
3721                eras[i4].until = Infinity;
3722                break;
3723              case "string":
3724                date = hooks(eras[i4].until).startOf("day").valueOf();
3725                eras[i4].until = date.valueOf();
3726                break;
3727            }
3728          }
3729          return eras;
3730        }
3731        function localeErasParse(eraName, format2, strict) {
3732          var i4, l4, eras = this.eras(), name, abbr, narrow;
3733          eraName = eraName.toUpperCase();
3734          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3735            name = eras[i4].name.toUpperCase();
3736            abbr = eras[i4].abbr.toUpperCase();
3737            narrow = eras[i4].narrow.toUpperCase();
3738            if (strict) {
3739              switch (format2) {
3740                case "N":
3741                case "NN":
3742                case "NNN":
3743                  if (abbr === eraName) {
3744                    return eras[i4];
3745                  }
3746                  break;
3747                case "NNNN":
3748                  if (name === eraName) {
3749                    return eras[i4];
3750                  }
3751                  break;
3752                case "NNNNN":
3753                  if (narrow === eraName) {
3754                    return eras[i4];
3755                  }
3756                  break;
3757              }
3758            } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
3759              return eras[i4];
3760            }
3761          }
3762        }
3763        function localeErasConvertYear(era, year) {
3764          var dir = era.since <= era.until ? 1 : -1;
3765          if (year === void 0) {
3766            return hooks(era.since).year();
3767          } else {
3768            return hooks(era.since).year() + (year - era.offset) * dir;
3769          }
3770        }
3771        function getEraName() {
3772          var i4, l4, val, eras = this.localeData().eras();
3773          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3774            val = this.clone().startOf("day").valueOf();
3775            if (eras[i4].since <= val && val <= eras[i4].until) {
3776              return eras[i4].name;
3777            }
3778            if (eras[i4].until <= val && val <= eras[i4].since) {
3779              return eras[i4].name;
3780            }
3781          }
3782          return "";
3783        }
3784        function getEraNarrow() {
3785          var i4, l4, val, eras = this.localeData().eras();
3786          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3787            val = this.clone().startOf("day").valueOf();
3788            if (eras[i4].since <= val && val <= eras[i4].until) {
3789              return eras[i4].narrow;
3790            }
3791            if (eras[i4].until <= val && val <= eras[i4].since) {
3792              return eras[i4].narrow;
3793            }
3794          }
3795          return "";
3796        }
3797        function getEraAbbr() {
3798          var i4, l4, val, eras = this.localeData().eras();
3799          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3800            val = this.clone().startOf("day").valueOf();
3801            if (eras[i4].since <= val && val <= eras[i4].until) {
3802              return eras[i4].abbr;
3803            }
3804            if (eras[i4].until <= val && val <= eras[i4].since) {
3805              return eras[i4].abbr;
3806            }
3807          }
3808          return "";
3809        }
3810        function getEraYear() {
3811          var i4, l4, dir, val, eras = this.localeData().eras();
3812          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3813            dir = eras[i4].since <= eras[i4].until ? 1 : -1;
3814            val = this.clone().startOf("day").valueOf();
3815            if (eras[i4].since <= val && val <= eras[i4].until || eras[i4].until <= val && val <= eras[i4].since) {
3816              return (this.year() - hooks(eras[i4].since).year()) * dir + eras[i4].offset;
3817            }
3818          }
3819          return this.year();
3820        }
3821        function erasNameRegex(isStrict) {
3822          if (!hasOwnProp(this, "_erasNameRegex")) {
3823            computeErasParse.call(this);
3824          }
3825          return isStrict ? this._erasNameRegex : this._erasRegex;
3826        }
3827        function erasAbbrRegex(isStrict) {
3828          if (!hasOwnProp(this, "_erasAbbrRegex")) {
3829            computeErasParse.call(this);
3830          }
3831          return isStrict ? this._erasAbbrRegex : this._erasRegex;
3832        }
3833        function erasNarrowRegex(isStrict) {
3834          if (!hasOwnProp(this, "_erasNarrowRegex")) {
3835            computeErasParse.call(this);
3836          }
3837          return isStrict ? this._erasNarrowRegex : this._erasRegex;
3838        }
3839        function matchEraAbbr(isStrict, locale2) {
3840          return locale2.erasAbbrRegex(isStrict);
3841        }
3842        function matchEraName(isStrict, locale2) {
3843          return locale2.erasNameRegex(isStrict);
3844        }
3845        function matchEraNarrow(isStrict, locale2) {
3846          return locale2.erasNarrowRegex(isStrict);
3847        }
3848        function matchEraYearOrdinal(isStrict, locale2) {
3849          return locale2._eraYearOrdinalRegex || matchUnsigned;
3850        }
3851        function computeErasParse() {
3852          var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i4, l4, erasName, erasAbbr, erasNarrow, eras = this.eras();
3853          for (i4 = 0, l4 = eras.length; i4 < l4; ++i4) {
3854            erasName = regexEscape(eras[i4].name);
3855            erasAbbr = regexEscape(eras[i4].abbr);
3856            erasNarrow = regexEscape(eras[i4].narrow);
3857            namePieces.push(erasName);
3858            abbrPieces.push(erasAbbr);
3859            narrowPieces.push(erasNarrow);
3860            mixedPieces.push(erasName);
3861            mixedPieces.push(erasAbbr);
3862            mixedPieces.push(erasNarrow);
3863          }
3864          this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
3865          this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i");
3866          this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i");
3867          this._erasNarrowRegex = new RegExp(
3868            "^(" + narrowPieces.join("|") + ")",
3869            "i"
3870          );
3871        }
3872        addFormatToken(0, ["gg", 2], 0, function() {
3873          return this.weekYear() % 100;
3874        });
3875        addFormatToken(0, ["GG", 2], 0, function() {
3876          return this.isoWeekYear() % 100;
3877        });
3878        function addWeekYearFormatToken(token2, getter) {
3879          addFormatToken(0, [token2, token2.length], 0, getter);
3880        }
3881        addWeekYearFormatToken("gggg", "weekYear");
3882        addWeekYearFormatToken("ggggg", "weekYear");
3883        addWeekYearFormatToken("GGGG", "isoWeekYear");
3884        addWeekYearFormatToken("GGGGG", "isoWeekYear");
3885        addRegexToken("G", matchSigned);
3886        addRegexToken("g", matchSigned);
3887        addRegexToken("GG", match1to2, match2);
3888        addRegexToken("gg", match1to2, match2);
3889        addRegexToken("GGGG", match1to4, match4);
3890        addRegexToken("gggg", match1to4, match4);
3891        addRegexToken("GGGGG", match1to6, match6);
3892        addRegexToken("ggggg", match1to6, match6);
3893        addWeekParseToken(
3894          ["gggg", "ggggg", "GGGG", "GGGGG"],
3895          function(input, week, config2, token2) {
3896            week[token2.substr(0, 2)] = toInt(input);
3897          }
3898        );
3899        addWeekParseToken(["gg", "GG"], function(input, week, config2, token2) {
3900          week[token2] = hooks.parseTwoDigitYear(input);
3901        });
3902        function getSetWeekYear(input) {
3903          return getSetWeekYearHelper.call(
3904            this,
3905            input,
3906            this.week(),
3907            this.weekday() + this.localeData()._week.dow,
3908            this.localeData()._week.dow,
3909            this.localeData()._week.doy
3910          );
3911        }
3912        function getSetISOWeekYear(input) {
3913          return getSetWeekYearHelper.call(
3914            this,
3915            input,
3916            this.isoWeek(),
3917            this.isoWeekday(),
3918            1,
3919            4
3920          );
3921        }
3922        function getISOWeeksInYear() {
3923          return weeksInYear(this.year(), 1, 4);
3924        }
3925        function getISOWeeksInISOWeekYear() {
3926          return weeksInYear(this.isoWeekYear(), 1, 4);
3927        }
3928        function getWeeksInYear() {
3929          var weekInfo = this.localeData()._week;
3930          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
3931        }
3932        function getWeeksInWeekYear() {
3933          var weekInfo = this.localeData()._week;
3934          return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
3935        }
3936        function getSetWeekYearHelper(input, week, weekday, dow, doy) {
3937          var weeksTarget;
3938          if (input == null) {
3939            return weekOfYear2(this, dow, doy).year;
3940          } else {
3941            weeksTarget = weeksInYear(input, dow, doy);
3942            if (week > weeksTarget) {
3943              week = weeksTarget;
3944            }
3945            return setWeekAll.call(this, input, week, weekday, dow, doy);
3946          }
3947        }
3948        function setWeekAll(weekYear, week, weekday, dow, doy) {
3949          var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
3950          this.year(date.getUTCFullYear());
3951          this.month(date.getUTCMonth());
3952          this.date(date.getUTCDate());
3953          return this;
3954        }
3955        addFormatToken("Q", 0, "Qo", "quarter");
3956        addRegexToken("Q", match1);
3957        addParseToken("Q", function(input, array) {
3958          array[MONTH] = (toInt(input) - 1) * 3;
3959        });
3960        function getSetQuarter(input) {
3961          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
3962        }
3963        addFormatToken("D", ["DD", 2], "Do", "date");
3964        addRegexToken("D", match1to2, match1to2NoLeadingZero);
3965        addRegexToken("DD", match1to2, match2);
3966        addRegexToken("Do", function(isStrict, locale2) {
3967          return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient;
3968        });
3969        addParseToken(["D", "DD"], DATE);
3970        addParseToken("Do", function(input, array) {
3971          array[DATE] = toInt(input.match(match1to2)[0]);
3972        });
3973        var getSetDayOfMonth = makeGetSet("Date", true);
3974        addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
3975        addRegexToken("DDD", match1to3);
3976        addRegexToken("DDDD", match3);
3977        addParseToken(["DDD", "DDDD"], function(input, array, config2) {
3978          config2._dayOfYear = toInt(input);
3979        });
3980        function getSetDayOfYear(input) {
3981          var dayOfYear = Math.round(
3982            (this.clone().startOf("day") - this.clone().startOf("year")) / 864e5
3983          ) + 1;
3984          return input == null ? dayOfYear : this.add(input - dayOfYear, "d");
3985        }
3986        addFormatToken("m", ["mm", 2], 0, "minute");
3987        addRegexToken("m", match1to2, match1to2HasZero);
3988        addRegexToken("mm", match1to2, match2);
3989        addParseToken(["m", "mm"], MINUTE);
3990        var getSetMinute = makeGetSet("Minutes", false);
3991        addFormatToken("s", ["ss", 2], 0, "second");
3992        addRegexToken("s", match1to2, match1to2HasZero);
3993        addRegexToken("ss", match1to2, match2);
3994        addParseToken(["s", "ss"], SECOND);
3995        var getSetSecond = makeGetSet("Seconds", false);
3996        addFormatToken("S", 0, 0, function() {
3997          return ~~(this.millisecond() / 100);
3998        });
3999        addFormatToken(0, ["SS", 2], 0, function() {
4000          return ~~(this.millisecond() / 10);
4001        });
4002        addFormatToken(0, ["SSS", 3], 0, "millisecond");
4003        addFormatToken(0, ["SSSS", 4], 0, function() {
4004          return this.millisecond() * 10;
4005        });
4006        addFormatToken(0, ["SSSSS", 5], 0, function() {
4007          return this.millisecond() * 100;
4008        });
4009        addFormatToken(0, ["SSSSSS", 6], 0, function() {
4010          return this.millisecond() * 1e3;
4011        });
4012        addFormatToken(0, ["SSSSSSS", 7], 0, function() {
4013          return this.millisecond() * 1e4;
4014        });
4015        addFormatToken(0, ["SSSSSSSS", 8], 0, function() {
4016          return this.millisecond() * 1e5;
4017        });
4018        addFormatToken(0, ["SSSSSSSSS", 9], 0, function() {
4019          return this.millisecond() * 1e6;
4020        });
4021        addRegexToken("S", match1to3, match1);
4022        addRegexToken("SS", match1to3, match2);
4023        addRegexToken("SSS", match1to3, match3);
4024        var token, getSetMillisecond;
4025        for (token = "SSSS"; token.length <= 9; token += "S") {
4026          addRegexToken(token, matchUnsigned);
4027        }
4028        function parseMs(input, array) {
4029          array[MILLISECOND] = toInt(("0." + input) * 1e3);
4030        }
4031        for (token = "S"; token.length <= 9; token += "S") {
4032          addParseToken(token, parseMs);
4033        }
4034        getSetMillisecond = makeGetSet("Milliseconds", false);
4035        addFormatToken("z", 0, 0, "zoneAbbr");
4036        addFormatToken("zz", 0, 0, "zoneName");
4037        function getZoneAbbr() {
4038          return this._isUTC ? "UTC" : "";
4039        }
4040        function getZoneName() {
4041          return this._isUTC ? "Coordinated Universal Time" : "";
4042        }
4043        var proto = Moment3.prototype;
4044        proto.add = add2;
4045        proto.calendar = calendar$1;
4046        proto.clone = clone;
4047        proto.diff = diff;
4048        proto.endOf = endOf;
4049        proto.format = format;
4050        proto.from = from;
4051        proto.fromNow = fromNow;
4052        proto.to = to2;
4053        proto.toNow = toNow;
4054        proto.get = stringGet;
4055        proto.invalidAt = invalidAt;
4056        proto.isAfter = isAfter;
4057        proto.isBefore = isBefore;
4058        proto.isBetween = isBetween;
4059        proto.isSame = isSame;
4060        proto.isSameOrAfter = isSameOrAfter;
4061        proto.isSameOrBefore = isSameOrBefore;
4062        proto.isValid = isValid$2;
4063        proto.lang = lang2;
4064        proto.locale = locale;
4065        proto.localeData = localeData;
4066        proto.max = prototypeMax;
4067        proto.min = prototypeMin;
4068        proto.parsingFlags = parsingFlags;
4069        proto.set = stringSet;
4070        proto.startOf = startOf;
4071        proto.subtract = subtract;
4072        proto.toArray = toArray3;
4073        proto.toObject = toObject;
4074        proto.toDate = toDate;
4075        proto.toISOString = toISOString;
4076        proto.inspect = inspect;
4077        if (typeof Symbol !== "undefined" && Symbol.for != null) {
4078          proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
4079            return "Moment<" + this.format() + ">";
4080          };
4081        }
4082        proto.toJSON = toJSON;
4083        proto.toString = toString;
4084        proto.unix = unix;
4085        proto.valueOf = valueOf;
4086        proto.creationData = creationData;
4087        proto.eraName = getEraName;
4088        proto.eraNarrow = getEraNarrow;
4089        proto.eraAbbr = getEraAbbr;
4090        proto.eraYear = getEraYear;
4091        proto.year = getSetYear;
4092        proto.isLeapYear = getIsLeapYear;
4093        proto.weekYear = getSetWeekYear;
4094        proto.isoWeekYear = getSetISOWeekYear;
4095        proto.quarter = proto.quarters = getSetQuarter;
4096        proto.month = getSetMonth;
4097        proto.daysInMonth = getDaysInMonth;
4098        proto.week = proto.weeks = getSetWeek;
4099        proto.isoWeek = proto.isoWeeks = getSetISOWeek;
4100        proto.weeksInYear = getWeeksInYear;
4101        proto.weeksInWeekYear = getWeeksInWeekYear;
4102        proto.isoWeeksInYear = getISOWeeksInYear;
4103        proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
4104        proto.date = getSetDayOfMonth;
4105        proto.day = proto.days = getSetDayOfWeek;
4106        proto.weekday = getSetLocaleDayOfWeek;
4107        proto.isoWeekday = getSetISODayOfWeek;
4108        proto.dayOfYear = getSetDayOfYear;
4109        proto.hour = proto.hours = getSetHour;
4110        proto.minute = proto.minutes = getSetMinute;
4111        proto.second = proto.seconds = getSetSecond;
4112        proto.millisecond = proto.milliseconds = getSetMillisecond;
4113        proto.utcOffset = getSetOffset;
4114        proto.utc = setOffsetToUTC;
4115        proto.local = setOffsetToLocal;
4116        proto.parseZone = setOffsetToParsedOffset;
4117        proto.hasAlignedHourOffset = hasAlignedHourOffset;
4118        proto.isDST = isDaylightSavingTime;
4119        proto.isLocal = isLocal;
4120        proto.isUtcOffset = isUtcOffset;
4121        proto.isUtc = isUtc;
4122        proto.isUTC = isUtc;
4123        proto.zoneAbbr = getZoneAbbr;
4124        proto.zoneName = getZoneName;
4125        proto.dates = deprecate(
4126          "dates accessor is deprecated. Use date instead.",
4127          getSetDayOfMonth
4128        );
4129        proto.months = deprecate(
4130          "months accessor is deprecated. Use month instead",
4131          getSetMonth
4132        );
4133        proto.years = deprecate(
4134          "years accessor is deprecated. Use year instead",
4135          getSetYear
4136        );
4137        proto.zone = deprecate(
4138          "moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
4139          getSetZone
4140        );
4141        proto.isDSTShifted = deprecate(
4142          "isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
4143          isDaylightSavingTimeShifted
4144        );
4145        function createUnix(input) {
4146          return createLocal(input * 1e3);
4147        }
4148        function createInZone() {
4149          return createLocal.apply(null, arguments).parseZone();
4150        }
4151        function preParsePostFormat(string) {
4152          return string;
4153        }
4154        var proto$1 = Locale.prototype;
4155        proto$1.calendar = calendar;
4156        proto$1.longDateFormat = longDateFormat;
4157        proto$1.invalidDate = invalidDate;
4158        proto$1.ordinal = ordinal;
4159        proto$1.preparse = preParsePostFormat;
4160        proto$1.postformat = preParsePostFormat;
4161        proto$1.relativeTime = relativeTime;
4162        proto$1.pastFuture = pastFuture;
4163        proto$1.set = set;
4164        proto$1.eras = localeEras;
4165        proto$1.erasParse = localeErasParse;
4166        proto$1.erasConvertYear = localeErasConvertYear;
4167        proto$1.erasAbbrRegex = erasAbbrRegex;
4168        proto$1.erasNameRegex = erasNameRegex;
4169        proto$1.erasNarrowRegex = erasNarrowRegex;
4170        proto$1.months = localeMonths;
4171        proto$1.monthsShort = localeMonthsShort;
4172        proto$1.monthsParse = localeMonthsParse;
4173        proto$1.monthsRegex = monthsRegex;
4174        proto$1.monthsShortRegex = monthsShortRegex;
4175        proto$1.week = localeWeek;
4176        proto$1.firstDayOfYear = localeFirstDayOfYear;
4177        proto$1.firstDayOfWeek = localeFirstDayOfWeek;
4178        proto$1.weekdays = localeWeekdays;
4179        proto$1.weekdaysMin = localeWeekdaysMin;
4180        proto$1.weekdaysShort = localeWeekdaysShort;
4181        proto$1.weekdaysParse = localeWeekdaysParse;
4182        proto$1.weekdaysRegex = weekdaysRegex;
4183        proto$1.weekdaysShortRegex = weekdaysShortRegex;
4184        proto$1.weekdaysMinRegex = weekdaysMinRegex;
4185        proto$1.isPM = localeIsPM;
4186        proto$1.meridiem = localeMeridiem;
4187        function get$1(format2, index4, field, setter) {
4188          var locale2 = getLocale(), utc = createUTC().set(setter, index4);
4189          return locale2[field](utc, format2);
4190        }
4191        function listMonthsImpl(format2, index4, field) {
4192          if (isNumber(format2)) {
4193            index4 = format2;
4194            format2 = void 0;
4195          }
4196          format2 = format2 || "";
4197          if (index4 != null) {
4198            return get$1(format2, index4, field, "month");
4199          }
4200          var i4, out = [];
4201          for (i4 = 0; i4 < 12; i4++) {
4202            out[i4] = get$1(format2, i4, field, "month");
4203          }
4204          return out;
4205        }
4206        function listWeekdaysImpl(localeSorted, format2, index4, field) {
4207          if (typeof localeSorted === "boolean") {
4208            if (isNumber(format2)) {
4209              index4 = format2;
4210              format2 = void 0;
4211            }
4212            format2 = format2 || "";
4213          } else {
4214            format2 = localeSorted;
4215            index4 = format2;
4216            localeSorted = false;
4217            if (isNumber(format2)) {
4218              index4 = format2;
4219              format2 = void 0;
4220            }
4221            format2 = format2 || "";
4222          }
4223          var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i4, out = [];
4224          if (index4 != null) {
4225            return get$1(format2, (index4 + shift) % 7, field, "day");
4226          }
4227          for (i4 = 0; i4 < 7; i4++) {
4228            out[i4] = get$1(format2, (i4 + shift) % 7, field, "day");
4229          }
4230          return out;
4231        }
4232        function listMonths(format2, index4) {
4233          return listMonthsImpl(format2, index4, "months");
4234        }
4235        function listMonthsShort(format2, index4) {
4236          return listMonthsImpl(format2, index4, "monthsShort");
4237        }
4238        function listWeekdays(localeSorted, format2, index4) {
4239          return listWeekdaysImpl(localeSorted, format2, index4, "weekdays");
4240        }
4241        function listWeekdaysShort(localeSorted, format2, index4) {
4242          return listWeekdaysImpl(localeSorted, format2, index4, "weekdaysShort");
4243        }
4244        function listWeekdaysMin(localeSorted, format2, index4) {
4245          return listWeekdaysImpl(localeSorted, format2, index4, "weekdaysMin");
4246        }
4247        getSetGlobalLocale("en", {
4248          eras: [
4249            {
4250              since: "0001-01-01",
4251              until: Infinity,
4252              offset: 1,
4253              name: "Anno Domini",
4254              narrow: "AD",
4255              abbr: "AD"
4256            },
4257            {
4258              since: "0000-12-31",
4259              until: -Infinity,
4260              offset: 1,
4261              name: "Before Christ",
4262              narrow: "BC",
4263              abbr: "BC"
4264            }
4265          ],
4266          dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
4267          ordinal: function(number) {
4268            var b4 = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b4 === 1 ? "st" : b4 === 2 ? "nd" : b4 === 3 ? "rd" : "th";
4269            return number + output;
4270          }
4271        });
4272        hooks.lang = deprecate(
4273          "moment.lang is deprecated. Use moment.locale instead.",
4274          getSetGlobalLocale
4275        );
4276        hooks.langData = deprecate(
4277          "moment.langData is deprecated. Use moment.localeData instead.",
4278          getLocale
4279        );
4280        var mathAbs = Math.abs;
4281        function abs() {
4282          var data = this._data;
4283          this._milliseconds = mathAbs(this._milliseconds);
4284          this._days = mathAbs(this._days);
4285          this._months = mathAbs(this._months);
4286          data.milliseconds = mathAbs(data.milliseconds);
4287          data.seconds = mathAbs(data.seconds);
4288          data.minutes = mathAbs(data.minutes);
4289          data.hours = mathAbs(data.hours);
4290          data.months = mathAbs(data.months);
4291          data.years = mathAbs(data.years);
4292          return this;
4293        }
4294        function addSubtract$1(duration, input, value, direction) {
4295          var other = createDuration2(input, value);
4296          duration._milliseconds += direction * other._milliseconds;
4297          duration._days += direction * other._days;
4298          duration._months += direction * other._months;
4299          return duration._bubble();
4300        }
4301        function add$1(input, value) {
4302          return addSubtract$1(this, input, value, 1);
4303        }
4304        function subtract$1(input, value) {
4305          return addSubtract$1(this, input, value, -1);
4306        }
4307        function absCeil(number) {
4308          if (number < 0) {
4309            return Math.floor(number);
4310          } else {
4311            return Math.ceil(number);
4312          }
4313        }
4314        function bubble() {
4315          var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays;
4316          if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) {
4317            milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5;
4318            days2 = 0;
4319            months2 = 0;
4320          }
4321          data.milliseconds = milliseconds2 % 1e3;
4322          seconds2 = absFloor(milliseconds2 / 1e3);
4323          data.seconds = seconds2 % 60;
4324          minutes2 = absFloor(seconds2 / 60);
4325          data.minutes = minutes2 % 60;
4326          hours2 = absFloor(minutes2 / 60);
4327          data.hours = hours2 % 24;
4328          days2 += absFloor(hours2 / 24);
4329          monthsFromDays = absFloor(daysToMonths(days2));
4330          months2 += monthsFromDays;
4331          days2 -= absCeil(monthsToDays(monthsFromDays));
4332          years2 = absFloor(months2 / 12);
4333          months2 %= 12;
4334          data.days = days2;
4335          data.months = months2;
4336          data.years = years2;
4337          return this;
4338        }
4339        function daysToMonths(days2) {
4340          return days2 * 4800 / 146097;
4341        }
4342        function monthsToDays(months2) {
4343          return months2 * 146097 / 4800;
4344        }
4345        function as(units) {
4346          if (!this.isValid()) {
4347            return NaN;
4348          }
4349          var days2, months2, milliseconds2 = this._milliseconds;
4350          units = normalizeUnits(units);
4351          if (units === "month" || units === "quarter" || units === "year") {
4352            days2 = this._days + milliseconds2 / 864e5;
4353            months2 = this._months + daysToMonths(days2);
4354            switch (units) {
4355              case "month":
4356                return months2;
4357              case "quarter":
4358                return months2 / 3;
4359              case "year":
4360                return months2 / 12;
4361            }
4362          } else {
4363            days2 = this._days + Math.round(monthsToDays(this._months));
4364            switch (units) {
4365              case "week":
4366                return days2 / 7 + milliseconds2 / 6048e5;
4367              case "day":
4368                return days2 + milliseconds2 / 864e5;
4369              case "hour":
4370                return days2 * 24 + milliseconds2 / 36e5;
4371              case "minute":
4372                return days2 * 1440 + milliseconds2 / 6e4;
4373              case "second":
4374                return days2 * 86400 + milliseconds2 / 1e3;
4375              case "millisecond":
4376                return Math.floor(days2 * 864e5) + milliseconds2;
4377              default:
4378                throw new Error("Unknown unit " + units);
4379            }
4380          }
4381        }
4382        function makeAs(alias) {
4383          return function() {
4384            return this.as(alias);
4385          };
4386        }
4387        var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds;
4388        function clone$1() {
4389          return createDuration2(this);
4390        }
4391        function get$2(units) {
4392          units = normalizeUnits(units);
4393          return this.isValid() ? this[units + "s"]() : NaN;
4394        }
4395        function makeGetter(name) {
4396          return function() {
4397            return this.isValid() ? this._data[name] : NaN;
4398          };
4399        }
4400        var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years");
4401        function weeks() {
4402          return absFloor(this.days() / 7);
4403        }
4404        var round2 = Math.round, thresholds = {
4405          ss: 44,
4406          s: 45,
4407          m: 45,
4408          h: 22,
4409          d: 26,
4410          w: null,
4411          M: 11
4412        };
4413        function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) {
4414          return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
4415        }
4416        function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
4417          var duration = createDuration2(posNegDuration).abs(), seconds2 = round2(duration.as("s")), minutes2 = round2(duration.as("m")), hours2 = round2(duration.as("h")), days2 = round2(duration.as("d")), months2 = round2(duration.as("M")), weeks2 = round2(duration.as("w")), years2 = round2(duration.as("y")), a4 = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
4418          if (thresholds2.w != null) {
4419            a4 = a4 || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
4420          }
4421          a4 = a4 || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2];
4422          a4[2] = withoutSuffix;
4423          a4[3] = +posNegDuration > 0;
4424          a4[4] = locale2;
4425          return substituteTimeAgo.apply(null, a4);
4426        }
4427        function getSetRelativeTimeRounding(roundingFunction) {
4428          if (roundingFunction === void 0) {
4429            return round2;
4430          }
4431          if (typeof roundingFunction === "function") {
4432            round2 = roundingFunction;
4433            return true;
4434          }
4435          return false;
4436        }
4437        function getSetRelativeTimeThreshold(threshold, limit) {
4438          if (thresholds[threshold] === void 0) {
4439            return false;
4440          }
4441          if (limit === void 0) {
4442            return thresholds[threshold];
4443          }
4444          thresholds[threshold] = limit;
4445          if (threshold === "s") {
4446            thresholds.ss = limit - 1;
4447          }
4448          return true;
4449        }
4450        function humanize(argWithSuffix, argThresholds) {
4451          if (!this.isValid()) {
4452            return this.localeData().invalidDate();
4453          }
4454          var withSuffix = false, th = thresholds, locale2, output;
4455          if (typeof argWithSuffix === "object") {
4456            argThresholds = argWithSuffix;
4457            argWithSuffix = false;
4458          }
4459          if (typeof argWithSuffix === "boolean") {
4460            withSuffix = argWithSuffix;
4461          }
4462          if (typeof argThresholds === "object") {
4463            th = Object.assign({}, thresholds, argThresholds);
4464            if (argThresholds.s != null && argThresholds.ss == null) {
4465              th.ss = argThresholds.s - 1;
4466            }
4467          }
4468          locale2 = this.localeData();
4469          output = relativeTime$1(this, !withSuffix, th, locale2);
4470          if (withSuffix) {
4471            output = locale2.pastFuture(+this, output);
4472          }
4473          return locale2.postformat(output);
4474        }
4475        var abs$1 = Math.abs;
4476        function sign(x5) {
4477          return (x5 > 0) - (x5 < 0) || +x5;
4478        }
4479        function toISOString$1() {
4480          if (!this.isValid()) {
4481            return this.localeData().invalidDate();
4482          }
4483          var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s4, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
4484          if (!total) {
4485            return "P0D";
4486          }
4487          minutes2 = absFloor(seconds2 / 60);
4488          hours2 = absFloor(minutes2 / 60);
4489          seconds2 %= 60;
4490          minutes2 %= 60;
4491          years2 = absFloor(months2 / 12);
4492          months2 %= 12;
4493          s4 = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : "";
4494          totalSign = total < 0 ? "-" : "";
4495          ymSign = sign(this._months) !== sign(total) ? "-" : "";
4496          daysSign = sign(this._days) !== sign(total) ? "-" : "";
4497          hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : "";
4498          return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s4 + "S" : "");
4499        }
4500        var proto$2 = Duration.prototype;
4501        proto$2.isValid = isValid$1;
4502        proto$2.abs = abs;
4503        proto$2.add = add$1;
4504        proto$2.subtract = subtract$1;
4505        proto$2.as = as;
4506        proto$2.asMilliseconds = asMilliseconds;
4507        proto$2.asSeconds = asSeconds;
4508        proto$2.asMinutes = asMinutes;
4509        proto$2.asHours = asHours;
4510        proto$2.asDays = asDays;
4511        proto$2.asWeeks = asWeeks;
4512        proto$2.asMonths = asMonths;
4513        proto$2.asQuarters = asQuarters;
4514        proto$2.asYears = asYears;
4515        proto$2.valueOf = valueOf$1;
4516        proto$2._bubble = bubble;
4517        proto$2.clone = clone$1;
4518        proto$2.get = get$2;
4519        proto$2.milliseconds = milliseconds;
4520        proto$2.seconds = seconds;
4521        proto$2.minutes = minutes;
4522        proto$2.hours = hours;
4523        proto$2.days = days;
4524        proto$2.weeks = weeks;
4525        proto$2.months = months;
4526        proto$2.years = years;
4527        proto$2.humanize = humanize;
4528        proto$2.toISOString = toISOString$1;
4529        proto$2.toString = toISOString$1;
4530        proto$2.toJSON = toISOString$1;
4531        proto$2.locale = locale;
4532        proto$2.localeData = localeData;
4533        proto$2.toIsoString = deprecate(
4534          "toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
4535          toISOString$1
4536        );
4537        proto$2.lang = lang2;
4538        addFormatToken("X", 0, 0, "unix");
4539        addFormatToken("x", 0, 0, "valueOf");
4540        addRegexToken("x", matchSigned);
4541        addRegexToken("X", matchTimestamp);
4542        addParseToken("X", function(input, array, config2) {
4543          config2._d = new Date(parseFloat(input) * 1e3);
4544        });
4545        addParseToken("x", function(input, array, config2) {
4546          config2._d = new Date(toInt(input));
4547        });
4548        hooks.version = "2.30.1";
4549        setHookCallback(createLocal);
4550        hooks.fn = proto;
4551        hooks.min = min2;
4552        hooks.max = max2;
4553        hooks.now = now3;
4554        hooks.utc = createUTC;
4555        hooks.unix = createUnix;
4556        hooks.months = listMonths;
4557        hooks.isDate = isDate;
4558        hooks.locale = getSetGlobalLocale;
4559        hooks.invalid = createInvalid;
4560        hooks.duration = createDuration2;
4561        hooks.isMoment = isMoment;
4562        hooks.weekdays = listWeekdays;
4563        hooks.parseZone = createInZone;
4564        hooks.localeData = getLocale;
4565        hooks.isDuration = isDuration;
4566        hooks.monthsShort = listMonthsShort;
4567        hooks.weekdaysMin = listWeekdaysMin;
4568        hooks.defineLocale = defineLocale;
4569        hooks.updateLocale = updateLocale;
4570        hooks.locales = listLocales;
4571        hooks.weekdaysShort = listWeekdaysShort;
4572        hooks.normalizeUnits = normalizeUnits;
4573        hooks.relativeTimeRounding = getSetRelativeTimeRounding;
4574        hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
4575        hooks.calendarFormat = getCalendarFormat;
4576        hooks.prototype = proto;
4577        hooks.HTML5_FMT = {
4578          DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
4579          DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
4580          DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS",
4581          DATE: "YYYY-MM-DD",
4582          TIME: "HH:mm",
4583          TIME_SECONDS: "HH:mm:ss",
4584          TIME_MS: "HH:mm:ss.SSS",
4585          WEEK: "GGGG-[W]WW",
4586          MONTH: "YYYY-MM"
4587        };
4588        return hooks;
4589      });
4590    }
4591  });
4592
4593