jscrewit 3.0.0 → 3.2.0

package/lib/jscrewit.js

@@ -1,4 +1,4 @@
-// JScrewIt 3.0.0 – https://jscrew.it
+// JScrewIt 3.2.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,7 +576,7 @@
         }
         function validateMask(mask) {
             if (!isMaskCompatible(mask))
-                throw new _Error('Incompatible features');
+                throw _Error('Incompatible features');
         }
         var utilInspect;
         try {
@@ -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(); };
@@ -1076,16 +1076,6 @@
             includes: ['NO_IE_SRC', 'NO_V8_SRC'],
             excludes: ['NO_FF_SRC'],
         },
-        FILL:
-        {
-            description: 'Existence of the native function Array.prototype.fill.',
-            check:
-            function ()
-            {
-                var available = Array.prototype.fill;
-                return available;
-            },
-        },
         FLAT:
         {
             description: 'Existence of the native function Array.prototype.flat.',
@@ -1298,6 +1288,16 @@
                 return available;
             },
         },
+        RUSSIAN_INFINITY:
+        {
+            description: 'Russian string representation of Infinity as "∞".',
+            check:
+            function ()
+            {
+                var available = Infinity.toLocaleString('ru') === '∞';
+                return available;
+            },
+        },
         SELF:
         {
             description:
@@ -1381,7 +1381,6 @@
                 'BARPROP',
                 'DOCUMENT',
                 'ESC_HTML_QUOT',
-                'FILL',
                 'FLAT',
                 'FROM_CODE_POINT',
                 'FUNCTION_19_LF',
@@ -1392,6 +1391,7 @@
                 'NAME',
                 'NO_IE_SRC',
                 'REGEXP_STRING_ITERATOR',
+                'RUSSIAN_INFINITY',
                 'STATUS',
                 'WINDOW',
             ],
@@ -1424,7 +1424,6 @@
                 'BARPROP',
                 'DOCUMENT',
                 'ESC_HTML_QUOT',
-                'FILL',
                 'FLAT',
                 'FROM_CODE_POINT',
                 'FUNCTION_19_LF',
@@ -1435,6 +1434,7 @@
                 'LOCALE_NUMERALS_EXT',
                 'NAME',
                 'REGEXP_STRING_ITERATOR',
+                'RUSSIAN_INFINITY',
                 'STATUS',
                 'V8_SRC',
                 'WINDOW',
@@ -1475,7 +1475,6 @@
                 'DOCUMENT',
                 'ESC_HTML_QUOT',
                 'FF_SRC',
-                'FILL',
                 'FLAT',
                 'FROM_CODE_POINT',
                 'FUNCTION_19_LF',
@@ -1486,6 +1485,7 @@
                 'NAME',
                 'OBJECT_ARRAY_ENTRIES_CTOR',
                 'REGEXP_STRING_ITERATOR',
+                'RUSSIAN_INFINITY',
                 'SHORT_LOCALES',
                 'STATUS',
                 'WINDOW',
@@ -1529,6 +1529,14 @@
             ],
             attributes: { 'char-increment-restriction': null, 'web-worker-restriction': null },
         },
+        IE_11_WIN_8:
+        {
+            inherits:               'IE_11',
+            versions:               ['11'],
+            compatibilityTag:       'on Windows 8',
+            compatibilityShortTag:  'W8',
+            includes:               { RUSSIAN_INFINITY: true },
+        },
         IE_11_WIN_10:
         {
             inherits:               'IE_11',
@@ -1540,6 +1548,7 @@
                 LOCALE_INFINITY:        true,
                 LOCALE_NUMERALS_BN:     true,
                 LOCALE_NUMERALS_EXT:    true,
+                RUSSIAN_INFINITY:       true,
             },
         },
         NODE_20:
@@ -1552,7 +1561,6 @@
                 'ARROW',
                 'AT',
                 'ESC_HTML_QUOT',
-                'FILL',
                 'FLAT',
                 'FROM_CODE_POINT',
                 'FUNCTION_19_LF',
@@ -1563,6 +1571,7 @@
                 'NAME',
                 'OBJECT_ARRAY_ENTRIES_CTOR',
                 'REGEXP_STRING_ITERATOR',
+                'RUSSIAN_INFINITY',
                 'SHORT_LOCALES',
                 'V8_SRC',
             ],
@@ -1598,7 +1607,6 @@
                 'DOCUMENT',
                 'ESC_HTML_QUOT',
                 'FF_SRC',
-                'FILL',
                 'FLAT',
                 'FROM_CODE_POINT',
                 'FUNCTION_19_LF',
