diff --git a/angular.json b/angular.json
index ad23b3847e..5704921f5e 100644
--- a/angular.json
+++ b/angular.json
@@ -37,7 +37,7 @@
               "aot": true,
               "extractLicenses": true,
               "vendorChunk": true,
-              "buildOptimizer": false,
+              "buildOptimizer": true,
               "fileReplacements": [
                 {
                   "replace": "demo/src/environments/environment.ts",
diff --git a/src/chronos/format/format.ts b/src/chronos/format/format.ts
index 65466b58eb..cb852a6d79 100644
--- a/src/chronos/format/format.ts
+++ b/src/chronos/format/format.ts
@@ -19,6 +19,7 @@ export function addFormatToken(token: string,
                                padded: [string, number, boolean],
                                ordinal: string,
                                callback: DateFormatterFn): void {
+
   if (token) {
     formatTokenFunctions[token] = callback;
   }
@@ -36,7 +37,9 @@ export function addFormatToken(token: string,
   }
 }
 
-export function makeFormatFunction(format: string): (date: Date, locale: Locale, isUTC?: boolean, offset?: number) => string {
+export function makeFormatFunction(format: string):
+  (date: Date, locale: Locale, isUTC?: boolean, offset?: number) => string {
+
   const array: string[] = format.match(formattingTokens);
   const length = array.length;
 
diff --git a/src/chronos/locale/locales.ts b/src/chronos/locale/locales.ts
index 232b8c1a82..22768f80c6 100644
--- a/src/chronos/locale/locales.ts
+++ b/src/chronos/locale/locales.ts
@@ -4,6 +4,22 @@ import { baseConfig } from './locale.defaults';
 import { hasOwnProp, isArray, isObject, isString, isUndefined, toInt } from '../utils/type-checks';
 import { compareArrays } from '../utils/compare-arrays';
 
+import { initWeek } from '../units/week';
+import { initWeekYear } from '../units/week-year';
+import { initYear } from '../units/year';
+import { initTimezone } from '../units/timezone';
+import { initTimestamp } from '../units/timestamp';
+import { initSecond } from '../units/second';
+import { initQuarter } from '../units/quarter';
+import { initOffset } from '../units/offset';
+import { initMinute } from '../units/minute';
+import { initMillisecond } from '../units/millisecond';
+import { initMonth } from '../units/month';
+import { initHour } from '../units/hour';
+import { initDayOfYear } from '../units/day-of-year';
+import { initDayOfWeek } from '../units/day-of-week';
+import { initDayOfMonth } from '../units/day-of-month';
+
 const locales: { [key: string]: Locale } = {};
 const localeFamilies: { [key: string]: {name: string; config: LocaleData}[] } = {};
 let globalLocale: Locale;
@@ -198,6 +214,8 @@ export function updateLocale(name: string, config?: LocaleData): Locale {
 
 // returns locale data
 export function getLocale(key?: string | string[]): Locale {
+  setDefaultLocale();
+
   if (!key) {
     return globalLocale;
   }
@@ -211,16 +229,38 @@ export function listLocales(): string[] {
   return Object.keys(locales);
 }
 
-// define default locale
-getSetGlobalLocale('en', {
-  dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
-  ordinal(num: number): string {
-    const b = num % 10;
-    const output =
-      toInt((num % 100) / 10) === 1
-        ? 'th'
-        : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';
-
-    return num + output;
+function setDefaultLocale(): void {
+  if (locales[`en`]) {
+
+    return undefined;
   }
-});
+
+  getSetGlobalLocale('en', {
+    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+    ordinal(num: number): string {
+      const b = num % 10;
+      const output =
+        toInt((num % 100) / 10) === 1
+          ? 'th'
+          : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';
+
+      return num + output;
+    }
+  });
+
+  initWeek();
+  initWeekYear();
+  initYear();
+  initTimezone();
+  initTimestamp();
+  initSecond();
+  initQuarter();
+  initOffset();
+  initMonth();
+  initMinute();
+  initMillisecond();
+  initHour();
+  initDayOfYear();
+  initDayOfWeek();
+  initDayOfMonth();
+}
diff --git a/src/chronos/public_api.ts b/src/chronos/public_api.ts
index d768018d2b..a06016f86f 100644
--- a/src/chronos/public_api.ts
+++ b/src/chronos/public_api.ts
@@ -3,19 +3,20 @@ import './units/index';
 export { add, subtract } from './moment/add-subtract';
 
 export {
-  getDay,
-  isFirstDayOfWeek,
-  isSameYear,
-  isSameDay,
-  isSameMonth,
-  getFullYear,
-  getFirstDayOfMonth,
-  getMonth
+getDay,
+isFirstDayOfWeek,
+isSameYear,
+isSameDay,
+isSameMonth,
+getFullYear,
+getFirstDayOfMonth,
+getMonth
 } from './utils/date-getters';
 
 export { parseDate } from './create/local';
 export { formatDate } from './format';
 
+
 export {
   listLocales,
   getLocale,
diff --git a/src/chronos/units/day-of-month.ts b/src/chronos/units/day-of-month.ts
index 484b237783..c0555bba36 100644
--- a/src/chronos/units/day-of-month.ts
+++ b/src/chronos/units/day-of-month.ts
@@ -9,32 +9,39 @@ import { addUnitAlias } from './aliases';
 import { addUnitPriority } from './priorities';
 import { DateParsingConfig } from '../create/parsing.types';
 
+
+export function initDayOfMonth() {
 // FORMATTING
 
-addFormatToken('D', ['DD', 2, false], 'Do',
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getDate(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('D', ['DD', 2, false], 'Do',
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getDate(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('date', 'D');
+  addUnitAlias('date', 'D');
 
 // PRIOROITY
-addUnitPriority('date', 9);
+  addUnitPriority('date', 9);
 
 // PARSING
 
-addRegexToken('D', match1to2);
-addRegexToken('DD', match1to2, match2);
-addRegexToken('Do', function (isStrict, locale) {
-  return locale._dayOfMonthOrdinalParse || locale._ordinalParse;
-});
+  addRegexToken('D', match1to2);
+  addRegexToken('DD', match1to2, match2);
+  addRegexToken('Do', function(isStrict, locale) {
+    return locale._dayOfMonthOrdinalParse || locale._ordinalParse;
+  });
 
-addParseToken(['D', 'DD'], DATE);
-addParseToken('Do',
-  function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-    array[DATE] = toInt(input.match(match1to2)[0]);
+  addParseToken(['D', 'DD'], DATE);
+  addParseToken(
+    'Do',
+    function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+      array[DATE] = toInt(input.match(match1to2)[0]);
 
-    return config;
-  });
+      return config;
+    }
+  );
+}
diff --git a/src/chronos/units/day-of-week.ts b/src/chronos/units/day-of-week.ts
index f0205473be..a5518abcdf 100644
--- a/src/chronos/units/day-of-week.ts
+++ b/src/chronos/units/day-of-week.ts
@@ -12,86 +12,102 @@ import { DateParsingConfig } from '../create/parsing.types';
 import { add } from '../moment/add-subtract';
 import { getLocale } from '../locale/locales';
 
+
+export function initDayOfWeek() {
 // FORMATTING
 
-addFormatToken('d', null, 'do',
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getDay(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('d', null, 'do',
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getDay(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
-addFormatToken('dd', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.locale.weekdaysMin(date, opts.format, opts.isUTC);
-  });
+  addFormatToken('dd', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.locale.weekdaysMin(date, opts.format, opts.isUTC);
+    }
+  );
 
-addFormatToken('ddd', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.locale.weekdaysShort(date, opts.format, opts.isUTC);
-  });
+  addFormatToken('ddd', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.locale.weekdaysShort(date, opts.format, opts.isUTC);
+    }
+  );
 
-addFormatToken('dddd', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.locale.weekdays(date, opts.format, opts.isUTC);
-  });
+  addFormatToken('dddd', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.locale.weekdays(date, opts.format, opts.isUTC);
+    }
+  );
 
-addFormatToken('e', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getLocaleDayOfWeek(date, opts.locale, opts.isUTC).toString(10);
-    // return getDay(date, opts.isUTC).toString(10);
-  });
-addFormatToken('E', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getISODayOfWeek(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('e', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getLocaleDayOfWeek(date, opts.locale, opts.isUTC)
+        .toString(10);
+      // return getDay(date, opts.isUTC).toString(10);
+    }
+  );
+  addFormatToken('E', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getISODayOfWeek(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('day', 'd');
-addUnitAlias('weekday', 'e');
-addUnitAlias('isoWeekday', 'E');
+  addUnitAlias('day', 'd');
+  addUnitAlias('weekday', 'e');
+  addUnitAlias('isoWeekday', 'E');
 
 // PRIORITY
-addUnitPriority('day', 11);
-addUnitPriority('weekday', 11);
-addUnitPriority('isoWeekday', 11);
+  addUnitPriority('day', 11);
+  addUnitPriority('weekday', 11);
+  addUnitPriority('isoWeekday', 11);
 
 // PARSING
 
-addRegexToken('d', match1to2);
-addRegexToken('e', match1to2);
-addRegexToken('E', match1to2);
-
-addRegexToken('dd', function (isStrict: boolean, locale: Locale): RegExp {
-  return locale.weekdaysMinRegex(isStrict);
-});
-
-addRegexToken('ddd', function (isStrict: boolean, locale: Locale): RegExp {
-  return locale.weekdaysShortRegex(isStrict);
-});
-addRegexToken('dddd', function (isStrict: boolean, locale: Locale): RegExp {
-  return locale.weekdaysRegex(isStrict);
-});
-
-addWeekParseToken(['dd', 'ddd', 'dddd'],
-  function (input: string, week: WeekParsing, config: DateParsingConfig, token) {
-    const weekday = config._locale.weekdaysParse(input, token, config._strict);
-    // if we didn't get a weekday name, mark the date as invalid
-    if (weekday != null) {
-      week.d = weekday;
-    } else {
-      getParsingFlags(config).invalidWeekday = !!input;
-    }
+  addRegexToken('d', match1to2);
+  addRegexToken('e', match1to2);
+  addRegexToken('E', match1to2);
 
-    return config;
+  addRegexToken('dd', function(isStrict: boolean, locale: Locale): RegExp {
+    return locale.weekdaysMinRegex(isStrict);
   });
 
-addWeekParseToken(['d', 'e', 'E'],
-  function (input: string, week: WeekParsing, config: DateParsingConfig, token: string): DateParsingConfig {
-    week[token] = toInt(input);
-
-    return config;
+  addRegexToken('ddd', function(isStrict: boolean, locale: Locale): RegExp {
+    return locale.weekdaysShortRegex(isStrict);
+  });
+  addRegexToken('dddd', function(isStrict: boolean, locale: Locale): RegExp {
+    return locale.weekdaysRegex(isStrict);
   });
 
+  addWeekParseToken(
+    ['dd', 'ddd', 'dddd'],
+    function(input: string, week: WeekParsing, config: DateParsingConfig, token) {
+      const weekday = config._locale.weekdaysParse(input, token, config._strict);
+      // if we didn't get a weekday name, mark the date as invalid
+      if (weekday != null) {
+        week.d = weekday;
+      } else {
+        getParsingFlags(config).invalidWeekday = !!input;
+      }
+
+      return config;
+    }
+  );
+
+  addWeekParseToken(
+    ['d', 'e', 'E'],
+    function(input: string, week: WeekParsing, config: DateParsingConfig, token: string): DateParsingConfig {
+      week[token] = toInt(input);
+
+      return config;
+    }
+  );
+}
+
 // HELPERS
 
 export function parseWeekday(input: string | number, locale: Locale): number {
diff --git a/src/chronos/units/day-of-year.ts b/src/chronos/units/day-of-year.ts
index de3278d19d..e65441229c 100644
--- a/src/chronos/units/day-of-year.ts
+++ b/src/chronos/units/day-of-year.ts
@@ -9,30 +9,37 @@ import { DateParsingConfig } from '../create/parsing.types';
 import { toInt } from '../utils/type-checks';
 import { add } from '../moment/add-subtract';
 
+
+export function initDayOfYear() {
 // FORMATTING
 
-addFormatToken('DDD', ['DDDD', 3, false], 'DDDo',
-  function (date: Date): string {
-    return getDayOfYear(date).toString(10);
-  });
+  addFormatToken('DDD', ['DDDD', 3, false], 'DDDo',
+    function(date: Date): string {
+      return getDayOfYear(date)
+        .toString(10);
+    }
+  );
 
 
 // ALIASES
 
-addUnitAlias('dayOfYear', 'DDD');
+  addUnitAlias('dayOfYear', 'DDD');
 
 // PRIORITY
 
-addUnitPriority('dayOfYear', 4);
+  addUnitPriority('dayOfYear', 4);
 
-addRegexToken('DDD', match1to3);
-addRegexToken('DDDD', match3);
-addParseToken(['DDD', 'DDDD'],
-  function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-    config._dayOfYear = toInt(input);
+  addRegexToken('DDD', match1to3);
+  addRegexToken('DDDD', match3);
+  addParseToken(
+    ['DDD', 'DDDD'],
+    function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+      config._dayOfYear = toInt(input);
 
-    return config;
-  });
+      return config;
+    }
+  );
+}
 
 export function getDayOfYear(date: Date, isUTC?: boolean): number {
   const date1 = +startOf(date, 'day', isUTC);
diff --git a/src/chronos/units/hour.ts b/src/chronos/units/hour.ts
index e259b74361..cceee71b7d 100644
--- a/src/chronos/units/hour.ts
+++ b/src/chronos/units/hour.ts
@@ -12,152 +12,169 @@ import { getParsingFlags } from '../create/parsing-flags';
 import { addUnitPriority } from './priorities';
 import { addUnitAlias } from './aliases';
 
+
+export function initHour() {
 // FORMATTING
 
-function hFormat(date: Date, isUTC: boolean): number {
-  return getHours(date, isUTC) % 12 || 12;
-}
+  function hFormat(date: Date, isUTC: boolean): number {
+    return getHours(date, isUTC) % 12 || 12;
+  }
+
+  function kFormat(date: Date, isUTC: boolean): number {
+    return getHours(date, isUTC) || 24;
+  }
+
+  addFormatToken('H', ['HH', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getHours(date, opts.isUTC)
+        .toString(10);
+    }
+  );
+  addFormatToken('h', ['hh', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return hFormat(date, opts.isUTC)
+        .toString(10);
+    }
+  );
+  addFormatToken('k', ['kk', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return kFormat(date, opts.isUTC)
+        .toString(10);
+    }
+  );
+
+  addFormatToken('hmm', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      const _h = hFormat(date, opts.isUTC);
+      const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+
+      return `${_h}${_mm}`;
+    }
+  );
+
+  addFormatToken('hmmss', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      const _h = hFormat(date, opts.isUTC);
+      const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+      const _ss = zeroFill(getSeconds(date, opts.isUTC), 2);
+
+      return `${_h}${_mm}${_ss}`;
+    }
+  );
+
+  addFormatToken('Hmm', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      const _H = getHours(date, opts.isUTC);
+      const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+
+      return `${_H}${_mm}`;
+    }
+  );
+
+  addFormatToken('Hmmss', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      const _H = getHours(date, opts.isUTC);
+      const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+      const _ss = zeroFill(getSeconds(date, opts.isUTC), 2);
+
+      return `${_H}${_mm}${_ss}`;
+    }
+  );
+
+  function meridiem(token: string, lowercase: boolean): void {
+    addFormatToken(token, null, null,
+      function(date: Date, opts: DateFormatterOptions): string {
+        return opts.locale.meridiem(getHours(date, opts.isUTC), getMinutes(date, opts.isUTC), lowercase);
+      }
+    );
+  }
+
+  meridiem('a', true);
+  meridiem('A', false);
 
-function kFormat(date: Date, isUTC: boolean): number {
-  return getHours(date, isUTC) || 24;
-}
-
-addFormatToken('H', ['HH', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getHours(date, opts.isUTC).toString(10);
-  });
-addFormatToken('h', ['hh', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return hFormat(date, opts.isUTC).toString(10);
-  });
-addFormatToken('k', ['kk', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return kFormat(date, opts.isUTC).toString(10);
-  });
+// ALIASES
 
-addFormatToken('hmm', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    const _h = hFormat(date, opts.isUTC);
-    const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+  addUnitAlias('hour', 'h');
 
-    return `${_h}${_mm}`;
-  });
+// PRIORITY
+  addUnitPriority('hour', 13);
 
-addFormatToken('hmmss', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    const _h = hFormat(date, opts.isUTC);
-    const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
-    const _ss = zeroFill(getSeconds(date, opts.isUTC), 2);
 
-    return `${_h}${_mm}${_ss}`;
-  });
+// PARSING
 
-addFormatToken('Hmm', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    const _H = getHours(date, opts.isUTC);
-    const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
+  function matchMeridiem(isStrict: boolean, locale: Locale): RegExp {
+    return locale._meridiemParse;
+  }
+
+  addRegexToken('a', matchMeridiem);
+  addRegexToken('A', matchMeridiem);
+  addRegexToken('H', match1to2);
+  addRegexToken('h', match1to2);
+  addRegexToken('k', match1to2);
+  addRegexToken('HH', match1to2, match2);
+  addRegexToken('hh', match1to2, match2);
+  addRegexToken('kk', match1to2, match2);
+
+  addRegexToken('hmm', match3to4);
+  addRegexToken('hmmss', match5to6);
+  addRegexToken('Hmm', match3to4);
+  addRegexToken('Hmmss', match5to6);
+
+  addParseToken(['H', 'HH'], HOUR);
+  addParseToken(
+    ['k', 'kk'],
+    function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+      const kInput = toInt(input);
+      array[HOUR] = kInput === 24 ? 0 : kInput;
+
+      return config;
+    }
+  );
+  addParseToken(['a', 'A'], function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    config._isPm = config._locale.isPM(input);
+    config._meridiem = input;
 
-    return `${_H}${_mm}`;
+    return config;
   });
+  addParseToken(['h', 'hh'], function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    array[HOUR] = toInt(input);
+    getParsingFlags(config).bigHour = true;
 
-addFormatToken('Hmmss', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    const _H = getHours(date, opts.isUTC);
-    const _mm = zeroFill(getMinutes(date, opts.isUTC), 2);
-    const _ss = zeroFill(getSeconds(date, opts.isUTC), 2);
-
-    return `${_H}${_mm}${_ss}`;
+    return config;
   });
+  addParseToken('hmm', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    const pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+    getParsingFlags(config).bigHour = true;
 
-function meridiem(token: string, lowercase: boolean): void {
-  addFormatToken(token, null, null,
-    function (date: Date, opts: DateFormatterOptions): string {
-      return opts.locale.meridiem(getHours(date, opts.isUTC), getMinutes(date, opts.isUTC), lowercase);
-    });
-}
-
-meridiem('a', true);
-meridiem('A', false);
-
-// ALIASES
-
-addUnitAlias('hour', 'h');
-
-// PRIORITY
-addUnitPriority('hour', 13);
-
-
-// PARSING
+    return config;
+  });
+  addParseToken('hmmss', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    const pos1 = input.length - 4;
+    const pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+    getParsingFlags(config).bigHour = true;
 
-function matchMeridiem(isStrict: boolean, locale: Locale): RegExp {
-  return locale._meridiemParse;
-}
+    return config;
+  });
+  addParseToken('Hmm', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    const pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
 
-addRegexToken('a', matchMeridiem);
-addRegexToken('A', matchMeridiem);
-addRegexToken('H', match1to2);
-addRegexToken('h', match1to2);
-addRegexToken('k', match1to2);
-addRegexToken('HH', match1to2, match2);
-addRegexToken('hh', match1to2, match2);
-addRegexToken('kk', match1to2, match2);
-
-addRegexToken('hmm', match3to4);
-addRegexToken('hmmss', match5to6);
-addRegexToken('Hmm', match3to4);
-addRegexToken('Hmmss', match5to6);
-
-addParseToken(['H', 'HH'], HOUR);
-addParseToken(['k', 'kk'],
-  function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-    const kInput = toInt(input);
-    array[HOUR] = kInput === 24 ? 0 : kInput;
+    return config;
+  });
+  addParseToken('Hmmss', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    const pos1 = input.length - 4;
+    const pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
 
     return config;
   });
-addParseToken(['a', 'A'], function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  config._isPm = config._locale.isPM(input);
-  config._meridiem = input;
-
-  return config;
-});
-addParseToken(['h', 'hh'], function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  array[HOUR] = toInt(input);
-  getParsingFlags(config).bigHour = true;
-
-  return config;
-});
-addParseToken('hmm', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  const pos = input.length - 2;
-  array[HOUR] = toInt(input.substr(0, pos));
-  array[MINUTE] = toInt(input.substr(pos));
-  getParsingFlags(config).bigHour = true;
-
-  return config;
-});
-addParseToken('hmmss', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  const pos1 = input.length - 4;
-  const pos2 = input.length - 2;
-  array[HOUR] = toInt(input.substr(0, pos1));
-  array[MINUTE] = toInt(input.substr(pos1, 2));
-  array[SECOND] = toInt(input.substr(pos2));
-  getParsingFlags(config).bigHour = true;
-
-  return config;
-});
-addParseToken('Hmm', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  const pos = input.length - 2;
-  array[HOUR] = toInt(input.substr(0, pos));
-  array[MINUTE] = toInt(input.substr(pos));
-
-  return config;
-});
-addParseToken('Hmmss', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  const pos1 = input.length - 4;
-  const pos2 = input.length - 2;
-  array[HOUR] = toInt(input.substr(0, pos1));
-  array[MINUTE] = toInt(input.substr(pos1, 2));
-  array[SECOND] = toInt(input.substr(pos2));
-
-  return config;
-});
+
+}
diff --git a/src/chronos/units/millisecond.ts b/src/chronos/units/millisecond.ts
index 1924751cba..d552181334 100644
--- a/src/chronos/units/millisecond.ts
+++ b/src/chronos/units/millisecond.ts
@@ -12,73 +12,84 @@ import { addUnitPriority } from './priorities';
 import { DateParsingConfig } from '../create/parsing.types';
 import { getMilliseconds } from '../utils/date-getters';
 
