jscrewit 3.1.0 → 3.3.0

package/lib/jscrewit.js

@@ -1,4 +1,4 @@
-// JScrewIt 3.0.0 – https://jscrew.it
+// JScrewIt 3.3.0 – https://jscrew.it
 
 (function () {
     'use strict';
@@ -61,7 +61,7 @@
     function esToString$1(arg)
     {
         if (typeof arg === 'symbol')
-            throw new _TypeError$1('Cannot convert a symbol to a string');
+            throw _TypeError$1('Cannot convert a symbol to a string');
         var str = _String$1(arg);
         return str;
     }
@@ -576,13 +576,13 @@
         }
         function validateMask(mask) {
             if (!isMaskCompatible(mask))
-                throw new _Error('Incompatible features');
+                throw _Error('Incompatible features');
         }
         var utilInspect;
         try {
-            /* eslint-disable @typescript-eslint/no-require-imports, n/prefer-node-protocol */
-            utilInspect = require('util').inspect;
-            /* eslint-enable @typescript-eslint/no-require-imports, n/prefer-node-protocol */
+            /* eslint-disable @typescript-eslint/no-require-imports */
+            utilInspect = require('node:util').inspect;
+            /* eslint-enable @typescript-eslint/no-require-imports */
         }
         catch (_a) { }
         {
@@ -828,7 +828,7 @@
     var createMap = function () { return _Object_create(null); };
     function esToString(name) {
         if (typeof name === 'symbol')
-            throw new _TypeError('Cannot convert a symbol to a string');
+            throw _TypeError('Cannot convert a symbol to a string');
         var str = _String(name);
         return str;
     }
@@ -865,7 +865,7 @@
         return str;
     }
     function throwUnknownFeatureError(name) {
-        throw new _Error("Unknown feature ".concat(_JSON_stringify(name)));
+        throw _Error("Unknown feature ".concat(_JSON_stringify(name)));
     }
     function wrapCheck(check) {
         var wrappedCheck = function () { return !!check(); };
@@ -1191,6 +1191,46 @@
                 return available;
             },
         },
+        LOCALE_NUMERALS_IE11_WIN7:
+        {
+            description:
+            'Localized number formatting exclusive to Internet Explorer 11 on Windows 7.',
+            check:
+            function ()
+            {
+                var available =
+                checkLocaleNumeral('lv', Infinity, /^......ī/) &&
+                checkLocaleNumeral('ru', Infinity, /^беск.н.ч.о.ть/);
+                return available;
+            },
+            excludes: ['RUSSIAN_INFINITY'],
+        },
+        LOCALE_NUMERALS_IE11_WIN7_8:
+        {
+            description:
+            'Localized number formatting exclusive to Internet Explorer 11 on Windows 7 and 8.',
+            check:
+            function ()
+            {
+                var available =
+                checkLocaleNumeral('ar', NaN, /^ليس.برقم/) &&
+                checkLocaleNumeral('ar', Infinity, /^..ا.نه..ة/) &&
+                checkLocaleNumeral('cs', NaN, /^.....č/) &&
+                checkLocaleNumeral('el', Infinity, /^Άπε..ο/) &&
+                checkLocaleNumeral('el', NaN, /^μη.αριθ.ός/) &&
+                checkLocaleNumeral('he', NaN, /^לא.מספר/) &&
+                checkLocaleNumeral('he', Infinity, /^.ינ.וף.ח..ב/) &&
+                checkLocaleNumeral('he', -Infinity, /^.......ש/) &&
+                checkLocaleNumeral('ja', Infinity, /^.∞/) &&
+                checkLocaleNumeral('ja', NaN, /^.....非数値/) &&
+                checkLocaleNumeral('lt', Infinity, /^.......ė/) &&
+                checkLocaleNumeral('pl', Infinity, /^.......ń.....ść/) &&
+                checkLocaleNumeral('pl', NaN, /^..............ą/) &&
+                checkLocaleNumeral('zh', Infinity, /^正/) &&
+                checkLocaleNumeral('zh-cn', NaN, /^..字/);
+                return available;
+            },
+        },
         NAME:
         {
             description: 'Existence of the name property for functions.',
@@ -1290,13 +1330,14 @@
         },
         RUSSIAN_INFINITY:
         {
-            description: 'Russian string representation of Infinity as "∞".',
+            description:    'Russian string representation of Infinity as "∞".',
             check:
             function ()
             {
                 var available = Infinity.toLocaleString('ru') === '∞';
                 return available;
             },
+            excludes:       ['LOCALE_NUMERALS_IE11_WIN7'],
         },
         SELF:
         {
@@ -1529,13 +1570,22 @@
             ],
             attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
         },
+        IE_11_WIN_7:
+        {
+            inherits:               'IE_11',
+            versions:               ['11'],
+            compatibilityTag:       'on Windows 7',
+            compatibilityShortTag:  'W7',
+            includes:
+            { LOCALE_NUMERALS_IE11_WIN7: true, LOCALE_NUMERALS_IE11_WIN7_8: true },
+        },
         IE_11_WIN_8:
         {
             inherits:               'IE_11',
             versions:               ['11'],
             compatibilityTag:       'on Windows 8',
             compatibilityShortTag:  'W8',
-            includes:               { RUSSIAN_INFINITY: true },
+            includes:               { LOCALE_NUMERALS_IE11_WIN7_8: true, RUSSIAN_INFINITY: true },
         },
         IE_11_WIN_10:
         {
@@ -2583,6 +2633,8 @@
         var LOCALE_INFINITY                 = Feature.LOCALE_INFINITY;
         var LOCALE_NUMERALS_BN              = Feature.LOCALE_NUMERALS_BN;
         var LOCALE_NUMERALS_EXT             = Feature.LOCALE_NUMERALS_EXT;
+        var LOCALE_NUMERALS_IE11_WIN7       = Feature.LOCALE_NUMERALS_IE11_WIN7;
+        var LOCALE_NUMERALS_IE11_WIN7_8     = Feature.LOCALE_NUMERALS_IE11_WIN7_8;
         var NAME                            = Feature.NAME;
         var NO_FF_SRC                       = Feature.NO_FF_SRC;
         var NO_IE_SRC                       = Feature.NO_IE_SRC;
@@ -2598,15 +2650,15 @@
         var V8_SRC                          = Feature.V8_SRC;
         var WINDOW                          = Feature.WINDOW;
 
-        function charDefaultDefinition(char)
+        function charCommonDefinition(char)
         {
-            var solution = this._defaultResolveCharacter(char);
+            var solution = this._commonResolveCharacter(char);
             return solution;
         }
 
-        function defineCharDefault()
+        function defineCharCommon()
         {
-            var entry = define(charDefaultDefinition);
+            var entry = define(charCommonDefinition);
             return entry;
         }
 
@@ -2691,15 +2743,17 @@
             var expr = '(' + number + ')[TO_LOCALE_STRING](' + locale + ')';
             if (index != null)
             {
-                if (index > 4)
+                if (index % 10 === 8)
+                    expr = '(' + R_PADDINGS[3] + ' + ' + expr + ')[' + (index - index % 10 + 11) + ']';
+                else if (index % 10 > 4)
                 {
-                    var paddingBlock = R_PADDINGS[10 - index];
-                    expr = '(' + paddingBlock + ' + ' + expr + ')[10]';
+                    var paddingBlock = R_PADDINGS[10 - index % 10];
+                    expr = '(' + paddingBlock + ' + ' + expr + ')[' + (index - index % 10 + 10) + ']';
                 }
                 else
                     expr += '[' + index + ']';
             }
-            var entry = define._callWithFeatures(expr, arguments, 3);
+            var entry = define._callWithFeatures({ expr: expr, optimize: true }, arguments, 3);
             return entry;
         }
 