@@ -1609,6 +1617,7 @@
                 'NAME',
                 'OBJECT_ARRAY_ENTRIES_CTOR',
                 'REGEXP_STRING_ITERATOR',
+                'RUSSIAN_INFINITY',
                 'SHORT_LOCALES',
                 'STATUS',
                 'WINDOW',
@@ -2249,10 +2258,10 @@
 
     var SIMPLE = createEmpty();
 
+    var FORMAT_MAPPER_LONG;
+    var FORMAT_MAPPER_SHORT;
     var FROM_CHAR_CODE;
     var FROM_CHAR_CODE_CALLBACK_FORMATTER;
-    var MAPPER_FORMATTER;
-    var OPTIMAL_ARG_NAME;
     var OPTIMAL_B;
     var OPTIMAL_RETURN_STRING;
 
@@ -2274,12 +2283,6 @@
     var FB_R_PADDING_SHIFTS;
     var FH_R_PADDING_SHIFTS;
 
-    function chooseOtherArgName(argName)
-    {
-        var otherArgName = argName !== 'undefined' ? 'undefined' : 'falsefalse';
-        return otherArgName;
-    }
-
     function createCharDefinitionInFn(expr, index, paddingEntries)
     {
         function charDefinitionInFn(char)
@@ -2570,7 +2573,6 @@
         var DOCUMENT                        = Feature.DOCUMENT;
         var ESC_HTML_QUOT                   = Feature.ESC_HTML_QUOT;
         var FF_SRC                          = Feature.FF_SRC;
-        var FILL                            = Feature.FILL;
         var FLAT                            = Feature.FLAT;
         var FROM_CODE_POINT                 = Feature.FROM_CODE_POINT;
         var FUNCTION_19_LF                  = Feature.FUNCTION_19_LF;
@@ -2589,6 +2591,7 @@
         var OBJECT_W_SELF                   = Feature.OBJECT_W_SELF;
         var PLAIN_INTL                      = Feature.PLAIN_INTL;
         var REGEXP_STRING_ITERATOR          = Feature.REGEXP_STRING_ITERATOR;
+        var RUSSIAN_INFINITY                = Feature.RUSSIAN_INFINITY;
         var SELF                            = Feature.SELF;
         var SHORT_LOCALES                   = Feature.SHORT_LOCALES;
         var STATUS                          = Feature.STATUS;
@@ -2889,9 +2892,6 @@
                 define('(RP_1_WA + FILTER)[20]', V8_SRC),
                 define('(RP_1_WA + AT)[20]', AT, NO_V8_SRC),
                 define('(RP_5_A + AT)[20]', AT, V8_SRC),
-                define('(+(RP_0_S + FILL)[0] + FILL)[20]', FILL, NO_FF_SRC),
-                define('(RP_5_A + FILL)[20]', FILL, NO_IE_SRC),
-                define('(RP_0_S + FILL)[20]', FILL, NO_V8_SRC),
                 define('(+(RP_0_S + FLAT)[0] + FLAT)[20]', FLAT, NO_FF_SRC),
                 define('(RP_5_A + FLAT)[20]', FLAT, NO_IE_SRC),
                 define('(RP_0_S + FLAT)[20]', FLAT, NO_V8_SRC),
@@ -2910,7 +2910,6 @@
             [
                 define('escape(FILTER)[20]'),
                 define('escape(0 + AT)[20]', AT),
-                define('escape(FILL)[21]', FILL),
                 define('escape(FLAT)[21]', FLAT),
                 define('escape(ANY_FUNCTION)[0]', IE_SRC),
                 defineCharDefault(),
@@ -2934,7 +2933,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]',
@@ -2996,12 +2995,9 @@
                 define('escape("}")[2]'),
                 define('escape((RP_4_A + [+("1000" + (AT + 0)[31] + 0)] + AT)[40])[2]', AT), // *
                 define // *
-                ('escape((NaN + [+("10" + [(RP_6_S + FILL)[40]] + "000")] + FILL)[40])[2]', FILL),
-                define // *
                 ('escape((NaN + [+("10" + [(RP_6_S + FLAT)[40]] + "000")] + FLAT)[40])[2]', FLAT),
                 define('escape(FILTER)[50]', V8_SRC),
                 define('escape([[]][+(RP_0_S + AT)[0]] + AT)[61]', AT, NO_FF_SRC), // *
-                define('escape(FILL)[60]', FF_SRC, FILL),
             ],
             'E':
             [
@@ -3305,6 +3301,7 @@
                 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]("ru")', RUSSIAN_INFINITY),
                 defineCharDefault(),
             ],
         });
@@ -3317,7 +3314,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")'),
         });
 
