moment_timezone-rails 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab1870c6883b821833d2ce72ef342ce90a8e53fa
-  data.tar.gz: 8ba2a9a96f99ca3db903ac53358557991f91cbed
+  metadata.gz: 34fb06044fcd232cebb6940b4e9d5ce0530b41db
+  data.tar.gz: cab067330843c1104899f723db40e86e4caaa31b
 SHA512:
-  metadata.gz: 1eeca069699a685c76a879304e925adff11a745cc4c7fac65579cf4674e298c5f10246a3f0b484f31e66e9c46d80558ec525f414ac2b34128a0d409d9d99b15e
-  data.tar.gz: 4fd4972095c57cca92f0bfd4219afbae608c31cdfd040099bbe3db4ca055bc1cb6ead46cd8a01b74670d83ebb93be1640e38a07fe96d5301d073bd8d012f6c11
+  metadata.gz: 80bc732d49f06ca3d0c22a2f55f67bfad3b383624cb3b6095b80d77f619d378136189cd6985663a105ee9e96760d4cac4bc10a252a36ef73649e823adba569c0
+  data.tar.gz: b7cb6f1fc57c8d86b728a2ca7f134134733e8c722ae7c05ea1ac0b63dae57ba36e40cc57cead49645dfbd878dd91399acc8c311dfe11d8349a9208182177ed83

data/README.md

@@ -4,7 +4,13 @@
 
 ## Installation
 