@@ -2727,11 +2781,12 @@
 
         function useLocaleNumeralDefinition(char, locale, number, index)
         {
-            CHARACTERS[char] =
-            [
-                defineLocalizedNumeral._callWithFeatures(locale, number, index, arguments, 4),
-                defineCharDefault(),
-            ];
+            var entries = CHARACTERS[char];
+            var entry = defineLocalizedNumeral._callWithFeatures(locale, number, index, arguments, 4);
+            if (entries)
+                entries.splice(entries.length - 1, 0, entry);
+            else
+                CHARACTERS[char] = [entry, defineCharCommon()];
         }
 
         function useLocaleNumeralDigitDefinitions(locale, zeroCharCode)
@@ -2901,10 +2956,7 @@
             [
                 define('"".fontcolor()[12]'),
             ],
-            '#':
-            [
-                defineCharDefault(),
-            ],
+            // '#'
             // '$'
             '%':
             [
@@ -2912,12 +2964,12 @@
                 define('escape(0 + AT)[20]', AT),
                 define('escape(FLAT)[21]', FLAT),
                 define('escape(ANY_FUNCTION)[0]', IE_SRC),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             '&':
             [
                 define('"".fontcolor("".fontcolor([]))[31]', ESC_HTML_QUOT),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             // '\''
             '(':
@@ -2933,7 +2985,7 @@
             ',':
             [
                 define('(RP_0_S + F_A_L_S_E)[1]'),
-                define({ expr: '[[]].concat([[]])', solutionType: SolutionType.OBJECT }),
+                define({ expr: '[[]][CONCAT]([[]])', solutionType: SolutionType.OBJECT }),
             ],
             '-': '(.0000001 + [])[2]',
             '.': '(11e20 + [])[1]',
@@ -2965,7 +3017,7 @@
             '?':
             [
                 define('(RP_0_S + RegExp())[2]'),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             // '@'
             'A':
@@ -2984,7 +3036,7 @@
                 define('escape(F_A_L_S_E)[11]'),
                 define('(RP_4_A + "".fontcolor())[10]', CAPITAL_HTML),
                 define('(RP_3_WA + Function("return console")())[11]', CONSOLE),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             'D':
             [
@@ -3002,6 +3054,7 @@
             'E':
             [
                 define('btoa("0NaN")[1]'),
+                define('escape(RP_4_A + "".italics())[10]'),
                 define('(RP_5_A + "".link())[10]', CAPITAL_HTML),
             ],
             'F':
@@ -3028,7 +3081,7 @@
             'K':
             [
                 define('(RP_5_A + "".strike())[10]', CAPITAL_HTML),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             'L':
             [
@@ -3054,7 +3107,7 @@
                 define('btoa("".italics())[0]'),
                 define('(RP_0_S + Function("return statusbar")())[11]', BARPROP),
                 define('"0".sup()[10]', CAPITAL_HTML),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             'Q':
             [
@@ -3153,7 +3206,7 @@
             'k':
             [
                 define('20[TO_STRING]("21")'),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             'l': '"false"[2]',
             'm':
@@ -3177,7 +3230,7 @@
             [
                 define('212[TO_STRING]("31")[1]'),
                 define('"".fontcolor(true + "".fontcolor())[30]', ESC_HTML_QUOT),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
             'r': '"true"[1]',
             's': '"false"[3]',
@@ -3301,8 +3354,9 @@
                 define('Infinity[TO_LOCALE_STRING]("ja")[SLICE_OR_SUBSTR]("-1")'),
                 define('Infinity[TO_LOCALE_STRING]("ja").at("-1")', AT),
                 define('Infinity[TO_LOCALE_STRING]()', LOCALE_INFINITY),
+                define('Infinity[TO_LOCALE_STRING]("ja")[1]', LOCALE_NUMERALS_IE11_WIN7_8),
                 define('Infinity[TO_LOCALE_STRING]("ru")', RUSSIAN_INFINITY),
-                defineCharDefault(),
+                defineCharCommon(),
             ],
         });
 
@@ -3314,7 +3368,7 @@
             RegExp:         define({ expr: 'RegExp.name', optimize: { complexOpt: false } }, NAME),
             String:         define('String.name', NAME),
             fromCharCo:
-            define({ expr: '"from3har3o".split(3).join("C")', optimize: { complexOpt: false } }),
+            define({ expr: '"from3har3o"[SPLIT](3)[JOIN]("C")', optimize: { complexOpt: false } }),
             mCh:            define('atob("bUNo")'),
         });
 
@@ -3404,10 +3458,11 @@
             [
                 define('[].at', AT),
             ],
-            FILTER:
+            CONCAT:
             [
-                define('[].filter'),
+                define({ expr: '"concat"', solutionType: SolutionType.COMBINED_STRING }),
             ],
+            FILTER:     '[].filter',
             FLAT:
             [
                 define('[].flat', FLAT),
@@ -3416,11 +3471,24 @@
             [
                 define('[][SLICE_OR_FLAT].call("false")'),
             ],
+            JOIN:
+            [
+                define({ expr: '"join"', solutionType: SolutionType.COMBINED_STRING }),
+            ],
             LOCALE_AR:
             [
                 define({ expr: '"ar-td"', solutionType: SolutionType.COMBINED_STRING }),
                 define({ expr: '"ar"', solutionType: SolutionType.COMBINED_STRING }, SHORT_LOCALES),
             ],
+            LOCALE_HE:
+            [
+                define({ expr: '"He"', solutionType: SolutionType.COMBINED_STRING }),
+                define({ expr: '"he"', solutionType: SolutionType.COMBINED_STRING }),
+            ],
+            MAP:
+            [
+                define({ expr: '"map"', optimize: true, solutionType: SolutionType.COMBINED_STRING }),
+            ],
             PLAIN_OBJECT:
             [
                 define('Function("return{}")()'),
@@ -3439,6 +3507,10 @@
                 define({ expr: '"slice"', solutionType: SolutionType.COMBINED_STRING }),
                 define({ expr: '"substr"', solutionType: SolutionType.COMBINED_STRING }),
             ],
+            SPLIT:
+            [
+                define({ expr: '"split"', optimize: true, solutionType: SolutionType.COMBINED_STRING }),
+            ],
             TO_LOCALE_STRING:
             [
                 define
@@ -3664,102 +3736,106 @@
 
         FH_R_PADDING_SHIFTS = [define(1, IE_SRC), define(0, NO_IE_SRC)];
 
-        var FORMAT_MAPPER_ENTRIES =
-        [
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(falsefalse){return function(undefined){return ' +
-                        'falsefalse' + accessor + '}}")()';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(undefined){return this' + accessor + '}")().bind';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(f){return this' + accessor + '}")().bind';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'f';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return falsefalse=>undefined=>falsefalse' + accessor + '")()';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })(),
-                ARROW
-            ),
-        ];
-
         FORMAT_MAPPER_LONG =
         defineList
         (
-            FORMAT_MAPPER_ENTRIES,
+            [
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(falsefalse){return function(undefined){return ' +
+                            'falsefalse' + accessor + '}}")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'undefined';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(f){return this' + accessor + '}")().bind';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'f';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return falsefalse=>undefined=>falsefalse' + accessor + '")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'undefined';
+                        return formatMapper;
+                    })(),
+                    ARROW
+                ),
+            ],
             [
                 define(0),
-                define(2, ARRAY_ITERATOR),
+                define(1, ARRAY_ITERATOR),
                 define(0, NO_FF_SRC),
                 define(0, NO_V8_SRC),
-                define(2, ARRAY_ITERATOR, CAPITAL_HTML),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML),
                 define(0, ARRAY_ITERATOR, AT),
                 define(0, ARRAY_ITERATOR, FLAT),
                 define(0, ARRAY_ITERATOR, NO_IE_SRC),
                 define(0, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC),
-                define(3),
+                define(2),
             ]
         );
 
         FORMAT_MAPPER_SHORT =
         defineList
         (
-            FORMAT_MAPPER_ENTRIES,
             [
-                define(0),
-                define(1, ARRAY_ITERATOR),
-                define(0, NO_FF_SRC),
-                define(0, NO_V8_SRC),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML),
-                define(0, ARRAY_ITERATOR, AT),
-                define(0, ARRAY_ITERATOR, FLAT),
-                define(0, ARRAY_ITERATOR, NO_IE_SRC),
-                define(0, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC),
-                define(3),
-            ]
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(undefined){return function(falsefalse){return ' +
+                            'undefined[1][undefined[0]' + accessor + ']}}")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'falsefalse';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return undefined=>falsefalse=>undefined[1][undefined[0]' +
+                            accessor + ']")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'falsefalse';
+                        return formatMapper;
+                    })(),
+                    ARROW
+                ),
+            ],
+            [define(0), define(1)]
         );
 
         FROM_CHAR_CODE =