-addFormatToken('S', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (~~(getMilliseconds(date, opts.isUTC) / 100)).toString(10);
-  });
-
-addFormatToken(null, ['SS', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (~~(getMilliseconds(date, opts.isUTC) / 10)).toString(10);
-  });
-
-addFormatToken(null, ['SSS', 3, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC)).toString(10);
-  });
-addFormatToken(null, ['SSSS', 4, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 10).toString(10);
-  });
-addFormatToken(null, ['SSSSS', 5, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 100).toString(10);
-  });
-addFormatToken(null, ['SSSSSS', 6, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 1000).toString(10);
-  });
-addFormatToken(null, ['SSSSSSS', 7, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 10000).toString(10);
-  });
-addFormatToken(null, ['SSSSSSSS', 8, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 100000).toString(10);
-  });
-addFormatToken(null, ['SSSSSSSSS', 9, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMilliseconds(date, opts.isUTC) * 1000000).toString(10);
-  });
+
+export function initMillisecond() {
+  addFormatToken('S', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (~~(getMilliseconds(date, opts.isUTC) / 100)).toString(10);
+    }
+  );
+
+  addFormatToken(null, ['SS', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (~~(getMilliseconds(date, opts.isUTC) / 10)).toString(10);
+    }
+  );
+
+  addFormatToken(null, ['SSS', 3, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC)).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSS', 4, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 10).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSSS', 5, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 100).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSSSS', 6, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 1000).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSSSSS', 7, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 10000).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSSSSSS', 8, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 100000).toString(10);
+    }
+  );
+  addFormatToken(null, ['SSSSSSSSS', 9, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMilliseconds(date, opts.isUTC) * 1000000).toString(10);
+    }
+  );
 
 
 // ALIASES
 
