@qite/tide-client/build/index.js

Frontend client for Tide

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });

exports.AllotmentKind = void 0;
(function (AllotmentKind) {
  AllotmentKind[(AllotmentKind["perUnit"] = 0)] = "perUnit";
  AllotmentKind[(AllotmentKind["perMember"] = 1)] = "perMember";
})(exports.AllotmentKind || (exports.AllotmentKind = {}));

exports.AllotmentStatus = void 0;
(function (AllotmentStatus) {
  AllotmentStatus[(AllotmentStatus["bookable"] = 0)] = "bookable";
  AllotmentStatus[(AllotmentStatus["closed"] = 1)] = "closed";
  AllotmentStatus[(AllotmentStatus["hidden"] = 2)] = "hidden";
})(exports.AllotmentStatus || (exports.AllotmentStatus = {}));

var AllotmentType = {
  freeSell: 0,
  onRequest: 1,
  allotment: 2,
};

var AvailabilitySearchType = {
  default: 0,
  allotment: 1,
};

var DataType = {
  text: "text",
  numeric: "number",
  int: "int",
  bool: "bool",
  value: "value",
  enum: "enum",
  date: "date",
  dateTime: "datetime",
  dateFrom: "dateFrom",
  html: "html",
  list: "list",
  template: "template",
};

var DossierType = {
  hotelOnly: 0,
  transportOnly: 1,
  cruise: 2,
  package: 3,
};

var EntryLineFlag = {
  none: 0,
  allotmentNoPlace: 1,
  flightLuggage: 2,
  noCachedPrice: 4,
};

var EntryLineStatus = {
  cancellationByClient: 0,
  cancellationByYou: 1,
  noAllotment: 2,
  offer: 3,
  ok: 4,
  option: 5,
  onRequest: 6,
  requestConfirmed: 7,
  requestDenied: 8,
  requestSent: 9,
  pending: 10,
  notBookable: 11,
  noAllotmentFallbackToRealtimeFlight: 12,
  notBookableFallbackToRealtimeFlight: 13,
  error: 14,
  bookingConfirmed: 15,
  cancellationConfirmed: 16,
};

exports.EntryStatus = void 0;
(function (EntryStatus) {
  EntryStatus[(EntryStatus["new"] = -1)] = "new";
  EntryStatus[(EntryStatus["offer"] = 0)] = "offer";
  EntryStatus[(EntryStatus["option"] = 1)] = "option";
  EntryStatus[(EntryStatus["booking"] = 2)] = "booking";
  EntryStatus[(EntryStatus["cancellationByClient"] = 3)] =
    "cancellationByClient";
  EntryStatus[(EntryStatus["cancellationByYou"] = 4)] = "cancellationByYou";
})(exports.EntryStatus || (exports.EntryStatus = {}));

var ExportStatus = {
  exported: 0,
  notExported: 1,
  exportFailed: 2,
};

var Gender = {
  male: 0,
  female: 1,
  other: 2,
};

exports.MetaDataItemPropertyType = void 0;
(function (MetaDataItemPropertyType) {
  MetaDataItemPropertyType[(MetaDataItemPropertyType["Height"] = 0)] = "Height";
  MetaDataItemPropertyType[(MetaDataItemPropertyType["Length"] = 1)] = "Length";
  MetaDataItemPropertyType[(MetaDataItemPropertyType["Width"] = 2)] = "Width";
  MetaDataItemPropertyType[(MetaDataItemPropertyType["Weight"] = 3)] = "Weight";
})(exports.MetaDataItemPropertyType || (exports.MetaDataItemPropertyType = {}));

var MetaDataType = {
  flight: 0,
  publicTransport: 1,
  rawHubData: 2,
  rawFlightData: 3,
  flightInfo: 4,
  bookFeedback: 5,
  cancelFeedback: 6,
  additionalServices: 7,
};

var PaymentType = {
  other: 0,
  bancontact: 1,
  creditcard: 2,
  cash: 3,
};

var PriceChartType = {
  purchasePrices: 0,
  sellingPrices: 1,
};

exports.PrintActionGroup = void 0;
(function (PrintActionGroup) {
  PrintActionGroup[(PrintActionGroup["Dossier"] = 0)] = "Dossier";
  PrintActionGroup[(PrintActionGroup["Offer"] = 1)] = "Offer";
  PrintActionGroup[(PrintActionGroup["Invoice"] = 2)] = "Invoice";
  PrintActionGroup[(PrintActionGroup["CreditNote"] = 3)] = "CreditNote";
  PrintActionGroup[(PrintActionGroup["Allotment"] = 4)] = "Allotment";
  PrintActionGroup[(PrintActionGroup["Product"] = 5)] = "Product";
  PrintActionGroup[(PrintActionGroup["EntryLine"] = 6)] = "EntryLine";
  PrintActionGroup[(PrintActionGroup["SelfBillingInvoice"] = 7)] =
    "SelfBillingInvoice";
})(exports.PrintActionGroup || (exports.PrintActionGroup = {}));

var RequirementType = {
  mandatory: 0,
  optional: 1,
  optionalInGroup: 2,
};

var RoomType = {
  pk1: 0,
  pk2: 1,
  pk3: 2,
  pk4: 3,
  pk5: 4,
  pk6: 5,
};

var SaleType = {
  ownOrganization: 0,
  resale: 1,
};

var ServiceType = {
  package: 0,
  roundTrip: 1,
  singleTrip: 2,
  hotel: 3,
  excursion: 4,
  extraService: 5,
  insurance: 6,
  flight: 7,
  serviceFee: 8,
  visum: 9,
  charter: 10,
  cruise: 11,
  ferry: 12,
  transfer: 13,
  bus: 14,
  tax: 15,
  fee: 16,
  car: 17,
  camper: 18,
  specialServices: 19,
  train: 20,
  gift: 21,
  rental: 22,
  restaurant: 23,
  event: 24,
  training: 25,
  voucher: 26,
  reduction: 27,
  rocket: 28,
  tent: 29,
  camp: 30,
};