@@ -3397,7 +3394,6 @@
             [
                 define('FILTER'),
                 define('AT', AT),
-                define('FILL', FILL),
                 define('FLAT', FLAT),
             ],
             ARRAY_ITERATOR:
@@ -3408,14 +3404,11 @@
             [
                 define('[].at', AT),
             ],
-            FILL:
-            [
-                define('[].fill', FILL),
-            ],
-            FILTER:
+            CONCAT:
             [
-                define('[].filter'),
+                define({ expr: '"concat"', solutionType: SolutionType.COMBINED_STRING }),
             ],
+            FILTER:     '[].filter',
             FLAT:
             [
                 define('[].flat', FLAT),
@@ -3424,11 +3417,19 @@
             [
                 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),
             ],
+            MAP:
+            [
+                define({ expr: '"map"', optimize: true, solutionType: SolutionType.COMBINED_STRING }),
+            ],
             PLAIN_OBJECT:
             [
                 define('Function("return{}")()'),
@@ -3447,6 +3448,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
@@ -3485,11 +3490,9 @@
             [
                 define('[[true][+(RP_3_WA + FILTER)[30]]]'),
                 define('[[true][+(RP_1_WA + AT)[30]]]', AT),
-                define('[[true][+(RP_5_A + FILL)[30]]]', FILL),
                 define('[[true][+(RP_5_A + FLAT)[30]]]', FLAT),
                 define('[[true][+!!++(RP_0_S + FILTER)[20]]]', INCR_CHAR),
                 define('[[true][+!!++(RP_1_WA + AT)[20]]]', AT, INCR_CHAR),
-                define('[[true][+!!++(RP_0_S + FILL)[20]]]', FILL, INCR_CHAR),
                 define('[[true][+!!++(RP_0_S + FLAT)[20]]]', FLAT, INCR_CHAR),
             ],
             FBEP_9_U:
@@ -3499,8 +3502,6 @@
                 define
                 ({ expr: '[false][+(RP_1_WA + AT)[20]]', solutionType: SolutionType.UNDEFINED }, AT),
                 define
-                ({ expr: '[false][+(RP_0_S + FILL)[20]]', solutionType: SolutionType.UNDEFINED }, FILL),
-                define
                 ({ expr: '[false][+(RP_0_S + FLAT)[20]]', solutionType: SolutionType.UNDEFINED }, FLAT),
             ],
             FBEP_10_S:
@@ -3536,14 +3537,6 @@
                     AT
                 ),
                 define