-addUnitAlias('millisecond', 'ms');
+  addUnitAlias('millisecond', 'ms');
 
 // PRIORITY
 
-addUnitPriority('millisecond', 16);
+  addUnitPriority('millisecond', 16);
 
 // PARSING
 
-addRegexToken('S', match1to3, match1);
-addRegexToken('SS', match1to3, match2);
-addRegexToken('SSS', match1to3, match3);
+  addRegexToken('S', match1to3, match1);
+  addRegexToken('SS', match1to3, match2);
+  addRegexToken('SSS', match1to3, match3);
 
-let token;
-for (token = 'SSSS'; token.length <= 9; token += 'S') {
-  addRegexToken(token, matchUnsigned);
-}
+  let token;
+  for (token = 'SSSS'; token.length <= 9; token += 'S') {
+    addRegexToken(token, matchUnsigned);
+  }
 
-function parseMs(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  array[MILLISECOND] = toInt(parseFloat(`0.${input}`) * 1000);
+  function parseMs(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    array[MILLISECOND] = toInt(parseFloat(`0.${input}`) * 1000);
 
-  return config;
-}
+    return config;
+  }
 
-for (token = 'S'; token.length <= 9; token += 'S') {
-  addParseToken(token, parseMs);
-}
+  for (token = 'S'; token.length <= 9; token += 'S') {
+    addParseToken(token, parseMs);
+  }
 // MOMENTS
