@formatjs/intl-listformat
Advanced tools
Comparing version 7.1.6 to 7.1.7
{ | ||
"name": "@formatjs/intl-listformat", | ||
"version": "7.1.6", | ||
"version": "7.1.7", | ||
"description": "Formats JS list in a i18n-safe way", | ||
@@ -22,9 +22,9 @@ "keywords": [ | ||
"dependencies": { | ||
"@formatjs/ecma402-abstract": "1.14.2", | ||
"@formatjs/intl-localematcher": "0.2.31", | ||
"tslib": "2.4.0" | ||
"@formatjs/ecma402-abstract": "1.14.3", | ||
"@formatjs/intl-localematcher": "0.2.32", | ||
"tslib": "^2.4.0" | ||
}, | ||
"devDependencies": { | ||
"@formatjs/intl-getcanonicallocales": "2.0.4", | ||
"@formatjs/intl-locale": "3.0.10" | ||
"@formatjs/intl-getcanonicallocales": "2.0.5", | ||
"@formatjs/intl-locale": "3.0.11" | ||
}, | ||
@@ -31,0 +31,0 @@ "main": "index.js", |
(() => { | ||
// ../../../../../../../../execroot/formatjs/bazel-out/darwin_arm64-fastbuild/bin/node_modules/.aspect_rules_js/tslib@2.4.0/node_modules/tslib/tslib.es6.js | ||
var extendStatics = function(d, b) { | ||
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { | ||
d2.__proto__ = b2; | ||
} || function(d2, b2) { | ||
for (var p in b2) | ||
if (Object.prototype.hasOwnProperty.call(b2, p)) | ||
d2[p] = b2[p]; | ||
}; | ||
return extendStatics(d, b); | ||
var __create = Object.create; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __getProtoOf = Object.getPrototypeOf; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __commonJS = (cb, mod) => function __require() { | ||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; | ||
}; | ||
function __extends(d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { | ||
this.constructor = d; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
} | ||
var __assign = function() { | ||
__assign = Object.assign || function __assign2(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) | ||
if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
return to; | ||
}; | ||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
mod | ||
)); | ||
// ../../../../../../../../execroot/formatjs/bazel-out/darwin_arm64-fastbuild/bin/node_modules/.aspect_rules_js/tslib@2.4.0/node_modules/tslib/tslib.js | ||
var require_tslib = __commonJS({ | ||
"../../../../../../../../execroot/formatjs/bazel-out/darwin_arm64-fastbuild/bin/node_modules/.aspect_rules_js/tslib@2.4.0/node_modules/tslib/tslib.js"(exports, module) { | ||
var __extends2; | ||
var __assign2; | ||
var __rest2; | ||
var __decorate2; | ||
var __param2; | ||
var __metadata2; | ||
var __awaiter2; | ||
var __generator2; | ||
var __exportStar2; | ||
var __values2; | ||
var __read2; | ||
var __spread2; | ||
var __spreadArrays2; | ||
var __spreadArray2; | ||
var __await2; | ||
var __asyncGenerator2; | ||
var __asyncDelegator2; | ||
var __asyncValues2; | ||
var __makeTemplateObject2; | ||
var __importStar2; | ||
var __importDefault2; | ||
var __classPrivateFieldGet2; | ||
var __classPrivateFieldSet2; | ||
var __classPrivateFieldIn2; | ||
var __createBinding2; | ||
(function(factory) { | ||
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {}; | ||
if (typeof define === "function" && define.amd) { | ||
define("tslib", ["exports"], function(exports2) { | ||
factory(createExporter(root, createExporter(exports2))); | ||
}); | ||
} else if (typeof module === "object" && typeof module.exports === "object") { | ||
factory(createExporter(root, createExporter(module.exports))); | ||
} else { | ||
factory(createExporter(root)); | ||
} | ||
function createExporter(exports2, previous) { | ||
if (exports2 !== root) { | ||
if (typeof Object.create === "function") { | ||
Object.defineProperty(exports2, "__esModule", { value: true }); | ||
} else { | ||
exports2.__esModule = true; | ||
} | ||
} | ||
return function(id, v) { | ||
return exports2[id] = previous ? previous(id, v) : v; | ||
}; | ||
} | ||
})(function(exporter) { | ||
var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) { | ||
d.__proto__ = b; | ||
} || function(d, b) { | ||
for (var p in b) | ||
if (Object.prototype.hasOwnProperty.call(b, p)) | ||
d[p] = b[p]; | ||
}; | ||
__extends2 = function(d, b) { | ||
if (typeof b !== "function" && b !== null) | ||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
extendStatics(d, b); | ||
function __() { | ||
this.constructor = d; | ||
} | ||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
}; | ||
__assign2 = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) | ||
if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
__rest2 = function(s, e) { | ||
var t = {}; | ||
for (var p in s) | ||
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
t[p] = s[p]; | ||
if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
t[p[i]] = s[p[i]]; | ||
} | ||
return t; | ||
}; | ||
__decorate2 = function(decorators, target, key, desc) { | ||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; | ||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") | ||
r = Reflect.decorate(decorators, target, key, desc); | ||
else | ||
for (var i = decorators.length - 1; i >= 0; i--) | ||
if (d = decorators[i]) | ||
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; | ||
return c > 3 && r && Object.defineProperty(target, key, r), r; | ||
}; | ||
__param2 = function(paramIndex, decorator) { | ||
return function(target, key) { | ||
decorator(target, key, paramIndex); | ||
}; | ||
}; | ||
__metadata2 = function(metadataKey, metadataValue) { | ||
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") | ||
return Reflect.metadata(metadataKey, metadataValue); | ||
}; | ||
__awaiter2 = function(thisArg, _arguments, P, generator) { | ||
function adopt(value) { | ||
return value instanceof P ? value : new P(function(resolve) { | ||
resolve(value); | ||
}); | ||
} | ||
return new (P || (P = Promise))(function(resolve, reject) { | ||
function fulfilled(value) { | ||
try { | ||
step(generator.next(value)); | ||
} catch (e) { | ||
reject(e); | ||
} | ||
} | ||
function rejected(value) { | ||
try { | ||
step(generator["throw"](value)); | ||
} catch (e) { | ||
reject(e); | ||
} | ||
} | ||
function step(result) { | ||
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); | ||
} | ||
step((generator = generator.apply(thisArg, _arguments || [])).next()); | ||
}); | ||
}; | ||
__generator2 = function(thisArg, body) { | ||
var _ = { label: 0, sent: function() { | ||
if (t[0] & 1) | ||
throw t[1]; | ||
return t[1]; | ||
}, trys: [], ops: [] }, f, y, t, g; | ||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { | ||
return this; | ||
}), g; | ||
function verb(n) { | ||
return function(v) { | ||
return step([n, v]); | ||
}; | ||
} | ||
function step(op) { | ||
if (f) | ||
throw new TypeError("Generator is already executing."); | ||
while (_) | ||
try { | ||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) | ||
return t; | ||
if (y = 0, t) | ||
op = [op[0] & 2, t.value]; | ||
switch (op[0]) { | ||
case 0: | ||
case 1: | ||
t = op; | ||
break; | ||
case 4: | ||
_.label++; | ||
return { value: op[1], done: false }; | ||
case 5: | ||
_.label++; | ||
y = op[1]; | ||
op = [0]; | ||
continue; | ||
case 7: | ||
op = _.ops.pop(); | ||
_.trys.pop(); | ||
continue; | ||
default: | ||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { | ||
_ = 0; | ||
continue; | ||
} | ||
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { | ||
_.label = op[1]; | ||
break; | ||
} | ||
if (op[0] === 6 && _.label < t[1]) { | ||
_.label = t[1]; | ||
t = op; | ||
break; | ||
} | ||
if (t && _.label < t[2]) { | ||
_.label = t[2]; | ||
_.ops.push(op); | ||
break; | ||
} | ||
if (t[2]) | ||
_.ops.pop(); | ||
_.trys.pop(); | ||
continue; | ||
} | ||
op = body.call(thisArg, _); | ||
} catch (e) { | ||
op = [6, e]; | ||
y = 0; | ||
} finally { | ||
f = t = 0; | ||
} | ||
if (op[0] & 5) | ||
throw op[1]; | ||
return { value: op[0] ? op[1] : void 0, done: true }; | ||
} | ||
}; | ||
__exportStar2 = function(m, o) { | ||
for (var p in m) | ||
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) | ||
__createBinding2(o, m, p); | ||
}; | ||
__createBinding2 = Object.create ? function(o, m, k, k2) { | ||
if (k2 === void 0) | ||
k2 = k; | ||
var desc = Object.getOwnPropertyDescriptor(m, k); | ||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { | ||
desc = { enumerable: true, get: function() { | ||
return m[k]; | ||
} }; | ||
} | ||
Object.defineProperty(o, k2, desc); | ||
} : function(o, m, k, k2) { | ||
if (k2 === void 0) | ||
k2 = k; | ||
o[k2] = m[k]; | ||
}; | ||
__values2 = function(o) { | ||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | ||
if (m) | ||
return m.call(o); | ||
if (o && typeof o.length === "number") | ||
return { | ||
next: function() { | ||
if (o && i >= o.length) | ||
o = void 0; | ||
return { value: o && o[i++], done: !o }; | ||
} | ||
}; | ||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | ||
}; | ||
__read2 = function(o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) | ||
return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) | ||
ar.push(r.value); | ||
} catch (error) { | ||
e = { error }; | ||
} finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) | ||
m.call(i); | ||
} finally { | ||
if (e) | ||
throw e.error; | ||
} | ||
} | ||
return ar; | ||
}; | ||
__spread2 = function() { | ||
for (var ar = [], i = 0; i < arguments.length; i++) | ||
ar = ar.concat(__read2(arguments[i])); | ||
return ar; | ||
}; | ||
__spreadArrays2 = function() { | ||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) | ||
s += arguments[i].length; | ||
for (var r = Array(s), k = 0, i = 0; i < il; i++) | ||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) | ||
r[k] = a[j]; | ||
return r; | ||
}; | ||
__spreadArray2 = function(to, from, pack) { | ||
if (pack || arguments.length === 2) | ||
for (var i = 0, l = from.length, ar; i < l; i++) { | ||
if (ar || !(i in from)) { | ||
if (!ar) | ||
ar = Array.prototype.slice.call(from, 0, i); | ||
ar[i] = from[i]; | ||
} | ||
} | ||
return to.concat(ar || Array.prototype.slice.call(from)); | ||
}; | ||
__await2 = function(v) { | ||
return this instanceof __await2 ? (this.v = v, this) : new __await2(v); | ||
}; | ||
__asyncGenerator2 = function(thisArg, _arguments, generator) { | ||
if (!Symbol.asyncIterator) | ||
throw new TypeError("Symbol.asyncIterator is not defined."); | ||
var g = generator.apply(thisArg, _arguments || []), i, q = []; | ||
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | ||
return this; | ||
}, i; | ||
function verb(n) { | ||
if (g[n]) | ||
i[n] = function(v) { | ||
return new Promise(function(a, b) { | ||
q.push([n, v, a, b]) > 1 || resume(n, v); | ||
}); | ||
}; | ||
} | ||
function resume(n, v) { | ||
try { | ||
step(g[n](v)); | ||
} catch (e) { | ||
settle(q[0][3], e); | ||
} | ||
} | ||
function step(r) { | ||
r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); | ||
} | ||
function fulfill(value) { | ||
resume("next", value); | ||
} | ||
function reject(value) { | ||
resume("throw", value); | ||
} | ||
function settle(f, v) { | ||
if (f(v), q.shift(), q.length) | ||
resume(q[0][0], q[0][1]); | ||
} | ||
}; | ||
__asyncDelegator2 = function(o) { | ||
var i, p; | ||
return i = {}, verb("next"), verb("throw", function(e) { | ||
throw e; | ||
}), verb("return"), i[Symbol.iterator] = function() { | ||
return this; | ||
}, i; | ||
function verb(n, f) { | ||
i[n] = o[n] ? function(v) { | ||
return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v; | ||
} : f; | ||
} | ||
}; | ||
__asyncValues2 = function(o) { | ||
if (!Symbol.asyncIterator) | ||
throw new TypeError("Symbol.asyncIterator is not defined."); | ||
var m = o[Symbol.asyncIterator], i; | ||
return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | ||
return this; | ||
}, i); | ||
function verb(n) { | ||
i[n] = o[n] && function(v) { | ||
return new Promise(function(resolve, reject) { | ||
v = o[n](v), settle(resolve, reject, v.done, v.value); | ||
}); | ||
}; | ||
} | ||
function settle(resolve, reject, d, v) { | ||
Promise.resolve(v).then(function(v2) { | ||
resolve({ value: v2, done: d }); | ||
}, reject); | ||
} | ||
}; | ||
__makeTemplateObject2 = function(cooked, raw) { | ||
if (Object.defineProperty) { | ||
Object.defineProperty(cooked, "raw", { value: raw }); | ||
} else { | ||
cooked.raw = raw; | ||
} | ||
return cooked; | ||
}; | ||
var __setModuleDefault = Object.create ? function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
} : function(o, v) { | ||
o["default"] = v; | ||
}; | ||
__importStar2 = function(mod) { | ||
if (mod && mod.__esModule) | ||
return mod; | ||
var result = {}; | ||
if (mod != null) { | ||
for (var k in mod) | ||
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) | ||
__createBinding2(result, mod, k); | ||
} | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
__importDefault2 = function(mod) { | ||
return mod && mod.__esModule ? mod : { "default": mod }; | ||
}; | ||
__classPrivateFieldGet2 = function(receiver, state, kind, f) { | ||
if (kind === "a" && !f) | ||
throw new TypeError("Private accessor was defined without a getter"); | ||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) | ||
throw new TypeError("Cannot read private member from an object whose class did not declare it"); | ||
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); | ||
}; | ||
__classPrivateFieldSet2 = function(receiver, state, value, kind, f) { | ||
if (kind === "m") | ||
throw new TypeError("Private method is not writable"); | ||
if (kind === "a" && !f) | ||
throw new TypeError("Private accessor was defined without a setter"); | ||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) | ||
throw new TypeError("Cannot write private member to an object whose class did not declare it"); | ||
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; | ||
}; | ||
__classPrivateFieldIn2 = function(state, receiver) { | ||
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") | ||
throw new TypeError("Cannot use 'in' operator on non-object"); | ||
return typeof state === "function" ? receiver === state : state.has(receiver); | ||
}; | ||
exporter("__extends", __extends2); | ||
exporter("__assign", __assign2); | ||
exporter("__rest", __rest2); | ||
exporter("__decorate", __decorate2); | ||
exporter("__param", __param2); | ||
exporter("__metadata", __metadata2); | ||
exporter("__awaiter", __awaiter2); | ||
exporter("__generator", __generator2); | ||
exporter("__exportStar", __exportStar2); | ||
exporter("__createBinding", __createBinding2); | ||
exporter("__values", __values2); | ||
exporter("__read", __read2); | ||
exporter("__spread", __spread2); | ||
exporter("__spreadArrays", __spreadArrays2); | ||
exporter("__spreadArray", __spreadArray2); | ||
exporter("__await", __await2); | ||
exporter("__asyncGenerator", __asyncGenerator2); | ||
exporter("__asyncDelegator", __asyncDelegator2); | ||
exporter("__asyncValues", __asyncValues2); | ||
exporter("__makeTemplateObject", __makeTemplateObject2); | ||
exporter("__importStar", __importStar2); | ||
exporter("__importDefault", __importDefault2); | ||
exporter("__classPrivateFieldGet", __classPrivateFieldGet2); | ||
exporter("__classPrivateFieldSet", __classPrivateFieldSet2); | ||
exporter("__classPrivateFieldIn", __classPrivateFieldIn2); | ||
}); | ||
} | ||
}); | ||
// ../../../../../../../../execroot/formatjs/bazel-out/darwin_arm64-fastbuild/bin/node_modules/.aspect_rules_js/tslib@2.4.0/node_modules/tslib/modules/index.js | ||
var import_tslib = __toESM(require_tslib(), 1); | ||
var { | ||
__extends, | ||
__assign, | ||
__rest, | ||
__decorate, | ||
__param, | ||
__metadata, | ||
__awaiter, | ||
__generator, | ||
__exportStar, | ||
__createBinding, | ||
__values, | ||
__read, | ||
__spread, | ||
__spreadArrays, | ||
__spreadArray, | ||
__await, | ||
__asyncGenerator, | ||
__asyncDelegator, | ||
__asyncValues, | ||
__makeTemplateObject, | ||
__importStar, | ||
__importDefault, | ||
__classPrivateFieldGet, | ||
__classPrivateFieldSet, | ||
__classPrivateFieldIn | ||
} = import_tslib.default; | ||
// ../../../../../../../../execroot/formatjs/bazel-out/darwin_arm64-fastbuild/bin/node_modules/.aspect_rules_js/@formatjs+ecma402-abstract@0.0.0/node_modules/@formatjs/ecma402-abstract/lib/CanonicalizeLocaleList.js | ||
@@ -36,0 +495,0 @@ function CanonicalizeLocaleList(locales) { |
683724
6431
+ Added@formatjs/ecma402-abstract@1.14.3(transitive)
+ Added@formatjs/intl-localematcher@0.2.32(transitive)
+ Addedtslib@2.6.3(transitive)
- Removed@formatjs/ecma402-abstract@1.14.2(transitive)
- Removed@formatjs/intl-localematcher@0.2.31(transitive)
- Removedtslib@2.4.0(transitive)
Updatedtslib@^2.4.0