-                (
-                    {
-                        expr:           '+("10" + [(RP_6_S + FILL)[40]] + "00000")',
-                        solutionType:   SolutionType.WEAK_ALGEBRAIC,
-                    },
-                    FILL
-                ),
-                define
                 (
                     {
                         expr:           '+("10" + [(RP_6_S + FLAT)[40]] + "00000")',
@@ -3570,14 +3563,6 @@
                     AT
                 ),
                 define
-                (
-                    {
-                        expr:           '+("1000" + (FILL + 0)[33] + "000")',
-                        solutionType:   SolutionType.WEAK_ALGEBRAIC,
-                    },
-                    FILL
-                ),
-                define
                 (
                     {
                         expr:           '+("1000" + (FLAT + 0)[33] + "000")',
@@ -3692,6 +3677,108 @@
 
         FH_R_PADDING_SHIFTS = [define(1, IE_SRC), define(0, NO_IE_SRC)];
 
+        FORMAT_MAPPER_LONG =
+        defineList
+        (
+            [
+                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(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(2),
+            ]
+        );
+
+        FORMAT_MAPPER_SHORT =
+        defineList
+        (
+            [
+                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 =
         defineList
         (
@@ -3700,30 +3787,37 @@
                 define(0),
                 define(1),
                 define(0, ITERATOR_HELPER),
-                define(1, FILL),
-                define(0, ARRAY_ITERATOR, CAPITAL_HTML, FROM_CODE_POINT),
-                define(1, FLAT, ITERATOR_HELPER),
-                define(0, FILL, FROM_CODE_POINT, ITERATOR_HELPER, NAME),
+                define(0, ARRAY_ITERATOR, CAPITAL_HTML),
                 define(1, ARRAY_ITERATOR, ITERATOR_HELPER),
+                define(1, AT, ITERATOR_HELPER),
+                define(1, BARPROP, ITERATOR_HELPER),
+                define(1, CAPITAL_HTML, ITERATOR_HELPER),
+                define(1, FLAT, ITERATOR_HELPER),
                 define(1, IE_SRC, ITERATOR_HELPER),
                 define(1, ITERATOR_HELPER, NO_IE_SRC),
-                define(1, FILL, FLAT, ITERATOR_HELPER, NAME),
-                define(0, ARRAY_ITERATOR, FILL, FROM_CODE_POINT, ITERATOR_HELPER),
                 define(0, ARRAY_ITERATOR, FLAT, FROM_CODE_POINT, ITERATOR_HELPER),
                 define(0, ARRAY_ITERATOR, FROM_CODE_POINT, IE_SRC, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, BARPROP, IE_SRC, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC, ITERATOR_HELPER),
                 define(0, ARRAY_ITERATOR, FROM_CODE_POINT, ITERATOR_HELPER, NO_IE_SRC),
-                define(1, ARRAY_ITERATOR, FILL, ITERATOR_HELPER, NO_IE_SRC),
-                define(1, ARRAY_ITERATOR, FILL, ITERATOR_HELPER, NO_V8_SRC),
-                define(1, ARRAY_ITERATOR, FLAT, ITERATOR_HELPER, NO_IE_SRC),
-                define(1, ARRAY_ITERATOR, FLAT, ITERATOR_HELPER, NO_V8_SRC),
+                define(1, ARRAY_ITERATOR, AT, FLAT, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, AT, IE_SRC, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, AT, ITERATOR_HELPER, NO_IE_SRC),
+                define(1, ARRAY_ITERATOR, BARPROP, FLAT, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, BARPROP, ITERATOR_HELPER, NO_IE_SRC),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FLAT, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML, ITERATOR_HELPER, NO_IE_SRC),
                 define(0, ARRAY_ITERATOR, FROM_CODE_POINT, ITERATOR_HELPER, NAME),
-                define(1, AT, ITERATOR_HELPER),
-                define(1, BARPROP, ITERATOR_HELPER),
-                define(1, CAPITAL_HTML, ITERATOR_HELPER),
-                define(1, ARRAY_ITERATOR, FILL, IE_SRC, ITERATOR_HELPER, NAME),
-                define(1, ARRAY_ITERATOR, FILL, ITERATOR_HELPER, NAME, NO_IE_SRC),
-                define(1, ARRAY_ITERATOR, FLAT, IE_SRC, ITERATOR_HELPER, NAME),
-                define(1, ARRAY_ITERATOR, FLAT, ITERATOR_HELPER, NAME, NO_IE_SRC),
+                define(1, ARRAY_ITERATOR, AT, ITERATOR_HELPER, NAME),
+                define(1, ARRAY_ITERATOR, BARPROP, ITERATOR_HELPER, NAME),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML, ITERATOR_HELPER, NAME),
+                define(1, ARRAY_ITERATOR, FLAT, ITERATOR_HELPER, NO_V8_SRC),
+                define(0, ARRAY_ITERATOR, FLAT, FROM_CODE_POINT, ITERATOR_HELPER, NAME, NO_V8_SRC),
+                define(1, ARRAY_ITERATOR, FLAT, IE_SRC, ITERATOR_HELPER),
+                define(1, ARRAY_ITERATOR, FLAT, ITERATOR_HELPER, NO_IE_SRC),
+                define(1, ARRAY_ITERATOR, AT, FLAT, ITERATOR_HELPER, NO_V8_SRC),
+                define(1, ARRAY_ITERATOR, BARPROP, FLAT, ITERATOR_HELPER, NO_V8_SRC),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FLAT, ITERATOR_HELPER, NO_V8_SRC),
             ]
         );
 
@@ -3799,8 +3893,6 @@
                 define(0, ARRAY_ITERATOR, CAPITAL_HTML, NO_V8_SRC),
                 define(1, ARRAY_ITERATOR, AT, CAPITAL_HTML),
                 define(1, ARRAY_ITERATOR, CAPITAL_HTML, FF_SRC, FLAT),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FILL, IE_SRC),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FILL, NO_IE_SRC),
                 define(1, ARRAY_ITERATOR, CAPITAL_HTML, FLAT, IE_SRC),
                 define(2, ARRAY_ITERATOR, CAPITAL_HTML),
                 define(3, ARRAY_ITERATOR, AT, CAPITAL_HTML, IE_SRC),
@@ -3810,82 +3902,13 @@
             ]
         );
 