-
+}
diff --git a/src/chronos/units/minute.ts b/src/chronos/units/minute.ts
index ee839e6bb1..2d5b7af20d 100644
--- a/src/chronos/units/minute.ts
+++ b/src/chronos/units/minute.ts
@@ -7,23 +7,28 @@ import { addUnitPriority } from './priorities';
 import { addUnitAlias } from './aliases';
 import { DateFormatterOptions } from '../types';
 
+
+export function initMinute() {
 // FORMATTING
 
-addFormatToken('m', ['mm', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getMinutes(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('m', ['mm', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getMinutes(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('minute', 'm');
+  addUnitAlias('minute', 'm');
 
 // PRIORITY
 
-addUnitPriority('minute', 14);
+  addUnitPriority('minute', 14);
 
 // PARSING
 
-addRegexToken('m', match1to2);
-addRegexToken('mm', match1to2, match2);
-addParseToken(['m', 'mm'], MINUTE);
+  addRegexToken('m', match1to2);
+  addRegexToken('mm', match1to2, match2);
+  addParseToken(['m', 'mm'], MINUTE);
+}
diff --git a/src/chronos/units/month.ts b/src/chronos/units/month.ts
index f76bbeb69a..c1989aef5c 100644
--- a/src/chronos/units/month.ts
+++ b/src/chronos/units/month.ts
@@ -25,59 +25,65 @@ export function daysInMonth(year: number, month: number): number {
     : (31 - modMonth % 7 % 2);
 }
 
+export function initMonth() {
 // FORMATTING
 
-addFormatToken('M', ['MM', 2, false], 'Mo',
-  function (date: Date, opts: DateFormatterOptions): string {
-    return (getMonth(date, opts.isUTC) + 1).toString(10);
-  });
+  addFormatToken('M', ['MM', 2, false], 'Mo',
+    function(date: Date, opts: DateFormatterOptions): string {
+      return (getMonth(date, opts.isUTC) + 1).toString(10);
+    }
+  );
 
-addFormatToken('MMM', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.locale.monthsShort(date, opts.format, opts.isUTC);
-  });
+  addFormatToken('MMM', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.locale.monthsShort(date, opts.format, opts.isUTC);
+    }
+  );
 
-addFormatToken('MMMM', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.locale.months(date, opts.format, opts.isUTC);
-  });
+  addFormatToken('MMMM', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.locale.months(date, opts.format, opts.isUTC);
+    }
+  );
 
 
 // ALIASES
 
-addUnitAlias('month', 'M');
+  addUnitAlias('month', 'M');
 
 // PRIORITY
 
-addUnitPriority('month', 8);
+  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: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  array[MONTH] = toInt(input) - 1;
-
-  return config;
-});
-
-addParseToken(['MMM', 'MMMM'],
-  function (input: string, array: DateArray, config: DateParsingConfig, token: string): DateParsingConfig {
-    const 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;
-    }
+  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: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    array[MONTH] = toInt(input) - 1;
 
     return config;
   });
 
