jscrewit 2.32.0 → 2.34.0

package/lib/jscrewit.js

@@ -1,4 +1,4 @@
-// JScrewIt 2.32.0 – https://jscrew.it
+// JScrewIt 2.34.0 – https://jscrew.it
 
 (function () {
     'use strict';
@@ -310,18 +310,12 @@
         return unionMask;
     }
 
-    var keyFor = function (mask) { return "_" + mask; };
+    var keyFor = function (mask) { return "_".concat(mask); };
     var MaskIndex = /** @class */ (function () {
         function MaskIndex() {
             this._index = Object.create(null);
             this._size = 0;
         }
-        /** Determines whether the current collection contains an entry for a specified mask. */
-        MaskIndex.prototype.has = function (mask) {
-            var key = keyFor(mask);
-            var returnValue = key in this._index;
-            return returnValue;
-        };
         Object.defineProperty(MaskIndex.prototype, "size", {
             /* The number of entries in the current collection. */
             get: function () {
@@ -330,6 +324,12 @@
             enumerable: false,
             configurable: true
         });
+        /** Determines whether the current collection contains an entry for a specified mask. */
+        MaskIndex.prototype.has = function (mask) {
+            var key = keyFor(mask);
+            var returnValue = key in this._index;
+            return returnValue;
+        };
         MaskIndex.prototype._setEntry = function (mask, value) {
             var key = keyFor(mask);
             var _index = this._index;
@@ -394,10 +394,12 @@
             _Object_defineProperty(target, name_1, descriptor);
         }
     }
-    function createFeatureClass(featureInfos) {
+    function createFeatureClass(featureInfos, formatEngineDescription) {
         var ALL = createMap();
         var DESCRIPTION_MAP = createMap();
         var ELEMENTARY = [];
+        var ENGINE = [];
+        var FAMILIES = createMap();
         var FEATURE_PROTOTYPE = Feature.prototype;
         var INCOMPATIBLE_MASK_LIST = [];
         var PRISTINE_ELEMENTARY;
@@ -487,14 +489,9 @@
                 featureObj = null;
             return featureObj;
         }
-        function createFeature(name, mask, check, engine, attributes, elementary) {
+        function createFeature(name, mask, check, attributes, elementary) {
             _Object_freeze(attributes);
-            var descriptors = {
-                attributes: { value: attributes },
-                check: { value: check },
-                engine: { value: engine },
-                name: { value: name },
-            };
+            var descriptors = { attributes: { value: attributes }, check: { value: check }, name: { value: name } };
             if (elementary)
                 descriptors.elementary = { value: true };
             var featureObj = _Object_create(FEATURE_PROTOTYPE, descriptors);
@@ -546,14 +543,9 @@
             if (this.check)
                 parts.push('(check)');
             {
-                var container = {};
-                var _c = this, attributes = _c.attributes, engine = _c.engine;
-                if (engine !== undefined)
-                    container.engine = engine;
-                if (attributes !== undefined)
-                    container.attributes = __assign({}, attributes);
-                if (_Object_keys(container).length) {
-                    var str_1 = utilInspect(container, opts);
+                var attributes = this.attributes;
+                if (typeof attributes === 'object') {
+                    var str_1 = utilInspect(__assign({}, attributes), opts);
                     parts.push(str_1);
                 }
             }
@@ -642,8 +634,8 @@
                 name: undefined,
                 toString: function () {
                     var _a;
-                    var name = (_a = this.name) !== null && _a !== void 0 ? _a : "<" + this.canonicalNames.join(', ') + ">";
-                    var str = "[Feature " + name + "]";
+                    var name = (_a = this.name) !== null && _a !== void 0 ? _a : "<".concat(this.canonicalNames.join(', '), ">");
+                    var str = "[Feature ".concat(name, "]");
                     return str;
                 },
             };
@@ -652,6 +644,9 @@
             assignNoEnum(FEATURE_PROTOTYPE, protoSource);
         }
         (function () {
+            var compareFeatureNames = function (feature1, feature2) {
+                return feature1.name < feature2.name ? -1 : 1;
+            };
             function completeExclusions() {
                 var incompatibleMaskSet = new MaskSet();
                 for (var _i = 0, featureNames_1 = featureNames; _i < featureNames_1.length; _i++) {
@@ -695,6 +690,7 @@
                         if (inherits != null)
                             completeFeature(inherits);
                         var wrappedCheck = void 0;
+                        var compatibilities = void 0;
                         var check = info_1.check;
                         if (check !== undefined) {
                             mask = maskNext(unionMask);
@@ -736,7 +732,37 @@
                                 mask = maskUnion(mask, includeMask);
                             }
                         }
-                        var engine = getInfoStringField('engine');
+                        if ('versions' in info_1) {
+                            var families = info_1.families;
+                            var versions_1 = info_1.versions;
+                            if (inherits != null)
+                                families !== null && families !== void 0 ? families : (families = familiesMap[inherits]);
+                            familiesMap[name] = families;
+                            var tag_1 = getInfoStringField('compatibilityTag');
+                            var shortTag_1 = getInfoStringField('compatibilityShortTag');
+                            compatibilities =
+                                families.map(function (family, index) {
+                                    var _a;
+                                    family = esToString(family);
+                                    var versionInfo = versions_1[index];
+                                    var version;
+                                    if (_Array_isArray(versionInfo)) {
+                                        var length_1 = versionInfo.length;
+                                        var from = esToString(versionInfo[0]);
+                                        var to = length_1 < 2 ? undefined : esToString(versionInfo[length_1 - 1]);
+                                        var dense = versionInfo.length === 2;
+                                        version = _Object_freeze({ from: from, to: to, dense: dense });
+                                    }
+                                    else
+                                        version = esToString(versionInfo);
+                                    var compatibility = _Object_freeze({ family: family, featureName: name, version: version, tag: tag_1, shortTag: shortTag_1 });
+                                    var familyCompatibilities = (_a = FAMILIES[family]) !== null && _a !== void 0 ? _a : (FAMILIES[family] = []);
+                                    familyCompatibilities.push(compatibility);
+                                    return compatibility;
+                                });
+                            if (description == null)
+                                description = formatEngineDescription === null || formatEngineDescription === void 0 ? void 0 : formatEngineDescription(compatibilities);
+                        }
                         var attributes = createMap();
                         if (inherits != null) {
                             var inheritedAttributes = ALL[inherits].attributes;
@@ -760,10 +786,11 @@
                             }
                         }
                         var elementary = wrappedCheck !== null && wrappedCheck !== void 0 ? wrappedCheck : info_1.excludes;
-                        featureObj =
-                            createFeature(name, mask, wrappedCheck, engine, attributes, elementary);
+                        featureObj = createFeature(name, mask, wrappedCheck, attributes, elementary);
                         if (elementary)
                             ELEMENTARY.push(featureObj);
+                        if (compatibilities)
+                            ENGINE.push(featureObj);
                     }
                     ALL[name] = featureObj;
                     DESCRIPTION_MAP[name] = description;
@@ -774,6 +801,8 @@
                 var constructorSource = {
                     ALL: ALL,
                     ELEMENTARY: ELEMENTARY,
+                    ENGINE: ENGINE,
+                    FAMILIES: FAMILIES,
                     _fromMask: _fromMask,
                     _getMask: _getMask,
                     areCompatible: areCompatible,
@@ -791,13 +820,19 @@
             }
             var featureNames = _Object_keys(featureInfos);
             var includeSetMap = createMap();
+            var familiesMap = createMap();
             var unionMask = maskNew();
             featureNames.forEach(completeFeature);
             completeExclusions();
             PRISTINE_ELEMENTARY = ELEMENTARY.slice();
-            ELEMENTARY.sort(function (feature1, feature2) { return feature1.name < feature2.name ? -1 : 1; });
+            ELEMENTARY.sort(compareFeatureNames);
             _Object_freeze(ELEMENTARY);
+            ENGINE.sort(compareFeatureNames);
+            _Object_freeze(ENGINE);
             _Object_freeze(ALL);
+            _Object_freeze(FAMILIES);
+            for (var family in FAMILIES)
+                _Object_freeze(FAMILIES[family]);
         })();
         return Feature;
     }
@@ -836,12 +871,12 @@
             return false;
         }
         var str = parts.length && (!compact || isMultiline()) ?
-            intro + "\n" + indent(parts.join(partSeparator + "\n")) + "\n" + outro :
-            "" + intro + preSeparator + parts.join(partSeparator + " ") + outro;
+            "".concat(intro, "\n").concat(indent(parts.join("".concat(partSeparator, "\n"))), "\n").concat(outro) :
+            "".concat(intro).concat(preSeparator).concat(parts.join("".concat(partSeparator, " "))).concat(outro);
         return str;
     }
     function throwUnknownFeatureError(name) {
-        throw new _Error("Unknown feature " + _JSON_stringify(name));
+        throw new _Error("Unknown feature ".concat(_JSON_stringify(name)));
     }
     function wrapCheck(check) {
         var wrappedCheck = function () { return !!check(); };
@@ -875,6 +910,12 @@
         return available;
     }
 
+    function describeEngine(engine)
+    {
+        var description = 'Features available in ' + engine + '.';
+        return description;
+    }
+
     function isExcludingAttribute(restrictionCache, restrictionName, featureObjs)
     {
         var returnValue = restrictionCache[restrictionName];
@@ -1681,6 +1722,7 @@
             includes:
             [
                 'ARROW',
+                'AT',
                 'ATOB',
                 'BARPROP',
                 'ESC_HTML_QUOT_ONLY',
@@ -1710,7 +1752,8 @@
         },
         ANDRO_4_0:
         {
-            engine: 'Android Browser 4.0',
+            families: ['Android Browser'],
+            versions: ['4.0'],
             includes:
             [
                 'ATOB',
@@ -1730,14 +1773,14 @@
         },
         ANDRO_4_1:
         {
-            engine: 'Android Browser 4.1 to 4.3',
             inherits: 'ANDRO_4_0',
+            versions: [['4.1',, '4.3']],
             includes: { GENERIC_ARRAY_TO_STRING: true, OBJECT_UNDEFINED: true },
         },
         ANDRO_4_4:
         {
-            engine: 'Android Browser 4.4',
             inherits: 'ANDRO_4_1',
+            versions: ['4.4'],
             includes:
             {
                 BARPROP:                true,
@@ -1753,17 +1796,18 @@
         },
         CHROME_PREV:
         {
-            engine: 'the previous to current versions of Chrome and Edge',
+            description: describeEngine('the previous to current versions of Chrome and Edge'),
             aliasFor: 'CHROME_92',
         },
         CHROME:
         {
-            engine: 'the current stable versions of Chrome, Edge and Opera',
+            description: describeEngine('the current stable versions of Chrome, Edge and Opera'),
             aliasFor: 'CHROME_92',
         },
         CHROME_92:
         {
-            engine: 'Chrome 92, Edge 92 and Opera 78 or later',
+            families: ['Chrome', 'Edge', 'Opera'],
+            versions: [['92'], ['92'], ['78']],
             includes:
             [
                 'ARROW',
@@ -1799,15 +1843,27 @@
         },
         FF_ESR:
         {
-            engine: 'the current version of Firefox ESR',
-            aliasFor: 'FF_78',
+            description: describeEngine('the current version of Firefox ESR'),
+            aliasFor: 'FF_90',
         },
-        FF_78:
+        FF_PREV:
         {
-            engine: 'Firefox 78 to 82',
+            description: describeEngine('the previous to current version of Firefox'),
+            aliasFor: 'FF_90',
+        },
+        FF:
+        {
+            description: describeEngine('the current stable version of Firefox'),
+            aliasFor: 'FF_90',
+        },
+        FF_90:
+        {
+            families: ['Firefox'],
+            versions: [['90']],
             includes:
             [
                 'ARROW',
+                'AT',
                 'ATOB',
                 'BARPROP',
                 'ESC_HTML_QUOT_ONLY',
@@ -1824,12 +1880,12 @@
                 'HISTORY',
                 'HTMLDOCUMENT',
                 'INCR_CHAR',
+                'INTL',
                 'LOCALE_INFINITY',
                 'LOCALE_NUMERALS_EXT',
                 'LOCATION',
                 'NAME',
                 'NO_OLD_SAFARI_ARRAY_ITERATOR',
-                'PLAIN_INTL',
                 'REGEXP_STRING_ITERATOR',
                 'SHORT_LOCALES',
                 'STATUS',
@@ -1838,31 +1894,10 @@
             attributes:
             { 'char-increment-restriction': null, 'unstable': null, 'web-worker-restriction': null },
         },
-        FF_PREV:
-        {
-            engine: 'the previous to current version of Firefox',
-            aliasFor: 'FF_83',
-        },
-        FF_83:
-        {
-            engine: 'Firefox 83 to 89',
-            inherits: 'FF_78',
-            includes: { INTL: true, PLAIN_INTL: false },
-        },
-        FF:
-        {
-            engine: 'the current stable version of Firefox',
-            aliasFor: 'FF_90',
-        },
-        FF_90:
-        {
-            engine: 'Firefox 90 or later',
-            inherits: 'FF_83',
-            includes: { AT: true },
-        },
         IE_9:
         {
-            engine: 'Internet Explorer 9',
+            families: ['Internet Explorer'],
+            versions: ['9'],
             includes:
             [
                 'CAPITAL_HTML',
@@ -1883,15 +1918,15 @@
         },
         IE_10:
         {
-            engine: 'Internet Explorer 10',
             inherits: 'IE_9',
+            versions: ['10'],
             includes: { ATOB: true, CONSOLE: true, OBJECT_UNDEFINED: true, UNDEFINED: false },
             attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
         },
         IE_11:
         {
-            engine: 'Internet Explorer 11',
             inherits: 'IE_10',
+            versions: ['11'],
             includes:
             {
                 DOCUMENT:           false,
@@ -1904,13 +1939,16 @@
         },
         IE_11_WIN_10:
         {
-            engine: 'Internet Explorer 11 on Windows 10',
             inherits: 'IE_11',
+            versions: ['11'],
+            compatibilityTag: 'on Windows 10',
+            compatibilityShortTag: 'W10',
             includes: { LOCALE_INFINITY: true, LOCALE_NUMERALS: false, LOCALE_NUMERALS_EXT: true },
         },
         NODE_0_10:
         {
-            engine: 'Node.js 0.10',
+            families: ['Node.js'],
+            versions: ['0.10'],
             includes:
             [
                 'ESC_HTML_ALL',
@@ -1925,8 +1963,8 @@
         },
         NODE_0_12:
         {
-            engine: 'Node.js 0.12',
             inherits: 'NODE_0_10',
+            versions: ['0.12'],
             includes:
             {
                 ESC_HTML_ALL:                   false,
@@ -1938,61 +1976,62 @@
         },
         NODE_4:
         {
-            engine: 'Node.js 4',
             inherits: 'NODE_0_12',
+            versions: ['4'],
             includes: { ARROW: true, ESC_REGEXP_SLASH: true, FILL: true, FROM_CODE_POINT: true },
         },
         NODE_5:
         {
-            engine: 'Node.js 5 to 9',
             inherits: 'NODE_4',
+            versions: [['5',, '9']],
             attributes: { 'char-increment-restriction': null },
         },
         NODE_10:
         {
-            engine: 'Node.js 10',
             inherits: 'NODE_5',
+            versions: ['10'],
             includes: { FUNCTION_19_LF: true, FUNCTION_22_LF: false },
         },
         NODE_11:
         {
-            engine: 'Node.js 11',
             inherits: 'NODE_10',
+            versions: ['11'],
             includes: { FLAT: true },
         },
         NODE_12:
         {
-            engine: 'Node.js 12',
             inherits: 'NODE_11',
+            versions: ['12'],
             includes: { ESC_REGEXP_LF: true, REGEXP_STRING_ITERATOR: true },
         },
         NODE_13:
         {
-            engine: 'Node.js 13 and Node.js 14',
             inherits: 'NODE_12',
+            versions: [['13', '14']],
             includes: { LOCALE_NUMERALS_EXT: true, SHORT_LOCALES: true },
         },
         NODE_15:
         {
-            engine: 'Node.js 15',
             inherits: 'NODE_13',
+            versions: ['15'],
             includes: { INTL: true, PLAIN_INTL: false },
         },
         NODE_16_0:
         {
-            engine: 'Node.js 16.0 to 16.5',
             inherits: 'NODE_15',
+            versions: [['16.0',, '16.5']],
             includes: { ATOB: true },
         },
         NODE_16_6:
         {
-            engine: 'Node.js 16.6 or later',
             inherits: 'NODE_16_0',
+            versions: [['16.6']],
             includes: { AT: true },
         },
         SAFARI_7_0:
         {
-            engine: 'Safari 7.0',
+            families: ['Safari'],
+            versions: ['7.0'],
             includes:
             [
                 'ATOB',
@@ -2027,16 +2066,15 @@
         },
         SAFARI_7_1:
         {
-            engine: 'Safari 7.1 and Safari 8',
             inherits: 'SAFARI_7_0',
+            versions: [['7.1', '8']],
             includes: { ARRAY_ITERATOR: true, FILL: true },
             attributes: { 'no-console-in-web-worker': undefined, 'safari-bug-21820506': null },
         },
-        SAFARI_8: { aliasFor: 'SAFARI_7_1' },
         SAFARI_9:
         {
-            engine: 'Safari 9',
             inherits: 'SAFARI_7_1',
+            versions: ['9'],
             includes:
             {
                 ARRAY_ITERATOR:                 false,
@@ -2047,8 +2085,8 @@
         },
         SAFARI_10:
         {
-            engine: 'Safari 10 and Safari 11',
             inherits: 'SAFARI_9',
+            versions: [['10', '11']],
             includes:
             {
                 ARROW:                      true,
@@ -2065,36 +2103,76 @@
         },
         SAFARI_12:
         {
-            engine: 'Safari 12',
             inherits: 'SAFARI_10',
+            versions: ['12'],
             includes: { FLAT: true },
         },
         SAFARI_13:
         {
-            engine: 'Safari 13 and Safari 14.0.0',
             inherits: 'SAFARI_12',
+            versions: [['13', '14.0.0']],
             includes: { REGEXP_STRING_ITERATOR: true },
         },
         SAFARI_14_0_1:
         {
-            engine: 'Safari 14.0.1 to 14.0.3',
             inherits: 'SAFARI_13',
+            versions: [['14.0.1',, '14.0.3']],
             includes: { INTL: true, PLAIN_INTL: false },
         },
-        SAFARI:
-        {
-            engine: 'the current stable version of Safari',
-            aliasFor: 'SAFARI_14_1',
-        },
         SAFARI_14_1:
         {
-            engine: 'Safari 14.1 or later',
             inherits: 'SAFARI_14_0_1',
+            versions: [['14.1',, '15.3']],
             includes: { CONSOLE: false },
         },
+        SAFARI:
+        {
+            description: describeEngine('the current stable version of Safari'),
+            aliasFor: 'SAFARI_15_4',
+        },
+        SAFARI_15_4:
+        {
+            inherits: 'SAFARI_14_1',
+            versions: [['15.4']],
+            includes: { AT: true },
+        },
     };
     (function ()
     {
+        function formatEngineDescription(compatibilities)
+        {
+            var appendix = '';
+            var parts =
+            compatibilities.map
+            (
+                function (compatibility)
+                {
+                    var family = compatibility.family;
+                    var version = compatibility.version;
+                    var part = family;
+                    if (typeof version === 'string')
+                        part += ' ' + version;
+                    else
+                    {
+                        part += ' ' + version.from;
+                        var to = version.to;
+                        if (to != null)
+                            part += (version.dense ? ' and ' + family + ' ' : ' to ') + to;
+                        else
+                            appendix = ' or later';
+                    }
+                    var tag = compatibility.tag;
+                    if (tag != null)
+                        part += ' ' + tag;
+                    return part;
+                }
+            );
+            var lastPart = parts.pop();
+            var engine = (parts.length ? parts.join(', ') + ' and ' + lastPart : lastPart) + appendix;
+            var description = describeEngine(engine);
+            return description;
+        }
+
         var autoIncludes =
         _Object_keys$1(featureInfos).filter
         (
@@ -2108,23 +2186,10 @@
         );
         featureInfos.AUTO =
         {
-            engine: 'the current environment',
+            description: describeEngine('the current environment'),
             includes: autoIncludes,
         };
-        _Object_keys$1(featureInfos).forEach
-        (
-            function (featureName)
-            {
-                var featureInfo = featureInfos[featureName];
-                var engine = featureInfo.engine;
-                if (engine != null)
-                {
-                    var description = 'Features available in ' + engine + '.';
-                    featureInfo.description = description;
-                }
-            }
-        );
-        Feature = createFeatureClass(featureInfos);
+        Feature = createFeatureClass(featureInfos, formatEngineDescription);
         ELEMENTARY = Feature.ELEMENTARY;
         featureInfos = null;
         assignNoEnum$1(Feature.prototype, { restrict: restrict });
@@ -2255,13 +2320,13 @@
     function evalExpr$1(expr) {
         var value = tryEvalExpr(expr);
         if (value === INVALID_EXPR)
-            throw SyntaxError("Invalid expression " + expr);
+            throw SyntaxError("Invalid expression ".concat(expr));
         return value;
     }
     function tryEvalExpr(expr) {
         var fn;
         try {
-            fn = Function("return(" + expr + ");");
+            fn = Function("return(".concat(expr, ");"));
         }
         catch (_a) {
             return INVALID_EXPR;
@@ -2310,9 +2375,9 @@
                 }
         }
     };
-    var isCombined = function (replacement, value) { return !value !== tryEvalExpr("!" + replacement); };
-    var isPrefixed = function (replacement, value) { return "0" + value !== tryEvalExpr("0+" + replacement); };
-    var isWeak$1 = function (replacement, value) { return "" + value !== tryEvalExpr("\"\"+" + replacement); };
+    var isCombined = function (replacement, value) { return !value !== tryEvalExpr("!".concat(replacement)); };
+    var isPrefixed = function (replacement, value) { return "0".concat(value) !== tryEvalExpr("0+".concat(replacement)); };
+    var isWeak$1 = function (replacement, value) { return "".concat(value) !== tryEvalExpr("\"\"+".concat(replacement)); };
 
     function createTypeSet() {
         var types = [];
@@ -2348,7 +2413,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.WEAK_ALGEBRAIC),
             ],
-            replace: function (r1, r2, r3) { return r1 + "+(" + r2 + "+[" + r3 + "])"; },
+            replace: function (r1, r2, r3) { return "".concat(r1, "+(").concat(r2, "+[").concat(r3, "])"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2357,7 +2422,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.WEAK_PREFIXED_STRING),
             ],
-            replace: function (r1, r2, r3) { return r1 + "+(" + r2 + "+(" + r3 + "))"; },
+            replace: function (r1, r2, r3) { return "".concat(r1, "+(").concat(r2, "+(").concat(r3, "))"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2366,7 +2431,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.OBJECT, SolutionType.STRING, SolutionType.COMBINED_STRING),
             ],
-            replace: function (r1, r2, r3) { return r1 + "+(" + r2 + "+" + r3 + ")"; },
+            replace: function (r1, r2, r3) { return "".concat(r1, "+(").concat(r2, "+").concat(r3, ")"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2374,7 +2439,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.UNDEFINED),
             ],
-            replace: function (r1, r2) { return "[]+" + r1 + "+" + r2; },
+            replace: function (r1, r2) { return "[]+".concat(r1, "+").concat(r2); },
             solutionType: SolutionType.COMBINED_STRING,
         },
         {
@@ -2382,7 +2447,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.ALGEBRAIC, SolutionType.WEAK_ALGEBRAIC),
             ],
-            replace: function (r1, r2) { return r1 + "+[" + r2 + "]"; },
+            replace: function (r1, r2) { return "".concat(r1, "+[").concat(r2, "]"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2390,7 +2455,7 @@
                 createTypeSet(SolutionType.UNDEFINED),
                 createTypeSet(SolutionType.PREFIXED_STRING),
             ],
-            replace: function (r1, r2) { return r1 + "+(" + r2 + ")"; },
+            replace: function (r1, r2) { return "".concat(r1, "+(").concat(r2, ")"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2404,7 +2469,7 @@
                 createTypeSet(SolutionType.ALGEBRAIC),
                 createTypeSet(SolutionType.UNDEFINED, SolutionType.ALGEBRAIC, SolutionType.PREFIXED_STRING),
             ],
-            replace: function (r1, r2) { return "[" + r1 + "]+" + r2; },
+            replace: function (r1, r2) { return "[".concat(r1, "]+").concat(r2); },
             solutionType: SolutionType.COMBINED_STRING,
         },
         {
@@ -2412,7 +2477,7 @@
                 createTypeSet(SolutionType.ALGEBRAIC),
                 createTypeSet(SolutionType.WEAK_ALGEBRAIC),
             ],
-            replace: function (r1, r2) { return r1 + "+[" + r2 + "]"; },
+            replace: function (r1, r2) { return "".concat(r1, "+[").concat(r2, "]"); },
             solutionType: SolutionType.PREFIXED_STRING,
         },
         {
@@ -2426,7 +2491,7 @@
                 createTypeSet(SolutionType.WEAK_ALGEBRAIC),
                 createTypeSet(SolutionType.UNDEFINED, SolutionType.ALGEBRAIC, SolutionType.PREFIXED_STRING),
             ],
-            replace: function (r1, r2) { return "[" + r1 + "]+" + r2; },
+            replace: function (r1, r2) { return "[".concat(r1, "]+").concat(r2); },
             solutionType: SolutionType.COMBINED_STRING,
         },
         {
@@ -2434,7 +2499,7 @@
                 createTypeSet(SolutionType.WEAK_ALGEBRAIC),
                 createTypeSet(SolutionType.WEAK_ALGEBRAIC),
             ],
-            replace: function (r1, r2) { return r1 + "+[" + r2 + "]"; },
+            replace: function (r1, r2) { return "".concat(r1, "+[").concat(r2, "]"); },
             solutionType: SolutionType.WEAK_PREFIXED_STRING,
         },
         {
@@ -2507,14 +2572,6 @@
             _this._solutions = [];
             return _this;
         }
-        DynamicSolution.prototype.append = function (solution) {
-            this._replacement = undefined;
-            this._solutions.push(solution);
-        };
-        DynamicSolution.prototype.prepend = function (solution) {
-            this._replacement = undefined;
-            this._solutions.unshift(solution);
-        };
         Object.defineProperty(DynamicSolution.prototype, "replacement", {
             get: function () {
                 var _a;
@@ -2557,6 +2614,14 @@
             enumerable: false,
             configurable: true
         });
+        DynamicSolution.prototype.append = function (solution) {
+            this._replacement = undefined;
+            this._solutions.push(solution);
+        };
+        DynamicSolution.prototype.prepend = function (solution) {
+            this._replacement = undefined;
+            this._solutions.unshift(solution);
+        };
         return DynamicSolution;
     }(AbstractSolution));
     var LazySolution = /** @class */ (function (_super) {
@@ -2578,7 +2643,7 @@
             attributes.enumerable = true;
             Object.defineProperty(this, 'replacement', attributes);
         };
-        return LazySolution;
+        return (LazySolution);
     }(AbstractSolution));
     var SimpleSolution = /** @class */ (function (_super) {
         __extends(SimpleSolution, _super);
@@ -2613,7 +2678,7 @@
     }
     var getAppendableReplacement = function (_a) {
         var replacement = _a.replacement, type = _a.type;
-        return isWeak(type) ? "+(" + replacement + ")" : "+" + replacement;
+        return isWeak(type) ? "+(".concat(replacement, ")") : "+".concat(replacement);
     };
     var getReplacement = function (_a) {
         var replacement = _a.replacement;
@@ -4609,16 +4674,6 @@
     }
     )();
 
-    var APPEND_LENGTH_OF_DIGIT_0     = 6;
-    var APPEND_LENGTH_OF_DOT         = 73;
-    var APPEND_LENGTH_OF_FALSE       = 4;
-    var APPEND_LENGTH_OF_EMPTY       = 3; // Append length of the empty array.
-    var APPEND_LENGTH_OF_MINUS       = 136;
-    var APPEND_LENGTH_OF_PLUS_SIGN   = 71;
-    var APPEND_LENGTH_OF_SMALL_E     = 26;
-
-    var APPEND_LENGTH_OF_DIGITS = [APPEND_LENGTH_OF_DIGIT_0, 8, 12, 17, 22, 27, 32, 37, 42, 47];
-
     // Recognized syntax elements include:
     //
     // • The boolean literals "true" and "false"
@@ -5209,29 +5264,15 @@
 
     var expressParseCached$1 = expressParseCached;
 
-    function findDefinition(entries)
-    {
-        var cacheKey = entries.cacheKey;
-        if (cacheKey === undefined)
-            entries.cacheKey = cacheKey = ++lastCacheKey;
-        var definitionCache = this._definitionCache;
-        if (cacheKey in definitionCache)
-            return definitionCache[cacheKey];
-        var definition;
-        for (var entryIndex = entries.length; entryIndex--;)
-        {
-            var entry = entries[entryIndex];
-            if (this.hasFeatures(entry.mask))
-            {
-                definition = entry.definition;
-                break;
-            }
-        }
-        definitionCache[cacheKey] = definition;
-        return definition;
-    }
+    var APPEND_LENGTH_OF_DIGIT_0     = 6;
+    var APPEND_LENGTH_OF_DOT         = 73;
+    var APPEND_LENGTH_OF_FALSE       = 4;
+    var APPEND_LENGTH_OF_EMPTY       = 3; // Append length of the empty array.
+    var APPEND_LENGTH_OF_MINUS       = 136;
+    var APPEND_LENGTH_OF_PLUS_SIGN   = 71;
+    var APPEND_LENGTH_OF_SMALL_E     = 26;
 
-    var lastCacheKey = 0;
+    var APPEND_LENGTH_OF_DIGITS = [APPEND_LENGTH_OF_DIGIT_0, 8, 12, 17, 22, 27, 32, 37, 42, 47];
 
     var SCREW_NORMAL             = 0;
     var SCREW_AS_STRING          = 1;
@@ -5391,6 +5432,129 @@
         );
     }
 
+    function findDefinition(entries)
+    {
+        var cacheKey = entries.cacheKey;
+        if (cacheKey === undefined)
+            entries.cacheKey = cacheKey = ++lastCacheKey;
+        var definitionCache = this._definitionCache;
+        if (cacheKey in definitionCache)
+            return definitionCache[cacheKey];
+        var definition;
+        for (var entryIndex = entries.length; entryIndex--;)
+        {
+            var entry = entries[entryIndex];
+            if (this.hasFeatures(entry.mask))
+            {
+                definition = entry.definition;
+                break;
+            }
+        }
+        definitionCache[cacheKey] = definition;
+        return definition;
+    }
+
+    var lastCacheKey = 0;
+
+    function evalNumber(preMantissa, lastDigit, exp)
+    {
+        var value = +(preMantissa + lastDigit + 'e' + exp);
+        return value;
+    }
+
+    function formatPositiveNumber(number)
+    {
+        function getMantissa()
+        {
+            var lastDigitIndex = usefulDigits - 1;
+            var preMantissa = digits.slice(0, lastDigitIndex);
+            var lastDigit = +digits[lastDigitIndex];
+            var value = evalNumber(preMantissa, lastDigit, exp);
+            for (;;)
+            {
+                var decreasedLastDigit = lastDigit - 1;
+                var newValue = evalNumber(preMantissa, decreasedLastDigit, exp);
+                if (newValue !== value)
+                    break;
+                lastDigit = decreasedLastDigit;
+            }
+            var mantissa = preMantissa + lastDigit;
+            return mantissa;
+        }
+
+        var str;
+        var match = /^(\d+)(?:\.(\d+))?(?:e(.+))?$/.exec(number);
+        var digitsAfterDot = match[2] || '';
+        var digits = (match[1] + digitsAfterDot).replace(/^0+/, '');
+        var usefulDigits = digits.search(/0*$/);
+        var exp = (match[3] | 0) - digitsAfterDot.length + digits.length - usefulDigits;
+        var mantissa = getMantissa();
+        if (exp >= 0)
+        {
+            if (exp < 10)
+                str = mantissa + extraZeros(exp);
+            else if (exp % 100 === 99 && (exp > 99 || mantissa[1]))
+                str = mantissa.replace(/.$/, '.$&e') + (exp + 1);
+            else
+                str = mantissa + 'e' + exp;
+        }
+        else
+        {
+            if (exp >= -mantissa.length)
+                str = mantissa.slice(0, exp) + '.' + mantissa.slice(exp);
+            else
+            {
+                var extraZeroCount = -mantissa.length - exp;
+                var extraLength = APPEND_LENGTH_OF_DOT + APPEND_LENGTH_OF_DIGIT_0 * extraZeroCount;
+                str =
+                replaceNegativeExponential(mantissa, exp, extraLength) ||
+                '.' + extraZeros(extraZeroCount) + mantissa;
+            }
+        }
+        return str;
+    }
+
+    function getMultiDigitLength(str)
+    {
+        var appendLength = 0;
+        _Array_prototype_forEach_call
+        (
+            str,
+            function (digit)
+            {
+                var digitAppendLength = APPEND_LENGTH_OF_DIGITS[digit];
+                appendLength += digitAppendLength;
+            }
+        );
+        return appendLength;
+    }
+
+    function replaceNegativeExponential(mantissa, exp, rivalExtraLength)
+    {
+        var extraZeroCount;
+        if (exp % 100 > 7 - 100)
+        {
+            if (exp % 10 > -7)
+                extraZeroCount = 0;
+            else
+                extraZeroCount = 10 + exp % 10;
+        }
+        else
+            extraZeroCount = 100 + exp % 100;
+        mantissa += extraZeros(extraZeroCount);
+        exp -= extraZeroCount;
+        var extraLength =
+        APPEND_LENGTH_OF_DIGIT_0 * extraZeroCount +
+        APPEND_LENGTH_OF_SMALL_E +
+        APPEND_LENGTH_OF_MINUS +
+        getMultiDigitLength(_String$1(-exp));
+        if (extraLength < rivalExtraLength)
+        {
+            var str = mantissa + 'e' + exp;
+            return str;
+        }
+    }
+
     function findBase64AlphabetDefinition(encoder, element)
     {
         var definition;
@@ -5608,12 +5772,6 @@
         return solution;
     }
 
-    function evalNumber(preMantissa, lastDigit, exp)
-    {
-        var value = +(preMantissa + lastDigit + 'e' + exp);
-        return value;
-    }
-
     function findOptimalSolution(encoder, source, entries, defaultSolutionType)
     {
         var optimalSolution;
@@ -5637,73 +5795,6 @@
         return optimalSolution;
     }
 
-    function formatPositiveNumber(number)
-    {
-        function getMantissa()
-        {
-            var lastDigitIndex = usefulDigits - 1;
-            var preMantissa = digits.slice(0, lastDigitIndex);
-            var lastDigit = +digits[lastDigitIndex];
-            var value = evalNumber(preMantissa, lastDigit, exp);
-            for (;;)
-            {
-                var decreasedLastDigit = lastDigit - 1;
-                var newValue = evalNumber(preMantissa, decreasedLastDigit, exp);
-                if (newValue !== value)
-                    break;
-                lastDigit = decreasedLastDigit;
-            }
-            var mantissa = preMantissa + lastDigit;
-            return mantissa;
-        }
-
-        var str;
-        var match = /^(\d+)(?:\.(\d+))?(?:e(.+))?$/.exec(number);
-        var digitsAfterDot = match[2] || '';
-        var digits = (match[1] + digitsAfterDot).replace(/^0+/, '');
-        var usefulDigits = digits.search(/0*$/);
-        var exp = (match[3] | 0) - digitsAfterDot.length + digits.length - usefulDigits;
-        var mantissa = getMantissa();
-        if (exp >= 0)
-        {
-            if (exp < 10)
-                str = mantissa + extraZeros(exp);
-            else if (exp % 100 === 99 && (exp > 99 || mantissa[1]))
-                str = mantissa.replace(/.$/, '.$&e') + (exp + 1);
-            else
-                str = mantissa + 'e' + exp;
-        }
-        else
-        {
-            if (exp >= -mantissa.length)
-                str = mantissa.slice(0, exp) + '.' + mantissa.slice(exp);
-            else
-            {
-                var extraZeroCount = -mantissa.length - exp;
-                var extraLength = APPEND_LENGTH_OF_DOT + APPEND_LENGTH_OF_DIGIT_0 * extraZeroCount;
-                str =
-                replaceNegativeExponential(mantissa, exp, extraLength) ||
-                '.' + extraZeros(extraZeroCount) + mantissa;
-            }
-        }
-        return str;
-    }
-
-    function getMultiDigitLength(str)
-    {
-        var appendLength = 0;
-        _Array_prototype_forEach_call
-        (
-            str,
-            function (digit)
-            {
-                var digitAppendLength = APPEND_LENGTH_OF_DIGITS[digit];
-                appendLength += digitAppendLength;
-            }
-        );
-        return appendLength;
-    }
-
     function getReplacers(optimize)
     {
         var replaceString =
@@ -5758,39 +5849,6 @@
         return replacement;
     }
 
-    function replaceMultiDigitNumber(number)
-    {
-        var str = formatPositiveNumber(number);
-        var replacement = replaceStaticString(str);
-        return replacement;
-    }
-
-    function replaceNegativeExponential(mantissa, exp, rivalExtraLength)
-    {
-        var extraZeroCount;
-        if (exp % 100 > 7 - 100)
-        {
-            if (exp % 10 > -7)
-                extraZeroCount = 0;
-            else
-                extraZeroCount = 10 + exp % 10;
-        }
-        else
-            extraZeroCount = 100 + exp % 100;
-        mantissa += extraZeros(extraZeroCount);
-        exp -= extraZeroCount;
-        var extraLength =
-        APPEND_LENGTH_OF_DIGIT_0 * extraZeroCount +
-        APPEND_LENGTH_OF_SMALL_E +
-        APPEND_LENGTH_OF_MINUS +
-        getMultiDigitLength(_String$1(-exp));
-        if (extraLength < rivalExtraLength)
-        {
-            var str = mantissa + 'e' + exp;
-            return str;
-        }
-    }
-
     function replacePrimaryExpr(encoder, unit, bondStrength, unitIndices, maxLength, replacers)
     {
         var MIN_APPEND_LENGTH = 3;
@@ -8170,6 +8228,29 @@
     var MIN_SOLUTION_SPAN = 2;
     var RADIX_REPLACEMENTS = [];
 
+    // DECIMAL_MIN_LENGTHS is indexed by decimalDigitMaxCount (the number of digits used to write
+    // MAX_SAFE_INTEGER in base radix).
+    // decimalDigitMaxCount may only range from 11 (for radix 36) to 15 (for radix 12).
+    var DECIMAL_MIN_LENGTHS =
+    [
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        ,
+        48, // 1e10
+        50, // 1e11
+        54, // 1e12
+        ,
+        64, // 1e14
+    ];
+
     function createOptimizer$1(toStringReplacement)
     {
         function appendLengthOf(solution)
@@ -8219,7 +8300,8 @@
                 var decimal = _parseInt(chars, radix);
                 if (decimal > MAX_SAFE_INTEGER)
                     return clusterAppendLength == null;
-                var decimalReplacement = replaceMultiDigitNumber(decimal);
+                var decimalStr = formatPositiveNumber(decimal);
+                var decimalReplacement = replaceStaticString(decimalStr);
                 // Adding 3 for leading "+(" and trailing ")".
                 var decimalLength = decimalReplacement.length + 3;
                 var radixReplacement = RADIX_REPLACEMENTS[radix];
@@ -8336,33 +8418,10 @@
     var initialize =
     function ()
     {
-        // DECIMAL_MIN_LENGTHS is indexed by decimalDigitMaxCount (the number of digits used to write
-        // MAX_SAFE_INTEGER in base radix).
-        // decimalDigitMaxCount may only range from 11 (for radix 36) to 15 (for radix 12).
-        var DECIMAL_MIN_LENGTHS =
-        [
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            ,
-            48, // 1e10
-            50, // 1e11
-            54, // 1e12
-            ,
-            64, // 1e14
-        ];
-
         var minLength = Infinity;
         for (var radix = MAX_RADIX; radix >= 12; --radix)
         {
-            var replacement = replaceMultiDigitNumber(radix);
+            var replacement = replaceStaticString(_String$1(radix));
             var length = replacement.length;
             if (length < minLength)
                 minLength = length;
@@ -8817,4 +8876,4 @@
         )();
     }
 
-}());
+})();