6.2.1 Unicode Locale Extension Sequences

This standard uses the term “Unicode locale extension sequence” for any substring of a language tag that starts with a separator "-" and the singleton "u" and includes the maximum sequence of following non-singleton subtags and their preceding "-" separators.

6.2.2 IsStructurallyValidLanguageTag (locale)

The IsStructurallyValidLanguageTag abstract operation verifies that the locale argument (which must be a String value)

• represents a well-formed BCP 47 language tag as specified in RFC 5646 section 2.1, or successor,
• does not include duplicate variant subtags, and
• does not include duplicate singleton subtags.

The abstract operation returns true if locale can be generated from the ABNF grammar in section 2.1 of the RFC, starting with Language-Tag, and does not contain duplicate variant or singleton subtags (other than as a private use subtag). It returns false otherwise. Terminal value characters in the grammar are interpreted as the Unicode equivalents of the ASCII octet values given.

6.2.3 CanonicalizeLanguageTag (locale)

The CanonicalizeLanguageTag abstract operation returns the canonical and case-regularized form of the locale argument (which must be a String value that is a structurally valid BCP 47 language tag as verified by the IsStructurallyValidLanguageTag abstract operation). It takes the steps specified in RFC 5646 section 4.5, or successor, to bring the language tag into canonical form, and to regularize the case of the subtags, but does not take the steps to bring a language tag into “extlang form” and to reorder variant subtags.

The specifications for extensions to BCP 47 language tags, such as RFC 6067, may include canonicalization rules for the extension subtag sequences they define that go beyond the canonicalization rules of RFC 5646 section 4.5. Implementations are allowed, but not required, to apply these additional rules.

6.2.4 DefaultLocale ()

The DefaultLocale abstract operation returns a String value representing the structurally valid (6.2.2) and canonicalized (6.2.3) BCP 47 language tag for the host environment’s current locale.

6.3.1 IsWellFormedCurrencyCode (currency)

The IsWellFormedCurrencyCode abstract operation verifies that the currency argument (after conversion to a String value) represents a well-formed 3-letter ISO currency code. The following steps are taken:

1. Let c be ToString(currency).
2. Let normalized be the result of mapping c to upper case as described in 6.1.
3. If the string length of normalized is not 3, return false.
4. If normalized contains any character that is not in the range "A" to "Z" (U+0041 to U+005A), return false.
5. Return true.

9.2.1 CanonicalizeLocaleList (locales)

The abstract operation CanonicalizeLocaleList takes the following steps:

1. If locales is undefined, then
   1. Return a new empty List.
2. Let seen be a new empty List.
3. If locales is a String value, then
   1. Let locales be a new array created as if by the expression new Array(locales) where Array is the standard built-in constructor with that name and locales is the value of locales.
4. Let O be ToObject(locales).
5. Let lenValue be the result of calling the [[Get]] internal method of O with the argument "length".
6. Let len be ToUint32(lenValue).
7. Let k be 0.
8. Repeat, while k < len
   1. Let Pk be ToString(k).
   2. Let kPresent be the result of calling the [[HasProperty]] internal method of O with argument Pk.
   3. If kPresent is true, then
      1. Let kValue be the result of calling the [[Get]] internal method of O with argument Pk.
      2. If the type of kValue is not String or Object, then throw a TypeError exception.
      3. Let tag be ToString(kValue).
      4. If the result of calling the abstract operation IsStructurallyValidLanguageTag (defined in 6.2.2), passing tag as the argument, is false, then throw a RangeError exception.
      5. Let tag be the result of calling the abstract operation CanonicalizeLanguageTag (defined in 6.2.3), passing tag as the argument.
      6. If tag is not an element of seen, then append tag as the last element of seen.
   4. Increase k by 1.
9. Return seen.

9.2.2 BestAvailableLocale (availableLocales, locale)

The BestAvailableLocale abstract operation compares the provided argument locale, which must be a String value with a structurally valid and canonicalized BCP 47 language tag, against the locales in availableLocales and returns either the longest non-empty prefix of locale that is an element of availableLocales, or undefined if there is no such element. It uses the fallback mechanism of RFC 4647, section 3.4. The following steps are taken:

1. Let candidate be locale.
2. Repeat
   1. If availableLocales contains an element equal to candidate, then return candidate.
   2. Let pos be the character index of the last occurrence of "-" (U+002D) within candidate. If that character does not occur, return undefined.
   3. If pos ≥ 2 and the character "-" occurs at index pos-2 of candidate, then decrease pos by 2.
   4. Let candidate be the substring of candidate from position 0, inclusive, to position pos, exclusive.

9.2.3 LookupMatcher (availableLocales, requestedLocales)

The LookupMatcher abstract operation compares requestedLocales, which must be a List as returned by CanonicalizeLocaleList, against the locales in availableLocales and determines the best available language to meet the request. The following steps are taken:

1. Let i be 0.
2. Let len be the number of elements in requestedLocales.
3. Let availableLocale be undefined.
4. Repeat while i < len and availableLocale is undefined:
   1. Let locale be the element of requestedLocales at 0-origined list position i.
   2. Let noExtensionsLocale be the String value that is locale with all Unicode locale extension sequences removed.
   3. Let availableLocale be the result of calling the BestAvailableLocale abstract operation (defined in 9.2.2) with arguments availableLocales and noExtensionsLocale.
   4. Increase i by 1.