+  addParseToken(
+    ['MMM', 'MMMM'],
+    function(input: string, array: DateArray, config: DateParsingConfig, token: string): DateParsingConfig {
+      const 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;
+      }
+
+      return config;
+    }
+  );
+}
diff --git a/src/chronos/units/offset.ts b/src/chronos/units/offset.ts
index df5362d639..b7cf85e1a4 100644
--- a/src/chronos/units/offset.ts
+++ b/src/chronos/units/offset.ts
@@ -25,19 +25,21 @@ function addOffsetFormatToken(token: string, separator: string): void {
   });
 }
 
-addOffsetFormatToken('Z', ':');
-addOffsetFormatToken('ZZ', '');
+export function initOffset() {
+  addOffsetFormatToken('Z', ':');
+  addOffsetFormatToken('ZZ', '');
 
 // PARSING
 
-addRegexToken('Z', matchShortOffset);
-addRegexToken('ZZ', matchShortOffset);
-addParseToken(['Z', 'ZZ'], function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  config._useUTC = true;
-  config._tzm = offsetFromString(matchShortOffset, input);
+  addRegexToken('Z', matchShortOffset);
+  addRegexToken('ZZ', matchShortOffset);
+  addParseToken(['Z', 'ZZ'], function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    config._useUTC = true;
+    config._tzm = offsetFromString(matchShortOffset, input);
 
-  return config;
-});
+    return config;
+  });
+}
 
 // HELPERS
 