@@ -3938,15 +4014,58 @@
         useLocaleNumeralDefinition('ي', '"ar"', NaN, 1);
         useLocaleNumeralDefinition('س', '"ar"', NaN, 2);
         useLocaleNumeralDefinition('ر', '"ar"', NaN, 4, LOCALE_NUMERALS_EXT);
+        useLocaleNumeralDefinition('ب', '"ar"', NaN, 4, LOCALE_NUMERALS_IE11_WIN7_8);
         useLocaleNumeralDefinition('ق', '"ar"', NaN, 5, LOCALE_NUMERALS_EXT);
+        useLocaleNumeralDefinition('ر', '"ar"', NaN, 5, LOCALE_NUMERALS_IE11_WIN7_8);
         useLocaleNumeralDefinition('م', '"ar"', NaN, 6, LOCALE_NUMERALS_EXT);
+        useLocaleNumeralDefinition('ق', '"ar"', NaN, 6, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('م', '"ar"', NaN, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ا', '"ar"', Infinity, 2, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ن', '"ar"', Infinity, 4, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ه', '"ar"', Infinity, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ة', '"ar"', Infinity, 8, LOCALE_NUMERALS_IE11_WIN7_8);
         useLocaleNumeralDigitDefinitions('"bn"', 0x09e6, LOCALE_NUMERALS_BN);
+        useLocaleNumeralDefinition('č', '"cs"', NaN, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('μ', '"el"', NaN, 0, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('η', '"el"', NaN, 1, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('α', '"el"', NaN, 3, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ρ', '"el"', NaN, 4, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ι', '"el"', NaN, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('θ', '"el"', NaN, 6, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ό', '"el"', NaN, 8, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ς', '"el"', NaN, 9, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('Ά', '"el"', Infinity, 0, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('π', '"el"', Infinity, 1, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ε', '"el"', Infinity, 2, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ο', '"el"', Infinity, 5, LOCALE_NUMERALS_IE11_WIN7_8);
         useLocaleNumeralDigitDefinitions('"fa"', 0x06f0);
         useLocaleNumeralDefinition('٬', '"fa"', 1000, 1);
         useLocaleNumeralDefinition('ن', '"fa"', NaN, 0, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('ا', '"fa"', NaN, 1, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('ع', '"fa"', NaN, 2, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('د', '"fa"', NaN, 3, LOCALE_NUMERALS_EXT);
+        useLocaleNumeralDefinition('ש', 'LOCALE_HE', -Infinity, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('י', 'LOCALE_HE', Infinity, 1, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('נ', 'LOCALE_HE', Infinity, 2, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ו', 'LOCALE_HE', Infinity, 4, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ף', 'LOCALE_HE', Infinity, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ח', 'LOCALE_HE', Infinity, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ב', 'LOCALE_HE', Infinity, 10, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ל', 'LOCALE_HE', NaN, 0, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('א', 'LOCALE_HE', NaN, 1, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('מ', 'LOCALE_HE', NaN, 3, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ס', 'LOCALE_HE', NaN, 4, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('פ', 'LOCALE_HE', NaN, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ר', 'LOCALE_HE', NaN, 6, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('非', '"ja"', NaN, 5, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('数', '"ja"', NaN, 6, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('値', '"ja"', NaN, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ė', '"lt"', Infinity, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ī', '"lv"', Infinity, 6, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('ń', '"pl"', Infinity, 7, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ś', '"pl"', Infinity, 13, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ć', '"pl"', Infinity, 14, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('ą', '"pl"', NaN, 14, LOCALE_NUMERALS_IE11_WIN7_8);
         useLocaleNumeralDefinition('н', '"ru"', NaN, 0, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('е', '"ru"', NaN, 1, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('ч', '"ru"', NaN, 3, LOCALE_NUMERALS_EXT);
@@ -3954,6 +4073,17 @@
         useLocaleNumeralDefinition('с', '"ru"', NaN, 5, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('л', '"ru"', NaN, 6, LOCALE_NUMERALS_EXT);
         useLocaleNumeralDefinition('о', '"ru"', NaN, 7, LOCALE_NUMERALS_EXT);
+        useLocaleNumeralDefinition('б', '"ru"', Infinity, 0, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('е', '"ru"', Infinity, 1, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('с', '"ru"', Infinity, 2, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('к', '"ru"', Infinity, 3, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('н', '"ru"', Infinity, 5, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('ч', '"ru"', Infinity, 7, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('о', '"ru"', Infinity, 9, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('т', '"ru"', Infinity, 11, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('ь', '"ru"', Infinity, 12, LOCALE_NUMERALS_IE11_WIN7);
+        useLocaleNumeralDefinition('正', '"zh"', Infinity, 0, LOCALE_NUMERALS_IE11_WIN7_8);
+        useLocaleNumeralDefinition('字', '"zh-cn"', NaN, 2, LOCALE_NUMERALS_IE11_WIN7_8);
     }
     )();
 
@@ -4691,8 +4821,8 @@
         function getMantissa()
         {
             var lastDigitIndex = usefulDigits - 1;
-            var preMantissa = digits.slice(0, lastDigitIndex);
-            var lastDigit = +digits[lastDigitIndex];
+            var preMantissa = digitsBeforeDot.slice(0, lastDigitIndex);
+            var lastDigit = +digitsBeforeDot[lastDigitIndex];
             var value = evalNumber(preMantissa, lastDigit, exp);
             for (;;)
             {
@@ -4709,9 +4839,9 @@
         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 digitsBeforeDot = (match[1] + digitsAfterDot).replace(/^0+/, '');
+        var usefulDigits = digitsBeforeDot.search(/0*$/);
+        var exp = (match[3] | 0) - digitsAfterDot.length + digitsBeforeDot.length - usefulDigits;
         var mantissa = getMantissa();
         if (exp >= 0)
         {
@@ -4974,7 +5104,7 @@
                 var chain = stack.slice(stackIndex);
                 var feature = featureFromMask(encoder.mask);
                 var message = 'Circular reference detected: ' + chain.join(' < ') + ' – ' + feature;
-                var error = new _SyntaxError(message);
+                var error = _SyntaxError(message);
                 assignNoEnum$1(error, { chain: chain, feature: feature });
                 throw error;
             }
@@ -5193,7 +5323,7 @@
         var stackLength = stack.length;
         if (stackLength)
             message += ' in the definition of ' + stack[stackLength - 1];
-        throw new _SyntaxError(message);
+        throw _SyntaxError(message);
     }
 
     var matchSimpleAt =
@@ -5234,7 +5364,18 @@
     (
         Encoder.prototype,
         {
-            _createCharDefaultSolution:
+            _commonResolveCharacter:
+            function (char)
+            {
+                var charCode = char.charCodeAt();
+                var atobOpt = charCode < 0x100;
+                var stdOpt = !atobOpt;
+                var solution =
+                this._createCharCommonSolution(char, charCode, atobOpt, stdOpt, stdOpt, stdOpt);
+                return solution;
+            },
+
+            _createCharCommonSolution:
             function (char, charCode, atobOpt, charCodeOpt, escSeqOpt, unescapeOpt)
             {
                 var solution;
@@ -5268,17 +5409,6 @@
                 return solution;
             },
 
-            _defaultResolveCharacter:
-            function (char)
-            {
-                var charCode = char.charCodeAt();
-                var atobOpt = charCode < 0x100;
-                var stdOpt = !atobOpt;
-                var solution =
-                this._createCharDefaultSolution(char, charCode, atobOpt, stdOpt, stdOpt, stdOpt);
-                return solution;
-            },
-
             _getPaddingBlock:
             function (length)
             {
@@ -5288,6 +5418,8 @@
                 throwSyntaxError(this, 'Undefined regular padding block with length ' + length);
             },
 
+            _guardResolution:       noop,
+
             _replaceCharByAtob:     replaceCharByAtob,
 
             _replaceCharByCharCode: replaceCharByCharCode,
@@ -5496,11 +5628,9 @@
                 var firstSolution = options.firstSolution;
                 var maxLength = options.maxLength;
                 if (firstSolution)
-                {
                     buffer.append(firstSolution);
-                    if (buffer.length > maxLength)
-                        return;
-                }
+                if (buffer.length > maxLength)
+                    return;
                 var length = str.length;
                 for (var index = 0; index < length;)
                 {
@@ -5563,19 +5693,21 @@
                 var solution = charCache[char];
                 if (solution === undefined)
                 {
+                    var charName = _JSON_stringify$1(char);
                     callResolver
                     (
                         this,
-                        _JSON_stringify$1(char),
+                        charName,
                         function ()
                         {
                             var entries = CHARACTERS[char];
                             if (!entries || _Array_isArray$1(entries))
                             {
+                                this._guardResolution(charName);
                                 if (entries)
                                     solution = findOptimalSolution(this, char, entries);
                                 if (!solution)
-                                    solution = this._defaultResolveCharacter(char);
+                                    solution = this._commonResolveCharacter(char);
                             }
                             else
                             {
@@ -5606,6 +5738,7 @@
                             var entries = this.constantDefinitions[constant];
                             if (_Array_isArray$1(entries))
                             {
+                                this._guardResolution(constant);
                                 solution =
                                 findOptimalSolution(this, constant, entries, SolutionType.OBJECT);
                             }
@@ -5624,6 +5757,12 @@
         }
     );
 
+    STATIC_ENCODER._guardResolution =
+    function (name)
+    {
+        throw _Error$1('Unable to resolve ' + name + ' statically');
+    };
+
     initStaticEncoder(STATIC_ENCODER);
 
     function createFigurator(startValues, joiner)
@@ -5747,6 +5886,49 @@
         return figurator;
     }
 
+    function joinWithMaxLength(maxLength)
+    {
+        for (var index = arguments.length; ;)
+        {
+            if (maxLength < 0)
+                return;
+            if (--index < 1)
+                break;
+            var str = arguments[index];
+            maxLength -= str.length;
+        }
+        var array = _Array_prototype_slice_call(arguments, 1);
+        var result = array.join('');
+        return result;
+    }
+
+    // Length of the shortest possible concat head replacement "[]".
+    var CONCAT_HEAD_MIN_LENGTH      = 2;
+
+    // The overhead of "[" + "]" plus the minimum concat head replacement length.
+    var CONCAT_HEAD_MIN_OVERHEAD    = 2 + CONCAT_HEAD_MIN_LENGTH;
+
+    // Length of the shortest possible concat part replacements "+[] and "![]".
+    var CONCAT_PART_MIN_LENGTH      = 3;
+
+    // The overhead of "[" + "](" + ")" plus the minimum concat part replacement length.
+    var CONCAT_PART_MIN_OVERHEAD    = 4 + CONCAT_PART_MIN_LENGTH;
+
+    // Length of the shortest possible joiner replacement "[]".
+    var JOINER_MIN_LENGTH           = 2;
+
+    // The overhead of "[" + "](" + ")" plus the minimum joiner replacement length.
+    var JOINING_MIN_OVERHEAD        = 4 + JOINER_MIN_LENGTH;
+
+    // Length of the shortest possible separator replacement "[]".
+    var SEPARATOR_MIN_LENGTH        = 2;
+
+    // The overhead of "[" + "](" + ")" plus the minimum separator replacement length.
+    var SEPARATION_MIN_OVERHEAD     = 4 + SEPARATOR_MIN_LENGTH;
+
+    // Length of the shortest possible sequence replacement "([]+[])".
+    var SEQUENCE_MIN_LENGTH         = 7;
+
     /**
      * An object that exposes properties used to split a string into an array of strings or to join
      * array elements into a string.
@@ -5762,6 +5944,81 @@
      * to join them into a single string.
      */
 
+    function createConcatenationReplacement
+    (encoder, array, allowZeroForEmptyElements, forceString, maxLength)
+    {
+        var concatReplacement = encoder.resolveConstant('CONCAT').replacement;
+        var concatCount = array.length - 1;
+        maxLength -=
+        CONCAT_HEAD_MIN_OVERHEAD + concatCount * (concatReplacement.length + CONCAT_PART_MIN_OVERHEAD);
+        if (maxLength < 0)
+            return;
+        var options = { screwMode: forceString ? SCREW_AS_STRING : SCREW_NORMAL };
+        var replacements = [];
+        for (var index = 0; index <= concatCount; ++index)
+        {
+            var element = array[index];
+            var elementReplacement = undefinedAsString(replaceStaticString(element, options));
+            var minLength = index ? CONCAT_PART_MIN_LENGTH : CONCAT_HEAD_MIN_LENGTH;
+            if (index)
+            {
+                if (elementReplacement === '[]')
+                    elementReplacement = allowZeroForEmptyElements ? '+[]' : '[[]]';
+                replacements.push('[', concatReplacement, '](', elementReplacement, ')');
+            }
+            else
+                replacements.push('[', elementReplacement, ']');
+            maxLength -= elementReplacement.length - minLength;
+            if (maxLength < 0)
+                return;
+        }
+        var concatenationReplacement = replacements.join('');
+        return concatenationReplacement;
+    }
+
+    function createSubstitutionsReplacement(encoder, substitutions, maxLength)
+    {
+        var substitutionCount = substitutions ? substitutions.length : 0;
+        if (!substitutionCount)
+            return '';
+        var splitReplacement = encoder.resolveConstant('SPLIT').replacement;
+        var joinReplacement = encoder.resolveConstant('JOIN').replacement;
+        maxLength -=
+        substitutionCount *
+        (
+            splitReplacement.length + SEPARATION_MIN_OVERHEAD +
+            joinReplacement.length + JOINING_MIN_OVERHEAD
+        );
+        if (maxLength < 0)
+            return;
+        var replacements = [];
+        for (var index = 0; index < substitutionCount; ++index)
+        {
+            var substitution = substitutions[index];
+            var separatorReplacement = undefinedAsString(encoder.replaceExpr(substitution.separator));
+            var joinerReplacement = undefinedAsString(encoder.replaceString(substitution.joiner));
+            maxLength -=
+            separatorReplacement.length - SEPARATOR_MIN_LENGTH +
+            joinerReplacement.length - JOINER_MIN_LENGTH;
+            if (maxLength < 0)
+                return;
+            replacements.push
+            (
+                '[',
+                splitReplacement,
+                '](',
+                separatorReplacement,
+                ')[',
+                joinReplacement,
+                '](',
+                joinerReplacement,
+                ')'
+            );
+        }
+        var substitutionsReplacement = replacements.join('');
+        return substitutionsReplacement;
+    }
+
     function replaceJoinedArrayString(array, joiner, maxLength)
     {
         var str = array.join(joiner);
@@ -5770,18 +6027,8 @@
         return replacement;
     }
 
-    function undefinedAsString(replacement)
-    {
-        if (replacement === '[][[]]')
-            replacement += '+[]';
-        return replacement;
-    }
-
     /**
-     * Replaces a given array of strings with equivalent JSFuck code.
-     *
-     * Array elements may only contain characters with static definitions in their string
-     * representations.
+     * Replaces a given array of statically replaceable strings with equivalent JSFuck code.
      *
      * @function Encoder#replaceStringArray
      *
@@ -5790,7 +6037,7 @@
      *
      * @param {Delimiter[]} insertions
      * An array of delimiters of which at most one will be used to compose a joined string and split it
-     * into an array of strings.
+     * into an array of strings. Every joiner in the insertions must be a statically replaceable string.
      *
      * The encoder can pick an insertion and insert a joiner between any two adjacent elements to mark
      * the boundary between them. The separator is then used to split the concatenated string back into
@@ -5838,143 +6085,69 @@
         // applied.
         if (substitutions || count > 2)
         {
-            var preReplacement =
-            function ()
-            {
-                // Length of the shortest string replacement "([]+[])".
-                var STRING_REPLACEMENT_MIN_LENGTH = 7;
-
-                // This is for the overhead of "[" + "](" + ")" plus the length of the shortest
-                // separator replacement "[]".
-                var SEPARATOR_MIN_OVERHEAD = 6;
-
-                // This is for the overhead of "[" + "](" + ")" plus the length of the shortest
-                // joiner replacement "[]".
-                var JOINER_MIN_OVERHEAD = 6;
-
-                var joinCount = substitutions ? substitutions.length : 0;
-                var splitCount = joinCount + 1;
-                var maxSplitReplacementLength =
-                (maxLength - STRING_REPLACEMENT_MIN_LENGTH) / splitCount - SEPARATOR_MIN_OVERHEAD;
-                var splitReplacement =
-                this.replaceString('split', { maxLength: maxSplitReplacementLength, optimize: true });
-                if (!splitReplacement)
-                    return;
-                var preReplacement = '';
-                if (joinCount)
-                {
-                    var maxJoinReplacementLength =
-                    (
-                        maxLength - STRING_REPLACEMENT_MIN_LENGTH -
-                        splitCount * (splitReplacement.length + SEPARATOR_MIN_OVERHEAD)
-                    ) /
-                    joinCount -
-                    JOINER_MIN_OVERHEAD;
-                    var joinReplacement =
-                    this.replaceString('join', { maxLength: maxJoinReplacementLength });
-                    if (!joinReplacement)
-                        return;
-                    substitutions.forEach
-                    (
-                        function (substitution)
-                        {
-                            var separatorReplacement =
-                            undefinedAsString(this.replaceExpr(substitution.separator));
-                            var joinerReplacement =
-                            undefinedAsString(this.replaceString(substitution.joiner));
-                            preReplacement +=
-                            '[' + splitReplacement + '](' + separatorReplacement + ')[' +
-                            joinReplacement + '](' + joinerReplacement + ')';
-                        },
-                        this
-                    );
-                }
-                preReplacement += '[' + splitReplacement + ']';
-                return preReplacement;
-            }
-            .call(this);
+            var splitReplacement = this.resolveConstant('SPLIT').replacement;
+            var minSubstitutionsReplacementLength =
+            maxLength -
+            SEQUENCE_MIN_LENGTH -
+            splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD;
+            var substitutionsReplacement =
+            createSubstitutionsReplacement(this, substitutions, minSubstitutionsReplacementLength);
         }
-        if (!substitutions && count > 1)
-        {
-            var concatReplacement =
-            this.replaceString('concat', { maxLength: maxLength, optimize: true });
-        }
-        if (preReplacement)
+        if (substitutionsReplacement != null)
         // Approach 1: (array[0] + joiner + array[1] + joiner + array[2]...).split(separator)
         {
-            // 2 is for the additional overhead of "(" + ")".
-            var maxBulkLength = maxLength - (preReplacement.length + 2);
-            var optimalStrReplacement;
+            var maxBulkLength =
+            maxLength - substitutionsReplacement.length - splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD + SEPARATOR_MIN_LENGTH;
+            var optimalSeqReplacement;
             var optimalSeparatorReplacement;
             insertions.forEach
             (
                 function (insertion)
                 {
-                    var strReplacement =
+                    var seqReplacement =
                     replaceJoinedArrayString(array, insertion.joiner, maxBulkLength);
-                    if (!strReplacement)
+                    if (!seqReplacement)
                         return;
                     var separatorReplacement = undefinedAsString(this.replaceExpr(insertion.separator));
-                    var bulkLength = strReplacement.length + separatorReplacement.length;
+                    var bulkLength = seqReplacement.length + separatorReplacement.length;
                     if (!(bulkLength > maxBulkLength))
                     {
                         maxBulkLength = bulkLength;
-                        optimalStrReplacement = strReplacement;
+                        optimalSeqReplacement = seqReplacement;
                         optimalSeparatorReplacement = separatorReplacement;
                     }
                 },
                 this
             );
-            if (optimalStrReplacement)
+            if (optimalSeqReplacement)
             {
                 replacement =
-                optimalStrReplacement + preReplacement + '(' + optimalSeparatorReplacement + ')';
+                optimalSeqReplacement + substitutionsReplacement + '[' + splitReplacement + '](' +
+                optimalSeparatorReplacement + ')';
                 maxLength = replacement.length - 1;
             }
         }
-        if
-        (
-            !substitutions &&
-            (
-                count <= 1 ||
-                concatReplacement &&
-                // 4 is the length of the shortest possible replacement "[[]]".
-                // 7 is the length of the shortest possible additional overhead for each following array
-                // element, as in "[" + "](+[])" or "[" + "](![])".
-                !(4 + (concatReplacement.length + 7) * (count - 1) > maxLength)
-            )
-        )
+        if (!substitutions)
         // Approach 2: [array[0]].concat(array[1]).concat(array[2])...
         {
-            var arrayReplacement;
-            var options = { screwMode: forceString ? SCREW_AS_STRING : SCREW_NORMAL };
-            if
-            (
-                !array.some
-                (
-                    function (element)
-                    {
-                        var elementReplacement =
-                        undefinedAsString(replaceStaticString(element, options));
-                        if (arrayReplacement)
-                        {
-                            if (elementReplacement === '[]')
-                                elementReplacement = allowZeroForEmptyElements ? '+[]' : '[[]]';
-                            arrayReplacement +=
-                            '[' + concatReplacement + '](' + elementReplacement + ')';
-                        }
-                        else
-                            arrayReplacement = '[' + elementReplacement + ']';
-                        var result = arrayReplacement.length > maxLength;
-                        return result;
-                    }
-                )
-            )
+            var arrayReplacement =
+            createConcatenationReplacement
+            (this, array, allowZeroForEmptyElements, forceString, maxLength);
+            if (arrayReplacement)
                 replacement = arrayReplacement;
         }
         return replacement;
     }
 
+    function undefinedAsString(replacement)
+    {
+        if (replacement === '[][[]]')
+            replacement += '+[]';
+        return replacement;
+    }
+
     var ENCODING_TYPE_COMBINED      = 'combined';
     var ENCODING_TYPE_EXPRESSION    = 'expression';
     var ENCODING_TYPE_TEXT          = 'text';
@@ -5982,6 +6155,12 @@
     var FALSE_FREE_DELIMITER = { joiner: 'false', separator: 'false' };
     var FALSE_TRUE_DELIMITER = { joiner: '', separator: 'Function("return/(?=false|true)/")()' };
 
+    // Underestimated minimum length of the joining: "[" + joinReplacement + "]([])".
+    var JOINING_MIN_LENGTH      = 8;
+
+    // Underestimated minimum overhead of the mapping: "[" + "](" + mapperReplacement + ")".
+    var MAPPING_MIN_OVERHEAD    = 12;
+
     var REPLACERS =
     {
         identifier:
@@ -6079,23 +6258,62 @@
         return charKeyArrayStr;
     }
 
-    function createJSFuckArrayMapping(encoder, arrayStr, mapper, legend)
+    function createLongStrCodesOutput(encoder, arrayReplacement, fromCharCode, arg, maxLength)
     {
-        var result =
-        arrayStr + '[' + encoder.replaceString('map', { optimize: true }) + '](' +
-        encoder.replaceExpr(mapper, true) + '(' + legend + '))';
-        return result;
+        var mapReplacement = encoder.resolveConstant('MAP').replacement;
+        var maxCharArrayLength = maxLength - JOINING_MIN_LENGTH;
+        var maxMapReplacementLength =
+        maxCharArrayLength - arrayReplacement.length - MAPPING_MIN_OVERHEAD;
+        if (mapReplacement.length > maxMapReplacementLength)
+            return;
+        var formatter = encoder.findDefinition(FROM_CHAR_CODE_CALLBACK_FORMATTER);
+        var formatterExpr = formatter(fromCharCode, arg);
+        var mapper = 'Function("return ' + formatterExpr + '")()';
+        var mapperReplacement = encoder._replaceMapper(mapper);
+        var charArrayReplacement =
+        joinWithMaxLength
+        (
+            maxCharArrayLength,
+            arrayReplacement,
+            '[',
+            mapReplacement,
+            '](',
+            mapperReplacement,
+            ')'
+        );
+        if (!charArrayReplacement)
+            return;
+        var replacement = encoder._joinCharArray(charArrayReplacement, maxLength);
+        return replacement;
     }
 
-    function createLongStrCodesOutput(encoder, strCodeArrayStr, fromCharCode, arg)
+    function createMappedArrayEncoding(encoder, arrayReplacement, mapper, legend, maxLength)
     {
-        var formatter = encoder.findDefinition(FROM_CHAR_CODE_CALLBACK_FORMATTER);
-        var formatterExpr = formatter(fromCharCode, arg);
-        var output =
-        strCodeArrayStr + '[' + encoder.replaceString('map', { optimize: true }) + '](' +
-        encoder.replaceExpr('Function("return ' + formatterExpr + '")()', true) + ')[' +
-        encoder.replaceString('join') + ']([])';
-        return output;
+        var mapReplacement = encoder.resolveConstant('MAP').replacement;
+        var maxCharArrayLength = maxLength - JOINING_MIN_LENGTH;
+        var maxMapReplacementLength =
+        // 2 is for the calling parentheses around the legend replacement.
+        maxCharArrayLength - arrayReplacement.length - MAPPING_MIN_OVERHEAD - legend.length - 2;
+        if (mapReplacement.length > maxMapReplacementLength)
+            return;
+        var mapperReplacement = encoder._replaceMapper(mapper);
+        var charArrayReplacement =
+        joinWithMaxLength
+        (
+            maxCharArrayLength,
+            arrayReplacement,
+            '[',
+            mapReplacement,
+            '](',
+            mapperReplacement,
+            '(',
+            legend,
+            '))'
+        );
+        if (!charArrayReplacement)
+            return;
+        var replacement = encoder._joinCharArray(charArrayReplacement, maxLength);
+        return replacement;
     }
 
     function createReindexMap(count, radix, amendingCount, coerceToInt)
@@ -6163,41 +6381,58 @@
         var strCodeCacheKey = 'strCodeCache' + (radix ? 'Radix' + radix : '');
         var cache = inputData[strCodeCacheKey] || (inputData[strCodeCacheKey] = createEmpty());
         var strCodeArray = splitter(input, radix, cache);
-        var strCodeArrayStr = encoder.replaceFalseFreeArray(strCodeArray, maxLength);
+        var strCodeArrayStr =
+        encoder.replaceStringArray(strCodeArray, [FALSE_FREE_DELIMITER], null, false, false, maxLength);
         if (strCodeArrayStr)
         {
-            var output;
+            var replacement;
             if (radix)
             {
-                output =
+                replacement =
                 createLongStrCodesOutput
-                (encoder, strCodeArrayStr, fromCharCode, 'parseInt(undefined,' + radix + ')');
+                (
+                    encoder,
+                    strCodeArrayStr,
+                    fromCharCode,
+                    'parseInt(undefined,' + radix + ')',
+                    maxLength
+                );
             }
             else
             {
                 var long = strCodeArray.length > encoder._maxDecodableArgs;
                 if (long)
                 {
-                    output =
-                    createLongStrCodesOutput(encoder, strCodeArrayStr, fromCharCode, 'undefined');
+                    replacement =
+                    createLongStrCodesOutput
+                    (
+                        encoder,
+                        strCodeArrayStr,
+                        fromCharCode,
+                        'undefined',
+                        maxLength
+                    );
                 }
                 else
                 {
                     var returnString = encoder.findDefinition(OPTIMAL_RETURN_STRING);
                     var str = returnString + '.' + fromCharCode + '(';
-                    output =
-                    encoder.resolveConstant('Function').replacement +
-                    '(' +
-                    encoder.replaceString(str, { optimize: true }) +
-                    '+' +
-                    strCodeArrayStr +
-                    '+' +
-                    encoder.resolveCharacter(')').replacement +
-                    ')()';
+                    replacement =
+                    joinWithMaxLength
+                    (
+                        maxLength,
+                        encoder.resolveConstant('Function').replacement,
+                        '(',
+                        encoder.replaceString(str, { optimize: true }),
+                        '+',
+                        strCodeArrayStr,
+                        '+',
+                        encoder.resolveCharacter(')').replacement,
+                        ')()'
+                    );
                 }
             }
-            if (!(output.length > maxLength))
-                return output;
+            return replacement;
         }
     }
 
@@ -6256,8 +6491,7 @@
         var legend = encodeDictLegend(encoder, dictChars, maxLength - minCharIndexArrayStrLength);
         if (!legend)
             return;
-        var figureLegendInsertions =
-        encoder._callGetFigureLegendInsertions(getFigureLegendInsertions, figurator, figures);
+        var figureLegendInsertions = getFigureLegendInsertions(figurator, figures);
         var figureMaxLength = maxLength - legend.length;
         var figureLegend =
         encoder.replaceStringArray
@@ -6284,13 +6518,10 @@
         );
         if (!charIndexFigureArrayStr)
             return;
-        var formatMapper = encoder.findDefinition(FORMAT_MAPPER_SHORT);
-        var argName = formatMapper.argName;
-        var accessor = '.indexOf(' + argName + ')';
-        var mapper = formatMapper(accessor);
-        var charIndexArrayStr =
-        createJSFuckArrayMapping(encoder, charIndexFigureArrayStr, mapper, figureLegend);
-        var output = encoder.createDictEncoding(legend, charIndexArrayStr, maxLength);
+        var formatMapper = encoder._findFormatMapperShort();
+        var output =
+        encoder._createDblDictEncoding
+        (formatMapper, charIndexFigureArrayStr, figureLegend, legend, maxLength);
         return output;
     }
 
@@ -6798,7 +7029,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                193
+                194
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6853,7 +7084,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                347
+                173
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6943,11 +7174,51 @@
     (
         Encoder.prototype,
         {
-            _callGetFigureLegendInsertions:
-            function (getFigureLegendInsertions, figurator, figures)
+            _createDblDictEncoding:
+            function (formatMapper, charIndexFigureArrayStr, figureLegend, legend, maxLength)
             {
-                var figureLegendInsertions = getFigureLegendInsertions(figurator, figures);
-                return figureLegendInsertions;
+                var argName = formatMapper.argName;
+                var accessor = '.indexOf(' + argName + ')';
+                var mapper = formatMapper(accessor);
+                var concatReplacement = this.resolveConstant('CONCAT').replacement;
+                var maxCombinedLegendLength = maxLength - charIndexFigureArrayStr.length - 10;
+                var combinedLegend =
+                joinWithMaxLength
+                (
+                    maxCombinedLegendLength,
+                    '[',
+                    figureLegend,
+                    '][',
+                    concatReplacement,
+                    '](',
+                    legend,
+                    ')'
+                );
+                if (!combinedLegend)
+                    return;
+                var replacement =
+                createMappedArrayEncoding
+                (this, charIndexFigureArrayStr, mapper, combinedLegend, maxLength);
+                return replacement;
+            },
+
+            _createDictEncoding:
+            function (charIndexArrayStr, legend, radix, coerceToInt, maxLength)
+            {
+                var mapper;
+                if (radix)
+                {
+                    var formatMapper = this.findDefinition(FORMAT_MAPPER_LONG);
+                    var argName = formatMapper.argName;
+                    var parseIntArg = (coerceToInt ? '+' : '') + argName;
+                    var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
+                    mapper = formatMapper(accessor);
+                }
+                else
+                    mapper = '"".charAt.bind';
+                var replacement =
+                createMappedArrayEncoding(this, charIndexArrayStr, mapper, legend, maxLength);
+                return replacement;
             },
 
             _encodeByCharCodes:
@@ -7044,7 +7315,7 @@
                 if (!charIndexArrayStr)
                     return;
                 var output =
-                this.createDictEncoding(legend, charIndexArrayStr, maxLength, radix, coerceToInt);
+                this._createDictEncoding(charIndexArrayStr, legend, radix, coerceToInt, maxLength);
                 return output;
             },
 
@@ -7092,41 +7363,33 @@
                     perfInfo.perfLog = perfLog;
                 delete this.perfLog;
                 if (output == null)
-                    throw new _Error$1('Encoding failed');
+                    throw _Error$1('Encoding failed');
                 return output;
             },
 
-            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
+            _findFormatMapperShort:
+            function ()
+            {
+                var formatMapper = this.findDefinition(FORMAT_MAPPER_SHORT);
+                return formatMapper;
+            },
 
-            createDictEncoding:
-            function (legend, charIndexArrayStr, maxLength, radix, coerceToInt)
+            _joinCharArray:
+            function (charArrayReplacement, maxLength)
             {
-                var mapper;
-                if (radix)
-                {
-                    var formatMapper = this.findDefinition(FORMAT_MAPPER_LONG);
-                    var argName = formatMapper.argName;
-                    var parseIntArg = (coerceToInt ? '+' : '') + argName;
-                    var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
-                    mapper = formatMapper(accessor);
-                }
-                else
-                    mapper = '"".charAt.bind';
-                var output =
-                createJSFuckArrayMapping(this, charIndexArrayStr, mapper, legend) + '[' +
-                this.replaceString('join') + ']([])';
-                if (!(output.length > maxLength))
-                    return output;
+                var joinReplacement = this.resolveConstant('JOIN').replacement;
+                var replacement =
+                joinWithMaxLength(maxLength, charArrayReplacement, '[', joinReplacement, ']([])');
+                return replacement;
             },
 
-            // Array elements may not contain the substring "false", because the value false could be
-            // used as a separator in the encoding.
-            replaceFalseFreeArray:
-            function (array, maxLength)
+            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
+
+            _replaceMapper:
+            function (mapper)
             {
-                var result =
-                this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, false, maxLength);
-                return result;
+                var mapperReplacement = this.replaceExpr(mapper, true);
+                return mapperReplacement;
             },
 
             replaceStringArray: replaceStringArray,
@@ -7872,7 +8135,7 @@
         case 'none':
             return [, STRATEGY_NAMES_TEXT];
         }
-        throw new _Error$1('Invalid value for option ' + name);
+        throw _Error$1('Invalid value for option ' + name);
     }
 
     function flushEncoderCache()
@@ -8023,7 +8286,7 @@
             {
                 constant = _String$1(constant);
                 if (!/^[$A-Z_a-z][$\w]*$/.test(constant))
-                    throw new _SyntaxError('Invalid identifier ' + _JSON_stringify$1(constant));
+                    throw _SyntaxError('Invalid identifier ' + _JSON_stringify$1(constant));
                 if (!encoder.hasOwnProperty('constantDefinitions'))
                     encoder.constantDefinitions = _Object_create$1(CONSTANTS);
                 var entries = [define(esToString$1(definition))];
@@ -8099,8 +8362,8 @@
                     ENTRIES[name + ':available'] = entries.available;
                 }
 
-                exposeEntries('FORMAT_MAPPER_LONG',               FORMAT_MAPPER_LONG);
-                exposeEntries('FORMAT_MAPPER_SHORT',              FORMAT_MAPPER_SHORT);
+                exposeEntries('FORMAT_MAPPER_LONG',                 FORMAT_MAPPER_LONG);
+                exposeEntries('FORMAT_MAPPER_SHORT',                FORMAT_MAPPER_SHORT);
                 exposeEntries('FROM_CHAR_CODE',                     FROM_CHAR_CODE);
                 exposeEntries('FROM_CHAR_CODE_CALLBACK_FORMATTER',  FROM_CHAR_CODE_CALLBACK_FORMATTER);
                 exposeEntries('OPTIMAL_B',                          OPTIMAL_B);