-        MAPPER_FORMATTER =
-        defineList
-        (
-            [
-                define
-                (
-                    function (argName, accessor)
-                    {
-                        var otherArgName = chooseOtherArgName(argName);
-                        var mapper =
-                        'Function("return function(' + otherArgName + '){return function(' + argName +
-                        '){return ' + otherArgName + accessor + '}}")()';
-                        return mapper;
-                    }
-                ),
-                define
-                (
-                    function (argName, accessor)
-                    {
-                        var mapper =
-                        'Function("return function(' + argName + '){return this' + accessor +
-                        '}")().bind';
-                        return mapper;
-                    }
-                ),
-                define
-                (
-                    function (argName, accessor)
-                    {
-                        var otherArgName = chooseOtherArgName(argName);
-                        var mapper =
-                        'Function("return ' + otherArgName + '=>' + argName + '=>' + otherArgName +
-                        accessor + '")()';
-                        return mapper;
-                    },
-                    ARROW
-                ),
-            ],
-            [
-                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, FILL),
-                define(0, ARRAY_ITERATOR, FLAT),
-                define(0, ARRAY_ITERATOR, NO_IE_SRC),
-                define(0, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC),
-                define(2),
-            ]
-        );
-
         NATIVE_FUNCTION_INFOS =
         [
             define({ expr: 'FILTER', shift: 6 }),
-            define({ expr: 'FILL', shift: 4 }, FILL),
             define({ expr: 'FLAT', shift: 4 }, FLAT),
             define({ expr: 'AT', shift: 2 }, AT),
         ];
 
-        OPTIMAL_ARG_NAME =
-        defineList
-        (
-            [define('f'), define('undefined')],
-            [
-                define(0),
-                define(1, AT),
-                define(0, FLAT),
-                define(1, FILL, IE_SRC),
-                define(1, FILL, NO_IE_SRC),
-                define(0, FILL, FLAT, IE_SRC),
-                define(0, FILL, FLAT, NO_IE_SRC),
-            ]
-        );
-
         OPTIMAL_B = defineList([define('B'), define('b')], [define(0), define(1, ARRAY_ITERATOR)]);
 
         OPTIMAL_RETURN_STRING =
@@ -3903,8 +3926,6 @@
                 define(0, ARRAY_ITERATOR, CAPITAL_HTML, NO_V8_SRC),
                 define(1, ARRAY_ITERATOR, AT, CAPITAL_HTML),
                 define(1, ARRAY_ITERATOR, CAPITAL_HTML, FF_SRC, FLAT),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FILL, IE_SRC),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML, FILL, NO_IE_SRC),
                 define(1, ARRAY_ITERATOR, CAPITAL_HTML, FLAT, IE_SRC),
                 define(2),
             ]
@@ -4454,7 +4475,7 @@
 
     var tokenCache = createEmpty();
 
-    // Reserved words and that cannot be written with escape sequences.
+    // Reserved words that cannot be written with escape sequences.
     var INESCAPABLE_WORDS = ['false', 'null', 'true'];
 
     // This list includes reserved words and identifiers that would cause a change in a script's
@@ -4970,7 +4991,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;
             }
@@ -5189,7 +5210,7 @@
         var stackLength = stack.length;
         if (stackLength)
             message += ' in the definition of ' + stack[stackLength - 1];
-        throw new _SyntaxError(message);
+        throw _SyntaxError(message);
     }
 
     var matchSimpleAt =
@@ -5284,6 +5305,8 @@
                 throwSyntaxError(this, 'Undefined regular padding block with length ' + length);
             },
 
+            _guardResolution:       noop,
+
             _replaceCharByAtob:     replaceCharByAtob,
 
             _replaceCharByCharCode: replaceCharByCharCode,
@@ -5492,11 +5515,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;)
                 {
@@ -5559,15 +5580,17 @@
                 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)
@@ -5602,6 +5625,7 @@
                             var entries = this.constantDefinitions[constant];
                             if (_Array_isArray$1(entries))
                             {
+                                this._guardResolution(constant);
                                 solution =
                                 findOptimalSolution(this, constant, entries, SolutionType.OBJECT);
                             }
@@ -5620,6 +5644,12 @@
         }
     );
 
+    STATIC_ENCODER._guardResolution =
+    function (name)
+    {
+        throw _Error$1('Unable to resolve ' + name + ' statically');
+    };
+
     initStaticEncoder(STATIC_ENCODER);
 
     function createFigurator(startValues, joiner)
@@ -5743,6 +5773,268 @@
         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.