5. Let result be a new Record.
6. If availableLocale is not undefined, then
   1. Set result.[[locale]] to availableLocale.
   2. If locale and noExtensionsLocale are not the same String value, then
      1. Let extension be the String value consisting of the first substring of locale that is a Unicode locale extension sequence.
      2. Let extensionIndex be the character position of the initial "-" of the first Unicode locale extension sequence within locale.
      3. Set result.[[extension]] to extension.
      4. Set result.[[extensionIndex]] to extensionIndex.
7. Else
   1. Set result.[[locale]] to the value returned by the DefaultLocale abstract operation (defined in 6.2.4).
8. Return result.

9.2.4 BestFitMatcher (availableLocales, requestedLocales)

The BestFitMatcher abstract operation compares requestedLocales, which must be a List as returned by CanonicalizeLocaleList, against the locales in availableLocales and determines the best available language to meet the request. The algorithm is implementation dependent, but should produce results that a typical user of the requested locales would perceive as at least as good as those produced by the LookupMatcher abstract operation. Options specified through Unicode locale extension sequences must be ignored by the algorithm. Information about such subsequences is returned separately. The abstract operation returns a record with a [[locale]] field, whose value is the language tag of the selected locale, which must be an element of availableLocales. If the language tag of the request locale that led to the selected locale contained a Unicode locale extension sequence, then the returned record also contains an [[extension]] field whose value is the first Unicode locale extension sequence, and an [[extensionIndex]] field whose value is the index of the first Unicode locale extension sequence within the request locale language tag.

9.2.5 ResolveLocale (availableLocales, requestedLocales, options, relevantExtensionKeys, localeData)

The ResolveLocale abstract operation compares a BCP 47 language priority list requestedLocales against the locales in availableLocales and determines the best available language to meet the request. availableLocales and requestedLocales must be provided as List values, options as a Record.

The following steps are taken:

1. Let matcher be the value of options.[[localeMatcher]].
2. If matcher is "lookup", then
   1. Let r be the result of calling the LookupMatcher abstract operation (defined in 9.2.3) with arguments availableLocales and requestedLocales.
3. Else
   1. Let r be the result of calling the BestFitMatcher abstract operation (defined in 9.2.4) with arguments availableLocales and requestedLocales.
4. Let foundLocale be the value of r.[[locale]].
5. If r has an [[extension]] field, then
   1. Let extension be the value of r.[[extension]].
   2. Let extensionIndex be the value of r.[[extensionIndex]].
   3. Let split be the standard built-in function object defined in ES5, 15.5.4.14.
   4. Let extensionSubtags be the result of calling the [[Call]] internal method of split with extension as the this value and an argument list containing the single item "-".
   5. Let extensionSubtagsLength be the result of calling the [[Get]] internal method of extensionSubtags with argument "length".
6. Let result be a new Record.
7. Set result.[[dataLocale]] to foundLocale.
8. Let supportedExtension be "-u".
9. Let i be 0.
10. Let len be the result of calling the [[Get]] internal method of relevantExtensionKeys with argument "length".
11. Repeat while i < len:
    1. Let key be the result of calling the [[Get]] internal method of relevantExtensionKeys with argument ToString(i).
    2. Let foundLocaleData be the result of calling the [[Get]] internal method of localeData with the argument foundLocale.
    3. Let keyLocaleData be the result of calling the [[Get]] internal method of foundLocaleData with the argument key.
    4. Let value be the result of calling the [[Get]] internal method of keyLocaleData with argument "0".
    5. Let supportedExtensionAddition be "".
    6. Let indexOf be the standard built-in function object defined in ES5, 15.4.4.14.
    7. If extensionSubtags is not undefined, then
       1. Let keyPos be the result of calling the [[Call]] internal method of indexOf with extensionSubtags as the this value and an argument list containing the single item key.
       2. If keyPos ≠ -1, then
          1. If keyPos + 1 < extensionSubtagsLength and the length of the result of calling the [[Get]] internal method of extensionSubtags with argument ToString(keyPos +1) is greater than 2, then
             1. Let requestedValue be the result of calling the [[Get]] internal method of extensionSubtags with argument ToString(keyPos + 1).
             2. Let valuePos be the result of calling the [[Call]] internal method of indexOf with keyLocaleData as the this value and an argument list containing the single item requestedValue.
             3. If valuePos ≠ -1, then
                1. Let value be requestedValue.
                2. Let supportedExtensionAddition be the concatenation of "-", key, "-", and value.
          2. Else
             1. Let valuePos be the result of calling the [[Call]] internal method of indexOf with keyLocaleData as the this value and an argument list containing the single item "true".
             2. If valuePos ≠ -1, then
                1. Let value be "true".
    8. If options has a field [[<key>]], then
       1. Let optionsValue be the value of options.[[<key>]].
       2. If the result of calling the [[Call]] internal method of indexOf with keyLocaleData as the this value and an argument list containing the single item optionsValue is not -1, then
          1. If optionsValue is not equal to value, then
             1. Let value be optionsValue.
             2. Let supportedExtensionAddition be "".
    9. Set result.[[<key>]] to value.
    10. Append supportedExtensionAddition to supportedExtension.
    11. Increase i by 1.
