Use shared container to manage imports/exports.

src/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ECMAScript 402 API implementation.
 
 /**
  * Intl object is a single object that has some named properties,
  * all of which are constructors.
  */
-(function(global, shared, exports) {
+(function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
+// -------------------------------------------------------------------
+// Imports
+
 var GlobalBoolean = global.Boolean;
 var GlobalDate = global.Date;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 
-var undefined = global.undefined;
+var MathFloor;
+
+utils.Import(function(from) {
+  MathFloor = from.MathFloor;
+});
+
+// -------------------------------------------------------------------
 
 var Intl = {};
 
 %AddNamedProperty(global, "Intl", Intl, DONT_ENUM);
 
 /**
  * Caches available locales for each service.
  */
 var AVAILABLE_LOCALES = {
-  'collator': undefined,
-  'numberformat': undefined,
-  'dateformat': undefined,
-  'breakiterator': undefined
+  'collator': UNDEFINED,
+  'numberformat': UNDEFINED,
+  'dateformat': UNDEFINED,
+  'breakiterator': UNDEFINED
 };
 
 /**
  * Caches default ICU locale.
  */
-var DEFAULT_ICU_LOCALE = undefined;
+var DEFAULT_ICU_LOCALE = UNDEFINED;
 
 /**
  * Unicode extension regular expression.
  */
-var UNICODE_EXTENSION_RE = undefined;
+var UNICODE_EXTENSION_RE = UNDEFINED;
 
 function GetUnicodeExtensionRE() {
-  if (UNICODE_EXTENSION_RE === undefined) {
+  if (IS_UNDEFINED(UNDEFINED)) {
     UNICODE_EXTENSION_RE = new GlobalRegExp('-u(-[a-z0-9]{2,8})+', 'g');
   }
   return UNICODE_EXTENSION_RE;
 }
 
 /**
  * Matches any Unicode extension.
  */
-var ANY_EXTENSION_RE = undefined;
+var ANY_EXTENSION_RE = UNDEFINED;
 
 function GetAnyExtensionRE() {
-  if (ANY_EXTENSION_RE === undefined) {
+  if (IS_UNDEFINED(ANY_EXTENSION_RE)) {
     ANY_EXTENSION_RE = new GlobalRegExp('-[a-z0-9]{1}-.*', 'g');
   }
   return ANY_EXTENSION_RE;
 }
 
 /**
  * Replace quoted text (single quote, anything but the quote and quote again).
  */
-var QUOTED_STRING_RE = undefined;
+var QUOTED_STRING_RE = UNDEFINED;
 
 function GetQuotedStringRE() {
-  if (QUOTED_STRING_RE === undefined) {
+  if (IS_UNDEFINED(QUOTED_STRING_RE)) {
     QUOTED_STRING_RE = new GlobalRegExp("'[^']+'", 'g');
   }
   return QUOTED_STRING_RE;
 }
 
 /**
  * Matches valid service name.
  */
-var SERVICE_RE = undefined;
+var SERVICE_RE = UNDEFINED;
 
 function GetServiceRE() {
-  if (SERVICE_RE === undefined) {
+  if (IS_UNDEFINED(SERVICE_RE)) {
     SERVICE_RE =
         new GlobalRegExp('^(collator|numberformat|dateformat|breakiterator)$');
   }
   return SERVICE_RE;
 }
 
 /**
  * Validates a language tag against bcp47 spec.
  * Actual value is assigned on first run.
  */
-var LANGUAGE_TAG_RE = undefined;
+var LANGUAGE_TAG_RE = UNDEFINED;
 
 function GetLanguageTagRE() {
-  if (LANGUAGE_TAG_RE === undefined) {
+  if (IS_UNDEFINED(LANGUAGE_TAG_RE)) {
     BuildLanguageTagREs();
   }
   return LANGUAGE_TAG_RE;
 }
 
 /**
  * Helps find duplicate variants in the language tag.
  */
-var LANGUAGE_VARIANT_RE = undefined;
+var LANGUAGE_VARIANT_RE = UNDEFINED;
 
 function GetLanguageVariantRE() {
-  if (LANGUAGE_VARIANT_RE === undefined) {
+  if (IS_UNDEFINED(LANGUAGE_VARIANT_RE)) {
     BuildLanguageTagREs();
   }
   return LANGUAGE_VARIANT_RE;
 }
 
 /**
  * Helps find duplicate singletons in the language tag.
  */
-var LANGUAGE_SINGLETON_RE = undefined;
+var LANGUAGE_SINGLETON_RE = UNDEFINED;
 
 function GetLanguageSingletonRE() {
-  if (LANGUAGE_SINGLETON_RE === undefined) {
+  if (IS_UNDEFINED(LANGUAGE_SINGLETON_RE)) {
     BuildLanguageTagREs();
   }
   return LANGUAGE_SINGLETON_RE;
 }
 
 /**
  * Matches valid IANA time zone names.
  */
-var TIMEZONE_NAME_CHECK_RE = undefined;
+var TIMEZONE_NAME_CHECK_RE = UNDEFINED;
 
 function GetTimezoneNameCheckRE() {
-  if (TIMEZONE_NAME_CHECK_RE === undefined) {
+  if (IS_UNDEFINED(TIMEZONE_NAME_CHECK_RE)) {
     TIMEZONE_NAME_CHECK_RE =
         new GlobalRegExp('^([A-Za-z]+)/([A-Za-z]+)(?:_([A-Za-z]+))*$');
   }
   return TIMEZONE_NAME_CHECK_RE;
 }
 
 /**
  * Adds bound method to the prototype of the given object.
  */
 function addBoundMethod(obj, methodName, implementation, length) {
   function getter() {
     if (!%IsInitializedIntlObject(this)) {
       throw MakeTypeError(kMethodCalledOnWrongObject, methodName);
     }
     var internalName = '__bound' + methodName + '__';
-    if (this[internalName] === undefined) {
+    if (IS_UNDEFINED(this[internalName])) {
       var that = this;
       var boundMethod;
-      if (length === undefined || length === 2) {
+      if (IS_UNDEFINED(length) || length === 2) {
         boundMethod = function(x, y) {
           if (%_IsConstructCall()) {
             throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
           }
           return implementation(that, x, y);
         }
       } else if (length === 1) {
         boundMethod = function(x) {
           if (%_IsConstructCall()) {
             throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
@@ skipping 38 matching lines @@
 /**
  * Returns an intersection of locales and service supported locales.
  * Parameter locales is treated as a priority list.
  */
 function supportedLocalesOf(service, locales, options) {
   if (IS_NULL(service.match(GetServiceRE()))) {
     throw MakeError(kWrongServiceType, service);
   }
 
   // Provide defaults if matcher was not specified.
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   } else {
     options = $toObject(options);
   }
 
   var matcher = options.localeMatcher;
-  if (matcher !== undefined) {
+  if (!IS_UNDEFINED(matcher)) {
     matcher = GlobalString(matcher);
     if (matcher !== 'lookup' && matcher !== 'best fit') {
       throw MakeRangeError(kLocaleMatcher, matcher);
     }
   } else {
     matcher = 'best fit';
   }
 
   var requestedLocales = initializeLocaleList(locales);
 
   // Cache these, they don't ever change per service.
-  if (AVAILABLE_LOCALES[service] === undefined) {
+  if (IS_UNDEFINED(AVAILABLE_LOCALES[service])) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
   }
 
   // Use either best fit or lookup algorithm to match locales.
   if (matcher === 'best fit') {
     return initializeLocaleList(bestFitSupportedLocalesOf(
         requestedLocales, AVAILABLE_LOCALES[service]));
   }
 
   return initializeLocaleList(lookupSupportedLocalesOf(
       requestedLocales, AVAILABLE_LOCALES[service]));
 }
 
 
 /**
  * Returns the subset of the provided BCP 47 language priority list for which
  * this service has a matching locale when using the BCP 47 Lookup algorithm.
  * Locales appear in the same order in the returned list as in the input list.
  */
 function lookupSupportedLocalesOf(requestedLocales, availableLocales) {
   var matchedLocales = [];
   for (var i = 0; i < requestedLocales.length; ++i) {
     // Remove -u- extension.
     var locale = requestedLocales[i].replace(GetUnicodeExtensionRE(), '');
     do {
-      if (availableLocales[locale] !== undefined) {
+      if (!IS_UNDEFINED(availableLocales[locale])) {
         // Push requested locale not the resolved one.
         matchedLocales.push(requestedLocales[i]);
         break;
       }
       // Truncate locale if possible, if not break.
       var pos = locale.lastIndexOf('-');
       if (pos === -1) {
         break;
       }
       locale = locale.substring(0, pos);
@@ skipping 15 matching lines @@
   return lookupSupportedLocalesOf(requestedLocales, availableLocales);
 }
 
 
 /**
  * Returns a getOption function that extracts property value for given
  * options object. If property is missing it returns defaultValue. If value
  * is out of range for that property it throws RangeError.
  */
 function getGetOption(options, caller) {
-  if (options === undefined) throw MakeError(kDefaultOptionsMissing, caller);
+  if (IS_UNDEFINED(options)) throw MakeError(kDefaultOptionsMissing, caller);
 
   var getOption = function getOption(property, type, values, defaultValue) {
-    if (options[property] !== undefined) {
+    if (!IS_UNDEFINED(options[property])) {
       var value = options[property];
       switch (type) {
         case 'boolean':
           value = GlobalBoolean(value);
           break;
         case 'string':
           value = GlobalString(value);
           break;
         case 'number':
           value = GlobalNumber(value);
           break;
         default:
           throw MakeError(kWrongValueType);
       }
-      if (values !== undefined && values.indexOf(value) === -1) {
+      if (!IS_UNDEFINED(values) && values.indexOf(value) === -1) {
         throw MakeRangeError(kValueOutOfRange, value, caller, property);
       }
 
       return value;
     }
 
     return defaultValue;
   }
 
   return getOption;
@@ skipping 33 matching lines @@
 /**
  * Returns best matched supported locale and extension info using basic
  * lookup algorithm.
  */
 function lookupMatcher(service, requestedLocales) {
   if (IS_NULL(service.match(GetServiceRE()))) {
     throw MakeError(kWrongServiceType, service);
   }
 
   // Cache these, they don't ever change per service.
-  if (AVAILABLE_LOCALES[service] === undefined) {
+  if (IS_UNDEFINED(AVAILABLE_LOCALES[service])) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
   }
 
   for (var i = 0; i < requestedLocales.length; ++i) {
     // Remove all extensions.
     var locale = requestedLocales[i].replace(GetAnyExtensionRE(), '');
     do {
-      if (AVAILABLE_LOCALES[service][locale] !== undefined) {
+      if (!IS_UNDEFINED(AVAILABLE_LOCALES[service][locale])) {
         // Return the resolved locale and extension.
         var extensionMatch = requestedLocales[i].match(GetUnicodeExtensionRE());
         var extension = IS_NULL(extensionMatch) ? '' : extensionMatch[0];
         return {'locale': locale, 'extension': extension, 'position': i};
       }
       // Truncate locale if possible.
       var pos = locale.lastIndexOf('-');
       if (pos === -1) {
         break;
       }
       locale = locale.substring(0, pos);
     } while (true);
   }
 
   // Didn't find a match, return default.
-  if (DEFAULT_ICU_LOCALE === undefined) {
+  if (IS_UNDEFINED(DEFAULT_ICU_LOCALE)) {
     DEFAULT_ICU_LOCALE = %GetDefaultICULocale();
   }
 
   return {'locale': DEFAULT_ICU_LOCALE, 'extension': '', 'position': -1};
 }
 
 
 /**
  * Returns best matched supported locale and extension info using
  * implementation dependend algorithm.
@@ skipping 14 matching lines @@
 
   // Assume ['', 'u', ...] input, but don't throw.
   if (extensionSplit.length <= 2 ||
       (extensionSplit[0] !== '' && extensionSplit[1] !== 'u')) {
     return {};
   }
 
   // Key is {2}alphanum, value is {3,8}alphanum.
   // Some keys may not have explicit values (booleans).
   var extensionMap = {};
-  var previousKey = undefined;
+  var previousKey = UNDEFINED;
   for (var i = 2; i < extensionSplit.length; ++i) {
     var length = extensionSplit[i].length;
     var element = extensionSplit[i];
     if (length === 2) {
-      extensionMap[element] = undefined;
+      extensionMap[element] = UNDEFINED;
       previousKey = element;
-    } else if (length >= 3 && length <=8 && previousKey !== undefined) {
+    } else if (length >= 3 && length <=8 && !IS_UNDEFINED(previousKey)) {
       extensionMap[previousKey] = element;
-      previousKey = undefined;
+      previousKey = UNDEFINED;
     } else {
       // There is a value that's too long, or that doesn't have a key.
       return {};
     }
   }
 
   return extensionMap;
 }
 
 
@@ skipping 12 matching lines @@
 
   var updateExtension = function updateExtension(key, value) {
     return '-' + key + '-' + GlobalString(value);
   }
 
   var updateProperty = function updateProperty(property, type, value) {
     if (type === 'boolean' && (typeof value === 'string')) {
       value = (value === 'true') ? true : false;
     }
 
-    if (property !== undefined) {
+    if (!IS_UNDEFINED(property)) {
       defineWEProperty(outOptions, property, value);
     }
   }
 
   for (var key in keyValues) {
     if (keyValues.hasOwnProperty(key)) {
-      var value = undefined;
+      var value = UNDEFINED;
       var map = keyValues[key];
-      if (map.property !== undefined) {
+      if (!IS_UNDEFINED(map.property)) {
         // This may return true if user specifies numeric: 'false', since
         // Boolean('nonempty') === true.
         value = getOption(map.property, map.type, map.values);
       }
-      if (value !== undefined) {
+      if (!IS_UNDEFINED(value)) {
         updateProperty(map.property, map.type, value);
         extension += updateExtension(key, value);
         continue;
       }
       // User options didn't have it, check Unicode extension.
       // Here we want to convert strings 'true', 'false' into proper Boolean
       // values (not a user error).
       if (extensionMap.hasOwnProperty(key)) {
         value = extensionMap[key];
-        if (value !== undefined) {
+        if (!IS_UNDEFINED(value)) {
           updateProperty(map.property, map.type, value);
           extension += updateExtension(key, value);
         } else if (map.type === 'boolean') {
           // Boolean keys are allowed not to have values in Unicode extension.
           // Those default to true.
           updateProperty(map.property, map.type, true);
           extension += updateExtension(key, true);
         }
       }
     }
@@ skipping 80 matching lines @@
   $objectDefineProperty(object, property,
                         {value: value, writable: true, enumerable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets configurable descriptor to false.
  */
 function addWEPropertyIfDefined(object, property, value) {
-  if (value !== undefined) {
+  if (!IS_UNDEFINED(value)) {
     defineWEProperty(object, property, value);
   }
 }
 
 
 /**
  * Defines a property and sets writable, enumerable and configurable to true.
  */
 function defineWECProperty(object, property, value) {
   $objectDefineProperty(object, property, {value: value,
                                            writable: true,
                                            enumerable: true,
                                            configurable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets all descriptors to true.
  */
 function addWECPropertyIfDefined(object, property, value) {
-  if (value !== undefined) {
+  if (!IS_UNDEFINED(value)) {
     defineWECProperty(object, property, value);
   }
 }
 
 
 /**
  * Returns titlecased word, aMeRricA -> America.
  */
 function toTitleCaseWord(word) {
   return word.substr(0, 1).toUpperCase() + word.substr(1).toLowerCase();
@@ skipping 27 matching lines @@
   return tag;
 }
 
 
 /**
  * Returns an array where all locales are canonicalized and duplicates removed.
  * Throws on locales that are not well formed BCP47 tags.
  */
 function initializeLocaleList(locales) {
   var seen = [];
-  if (locales === undefined) {
+  if (IS_UNDEFINED(locales)) {
     // Constructor is called without arguments.
     seen = [];
   } else {
     // We allow single string localeID.
     if (typeof locales === 'string') {
       seen.push(canonicalizeLanguageTag(locales));
       return freezeArray(seen);
     }
 
     var o = $toObject(locales);
@@ skipping 112 matching lines @@
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
     throw MakeTypeError(kReinitializeIntl, "Collator");
   }
 
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'collator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'usage', getOption(
     'usage', 'string', ['sort', 'search'], 'sort'));
 
   var sensitivity = getOption('sensitivity', 'string',
                               ['base', 'accent', 'case', 'variant']);
-  if (sensitivity === undefined && internalOptions.usage === 'sort') {
+  if (IS_UNDEFINED(sensitivity) && internalOptions.usage === 'sort') {
     sensitivity = 'variant';
   }
   defineWEProperty(internalOptions, 'sensitivity', sensitivity);
 
   defineWEProperty(internalOptions, 'ignorePunctuation', getOption(
-    'ignorePunctuation', 'boolean', undefined, false));
+    'ignorePunctuation', 'boolean', UNDEFINED, false));
 
   var locale = resolveLocale('collator', locales, options);
 
   // ICU can't take kb, kc... parameters through localeID, so we need to pass
   // them as options.
   // One exception is -co- which has to be part of the extension, but only for
   // usage: sort, and its value can't be 'standard' or 'search'.
   var extensionMap = parseExtension(locale.extension);
 
   /**
@@ skipping 165 matching lines @@
       currency.match(/[^A-Za-z]/) == null;
 }
 
 
 /**
  * Returns the valid digit count for a property, or throws RangeError on
  * a value out of the range.
  */
 function getNumberOption(options, property, min, max, fallback) {
   var value = options[property];
-  if (value !== undefined) {
+  if (!IS_UNDEFINED(value)) {
     value = GlobalNumber(value);
     if ($isNaN(value) || value < min || value > max) {
       throw MakeRangeError(kPropertyValueOutOfRange, property);
     }
-    return $floor(value);
+    return MathFloor(value);
   }
 
   return fallback;
 }
 
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function initializeNumberFormat(numberFormat, locales, options) {
   if (%IsInitializedIntlObject(numberFormat)) {
     throw MakeTypeError(kReinitializeIntl, "NumberFormat");
   }
 
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'numberformat');
 
   var locale = resolveLocale('numberformat', locales, options);
 
   var internalOptions = {};
   defineWEProperty(internalOptions, 'style', getOption(
     'style', 'string', ['decimal', 'percent', 'currency'], 'decimal'));
 
   var currency = getOption('currency', 'string');
-  if (currency !== undefined && !isWellFormedCurrencyCode(currency)) {
+  if (!IS_UNDEFINED(currency) && !isWellFormedCurrencyCode(currency)) {
     throw MakeRangeError(kInvalidCurrencyCode, currency);
   }
 
-  if (internalOptions.style === 'currency' && currency === undefined) {
+  if (internalOptions.style === 'currency' && IS_UNDEFINED(currency)) {
     throw MakeTypeError(kCurrencyCode);
   }
 
   var currencyDisplay = getOption(
       'currencyDisplay', 'string', ['code', 'symbol', 'name'], 'symbol');
   if (internalOptions.style === 'currency') {
     defineWEProperty(internalOptions, 'currency', currency.toUpperCase());
     defineWEProperty(internalOptions, 'currencyDisplay', currencyDisplay);
   }
 
   // Digit ranges.
   var mnid = getNumberOption(options, 'minimumIntegerDigits', 1, 21, 1);
   defineWEProperty(internalOptions, 'minimumIntegerDigits', mnid);
 
   var mnfd = getNumberOption(options, 'minimumFractionDigits', 0, 20, 0);
   defineWEProperty(internalOptions, 'minimumFractionDigits', mnfd);
 
   var mxfd = getNumberOption(options, 'maximumFractionDigits', mnfd, 20, 3);
   defineWEProperty(internalOptions, 'maximumFractionDigits', mxfd);
 
   var mnsd = options['minimumSignificantDigits'];
   var mxsd = options['maximumSignificantDigits'];
-  if (mnsd !== undefined || mxsd !== undefined) {
+  if (!IS_UNDEFINED(mnsd) || !IS_UNDEFINED(mxsd)) {
     mnsd = getNumberOption(options, 'minimumSignificantDigits', 1, 21, 0);
     defineWEProperty(internalOptions, 'minimumSignificantDigits', mnsd);
 
     mxsd = getNumberOption(options, 'maximumSignificantDigits', mnsd, 21, 21);
     defineWEProperty(internalOptions, 'maximumSignificantDigits', mxsd);
   }
 
   // Grouping.
   defineWEProperty(internalOptions, 'useGrouping', getOption(
-    'useGrouping', 'boolean', undefined, true));
+    'useGrouping', 'boolean', UNDEFINED, true));
 
   // ICU prefers options to be passed using -u- extension key/values for
   // number format, so we need to build that.
   var extensionMap = parseExtension(locale.extension);
 
   /**
    * Map of Unicode extensions to option properties, and their values and types,
    * for a number format.
    */
   var NUMBER_FORMAT_KEY_MAP = {
-    'nu': {'property': undefined, 'type': 'string'}
+    'nu': {'property': UNDEFINED, 'type': 'string'}
   };
 
   var extension = setOptions(options, extensionMap, NUMBER_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
   var resolved = $objectDefineProperties({}, {
     currency: {writable: true},
     currencyDisplay: {writable: true},
     locale: {writable: true},
     maximumFractionDigits: {writable: true},
     minimumFractionDigits: {writable: true},
     minimumIntegerDigits: {writable: true},
     numberingSystem: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     style: {value: internalOptions.style, writable: true},
     useGrouping: {writable: true}
   });
   if (internalOptions.hasOwnProperty('minimumSignificantDigits')) {
-    defineWEProperty(resolved, 'minimumSignificantDigits', undefined);
+    defineWEProperty(resolved, 'minimumSignificantDigits', UNDEFINED);
   }
   if (internalOptions.hasOwnProperty('maximumSignificantDigits')) {
-    defineWEProperty(resolved, 'maximumSignificantDigits', undefined);
+    defineWEProperty(resolved, 'maximumSignificantDigits', UNDEFINED);
   }
   var formatter = %CreateNumberFormat(requestedLocale,
                                       internalOptions,
                                       resolved);
 
   // We can't get information about number or currency style from ICU, so we
   // assume user request was fulfilled.
   if (internalOptions.style === 'currency') {
     $objectDefineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
                                                         writable: true});
@@ skipping 148 matching lines @@
                      ['2-digit', 'numeric', 'narrow', 'short', 'long']);
   ldmlString += appendToLDMLString(option, {'2-digit': 'MM', 'numeric': 'M',
           'narrow': 'MMMMM', 'short': 'MMM', 'long': 'MMMM'});
 
   option = getOption('day', 'string', ['2-digit', 'numeric']);
   ldmlString += appendToLDMLString(
       option, {'2-digit': 'dd', 'numeric': 'd'});
 
   var hr12 = getOption('hour12', 'boolean');
   option = getOption('hour', 'string', ['2-digit', 'numeric']);
-  if (hr12 === undefined) {
+  if (IS_UNDEFINED(hr12)) {
     ldmlString += appendToLDMLString(option, {'2-digit': 'jj', 'numeric': 'j'});
   } else if (hr12 === true) {
     ldmlString += appendToLDMLString(option, {'2-digit': 'hh', 'numeric': 'h'});
   } else {
     ldmlString += appendToLDMLString(option, {'2-digit': 'HH', 'numeric': 'H'});
   }
 
   option = getOption('minute', 'string', ['2-digit', 'numeric']);
   ldmlString += appendToLDMLString(option, {'2-digit': 'mm', 'numeric': 'm'});
 
   option = getOption('second', 'string', ['2-digit', 'numeric']);
   ldmlString += appendToLDMLString(option, {'2-digit': 'ss', 'numeric': 's'});
 
   option = getOption('timeZoneName', 'string', ['short', 'long']);
   ldmlString += appendToLDMLString(option, {short: 'z', long: 'zzzz'});
 
   return ldmlString;
 }
 
 
 /**
  * Returns either LDML equivalent of the current option or empty string.
  */
 function appendToLDMLString(option, pairs) {
-  if (option !== undefined) {
+  if (!IS_UNDEFINED(option)) {
     return pairs[option];
   } else {
     return '';
   }
 }
 
 
 /**
  * Returns object that matches LDML representation of the date.
  */
@@ skipping 53 matching lines @@
   options = appendToDateTimeObject(
       options, 'timeZoneName', match, {z: 'short', zzzz: 'long'});
 
   return options;
 }
 
 
 function appendToDateTimeObject(options, option, match, pairs) {
   if (IS_NULL(match)) {
     if (!options.hasOwnProperty(option)) {
-      defineWEProperty(options, option, undefined);
+      defineWEProperty(options, option, UNDEFINED);
     }
     return options;
   }
 
   var property = match[0];
   defineWEProperty(options, option, pairs[property]);
 
   return options;
 }
 
 
 /**
  * Returns options with at least default values in it.
  */
 function toDateTimeOptions(options, required, defaults) {
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   } else {
     options = TO_OBJECT_INLINE(options);
   }
 
   var needsDefault = true;
   if ((required === 'date' || required === 'any') &&
-      (options.weekday !== undefined || options.year !== undefined ||
-       options.month !== undefined || options.day !== undefined)) {
+      (!IS_UNDEFINED(options.weekday) || !IS_UNDEFINED(options.year) ||
+       !IS_UNDEFINED(options.month) || !IS_UNDEFINED(options.day))) {
     needsDefault = false;
   }
 
   if ((required === 'time' || required === 'any') &&
-      (options.hour !== undefined || options.minute !== undefined ||
-       options.second !== undefined)) {
+      (!IS_UNDEFINED(options.hour) || !IS_UNDEFINED(options.minute) ||
+       !IS_UNDEFINED(options.second))) {
     needsDefault = false;
   }
 
   if (needsDefault && (defaults === 'date' || defaults === 'all')) {
     $objectDefineProperty(options, 'year', {value: 'numeric',
                                             writable: true,
                                             enumerable: true,
                                             configurable: true});
     $objectDefineProperty(options, 'month', {value: 'numeric',
                                              writable: true,
@@ skipping 27 matching lines @@
 /**
  * Initializes the given object so it's a valid DateTimeFormat instance.
  * Useful for subclassing.
  */
 function initializeDateTimeFormat(dateFormat, locales, options) {
 
   if (%IsInitializedIntlObject(dateFormat)) {
     throw MakeTypeError(kReinitializeIntl, "DateTimeFormat");
   }
 
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var locale = resolveLocale('dateformat', locales, options);
 
   options = toDateTimeOptions(options, 'any', 'date');
 
   var getOption = getGetOption(options, 'dateformat');
 
   // We implement only best fit algorithm, but still need to check
@@ skipping 12 matching lines @@
   // ICU prefers options to be passed using -u- extension key/values, so
   // we need to build that.
   var internalOptions = {};
   var extensionMap = parseExtension(locale.extension);
 
   /**
    * Map of Unicode extensions to option properties, and their values and types,
    * for a date/time format.
    */
   var DATETIME_FORMAT_KEY_MAP = {
-    'ca': {'property': undefined, 'type': 'string'},
-    'nu': {'property': undefined, 'type': 'string'}
+    'ca': {'property': UNDEFINED, 'type': 'string'},
+    'nu': {'property': UNDEFINED, 'type': 'string'}
   };
 
   var extension = setOptions(options, extensionMap, DATETIME_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
   var resolved = $objectDefineProperties({}, {
     calendar: {writable: true},
     day: {writable: true},
     era: {writable: true},
     hour12: {writable: true},
     hour: {writable: true},
     locale: {writable: true},
     minute: {writable: true},
     month: {writable: true},
     numberingSystem: {writable: true},
     pattern: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     second: {writable: true},
     timeZone: {writable: true},
     timeZoneName: {writable: true},
     tz: {value: tz, writable: true},
     weekday: {writable: true},
     year: {writable: true}
   });
 
   var formatter = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
-  if (tz !== undefined && tz !== resolved.timeZone) {
+  if (!IS_UNDEFINED(tz) && tz !== resolved.timeZone) {
     throw MakeRangeError(kUnsupportedTimeZone, tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
   $objectDefineProperty(dateFormat, 'resolved', {value: resolved});
 
   return dateFormat;
 }
 
 
@@ skipping 45 matching lines @@
       'chinese': 'chinese',
       'indian': 'indian',
       'coptic': 'coptic',
       'ethiopic': 'ethiopic',
       'ethiopic-amete-alem': 'ethioaa'
     };
 
     var format = this;
     var fromPattern = fromLDMLString(format.resolved.pattern);
     var userCalendar = ICU_CALENDAR_MAP[format.resolved.calendar];
-    if (userCalendar === undefined) {
+    if (IS_UNDEFINED(userCalendar)) {
       // Use ICU name if we don't have a match. It shouldn't happen, but
       // it would be too strict to throw for this.
       userCalendar = format.resolved.calendar;
     }
 
     var locale = getOptimalLanguageTag(format.resolved.requestedLocale,
                                        format.resolved.locale);
 
     var result = {
       locale: locale,
@@ skipping 43 matching lines @@
 %SetNativeFlag(Intl.DateTimeFormat.supportedLocalesOf);
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(date)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
  */
 function formatDate(formatter, dateValue) {
   var dateMs;
-  if (dateValue === undefined) {
+  if (IS_UNDEFINED(dateValue)) {
     dateMs = GlobalDate.now();
   } else {
     dateMs = $toNumber(dateValue);
   }
 
   if (!$isFinite(dateMs)) throw MakeRangeError(kDateRange);
 
   return %InternalDateFormat(%GetImplFromInitializedIntlObject(formatter),
                              new GlobalDate(dateMs));
 }
@@ skipping 15 matching lines @@
 addBoundMethod(Intl.DateTimeFormat, 'format', formatDate, 0);
 addBoundMethod(Intl.DateTimeFormat, 'v8Parse', parseDate, 1);
 
 
 /**
  * Returns canonical Area/Location name, or throws an exception if the zone
  * name is invalid IANA name.
  */
 function canonicalizeTimeZoneID(tzID) {
   // Skip undefined zones.
-  if (tzID === undefined) {
+  if (IS_UNDEFINED(tzID)) {
     return tzID;
   }
 
   // Special case handling (UTC, GMT).
   var upperID = tzID.toUpperCase();
   if (upperID === 'UTC' || upperID === 'GMT' ||
       upperID === 'ETC/UTC' || upperID === 'ETC/GMT') {
     return 'UTC';
   }
 
   // We expect only _ and / beside ASCII letters.
   // All inputs should conform to Area/Location from now on.
   var match = GetTimezoneNameCheckRE().exec(tzID);
   if (IS_NULL(match)) throw MakeRangeError(kExpectedLocation, tzID);
 
   var result = toTitleCaseWord(match[1]) + '/' + toTitleCaseWord(match[2]);
   var i = 3;
-  while (match[i] !== undefined && i < match.length) {
+  while (!IS_UNDEFINED(match[i]) && i < match.length) {
     result = result + '_' + toTitleCaseWord(match[i]);
     i++;
   }
 
   return result;
 }
 
 /**
  * Initializes the given object so it's a valid BreakIterator instance.
  * Useful for subclassing.
  */
 function initializeBreakIterator(iterator, locales, options) {
   if (%IsInitializedIntlObject(iterator)) {
     throw MakeTypeError(kReinitializeIntl, "v8BreakIterator");
   }
 
-  if (options === undefined) {
+  if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'type', getOption(
     'type', 'string', ['character', 'word', 'sentence', 'line'], 'word'));
 
@@ skipping 142 matching lines @@
   'numberformat': Intl.NumberFormat,
   'dateformatall': Intl.DateTimeFormat,
   'dateformatdate': Intl.DateTimeFormat,
   'dateformattime': Intl.DateTimeFormat
 };
 
 
 // Default (created with undefined locales and options parameters) collator,
 // number and date format instances. They'll be created as needed.
 var defaultObjects = {
-  'collator': undefined,
-  'numberformat': undefined,
-  'dateformatall': undefined,
-  'dateformatdate': undefined,
-  'dateformattime': undefined,
+  'collator': UNDEFINED,
+  'numberformat': UNDEFINED,
+  'dateformatall': UNDEFINED,
+  'dateformatdate': UNDEFINED,
+  'dateformattime': UNDEFINED,
 };
 
 
 /**
  * Returns cached or newly created instance of a given service.
  * We cache only default instances (where no locales or options are provided).
  */
 function cachedOrNewService(service, locales, options, defaults) {
-  var useOptions = (defaults === undefined) ? options : defaults;
-  if (locales === undefined && options === undefined) {
-    if (defaultObjects[service] === undefined) {
+  var useOptions = (IS_UNDEFINED(defaults)) ? options : defaults;
+  if (IS_UNDEFINED(locales) && IS_UNDEFINED(options)) {
+    if (IS_UNDEFINED(defaultObjects[service])) {
       defaultObjects[service] = new savedObjects[service](locales, useOptions);
     }
     return defaultObjects[service];
   }
   return new savedObjects[service](locales, useOptions);
 }
 
 
 /**
  * Compares this and that, and returns less than 0, 0 or greater than 0 value.
@@ skipping 133 matching lines @@
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })