tor-browser

PluralRules.js (11790B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/**
* PluralRules internal properties.
*
* 9.1 Internal slots of Service Constructors
* 16.2.3 Properties of the Intl.PluralRules Constructor, Internal slots
*
* ES2024 Intl draft rev 74ca7099f103d143431b2ea422ae640c6f43e3e6
*/
var pluralRulesInternalProperties = {
 localeData: pluralRulesLocaleData,
 relevantExtensionKeys: [],
};

function pluralRulesLocaleData() {
 // PluralRules don't support any extension keys.
 return {};
}

/**
* 16.1.2 InitializePluralRules ( pluralRules, locales, options )
*
* Compute an internal properties object from |lazyPluralRulesData|.
*
* ES2024 Intl draft rev 74ca7099f103d143431b2ea422ae640c6f43e3e6
*/
function resolvePluralRulesInternals(lazyPluralRulesData) {
 assert(IsObject(lazyPluralRulesData), "lazy data not an object?");

 var internalProps = std_Object_create(null);

 var PluralRules = pluralRulesInternalProperties;

 // Compute effective locale.

 // Step 9.
 var localeData = PluralRules.localeData;

 // Step 10.
 var r = ResolveLocale(
   "PluralRules",
   lazyPluralRulesData.requestedLocales,
   lazyPluralRulesData.opt,
   PluralRules.relevantExtensionKeys,
   localeData
 );

 // Step 11.
 internalProps.locale = r.locale;

 // Step 7.
 internalProps.type = lazyPluralRulesData.type;

 // Step 8. SetNumberFormatDigitOptions, step 6.
 internalProps.minimumIntegerDigits = lazyPluralRulesData.minimumIntegerDigits;

 // Step 8. SetNumberFormatDigitOptions, step 14.
 internalProps.roundingIncrement = lazyPluralRulesData.roundingIncrement;

 // Step 8. SetNumberFormatDigitOptions, step 15.
 internalProps.roundingMode = lazyPluralRulesData.roundingMode;

 // Step 8. SetNumberFormatDigitOptions, step 16.
 internalProps.trailingZeroDisplay = lazyPluralRulesData.trailingZeroDisplay;

 // Step 8. SetNumberFormatDigitOptions, steps 25-26.
 if ("minimumFractionDigits" in lazyPluralRulesData) {
   assert(
     "maximumFractionDigits" in lazyPluralRulesData,
     "min/max frac digits mismatch"
   );
   internalProps.minimumFractionDigits =
     lazyPluralRulesData.minimumFractionDigits;
   internalProps.maximumFractionDigits =
     lazyPluralRulesData.maximumFractionDigits;
 }

 // Step 8. SetNumberFormatDigitOptions, steps 24 and 26.
 if ("minimumSignificantDigits" in lazyPluralRulesData) {
   assert(
     "maximumSignificantDigits" in lazyPluralRulesData,
     "min/max sig digits mismatch"
   );
   internalProps.minimumSignificantDigits =
     lazyPluralRulesData.minimumSignificantDigits;
   internalProps.maximumSignificantDigits =
     lazyPluralRulesData.maximumSignificantDigits;
 }

 // Step 8. SetNumberFormatDigitOptions, steps 26-30.
 internalProps.roundingPriority = lazyPluralRulesData.roundingPriority;

 // `pluralCategories` is lazily computed on first access.
 internalProps.pluralCategories = null;

 return internalProps;
}

/**
* Returns an object containing the PluralRules internal properties of |obj|.
*/
function getPluralRulesInternals(obj) {
 assert(IsObject(obj), "getPluralRulesInternals called with non-object");
 assert(
   intl_GuardToPluralRules(obj) !== null,
   "getPluralRulesInternals called with non-PluralRules"
 );

 var internals = getIntlObjectInternals(obj);
 assert(
   internals.type === "PluralRules",
   "bad type escaped getIntlObjectInternals"
 );

 var internalProps = maybeInternalProperties(internals);
 if (internalProps) {
   return internalProps;
 }

 internalProps = resolvePluralRulesInternals(internals.lazyData);
 setInternalProperties(internals, internalProps);
 return internalProps;
}

/**
* 16.1.2 InitializePluralRules ( pluralRules, locales, options )
*
* Initializes an object as a PluralRules.
*
* This method is complicated a moderate bit by its implementing initialization
* as a *lazy* concept.  Everything that must happen now, does -- but we defer
* all the work we can until the object is actually used as a PluralRules.
* This later work occurs in |resolvePluralRulesInternals|; steps not noted
* here occur there.
*
* ES2024 Intl draft rev 74ca7099f103d143431b2ea422ae640c6f43e3e6
*/
function InitializePluralRules(pluralRules, locales, options) {
 assert(IsObject(pluralRules), "InitializePluralRules called with non-object");
 assert(
   intl_GuardToPluralRules(pluralRules) !== null,
   "InitializePluralRules called with non-PluralRules"
 );

 // Lazy PluralRules data has the following structure:
 //
 //   {
 //     requestedLocales: List of locales,
 //     type: "cardinal" / "ordinal",
 //
 //     opt: // opt object computer in InitializePluralRules
 //       {
 //         localeMatcher: "lookup" / "best fit",
 //       }
 //
 //     minimumIntegerDigits: integer ∈ [1, 21],
 //
 //     // optional, mutually exclusive with the significant-digits option
 //     minimumFractionDigits: integer ∈ [0, 100],
 //     maximumFractionDigits: integer ∈ [0, 100],
 //
 //     // optional, mutually exclusive with the fraction-digits option
 //     minimumSignificantDigits: integer ∈ [1, 21],
 //     maximumSignificantDigits: integer ∈ [1, 21],
 //
 //     roundingPriority: "auto" / "lessPrecision" / "morePrecision",
 //
 //     trailingZeroDisplay: "auto" / "stripIfInteger",
 //
 //     roundingIncrement: integer ∈ (1, 2, 5,
 //                                   10, 20, 25, 50,
 //                                   100, 200, 250, 500,
 //                                   1000, 2000, 2500, 5000),
 //
 //     roundingMode: "ceil" / "floor" / "expand" / "trunc" /
 //                   "halfCeil" / "halfFloor" / "halfExpand" / "halfTrunc" / "halfEven",
 //   }
 //
 // Note that lazy data is only installed as a final step of initialization,
 // so every PluralRules lazy data object has *all* these properties, never a
 // subset of them.
 var lazyPluralRulesData = std_Object_create(null);

 // Step 1.
 var requestedLocales = CanonicalizeLocaleList(locales);
 lazyPluralRulesData.requestedLocales = requestedLocales;

 // Step 2. (Inlined call to CoerceOptionsToObject.)
 if (options === undefined) {
   options = std_Object_create(null);
 } else {
   options = ToObject(options);
 }

 // Step 3.
 var opt = NEW_RECORD();
 lazyPluralRulesData.opt = opt;

 // Steps 4-5.
 var matcher = GetOption(
   options,
   "localeMatcher",
   "string",
   ["lookup", "best fit"],
   "best fit"
 );
 opt.localeMatcher = matcher;

 // Steps 6-7.
 var type = GetOption(
   options,
   "type",
   "string",
   ["cardinal", "ordinal"],
   "cardinal"
 );
 lazyPluralRulesData.type = type;

 // Step 8.
 SetNumberFormatDigitOptions(lazyPluralRulesData, options, 0, 3, "standard");

 // Step 12.
 //
 // We've done everything that must be done now: mark the lazy data as fully
 // computed and install it.
 initializeIntlObject(pluralRules, "PluralRules", lazyPluralRulesData);
}

/**
* 16.3.3 Intl.PluralRules.prototype.select ( value )
*
* Returns a String value representing the plural category matching
* the number passed as value according to the
* effective locale and the formatting options of this PluralRules.
*
* ES2024 Intl draft rev 74ca7099f103d143431b2ea422ae640c6f43e3e6
*/
function Intl_PluralRules_select(value) {
 // Step 1.
 var pluralRules = this;

 // Step 2.
 if (
   !IsObject(pluralRules) ||
   (pluralRules = intl_GuardToPluralRules(pluralRules)) === null
 ) {
   return callFunction(
     intl_CallPluralRulesMethodIfWrapped,
     this,
     value,
     "Intl_PluralRules_select"
   );
 }

 // Step 3.
 var n = TO_NUMBER(value);

 // Ensure the PluralRules internals are resolved.
 getPluralRulesInternals(pluralRules);

 // Step 4.
 return intl_SelectPluralRule(pluralRules, n);
}

/**
* 16.3.4 Intl.PluralRules.prototype.selectRange ( start, end )
*
* Returns a String value representing the plural category matching the input
* number range according to the effective locale and the formatting options
* of this PluralRules.
*
* ES2024 Intl draft rev 74ca7099f103d143431b2ea422ae640c6f43e3e6
*/
function Intl_PluralRules_selectRange(start, end) {
 // Step 1.
 var pluralRules = this;

 // Step 2.
 if (
   !IsObject(pluralRules) ||
   (pluralRules = intl_GuardToPluralRules(pluralRules)) === null
 ) {
   return callFunction(
     intl_CallPluralRulesMethodIfWrapped,
     this,
     start,
     end,
     "Intl_PluralRules_selectRange"
   );
 }

 // Step 3.
 if (start === undefined || end === undefined) {
   ThrowTypeError(
     JSMSG_UNDEFINED_NUMBER,
     start === undefined ? "start" : "end",
     "PluralRules",
     "selectRange"
   );
 }

 // Step 4.
 var x = TO_NUMBER(start);

 // Step 5.
 var y = TO_NUMBER(end);

 // Step 6.
 return intl_SelectPluralRuleRange(pluralRules, x, y);
}

/**
* 16.3.5 Intl.PluralRules.prototype.resolvedOptions ( )
*
* Returns the resolved options for a PluralRules object.
*
* ES2024 Intl draft rev a1db4567870dbe505121a4255f1210338757190a
*/
function Intl_PluralRules_resolvedOptions() {
 // Step 1.
 var pluralRules = this;

 // Step 2.
 if (
   !IsObject(pluralRules) ||
   (pluralRules = intl_GuardToPluralRules(pluralRules)) === null
 ) {
   return callFunction(
     intl_CallPluralRulesMethodIfWrapped,
     this,
     "Intl_PluralRules_resolvedOptions"
   );
 }

 var internals = getPluralRulesInternals(pluralRules);

 // Step 4.
 var internalsPluralCategories = internals.pluralCategories;
 if (internalsPluralCategories === null) {
   internalsPluralCategories = intl_GetPluralCategories(pluralRules);
   internals.pluralCategories = internalsPluralCategories;
 }

 // Step 5.b.
 var pluralCategories = [];
 for (var i = 0; i < internalsPluralCategories.length; i++) {
   DefineDataProperty(pluralCategories, i, internalsPluralCategories[i]);
 }

 // Steps 3 and 5.
 var result = {
   locale: internals.locale,
   type: internals.type,
   minimumIntegerDigits: internals.minimumIntegerDigits,
 };

 // Min/Max fraction digits are either both present or not present at all.
 assert(
   hasOwn("minimumFractionDigits", internals) ===
     hasOwn("maximumFractionDigits", internals),
   "minimumFractionDigits is present iff maximumFractionDigits is present"
 );

 if (hasOwn("minimumFractionDigits", internals)) {
   DefineDataProperty(
     result,
     "minimumFractionDigits",
     internals.minimumFractionDigits
   );
   DefineDataProperty(
     result,
     "maximumFractionDigits",
     internals.maximumFractionDigits
   );
 }

 // Min/Max significant digits are either both present or not present at all.
 assert(
   hasOwn("minimumSignificantDigits", internals) ===
     hasOwn("maximumSignificantDigits", internals),
   "minimumSignificantDigits is present iff maximumSignificantDigits is present"
 );

 if (hasOwn("minimumSignificantDigits", internals)) {
   DefineDataProperty(
     result,
     "minimumSignificantDigits",
     internals.minimumSignificantDigits
   );
   DefineDataProperty(
     result,
     "maximumSignificantDigits",
     internals.maximumSignificantDigits
   );
 }

 DefineDataProperty(result, "pluralCategories", pluralCategories);
 DefineDataProperty(result, "roundingIncrement", internals.roundingIncrement);
 DefineDataProperty(result, "roundingMode", internals.roundingMode);
 DefineDataProperty(result, "roundingPriority", internals.roundingPriority);
 DefineDataProperty(
   result,
   "trailingZeroDisplay",
   internals.trailingZeroDisplay
 );

 // Step 6.
 return result;
}