12. If the length of supportedExtension is greater than 2, then
    1. Let preExtension be the substring of foundLocale from position 0, inclusive, to position extensionIndex, exclusive.
    2. Let postExtension be the substring of foundLocale from position extensionIndex to the end of the string.
    3. Let foundLocale be the concatenation of preExtension, supportedExtension, and postExtension.
13. Set result.[[locale]] to foundLocale.
14. Return result.

9.2.6 LookupSupportedLocales (availableLocales, requestedLocales)

The LookupSupportedLocales abstract operation returns the subset of the provided BCP 47 language priority list requestedLocales for which availableLocales has a matching locale when using the BCP 47 Lookup algorithm. Locales appear in the same order in the returned list as in requestedLocales. The following steps are taken:

1. Let len be the number of elements in requestedLocales.
2. Let subset be a new empty List.
3. Let k be 0.
4. Repeat while k < len
   1. Let locale be the element of requestedLocales at 0-origined list position k.
   2. Let noExtensionsLocale be the String value that is locale with all Unicode locale extension sequences removed.
   3. Let availableLocale be the result of calling the BestAvailableLocale abstract operation (defined in 9.2.2) with arguments availableLocales and noExtensionsLocale.
   4. If availableLocale is not undefined, then append locale to the end of subset.
   5. Increment k by 1.
5. Let subsetArray be a new Array object whose elements are the same values in the same order as the elements of subset.
6. Return subsetArray.

9.2.7 BestFitSupportedLocales (availableLocales, requestedLocales)

The BestFitSupportedLocales abstract operation returns the subset of the provided BCP 47 language priority list requestedLocales for which availableLocales has a matching locale when using the Best Fit Matcher algorithm. Locales appear in the same order in the returned list as in requestedLocales. The steps taken are implementation dependent.

9.2.8 SupportedLocales (availableLocales, requestedLocales, options)

The SupportedLocales abstract operation returns the subset of the provided BCP 47 language priority list requestedLocales for which availableLocales has a matching locale. Two algorithms are available to match the locales: the Lookup algorithm described in RFC 4647 section 3.4, and an implementation dependent best-fit algorithm. Locales appear in the same order in the returned list as in requestedLocales. The following steps are taken:

1. If options is not undefined, then
   1. Let options be ToObject(options).
   2. Let matcher be the result of calling the [[Get]] internal method of options with argument "localeMatcher".
   3. If matcher is not undefined, then
      1. Let matcher be ToString(matcher).
      2. If matcher is not "lookup" or "best fit", then throw a RangeError exception.
2. If matcher is undefined or "best fit", then
   1. Let subset be the result of calling the BestFitSupportedLocales abstract operation (defined in 9.2.7) with arguments availableLocales and requestedLocales.
3. Else
   1. Let subset be the result of calling the LookupSupportedLocales abstract operation (defined in 9.2.6) with arguments availableLocales and requestedLocales.
4. For each named own property name P of subset,
   1. Let desc be the result of calling the [[GetOwnProperty]] internal method of subset with P.
   2. Set desc.[[Writable]] to false.
   3. Set desc.[[Configurable]] to false.
   4. Call the [[DefineOwnProperty]] internal method of subset with P, desc, and true as arguments.
5. Return subset.

9.2.9 GetOption (options, property, type, values, fallback)

The GetOption abstract operation extracts the value of the property named property from the provided options object, converts it to the required type, checks whether it is one of a List of allowed values, and fills in a fallback value if necessary.

1. Let value be the result of calling the [[Get]] internal method of options with argument property.
2. If value is not undefined, then
   1. Assert: type is "boolean" or "string".
   2. If type is "boolean", then let value be ToBoolean(value).
   3. If type is "string", then let value be ToString(value).
   4. If values is not undefined, then
      1. If values does not contain an element equal to value, then throw a RangeError exception.
   5. Return value.
3. Else return fallback.

9.2.10 GetNumberOption (options, property, minimum, maximum, fallback)

The GetNumberOption abstract operation extracts a property value from the provided options object, converts it to a Number value, checks whether it is in the allowed range, and fills in a fallback value if necessary.

1. Let value be the result of calling the [[Get]] internal method of options with argument property.
2. If value is not undefined, then
   1. Let value be ToNumber(value).
   2. If value is NaN or less than minimum or greater than maximum, throw a RangeError exception.
   3. Return floor(value).
3. Else return fallback.

10.1.1 Initializing an Object as a Collator

10.1.2 The Intl.Collator Constructor Called as a Function

10.1.3 The Intl.Collator Constructor Used in a new Expression

10.2.1 Intl.Collator.prototype

The value of Intl.Collator.prototype is the built-in Intl.Collator prototype object (10.3).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

10.2.2 Intl.Collator.supportedLocalesOf (locales [, options])

When the supportedLocalesOf method of Intl.Collator is called, the following steps are taken:

1. If options is not provided, then let options be undefined.
2. Let availableLocales be the value of the [[availableLocales]] internal property of the standard built-in object that is the initial value of Intl.Collator.
3. Let requestedLocales be the result of calling the CanonicalizeLocaleList abstract operation (defined in 9.2.1) with argument locales.
4. Return the result of calling the SupportedLocales abstract operation (defined in 9.2.8) with arguments availableLocales, requestedLocales, and options.