diff --git a/src/chronos/units/quarter.ts b/src/chronos/units/quarter.ts
index 6090e19d6b..c11a58d808 100644
--- a/src/chronos/units/quarter.ts
+++ b/src/chronos/units/quarter.ts
@@ -10,29 +10,34 @@ import { addUnitAlias } from './aliases';
 import { DateParsingConfig } from '../create/parsing.types';
 import { setMonth } from '../utils/date-setters';
 
+
+export function initQuarter() {
 // FORMATTING
 
-addFormatToken('Q', null, 'Qo',
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getQuarter(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('Q', null, 'Qo',
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getQuarter(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('quarter', 'Q');
+  addUnitAlias('quarter', 'Q');
 
 // PRIORITY
 
-addUnitPriority('quarter', 7);
+  addUnitPriority('quarter', 7);
 
 // PARSING
 
-addRegexToken('Q', match1);
-addParseToken('Q', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  array[MONTH] = (toInt(input) - 1) * 3;
+  addRegexToken('Q', match1);
+  addParseToken('Q', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    array[MONTH] = (toInt(input) - 1) * 3;
 
-  return config;
-});
+    return config;
+  });
+}
 
 // MOMENTS
 
diff --git a/src/chronos/units/second.ts b/src/chronos/units/second.ts
index 86f2ff0e5f..0726fcf8b0 100644
--- a/src/chronos/units/second.ts
+++ b/src/chronos/units/second.ts
@@ -7,23 +7,28 @@ import { addUnitAlias } from './aliases';
 import { addUnitPriority } from './priorities';
 import { DateFormatterOptions } from '../types';
 
+
+export function initSecond() {
 // FORMATTING
 
-addFormatToken('s', ['ss', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getSeconds(date, opts.isUTC).toString(10);
-  });
+  addFormatToken('s', ['ss', 2, false], null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getSeconds(date, opts.isUTC)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('second', 's');
+  addUnitAlias('second', 's');
 
 // PRIORITY
 
-addUnitPriority('second', 15);
+  addUnitPriority('second', 15);
 
 // PARSING
 
-addRegexToken('s', match1to2);
-addRegexToken('ss', match1to2, match2);
-addParseToken(['s', 'ss'], SECOND);
+  addRegexToken('s', match1to2);
+  addRegexToken('ss', match1to2, match2);
+  addParseToken(['s', 'ss'], SECOND);
+}
diff --git a/src/chronos/units/timestamp.ts b/src/chronos/units/timestamp.ts
index 1202da1754..5a272f7c19 100644
--- a/src/chronos/units/timestamp.ts
+++ b/src/chronos/units/timestamp.ts
@@ -6,27 +6,32 @@ import { toInt } from '../utils/type-checks';
 import { DateArray } from '../types';
 import { DateParsingConfig } from '../create/parsing.types';
 
+
+export function initTimestamp() {
 // FORMATTING
 
-addFormatToken('X', null, null, function (date: Date): string {
-  return unix(date).toString(10);
-});
-addFormatToken('x', null, null, function (date: Date): string {
-  return date.valueOf().toString(10);
-});
+  addFormatToken('X', null, null, function(date: Date): string {
+    return unix(date)
+      .toString(10);
+  });
+  addFormatToken('x', null, null, function(date: Date): string {
+    return date.valueOf()
+      .toString(10);
+  });
 
 // PARSING
 
-addRegexToken('x', matchSigned);
-addRegexToken('X', matchTimestamp);
+  addRegexToken('x', matchSigned);
+  addRegexToken('X', matchTimestamp);
 
-addParseToken('X', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  config._d = new Date(parseFloat(input) * 1000);
+  addParseToken('X', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    config._d = new Date(parseFloat(input) * 1000);
 
-  return config;
-});
-addParseToken('x', function (input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
-  config._d = new Date(toInt(input));
+    return config;
+  });
+  addParseToken('x', function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {
+    config._d = new Date(toInt(input));
 
-  return config;
-});
+    return config;
+  });
+}
diff --git a/src/chronos/units/timezone.ts b/src/chronos/units/timezone.ts
index 103c303bb1..613054caf9 100644
--- a/src/chronos/units/timezone.ts
+++ b/src/chronos/units/timezone.ts
@@ -3,15 +3,19 @@ import { DateFormatterOptions } from '../types';
 
 // todo: add support for timezones
 
-// FORMATTING
-addFormatToken('z', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.isUTC ? 'UTC' : '';
-  });
-addFormatToken('zz', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    return opts.isUTC ? 'Coordinated Universal Time' : '';
-  });
+export function initTimezone() {
+  // FORMATTING
+  addFormatToken('z', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.isUTC ? 'UTC' : '';
+    }
+  );
+  addFormatToken('zz', null, null,
+    function(date: Date, opts: DateFormatterOptions): string {
+      return opts.isUTC ? 'Coordinated Universal Time' : '';
+    }
+  );
+}
 
 // MOMENTS
 
