@formatjs/intl-segmenter 11.2.0 → 11.3.0

package/lib/src/segmenter.js

@@ -38,7 +38,7 @@ var breaksAtResult = function (breaks, matchingRule) { return ({
     breaks: breaks,
     matchingRule: matchingRule,
 }); };
-var Segmenter = /** @class */ (function () {
+export var Segmenter = /** @class */ (function () {
     function Segmenter(locales, options) {
         var _newTarget = this.constructor;
         if (_newTarget === undefined) {
@@ -75,6 +75,7 @@ var Segmenter = /** @class */ (function () {
         this.ruleSortedKeys = Object.keys(this.rules).sort(function (a, b) { return Number(a) - Number(b); });
     }
     Segmenter.prototype.breaksAt = function (position, input) {
+        var _a;
         var ruleSortedKeys = this.ruleSortedKeys;
         var rules = this.rules;
         var mergedSegmentationTypeValue = this.mergedSegmentationTypeValue;
@@ -95,17 +96,17 @@ var Segmenter = /** @class */ (function () {
         var stringAfterBreak = input.substring(position);
         //artificial rule 0.4: handle suppressions
         if ('suppressions' in mergedSegmentationTypeValue) {
-            for (var _i = 0, _a = mergedSegmentationTypeValue.suppressions; _i < _a.length; _i++) {
-                var suppressions = _a[_i];
+            for (var _i = 0, _b = mergedSegmentationTypeValue.suppressions; _i < _b.length; _i++) {
+                var suppressions = _b[_i];
                 if (stringBeforeBreak.trim().endsWith(suppressions)) {
                     return breaksAtResult(false, '0.4');
                 }
             }
         }
         // loop through rules and find a match
-        for (var _b = 0, ruleSortedKeys_1 = ruleSortedKeys; _b < ruleSortedKeys_1.length; _b++) {
-            var ruleKey = ruleSortedKeys_1[_b];
-            var _c = rules[ruleKey], before = _c.before, after = _c.after, breaks = _c.breaks;
+        for (var _c = 0, ruleSortedKeys_1 = ruleSortedKeys; _c < ruleSortedKeys_1.length; _c++) {
+            var ruleKey = ruleSortedKeys_1[_c];
+            var before = (_a = rules[ruleKey], _a.before), after = _a.after, breaks = _a.breaks;
             // for debugging
             // if (ruleKey === '16' && position === 4) {
             //   console.log({before, after, stringBeforeBreak, stringAfterBreak})
@@ -142,7 +143,6 @@ var Segmenter = /** @class */ (function () {
     Segmenter.polyfilled = true;
     return Segmenter;
 }());
-export { Segmenter };
 var createSegmentDataObject = function (segmenter, segment, index, input, matchingRule) {
     var returnValue = {
         segment: segment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/intl-segmenter",
-  "version": "11.2.0",
+  "version": "11.3.0",
   "description": "Polyfill for Intl.Segmenter",
   "keywords": [
     "intl",
@@ -19,12 +19,12 @@
     "url": "git@github.com:formatjs/formatjs.git"
   },
   "dependencies": {
-    "@formatjs/ecma402-abstract": "workspace:*",
-    "@formatjs/intl-localematcher": "workspace:*",
+    "@formatjs/ecma402-abstract": "1.14.3",
+    "@formatjs/intl-localematcher": "0.2.32",
     "tslib": "^2.4.0"
   },
   "main": "index.js",
   "types": "index.d.ts",
   "homepage": "https://github.com/formatjs/formatjs",
   "license": "MIT"
-}
+}

package/polyfill.iife.js

@@ -1,495 +1,47 @@
 (() => {
-  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;
+  // ../../../../../../../../execroot/formatjs/bazel-out/darwin-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 __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 });
+  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;
     }
-    return to;
+    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);
   };
-  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-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-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 __spreadArray(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];
         }
-        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-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;
+      }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  }
 
   // ../../../../../../../../execroot/formatjs/bazel-out/darwin-fastbuild/bin/packages/intl-segmenter/lib/src/cldr-segmentation-rules.generated.js
   var SegmentationRules = {
@@ -2142,15 +1694,18 @@
   }
 
   // ../../../../../../../../execroot/formatjs/bazel-out/darwin-fastbuild/bin/node_modules/.aspect_rules_js/@formatjs+ecma402-abstract@0.0.0/node_modules/@formatjs/ecma402-abstract/lib/data.js
-  var MissingLocaleDataError = function(_super) {
-    __extends(MissingLocaleDataError2, _super);
-    function MissingLocaleDataError2() {
-      var _this = _super !== null && _super.apply(this, arguments) || this;
-      _this.type = "MISSING_LOCALE_DATA";
-      return _this;
-    }
-    return MissingLocaleDataError2;
-  }(Error);
+  var MissingLocaleDataError = (
+    /** @class */
+    function(_super) {
+      __extends(MissingLocaleDataError2, _super);
+      function MissingLocaleDataError2() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.type = "MISSING_LOCALE_DATA";
+        return _this;
+      }
+      return MissingLocaleDataError2;
+    }(Error)
+  );
 
   // ../../../../../../../../execroot/formatjs/bazel-out/darwin-fastbuild/bin/node_modules/.aspect_rules_js/@formatjs+ecma402-abstract@0.0.0/node_modules/@formatjs/ecma402-abstract/lib/types/date-time.js
   var RangePatternType;
@@ -2188,102 +1743,109 @@
       matchingRule
     };
   };
-  var Segmenter = function() {
-    function Segmenter2(locales, options) {
-      var _newTarget = this.constructor;
-      if (_newTarget === void 0) {
-        throw TypeError("Constructor Intl.Segmenter requires 'new'");
-      }
-      var requestedLocales = CanonicalizeLocaleList(locales);
-      options = GetOptionsObject(options);
-      var opt = /* @__PURE__ */ Object.create(null);
-      var matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
-      opt.localeMatcher = matcher;
-      var granularity = GetOption(options, "granularity", "string", ["word", "sentence", "grapheme"], "grapheme");
-      setSlot(this, "granularity", granularity);
-      var r = ResolveLocale(
-        Segmenter2.availableLocales,
-        requestedLocales,
-        opt,
-        [],
-        {},
-        function() {
-          return "";
-        }
-      );
-      setSlot(this, "locale", r.locale);
-      this.mergedSegmentationTypeValue = SegmentationRules.root[granularity];
-      if (r.locale.length) {
-        var localeOverrides = SegmentationRules[r.locale];
-        if (granularity in localeOverrides) {
-          var localeSegmentationTypeValue = localeOverrides[granularity];
-          this.mergedSegmentationTypeValue.variables = __assign(__assign({}, this.mergedSegmentationTypeValue.variables), localeSegmentationTypeValue.variables);
-          this.mergedSegmentationTypeValue.segmentRules = __assign(__assign({}, this.mergedSegmentationTypeValue.segmentRules), localeSegmentationTypeValue.segmentRules);
-          this.mergedSegmentationTypeValue.suppressions = __spreadArray(__spreadArray([], this.mergedSegmentationTypeValue.suppressions, true), localeSegmentationTypeValue.suppressions, true);
+  var Segmenter = (
+    /** @class */
+    function() {
+      function Segmenter2(locales, options) {
+        var _newTarget = this.constructor;
+        if (_newTarget === void 0) {
+          throw TypeError("Constructor Intl.Segmenter requires 'new'");
         }
-      }
-      this.rules = prepareLocaleSegmentationRules(this.mergedSegmentationTypeValue);
-      this.ruleSortedKeys = Object.keys(this.rules).sort(function(a, b) {
-        return Number(a) - Number(b);
-      });
-    }
-    Segmenter2.prototype.breaksAt = function(position, input) {
-      var ruleSortedKeys = this.ruleSortedKeys;
-      var rules = this.rules;
-      var mergedSegmentationTypeValue = this.mergedSegmentationTypeValue;
-      if (position === 0) {
-        return breaksAtResult(true, "0.2");
-      }
-      if (position === input.length) {
-        return breaksAtResult(true, "0.3");
-      }
-      if (isSurrogate(input, position)) {
-        return breaksAtResult(false, "0.1");
-      }
-      var stringBeforeBreak = input.substring(0, position);
-      var stringAfterBreak = input.substring(position);
-      if ("suppressions" in mergedSegmentationTypeValue) {
-        for (var _i = 0, _a = mergedSegmentationTypeValue.suppressions; _i < _a.length; _i++) {
-          var suppressions = _a[_i];
-          if (stringBeforeBreak.trim().endsWith(suppressions)) {
-            return breaksAtResult(false, "0.4");
+        var requestedLocales = CanonicalizeLocaleList(locales);
+        options = GetOptionsObject(options);
+        var opt = /* @__PURE__ */ Object.create(null);
+        var matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
+        opt.localeMatcher = matcher;
+        var granularity = GetOption(options, "granularity", "string", ["word", "sentence", "grapheme"], "grapheme");
+        setSlot(this, "granularity", granularity);
+        var r = ResolveLocale(
+          Segmenter2.availableLocales,
+          //availible locales
+          requestedLocales,
+          opt,
+          [],
+          // there is no relevantExtensionKeys
+          {},
+          function() {
+            return "";
+          }
+          //use only root rules
+        );
+        setSlot(this, "locale", r.locale);
+        this.mergedSegmentationTypeValue = SegmentationRules.root[granularity];
+        if (r.locale.length) {
+          var localeOverrides = SegmentationRules[r.locale];
+          if (granularity in localeOverrides) {
+            var localeSegmentationTypeValue = localeOverrides[granularity];
+            this.mergedSegmentationTypeValue.variables = __assign(__assign({}, this.mergedSegmentationTypeValue.variables), localeSegmentationTypeValue.variables);
+            this.mergedSegmentationTypeValue.segmentRules = __assign(__assign({}, this.mergedSegmentationTypeValue.segmentRules), localeSegmentationTypeValue.segmentRules);
+            this.mergedSegmentationTypeValue.suppressions = __spreadArray(__spreadArray([], this.mergedSegmentationTypeValue.suppressions, true), localeSegmentationTypeValue.suppressions, true);
           }
         }
+        this.rules = prepareLocaleSegmentationRules(this.mergedSegmentationTypeValue);
+        this.ruleSortedKeys = Object.keys(this.rules).sort(function(a, b) {
+          return Number(a) - Number(b);
+        });
       }
-      for (var _b = 0, ruleSortedKeys_1 = ruleSortedKeys; _b < ruleSortedKeys_1.length; _b++) {
-        var ruleKey = ruleSortedKeys_1[_b];
-        var _c = rules[ruleKey], before = _c.before, after = _c.after, breaks = _c.breaks;
-        if (before) {
-          if (!before.test(stringBeforeBreak)) {
-            continue;
+      Segmenter2.prototype.breaksAt = function(position, input) {
+        var _a;
+        var ruleSortedKeys = this.ruleSortedKeys;
+        var rules = this.rules;
+        var mergedSegmentationTypeValue = this.mergedSegmentationTypeValue;
+        if (position === 0) {
+          return breaksAtResult(true, "0.2");
+        }
+        if (position === input.length) {
+          return breaksAtResult(true, "0.3");
+        }
+        if (isSurrogate(input, position)) {
+          return breaksAtResult(false, "0.1");
+        }
+        var stringBeforeBreak = input.substring(0, position);
+        var stringAfterBreak = input.substring(position);
+        if ("suppressions" in mergedSegmentationTypeValue) {
+          for (var _i = 0, _b = mergedSegmentationTypeValue.suppressions; _i < _b.length; _i++) {
+            var suppressions = _b[_i];
+            if (stringBeforeBreak.trim().endsWith(suppressions)) {
+              return breaksAtResult(false, "0.4");
+            }
           }
         }
-        if (after) {
-          if (!after.test(stringAfterBreak)) {
-            continue;
+        for (var _c = 0, ruleSortedKeys_1 = ruleSortedKeys; _c < ruleSortedKeys_1.length; _c++) {
+          var ruleKey = ruleSortedKeys_1[_c];
+          var before = (_a = rules[ruleKey], _a.before), after = _a.after, breaks = _a.breaks;
+          if (before) {
+            if (!before.test(stringBeforeBreak)) {
+              continue;
+            }
+          }
+          if (after) {
+            if (!after.test(stringAfterBreak)) {
+              continue;
+            }
           }
+          return breaksAtResult(breaks, ruleKey);
         }
-        return breaksAtResult(breaks, ruleKey);
-      }
-      return breaksAtResult(true, "999");
-    };
-    Segmenter2.prototype.segment = function(input) {
-      checkReceiver(this, "segment");
-      return new SegmentIterator(this, input);
-    };
-    Segmenter2.prototype.resolvedOptions = function() {
-      checkReceiver(this, "resolvedOptions");
-      return __assign({}, getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, "locale", "granularity"));
-    };
-    Segmenter2.supportedLocalesOf = function(locales, options) {
-      return SupportedLocales(Segmenter2.availableLocales, CanonicalizeLocaleList(locales), options);
-    };
-    Segmenter2.availableLocales = new Set(Object.keys(SegmentationRules).filter(function(key) {
-      return key !== "root";
-    }));
-    Segmenter2.polyfilled = true;
-    return Segmenter2;
-  }();
+        return breaksAtResult(true, "999");
+      };
+      Segmenter2.prototype.segment = function(input) {
+        checkReceiver(this, "segment");
+        return new SegmentIterator(this, input);
+      };
+      Segmenter2.prototype.resolvedOptions = function() {
+        checkReceiver(this, "resolvedOptions");
+        return __assign({}, getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, "locale", "granularity"));
+      };
+      Segmenter2.supportedLocalesOf = function(locales, options) {
+        return SupportedLocales(Segmenter2.availableLocales, CanonicalizeLocaleList(locales), options);
+      };
+      Segmenter2.availableLocales = new Set(Object.keys(SegmentationRules).filter(function(key) {
+        return key !== "root";
+      }));
+      Segmenter2.polyfilled = true;
+      return Segmenter2;
+    }()
+  );
   var createSegmentDataObject = function(segmenter, segment, index, input, matchingRule) {
     var returnValue = {
       segment,
@@ -2295,70 +1857,73 @@
     }
     return returnValue;
   };
-  var SegmentIterator = function() {
-    function SegmentIterator2(segmenter, input) {
-      this.segmenter = segmenter;
-      this.lastSegmentIndex = 0;
-      if (typeof input == "symbol") {
-        throw TypeError("Input must not be a symbol");
-      }
-      this.input = String(input);
-    }
-    SegmentIterator2.prototype[Symbol.iterator] = function() {
-      return new SegmentIterator2(this.segmenter, this.input);
-    };
-    SegmentIterator2.prototype.next = function() {
-      var checkString = this.input.substring(this.lastSegmentIndex);
-      for (var position = 1; position <= checkString.length; position++) {
-        var _a = this.segmenter.breaksAt(position, checkString), breaks = _a.breaks, matchingRule = _a.matchingRule;
-        if (breaks) {
-          var segment = checkString.substring(0, position);
-          var index = this.lastSegmentIndex;
-          this.lastSegmentIndex += position;
-          return {
-            done: false,
-            value: createSegmentDataObject(this.segmenter, segment, index, this.input, matchingRule)
-          };
+  var SegmentIterator = (
+    /** @class */
+    function() {
+      function SegmentIterator2(segmenter, input) {
+        this.segmenter = segmenter;
+        this.lastSegmentIndex = 0;
+        if (typeof input == "symbol") {
+          throw TypeError("Input must not be a symbol");
         }
+        this.input = String(input);
       }
-      return { done: true, value: void 0 };
-    };
-    SegmentIterator2.prototype.containing = function(positionInput) {
-      if (typeof positionInput === "bigint") {
-        throw TypeError("Index must not be a BigInt");
-      }
-      var position = Number(positionInput);
-      if (isNaN(position) || !position) {
-        position = 0;
-      }
-      position = Math.floor(Math.abs(position)) * (position < 0 ? -1 : 1);
-      if (position < 0 || position >= this.input.length) {
-        return void 0;
-      }
-      var previousBreakPoint = 0;
-      if (position === 0) {
-        previousBreakPoint = 0;
-      } else {
-        var checkString_1 = this.input;
-        for (var cursor = position; cursor >= 0; cursor--) {
-          var breaks = this.segmenter.breaksAt(cursor, checkString_1).breaks;
+      SegmentIterator2.prototype[Symbol.iterator] = function() {
+        return new SegmentIterator2(this.segmenter, this.input);
+      };
+      SegmentIterator2.prototype.next = function() {
+        var checkString = this.input.substring(this.lastSegmentIndex);
+        for (var position = 1; position <= checkString.length; position++) {
+          var _a = this.segmenter.breaksAt(position, checkString), breaks = _a.breaks, matchingRule = _a.matchingRule;
           if (breaks) {
-            previousBreakPoint = cursor;
-            break;
+            var segment = checkString.substring(0, position);
+            var index = this.lastSegmentIndex;
+            this.lastSegmentIndex += position;
+            return {
+              done: false,
+              value: createSegmentDataObject(this.segmenter, segment, index, this.input, matchingRule)
+            };
           }
         }
-      }
-      var checkString = this.input.substring(previousBreakPoint);
-      for (var cursor = 1; cursor <= checkString.length; cursor++) {
-        var _a = this.segmenter.breaksAt(cursor, checkString), breaks = _a.breaks, matchingRule = _a.matchingRule;
-        if (breaks) {
-          var segment = checkString.substring(0, cursor);
-          return createSegmentDataObject(this.segmenter, segment, previousBreakPoint, this.input, matchingRule);
+        return { done: true, value: void 0 };
+      };
+      SegmentIterator2.prototype.containing = function(positionInput) {
+        if (typeof positionInput === "bigint") {
+          throw TypeError("Index must not be a BigInt");
         }
-      }
-    };
-    return SegmentIterator2;
-  }();
+        var position = Number(positionInput);
+        if (isNaN(position) || !position) {
+          position = 0;
+        }
+        position = Math.floor(Math.abs(position)) * (position < 0 ? -1 : 1);
+        if (position < 0 || position >= this.input.length) {
+          return void 0;
+        }
+        var previousBreakPoint = 0;
+        if (position === 0) {
+          previousBreakPoint = 0;
+        } else {
+          var checkString_1 = this.input;
+          for (var cursor = position; cursor >= 0; cursor--) {
+            var breaks = this.segmenter.breaksAt(cursor, checkString_1).breaks;
+            if (breaks) {
+              previousBreakPoint = cursor;
+              break;
+            }
+          }
+        }
+        var checkString = this.input.substring(previousBreakPoint);
+        for (var cursor = 1; cursor <= checkString.length; cursor++) {
+          var _a = this.segmenter.breaksAt(cursor, checkString), breaks = _a.breaks, matchingRule = _a.matchingRule;
+          if (breaks) {
+            var segment = checkString.substring(0, cursor);
+            return createSegmentDataObject(this.segmenter, segment, previousBreakPoint, this.input, matchingRule);
+          }
+        }
+      };
+      return SegmentIterator2;
+    }()
+  );
   var __INTERNAL_SLOT_MAP__ = /* @__PURE__ */ new WeakMap();
   function getSlot(instance, key) {
     return getInternalSlot(__INTERNAL_SLOT_MAP__, instance, key);

package/src/cldr-segmentation-rules.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cldr-segmentation-rules.generated.d.ts","sourceRoot":"","sources":["cldr-segmentation-rules.generated.ts"],"names":[],"mappings":"AAEI,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8uCjC,CAAA"}
+{"version":3,"file":"cldr-segmentation-rules.generated.d.ts","sourceRoot":"","sources":["../src/cldr-segmentation-rules.generated.ts"],"names":[],"mappings":"AAEI,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8uCjC,CAAA"}

package/src/segmentation-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segmentation-utils.d.ts","sourceRoot":"","sources":["segmentation-utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cAChB,OAAO,MAAM,EAAE,MAAM,CAAC,SAC1B,MAAM,WASd,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,MAAM,OAAO,MAAM,YAOnD,CAAA"}
+{"version":3,"file":"segmentation-utils.d.ts","sourceRoot":"","sources":["../src/segmentation-utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cAChB,OAAO,MAAM,EAAE,MAAM,CAAC,SAC1B,MAAM,WASd,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,MAAM,OAAO,MAAM,YAOnD,CAAA"}

package/src/segmenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["segmenter.ts"],"names":[],"mappings":"AA+BA,KAAK,aAAa,GACd;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,GACrE,SAAS,CAAA;AAEb,MAAM,WAAW,gBAAgB;IAC/B,aAAa,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAA;CAC/C;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAA;CAC1D;AAoDD,QAAA,MAAM,cAAc,WAAY,OAAO,gBAAgB,MAAM;;;CAG3D,CAAA;AAEF,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAA;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAA;IAC/B,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAyB;gBAGnE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,OAAO,EAAE,gBAAgB;IA0EpB,QAAQ,CACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,UAAU,CAAC,OAAO,cAAc,CAAC;IA6DpC,OAAO,CAAC,KAAK,EAAE,MAAM;IAKrB,eAAe,IAAI,wBAAwB;IAY3C,MAAM,CAAC,gBAAgB,cAEtB;IACD,MAAM,CAAC,kBAAkB,CACvB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAC3B,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,eAAe,CAAC,GAChD,MAAM,EAAE;IAOX,gBAAuB,UAAU,QAAO;CACzC;AAwBD,cAAM,eACJ,YAAW,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAA;IAC1B,OAAO,CAAC,gBAAgB,CAAA;IACxB,OAAO,CAAC,KAAK,CAAA;gBACD,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM;IAS/C,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIjB,IAAI;;;;;;;;;;;;IA+BJ,UAAU,CAAC,aAAa,EAAE,MAAM;;;;;;CAqDjC;AAED,YAAY,EAAC,eAAe,EAAC,CAAA"}
+{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["../src/segmenter.ts"],"names":[],"mappings":"AA+BA,KAAK,aAAa,GACd;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,GACrE,SAAS,CAAA;AAEb,MAAM,WAAW,gBAAgB;IAC/B,aAAa,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAA;CAC/C;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAA;CAC1D;AAoDD,QAAA,MAAM,cAAc,WAAY,OAAO,gBAAgB,MAAM;;;CAG3D,CAAA;AAEF,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAA;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAA;IAC/B,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAyB;gBAGnE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,OAAO,EAAE,gBAAgB;IA0EpB,QAAQ,CACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,UAAU,CAAC,OAAO,cAAc,CAAC;IA6DpC,OAAO,CAAC,KAAK,EAAE,MAAM;IAKrB,eAAe,IAAI,wBAAwB;IAY3C,MAAM,CAAC,gBAAgB,cAEtB;IACD,MAAM,CAAC,kBAAkB,CACvB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAC3B,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,eAAe,CAAC,GAChD,MAAM,EAAE;IAOX,gBAAuB,UAAU,QAAO;CACzC;AAwBD,cAAM,eACJ,YAAW,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAA;IAC1B,OAAO,CAAC,gBAAgB,CAAA;IACxB,OAAO,CAAC,KAAK,CAAA;gBACD,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM;IAS/C,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIjB,IAAI;;;;;;;;;;;;IA+BJ,UAAU,CAAC,aAAa,EAAE,MAAM;;;;;;CAqDjC;AAED,YAAY,EAAC,eAAe,EAAC,CAAA"}

package/src/segmenter.js

@@ -41,7 +41,7 @@ var breaksAtResult = function (breaks, matchingRule) { return ({
     breaks: breaks,
     matchingRule: matchingRule,
 }); };
-var Segmenter = /** @class */ (function () {
+var Segmenter = exports.Segmenter = /** @class */ (function () {
     function Segmenter(locales, options) {
         var _newTarget = this.constructor;
         if (_newTarget === undefined) {
@@ -78,6 +78,7 @@ var Segmenter = /** @class */ (function () {
         this.ruleSortedKeys = Object.keys(this.rules).sort(function (a, b) { return Number(a) - Number(b); });
     }
     Segmenter.prototype.breaksAt = function (position, input) {
+        var _a;
         var ruleSortedKeys = this.ruleSortedKeys;
         var rules = this.rules;
         var mergedSegmentationTypeValue = this.mergedSegmentationTypeValue;
@@ -98,17 +99,17 @@ var Segmenter = /** @class */ (function () {
         var stringAfterBreak = input.substring(position);
         //artificial rule 0.4: handle suppressions
         if ('suppressions' in mergedSegmentationTypeValue) {
-            for (var _i = 0, _a = mergedSegmentationTypeValue.suppressions; _i < _a.length; _i++) {
-                var suppressions = _a[_i];
+            for (var _i = 0, _b = mergedSegmentationTypeValue.suppressions; _i < _b.length; _i++) {
+                var suppressions = _b[_i];
                 if (stringBeforeBreak.trim().endsWith(suppressions)) {
                     return breaksAtResult(false, '0.4');
                 }
             }
         }
         // loop through rules and find a match
-        for (var _b = 0, ruleSortedKeys_1 = ruleSortedKeys; _b < ruleSortedKeys_1.length; _b++) {
-            var ruleKey = ruleSortedKeys_1[_b];
-            var _c = rules[ruleKey], before = _c.before, after = _c.after, breaks = _c.breaks;
+        for (var _c = 0, ruleSortedKeys_1 = ruleSortedKeys; _c < ruleSortedKeys_1.length; _c++) {
+            var ruleKey = ruleSortedKeys_1[_c];
+            var before = (_a = rules[ruleKey], _a.before), after = _a.after, breaks = _a.breaks;
             // for debugging
             // if (ruleKey === '16' && position === 4) {
             //   console.log({before, after, stringBeforeBreak, stringAfterBreak})
@@ -145,7 +146,6 @@ var Segmenter = /** @class */ (function () {
     Segmenter.polyfilled = true;
     return Segmenter;
 }());
-exports.Segmenter = Segmenter;
 var createSegmentDataObject = function (segmenter, segment, index, input, matchingRule) {
     var returnValue = {
         segment: segment,