+     *
+     * @typedef Delimiter
+     *
+     * @property {string} separator
+     * An express-parsable expression used as an argument for `String.prototype.split` to split a string
+     * into an array of strings.
+     *
+     * @property {string} joiner
+     * The joiner can be any string. A joiner is inserted between adjacent strings in an array in order
+     * 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);
+        var options = { maxLength: maxLength, screwMode: SCREW_AS_BONDED_STRING };
+        var replacement = replaceStaticString(str, options);
+        return replacement;
+    }
+
+    /**
+     * Replaces a given array of statically replaceable strings with equivalent JSFuck code.
+     *
+     * @function Encoder#replaceStringArray
+     *
+     * @param {string[]} array
+     * The string array to replace. Empty arrays are not supported.
+     *
+     * @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. 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
+     * its elements.
+     *
+     * @param {Delimiter[]|null} [substitutions]
+     * An array of delimiters, specifying substitutions to be applied to the input elements.
+     *
+     * All substitutions are applied on each element of the input array, in the order they are
+     * specified.
+     *
+     * Substitutions are expensive in two ways: they create additional overhead and prevent certain
+     * optimizations for short arrays to be made. To allow all optimizations to be performed, omit this
+     * argument or set it to null instead of specifying an empty array.
+     *
+     * @param {boolean} [allowZeroForEmptyElements=false]
+     * Indicates whether empty string elements in the input array may be replaced with zeros.
+     *
+     * @param {boolean} [forceString=false]
+     * Indicates whether the elements in the replacement expression should evaluate to strings.
+     *
+     * If this argument is falsy, the elements in the replacement expression may not be equal to those
+     * in the input array, but will have the same string representation.
+     *
+     * Regardless of this argument, the string representation of the value of the whole replacement
+     * expression will be always the same as the string representation of the input array after applying
+     * substitutions (including optional empty string to zero replacements) to its elements.
+     *
+     * @param {number} [maxLength=(NaN)]
+     * The maximum length of the replacement expression.
+     *
+     * If the replacement expression exceeds the specified length, the return value is `undefined`.
+     *
+     * If this parameter is `NaN`, then no length limit is imposed.
+     *
+     * @returns {string|undefined}
+     * The replacement string or `undefined`.
+     */
+    function replaceStringArray
+    (array, insertions, substitutions, allowZeroForEmptyElements, forceString, maxLength)
+    {
+        var replacement;
+        var count = array.length;
+        // Don't even try the split approach for two or less elements if the concat approach can be
+        // applied.
+        if (substitutions || count > 2)
+        {
+            var splitReplacement = this.resolveConstant('SPLIT').replacement;
+            var minSubstitutionsReplacementLength =
+            maxLength -
+            SEQUENCE_MIN_LENGTH -
+            splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD;
+            var substitutionsReplacement =
+            createSubstitutionsReplacement(this, substitutions, minSubstitutionsReplacementLength);
+        }
+        if (substitutionsReplacement != null)
+        // Approach 1: (array[0] + joiner + array[1] + joiner + array[2]...).split(separator)
+        {
+            var maxBulkLength =
+            maxLength - substitutionsReplacement.length - splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD + SEPARATOR_MIN_LENGTH;
+            var optimalSeqReplacement;
+            var optimalSeparatorReplacement;
+            insertions.forEach
+            (
+                function (insertion)
+                {
+                    var seqReplacement =
+                    replaceJoinedArrayString(array, insertion.joiner, maxBulkLength);
+                    if (!seqReplacement)
+                        return;
+                    var separatorReplacement = undefinedAsString(this.replaceExpr(insertion.separator));
+                    var bulkLength = seqReplacement.length + separatorReplacement.length;
+                    if (!(bulkLength > maxBulkLength))
+                    {
+                        maxBulkLength = bulkLength;
+                        optimalSeqReplacement = seqReplacement;
+                        optimalSeparatorReplacement = separatorReplacement;
+                    }
+                },
+                this
+            );
+            if (optimalSeqReplacement)
+            {
+                replacement =
+                optimalSeqReplacement + substitutionsReplacement + '[' + splitReplacement + '](' +
+                optimalSeparatorReplacement + ')';
+                maxLength = replacement.length - 1;
+            }
+        }
+        if (!substitutions)
+        // Approach 2: [array[0]].concat(array[1]).concat(array[2])...
+        {
+            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';
@@ -5750,6 +6042,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:
@@ -5829,7 +6127,7 @@
     }
 
     function createCharKeyArrayString
-    (encoder, input, charMap, insertions, substitutions, forceString, maxLength)
+    (encoder, input, charMap, insertions, substitutions, areKeysFigures, maxLength)
     {
         var charKeyArray =
         _Array_prototype_map_call
@@ -5842,27 +6140,67 @@
             }
         );
         var charKeyArrayStr =
-        encoder.replaceStringArray(charKeyArray, insertions, substitutions, forceString, maxLength);
+        encoder.replaceStringArray
+        (charKeyArray, insertions, substitutions, !areKeysFigures, areKeysFigures, maxLength);
         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)
@@ -5930,41 +6268,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;
         }
     }
 