diff --git a/src/chronos/units/week-year.ts b/src/chronos/units/week-year.ts
index 3e8051d09e..610f61ea42 100644
--- a/src/chronos/units/week-year.ts
+++ b/src/chronos/units/week-year.ts
@@ -17,69 +17,73 @@ import { DateFormatterFn, DateFormatterOptions, WeekParsing } from '../types';
 
 // FORMATTING
 
-addFormatToken(null, ['gg', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-    // return this.weekYear() % 100;
-    return (getWeekYear(date, opts.locale) % 100).toString();
-  });
-
-addFormatToken(null, ['GG', 2, false], null,
-  function (date: Date): string {
-    // return this.isoWeekYear() % 100;
-    return (getISOWeekYear(date) % 100).toString();
-  });
-
-function addWeekYearFormatToken(token: string, getter: DateFormatterFn): void {
-  addFormatToken(null, [token, token.length, false], null, getter);
-}
-
-function _getWeekYearFormatCb(date: Date, opts: DateFormatterOptions): string {
-  return getWeekYear(date, opts.locale).toString();
-}
-
-function _getISOWeekYearFormatCb(date: Date): string {
-  return getISOWeekYear(date).toString();
-}
-
-addWeekYearFormatToken('gggg', _getWeekYearFormatCb);
-addWeekYearFormatToken('ggggg', _getWeekYearFormatCb);
-addWeekYearFormatToken('GGGG', _getISOWeekYearFormatCb);
-addWeekYearFormatToken('GGGGG', _getISOWeekYearFormatCb);
+export function initWeekYear() {
+  addFormatToken(null, ['gg', 2, false], null,
+    function (date: Date, opts: DateFormatterOptions): string {
+      // return this.weekYear() % 100;
+      return (getWeekYear(date, opts.locale) % 100).toString();
+    }
+  );
+
+  addFormatToken(null, ['GG', 2, false], null,
+    function (date: Date): string {
+      // return this.isoWeekYear() % 100;
+      return (getISOWeekYear(date) % 100).toString();
+    }
+  );
+
+  addWeekYearFormatToken('gggg', _getWeekYearFormatCb);
+  addWeekYearFormatToken('ggggg', _getWeekYearFormatCb);
+  addWeekYearFormatToken('GGGG', _getISOWeekYearFormatCb);
+  addWeekYearFormatToken('GGGGG', _getISOWeekYearFormatCb);
 
 // ALIASES
 
-addUnitAlias('weekYear', 'gg');
-addUnitAlias('isoWeekYear', 'GG');
+  addUnitAlias('weekYear', 'gg');
+  addUnitAlias('isoWeekYear', 'GG');
 
 // PRIORITY
 
-addUnitPriority('weekYear', 1);
-addUnitPriority('isoWeekYear', 1);
+  addUnitPriority('weekYear', 1);
+  addUnitPriority('isoWeekYear', 1);
 
 
 // PARSING
 
-addRegexToken('G', matchSigned);
-addRegexToken('g', matchSigned);
-addRegexToken('GG', match1to2, match2);
-addRegexToken('gg', match1to2, match2);
-addRegexToken('GGGG', match1to4, match4);
-addRegexToken('gggg', match1to4, match4);
-addRegexToken('GGGGG', match1to6, match6);
-addRegexToken('ggggg', match1to6, match6);
+  addRegexToken('G', matchSigned);
+  addRegexToken('g', matchSigned);
+  addRegexToken('GG', match1to2, match2);
+  addRegexToken('gg', match1to2, match2);
+  addRegexToken('GGGG', match1to4, match4);
+  addRegexToken('gggg', match1to4, match4);
+  addRegexToken('GGGGG', match1to6, match6);
+  addRegexToken('ggggg', match1to6, match6);
+
+  addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'],
+    function (input, week: WeekParsing, config, token) {
+      week[token.substr(0, 2)] = toInt(input);
 
-addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'],
-  function (input, week: WeekParsing, config, token) {
-    week[token.substr(0, 2)] = toInt(input);
+      return config;
+    });
+
+  addWeekParseToken(['gg', 'GG'], function (input, week: WeekParsing, config, token) {
+    week[token] = parseTwoDigitYear(input);
 
     return config;
   });
+}
+
+function addWeekYearFormatToken(token: string, getter: DateFormatterFn): void {
+  addFormatToken(null, [token, token.length, false], null, getter);
+}
 
-addWeekParseToken(['gg', 'GG'], function (input, week: WeekParsing, config, token) {
-  week[token] = parseTwoDigitYear(input);
+function _getWeekYearFormatCb(date: Date, opts: DateFormatterOptions): string {
+  return getWeekYear(date, opts.locale).toString();
+}
 
-  return config;
-});
+function _getISOWeekYearFormatCb(date: Date): string {
+  return getISOWeekYear(date).toString();
+}
 
 // MOMENTS
 
diff --git a/src/chronos/units/week.ts b/src/chronos/units/week.ts
index 827052f8be..ddbf0f2ee4 100644
--- a/src/chronos/units/week.ts
+++ b/src/chronos/units/week.ts
@@ -13,44 +13,52 @@ import { add } from '../moment/add-subtract';
 
 // FORMATTING
 