The value of the length property of the supportedLocalesOf method is 1.

10.2.3 Internal Properties

The value of the [[availableLocales]] internal property is implementation defined within the constraints described in 9.1.

The value of the [[relevantExtensionKeys]] internal property is an array that must include the element "co", may include any or all of the elements "kn" and "kf", and must not include any other elements.

The values of the [[sortLocaleData]] and [[searchLocaleData]] internal properties are implementation defined within the constraints described in 9.1 and the following additional constraints:

• The first element of [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co must be null for all locale values.

• The values "standard" and "search" must not be used as elements in any [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co array.

• [[searchLocaleData]][locale] must have a sensitivity property with a String value equal to "base", "accent", "case", or "variant" for all locale values.

10.3.1 Intl.Collator.prototype.constructor

The initial value of Intl.Collator.prototype.constructor is the built-in Intl.Collator constructor.

10.3.2 Intl.Collator.prototype.compare

This named accessor property returns a function that compares two strings according to the sort order of this Collator object.

The value of the [[Get]] attribute is a function that takes the following steps:

1. If the [[boundCompare]] internal property of this Collator object is undefined, then:
   1. Let F be a Function object, with internal properties set as specified for built-in functions in ES5, 15, or successor, and the length property set to 2, that takes the arguments x and y and performs the following steps:
      1. If x is not provided, then let x be undefined.
      2. If y is not provided, then let y be undefined.
      3. Let X be ToString(x).
      4. Let Y be ToString(y).
      5. Return the result of calling the CompareStrings abstract operation (defined below) with arguments this, X, and Y.
   2. Let bind be the standard built-in function object defined in ES5, 15.3.4.5.
   3. Let bc be the result of calling the [[Call]] internal method of bind with F as the this value and an argument List containing the single item this.
   4. Set the [[boundCompare]] internal property of this Collator object to bc.
2. Return the value of the [[boundCompare]] internal property of this Collator object.

The value of the [[Set]] attribute is undefined.

When the CompareStrings abstract operation is called with arguments collator (which must be an object initialized as a Collator), x and y (which must be String values), it returns a Number other than NaN that represents the result of a locale-sensitive String comparison of x with y. The two Strings are compared in an implementation-defined fashion. The result is intended to order String values in the sort order specified by the effective locale and collation options computed during construction of collator, and will be negative, zero, or positive, depending on whether x comes before y in the sort order, the Strings are equal under the sort order, or x comes after y in the sort order, respectively. String values must be interpreted as UTF-16 code unit sequences, and a surrogate pair (a code unit in the range 0xD800 to 0xDBFF followed by a code unit in the range 0xDC00 to 0xDFFF) within a string must be interpreted as the corresponding code point.

The sensitivity of collator is interpreted as follows:

• base: Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.

• accent: Only strings that differ in base letters or accents and other diacritic marks compare as unequal. Examples: a ≠ b, a ≠ á, a = A.

• case: Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.

• variant: Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal. Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A.

If the collator is set to ignore punctuation, then strings that differ only in punctuation compare as equal.

For the interpretation of options settable through extension keys, see Unicode Technical Standard 35.

The CompareStrings abstract operation with any given collator argument, if considered as a function of the remaining two arguments x and y, must be a consistent comparison function (as defined in ES5, 15.4.4.11) on the set of all Strings.

The actual return values are implementation-defined to permit implementers to encode additional information in the value. The method is required to return 0 when comparing Strings that are considered canonically equivalent by the Unicode standard.

10.3.3 Intl.Collator.prototype.resolvedOptions ()

This function provides access to the locale and collation options computed during initialization of the object.

The function returns a new object whose properties and attributes are set as if constructed by an object literal assigning to each of the following properties the value of the corresponding internal property of this Collator object (see 10.4): locale, usage, sensitivity, ignorePunctuation, collation, as well as those properties shown in Table 1 whose keys are included in the [[relevantExtensionKeys]] internal property of the standard built-in object that is the initial value of Intl.Collator.

11.1.1 Initializing an Object as a NumberFormat

11.1.2 The Intl.NumberFormat Constructor Called as a Function

11.1.3 The Intl.NumberFormat Constructor Used in a new Expression

11.2.1 Intl.NumberFormat.prototype

The value of Intl.NumberFormat.prototype is the built-in Intl.NumberFormat prototype object (11.3).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

11.2.2 Intl.NumberFormat.supportedLocalesOf (locales [, options])

When the supportedLocalesOf method of Intl.NumberFormat is called, the following steps are taken:

1. If options is not provided, then let options be undefined.
2. Let availableLocales be the value of the [[availableLocales]] internal property of the standard built-in object that is the initial value of Intl.NumberFormat.
3. Let requestedLocales be the result of calling the CanonicalizeLocaleList abstract operation (defined in 9.2.1) with argument locales.
4. Return the result of calling the SupportedLocales abstract operation (defined in 9.2.8) with arguments availableLocales, requestedLocales, and options.

The value of the length property of the supportedLocalesOf method is 1.

11.2.3 Internal Properties

The value of the [[availableLocales]] internal property is implementation defined within the constraints described in 9.1.

The value of the [[relevantExtensionKeys]] internal property is ["nu"].

The value of the [[localeData]] internal property is implementation defined within the constraints described in 9.1 and the following additional constraints:

• The array that is the value of the "nu" property of any locale property of [[localeData]] must not include the values "native", "traditio", or "finance".

• [[localeData]][locale] must have a patterns property for all locale values. The value of this property must be an object, which must have properties with the names of the three number format styles: "decimal", "percent", and "currency". Each of these properties in turn must be an object with the properties positivePattern and negativePattern. The value of these properties must be string values that contain a substring "{number}"; the values within the currency property must also contain a substring "{currency}". The pattern strings must not contain any characters in the General Category “Number, decimal digit” as specified by the Unicode Standard.

11.3.1 Intl.NumberFormat.prototype.constructor

The initial value of Intl.NumberFormat.prototype.constructor is the built-in Intl.NumberFormat constructor.

11.3.2 Intl.NumberFormat.prototype.format

This named accessor property returns a function that formats a number according to the effective locale and the formatting options of this NumberFormat object.

The value of the [[Get]] attribute is a function that takes the following steps:

1. If the [[boundFormat]] internal property of this NumberFormat object is undefined, then:
   1. Let F be a Function object, with internal properties set as specified for built-in functions in ES5, 15, or successor, and the length property set to 1, that takes the argument value and performs the following steps:
      1. If value is not provided, then let value be undefined.
      2. Let x be ToNumber(value).
      3. Return the result of calling the FormatNumber abstract operation (defined below) with arguments this and x.
   2. Let bind be the standard built-in function object defined in ES5, 15.3.4.5.
   3. Let bf be the result of calling the [[Call]] internal method of bind with F as the this value and an argument list containing the single item this.
   4. Set the [[boundFormat]] internal property of this NumberFormat object to bf.
2. Return the value of the [[boundFormat]] internal property of this NumberFormat object.

The value of the [[Set]] attribute is undefined.

When the FormatNumber abstract operation is called with arguments numberFormat (which must be an object initialized as a NumberFormat) and x (which must be a Number value), it returns a String value representing x according to the effective locale and the formatting options of numberFormat.

The computations rely on String values and locations within numeric strings that are dependent upon the implementation and the effective locale of numberFormat (“ILD”) or upon the implementation, the effective locale, and the numbering system of numberFormat (“ILND”). The ILD and ILND Strings mentioned, other than those for currency names, must not contain any characters in the General Category “Number, decimal digit” as specified by the Unicode Standard.

The following steps are taken:

1. Let negative be false.
2. If the result of isFinite(x) is false, then
   1. If x is NaN, then let n be an ILD String value indicating the NaN value.
   2. Else
      1. Let n be an ILD String value indicating infinity.
      2. If x < 0, then let negative be true.
3. Else
   1. If x < 0, then
      1. Let negative be true.
      2. Let x be -x.
   2. If the value of the [[style]] internal property of numberFormat is "percent", let x be 100 × x.
   3. If the [[minimumSignificantDigits]] and [[maximumSignificantDigits]] internal properties of numberFormat are present, then
      1. Let n be the result of calling the ToRawPrecision abstract operation (defined below), passing as arguments x and the values of the [[minimumSignificantDigits]] and [[maximumSignificantDigits]] internal properties of numberFormat.
   4. Else
      1. Let n be the result of calling the ToRawFixed abstract operation (defined below), passing as arguments x and the values of the [[minimumIntegerDigits]], [[minimumFractionDigits]], and [[maximumFractionDigits]] internal properties of numberFormat.
   5. If the value of the [[numberingSystem]] internal property of numberFormat matches one of the values in the “Numbering System” column of Table 2 below, then
      1. Let digits be an array whose 10 String valued elements are the UTF-16 string representations of the 10 digits specified in the “Digits” column of Table 2 in the row containing the value of the [[numberingSystem]] internal property.
      2. Replace each digit in n with the value of digits[digit].
   6. Else use an implementation dependent algorithm to map n to the appropriate representation of n in the given numbering system.
   7. If n contains the character ".", then replace it with an ILND String representing the decimal separator.
   8. If the value of the [[useGrouping]] internal property of numberFormat is true, then insert an ILND String representing a grouping separator into an ILND set of locations within the integer part of n.
4. If negative is true, then let result be the value of the [[negativePattern]] internal property of numberFormat; else let result be the value of the [[positivePattern]] internal property of numberFormat.
5. Replace the substring "{number}" within result with n.
6. If the value of the [[style]] internal property of numberFormat is "currency", then:
   1. Let currency be the value of the [[currency]] internal property of numberFormat.
   2. If the value of the [[currencyDisplay]] internal property of numberFormat is "code", then let cd be currency.
   3. Else if the value of the [[currencyDisplay]] internal property of numberFormat is "symbol", then let cd be an ILD string representing currency in short form. If the implementation does not have such a representation of currency, then use currency itself.
   4. Else if the value of the [[currencyDisplay]] internal property of numberFormat is "name", then let cd be an ILD string representing currency in long form. If the implementation does not have such a representation of currency, then use currency itself.
   5. Replace the substring "{currency}" within result with cd.
7. Return result.

When the ToRawPrecision abstract operation is called with arguments x (which must be a finite non-negative number), minPrecision, and maxPrecision (both must be integers between 1 and 21) the following steps are taken:

1. Let p be maxPrecision.
2. If x = 0, then
   1. Let m be the String consisting of p occurrences of the character "0".
   2. Let e be 0.
3. Else
   1. Let e and n be integers such that 10^p–1 ≤ n < 10^p and for which the exact mathematical value of n × 10^e–p+1 – x is as close to zero as possible. If there are two such sets of e and n, pick the e and n for which n × 10^e–p+1 is larger.
   2. Let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
4. If e ≥ p, then
   1. Return the concatenation of m and e-p+1 occurrences of the character "0".
5. If e = p-1, then
   1. Return m.
6. If e ≥ 0, then
   1. Let m be the concatenation of the first e+1 characters of m, the character ".", and the remaining p–(e+1) characters of m.
7. If e < 0, then
   1. Let m be the concatenation of the String "0.", –(e+1) occurrences of the character "0", and the string m.
8. If m contains the character ".", and maxPrecision > minPrecision, then
   1. Let cut be maxPrecision – minPrecision.
   2. Repeat while cut > 0 and the last character of m is "0":
      1. Remove the last character from m.
      2. Decrease cut by 1.
   3. If the last character of m is ".", then
      1. Remove the last character from m.
9. Return m.

When the ToRawFixed abstract operation is called with arguments x (which must be a finite non-negative number), minInteger (which must be an integer between 1 and 21), minFraction, and maxFraction (which must be integers between 0 and 20) the following steps are taken:

1. Let f be maxFraction.
2. Let n be an integer for which the exact mathematical value of n ÷ 10^f – x is as close to zero as possible. If there are two such n, pick the larger n.
3. If n = 0, let m be the String "0". Otherwise, let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
4. If f ≠ 0, then
   1. Let k be the number of characters in m.
   2. If k ≤ f, then
      1. Let z be the String consisting of f+1–k occurrences of the character "0".
      2. Let m be the concatenation of Strings z and m.
      3. Let k=f+1.
   3. Let a be the first k–f characters of m, and let b be the remaining f characters of m.
   4. Let m be the concatenation of the three Strings a, ".", and b.
   5. Let int be the number of characters in a.
5. Else let int be the number of characters in m.
6. Let cut be maxFraction – minFraction.
7. Repeat while cut > 0 and the last character of m is "0":
   1. Remove the last character from m.
   2. Decrease cut by 1.
8. If the last character of m is ".", then
   1. Remove the last character from m.
9. If int < minInteger, then
   1. Let z be the String consisting of minInteger–int occurrences of the character "0".
   2. Let m be the concatenation of Strings z and m.
10. Return m.

11.3.3 Intl.NumberFormat.prototype.resolvedOptions ()

This function provides access to the locale and formatting options computed during initialization of the object.

The function returns a new object whose properties and attributes are set as if constructed by an object literal assigning to each of the following properties the value of the corresponding internal property of this NumberFormat object (see 11.4): locale, numberingSystem, style, currency, currencyDisplay, minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, minimumSignificantDigits, maximumSignificantDigits, and useGrouping. Properties whose corresponding internal properties are not present are not assigned.

12.1.1 Initializing an Object as a DateTimeFormat

12.1.2 The Intl.DateTimeFormat Constructor Called as a Function

12.1.3 The Intl.DateTimeFormat Constructor Used in a new Expression

12.2.1 Intl.DateTimeFormat.prototype

The value of Intl.DateTimeFormat.prototype is the built-in Intl.DateTimeFormat prototype object (12.3).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

12.2.2 Intl.DateTimeFormat.supportedLocalesOf (locales [, options])

When the supportedLocalesOf method of Intl.DateTimeFormat is called, the following steps are taken:

1. If options is not provided, then let options be undefined.
2. Let availableLocales be the value of the [[availableLocales]] internal property of the standard built-in object that is the initial value of Intl.DateTimeFormat.
3. Let requestedLocales be the result of calling the CanonicalizeLocaleList abstract operation (defined in 9.2.1) with argument locales.
4. Return the result of calling the SupportedLocales abstract operation (defined in 9.2.8) with arguments availableLocales, requestedLocales, and options.

The value of the length property of the supportedLocalesOf method is 1.

12.2.3 Internal Properties

The value of the [[availableLocales]] internal property is implementation defined within the constraints described in 9.1.

The value of the [[relevantExtensionKeys]] internal property is ["ca", "nu"].

The value of the [[localeData]] internal property is implementation defined within the constraints described in 9.1 and the following additional constraints:

• The array that is the value of the "nu" property of any locale property of [[localeData]] must not include the values "native", "traditio", or "finance".

• [[localeData]][locale] must have hour12 and hourNo0 properties with Boolean values for all locale values.

• [[localeData]][locale] must have a formats property for all locale values. The value of this property must be an array of objects, each of which has a subset of the properties shown in Table 3, where each property must have one of the values specified for the property in Table 3. Multiple objects in an array may use the same subset of the properties as long as they have different values for the properties. The following subsets must be available for each locale:

  • weekday, year, month, day, hour, minute, second
  • weekday, year, month, day
  • year, month, day
  • year, month
  • month, day
  • hour, minute, second
  • hour, minute

• Each of the objects must also have a pattern property, whose value is a String value that contains for each of the date and time format component properties of the object a substring starting with "{", followed by the name of the property, followed by "}". If the object has an hour property, it must also have a pattern12 property, whose value is a String value that, in addition to the substrings of the pattern property, contains a substring "{ampm}".

12.3.1 Intl.DateTimeFormat.prototype.constructor

The initial value of Intl.DateTimeFormat.prototype.constructor is the built-in Intl.DateTimeFormat constructor.

12.3.2 Intl.DateTimeFormat.prototype.format

This named accessor property returns a function that formats a date according to the effective locale and the formatting options of this DateTimeFormat object.

The value of the [[Get]] attribute is a function that takes the following steps:

1. If the [[boundFormat]] internal property of this DateTimeFormat object is undefined, then:
   1. Let F be a Function object, with internal properties set as specified for built-in functions in ES5, 15, or successor, and the length property set to 0, that takes the argument date and performs the following steps:
      1. If date is not provided or is undefined, then let x be the result as if by the expression Date.now() where Date.now is the standard built-in function defined in ES5, 15.9.4.4.
      2. Else let x be ToNumber(date).
      3. Return the result of calling the FormatDateTime abstract operation (defined below) with arguments this and x.
   2. Let bind be the standard built-in function object defined in ES5, 15.3.4.5.
   3. Let bf be the result of calling the [[Call]] internal method of bind with F as the this value and an argument list containing the single item this.
   4. Set the [[boundFormat]] internal property of this DateTimeFormat object to bf.
2. Return the value of the [[boundFormat]] internal property of this DateTimeFormat object.

The value of the [[Set]] attribute is undefined.

When the FormatDateTime abstract operation is called with arguments dateTimeFormat (which must be an object initialized as a DateTimeFormat) and x (which must be a Number value), it returns a String value representing x (interpreted as a time value as specified in ES5, 15.9.1.1) according to the effective locale and the formatting options of dateTimeFormat.

1. If x is not a finite Number, then throw a RangeError exception.
2. Let locale be the value of the [[locale]] internal property of dateTimeFormat.
3. Let nf be the result of creating a new NumberFormat object as if by the expression new Intl.NumberFormat([locale], {useGrouping: false}) where Intl.NumberFormat is the standard built-in constructor defined in 11.1.3.
4. Let nf2 be the result of creating a new NumberFormat object as if by the expression new Intl.NumberFormat([locale], {minimumIntegerDigits: 2, useGrouping: false}) where Intl.NumberFormat is the standard built-in constructor defined in 11.1.3.
5. Let tm be the result of calling the ToLocalTime abstract operation (defined below) with x, the value of the [[calendar]] internal property of dateTimeFormat, and the value of the [[timeZone]] internal property of dateTimeFormat.
6. Let result be the value of the [[pattern]] internal property of dateTimeFormat.
7. For each row of Table 3, except the header row, do:
   1. If dateTimeFormat has an internal property with the name given in the Property column of the row, then:
      1. Let p be the name given in the Property column of the row.
      2. Let f be the value of the [[<p>]] internal property of dateTimeFormat.
      3. Let v be the value of tm.[[<p>]].
      4. If p is "year" and v ≤ 0, then let v be 1 - v.
      5. If p is "month", then increase v by 1.
      6. If p is "hour" and the value of the [[hour12]] internal property of dateTimeFormat is true, then
         1. Let v be v modulo 12.
         2. If v is equal to the value of tm.[[<p>]], then let pm be false; else let pm be true.
         3. If v is 0 and the value of the [[hourNo0]] internal property of dateTimeFormat is true, then let v be 12.
      7. If f is "numeric", then
         1. Let fv be the result of calling the FormatNumber abstract operation (defined in 11.3.2) with arguments nf and v.
      8. Else if f is "2-digit", then
         1. Let fv be the result of calling the FormatNumber abstract operation with arguments nf2 and v.
         2. If the length of fv is greater than 2, let fv be the substring of fv containing the last two characters.
      9. Else if f is "narrow", "short", or "long", then let fv be a String value representing f in the desired form; the String value depends upon the implementation and the effective locale and calendar of dateTimeFormat. If p is "month", then the String value may also depend on whether dateTimeFormat has a [[day]] internal property. If p is "timeZoneName", then the String value may also depend on the value of the [[inDST]] field of tm.
      10. Replace the substring of result that consists of "{", p, and "}", with fv.
8. If dateTimeFormat has an internal property [[hour12]] whose value is true, then
   1. If pm is true, then let fv be an implementation and locale dependent String value representing “post meridiem”; else let fv be an implementation and locale dependent String value representing “ante meridiem”.
   2. Replace the substring of result that consists of "{ampm}", with fv.
9. Return result.

When the ToLocalTime abstract operation is called with arguments date, calendar, and timeZone, the following steps are taken:

1. Apply calendrical calculations on date for the given calendar and time zone to produce weekday, era, year, month, day, hour, minute, second, and inDST values. The calculations should use best available information about the specified calendar and time zone. If the calendar is "gregory", then the calculations must match the algorithms specified in ES5, 15.9.1, except that calculations are not bound by the restrictions on the use of best available information on time zones for local time zone adjustment and daylight saving time adjustment imposed by ES5, 15.9.1.7 and 15.9.1.8.
2. Return a Record with fields [[weekday]], [[era]], [[year]], [[month]], [[day]], [[hour]], [[minute]], [[second]], and [[inDST]], each with the corresponding calculated value.

12.3.3 Intl.DateTimeFormat.prototype.resolvedOptions ()

This function provides access to the locale and formatting options computed during initialization of the object.

The function returns a new object whose properties and attributes are set as if constructed by an object literal assigning to each of the following properties the value of the corresponding internal property of this DateTimeFormat object (see 12.4): locale, calendar, numberingSystem, timeZone, hour12, weekday, era, year, month, day, hour, minute, second, and timeZoneName. Properties whose corresponding internal properties are not present are not assigned.

13.1.1 String.prototype.localeCompare (that [, locales [, options]])

This definition supersedes the definition provided in ES5, 15.5.4.9.

When the localeCompare method is called with argument that and optional arguments locales, and options, the following steps are taken:

1. Call CheckObjectCoercible passing the this value as its argument.
2. Let S be the result of calling ToString passing the this value as its argument.
3. Let That be ToString(that).
4. If locales is not provided, then let locales be undefined.
5. If options is not provided, then let options be undefined.
6. Let collator be the result of creating an object as if by the expression new Intl.Collator(locales, options) where Intl.Collator is the standard built-in constructor defined in 10.1.3.
7. Return the result of calling the CompareStrings abstract operation (defined in 10.3.2) with arguments collator, S, and That.

The value of the length property of the localeCompare method is 1.

13.2.1 Number.prototype.toLocaleString ([locales [, options]])

This definition supersedes the definition provided in ES5, 15.7.4.3.

When the toLocaleString method is called with optional arguments locales and options, the following steps are taken:

1. Let x be this Number value (as defined in ES5, 15.7.4).
2. If locales is not provided, then let locales be undefined.
3. If options is not provided, then let options be undefined.
4. Let numberFormat be the result of creating a new object as if by the expression new Intl.NumberFormat(locales, options) where Intl.NumberFormat is the standard built-in constructor defined in 11.1.3.
5. Return the result of calling the FormatNumber abstract operation (defined in 11.3.2) with arguments numberFormat and x.

The value of the length property of the toLocaleString method is 0.

13.3.1 Date.prototype.toLocaleString ([locales [, options]])

This definition supersedes the definition provided in ES5, 15.9.5.5.

When the toLocaleString method is called with optional arguments locales and options, the following steps are taken:

1. Let x be this time value (as defined in ES5, 15.9.5).
2. If x is NaN, then return "Invalid Date".
3. If locales is not provided, then let locales be undefined.
4. If options is not provided, then let options be undefined.
5. Let options be the result of calling the ToDateTimeOptions abstract operation (defined in 12.1.1) with arguments options, "any", and "all".
6. Let dateTimeFormat be the result of creating a new object as if by the expression new Intl.DateTimeFormat(locales, options) where Intl.DateTimeFormat is the standard built-in constructor defined in 12.1.3.
7. Return the result of calling the FormatDateTime abstract operation (defined in 12.3.2) with arguments dateTimeFormat and x.

The value of the length property of the toLocaleString method is 0.

13.3.2 Date.prototype.toLocaleDateString ([locales [, options]])

This definition supersedes the definition provided in ES5, 15.9.5.6.

When the toLocaleDateString method is called with optional arguments locales and options, the following steps are taken:

1. Let x be this time value (as defined in ES5, 15.9.5).
2. If x is NaN, then return "Invalid Date".
3. If locales is not provided, then let locales be undefined.
4. If options is not provided, then let options be undefined.
5. Let options be the result of calling the ToDateTimeOptions abstract operation (defined in 12.1.1) with arguments options, "date", and "date".
6. Let dateFormat be the result of creating a new object as if by the expression new Intl.DateTimeFormat(locales, options) where Intl.DateTimeFormat is the standard built-in constructor defined in 12.1.3.
7. Return the result of calling the FormatDateTime abstract operation (defined in 12.3.2) with arguments dateTimeFormat and x.

The value of the length property of the toLocaleDateString method is 0.

13.3.3 Date.prototype.toLocaleTimeString ([locales [, options]])

This definition supersedes the definition provided in ES5, 15.9.5.7.

When the toLocaleTimeString method is called with optional arguments locales and options, the following steps are taken:

1. Let x be this time value (as defined in ES5, 15.9.5).
2. If x is NaN, then return "Invalid Date".
3. If locales is not provided, then let locales be undefined.
4. If options is not provided, then let options be undefined.
5. Let options be the result of calling the ToDateTimeOptions abstract operation (defined in 12.1.1) with arguments options, "time", and "time".
6. Let timeFormat be the result of creating a new object as if by the expression new Intl.DateTimeFormat(locales, options) where Intl.DateTimeFormat is the standard built-in constructor defined in 12.1.3.
7. Return the result of calling the FormatDateTime abstract operation (defined in 12.3.2) with arguments dateTimeFormat and x.

The value of the length property of the toLocaleTimeString method is 0.