-Add this line to your application's Gemfile:
+`momentjs-rails` need to be explicitly included in your application's Gemfile:
+
+```ruby
+gem 'momentjs-rails'
+```
+
+Then add this line to your application's Gemfile:
 
 ```ruby
 gem 'moment_timezone-rails'
@@ -26,12 +32,30 @@ $ gem install moment_timezone-rails
 
 Add the following directives to `application.js`.
 
+### For v0.0.4 and below
+
 ```js
 //= require moment
 //= require moment-timezone
 //= require moment-timezone-data
 ```
 
+### For v0.1.0
+
+```js
+//= require moment
+
+// moment-timezone without timezone data
+//= require moment-timezone
+
+// moment-timezone with timezone data from 2010-2020
+//= require moment-timezone-2010-2020
+
+// moment-timezone all timezone data
+//= require moment-timezone-all-years
+
+```
+
 ## Contributing
 
 1. Fork it

data/lib/moment_timezone/rails/version.rb

@@ -1,5 +1,5 @@
 module MomentTimezone
   module Rails
-    VERSION = "0.0.4"
+    VERSION = "0.1.0"
   end
 end

data/moment_timezone-rails.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "rails", "~> 3.2.11"
+  spec.add_development_dependency "rails", "~> 3.2"
 
-  spec.add_runtime_dependency "momentjs-rails", "~> 2.1"
+  spec.add_runtime_dependency "momentjs-rails", "~> 2.7"
 end

data/vendor/assets/javascripts/moment-timezone.js

@@ -1,540 +1,330 @@
-// moment-timezone.js
-// version : 0.0.4
-// author : Tim Wood
-// license : MIT
-// github.com/timrwood/moment-timezone
-
-(function () {
-
-	var VERSION = "0.0.4";
-
-	function onload(moment) {
-		var oldZoneName = moment.fn.zoneName,
-			oldZoneAbbr = moment.fn.zoneAbbr,
+//! moment-timezone.js
+//! version : 0.1.0
+//! author : Tim Wood
+//! license : MIT
+//! github.com/moment/moment-timezone
+
+(function (root, factory) {
+	"use strict";
+
+	/*global define*/
+	if (typeof define === 'function' && define.amd) {
+		define(['moment'], factory);                 // AMD
+	} else if (typeof exports === 'object') {
+		module.exports = factory(require('moment')); // Node
+	} else {
+		factory(root.moment);                        // Browser
+	}
+}(this, function (moment) {
+	"use strict";
 
-			defaultRule,
-			rules = {},
-			ruleSets = {},
-			zones = {},
-			zoneSets = {},
-			links = {},
+	// Do not load moment-timezone a second time.
+	if (moment.tz !== undefined) { return moment; }
 
-			TIME_RULE_WALL_CLOCK = 0,
-			TIME_RULE_UTC        = 1,
-			TIME_RULE_STANDARD   = 2,
+	var VERSION = "0.1.0",
+		zones = {},
+		links = {};
 
-			DAY_RULE_DAY_OF_MONTH   = 7,
-			DAY_RULE_LAST_WEEKDAY   = 8;
+	/************************************
+		Unpacking
+	************************************/
 
-		if (moment.tz !== undefined) {
-			// Do not load moment-timezone a second time.
-			return;
+	function charCodeToInt(charCode) {
+		if (charCode > 96) {
+			return charCode - 87;
+		} else if (charCode > 64) {
+			return charCode - 29;
 		}
+		return charCode - 48;
+	}
 
-		// converts time in the HH:mm:ss format to absolute number of minutes
-		function parseMinutes (input) {
-			input = input + '';
-			var output = input.split(':'),
-				sign = ~input.indexOf('-') ? -1 : 1,
-				hour = Math.abs(+output[0]),
-				minute = parseInt(output[1], 10) || 0,
-				second = parseInt(output[2], 10) || 0;
-
-			return sign * ((hour * 60) + (minute) + (second / 60));
+	function unpackBase60(string) {
+		var i = 0,
+			parts = string.split('.'),
+			whole = parts[0],
+			fractional = parts[1] || '',
+			multiplier = 1,
+			num,
+			out = 0,
+			sign = 1;
+
+		// handle negative numbers
+		if (string.charCodeAt(0) === 45) {
+			i = 1;
+			sign = -1;
 		}
 
-		/************************************
-			Rules
-		************************************/
-
-		function Rule (name, startYear, endYear, month, day, dayRule, time, timeRule, offset, letters) {
-			this.name      = name;
-			this.startYear = +startYear;
-			this.endYear   = +endYear;
-			this.month     = +month;
-			this.day       = +day;
-			this.dayRule   = +dayRule;
-			this.time      = parseMinutes(time);
-			this.timeRule  = +timeRule;
-			this.offset    = parseMinutes(offset);
-			this.letters   = letters || '';
-			this.date = memoize(this.date);
-			this.weekdayAfter = memoize(this.weekdayAfter);
-			this.lastWeekday = memoize(this.lastWeekday);
+		// handle digits before the decimal
+		for (i; i < whole.length; i++) {
+			num = charCodeToInt(whole.charCodeAt(i));
+			out = 60 * out + num;
 		}
 
-		Rule.prototype = {
-			contains : function (year) {
-				return (year >= this.startYear && year <= this.endYear);
-			},
-
-			start : function (year) {
-				year = Math.min(Math.max(year, this.startYear), this.endYear);
-				return moment.utc([year, this.month, this.date(year), 0, this.time]);
-			},
-
-			date : function (year) {
-				if (this.dayRule === DAY_RULE_DAY_OF_MONTH) {
-					return this.day;
-				} else if (this.dayRule === DAY_RULE_LAST_WEEKDAY) {
-					return this.lastWeekday(year);
-				}
-				return this.weekdayAfter(year);
-			},
-
-			weekdayAfter : function (year) {
-				var day = this.day,
-					firstDayOfWeek = moment([year, this.month, 1]).day(),
-					output = this.dayRule + 1 - firstDayOfWeek;
-
-				while (output < day) {
-					output += 7;
-				}
-
-				return output;
-			},
-
-			lastWeekday : function (year) {
-				var day = this.day,
-					dow = day % 7,
-					lastDowOfMonth = moment([year, this.month + 1, 1]).day(),
-					daysInMonth = moment([year, this.month, 1]).daysInMonth(),
-					output = daysInMonth + (dow - (lastDowOfMonth - 1)) - (~~(day / 7) * 7);
-
-				if (dow >= lastDowOfMonth) {
-					output -= 7;
-				}
-				return output;
-			}
-		};
+		// handle digits after the decimal
+		for (i = 0; i < fractional.length; i++) {
+			multiplier = multiplier / 60;
+			num = charCodeToInt(fractional.charCodeAt(i));
+			out += num * multiplier;
+		}
 
-		/************************************
-			Rule Year
-		************************************/
+		return out * sign;
+	}
 
-		function RuleYear (year, rule) {
-			this.rule = rule;
-			this.start = rule.start(year);
+	function arrayToInt (array) {
+		for (var i = 0; i < array.length; i++) {
+			array[i] = unpackBase60(array[i]);
 		}
+	}
 
-		RuleYear.prototype = {
-			equals : function (other) {
-				if (!other || other.rule !== this.rule) {
-					return false;
-				}
-				return Math.abs(other.start - this.start) < 86400000; // 24 * 60 * 60 * 1000
-			}
-		};
-
-		function sortRuleYears (a, b) {
-			if (a.isLast) {
-				return -1;
-			}
-			if (b.isLast) {
-				return 1;
-			}
-			return b.start - a.start;
+	function intToUntil (array, length) {
+		for (var i = 0; i < length; i++) {
+			array[i] = Math.round((array[i - 1] || 0) + (array[i] * 60000)); // minutes to milliseconds
 		}
 
-		/************************************
-			Rule Sets
-		************************************/
+		array[length - 1] = Infinity;
+	}
+
+	function mapIndices (source, indices) {
+		var out = [], i;
 
-		function RuleSet (name) {
-			this.name = name;
-			this.rules = [];
-			this.lastYearRule = memoize(this.lastYearRule);
+		for (i = 0; i < indices.length; i++) {
+			out[i] = source[indices[i]];
 		}
 
-		RuleSet.prototype = {
-			add : function (rule) {
-				this.rules.push(rule);
-			},
-
-			ruleYears : function (mom, lastZone) {
-				var i, j,
-					year = mom.year(),
-					rule,
-					lastZoneRule,
-					rules = [];
-
-				for (i = 0; i < this.rules.length; i++) {
-					rule = this.rules[i];
-					if (rule.contains(year)) {
-						rules.push(new RuleYear(year, rule));
-					} else if (rule.contains(year + 1)) {
-						rules.push(new RuleYear(year + 1, rule));
-					}
-				}
-				rules.push(new RuleYear(year - 1, this.lastYearRule(year - 1)));
+		return out;
+	}
 
-				if (lastZone) {
-					lastZoneRule = new RuleYear(year - 1, lastZone.lastRule());
-					lastZoneRule.start = lastZone.until.clone().utc();
-					lastZoneRule.isLast = lastZone.ruleSet !== this;
-					rules.push(lastZoneRule);
-				}
+	function unpack (string) {
+		var data = string.split('|'),
+			offsets = data[2].split(' '),
+			indices = data[3].split(''),
+			untils  = data[4].split(' ');
 
-				rules.sort(sortRuleYears);
-				return rules;
-			},
-
-			rule : function (mom, offset, lastZone) {
-				var rules = this.ruleYears(mom, lastZone),
-					lastOffset = 0,
-					rule,
-					lastZoneOffset,
-					lastZoneOffsetAbs,
-					lastRule,
-					i;
-
-				if (lastZone) {
-					lastZoneOffset = lastZone.offset + lastZone.lastRule().offset;
-					lastZoneOffsetAbs = Math.abs(lastZoneOffset) * 90000;
-				}
+		arrayToInt(offsets);
+		arrayToInt(indices);
+		arrayToInt(untils);
 
-				// make sure to include the previous rule's offset
-				for (i = rules.length - 1; i > -1; i--) {
-					lastRule = rule;
-					rule = rules[i];
+		intToUntil(untils, indices.length);
 
-					if (rule.equals(lastRule)) {
-						continue;
-					}
+		return {
+			name    : data[0],
+			abbrs   : mapIndices(data[1].split(' '), indices),
+			offsets : mapIndices(offsets, indices),
+			untils  : untils
+		};
+	}
 
-					if (lastZone && !rule.isLast && Math.abs(rule.start - lastZone.until) <= lastZoneOffsetAbs) {
-						lastOffset += lastZoneOffset - offset;
-					}
+	/************************************
+		Zone object
+	************************************/
 
-					if (rule.rule.timeRule === TIME_RULE_STANDARD) {
-						lastOffset = offset;
-					}
+	function Zone (packedString) {
+		var unpacked = unpack(packedString);
+		this.name    = unpacked.name;
+		this.abbrs   = unpacked.abbrs;
+		this.untils  = unpacked.untils;
+		this.offsets = unpacked.offsets;
+	}
 
-					if (rule.rule.timeRule !== TIME_RULE_UTC) {
-						rule.start.add('m', -lastOffset);
-					}
+	Zone.prototype = {
+		_index : function (timestamp) {
+			var target = +timestamp,
+				untils = this.untils,
+				i;
 
-					lastOffset = rule.rule.offset + offset;
+			for (i = 0; i < untils.length; i++) {
+				if (target < untils[i]) {
+					return i;
 				}
+			}
+		},
 
-				for (i = 0; i < rules.length; i++) {
-					rule = rules[i];
-					if (mom >= rule.start && !rule.isLast) {
-						return rule.rule;
-					}
-				}
+		parse : function (timestamp) {
+			var target  = +timestamp,
+				offsets = this.offsets,
+				untils  = this.untils,
+				i;
 
-				return defaultRule;
-			},
-
-			lastYearRule : function (year) {
-				var i,
-					rule,
-					start,
-					bestRule = defaultRule,
-					largest = -1e30;
-
-				for (i = 0; i < this.rules.length; i++) {
-					rule = this.rules[i];
-					if (year >= rule.startYear) {
-						start = rule.start(year);
-						if (start > largest) {
-							largest = start;
-							bestRule = rule;
-						}
-					}
+			for (i = 0; i < untils.length; i++) {
+				if (target < untils[i] - (offsets[i] * 60000)) {
+					return offsets[i];
 				}
-
-				return bestRule;
 			}
-		};
-
-		/************************************
-			Zone
-		************************************/
+		},
 
-		function Zone (name, offset, ruleSet, letters, until, untilOffset) {
-			var i,
-				untilArray = typeof until === 'string' ? until.split('_') : [9999];
+		abbr : function (mom) {
+			return this.abbrs[this._index(mom)];
+		},
 
-			this.name = name;
-			this.offset = parseMinutes(offset);
-			this.ruleSet = ruleSet;
-			this.letters = letters;
-			this.lastRule = memoize(this.lastRule);
-
-			for (i = 0; i < untilArray.length; i++) {
-				untilArray[i] = +untilArray[i];
-			}
-			this.until = moment.utc(untilArray).subtract('m', parseMinutes(untilOffset));
+		offset : function (mom) {
+			return this.offsets[this._index(mom)];
 		}
+	};
 
-		Zone.prototype = {
-			rule : function (mom, lastZone) {
-				return this.ruleSet.rule(mom, this.offset, lastZone);
-			},
+	/************************************
+		Global Methods
+	************************************/
 
-			lastRule : function () {
-				return this.rule(this.until);
-			},
-
-			format : function (rule) {
-				return this.letters.replace("%s", rule.letters);
-			}
-		};
+	function normalizeName (name) {
+		return (name || '').toLowerCase().replace(/\//g, '_');
+	}
 
-		/************************************
-			Zone Set
-		************************************/
+	function addZone (packed) {
+		var i, zone;
 
-		function sortZones (a, b) {
-			return a.until - b.until;
+		if (typeof packed === "string") {
+			packed = [packed];
 		}
 
-		function ZoneSet (name) {
-			this.name = normalizeName(name);
-			this.displayName = name;
-			this.zones = [];
-			this.zoneAndRule = memoize(this.zoneAndRule, function (mom) {
-				return +mom;
-			});
+		for (i = 0; i < packed.length; i++) {
+			zone = new Zone(packed[i]);
+			zones[normalizeName(zone.name)] = zone;
 		}
+	}
 
-		ZoneSet.prototype = {
-			zoneAndRule : function (mom) {
-				var i,
-					zone,
-					lastZone;
-
-				mom = mom.clone().utc();
-				for (i = 0; i < this.zones.length; i++) {
-					zone = this.zones[i];
-					if (mom < zone.until) {
-						break;
-					}
-					lastZone = zone;
-				}
-
-				return [zone, zone.rule(mom, lastZone)];
-			},
-
-			add : function (zone) {
-				this.zones.push(zone);
-				this.zones.sort(sortZones);
-			},
+	function getZone (name) {
+		name = normalizeName(name);
+		var linkName = links[name];
 
-			format : function (mom) {
-				var zoneAndRule = this.zoneAndRule(mom);
-				return zoneAndRule[0].format(zoneAndRule[1]);
-			},
+		if (linkName && zones[linkName]) {
+			name = linkName;
+		}
 
-			offset : function (mom) {
-				var zoneAndRule = this.zoneAndRule(mom);
-				return -(zoneAndRule[0].offset + zoneAndRule[1].offset);
-			}
-		};
+		return zones[name] || null;
+	}
 
-		/************************************
-			Global Methods
-		************************************/
-
-		function memoize (fn, keyFn) {
-			var cache = {};
-			return function (first) {
-				var key = keyFn ? keyFn.apply(this, arguments) : first;
-				return key in cache ?
-					cache[key] :
-					(cache[key] = fn.apply(this, arguments));
-			};
-		}
+	function getNames () {
+		var i, out = [];
 
-		function addRules (rules) {
-			var i, j, rule;
-			for (i in rules) {
-				rule = rules[i];
-				for (j = 0; j < rule.length; j++) {
-					addRule(i + '\t' + rule[j]);
-				}
+		for (i in zones) {
+			if (zones.hasOwnProperty(i) && zones[i]) {
+				out.push(zones[i].name);
 			}
 		}
 
-		function addRule (ruleString) {
-			// don't duplicate rules
-			if (rules[ruleString]) {
-				return rules[ruleString];
-			}
-
-			var p = ruleString.split(/\s/),
-				name = normalizeName(p[0]),
-				rule = new Rule(name, p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10]);
-
-			// cache the rule so we don't add it again
-			rules[ruleString] = rule;
+		return out.sort();
+	}
 
-			// add to the ruleset
-			getRuleSet(name).add(rule);
+	function addLink (aliases) {
+		var i, alias;
 
-			return rule;
+		if (typeof aliases === "string") {
+			aliases = [aliases];
 		}
 
-		function normalizeName (name) {
-			return (name || '').toLowerCase().replace(/\//g, '_');
+		for (i = 0; i < aliases.length; i++) {
+			alias = normalizeName(aliases[i]).split('|');
+			links[alias[0]] = alias[1];
+			links[alias[1]] = alias[0];
 		}
+	}
 
-		function addZones (zones) {
-			var i, j, zone;
-			for (i in zones) {
-				zone = zones[i];
-				for (j = 0; j < zone.length; j++) {
-					addZone(i + '\t' + zone[j]);
-				}
-			}
-		}
+	function loadData (data) {
+		addZone(data.zones);
+		addLink(data.links);
+		tz.dataVersion = data.version;
+	}
 
-		function addLinks (linksToAdd) {
-			var i;
-			for (i in linksToAdd) {
-				links[normalizeName(i)] = normalizeName(linksToAdd[i]);
+	function zoneExists (name) {
+		if (!zoneExists.didShowError) {
+			zoneExists.didShowError = true;
+			if (typeof console !== 'undefined' && typeof console.error === 'function') {
+				console.error("moment.tz.zoneExists('" + name + "') has been deprecated in favor of !moment.tz.zone('" + name + "')");
 			}
 		}
+		return !!getZone(name);
+	}
 
-		function addZone (zoneString) {
-			// don't duplicate zones
-			if (zones[zoneString]) {
-				return zones[zoneString];
-			}
-
-			var p = zoneString.split(/\s/),
-				name = normalizeName(p[0]),
-				zone = new Zone(name, p[1], getRuleSet(p[2]), p[3], p[4], p[5]);
+	function needsOffset (m) {
+		return !!(m._a && (m._tzm === undefined));
+	}
 
-			// cache the zone so we don't add it again
-			zones[zoneString] = zone;
+	/************************************
+		moment.tz namespace
+	************************************/
 
-			// add to the zoneset
-			getZoneSet(p[0]).add(zone);
+	function tz () {
+		var args = Array.prototype.slice.call(arguments, 0, -1),
+			name = arguments[arguments.length - 1],
+			zone = getZone(name),
+			out  = moment.utc.apply(null, args);
 
-			return zone;
+		if (zone && needsOffset(out)) {
+			out.add('minutes', zone.parse(out));
 		}
 
-		function getRuleSet (name) {
-			name = normalizeName(name);
-			if (!ruleSets[name]) {
-				ruleSets[name] = new RuleSet(name);
-			}
-			return ruleSets[name];
-		}
+		out.tz(name);
 
-		function getZoneSet (name) {
-			var machineName = normalizeName(name);
-			if (links[machineName]) {
-				machineName = links[machineName];
-			}
-			if (!zoneSets[machineName]) {
-				zoneSets[machineName] = new ZoneSet(name);
-			}
-			return zoneSets[machineName];
-		}
-
-		function add (data) {
-			if (!data) {
-				return;
-			}
-			if (data.zones) {
-				addZones(data.zones);
-			}
-			if (data.rules) {
-				addRules(data.rules);
-			}
-			if (data.links) {
-				addLinks(data.links);
-			}
-		}
-
-		// overwrite moment.updateOffset
-		moment.updateOffset = function (mom, keepTime) {
-			var offset;
-			if (mom._z) {
-				offset = mom._z.offset(mom);
-				if (Math.abs(offset) < 16) {
-					offset = offset / 60;
-				}
-				mom.zone(offset, keepTime);
-			}
-		};
+		return out;
+	}
 
-		function getZoneSets() {
-			var sets = [],
-				zoneName;
-			for (zoneName in zoneSets) {
-				sets.push(zoneSets[zoneName]);
+	tz.version      = VERSION;
+	tz.dataVersion  = '';
+	tz._zones       = zones;
+	tz._links       = links;
+	tz.add          = addZone;
+	tz.link         = addLink;
+	tz.load         = loadData;
+	tz.zone         = getZone;
+	tz.zoneExists   = zoneExists; // deprecated in 0.1.0
+	tz.names        = getNames;
+	tz.Zone         = Zone;
+	tz.unpack       = unpack;
+	tz.unpackBase60 = unpackBase60;
+	tz.needsOffset  = needsOffset;
+
+	/************************************
+		Interface with Moment.js
+	************************************/
+
+	var fn = moment.fn;
+
+	moment.tz = tz;
+
+	moment.updateOffset = function (mom, keepTime) {
+		var offset;
+		if (mom._z) {
+			offset = mom._z.offset(mom);
+			if (Math.abs(offset) < 16) {
+				offset = offset / 60;
 			}
-			return sets;
+			mom.zone(offset, keepTime);
 		}
+	};
 
-		moment.fn.tz = function (name) {
-			if (name) {
-				this._z = getZoneSet(name);
-				if (this._z) {
-					moment.updateOffset(this);
-				}
-				return this;
-			}
-			if (this._z) {
-				return this._z.displayName;
-			}
-		};
-
-		moment.fn.zoneName = function () {
+	fn.tz = function (name) {
+		if (name) {
+			this._z = getZone(name);
 			if (this._z) {
-				return this._z.format(this);
+				moment.updateOffset(this);
 			}
-			return oldZoneName.call(this);
-		};
+			return this;
+		}
+		if (this._z) { return this._z.name; }
+	};
 
-		moment.fn.zoneAbbr = function () {
-			if (this._z) {
-				return this._z.format(this);
-			}
-			return oldZoneAbbr.call(this);
+	function abbrWrap (old) {
+		return function () {
+			if (this._z) { return this._z.abbr(this); }
+			return old.call(this);
 		};
+	}
 
-		// Make sure moment's clone includes the newly added properties
-		moment.momentProperties._z = null;
-
-		moment.tz = function () {
-			var args = [], i, len = arguments.length - 1;
-			for (i = 0; i < len; i++) {
-				args[i] = arguments[i];
-			}
-			var m = moment.apply(null, args);
-			var preTzOffset = m.zone();
-			m.tz(arguments[len]);
-			return m.add('minutes', m.zone() - preTzOffset);
+	function resetZoneWrap (old) {
+		return function () {
+			this._z = null;
+			return old.call(this);
 		};
+	}
 
-		moment.tz.add = add;
-		moment.tz.addRule = addRule;
-		moment.tz.addZone = addZone;
-		moment.tz.zones = getZoneSets;
-
-		moment.tz.version = VERSION;
-
-		moment.tz.zoneExists = function (name) {
-			return getZoneSet(name).zones.length > 0;
-		};
+	fn.zoneName = abbrWrap(fn.zoneName);
+	fn.zoneAbbr = abbrWrap(fn.zoneAbbr);
+	fn.utc      = resetZoneWrap(fn.utc);
 
-		// add default rule
-		defaultRule = addRule("- 0 9999 0 0 0 0 0 0");
+	// Cloning a moment should include the _z property.
+	moment.momentProperties._z = null;
 
-		return moment;
-	}
+	// INJECT DATA
 
-	if (typeof define === "function" && define.amd) {
-		define("moment-timezone", ["moment"], onload);
-	} else if (typeof module !== 'undefined') {
-		module.exports = onload(require('moment'));
-	} else if (typeof window !== "undefined" && window.moment) {
-		onload(window.moment);
-	}
-}).apply(this);
+	return moment;
+}));