-addFormatToken('w', ['ww', 2, false], 'wo',
-  function (date: Date, opts: DateFormatterOptions): string {
-    return getWeek(date, opts.locale).toString(10);
-  });
-
-addFormatToken('W', ['WW', 2, false], 'Wo',
-  function (date: Date): string {
-    return getISOWeek(date).toString(10);
-  });
+export function initWeek() {
+  addFormatToken('w', ['ww', 2, false], 'wo',
+    function(date: Date, opts: DateFormatterOptions): string {
+      return getWeek(date, opts.locale)
+        .toString(10);
+    }
+  );
+
+  addFormatToken('W', ['WW', 2, false], 'Wo',
+    function(date: Date): string {
+      return getISOWeek(date)
+        .toString(10);
+    }
+  );
 
 // ALIASES
 
-addUnitAlias('week', 'w');
-addUnitAlias('isoWeek', 'W');
+  addUnitAlias('week', 'w');
+  addUnitAlias('isoWeek', 'W');
 
 // PRIORITIES
 
-addUnitPriority('week', 5);
-addUnitPriority('isoWeek', 5);
+  addUnitPriority('week', 5);
+  addUnitPriority('isoWeek', 5);
 
 // PARSING
 
-addRegexToken('w', match1to2);
-addRegexToken('ww', match1to2, match2);
-addRegexToken('W', match1to2);
-addRegexToken('WW', match1to2, match2);
+  addRegexToken('w', match1to2);
+  addRegexToken('ww', match1to2, match2);
+  addRegexToken('W', match1to2);
+  addRegexToken('WW', match1to2, match2);
 
-addWeekParseToken(['w', 'ww', 'W', 'WW'],
-  function (input: string, week: WeekParsing, config: DateParsingConfig, token: string): DateParsingConfig {
-    week[token.substr(0, 1)] = toInt(input);
+  addWeekParseToken(
+    ['w', 'ww', 'W', 'WW'],
+    function(input: string, week: WeekParsing, config: DateParsingConfig, token: string): DateParsingConfig {
+      week[token.substr(0, 1)] = toInt(input);
 
-    return config;
-  });
+      return config;
+    }
+  );
 
 // export function getSetWeek (input) {
 //   var week = this.localeData().week(this);
 //   return input == null ? week : this.add((input - week) * 7, 'd');
 // }
+}
 
 export function setWeek(date: Date, input: number, locale = getLocale()): Date {
   const week = getWeek(date, locale);
diff --git a/src/chronos/units/year.ts b/src/chronos/units/year.ts
index 0c04ce68a4..3abc4374c2 100644
--- a/src/chronos/units/year.ts
+++ b/src/chronos/units/year.ts
@@ -14,54 +14,56 @@ function getYear(date: Date, opts: DateFormatterOptions): string {
   return getFullYear(date, opts.isUTC).toString();
 }
 
-addFormatToken('Y', null, null,
-  function (date: Date, opts: DateFormatterOptions): string {
-  const y = getFullYear(date, opts.isUTC);
+export function initYear() {
+  addFormatToken('Y', null, null,
+    function (date: Date, opts: DateFormatterOptions): string {
+    const y = getFullYear(date, opts.isUTC);
 
-  return y <= 9999 ? y.toString(10) : `+${y}`;
-});
+    return y <= 9999 ? y.toString(10) : `+${y}`;
+  });
 
-addFormatToken(null, ['YY', 2, false], null,
-  function (date: Date, opts: DateFormatterOptions): string {
-  return (getFullYear(date, opts.isUTC) % 100).toString(10);
-});
+  addFormatToken(null, ['YY', 2, false], null,
+    function (date: Date, opts: DateFormatterOptions): string {
+    return (getFullYear(date, opts.isUTC) % 100).toString(10);
+  });
 
-addFormatToken(null, ['YYYY', 4, false], null, getYear);
-addFormatToken(null, ['YYYYY', 5, false], null, getYear);
-addFormatToken(null, ['YYYYYY', 6, true], null, getYear);
+  addFormatToken(null, ['YYYY', 4, false], null, getYear);
+  addFormatToken(null, ['YYYYY', 5, false], null, getYear);
+  addFormatToken(null, ['YYYYYY', 6, true], null, getYear);
 
-// ALIASES
+  // ALIASES
 
-addUnitAlias('year', 'y');
+  addUnitAlias('year', 'y');
 
-// PRIORITIES
+  // PRIORITIES
 
-addUnitPriority('year', 1);
+  addUnitPriority('year', 1);
 
-// PARSING
+  // PARSING
 
-addRegexToken('Y', matchSigned);
-addRegexToken('YY', match1to2, match2);
-addRegexToken('YYYY', match1to4, match4);
-addRegexToken('YYYYY', match1to6, match6);
-addRegexToken('YYYYYY', match1to6, match6);
+  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, config) {
-  array[YEAR] = input.length === 2 ? parseTwoDigitYear(input) : toInt(input);
+  addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+  addParseToken('YYYY', function (input, array, config) {
+    array[YEAR] = input.length === 2 ? parseTwoDigitYear(input) : toInt(input);
 
-  return config;
-});
-addParseToken('YY', function (input, array, config) {
-  array[YEAR] = parseTwoDigitYear(input);
+    return config;
+  });
+  addParseToken('YY', function (input, array, config) {
+    array[YEAR] = parseTwoDigitYear(input);
 
-  return config;
-});
-addParseToken('Y', function (input, array, config) {
-  array[YEAR] = parseInt(input, 10);
+    return config;
+  });
+  addParseToken('Y', function (input, array, config) {
+    array[YEAR] = parseInt(input, 10);
 
-  return config;
-});
+    return config;
+  });
+}
 
 export function parseTwoDigitYear(input: string): number {
   return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);