@@ -6023,15 +6378,21 @@
         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
-        (figures, figureLegendInsertions, null, true, figureMaxLength - minCharIndexArrayStrLength);
+        (
+            figures,
+            figureLegendInsertions,
+            null,
+            false,
+            true,
+            figureMaxLength - minCharIndexArrayStrLength
+        );
         if (!figureLegend)
             return;
-        var keyFigureArrayStr =
+        var charIndexFigureArrayStr =
         createCharKeyArrayString
         (
             encoder,
@@ -6042,15 +6403,12 @@
             true,
             figureMaxLength - figureLegend.length
         );
-        if (!keyFigureArrayStr)
+        if (!charIndexFigureArrayStr)
             return;
-        var formatter = encoder.findDefinition(MAPPER_FORMATTER);
-        var argName = 'undefined';
-        var accessor = '.indexOf(' + argName + ')';
-        var mapper = formatter(argName, accessor);
-        var charIndexArrayStr =
-        createJSFuckArrayMapping(encoder, keyFigureArrayStr, mapper, figureLegend);
-        var output = encoder.createDictEncoding(legend, charIndexArrayStr, maxLength);
+        var formatMapper = encoder._findFormatMapperShort();
+        var output =
+        encoder._createDblDictEncoding
+        (formatMapper, charIndexFigureArrayStr, figureLegend, legend, maxLength);
         return output;
     }
 
@@ -6186,13 +6544,6 @@
         return strCodes;
     }
 