exports.UnitOfMeasure = void 0;
(function (UnitOfMeasure) {
  UnitOfMeasure[(UnitOfMeasure["cm"] = 0)] = "cm";
  UnitOfMeasure[(UnitOfMeasure["kg"] = 1)] = "kg";
  UnitOfMeasure[(UnitOfMeasure["lb"] = 2)] = "lb";
})(exports.UnitOfMeasure || (exports.UnitOfMeasure = {}));

/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P
      ? value
      : new P(function (resolve) {
          resolve(value);
        });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done
        ? resolve(result.value)
        : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}

function __generator(thisArg, body) {
  var _ = {
      label: 0,
      sent: function () {
        if (t[0] & 1) throw t[1];
        return t[1];
      },
      trys: [],
      ops: [],
    },
    f,
    y,
    t,
    g = Object.create(
      (typeof Iterator === "function" ? Iterator : Object).prototype
    );
  return (
    (g.next = verb(0)),
    (g["throw"] = verb(1)),
    (g["return"] = verb(2)),
    typeof Symbol === "function" &&
      (g[Symbol.iterator] = function () {
        return this;
      }),
    g
  );
  function verb(n) {
    return function (v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");
    while ((g && ((g = 0), op[0] && (_ = 0)), _))
      try {
        if (
          ((f = 1),
          y &&
            (t =
              op[0] & 2
                ? y["return"]
                : op[0]
                ? y["throw"] || ((t = y["return"]) && t.call(y), 0)
                : y.next) &&
            !(t = t.call(y, op[1])).done)
        )
          return t;
        if (((y = 0), t)) op = [op[0] & 2, t.value];
        switch (op[0]) {
          case 0:
          case 1:
            t = op;
            break;
          case 4:
            _.label++;
            return { value: op[1], done: false };
          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;
          case 7:
            op = _.ops.pop();
            _.trys.pop();
            continue;
          default:
            if (
              !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
              (op[0] === 6 || op[0] === 2)
            ) {
              _ = 0;
              continue;
            }
            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
              _.label = op[1];
              break;
            }
            if (op[0] === 6 && _.label < t[1]) {
              _.label = t[1];
              t = op;
              break;
            }
            if (t && _.label < t[2]) {
              _.label = t[2];
              _.ops.push(op);
              break;
            }
            if (t[2]) _.ops.pop();
            _.trys.pop();
            continue;
        }
        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t = 0;
      }
    if (op[0] & 5) throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
}

typeof SuppressedError === "function"
  ? SuppressedError
  : function (error, suppressed, message) {
      var e = new Error(message);
      return (
        (e.name = "SuppressedError"),
        (e.error = error),
        (e.suppressed = suppressed),
        e
      );
    };

var post$1 = function (url, apiKey, body, token, signal, languageCode) {
  return __awaiter(void 0, void 0, void 0, function () {
    var response;
    return __generator(this, function (_a) {
      switch (_a.label) {
        case 0:
          return [
            4 /*yield*/,
            fetch(url, {
              method: "POST",
              headers: {
                "Content-Type": "application/json",
                "Api-Key": apiKey,
                Language: languageCode || "nl-BE",
                Authorization: token ? "Bearer " + token : "",
              },
              credentials: "include",
              body: body,
              signal: signal,
            }),
          ];
        case 1:
          response = _a.sent();
          if (!response.ok) {
            throw new Error(response.statusText);
          }
          return [2 /*return*/, response];
      }
    });
  });
};
var patch$1 = function (url, apiKey, body, token, signal, languageCode) {
  return __awaiter(void 0, void 0, void 0, function () {
    var response;
    return __generator(this, function (_a) {
      switch (_a.label) {
        case 0:
          return [
            4 /*yield*/,
            fetch(url, {
              method: "PATCH",
              headers: {
                "Content-Type": "application/json",
                "Api-Key": apiKey,
                Language: languageCode || "nl-BE",
                Authorization: token ? "Bearer " + token : "",
              },
              credentials: "include",
              body: body,
              signal: signal,
            }),
          ];
        case 1:
          response = _a.sent();
          if (!response.ok) {
            throw new Error(response.statusText);
          }
          return [2 /*return*/, response];
      }
    });
  });
};
var get$1 = function (url, apiKey, token, signal, languageCode) {
  return __awaiter(void 0, void 0, void 0, function () {
    var response;
    return __generator(this, function (_a) {
      switch (_a.label) {
        case 0:
          return [
            4 /*yield*/,
            fetch(url, {
              method: "GET",
              headers: {
                "Content-Type": "application/json",
                "Api-Key": apiKey,
                Language: languageCode || "nl-BE",
                "Accept-Language": languageCode || "nl-BE",
                Authorization: token ? "Bearer " + token : "",
              },
              credentials: "include",
              signal: signal,
            }),
          ];
        case 1:
          response = _a.sent();
          if (!response.ok) {
            throw new Error(response.statusText);
          }
          return [2 /*return*/, response];
      }
    });
  });
};

var commonjsGlobal =
  typeof globalThis !== "undefined"
    ? globalThis
    : typeof window !== "undefined"
    ? window
    : typeof global !== "undefined"
    ? global
    : typeof self !== "undefined"
    ? self
    : {};

function commonjsRequire(path) {
  throw new Error(
    'Could not dynamically require "' +
      path +
      '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'
  );
}

var moment$1 = { exports: {} };

(function (module, exports) {
  (function (global, factory) {
    module.exports = factory();
  })(commonjsGlobal, function () {
    var hookCallback;

    function hooks() {
      return hookCallback.apply(null, arguments);
    }

    // This is done to register the method called with moment()
    // without creating circular dependencies.
    function setHookCallback(callback) {
      hookCallback = callback;
    }

    function isArray(input) {
      return (
        input instanceof Array ||
        Object.prototype.toString.call(input) === "[object Array]"
      );
    }

    function isObject(input) {
      // IE8 will treat undefined and null as object if it wasn't for
      // input != null
      return (
        input != null &&
        Object.prototype.toString.call(input) === "[object Object]"
      );
    }

    function hasOwnProp(a, b) {
      return Object.prototype.hasOwnProperty.call(a, b);
    }

    function isObjectEmpty(obj) {
      if (Object.getOwnPropertyNames) {
        return Object.getOwnPropertyNames(obj).length === 0;
      } else {
        var k;
        for (k in obj) {
          if (hasOwnProp(obj, k)) {
            return false;
          }
        }
        return true;
      }
    }

    function isUndefined(input) {
      return input === void 0;
    }

    function isNumber(input) {
      return (
        typeof input === "number" ||
        Object.prototype.toString.call(input) === "[object Number]"
      );
    }

    function isDate(input) {
      return (
        input instanceof Date ||
        Object.prototype.toString.call(input) === "[object Date]"
      );
    }

    function map(arr, fn) {
      var res = [],
        i;
      for (i = 0; i < arr.length; ++i) {
        res.push(fn(arr[i], i));
      }
      return res;
    }

    function extend(a, b) {
      for (var i in b) {
        if (hasOwnProp(b, i)) {
          a[i] = b[i];
        }
      }

      if (hasOwnProp(b, "toString")) {
        a.toString = b.toString;
      }

      if (hasOwnProp(b, "valueOf")) {
        a.valueOf = b.valueOf;
      }

      return a;
    }

    function createUTC(input, format, locale, strict) {
      return createLocalOrUTC(input, format, locale, strict, true).utc();
    }

    function defaultParsingFlags() {
      // We need to deep clone this object.
      return {
        empty: false,
        unusedTokens: [],
        unusedInput: [],
        overflow: -2,
        charsLeftOver: 0,
        nullInput: false,
        invalidEra: null,
        invalidMonth: null,
        invalidFormat: false,
        userInvalidated: false,
        iso: false,
        parsedDateParts: [],
        era: null,
        meridiem: null,
        rfc2822: false,
        weekdayMismatch: false,
      };
    }

    function getParsingFlags(m) {
      if (m._pf == null) {
        m._pf = defaultParsingFlags();
      }
      return m._pf;
    }

    var some;
    if (Array.prototype.some) {
      some = Array.prototype.some;
    } else {
      some = function (fun) {
        var t = Object(this),
          len = t.length >>> 0,
          i;

        for (i = 0; i < len; i++) {
          if (i in t && fun.call(this, t[i], i, t)) {
            return true;
          }
        }

        return false;
      };
    }

    function isValid(m) {
      if (m._isValid == null) {
        var flags = getParsingFlags(m),
          parsedParts = some.call(flags.parsedDateParts, function (i) {
            return i != null;
          }),
          isNowValid =
            !isNaN(m._d.getTime()) &&
            flags.overflow < 0 &&
            !flags.empty &&
            !flags.invalidEra &&
            !flags.invalidMonth &&
            !flags.invalidWeekday &&
            !flags.weekdayMismatch &&
            !flags.nullInput &&
            !flags.invalidFormat &&
            !flags.userInvalidated &&
            (!flags.meridiem || (flags.meridiem && parsedParts));

        if (m._strict) {
          isNowValid =
            isNowValid &&
            flags.charsLeftOver === 0 &&
            flags.unusedTokens.length === 0 &&
            flags.bigHour === undefined;
        }

        if (Object.isFrozen == null || !Object.isFrozen(m)) {
          m._isValid = isNowValid;
        } else {
          return isNowValid;
        }
      }
      return m._isValid;
    }

    function createInvalid(flags) {
      var m = createUTC(NaN);
      if (flags != null) {
        extend(getParsingFlags(m), flags);
      } else {
        getParsingFlags(m).userInvalidated = true;
      }

      return m;
    }

    // Plugins that add properties should also add the key here (null value),
    // so we can properly clone ourselves.
    var momentProperties = (hooks.momentProperties = []),
      updateInProgress = false;

    function copyConfig(to, from) {
      var i, prop, val;

      if (!isUndefined(from._isAMomentObject)) {
        to._isAMomentObject = from._isAMomentObject;
      }
      if (!isUndefined(from._i)) {
        to._i = from._i;
      }
      if (!isUndefined(from._f)) {
        to._f = from._f;
      }
      if (!isUndefined(from._l)) {
        to._l = from._l;
      }
      if (!isUndefined(from._strict)) {
        to._strict = from._strict;
      }
      if (!isUndefined(from._tzm)) {
        to._tzm = from._tzm;
      }
      if (!isUndefined(from._isUTC)) {
        to._isUTC = from._isUTC;
      }
      if (!isUndefined(from._offset)) {
        to._offset = from._offset;
      }
      if (!isUndefined(from._pf)) {
        to._pf = getParsingFlags(from);
      }
      if (!isUndefined(from._locale)) {
        to._locale = from._locale;
      }

      if (momentProperties.length > 0) {
        for (i = 0; i < momentProperties.length; i++) {
          prop = momentProperties[i];
          val = from[prop];
          if (!isUndefined(val)) {
            to[prop] = val;
          }
        }
      }

      return to;
    }

    // Moment prototype object
    function Moment(config) {
      copyConfig(this, config);
      this._d = new Date(config._d != null ? config._d.getTime() : NaN);
      if (!this.isValid()) {
        this._d = new Date(NaN);
      }
      // Prevent infinite loop in case updateOffset creates new moment
      // objects.
      if (updateInProgress === false) {
        updateInProgress = true;
        hooks.updateOffset(this);
        updateInProgress = false;
      }
    }

    function isMoment(obj) {
      return (
        obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
      );
    }

    function warn(msg) {
      if (
        hooks.suppressDeprecationWarnings === false &&
        typeof console !== "undefined" &&
        console.warn
      ) {
        console.warn("Deprecation warning: " + msg);
      }
    }

    function deprecate(msg, fn) {
      var firstTime = true;

      return extend(function () {
        if (hooks.deprecationHandler != null) {
          hooks.deprecationHandler(null, msg);
        }
        if (firstTime) {
          var args = [],
            arg,
            i,
            key;
          for (i = 0; i < arguments.length; i++) {
            arg = "";
            if (typeof arguments[i] === "object") {
              arg += "\n[" + i + "] ";
              for (key in arguments[0]) {
                if (hasOwnProp(arguments[0], key)) {
                  arg += key + ": " + arguments[0][key] + ", ";
                }
              }
              arg = arg.slice(0, -2); // Remove trailing comma and space
            } else {
              arg = arguments[i];
            }
            args.push(arg);
          }
          warn(
            msg +
              "\nArguments: " +
              Array.prototype.slice.call(args).join("") +
              "\n" +
              new Error().stack
          );
          firstTime = false;
        }
        return fn.apply(this, arguments);
      }, fn);
    }

    var deprecations = {};

    function deprecateSimple(name, msg) {
      if (hooks.deprecationHandler != null) {
        hooks.deprecationHandler(name, msg);
      }
      if (!deprecations[name]) {
        warn(msg);
        deprecations[name] = true;
      }
    }

    hooks.suppressDeprecationWarnings = false;
    hooks.deprecationHandler = null;

    function isFunction(input) {
      return (
        (typeof Function !== "undefined" && input instanceof Function) ||
        Object.prototype.toString.call(input) === "[object Function]"
      );
    }

    function set(config) {
      var prop, i;
      for (i in config) {
        if (hasOwnProp(config, i)) {
          prop = config[i];
          if (isFunction(prop)) {
            this[i] = prop;
          } else {
            this["_" + i] = prop;
          }
        }
      }
      this._config = config;
      // Lenient ordinal parsing accepts just a number in addition to
      // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
      // TODO: Remove "ordinalParse" fallback in next major release.
      this._dayOfMonthOrdinalParseLenient = new RegExp(
        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
          "|" +
          /\d{1,2}/.source
      );
    }

    function mergeConfigs(parentConfig, childConfig) {
      var res = extend({}, parentConfig),
        prop;
      for (prop in childConfig) {
        if (hasOwnProp(childConfig, prop)) {
          if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
            res[prop] = {};
            extend(res[prop], parentConfig[prop]);
            extend(res[prop], childConfig[prop]);
          } else if (childConfig[prop] != null) {
            res[prop] = childConfig[prop];
          } else {
            delete res[prop];
          }
        }
      }
      for (prop in parentConfig) {
        if (
          hasOwnProp(parentConfig, prop) &&
          !hasOwnProp(childConfig, prop) &&
          isObject(parentConfig[prop])
        ) {
          // make sure changes to properties don't modify parent config
          res[prop] = extend({}, res[prop]);
        }
      }
      return res;
    }

    function Locale(config) {
      if (config != null) {
        this.set(config);
      }
    }

    var keys;

    if (Object.keys) {
      keys = Object.keys;
    } else {
      keys = function (obj) {
        var i,
          res = [];
        for (i in obj) {
          if (hasOwnProp(obj, i)) {
            res.push(i);
          }
        }
        return res;
      };
    }

    var defaultCalendar = {
      sameDay: "[Today at] LT",
      nextDay: "[Tomorrow at] LT",
      nextWeek: "dddd [at] LT",
      lastDay: "[Yesterday at] LT",
      lastWeek: "[Last] dddd [at] LT",
      sameElse: "L",
    };

    function calendar(key, mom, now) {
      var output = this._calendar[key] || this._calendar["sameElse"];
      return isFunction(output) ? output.call(mom, now) : output;
    }

    function zeroFill(number, targetLength, forceSign) {
      var absNumber = "" + Math.abs(number),
        zerosToFill = targetLength - absNumber.length,
        sign = number >= 0;
      return (
        (sign ? (forceSign ? "+" : "") : "-") +
        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
        absNumber
      );
    }

    var formattingTokens =
        /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
      localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
      formatFunctions = {},
      formatTokenFunctions = {};

    // token:    'M'
    // padded:   ['MM', 2]
    // ordinal:  'Mo'
    // callback: function () { this.month() + 1 }
    function addFormatToken(token, padded, ordinal, callback) {
      var func = callback;
      if (typeof callback === "string") {
        func = function () {
          return this[callback]();
        };
      }
      if (token) {
        formatTokenFunctions[token] = func;
      }
      if (padded) {
        formatTokenFunctions[padded[0]] = function () {
          return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
        };
      }
      if (ordinal) {
        formatTokenFunctions[ordinal] = function () {
          return this.localeData().ordinal(func.apply(this, arguments), token);
        };
      }
    }

    function removeFormattingTokens(input) {
      if (input.match(/\[[\s\S]/)) {
        return input.replace(/^\[|\]$/g, "");
      }
      return input.replace(/\\/g, "");
    }

    function makeFormatFunction(format) {
      var array = format.match(formattingTokens),
        i,
        length;

      for (i = 0, length = array.length; i < length; i++) {
        if (formatTokenFunctions[array[i]]) {
          array[i] = formatTokenFunctions[array[i]];
        } else {
          array[i] = removeFormattingTokens(array[i]);
        }
      }

      return function (mom) {
        var output = "",
          i;
        for (i = 0; i < length; i++) {
          output += isFunction(array[i])
            ? array[i].call(mom, format)
            : array[i];
        }
        return output;
      };
    }

    // format date using native date object
    function formatMoment(m, format) {
      if (!m.isValid()) {
        return m.localeData().invalidDate();
      }

      format = expandFormat(format, m.localeData());
      formatFunctions[format] =
        formatFunctions[format] || makeFormatFunction(format);

      return formatFunctions[format](m);
    }

    function expandFormat(format, locale) {
      var i = 5;

      function replaceLongDateFormatTokens(input) {
        return locale.longDateFormat(input) || input;
      }

      localFormattingTokens.lastIndex = 0;
      while (i >= 0 && localFormattingTokens.test(format)) {
        format = format.replace(
          localFormattingTokens,
          replaceLongDateFormatTokens
        );
        localFormattingTokens.lastIndex = 0;
        i -= 1;
      }

      return format;
    }

    var defaultLongDateFormat = {
      LTS: "h:mm:ss A",
      LT: "h:mm A",
      L: "MM/DD/YYYY",
      LL: "MMMM D, YYYY",
      LLL: "MMMM D, YYYY h:mm A",
      LLLL: "dddd, MMMM D, YYYY h:mm A",
    };

    function longDateFormat(key) {
      var format = this._longDateFormat[key],
        formatUpper = this._longDateFormat[key.toUpperCase()];

      if (format || !formatUpper) {
        return format;
      }

      this._longDateFormat[key] = formatUpper
        .match(formattingTokens)
        .map(function (tok) {
          if (
            tok === "MMMM" ||
            tok === "MM" ||
            tok === "DD" ||
            tok === "dddd"
          ) {
            return tok.slice(1);
          }
          return tok;
        })
        .join("");

      return this._longDateFormat[key];
    }

    var defaultInvalidDate = "Invalid date";

    function invalidDate() {
      return this._invalidDate;
    }

    var defaultOrdinal = "%d",
      defaultDayOfMonthOrdinalParse = /\d{1,2}/;

    function ordinal(number) {
      return this._ordinal.replace("%d", number);
    }

    var defaultRelativeTime = {
      future: "in %s",
      past: "%s ago",
      s: "a few seconds",
      ss: "%d seconds",
      m: "a minute",
      mm: "%d minutes",
      h: "an hour",
      hh: "%d hours",
      d: "a day",
      dd: "%d days",
      w: "a week",
      ww: "%d weeks",
      M: "a month",
      MM: "%d months",
      y: "a year",
      yy: "%d years",
    };

    function relativeTime(number, withoutSuffix, string, isFuture) {
      var output = this._relativeTime[string];
      return isFunction(output)
        ? output(number, withoutSuffix, string, isFuture)
        : output.replace(/%d/i, number);
    }

    function pastFuture(diff, output) {
      var format = this._relativeTime[diff > 0 ? "future" : "past"];
      return isFunction(format)
        ? format(output)
        : format.replace(/%s/i, output);
    }

    var aliases = {};

    function addUnitAlias(unit, shorthand) {
      var lowerCase = unit.toLowerCase();
      aliases[lowerCase] = aliases[lowerCase + "s"] = aliases[shorthand] = unit;
    }

    function normalizeUnits(units) {
      return typeof units === "string"
        ? aliases[units] || aliases[units.toLowerCase()]
        : undefined;
    }

    function normalizeObjectUnits(inputObject) {
      var normalizedInput = {},
        normalizedProp,
        prop;

      for (prop in inputObject) {
        if (hasOwnProp(inputObject, prop)) {
          normalizedProp = normalizeUnits(prop);
          if (normalizedProp) {
            normalizedInput[normalizedProp] = inputObject[prop];
          }
        }
      }

      return normalizedInput;
    }

    var priorities = {};

    function addUnitPriority(unit, priority) {
      priorities[unit] = priority;
    }

    function getPrioritizedUnits(unitsObj) {
      var units = [],
        u;
      for (u in unitsObj) {
        if (hasOwnProp(unitsObj, u)) {
          units.push({ unit: u, priority: priorities[u] });
        }
      }
      units.sort(function (a, b) {
        return a.priority - b.priority;
      });
      return units;
    }

    function isLeapYear(year) {
      return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
    }

    function absFloor(number) {
      if (number < 0) {
        // -0 -> 0
        return Math.ceil(number) || 0;
      } else {
        return Math.floor(number);
      }
    }

    function toInt(argumentForCoercion) {
      var coercedNumber = +argumentForCoercion,
        value = 0;

      if (coercedNumber !== 0 && isFinite(coercedNumber)) {
        value = absFloor(coercedNumber);
      }

      return value;
    }

    function makeGetSet(unit, keepTime) {
      return function (value) {
        if (value != null) {
          set$1(this, unit, value);
          hooks.updateOffset(this, keepTime);
          return this;
        } else {
          return get(this, unit);
        }
      };
    }

    function get(mom, unit) {
      return mom.isValid()
        ? mom._d["get" + (mom._isUTC ? "UTC" : "") + unit]()
        : NaN;
    }

    function set$1(mom, unit, value) {
      if (mom.isValid() && !isNaN(value)) {
        if (
          unit === "FullYear" &&
          isLeapYear(mom.year()) &&
          mom.month() === 1 &&
          mom.date() === 29
        ) {
          value = toInt(value);
          mom._d["set" + (mom._isUTC ? "UTC" : "") + unit](
            value,
            mom.month(),
            daysInMonth(value, mom.month())
          );
        } else {
          mom._d["set" + (mom._isUTC ? "UTC" : "") + unit](value);
        }
      }
    }

    // MOMENTS

    function stringGet(units) {
      units = normalizeUnits(units);
      if (isFunction(this[units])) {
        return this[units]();
      }
      return this;
    }

    function stringSet(units, value) {
      if (typeof units === "object") {
        units = normalizeObjectUnits(units);
        var prioritized = getPrioritizedUnits(units),
          i;
        for (i = 0; i < prioritized.length; i++) {
          this[prioritized[i].unit](units[prioritized[i].unit]);
        }
      } else {
        units = normalizeUnits(units);
        if (isFunction(this[units])) {
          return this[units](value);
        }
      }
      return this;
    }

    var match1 = /\d/, //       0 - 9
      match2 = /\d\d/, //      00 - 99
      match3 = /\d{3}/, //     000 - 999
      match4 = /\d{4}/, //    0000 - 9999
      match6 = /[+-]?\d{6}/, // -999999 - 999999
      match1to2 = /\d\d?/, //       0 - 99
      match3to4 = /\d\d\d\d?/, //     999 - 9999
      match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
      match1to3 = /\d{1,3}/, //       0 - 999
      match1to4 = /\d{1,4}/, //       0 - 9999
      match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
      matchUnsigned = /\d+/, //       0 - inf
      matchSigned = /[+-]?\d+/, //    -inf - inf
      matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
      matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
      matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
      // any word (or two) characters or numbers including two/three word month in arabic.
      // includes scottish gaelic two word and hyphenated months
      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,
      regexes;

    regexes = {};

    function addRegexToken(token, regex, strictRegex) {
      regexes[token] = isFunction(regex)
        ? regex
        : function (isStrict, localeData) {
            return isStrict && strictRegex ? strictRegex : regex;
          };
    }

    function getParseRegexForToken(token, config) {
      if (!hasOwnProp(regexes, token)) {
        return new RegExp(unescapeFormat(token));
      }

      return regexes[token](config._strict, config._locale);
    }

    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
    function unescapeFormat(s) {
      return regexEscape(
        s
          .replace("\\", "")
          .replace(
            /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
            function (matched, p1, p2, p3, p4) {
              return p1 || p2 || p3 || p4;
            }
          )
      );
    }

    function regexEscape(s) {
      return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
    }

    var tokens = {};

    function addParseToken(token, callback) {
      var i,
        func = callback;
      if (typeof token === "string") {
        token = [token];
      }
      if (isNumber(callback)) {
        func = function (input, array) {
          array[callback] = toInt(input);
        };
      }
      for (i = 0; i < token.length; i++) {
        tokens[token[i]] = func;
      }
    }

    function addWeekParseToken(token, callback) {
      addParseToken(token, function (input, array, config, token) {
        config._w = config._w || {};
        callback(input, config._w, config, token);
      });
    }

    function addTimeToArrayFromToken(token, input, config) {
      if (input != null && hasOwnProp(tokens, token)) {
        tokens[token](input, config._a, config, token);
      }
    }

    var YEAR = 0,
      MONTH = 1,
      DATE = 2,
      HOUR = 3,
      MINUTE = 4,
      SECOND = 5,
      MILLISECOND = 6,
      WEEK = 7,
      WEEKDAY = 8;

    function mod(n, x) {
      return ((n % x) + x) % x;
    }

    var indexOf;

    if (Array.prototype.indexOf) {
      indexOf = Array.prototype.indexOf;
    } else {
      indexOf = function (o) {
        // I know
        var i;
        for (i = 0; i < this.length; ++i) {
          if (this[i] === o) {
            return i;
          }
        }
        return -1;
      };
    }

    function daysInMonth(year, month) {
      if (isNaN(year) || isNaN(month)) {
        return NaN;
      }
      var modMonth = mod(month, 12);
      year += (month - modMonth) / 12;
      return modMonth === 1
        ? isLeapYear(year)
          ? 29
          : 28
        : 31 - ((modMonth % 7) % 2);
    }

    // FORMATTING

    addFormatToken("M", ["MM", 2], "Mo", function () {
      return this.month() + 1;
    });

    addFormatToken("MMM", 0, 0, function (format) {
      return this.localeData().monthsShort(this, format);
    });

    addFormatToken("MMMM", 0, 0, function (format) {
      return this.localeData().months(this, format);
    });

    // ALIASES

    addUnitAlias("month", "M");

    // PRIORITY

    addUnitPriority("month", 8);

    // PARSING

    addRegexToken("M", match1to2);
    addRegexToken("MM", match1to2, match2);
    addRegexToken("MMM", function (isStrict, locale) {
      return locale.monthsShortRegex(isStrict);
    });
    addRegexToken("MMMM", function (isStrict, locale) {
      return locale.monthsRegex(isStrict);
    });

    addParseToken(["M", "MM"], function (input, array) {
      array[MONTH] = toInt(input) - 1;
    });

    addParseToken(["MMM", "MMMM"], function (input, array, config, token) {
      var month = config._locale.monthsParse(input, token, config._strict);
      // if we didn't find a month name, mark the date as invalid.
      if (month != null) {
        array[MONTH] = month;
      } else {
        getParsingFlags(config).invalidMonth = input;
      }
    });

    // LOCALES

    var defaultLocaleMonths =
        "January_February_March_April_May_June_July_August_September_October_November_December".split(
          "_"
        ),
      defaultLocaleMonthsShort =
        "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
      MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
      defaultMonthsShortRegex = matchWord,
      defaultMonthsRegex = matchWord;

    function localeMonths(m, format) {
      if (!m) {
        return isArray(this._months)
          ? this._months
          : this._months["standalone"];
      }
      return isArray(this._months)
        ? this._months[m.month()]
        : this._months[
            (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
              ? "format"
              : "standalone"
          ][m.month()];
    }

    function localeMonthsShort(m, format) {
      if (!m) {
        return isArray(this._monthsShort)
          ? this._monthsShort
          : this._monthsShort["standalone"];
      }
      return isArray(this._monthsShort)
        ? this._monthsShort[m.month()]
        : this._monthsShort[
            MONTHS_IN_FORMAT.test(format) ? "format" : "standalone"
          ][m.month()];
    }

    function handleStrictParse(monthName, format, strict) {
      var i,
        ii,
        mom,
        llc = monthName.toLocaleLowerCase();
      if (!this._monthsParse) {
        // this is not used
        this._monthsParse = [];
        this._longMonthsParse = [];
        this._shortMonthsParse = [];
        for (i = 0; i < 12; ++i) {
          mom = createUTC([2000, i]);
          this._shortMonthsParse[i] = this.monthsShort(
            mom,
            ""
          ).toLocaleLowerCase();
          this._longMonthsParse[i] = this.months(mom, "").toLocaleLowerCase();
        }
      }

      if (strict) {
        if (format === "MMM") {
          ii = indexOf.call(this._shortMonthsParse, llc);
          return ii !== -1 ? ii : null;
        } else {
          ii = indexOf.call(this._longMonthsParse, llc);
          return ii !== -1 ? ii : null;
        }
      } else {
        if (format === "MMM") {
          ii = indexOf.call(this._shortMonthsParse, llc);
          if (ii !== -1) {
            return ii;
          }
          ii = indexOf.call(this._longMonthsParse, llc);
          return ii !== -1 ? ii : null;
        } else {
          ii = indexOf.call(this._longMonthsParse, llc);
          if (ii !== -1) {
            return ii;
          }
          ii = indexOf.call(this._shortMonthsParse, llc);
          return ii !== -1 ? ii : null;
        }
      }
    }

    function localeMonthsParse(monthName, format, strict) {
      var i, mom, regex;

      if (this._monthsParseExact) {
        return handleStrictParse.call(this, monthName, format, strict);
      }

      if (!this._monthsParse) {
        this._monthsParse = [];
        this._longMonthsParse = [];
        this._shortMonthsParse = [];
      }

      // TODO: add sorting
      // Sorting makes sure if one month (or abbr) is a prefix of another
      // see sorting in computeMonthsParse
      for (i = 0; i < 12; i++) {
        // make the regex if we don't have it already
        mom = createUTC([2000, i]);
        if (strict && !this._longMonthsParse[i]) {
          this._longMonthsParse[i] = new RegExp(
            "^" + this.months(mom, "").replace(".", "") + "$",
            "i"
          );
          this._shortMonthsParse[i] = new RegExp(
            "^" + this.monthsShort(mom, "").replace(".", "") + "$",
            "i"
          );
        }
        if (!strict && !this._monthsParse[i]) {
          regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
          this._monthsParse[i] = new RegExp(regex.replace(".", ""), "i");
        }
        // test the regex
        if (
          strict &&
          format === "MMMM" &&
          this._longMonthsParse[i].test(monthName)
        ) {
          return i;
        } else if (
          strict &&
          format === "MMM" &&
          this._shortMonthsParse[i].test(monthName)
        ) {
          return i;
        } else if (!strict && this._monthsParse[i].test(monthName)) {
          return i;
        }
      }
    }

    // MOMENTS

    function setMonth(mom, value) {
      var dayOfMonth;

      if (!mom.isValid()) {
        // No op
        return mom;
      }

      if (typeof value === "string") {
        if (/^\d+$/.test(value)) {
          value = toInt(value);
        } else {
          value = mom.localeData().monthsParse(value);
          // TODO: Another silent failure?
          if (!isNumber(value)) {
            return mom;
          }
        }
      }

      dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
      mom._d["set" + (mom._isUTC ? "UTC" : "") + "Month"](value, dayOfMonth);
      return mom;
    }

    function getSetMonth(value) {
      if (value != null) {
        setMonth(this, value);
        hooks.updateOffset(this, true);
        return this;
      } else {
        return get(this, "Month");
      }
    }

    function getDaysInMonth() {
      return daysInMonth(this.year(), this.month());
    }

    function monthsShortRegex(isStrict) {
      if (this._monthsParseExact) {
        if (!hasOwnProp(this, "_monthsRegex")) {
          computeMonthsParse.call(this);
        }
        if (isStrict) {
          return this._monthsShortStrictRegex;
        } else {
          return this._monthsShortRegex;
        }
      } else {
        if (!hasOwnProp(this, "_monthsShortRegex")) {
          this._monthsShortRegex = defaultMonthsShortRegex;
        }
        return this._monthsShortStrictRegex && isStrict
          ? this._monthsShortStrictRegex
          : this._monthsShortRegex;
      }
    }

    function monthsRegex(isStrict) {
      if (this._monthsParseExact) {
        if (!hasOwnProp(this, "_monthsRegex")) {
          computeMonthsParse.call(this);
        }
        if (isStrict) {
          return this._monthsStrictRegex;
        } else {
          return this._monthsRegex;
        }
      } else {
        if (!hasOwnProp(this, "_monthsRegex")) {
          this._monthsRegex = defaultMonthsRegex;
        }
        return this._monthsStrictRegex && isStrict
          ? this._monthsStrictRegex
          : this._monthsRegex;
      }
    }

    function computeMonthsParse() {
      function cmpLenRev(a, b) {
        return b.length - a.length;
      }

      var shortPieces = [],
        longPieces = [],
        mixedPieces = [],
        i,
        mom;
      for (i = 0; i < 12; i++) {
        // make the regex if we don't have it already
        mom = createUTC([2000, i]);
        shortPieces.push(this.monthsShort(mom, ""));
        longPieces.push(this.months(mom, ""));
        mixedPieces.push(this.months(mom, ""));
        mixedPieces.push(this.monthsShort(mom, ""));
      }
      // Sorting makes sure if one month (or abbr) is a prefix of another it
      // will match the longer piece.
      shortPieces.sort(cmpLenRev);
      longPieces.sort(cmpLenRev);
      mixedPieces.sort(cmpLenRev);
      for (i = 0; i < 12; i++) {
        shortPieces[i] = regexEscape(shortPieces[i]);
        longPieces[i] = regexEscape(longPieces[i]);
      }
      for (i = 0; i < 24; i++) {
        mixedPieces[i] = regexEscape(mixedPieces[i]);
      }

      this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
      this._monthsShortRegex = this._monthsRegex;
      this._monthsStrictRegex = new RegExp(
        "^(" + longPieces.join("|") + ")",
        "i"
      );
      this._monthsShortStrictRegex = new RegExp(
        "^(" + shortPieces.join("|") + ")",
        "i"
      );
    }

    // FORMATTING

    addFormatToken("Y", 0, 0, function () {
      var y = this.year();
      return y <= 9999 ? zeroFill(y, 4) : "+" + y;
    });

    addFormatToken(0, ["YY", 2], 0, function () {
      return this.year() % 100;
    });

    addFormatToken(0, ["YYYY", 4], 0, "year");
    addFormatToken(0, ["YYYYY", 5], 0, "year");
    addFormatToken(0, ["YYYYYY", 6, true], 0, "year");

    // ALIASES

    addUnitAlias("year", "y");

    // PRIORITIES

    addUnitPriority("year", 1);

    // PARSING

    addRegexToken("Y", matchSigned);
    addRegexToken("YY", match1to2, match2);
    addRegexToken("YYYY", match1to4, match4);
    addRegexToken("YYYYY", match1to6, match6);
    addRegexToken("YYYYYY", match1to6, match6);

    addParseToken(["YYYYY", "YYYYYY"], YEAR);
    addParseToken("YYYY", function (input, array) {
      array[YEAR] =
        input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
    });
    addParseToken("YY", function (input, array) {
      array[YEAR] = hooks.parseTwoDigitYear(input);
    });
    addParseToken("Y", function (input, array) {
      array[YEAR] = parseInt(input, 10);
    });

    // HELPERS

    function daysInYear(year) {
      return isLeapYear(year) ? 366 : 365;
    }

    // HOOKS

    hooks.parseTwoDigitYear = function (input) {
      return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
    };

    // MOMENTS

    var getSetYear = makeGetSet("FullYear", true);

    function getIsLeapYear() {
      return isLeapYear(this.year());
    }

    function createDate(y, m, d, h, M, s, ms) {
      // can't just apply() to create a date:
      // https://stackoverflow.com/q/181348
      var date;
      // the date constructor remaps years 0-99 to 1900-1999
      if (y < 100 && y >= 0) {
        // preserve leap years using a full 400 year cycle, then reset
        date = new Date(y + 400, m, d, h, M, s, ms);
        if (isFinite(date.getFullYear())) {
          date.setFullYear(y);
        }
      } else {
        date = new Date(y, m, d, h, M, s, ms);
      }

      return date;
    }

    function createUTCDate(y) {
      var date, args;
      // the Date.UTC function remaps years 0-99 to 1900-1999
      if (y < 100 && y >= 0) {
        args = Array.prototype.slice.call(arguments);
        // preserve leap years using a full 400 year cycle, then reset
        args[0] = y + 400;
        date = new Date(Date.UTC.apply(null, args));
        if (isFinite(date.getUTCFullYear())) {
          date.setUTCFullYear(y);
        }
      } else {
        date = new Date(Date.UTC.apply(null, arguments));
      }

      return date;
    }

    // start-of-first-week - start-of-year
    function firstWeekOffset(year, dow, doy) {
      var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
        fwd = 7 + dow - doy,
        // first-week day local weekday -- which local weekday is fwd
        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;

      return -fwdlw + fwd - 1;
    }

    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
      var localWeekday = (7 + weekday - dow) % 7,
        weekOffset = firstWeekOffset(year, dow, doy),
        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
        resYear,
        resDayOfYear;

      if (dayOfYear <= 0) {
        resYear = year - 1;
        resDayOfYear = daysInYear(resYear) + dayOfYear;
      } else if (dayOfYear > daysInYear(year)) {
        resYear = year + 1;
        resDayOfYear = dayOfYear - daysInYear(year);
      } else {
        resYear = year;
        resDayOfYear = dayOfYear;
      }

      return {
        year: resYear,
        dayOfYear: resDayOfYear,
      };
    }

    function weekOfYear(mom, dow, doy) {
      var weekOffset = firstWeekOffset(mom.year(), dow, doy),
        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
        resWeek,
        resYear;

      if (week < 1) {
        resYear = mom.year() - 1;
        resWeek = week + weeksInYear(resYear, dow, doy);
      } else if (week > weeksInYear(mom.year(), dow, doy)) {
        resWeek = week - weeksInYear(mom.year(), dow, doy);
        resYear = mom.year() + 1;
      } else {
        resYear = mom.year();
        resWeek = week;
      }

      return {
        week: resWeek,
        year: resYear,
      };
    }

    function weeksInYear(year, dow, doy) {
      var weekOffset = firstWeekOffset(year, dow, doy),
        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
      return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
    }

    // FORMATTING

    addFormatToken("w", ["ww", 2], "wo", "week");
    addFormatToken("W", ["WW", 2], "Wo", "isoWeek");

    // ALIASES

    addUnitAlias("week", "w");
    addUnitAlias("isoWeek", "W");

    // PRIORITIES

    addUnitPriority("week", 5);
    addUnitPriority("isoWeek", 5);

    // PARSING

    addRegexToken("w", match1to2);
    addRegexToken("ww", match1to2, match2);
    addRegexToken("W", match1to2);
    addRegexToken("WW", match1to2, match2);

    addWeekParseToken(
      ["w", "ww", "W", "WW"],
      function (input, week, config, token) {
        week[token.substr(0, 1)] = toInt(input);
      }
    );

    // HELPERS

    // LOCALES

    function localeWeek(mom) {
      return weekOfYear(mom, this._week.dow, this._week.doy).week;