(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.MakePlural = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.default = void 0;
|
|
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
|
|
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
|
|
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
|
|
function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest(); }
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
|
|
function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
/**
|
* make-plural -- https://github.com/eemeli/make-plural
|
* Copyright (c) 2014-2016 by Eemeli Aro <eemeli@gmail.com>
|
*
|
* Permission to use, copy, modify, and/or distribute this software for any
|
* purpose with or without fee is hereby granted, provided that the above
|
* copyright notice and this permission notice appear in all copies.
|
*
|
* The software is provided "as is" and the author disclaims all warranties
|
* with regard to this software including all implied warranties of
|
* merchantability and fitness. In no event shall the author be liable for
|
* any special, direct, indirect, or consequential damages or any damages
|
* whatsoever resulting from loss of use, data or profits, whether in an
|
* action of contract, negligence or other tortious action, arising out of
|
* or in connection with the use or performance of this software.
|
*/
|
var Parser =
|
/*#__PURE__*/
|
function () {
|
function Parser() {
|
_classCallCheck(this, Parser);
|
}
|
|
_createClass(Parser, [{
|
key: "parse",
|
value: function parse(cond) {
|
var _this = this;
|
|
if (cond === 'i = 0 or n = 1') return 'n >= 0 && n <= 1';
|
if (cond === 'i = 0,1') return 'n >= 0 && n < 2';
|
|
if (cond === 'i = 1 and v = 0') {
|
this.v0 = 1;
|
return 'n == 1 && v0';
|
}
|
|
return cond.replace(/([tv]) (!?)= 0/g, function (m, sym, noteq) {
|
var sn = sym + '0';
|
_this[sn] = 1;
|
return noteq ? '!' + sn : sn;
|
}).replace(/\b[fintv]\b/g, function (m) {
|
_this[m] = 1;
|
return m;
|
}).replace(/([fin]) % (10+)/g, function (m, sym, num) {
|
var sn = sym + num;
|
_this[sn] = 1;
|
return sn;
|
}).replace(/n10+ = 0/g, 't0 && $&').replace(/(\w+ (!?)= )([0-9.]+,[0-9.,]+)/g, function (m, se, noteq, x) {
|
if (m === 'n = 0,1') return '(n == 0 || n == 1)';
|
if (noteq) return se + x.split(',').join(' && ' + se);
|
return '(' + se + x.split(',').join(' || ' + se) + ')';
|
}).replace(/(\w+) (!?)= ([0-9]+)\.\.([0-9]+)/g, function (m, sym, noteq, x0, x1) {
|
if (Number(x0) + 1 === Number(x1)) {
|
if (noteq) return "".concat(sym, " != ").concat(x0, " && ").concat(sym, " != ").concat(x1);
|
return "(".concat(sym, " == ").concat(x0, " || ").concat(sym, " == ").concat(x1, ")");
|
}
|
|
if (noteq) return "(".concat(sym, " < ").concat(x0, " || ").concat(sym, " > ").concat(x1, ")");
|
|
if (sym === 'n') {
|
_this.t0 = 1;
|
return "(t0 && n >= ".concat(x0, " && n <= ").concat(x1, ")");
|
}
|
|
return "(".concat(sym, " >= ").concat(x0, " && ").concat(sym, " <= ").concat(x1, ")");
|
}).replace(/ and /g, ' && ').replace(/ or /g, ' || ').replace(/ = /g, ' == ');
|
}
|
}, {
|
key: "vars",
|
value: function vars() {
|
var vars = [];
|
if (this.i) vars.push('i = s[0]');
|
if (this.f || this.v) vars.push("f = s[1] || ''");
|
if (this.t) vars.push("t = (s[1] || '').replace(/0+$/, '')");
|
if (this.v) vars.push('v = f.length');
|
if (this.v0) vars.push('v0 = !s[1]');
|
if (this.t0 || this.n10 || this.n100) vars.push('t0 = Number(s[0]) == n');
|
|
for (var k in this) {
|
if (/^.10+$/.test(k)) {
|
var k0 = k[0] === 'n' ? 't0 && s[0]' : k[0];
|
vars.push("".concat(k, " = ").concat(k0, ".slice(-").concat(k.substr(2).length, ")"));
|
}
|
}
|
|
if (!vars.length) return '';
|
return 'var ' + ["s = String(n).split('.')"].concat(vars).join(', ');
|
}
|
}]);
|
|
return Parser;
|
}();
|
|
var Tests =
|
/*#__PURE__*/
|
function () {
|
function Tests(obj) {
|
_classCallCheck(this, Tests);
|
|
this.obj = obj;
|
this.ordinal = {};
|
this.cardinal = {};
|
}
|
|
_createClass(Tests, [{
|
key: "add",
|
value: function add(type, cat, src) {
|
this[type][cat] = {
|
src: src,
|
values: null
|
};
|
}
|
}, {
|
key: "testCond",
|
value: function testCond(n, type, expResult, fn) {
|
try {
|
var r = (fn || this.obj.fn)(n, type === 'ordinal');
|
} catch (e) {
|
r = e.toString();
|
}
|
|
if (r !== expResult) {
|
throw new Error('Locale ' + JSON.stringify(this.obj.lc) + type + ' rule self-test failed for v = ' + JSON.stringify(n) + ' (was ' + JSON.stringify(r) + ', expected ' + JSON.stringify(expResult) + ')');
|
}
|
|
return true;
|
}
|
}, {
|
key: "testCat",
|
value: function testCat(type, cat, fn) {
|
var _this2 = this;
|
|
var data = this[type][cat];
|
|
if (!data.values) {
|
data.values = data.src.join(' ').replace(/^[ ,]+|[ ,…]+$/g, '').replace(/(0\.[0-9])~(1\.[1-9])/g, '$1 1.0 $2').split(/[ ,~…]+/);
|
}
|
|
data.values.forEach(function (n) {
|
_this2.testCond(n, type, cat, fn);
|
|
if (!/\.0+$/.test(n)) _this2.testCond(Number(n), type, cat, fn);
|
});
|
return true;
|
}
|
}, {
|
key: "testAll",
|
value: function testAll() {
|
for (var cat in this.cardinal) {
|
this.testCat('cardinal', cat);
|
}
|
|
for (var _cat in this.ordinal) {
|
this.testCat('ordinal', _cat);
|
}
|
|
return true;
|
}
|
}]);
|
|
return Tests;
|
}();
|
|
var MakePlural =
|
/*#__PURE__*/
|
function () {
|
function MakePlural(lc) {
|
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : MakePlural,
|
cardinals = _ref.cardinals,
|
ordinals = _ref.ordinals;
|
|
_classCallCheck(this, MakePlural);
|
|
if (!cardinals && !ordinals) throw new Error('At least one type of plural is required');
|
this.lc = lc;
|
this.categories = {
|
cardinal: [],
|
ordinal: []
|
};
|
this.parser = new Parser();
|
this.tests = new Tests(this);
|
this.fn = this.buildFunction(cardinals, ordinals);
|
this.fn._obj = this;
|
this.fn.categories = this.categories;
|
|
this.fn.test = function () {
|
return this.tests.testAll() && this.fn;
|
}.bind(this);
|
|
this.fn.toString = this.fnToString.bind(this);
|
return this.fn;
|
}
|
|
_createClass(MakePlural, [{
|
key: "compile",
|
value: function compile(type, req) {
|
var cases = [];
|
var rules = MakePlural.getRules(type, this.lc);
|
|
if (!rules) {
|
if (req) throw new Error("Locale \"".concat(this.lc, "\" ").concat(type, " rules not found"));
|
this.categories[type] = ['other'];
|
return "'other'";
|
}
|
|
for (var r in rules) {
|
var _rules$r$trim$split = rules[r].trim().split(/\s*@\w*/),
|
_rules$r$trim$split2 = _toArray(_rules$r$trim$split),
|
cond = _rules$r$trim$split2[0],
|
examples = _rules$r$trim$split2.slice(1);
|
|
var cat = r.replace('pluralRule-count-', '');
|
if (cond) cases.push([this.parser.parse(cond), cat]);
|
this.tests.add(type, cat, examples);
|
}
|
|
this.categories[type] = cases.map(function (c) {
|
return c[1];
|
}).concat('other');
|
|
if (cases.length === 1) {
|
return "(".concat(cases[0][0], ") ? '").concat(cases[0][1], "' : 'other'");
|
} else {
|
return _toConsumableArray(cases.map(function (c) {
|
return "(".concat(c[0], ") ? '").concat(c[1], "'");
|
})).concat(["'other'"]).join('\n : ');
|
}
|
}
|
}, {
|
key: "buildFunction",
|
value: function buildFunction(cardinals, ordinals) {
|
var _this3 = this;
|
|
var compile = function compile(c) {
|
return c ? (c[1] ? 'return ' : 'if (ord) return ') + _this3.compile.apply(_this3, _toConsumableArray(c)) : '';
|
};
|
|
var fold = {
|
vars: function vars(str) {
|
return " ".concat(str, ";").replace(/(.{1,78})(,|$) ?/g, '$1$2\n ');
|
},
|
cond: function cond(str) {
|
return " ".concat(str, ";").replace(/(.{1,78}) (\|\| |$) ?/gm, '$1\n $2');
|
}
|
};
|
var cond = [ordinals && ['ordinal', !cardinals], cardinals && ['cardinal', true]].map(compile).map(fold.cond);
|
var body = [fold.vars(this.parser.vars())].concat(_toConsumableArray(cond)).filter(function (line) {
|
return !/^[\s;]*$/.test(line);
|
}).map(function (line) {
|
return line.replace(/\s+$/gm, '');
|
}).join('\n');
|
var args = ordinals && cardinals ? 'n, ord' : 'n';
|
return new Function(args, body); // eslint-disable-line no-new-func
|
}
|
}, {
|
key: "fnToString",
|
value: function fnToString(name) {
|
return Function.prototype.toString.call(this.fn).replace(/^function( \w+)?/, name ? 'function ' + name : 'function').replace(/\n\/\*(``)?\*\//, '');
|
}
|
}], [{
|
key: "load",
|
value: function load() {
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
args[_key] = arguments[_key];
|
}
|
|
args.forEach(function (cldr) {
|
var data = cldr && cldr.supplemental || null;
|
if (!data) throw new Error('Data does not appear to be CLDR data');
|
MakePlural.rules = {
|
cardinal: data['plurals-type-cardinal'] || MakePlural.rules.cardinal,
|
ordinal: data['plurals-type-ordinal'] || MakePlural.rules.ordinal
|
};
|
});
|
return MakePlural;
|
}
|
}, {
|
key: "getRules",
|
value: function getRules(type, locale) {
|
if (locale.length) {
|
var cat = MakePlural.rules[type];
|
if (locale in cat) return cat[locale];
|
var lc0 = locale.toLowerCase();
|
|
for (var lc in cat) {
|
if (lc.toLowerCase() === lc0) return cat[lc];
|
}
|
}
|
|
return null;
|
}
|
}]);
|
|
return MakePlural;
|
}();
|
|
exports.default = MakePlural;
|
MakePlural.cardinals = true;
|
MakePlural.ordinals = false;
|
MakePlural.rules = {
|
cardinal: {},
|
ordinal: {}
|
};
|
module.exports = exports.default;
|
|
},{}]},{},[1])(1)
|
});
|