-    function undefinedAsString(replacement)
-    {
-        if (replacement === '[][[]]')
-            replacement += '+[]';
-        return replacement;
-    }
-
     function wrapWithCall(str)
     {
         var output = this.resolveConstant('Function').replacement + '(' + str + ')()';
@@ -6342,15 +6693,15 @@
 
             /* -------------------------------------------------------------------------------------- *\
 
-            Encodes "NINE" as:
+            Encodes "FIFTY" as:
 
-            "false2falsefalse1".split(false).map("".charAt.bind("NEI")).join([])
+            "false1falsefalse2false3".split(false).map("".charAt.bind("FITY")).join([])
 
             (split strategy)
 
             Or:
 
-            [0].concat(2).concat(0).concat(1).map("".charAt.bind("NEI")).join([])
+            [[]].concat(1).concat(0).concat(2).concat(3).map("".charAt.bind("FITY")).join([])
 
             (concat strategy)
 
@@ -6565,7 +6916,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                193
+                194
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6620,7 +6971,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                347
+                173
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6710,11 +7061,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:
@@ -6811,7 +7202,7 @@
                 if (!charIndexArrayStr)
                     return;
                 var output =
-                this.createDictEncoding(legend, charIndexArrayStr, maxLength, radix, coerceToInt);
+                this._createDictEncoding(charIndexArrayStr, legend, radix, coerceToInt, maxLength);
                 return output;
             },
 
@@ -6859,265 +7250,36 @@
                     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.
-
-            createDictEncoding:
-            function (legend, charIndexArrayStr, maxLength, radix, coerceToInt)
-            {
-                var mapper;
-                if (radix)
-                {
-                    var formatter = this.findDefinition(MAPPER_FORMATTER);
-                    var argName = this.findDefinition(OPTIMAL_ARG_NAME);
-                    var parseIntArg = (coerceToInt ? '+' : '') + argName;
-                    var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
-                    mapper = formatter(argName, accessor);
-                }
-                else
-                    mapper = '"".charAt.bind';
-                var output =
-                createJSFuckArrayMapping(this, charIndexArrayStr, mapper, legend) + '[' +
-                this.replaceString('join') + ']([])';
-                if (!(output.length > maxLength))
-                    return output;
-            },
-
-            // 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)
+            _findFormatMapperShort:
+            function ()
             {
-                var result =
-                this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, maxLength);
-                return result;
+                var formatMapper = this.findDefinition(FORMAT_MAPPER_SHORT);
+                return formatMapper;
             },
 
-            replaceJoinedArrayString:
-            function (str, maxLength)
+            _joinCharArray:
+            function (charArrayReplacement, maxLength)
             {
-                var options = { maxLength: maxLength, screwMode: SCREW_AS_BONDED_STRING };
-                var replacement = replaceStaticString(str, options);
+                var joinReplacement = this.resolveConstant('JOIN').replacement;
+                var replacement =
+                joinWithMaxLength(maxLength, charArrayReplacement, '[', joinReplacement, ']([])');
                 return replacement;
             },
 
-            /**
-             * An object that exposes properties used to split a string into an array of strings or to
-             * join array elements into a string.
-             *
-             * @typedef Delimiter
-             *
-             * @property {string} separator
-             * An express-parsable expression used as an argument for `String.prototype.split` to split
-             * a string into an array of strings.
-             *
-             * @property {number} joiner
-             * The joiner can be any string. A joiner is inserted between adjacent strings in an array
-             * in order to join them into a single string.
-             */
+            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
 
-            /**
-             * Replaces a given array of strings with equivalent JSFuck code.
-             *
-             * Array elements may only contain characters with static definitions in their string
-             * representations.
-             *
-             * @function Encoder#replaceStringArray
-             *
-             * @param {string[]} array
-             * The string array to replace. Empty arrays are not supported.
-             *
-             * @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.
-             *
-             * 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 its elements.
-             *
-             * @param {Delimiter[]|null} [substitutions]
-             * An array of delimiters, specifying substitutions to be applied to the input elements.
-             *
-             * All substitutions are applied on each element of the input array, in the order they are
-             * specified.
-             *
-             * Substitutions are expensive in two ways: they create additional overhead and prevent
-             * certain optimizations for short arrays to be made. To allow all optimizations to be
-             * performed, omit this argument or set it to null instead of specifying an empty array.
-             *
-             * @param {boolean} [forceString=false]
-             * Indicates whether the elements in the replacement expression should evaluate to strings.
-             *
-             * If this argument is falsy, the elements in the replacement expression may not be equal to
-             * those in the input array, but will have the same string representation.
-             *
-             * Regardless of this argument, the string representation of the value of the whole
-             * replacement expression will be always the same as the string representation of the input
-             * array.
-             *
-             * @param {number} [maxLength=(NaN)]
-             * The maximum length of the replacement expression.
-             *
-             * If the replacement expression exceeds the specified length, the return value is
-             * `undefined`.
-             *
-             * If this parameter is `NaN`, then no length limit is imposed.
-             *
-             * @returns {string|undefined}
-             * The replacement string or `undefined`.
-             */
-            replaceStringArray:
-            function (array, insertions, substitutions, forceString, maxLength)
-            {
-                var replacement;
-                var count = array.length;
-                // Don't even try the split approach for 3 or less elements if the concat approach can
-                // be applied.
-                if (substitutions || count > 3)
-                {
-                    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);
-                }
-                if (!substitutions && count > 1)
-                {
-                    var concatReplacement =
-                    this.replaceString('concat', { maxLength: maxLength, optimize: true });
-                }
-                if (preReplacement)
-                // 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 optimalSeparatorReplacement;
-                    insertions.forEach
-                    (
-                        function (insertion)
-                        {
-                            var str = array.join(insertion.joiner);
-                            var strReplacement = this.replaceJoinedArrayString(str, maxBulkLength);
-                            if (!strReplacement)
-                                return;
-                            var separatorReplacement =
-                            undefinedAsString(this.replaceExpr(insertion.separator));
-                            var bulkLength = strReplacement.length + separatorReplacement.length;
-                            if (!(bulkLength > maxBulkLength))
-                            {
-                                maxBulkLength = bulkLength;
-                                optimalStrReplacement = strReplacement;
-                                optimalSeparatorReplacement = separatorReplacement;
-                            }
-                        },
-                        this
-                    );
-                    if (optimalStrReplacement)
-                    {
-                        replacement =
-                        optimalStrReplacement + preReplacement + '(' + 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)
-                    )
-                )
-                // 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 = '[[]]';
-                                    arrayReplacement +=
-                                    '[' + concatReplacement + '](' + elementReplacement + ')';
-                                }
-                                else
-                                    arrayReplacement = '[' + elementReplacement + ']';
-                                var result = arrayReplacement.length > maxLength;
-                                return result;
-                            }
-                        )
-                    )
-                        replacement = arrayReplacement;
-                }
-                return replacement;
+            _replaceMapper:
+            function (mapper)
+            {
+                var mapperReplacement = this.replaceExpr(mapper, true);
+                return mapperReplacement;
             },
+
+            replaceStringArray: replaceStringArray,
         }
     );
 
@@ -7860,7 +8022,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()
@@ -8011,7 +8173,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))];
@@ -8087,10 +8249,10 @@
                     ENTRIES[name + ':available'] = entries.available;
                 }
 
+                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('MAPPER_FORMATTER',                   MAPPER_FORMATTER);
-                exposeEntries('OPTIMAL_ARG_NAME',                   OPTIMAL_ARG_NAME);
                 exposeEntries('OPTIMAL_B',                          OPTIMAL_B);
                 exposeEntries('OPTIMAL_RETURN_STRING',              OPTIMAL_RETURN_STRING);
             }