2333 lines
51 KiB
JavaScript
2333 lines
51 KiB
JavaScript
/* compromise-numbers 1.1.0 MIT */
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
||
typeof define === 'function' && define.amd ? define(factory) :
|
||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.compromiseNumbers = factory());
|
||
}(this, (function () { 'use strict';
|
||
|
||
function _classCallCheck(instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
}
|
||
|
||
function _inherits(subClass, superClass) {
|
||
if (typeof superClass !== "function" && superClass !== null) {
|
||
throw new TypeError("Super expression must either be null or a function");
|
||
}
|
||
|
||
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
||
constructor: {
|
||
value: subClass,
|
||
writable: true,
|
||
configurable: true
|
||
}
|
||
});
|
||
if (superClass) _setPrototypeOf(subClass, superClass);
|
||
}
|
||
|
||
function _getPrototypeOf(o) {
|
||
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
|
||
return o.__proto__ || Object.getPrototypeOf(o);
|
||
};
|
||
return _getPrototypeOf(o);
|
||
}
|
||
|
||
function _setPrototypeOf(o, p) {
|
||
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
|
||
o.__proto__ = p;
|
||
return o;
|
||
};
|
||
|
||
return _setPrototypeOf(o, p);
|
||
}
|
||
|
||
function _isNativeReflectConstruct() {
|
||
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
|
||
if (Reflect.construct.sham) return false;
|
||
if (typeof Proxy === "function") return true;
|
||
|
||
try {
|
||
Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
|
||
return true;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function _assertThisInitialized(self) {
|
||
if (self === void 0) {
|
||
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
}
|
||
|
||
return self;
|
||
}
|
||
|
||
function _possibleConstructorReturn(self, call) {
|
||
if (call && (typeof call === "object" || typeof call === "function")) {
|
||
return call;
|
||
}
|
||
|
||
return _assertThisInitialized(self);
|
||
}
|
||
|
||
function _createSuper(Derived) {
|
||
var hasNativeReflectConstruct = _isNativeReflectConstruct();
|
||
|
||
return function _createSuperInternal() {
|
||
var Super = _getPrototypeOf(Derived),
|
||
result;
|
||
|
||
if (hasNativeReflectConstruct) {
|
||
var NewTarget = _getPrototypeOf(this).constructor;
|
||
|
||
result = Reflect.construct(Super, arguments, NewTarget);
|
||
} else {
|
||
result = Super.apply(this, arguments);
|
||
}
|
||
|
||
return _possibleConstructorReturn(this, result);
|
||
};
|
||
}
|
||
|
||
var tens = 'twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|fourty';
|
||
var teens = 'eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen'; // this is a bit of a mess
|
||
|
||
var findNumbers = function findNumbers(doc, n) {
|
||
var match = doc.match('#Value+'); //"50 83"
|
||
|
||
if (match.has('#NumericValue #NumericValue')) {
|
||
//a comma may mean two numbers
|
||
if (match.has('#Value @hasComma #Value')) {
|
||
match.splitAfter('@hasComma');
|
||
} else if (match.has('#NumericValue #Fraction')) {
|
||
match.splitAfter('#NumericValue #Fraction');
|
||
} else {
|
||
match = match.splitAfter('#NumericValue');
|
||
}
|
||
} //three-length
|
||
|
||
|
||
if (match.has('#Value #Value #Value') && !match.has('#Multiple')) {
|
||
//twenty-five-twenty
|
||
if (match.has('(' + tens + ') #Cardinal #Cardinal')) {
|
||
match = match.splitAfter('(' + tens + ') #Cardinal');
|
||
}
|
||
} //two-length ones
|
||
|
||
|
||
if (match.has('#Value #Value')) {
|
||
//june 21st 1992 is two seperate values
|
||
if (match.has('#NumericValue #NumericValue')) {
|
||
match = match.splitOn('#Year');
|
||
} //sixty fifteen
|
||
|
||
|
||
if (match.has('(' + tens + ') (' + teens + ')')) {
|
||
match = match.splitAfter('(' + tens + ')');
|
||
} //"72 82"
|
||
|
||
|
||
var _double = match.match('#Cardinal #Cardinal');
|
||
|
||
if (_double.found && !match.has('(point|decimal)')) {
|
||
//not 'two hundred'
|
||
if (!_double.has('#Cardinal (#Multiple|point|decimal)')) {
|
||
//one proper way, 'twenty one', or 'hundred one'
|
||
if (!_double.has('(' + tens + ') #Cardinal') && !_double.has('#Multiple #Value')) {
|
||
// double = double.firstTerm()
|
||
_double.terms().forEach(function (d) {
|
||
match = match.splitOn(d);
|
||
});
|
||
}
|
||
}
|
||
} //seventh fifth
|
||
|
||
|
||
if (match.match('#Ordinal #Ordinal').match('#TextValue').found && !match.has('#Multiple')) {
|
||
//the one proper way, 'twenty first'
|
||
if (!match.has('(' + tens + ') #Ordinal')) {
|
||
match = match.splitAfter('#Ordinal');
|
||
}
|
||
} //fifth five
|
||
|
||
|
||
if (match.has('#Ordinal #Cardinal')) {
|
||
match = match.splitBefore('#Cardinal+');
|
||
} //five 2017 (support '5 hundred', and 'twenty 5'
|
||
|
||
|
||
if (match.has('#TextValue #NumericValue') && !match.has('(' + tens + '|#Multiple)')) {
|
||
match = match.splitBefore('#NumericValue+');
|
||
}
|
||
} //5-8
|
||
|
||
|
||
if (match.has('#NumberRange')) {
|
||
match = match.splitAfter('#NumberRange');
|
||
} //grab (n)th result
|
||
|
||
|
||
if (typeof n === 'number') {
|
||
match = match.get(n);
|
||
}
|
||
|
||
return match;
|
||
};
|
||
|
||
var find = findNumbers;
|
||
|
||
//support global multipliers, like 'half-million' by doing 'million' then multiplying by 0.5
|
||
var findModifiers = function findModifiers(str) {
|
||
var mults = [{
|
||
reg: /^(minus|negative)[\s\-]/i,
|
||
mult: -1
|
||
}, {
|
||
reg: /^(a\s)?half[\s\-](of\s)?/i,
|
||
mult: 0.5
|
||
} // {
|
||
// reg: /^(a\s)?quarter[\s\-]/i,
|
||
// mult: 0.25
|
||
// }
|
||
];
|
||
|
||
for (var i = 0; i < mults.length; i++) {
|
||
if (mults[i].reg.test(str) === true) {
|
||
return {
|
||
amount: mults[i].mult,
|
||
str: str.replace(mults[i].reg, '')
|
||
};
|
||
}
|
||
}
|
||
|
||
return {
|
||
amount: 1,
|
||
str: str
|
||
};
|
||
};
|
||
|
||
var findModifiers_1 = findModifiers;
|
||
|
||
var data = {
|
||
ones: {
|
||
zeroth: 0,
|
||
first: 1,
|
||
second: 2,
|
||
third: 3,
|
||
fourth: 4,
|
||
fifth: 5,
|
||
sixth: 6,
|
||
seventh: 7,
|
||
eighth: 8,
|
||
ninth: 9,
|
||
zero: 0,
|
||
one: 1,
|
||
two: 2,
|
||
three: 3,
|
||
four: 4,
|
||
five: 5,
|
||
six: 6,
|
||
seven: 7,
|
||
eight: 8,
|
||
nine: 9
|
||
},
|
||
teens: {
|
||
tenth: 10,
|
||
eleventh: 11,
|
||
twelfth: 12,
|
||
thirteenth: 13,
|
||
fourteenth: 14,
|
||
fifteenth: 15,
|
||
sixteenth: 16,
|
||
seventeenth: 17,
|
||
eighteenth: 18,
|
||
nineteenth: 19,
|
||
ten: 10,
|
||
eleven: 11,
|
||
twelve: 12,
|
||
thirteen: 13,
|
||
fourteen: 14,
|
||
fifteen: 15,
|
||
sixteen: 16,
|
||
seventeen: 17,
|
||
eighteen: 18,
|
||
nineteen: 19
|
||
},
|
||
tens: {
|
||
twentieth: 20,
|
||
thirtieth: 30,
|
||
fortieth: 40,
|
||
fourtieth: 40,
|
||
fiftieth: 50,
|
||
sixtieth: 60,
|
||
seventieth: 70,
|
||
eightieth: 80,
|
||
ninetieth: 90,
|
||
twenty: 20,
|
||
thirty: 30,
|
||
forty: 40,
|
||
fourty: 40,
|
||
fifty: 50,
|
||
sixty: 60,
|
||
seventy: 70,
|
||
eighty: 80,
|
||
ninety: 90
|
||
},
|
||
multiples: {
|
||
hundredth: 100,
|
||
thousandth: 1000,
|
||
millionth: 1e6,
|
||
billionth: 1e9,
|
||
trillionth: 1e12,
|
||
quadrillionth: 1e15,
|
||
quintillionth: 1e18,
|
||
sextillionth: 1e21,
|
||
septillionth: 1e24,
|
||
hundred: 100,
|
||
thousand: 1000,
|
||
million: 1e6,
|
||
billion: 1e9,
|
||
trillion: 1e12,
|
||
quadrillion: 1e15,
|
||
quintillion: 1e18,
|
||
sextillion: 1e21,
|
||
septillion: 1e24,
|
||
grand: 1000
|
||
}
|
||
};
|
||
|
||
var isValid = function isValid(w, has) {
|
||
if (data.ones.hasOwnProperty(w)) {
|
||
if (has.ones || has.teens) {
|
||
return false;
|
||
}
|
||
} else if (data.teens.hasOwnProperty(w)) {
|
||
if (has.ones || has.teens || has.tens) {
|
||
return false;
|
||
}
|
||
} else if (data.tens.hasOwnProperty(w)) {
|
||
if (has.ones || has.teens || has.tens) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
var validate = isValid;
|
||
|
||
var parseDecimals = function parseDecimals(arr) {
|
||
var str = '0.';
|
||
|
||
for (var i = 0; i < arr.length; i++) {
|
||
var w = arr[i];
|
||
|
||
if (data.ones.hasOwnProperty(w) === true) {
|
||
str += data.ones[w];
|
||
} else if (data.teens.hasOwnProperty(w) === true) {
|
||
str += data.teens[w];
|
||
} else if (data.tens.hasOwnProperty(w) === true) {
|
||
str += data.tens[w];
|
||
} else if (/^[0-9]$/.test(w) === true) {
|
||
str += w;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
return parseFloat(str);
|
||
};
|
||
|
||
var parseDecimals_1 = parseDecimals;
|
||
|
||
//parse a string like "4,200.1" into Number 4200.1
|
||
var parseNumeric = function parseNumeric(str) {
|
||
//remove ordinal - 'th/rd'
|
||
str = str.replace(/1st$/, '1');
|
||
str = str.replace(/2nd$/, '2');
|
||
str = str.replace(/3rd$/, '3');
|
||
str = str.replace(/([4567890])r?th$/, '$1'); //remove prefixes
|
||
|
||
str = str.replace(/^[$€¥£¢]/, ''); //remove suffixes
|
||
|
||
str = str.replace(/[%$€¥£¢]$/, ''); //remove commas
|
||
|
||
str = str.replace(/,/g, ''); //split '5kg' from '5'
|
||
|
||
str = str.replace(/([0-9])([a-z\u00C0-\u00FF]{1,2})$/, '$1');
|
||
return str;
|
||
};
|
||
|
||
var parseNumeric_1 = parseNumeric;
|
||
|
||
var improperFraction = /^([0-9,\. ]+)\/([0-9,\. ]+)$/; //some numbers we know
|
||
|
||
var casualForms = {
|
||
// 'a few': 3,
|
||
'a couple': 2,
|
||
'a dozen': 12,
|
||
'two dozen': 24,
|
||
zero: 0
|
||
}; // a 'section' is something like 'fifty-nine thousand'
|
||
// turn a section into something we can add to - like 59000
|
||
|
||
var section_sum = function section_sum(obj) {
|
||
return Object.keys(obj).reduce(function (sum, k) {
|
||
sum += obj[k];
|
||
return sum;
|
||
}, 0);
|
||
}; //turn a string into a number
|
||
|
||
|
||
var parse = function parse(str) {
|
||
//convert some known-numbers
|
||
if (casualForms.hasOwnProperty(str) === true) {
|
||
return casualForms[str];
|
||
} //'a/an' is 1
|
||
|
||
|
||
if (str === 'a' || str === 'an') {
|
||
return 1;
|
||
}
|
||
|
||
var modifier = findModifiers_1(str);
|
||
str = modifier.str;
|
||
var last_mult = null;
|
||
var has = {};
|
||
var sum = 0;
|
||
var isNegative = false;
|
||
var terms = str.split(/[ -]/);
|
||
|
||
for (var i = 0; i < terms.length; i++) {
|
||
var w = terms[i];
|
||
w = parseNumeric_1(w);
|
||
|
||
if (!w || w === 'and') {
|
||
continue;
|
||
}
|
||
|
||
if (w === '-' || w === 'negative') {
|
||
isNegative = true;
|
||
continue;
|
||
}
|
||
|
||
if (w.charAt(0) === '-') {
|
||
isNegative = true;
|
||
w = w.substr(1);
|
||
} //decimal mode
|
||
|
||
|
||
if (w === 'point') {
|
||
sum += section_sum(has);
|
||
sum += parseDecimals_1(terms.slice(i + 1, terms.length));
|
||
sum *= modifier.amount;
|
||
return sum;
|
||
} //improper fraction
|
||
|
||
|
||
var fm = w.match(improperFraction);
|
||
|
||
if (fm) {
|
||
var num = parseFloat(fm[1].replace(/[, ]/g, ''));
|
||
var denom = parseFloat(fm[2].replace(/[, ]/g, ''));
|
||
|
||
if (denom) {
|
||
sum += num / denom || 0;
|
||
}
|
||
|
||
continue;
|
||
} //prevent mismatched units, like 'seven eleven'
|
||
|
||
|
||
if (validate(w, has) === false) {
|
||
return null;
|
||
} //buildOut section, collect 'has' values
|
||
|
||
|
||
if (/^[0-9\.]+$/.test(w)) {
|
||
has['ones'] = parseFloat(w); //not technically right
|
||
} else if (data.ones.hasOwnProperty(w) === true) {
|
||
has['ones'] = data.ones[w];
|
||
} else if (data.teens.hasOwnProperty(w) === true) {
|
||
has['teens'] = data.teens[w];
|
||
} else if (data.tens.hasOwnProperty(w) === true) {
|
||
has['tens'] = data.tens[w];
|
||
} else if (data.multiples.hasOwnProperty(w) === true) {
|
||
var mult = data.multiples[w]; //something has gone wrong : 'two hundred five hundred'
|
||
|
||
if (mult === last_mult) {
|
||
return null;
|
||
} //support 'hundred thousand'
|
||
//this one is tricky..
|
||
|
||
|
||
if (mult === 100 && terms[i + 1] !== undefined) {
|
||
// has['hundreds']=
|
||
var w2 = terms[i + 1];
|
||
|
||
if (data.multiples[w2]) {
|
||
mult *= data.multiples[w2]; //hundredThousand/hundredMillion
|
||
|
||
i += 1;
|
||
}
|
||
} //natural order of things
|
||
//five thousand, one hundred..
|
||
|
||
|
||
if (last_mult === null || mult < last_mult) {
|
||
sum += (section_sum(has) || 1) * mult;
|
||
last_mult = mult;
|
||
has = {};
|
||
} else {
|
||
//maybe hundred .. thousand
|
||
sum += section_sum(has);
|
||
last_mult = mult;
|
||
sum = (sum || 1) * mult;
|
||
has = {};
|
||
}
|
||
}
|
||
} //dump the remaining has values
|
||
|
||
|
||
sum += section_sum(has); //post-process add modifier
|
||
|
||
sum *= modifier.amount;
|
||
sum *= isNegative ? -1 : 1; //dont return 0, if it went straight-through
|
||
|
||
if (sum === 0 && Object.keys(has).length === 0) {
|
||
return null;
|
||
}
|
||
|
||
return sum;
|
||
};
|
||
|
||
var toNumber = parse;
|
||
|
||
var parseNumeric$1 = function parseNumeric(str, p) {
|
||
str = str.replace(/,/g, ''); //parse a numeric-number (easy)
|
||
|
||
var arr = str.split(/^([^0-9]*)([0-9.,]*)([^0-9]*)$/);
|
||
|
||
if (arr && arr[2] && p.terms().length < 2) {
|
||
var num = parseFloat(arr[2] || str); //ensure that num is an actual number
|
||
|
||
if (typeof num !== 'number') {
|
||
num = null;
|
||
} // strip an ordinal off the suffix
|
||
|
||
|
||
var suffix = arr[3] || '';
|
||
|
||
if (suffix === 'st' || suffix === 'nd' || suffix === 'rd' || suffix === 'th') {
|
||
suffix = '';
|
||
} // support M for million, k for thousand
|
||
|
||
|
||
if (suffix === 'm' || suffix === 'M') {
|
||
num *= 1000000;
|
||
suffix = '';
|
||
}
|
||
|
||
if (suffix === 'k' || suffix === 'k') {
|
||
num *= 1000;
|
||
suffix = '';
|
||
}
|
||
|
||
return {
|
||
prefix: arr[1] || '',
|
||
num: num,
|
||
suffix: suffix
|
||
};
|
||
}
|
||
|
||
return null;
|
||
}; // get a numeric value from this phrase
|
||
|
||
|
||
var parseNumber = function parseNumber(p) {
|
||
var str = p.text('reduced'); // is it in '3,123' format?
|
||
|
||
var hasComma = /[0-9],[0-9]/.test(p.text('text')); // parse a numeric-number like '$4.00'
|
||
|
||
var res = parseNumeric$1(str, p);
|
||
|
||
if (res !== null) {
|
||
res.hasComma = hasComma;
|
||
return res;
|
||
} //parse a text-numer (harder)
|
||
|
||
|
||
var num = toNumber(str);
|
||
return {
|
||
hasComma: hasComma,
|
||
prefix: '',
|
||
num: num,
|
||
suffix: ''
|
||
};
|
||
};
|
||
|
||
var parse$1 = parseNumber;
|
||
|
||
// handle 'one bottle', 'two bottles'
|
||
var agreeUnits = function agreeUnits(agree, val, obj) {
|
||
if (agree === false) {
|
||
return;
|
||
}
|
||
|
||
var unit = val.lookAhead('^(#Unit|#Noun)'); // don't do these
|
||
|
||
if (unit.has('(#Address|#Money|#Percent)') || val.has('#Ordinal')) {
|
||
return;
|
||
}
|
||
|
||
if (obj.num === 1) {
|
||
unit.nouns().toSingular();
|
||
} else if (unit.has('#Singular')) {
|
||
unit.nouns().toPlural();
|
||
}
|
||
};
|
||
|
||
var _agreeUnits = agreeUnits;
|
||
|
||
/**
|
||
* turn big numbers, like 2.3e+22, into a string with a ton of trailing 0's
|
||
* */
|
||
var numToString = function numToString(n) {
|
||
if (n < 1000000) {
|
||
return String(n);
|
||
}
|
||
|
||
var str;
|
||
|
||
if (typeof n === 'number') {
|
||
str = n.toFixed(0);
|
||
} else {
|
||
str = n;
|
||
}
|
||
|
||
if (str.indexOf('e+') === -1) {
|
||
return str;
|
||
}
|
||
|
||
return str.replace('.', '').split('e+').reduce(function (p, b) {
|
||
return p + Array(b - p.length + 2).join(0);
|
||
});
|
||
};
|
||
|
||
var _toString = numToString; // console.log(numToString(2.5e+22));
|
||
|
||
/**
|
||
* turns an integer/float into.ber, like 'fifty-five'
|
||
*/
|
||
|
||
var tens_mapping = [['ninety', 90], ['eighty', 80], ['seventy', 70], ['sixty', 60], ['fifty', 50], ['forty', 40], ['thirty', 30], ['twenty', 20]];
|
||
var ones_mapping = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
|
||
var sequence = [[1e24, 'septillion'], [1e20, 'hundred sextillion'], [1e21, 'sextillion'], [1e20, 'hundred quintillion'], [1e18, 'quintillion'], [1e17, 'hundred quadrillion'], [1e15, 'quadrillion'], [1e14, 'hundred trillion'], [1e12, 'trillion'], [1e11, 'hundred billion'], [1e9, 'billion'], [1e8, 'hundred million'], [1e6, 'million'], [100000, 'hundred thousand'], [1000, 'thousand'], [100, 'hundred'], [1, 'one']]; //turn number into an array of magnitudes, like [[5, million], [2, hundred]]
|
||
|
||
var breakdown_magnitudes = function breakdown_magnitudes(num) {
|
||
var working = num;
|
||
var have = [];
|
||
sequence.forEach(function (a) {
|
||
if (num >= a[0]) {
|
||
var howmany = Math.floor(working / a[0]);
|
||
working -= howmany * a[0];
|
||
|
||
if (howmany) {
|
||
have.push({
|
||
unit: a[1],
|
||
count: howmany
|
||
});
|
||
}
|
||
}
|
||
});
|
||
return have;
|
||
}; //turn numbers from 100-0 into their text
|
||
|
||
|
||
var breakdown_hundred = function breakdown_hundred(num) {
|
||
var arr = [];
|
||
|
||
if (num > 100) {
|
||
return arr; //something bad happened..
|
||
}
|
||
|
||
for (var i = 0; i < tens_mapping.length; i++) {
|
||
if (num >= tens_mapping[i][1]) {
|
||
num -= tens_mapping[i][1];
|
||
arr.push(tens_mapping[i][0]);
|
||
}
|
||
} //(hopefully) we should only have 20-0 now
|
||
|
||
|
||
if (ones_mapping[num]) {
|
||
arr.push(ones_mapping[num]);
|
||
}
|
||
|
||
return arr;
|
||
};
|
||
/** print-out 'point eight nine'*/
|
||
|
||
|
||
var handle_decimal = function handle_decimal(num) {
|
||
var names = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'];
|
||
var arr = []; //parse it out like a string, because js math is such shit
|
||
|
||
var str = _toString(num);
|
||
var decimal = str.match(/\.([0-9]+)/);
|
||
|
||
if (!decimal || !decimal[0]) {
|
||
return arr;
|
||
}
|
||
|
||
arr.push('point');
|
||
var decimals = decimal[0].split('');
|
||
|
||
for (var i = 0; i < decimals.length; i++) {
|
||
arr.push(names[decimals[i]]);
|
||
}
|
||
|
||
return arr;
|
||
};
|
||
/** turns an integer into a textual number */
|
||
|
||
|
||
var to_text = function to_text(num) {
|
||
// handle zero, quickly
|
||
if (num === 0 || num === '0') {
|
||
return 'zero'; // no?
|
||
} //big numbers, north of sextillion, aren't gonna work well..
|
||
//keep them small..
|
||
|
||
|
||
if (num > 1e21) {
|
||
num = _toString(num);
|
||
}
|
||
|
||
var arr = []; //handle negative numbers
|
||
|
||
if (num < 0) {
|
||
arr.push('minus');
|
||
num = Math.abs(num);
|
||
} //break-down into units, counts
|
||
|
||
|
||
var units = breakdown_magnitudes(num); //build-up the string from its components
|
||
|
||
for (var i = 0; i < units.length; i++) {
|
||
var unit_name = units[i].unit;
|
||
|
||
if (unit_name === 'one') {
|
||
unit_name = ''; //put an 'and' in here
|
||
|
||
if (arr.length > 1) {
|
||
arr.push('and');
|
||
}
|
||
}
|
||
|
||
arr = arr.concat(breakdown_hundred(units[i].count));
|
||
arr.push(unit_name);
|
||
} //also support decimals - 'point eight'
|
||
|
||
|
||
arr = arr.concat(handle_decimal(num)); //remove empties
|
||
|
||
arr = arr.filter(function (s) {
|
||
return s;
|
||
});
|
||
|
||
if (arr.length === 0) {
|
||
arr[0] = '';
|
||
}
|
||
|
||
return arr.join(' ');
|
||
};
|
||
|
||
var toText = to_text; // console.log(to_text(-1000.8));
|
||
|
||
/**
|
||
* turn a number like 5 into an ordinal like 5th
|
||
*/
|
||
|
||
var numOrdinal = function numOrdinal(num) {
|
||
if (!num && num !== 0) {
|
||
return null;
|
||
} //the teens are all 'th'
|
||
|
||
|
||
var tens = num % 100;
|
||
|
||
if (tens > 10 && tens < 20) {
|
||
return String(num) + 'th';
|
||
} //the rest of 'em
|
||
|
||
|
||
var mapping = {
|
||
0: 'th',
|
||
1: 'st',
|
||
2: 'nd',
|
||
3: 'rd'
|
||
};
|
||
var str = _toString(num);
|
||
var last = str.slice(str.length - 1, str.length);
|
||
|
||
if (mapping[last]) {
|
||
str += mapping[last];
|
||
} else {
|
||
str += 'th';
|
||
}
|
||
|
||
return str;
|
||
};
|
||
|
||
var numOrdinal_1 = numOrdinal;
|
||
|
||
var irregulars = {
|
||
one: 'first',
|
||
two: 'second',
|
||
three: 'third',
|
||
five: 'fifth',
|
||
eight: 'eighth',
|
||
nine: 'ninth',
|
||
twelve: 'twelfth',
|
||
twenty: 'twentieth',
|
||
thirty: 'thirtieth',
|
||
forty: 'fortieth',
|
||
fourty: 'fourtieth',
|
||
fifty: 'fiftieth',
|
||
sixty: 'sixtieth',
|
||
seventy: 'seventieth',
|
||
eighty: 'eightieth',
|
||
ninety: 'ninetieth'
|
||
};
|
||
/**
|
||
* convert a javascript number to 'twentieth' format
|
||
* */
|
||
|
||
var textOrdinal = function textOrdinal(num) {
|
||
var words = toText(num).split(' '); //convert the last number to an ordinal
|
||
|
||
var last = words[words.length - 1];
|
||
|
||
if (irregulars.hasOwnProperty(last)) {
|
||
words[words.length - 1] = irregulars[last];
|
||
} else {
|
||
words[words.length - 1] = last.replace(/y$/, 'i') + 'th';
|
||
}
|
||
|
||
return words.join(' ');
|
||
};
|
||
|
||
var textOrdinal_1 = textOrdinal;
|
||
|
||
var prefixes = {
|
||
'¢': 'cents',
|
||
$: 'dollars',
|
||
'£': 'pounds',
|
||
'¥': 'yen',
|
||
'€': 'euros',
|
||
'₡': 'colón',
|
||
'฿': 'baht',
|
||
'₭': 'kip',
|
||
'₩': 'won',
|
||
'₹': 'rupees',
|
||
'₽': 'ruble',
|
||
'₺': 'liras'
|
||
};
|
||
var suffixes = {
|
||
'%': 'percent',
|
||
s: 'seconds',
|
||
cm: 'centimetres',
|
||
km: 'kilometres'
|
||
};
|
||
var _symbols = {
|
||
prefixes: prefixes,
|
||
suffixes: suffixes
|
||
};
|
||
|
||
var prefixes$1 = _symbols.prefixes;
|
||
var suffixes$1 = _symbols.suffixes;
|
||
var isCurrency = {
|
||
usd: true,
|
||
eur: true,
|
||
jpy: true,
|
||
gbp: true,
|
||
cad: true,
|
||
aud: true,
|
||
chf: true,
|
||
cny: true,
|
||
hkd: true,
|
||
nzd: true,
|
||
kr: true,
|
||
rub: true
|
||
}; // convert $ to 'dollars', etc
|
||
|
||
var prefixToText = function prefixToText(obj) {
|
||
// turn 5% to 'five percent'
|
||
if (prefixes$1.hasOwnProperty(obj.prefix)) {
|
||
obj.suffix += prefixes$1[obj.prefix];
|
||
obj.prefix = '';
|
||
} //turn 5km to 'five kilometres'
|
||
|
||
|
||
if (suffixes$1.hasOwnProperty(obj.suffix)) {
|
||
obj.suffix = suffixes$1[obj.suffix];
|
||
} //uppercase lost case for 'USD', etc
|
||
|
||
|
||
if (isCurrency.hasOwnProperty(obj.suffix)) {
|
||
obj.suffix = obj.suffix.toUpperCase();
|
||
} // add a space, if it exists
|
||
|
||
|
||
if (obj.suffix) {
|
||
obj.suffix = ' ' + obj.suffix;
|
||
}
|
||
|
||
return obj;
|
||
}; //business-logic for converting a cardinal-number to other forms
|
||
|
||
|
||
var makeNumber = function makeNumber(obj, isText, isOrdinal) {
|
||
var num = String(obj.num);
|
||
|
||
if (isText) {
|
||
obj = prefixToText(obj);
|
||
|
||
if (isOrdinal) {
|
||
//ordinal-text
|
||
num = textOrdinal_1(num);
|
||
return "".concat(obj.prefix || '').concat(num).concat(obj.suffix || '');
|
||
} //cardinal-text
|
||
|
||
|
||
num = toText(num);
|
||
return "".concat(obj.prefix || '').concat(num).concat(obj.suffix || '');
|
||
} //ordinal-number
|
||
|
||
|
||
if (isOrdinal) {
|
||
num = numOrdinal_1(num); // support '5th percent'
|
||
|
||
obj = prefixToText(obj);
|
||
return "".concat(obj.prefix || '').concat(num).concat(obj.suffix || '');
|
||
} // support comma format
|
||
|
||
|
||
if (obj.hasComma === true) {
|
||
num = obj.num.toLocaleString();
|
||
} // cardinal-number
|
||
|
||
|
||
num = _toString(num); // support very large numbers
|
||
|
||
return "".concat(obj.prefix || '').concat(num).concat(obj.suffix || '');
|
||
};
|
||
|
||
var makeNumber_1 = makeNumber;
|
||
|
||
var methods = {
|
||
/** overloaded json method with additional number information */
|
||
json: function json(options) {
|
||
var n = null;
|
||
|
||
if (typeof options === 'number') {
|
||
n = options;
|
||
options = null;
|
||
}
|
||
|
||
options = options || {
|
||
text: true,
|
||
normal: true,
|
||
trim: true,
|
||
terms: true
|
||
};
|
||
var res = [];
|
||
this.forEach(function (doc) {
|
||
var json = doc.json(options)[0];
|
||
var obj = parse$1(doc);
|
||
json.prefix = obj.prefix;
|
||
json.number = obj.num;
|
||
json.suffix = obj.suffix;
|
||
json.cardinal = makeNumber_1(obj, false, false);
|
||
json.ordinal = makeNumber_1(obj, false, true);
|
||
json.textCardinal = makeNumber_1(obj, true, false);
|
||
json.textOrdinal = makeNumber_1(obj, true, true);
|
||
res.push(json);
|
||
});
|
||
|
||
if (n !== null) {
|
||
return res[n];
|
||
}
|
||
|
||
return res;
|
||
},
|
||
|
||
/** two of what? */
|
||
units: function units() {
|
||
var m = this.lookAhead('(#Unit|#Noun)+');
|
||
m = m.splitAfter('@hasComma').first();
|
||
m = m.not('#Pronoun');
|
||
return m.first();
|
||
},
|
||
|
||
/** return only ordinal numbers */
|
||
isOrdinal: function isOrdinal() {
|
||
return this["if"]('#Ordinal');
|
||
},
|
||
|
||
/** return only cardinal numbers*/
|
||
isCardinal: function isCardinal() {
|
||
return this["if"]('#Cardinal');
|
||
},
|
||
|
||
/** convert to numeric form like '8' or '8th' */
|
||
toNumber: function toNumber() {
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
var str = makeNumber_1(obj, false, val.has('#Ordinal'));
|
||
val.replaceWith(str, true);
|
||
val.tag('NumericValue');
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** add commas, or nicer formatting for numbers */
|
||
toLocaleString: function toLocaleString() {
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
obj.num = obj.num.toLocaleString();
|
||
var str = makeNumber_1(obj, false, val.has('#Ordinal'));
|
||
val.replaceWith(str, true);
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** convert to text form - like 'eight' or 'eigth'*/
|
||
toText: function toText() {
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
var str = makeNumber_1(obj, true, val.has('#Ordinal'));
|
||
val.replaceWith(str, true);
|
||
val.tag('TextValue');
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** convert to cardinal form, like 'eight', or '8' */
|
||
toCardinal: function toCardinal(agree) {
|
||
var m = this["if"]('#Ordinal');
|
||
m.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
var str = makeNumber_1(obj, val.has('#TextValue'), false); // a hack for number-ranges
|
||
|
||
if (val.has('#NumberRange')) {
|
||
var t = val.termList()[0];
|
||
|
||
if (t.text && t.post === '') {
|
||
t.post = ' ';
|
||
}
|
||
} // change the number text
|
||
|
||
|
||
val.replaceWith(str, true);
|
||
val.tag('Cardinal'); // turn unit into plural -> 'seven beers'
|
||
|
||
_agreeUnits(agree, val, obj);
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** convert to ordinal form, like 'eighth', or '8th' */
|
||
toOrdinal: function toOrdinal() {
|
||
var _this = this;
|
||
|
||
var m = this["if"]('#Cardinal');
|
||
m.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
var str = makeNumber_1(obj, val.has('#TextValue'), true); // a hack for number-ranges
|
||
|
||
if (val.has('#NumberRange')) {
|
||
var t = val.termList()[0];
|
||
|
||
if (t.text && t.post === '') {
|
||
t.post = ' ';
|
||
}
|
||
} // change the number text
|
||
|
||
|
||
val.replaceWith(str, true);
|
||
val.tag('Ordinal'); // turn unit into singular -> 'seventh beer'
|
||
|
||
var unit = _this.lookAhead('^#Plural');
|
||
|
||
if (unit.found) {
|
||
unit.nouns().toSingular();
|
||
}
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** return only numbers that are == n */
|
||
isEqual: function isEqual(n) {
|
||
return this.filter(function (val) {
|
||
var num = parse$1(val).num;
|
||
return num === n;
|
||
});
|
||
},
|
||
|
||
/** return only numbers that are > n*/
|
||
greaterThan: function greaterThan(n) {
|
||
return this.filter(function (val) {
|
||
var num = parse$1(val).num;
|
||
return num > n;
|
||
});
|
||
},
|
||
|
||
/** return only numbers that are < n*/
|
||
lessThan: function lessThan(n) {
|
||
return this.filter(function (val) {
|
||
var num = parse$1(val).num;
|
||
return num < n;
|
||
});
|
||
},
|
||
|
||
/** return only numbers > min and < max */
|
||
between: function between(min, max) {
|
||
return this.filter(function (val) {
|
||
var num = parse$1(val).num;
|
||
return num > min && num < max;
|
||
});
|
||
},
|
||
|
||
/** set these number to n */
|
||
set: function set(n, agree) {
|
||
if (n === undefined) {
|
||
return this; // don't bother
|
||
}
|
||
|
||
if (typeof n === 'string') {
|
||
n = toNumber(n);
|
||
}
|
||
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
obj.num = n;
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
var str = makeNumber_1(obj, val.has('#TextValue'), val.has('#Ordinal'));
|
||
val = val.not('#Currency');
|
||
val.replaceWith(str, true); // handle plural/singular unit
|
||
|
||
_agreeUnits(agree, val, obj);
|
||
});
|
||
return this;
|
||
},
|
||
add: function add(n, agree) {
|
||
if (!n) {
|
||
return this; // don't bother
|
||
}
|
||
|
||
if (typeof n === 'string') {
|
||
n = toNumber(n);
|
||
}
|
||
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num === null) {
|
||
return;
|
||
}
|
||
|
||
obj.num += n;
|
||
var str = makeNumber_1(obj, val.has('#TextValue'), val.has('#Ordinal'));
|
||
val = val.not('#Currency');
|
||
val.replaceWith(str, true); // handle plural/singular unit
|
||
|
||
_agreeUnits(agree, val, obj);
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** decrease each number by n*/
|
||
subtract: function subtract(n, agree) {
|
||
return this.add(n * -1, agree);
|
||
},
|
||
|
||
/** increase each number by 1 */
|
||
increment: function increment(agree) {
|
||
this.add(1, agree);
|
||
return this;
|
||
},
|
||
|
||
/** decrease each number by 1 */
|
||
decrement: function decrement(agree) {
|
||
this.add(-1, agree);
|
||
return this;
|
||
},
|
||
|
||
/** return things like CCXX*/
|
||
romanNumerals: function romanNumerals(n) {
|
||
var m = this.match('#RomanNumeral').numbers();
|
||
|
||
if (typeof n === 'number') {
|
||
m = m.get(n);
|
||
}
|
||
|
||
return m;
|
||
},
|
||
|
||
/** split-apart suffix and number */
|
||
normalize: function normalize() {
|
||
var keep = {
|
||
'%': true
|
||
};
|
||
this.forEach(function (val) {
|
||
var obj = parse$1(val);
|
||
|
||
if (obj.num !== null && obj.suffix && keep[obj.suffix] !== true) {
|
||
var prefix = obj.prefix || '';
|
||
val = val.replaceWith(prefix + obj.num + ' ' + obj.suffix);
|
||
return;
|
||
}
|
||
});
|
||
return this;
|
||
},
|
||
|
||
/** retrieve the parsed number */
|
||
get: function get(n) {
|
||
var arr = [];
|
||
this.forEach(function (doc) {
|
||
arr.push(parse$1(doc).num);
|
||
});
|
||
|
||
if (n !== undefined) {
|
||
return arr[n];
|
||
}
|
||
|
||
return arr;
|
||
}
|
||
}; // aliases
|
||
|
||
methods.toNice = methods.toLocaleString;
|
||
methods.isBetween = methods.between;
|
||
methods.minus = methods.subtract;
|
||
methods.plus = methods.add;
|
||
methods.equals = methods.isEqual;
|
||
var methods_1 = methods;
|
||
|
||
//from wikipedia's {{infobox currency}}, Dec 2020
|
||
var currencies = [{
|
||
dem: 'american',
|
||
name: 'dollar',
|
||
iso: 'usd',
|
||
sub: 'cent',
|
||
sym: ['$', 'US$', 'U$']
|
||
}, {
|
||
name: 'euro',
|
||
iso: 'eur',
|
||
sub: 'cent',
|
||
sym: ['€']
|
||
}, {
|
||
dem: 'british',
|
||
name: 'pound',
|
||
iso: 'gbp',
|
||
sub: 'penny',
|
||
alias: {
|
||
sterling: true
|
||
},
|
||
sym: ['£']
|
||
}, {
|
||
name: 'renminbi',
|
||
iso: 'cny',
|
||
sub: 'yuán',
|
||
plural: 'yuán',
|
||
alias: {
|
||
yuan: true
|
||
},
|
||
sym: ['元'] //'¥'
|
||
|
||
}, {
|
||
dem: 'japanese',
|
||
name: 'yen',
|
||
iso: 'jpy',
|
||
sub: 'sen',
|
||
sym: ['¥', '円', '圓']
|
||
}, // kr
|
||
{
|
||
dem: 'swedish',
|
||
name: 'krona',
|
||
iso: 'sek',
|
||
sub: 'öre',
|
||
alias: {
|
||
ore: true,
|
||
kronor: true
|
||
},
|
||
sym: ['kr']
|
||
}, {
|
||
dem: 'estonian',
|
||
name: 'kroon',
|
||
iso: 'eek',
|
||
sub: 'sent',
|
||
sym: ['kr']
|
||
}, {
|
||
dem: 'norwegian',
|
||
name: 'krone',
|
||
iso: 'nok',
|
||
sub: 'øre',
|
||
sym: ['kr']
|
||
}, {
|
||
dem: 'icelandic',
|
||
name: 'króna',
|
||
iso: 'isk',
|
||
sym: ['kr']
|
||
}, {
|
||
dem: 'danish',
|
||
name: 'krone',
|
||
iso: 'dkk',
|
||
sub: 'øre',
|
||
sym: ['kr.']
|
||
}, // {
|
||
// dem: 'scandinavian',
|
||
// name: 'Monetary Union',
|
||
// sub: 'øre',
|
||
// sym: ['kr.'],
|
||
// },
|
||
// 'k'
|
||
{
|
||
dem: 'zambian',
|
||
name: 'kwacha',
|
||
iso: 'zmw',
|
||
sub: 'ngwee',
|
||
sym: ['K']
|
||
}, {
|
||
dem: 'malawian',
|
||
name: 'kwacha',
|
||
iso: 'mwk',
|
||
sub: 'tambala',
|
||
sym: ['K']
|
||
}, // misc
|
||
{
|
||
dem: 'greek',
|
||
name: 'drachma',
|
||
iso: 'grd',
|
||
sub: 'leptοn',
|
||
sym: ['Δρχ.', 'Δρ.', '₯']
|
||
}, {
|
||
dem: 'eastern caribbean',
|
||
name: 'dollar',
|
||
iso: 'xcd',
|
||
sub: 'cent',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'finnish',
|
||
name: 'markka',
|
||
iso: 'fim',
|
||
sub: 'penni',
|
||
sym: ['mk']
|
||
}, {
|
||
dem: 'polish',
|
||
name: 'złoty',
|
||
iso: 'pln',
|
||
sub: 'grosz',
|
||
sym: ['zł']
|
||
}, {
|
||
dem: 'slovenian',
|
||
name: 'tolar',
|
||
iso: 'sit',
|
||
sub: 'stotin',
|
||
sym: []
|
||
}, {
|
||
dem: 'australian',
|
||
name: 'dollar',
|
||
iso: 'aud',
|
||
sub: 'cent',
|
||
sym: ['$', 'A$', 'AU$']
|
||
}, {
|
||
dem: 'deutsche',
|
||
name: 'mark',
|
||
iso: 'dem',
|
||
sub: 'pfennig',
|
||
sym: ['DM']
|
||
}, {
|
||
dem: 'thai',
|
||
name: 'baht',
|
||
iso: 'thb',
|
||
sub: 'satang',
|
||
sym: ['฿']
|
||
}, {
|
||
dem: 'canadian',
|
||
name: 'dollar',
|
||
iso: 'cad',
|
||
sub: 'cent',
|
||
sym: ['$', 'Can$', 'C$', 'CA$', 'CAD']
|
||
}, {
|
||
dem: 'mexican',
|
||
name: 'peso',
|
||
iso: 'mxn',
|
||
sub: 'centavo',
|
||
sym: ['$', 'Mex$']
|
||
}, {
|
||
dem: 'spanish',
|
||
name: 'peseta',
|
||
iso: 'esp',
|
||
sub: 'céntimo',
|
||
sym: ['Pta']
|
||
}, {
|
||
dem: 'new zealand',
|
||
name: 'dollar',
|
||
iso: 'nzd',
|
||
sub: 'cent',
|
||
sym: ['$', 'NZ$']
|
||
}, {
|
||
dem: 'chilean',
|
||
name: 'peso',
|
||
iso: 'clp',
|
||
sub: 'Centavo',
|
||
sym: ['Cifrão', '$']
|
||
}, {
|
||
dem: 'nigerian',
|
||
name: 'naira',
|
||
iso: 'ngn',
|
||
sub: 'kobo',
|
||
sym: ['₦']
|
||
}, {
|
||
dem: 'austrian',
|
||
name: 'schilling',
|
||
iso: 'ats',
|
||
sub: 'groschen',
|
||
sym: ['S', 'öS']
|
||
}, {
|
||
dem: 'guatemalan',
|
||
name: 'quetzal',
|
||
iso: 'gtq',
|
||
sub: 'centavo',
|
||
sym: ['Q']
|
||
}, {
|
||
dem: 'philippine',
|
||
name: 'peso',
|
||
iso: 'php',
|
||
sub: 'sentimo',
|
||
sym: ['₱']
|
||
}, {
|
||
dem: 'hungarian',
|
||
name: 'forint',
|
||
iso: 'huf',
|
||
sub: 'fillér',
|
||
sym: ['Ft']
|
||
}, {
|
||
dem: 'russian',
|
||
name: 'ruble',
|
||
iso: 'rub',
|
||
sub: 'kopeyka',
|
||
sym: ['₽', 'руб', 'р.']
|
||
}, {
|
||
dem: 'kuwaiti',
|
||
name: 'dinar',
|
||
iso: 'kwd',
|
||
sub: 'fils',
|
||
sym: ['د.ك', 'KD']
|
||
}, {
|
||
dem: 'israeli',
|
||
name: 'new shekel',
|
||
iso: 'ils',
|
||
sub: 'agora',
|
||
sym: ['₪']
|
||
}, {
|
||
dem: 'latvian',
|
||
name: 'lats',
|
||
iso: 'lvl',
|
||
sub: 'santīms',
|
||
sym: ['Ls']
|
||
}, {
|
||
dem: 'kazakhstani',
|
||
name: 'tenge',
|
||
iso: 'kzt',
|
||
sub: 'tıyn',
|
||
sym: ['₸']
|
||
}, {
|
||
dem: 'iraqi',
|
||
name: 'dinar',
|
||
iso: 'iqd',
|
||
sub: 'fils',
|
||
sym: ['د.ع']
|
||
}, {
|
||
dem: 'bahamian',
|
||
name: 'dollar',
|
||
iso: 'bsd',
|
||
sub: 'cent',
|
||
sym: ['$', 'B$']
|
||
}, {
|
||
dem: 'seychellois',
|
||
name: 'rupee',
|
||
iso: 'scr',
|
||
sub: 'cent',
|
||
sym: ['SCR', 'SR']
|
||
}, {
|
||
dem: 'albanian',
|
||
name: 'lek',
|
||
iso: 'all',
|
||
sub: 'qindarkë',
|
||
sym: ['L']
|
||
}, {
|
||
dem: 'bulgarian',
|
||
name: 'lev',
|
||
iso: 'bgn',
|
||
sub: 'stotinka',
|
||
sym: ['лв.']
|
||
}, {
|
||
dem: 'irish',
|
||
name: 'pound',
|
||
iso: 'iep',
|
||
sym: ['£', 'IR£']
|
||
}, {
|
||
name: 'cfp franc',
|
||
iso: 'xpf',
|
||
sym: ['f']
|
||
}, {
|
||
dem: 'south african',
|
||
name: 'rand',
|
||
iso: 'zar',
|
||
sub: 'cent',
|
||
sym: ['R']
|
||
}, {
|
||
dem: 'south korean',
|
||
name: 'won',
|
||
iso: 'krw',
|
||
sub: 'jeon',
|
||
plural: 'won',
|
||
sym: ['₩']
|
||
}, {
|
||
dem: 'north korean',
|
||
name: 'won',
|
||
iso: 'kpw',
|
||
sub: 'chon',
|
||
plural: 'won',
|
||
sym: ['₩']
|
||
}, {
|
||
dem: 'portuguese',
|
||
name: 'escudo',
|
||
iso: 'pte',
|
||
sub: 'centavo',
|
||
sym: []
|
||
}, {
|
||
dem: 'ghanaian',
|
||
name: 'cedi',
|
||
iso: 'ghs',
|
||
sub: 'pesewa',
|
||
sym: ['GH₵']
|
||
}, {
|
||
dem: 'hong kong',
|
||
name: 'dollar',
|
||
iso: 'hkd',
|
||
sub: '毫',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'new taiwan',
|
||
name: 'dollar',
|
||
iso: 'twd',
|
||
sub: 'dime',
|
||
sym: ['NT$']
|
||
}, {
|
||
dem: 'east german',
|
||
name: 'mark',
|
||
iso: 'ddm',
|
||
sub: 'pfennig',
|
||
sym: ['M']
|
||
}, {
|
||
dem: 'namibian',
|
||
name: 'dollar',
|
||
iso: 'nad',
|
||
sub: 'cent',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'malaysian',
|
||
name: 'ringgit',
|
||
iso: 'myr',
|
||
sub: 'sen',
|
||
sym: ['RM']
|
||
}, {
|
||
dem: 'swiss',
|
||
name: 'franc',
|
||
iso: 'chf',
|
||
sym: ['Rp.']
|
||
}, {
|
||
dem: 'panamanian',
|
||
name: 'balboa',
|
||
iso: 'pab',
|
||
sub: 'centésimo',
|
||
sym: ['B/.']
|
||
}, {
|
||
dem: 'indonesian',
|
||
name: 'rupiah',
|
||
iso: 'idr',
|
||
sub: 'sen',
|
||
sym: ['Rp']
|
||
}, {
|
||
dem: 'brunei',
|
||
name: 'dollar',
|
||
iso: 'bnd',
|
||
sub: 'sen',
|
||
sym: ['$', 'B$']
|
||
}, {
|
||
dem: 'venezuelan',
|
||
name: 'bolívar',
|
||
iso: 'vef',
|
||
sub: 'céntimo',
|
||
sym: ['Bs.F', 'Bs.']
|
||
}, {
|
||
dem: 'macedonian',
|
||
name: 'denar',
|
||
iso: 'mkd',
|
||
sub: 'deni',
|
||
sym: ['den']
|
||
}, {
|
||
dem: 'mauritanian',
|
||
name: 'ouguiya',
|
||
iso: 'mru',
|
||
sub: 'khoums',
|
||
sym: ['UM']
|
||
}, {
|
||
dem: 'argentine',
|
||
name: 'peso',
|
||
iso: 'ars',
|
||
sub: 'centavo',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'libyan',
|
||
name: 'dinar',
|
||
iso: 'lyd',
|
||
sub: 'dirham',
|
||
sym: ['LD', 'ل.د']
|
||
}, {
|
||
dem: 'jordanian',
|
||
name: 'dinar',
|
||
iso: 'jod',
|
||
sub: 'dirham',
|
||
sym: ['د.أ']
|
||
}, {
|
||
dem: 'french',
|
||
name: 'franc',
|
||
iso: 'frf',
|
||
sub: 'centime',
|
||
sym: ['F', 'Fr', 'FF', '₣']
|
||
}, {
|
||
dem: 'syrian',
|
||
name: 'pound',
|
||
iso: 'syp',
|
||
sub: 'piastre',
|
||
sym: ['LS', '£S']
|
||
}, {
|
||
dem: 'belize',
|
||
name: 'dollar',
|
||
iso: 'bzd',
|
||
sub: 'cent',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'saudi',
|
||
name: 'riyal',
|
||
iso: 'sar',
|
||
sub: 'halalah',
|
||
sym: ['SAR', 'ر.س', ' ﷼']
|
||
}, {
|
||
dem: 'surinamese',
|
||
name: 'dollar',
|
||
iso: 'srd',
|
||
sub: 'cent',
|
||
sym: ['$']
|
||
}, {
|
||
dem: 'singapore',
|
||
name: 'dollar',
|
||
iso: 'sgd',
|
||
sub: 'cent',
|
||
sym: ['S$', '$']
|
||
}, {
|
||
dem: 'nepalese',
|
||
name: 'rupee',
|
||
iso: 'npr',
|
||
sub: 'Paisa',
|
||
sym: ['रु ₨', 'Re']
|
||
}, {
|
||
dem: 'macanese',
|
||
name: 'pataca',
|
||
iso: 'mop',
|
||
sub: 'ho',
|
||
sym: ['MOP$']
|
||
}, {
|
||
dem: 'nicaraguan',
|
||
name: 'córdoba',
|
||
iso: 'nio',
|
||
sub: 'centavo',
|
||
sym: ['C$']
|
||
}, {
|
||
dem: 'bangladeshi',
|
||
name: 'taka',
|
||
iso: 'bdt',
|
||
sub: 'poysha',
|
||
sym: ['৳']
|
||
}, {
|
||
dem: 'indian',
|
||
name: 'rupee',
|
||
iso: 'inr',
|
||
sub: 'paisa',
|
||
sym: ['₹']
|
||
}, {
|
||
dem: 'maldivian',
|
||
name: 'rufiyaa',
|
||
iso: 'mvr',
|
||
sub: 'laari',
|
||
sym: ['Rf', 'MRf', 'MVR', '.ރ ']
|
||
}, {
|
||
dem: 'sri lankan',
|
||
name: 'rupee',
|
||
iso: 'lkr',
|
||
sub: 'Cents',
|
||
sym: ['Rs', 'රු', 'ரூ']
|
||
}, {
|
||
dem: 'bhutanese',
|
||
name: 'ngultrum',
|
||
iso: 'btn',
|
||
sub: 'chhertum',
|
||
sym: ['Nu.']
|
||
}, {
|
||
dem: 'turkish',
|
||
name: 'lira',
|
||
iso: 'try',
|
||
sub: 'new kuruş',
|
||
sym: ['YTL']
|
||
}, {
|
||
dem: 'serbian',
|
||
name: 'dinar',
|
||
iso: 'rsd',
|
||
sub: 'para',
|
||
sym: ['din', 'дин']
|
||
}, {
|
||
dem: 'bosnia and herzegovina',
|
||
name: 'convertible mark',
|
||
iso: 'bam',
|
||
sub: 'Fening/Pfenig',
|
||
sym: ['KM']
|
||
}, {
|
||
dem: 'botswana',
|
||
name: 'pula',
|
||
iso: 'bwp',
|
||
sub: 'thebe',
|
||
sym: ['p']
|
||
}, {
|
||
dem: 'swazi',
|
||
name: 'lilangeni',
|
||
iso: 'szl',
|
||
sub: 'cent',
|
||
sym: ['L', 'E']
|
||
}, {
|
||
dem: 'lithuanian',
|
||
name: 'litas',
|
||
iso: 'ltl',
|
||
sub: 'centas',
|
||
sym: ['Lt', 'ct']
|
||
}, {
|
||
dem: 'mauritian',
|
||
name: 'rupee',
|
||
iso: 'mur',
|
||
sub: 'cent',
|
||
sym: ['₨']
|
||
}, {
|
||
dem: 'pakistani',
|
||
name: 'rupee',
|
||
iso: 'pkr',
|
||
sub: 'Paisa',
|
||
sym: ['₨']
|
||
}, {
|
||
dem: 'maltese',
|
||
name: 'lira',
|
||
iso: 'mtl',
|
||
sub: 'cent',
|
||
sym: ['₤', 'Lm']
|
||
}, {
|
||
dem: 'cypriot',
|
||
name: 'pound',
|
||
iso: 'cyp',
|
||
sub: 'cent',
|
||
sym: ['£']
|
||
}, {
|
||
dem: 'moldovan',
|
||
name: 'leu',
|
||
iso: 'mdl',
|
||
sub: 'ban',
|
||
sym: ['l']
|
||
}, {
|
||
dem: 'croatian',
|
||
name: 'kuna',
|
||
iso: 'hrk',
|
||
sub: 'lipa',
|
||
sym: ['kn']
|
||
}, {
|
||
dem: 'afghan',
|
||
name: 'afghani',
|
||
iso: 'afn',
|
||
sub: 'pul',
|
||
sym: ['؋', 'Af', 'Afs']
|
||
}, {
|
||
dem: 'ecuadorian',
|
||
name: 'sucre',
|
||
iso: 'ecs',
|
||
sub: 'centavo',
|
||
sym: ['S/.']
|
||
}, {
|
||
dem: 'sierra leonean',
|
||
name: 'leone',
|
||
iso: 'sll',
|
||
sub: 'cent',
|
||
sym: ['Le']
|
||
} // {
|
||
//
|
||
// name: 'European Currency Unit',
|
||
// iso: 'xeu',
|
||
// sym: ['₠'],
|
||
// },
|
||
// {
|
||
//
|
||
// name: 'Special drawing rights',
|
||
// iso: 'xdr',
|
||
// sym: ['SDR'],
|
||
// },
|
||
// {
|
||
//
|
||
// name: 'Unidad de Valor Constante',
|
||
// iso: 'ecv',
|
||
// },
|
||
];
|
||
|
||
var symbols = {};
|
||
currencies.forEach(function (o) {
|
||
o.sym.forEach(function (str) {
|
||
symbols[str] = symbols[str] || o.iso;
|
||
});
|
||
symbols[o.iso] = symbols[o.iso] || o.iso;
|
||
}); // parse 'australian dollars'
|
||
|
||
var getNamedCurrency = function getNamedCurrency(doc) {
|
||
var m = doc.match('#Currency+');
|
||
m.nouns().toSingular(); // 'dollars'➔'dollar'
|
||
|
||
var str = m.text('reduced');
|
||
return currencies.find(function (o) {
|
||
// 'mexcan peso'
|
||
if (str === "".concat(o.dem, " ").concat(o.name)) {
|
||
return o;
|
||
} // 'CAD'
|
||
|
||
|
||
if (str === o.iso) {
|
||
return o;
|
||
} // 'cent'
|
||
|
||
|
||
if (str === o.sub) {
|
||
return o;
|
||
} // 'peso'
|
||
|
||
|
||
if (str === o.name) {
|
||
return o;
|
||
} // any other alt names
|
||
|
||
|
||
if (o.alias && o.alias[str] === true) {
|
||
return o;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
}; // turn '£' into GBP
|
||
|
||
|
||
var getBySymbol = function getBySymbol(obj) {
|
||
// do suffix first, for '$50CAD'
|
||
if (obj.suffix && symbols.hasOwnProperty(obj.suffix)) {
|
||
return currencies.find(function (o) {
|
||
return o.iso === symbols[obj.suffix];
|
||
});
|
||
} // parse prefix for '£50'
|
||
|
||
|
||
if (obj.prefix && symbols.hasOwnProperty(obj.prefix)) {
|
||
return currencies.find(function (o) {
|
||
return o.iso === symbols[obj.prefix];
|
||
});
|
||
}
|
||
|
||
return null;
|
||
};
|
||
|
||
var parseMoney = function parseMoney(doc) {
|
||
var res = parse$1(doc);
|
||
var found = getBySymbol(res) || getNamedCurrency(doc) || {};
|
||
var sym = '';
|
||
|
||
if (found && found.sym) {
|
||
sym = found.sym[0];
|
||
}
|
||
|
||
return {
|
||
num: res.num,
|
||
iso: found.iso,
|
||
demonym: found.dem,
|
||
currency: found.name,
|
||
plural: found.plural,
|
||
symbol: sym
|
||
};
|
||
};
|
||
|
||
var parse$2 = parseMoney;
|
||
|
||
var titleCase = function titleCase() {
|
||
var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
||
return str.replace(/\w\S*/g, function (txt) {
|
||
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
|
||
});
|
||
};
|
||
|
||
var moneyMethods = {
|
||
/** which currency is this money in? */
|
||
currency: function currency(n) {
|
||
var arr = [];
|
||
this.forEach(function (doc) {
|
||
var found = parse$2(doc);
|
||
|
||
if (found) {
|
||
arr.push(found);
|
||
}
|
||
});
|
||
|
||
if (typeof n === 'number') {
|
||
return arr[n];
|
||
}
|
||
|
||
return arr;
|
||
},
|
||
|
||
/** overloaded json method with additional number information */
|
||
json: function json(options) {
|
||
var n = null;
|
||
|
||
if (typeof options === 'number') {
|
||
n = options;
|
||
options = null;
|
||
}
|
||
|
||
options = options || {
|
||
text: true,
|
||
normal: true,
|
||
trim: true,
|
||
terms: true
|
||
};
|
||
var res = [];
|
||
this.forEach(function (doc) {
|
||
var json = doc.json(options)[0];
|
||
var obj = parse$2(doc);
|
||
json.number = obj.num;
|
||
|
||
if (obj.iso) {
|
||
json.iso = obj.iso.toUpperCase();
|
||
json.symbol = obj.symbol;
|
||
json.currency = titleCase(obj.demonym) + ' ' + titleCase(obj.currency);
|
||
} // 'thirty pounds'
|
||
|
||
|
||
json.textFmt = makeNumber_1(obj, true, false);
|
||
|
||
if (obj.currency) {
|
||
var str = obj.currency;
|
||
|
||
if (obj.num !== 1) {
|
||
str = obj.plural || str + 's';
|
||
}
|
||
|
||
json.textFmt += ' ' + str;
|
||
}
|
||
|
||
res.push(json);
|
||
});
|
||
|
||
if (n !== null) {
|
||
return res[n] || {};
|
||
}
|
||
|
||
return res;
|
||
}
|
||
};
|
||
var methods$1 = moneyMethods;
|
||
|
||
var endS = /s$/;
|
||
|
||
var slashForm = function slashForm(m) {
|
||
var str = m.text('reduced');
|
||
var found = str.match(/^([-+]?[0-9]+)\/([-+]?[0-9]+)(st|nd|rd|th)?s?$/);
|
||
|
||
if (found && found[1] && found[0]) {
|
||
return {
|
||
numerator: Number(found[1]),
|
||
denominator: Number(found[2])
|
||
};
|
||
}
|
||
|
||
return null;
|
||
}; // parse '4 out of 4'
|
||
|
||
|
||
var textForm1 = function textForm1(m) {
|
||
var found = m.match('[<num>#Value+] out of every? [<den>#Value+]');
|
||
|
||
if (found.found !== true) {
|
||
return null;
|
||
}
|
||
|
||
var _found$groups = found.groups(),
|
||
num = _found$groups.num,
|
||
den = _found$groups.den;
|
||
|
||
num = num.numbers().get(0);
|
||
den = den.numbers().get(0);
|
||
|
||
if (typeof num === 'number' && typeof den === 'number') {
|
||
return {
|
||
numerator: num,
|
||
denominator: den
|
||
};
|
||
}
|
||
|
||
return null;
|
||
}; // parse 'a third'
|
||
|
||
|
||
var textForm2 = function textForm2(m) {
|
||
var found = m.match('[<num>(#Cardinal|a)+] [<den>#Ordinal+]');
|
||
|
||
if (found.found !== true) {
|
||
return null;
|
||
}
|
||
|
||
var _found$groups2 = found.groups(),
|
||
num = _found$groups2.num,
|
||
den = _found$groups2.den; // quick-support for 'a third'
|
||
|
||
|
||
if (num.has('a')) {
|
||
num = 1;
|
||
} else {
|
||
num = num.numbers().get(0);
|
||
} // turn 'thirds' into third
|
||
|
||
|
||
var str = den.text('reduced');
|
||
|
||
if (endS.test(str)) {
|
||
str = str.replace(endS, '');
|
||
den.replaceWith(str);
|
||
} // support 'one half' as '1/2'
|
||
|
||
|
||
if (den.has('half')) {
|
||
den = 2;
|
||
} else {
|
||
den = den.numbers().get(0);
|
||
}
|
||
|
||
if (typeof num === 'number' && typeof den === 'number') {
|
||
return {
|
||
numerator: num,
|
||
denominator: den
|
||
};
|
||
}
|
||
|
||
return null;
|
||
};
|
||
|
||
var parseFraction = function parseFraction(m) {
|
||
return slashForm(m) || textForm1(m) || textForm2(m) || null;
|
||
};
|
||
|
||
var parse$3 = parseFraction;
|
||
|
||
var methods$2 = {
|
||
/** overloaded json method with additional number information */
|
||
json: function json(options) {
|
||
var n = null;
|
||
|
||
if (typeof options === 'number') {
|
||
n = options;
|
||
options = null;
|
||
}
|
||
|
||
options = options || {
|
||
text: true,
|
||
normal: true,
|
||
trim: true,
|
||
terms: true
|
||
};
|
||
var res = [];
|
||
this.forEach(function (m) {
|
||
var json = m.json(options)[0];
|
||
var found = parse$3(m) || {};
|
||
json.numerator = found.numerator;
|
||
json.denominator = found.denominator;
|
||
res.push(json);
|
||
});
|
||
|
||
if (n !== null) {
|
||
return res[n] || {};
|
||
}
|
||
|
||
return res;
|
||
},
|
||
|
||
/** change 'four out of 10' to 4/10 */
|
||
normalize: function normalize() {
|
||
var _this = this;
|
||
|
||
this.forEach(function (m) {
|
||
var found = parse$3(m);
|
||
|
||
if (found && typeof found.numerator === 'number' && typeof found.denominator === 'number') {
|
||
var str = "".concat(found.numerator, "/").concat(found.denominator);
|
||
|
||
_this.replace(m, str);
|
||
}
|
||
});
|
||
return this;
|
||
}
|
||
};
|
||
var methods_1$1 = methods$2;
|
||
|
||
var here = 'number-tag';
|
||
var multiples = '(hundred|thousand|million|billion|trillion|quadrillion|quintillion|sextillion|septillion)'; //support 'two thirds'
|
||
// (do this conservatively)
|
||
|
||
var ordinals = ['half', 'third', 'fourth', 'quarter', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth', 'hundredth', 'thousandth', 'millionth']; // add plural forms
|
||
|
||
var len = ordinals.length;
|
||
|
||
for (var i = 0; i < len; i += 1) {
|
||
ordinals.push(ordinals[i] + 's');
|
||
}
|
||
|
||
ordinals = "(".concat(ordinals.join('|'), ")"); // improved tagging for numbers
|
||
|
||
var tagger = function tagger(doc) {
|
||
doc.match(multiples).tag('#Multiple', here); // in the 400s
|
||
|
||
doc.match('the [/[0-9]+s$/]').tag('#Plural', here); //half a million
|
||
|
||
doc.match('half a? #Value').tag('Value', 'half-a-value'); //(quarter not ready)
|
||
//five and a half
|
||
|
||
doc.match('#Value and a (half|quarter)').tag('Value', 'value-and-a-half'); //one hundred and seven dollars
|
||
|
||
doc.match('#Money and #Money #Currency?').tag('Money', 'money-and-money'); // $5.032 is invalid money
|
||
|
||
doc.match('#Money').not('#TextValue').match('/\\.[0-9]{3}$/').unTag('#Money', 'three-decimal money'); // cleanup currency false-positives
|
||
|
||
doc.ifNo('#Value').match('#Currency #Verb').unTag('Currency', 'no-currency'); // 6 dollars and 5 cents
|
||
|
||
doc.match('#Value #Currency [and] #Value (cents|ore|centavos|sens)', 0).tag('Money', here); // maybe currencies
|
||
|
||
var m = doc.match('[<num>#Value] [<currency>(mark|rand|won|rub|ore)]');
|
||
m.group('num').tag('Money', here);
|
||
m.group('currency').tag('Currency', here); // fraction - '3 out of 5'
|
||
|
||
doc.match('#Cardinal+ out of every? #Cardinal').tag('Fraction', here); // fraction - 'a third of a slice'
|
||
|
||
m = doc.match("[(#Cardinal|a) ".concat(ordinals, "] of (a|an|the)"), 0).tag('Fraction', here); // tag 'thirds' as a ordinal
|
||
|
||
m.match('.$').tag('Ordinal', 'plural-ordinal');
|
||
};
|
||
|
||
var tagger_1 = tagger;
|
||
|
||
var tags = {
|
||
Fraction: {
|
||
isA: ['Value', 'NumericValue']
|
||
},
|
||
Multiple: {
|
||
isA: 'Value'
|
||
}
|
||
};
|
||
|
||
var ambig = {
|
||
mark: true,
|
||
sucre: true,
|
||
leone: true,
|
||
afghani: true,
|
||
rand: true,
|
||
"try": true,
|
||
mop: true,
|
||
won: true,
|
||
all: true,
|
||
rub: true,
|
||
eek: true,
|
||
sit: true,
|
||
bam: true,
|
||
npr: true,
|
||
leu: true
|
||
};
|
||
var lex = {
|
||
kronor: 'Currency'
|
||
};
|
||
currencies.forEach(function (o) {
|
||
if (o.iso && !ambig[o.iso]) {
|
||
lex[o.iso] = ['Acronym', 'Currency'];
|
||
}
|
||
|
||
var name = o.name;
|
||
|
||
if (name && !ambig[name]) {
|
||
lex[name] = 'Currency';
|
||
lex[name + 's'] = 'Currency';
|
||
}
|
||
|
||
if (o.dem) {
|
||
var dem = o.dem;
|
||
lex["".concat(dem, " ").concat(name)] = 'Currency';
|
||
lex["".concat(dem, " ").concat(name, "s")] = 'Currency';
|
||
}
|
||
});
|
||
var lexicon = lex;
|
||
|
||
/** adds .numbers() method */
|
||
|
||
var plugin = function plugin(Doc, world) {
|
||
// add money words to our lexicon
|
||
world.addWords(lexicon); // add tags to our tagset
|
||
|
||
world.addTags(tags); // additional tagging before running the number-parser
|
||
|
||
world.postProcess(tagger_1);
|
||
/** a list of number values, and their units */
|
||
|
||
var Numbers = /*#__PURE__*/function (_Doc) {
|
||
_inherits(Numbers, _Doc);
|
||
|
||
var _super = _createSuper(Numbers);
|
||
|
||
function Numbers() {
|
||
_classCallCheck(this, Numbers);
|
||
|
||
return _super.apply(this, arguments);
|
||
}
|
||
|
||
return Numbers;
|
||
}(Doc);
|
||
|
||
Object.assign(Numbers.prototype, methods_1);
|
||
/** a number and a currency */
|
||
|
||
var Money = /*#__PURE__*/function (_Numbers) {
|
||
_inherits(Money, _Numbers);
|
||
|
||
var _super2 = _createSuper(Money);
|
||
|
||
function Money() {
|
||
_classCallCheck(this, Money);
|
||
|
||
return _super2.apply(this, arguments);
|
||
}
|
||
|
||
return Money;
|
||
}(Numbers);
|
||
|
||
Object.assign(Money.prototype, methods$1);
|
||
|
||
var Fraction = /*#__PURE__*/function (_Numbers2) {
|
||
_inherits(Fraction, _Numbers2);
|
||
|
||
var _super3 = _createSuper(Fraction);
|
||
|
||
function Fraction() {
|
||
_classCallCheck(this, Fraction);
|
||
|
||
return _super3.apply(this, arguments);
|
||
}
|
||
|
||
return Fraction;
|
||
}(Numbers);
|
||
|
||
Object.assign(Fraction.prototype, methods_1$1);
|
||
var docMethods = {
|
||
/** find all numbers and values */
|
||
numbers: function numbers(n) {
|
||
var m = find(this, n);
|
||
return new Numbers(m.list, this, this.world);
|
||
},
|
||
|
||
/** return '4%' or 'four percent' etc*/
|
||
percentages: function percentages(n) {
|
||
var m = this.match('#Percent+');
|
||
m = m.concat(this.match('[#Cardinal] percent', 0));
|
||
|
||
if (typeof n === 'number') {
|
||
m = m.eq(n);
|
||
}
|
||
|
||
return new Numbers(m.list, this, this.world);
|
||
},
|
||
|
||
/** return '3 out of 5' or '3/5' etc**/
|
||
fractions: function fractions(n) {
|
||
var m = this.match('#Fraction+');
|
||
|
||
if (typeof n === 'number') {
|
||
m = m.eq(n);
|
||
}
|
||
|
||
return new Fraction(m.list, this, this.world);
|
||
},
|
||
|
||
/** number + currency pair */
|
||
money: function money() {
|
||
var m = this.splitOn('(#Money|#Currency)+');
|
||
m = m["if"]('#Money')["if"]('#Value');
|
||
return new Money(m.list, this, this.world);
|
||
}
|
||
}; // aliases
|
||
|
||
docMethods.values = docMethods.numbers;
|
||
docMethods.percents = docMethods.percentages;
|
||
Object.assign(Doc.prototype, docMethods);
|
||
return Doc;
|
||
};
|
||
|
||
var src = plugin;
|
||
|
||
return src;
|
||
|
||
})));
|
||
//# sourceMappingURL=compromise-numbers.js.map
|