jscrewit 3.0.0 → 3.1.0

package/lib/jscrewit.js

@@ -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(),
@@ -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(),
             ],
         });
@@ -3397,7 +3394,6 @@
             [
                 define('FILTER'),
                 define('AT', AT),
-                define('FILL', FILL),
                 define('FLAT', FLAT),
             ],
             ARRAY_ITERATOR:
@@ -3408,10 +3404,6 @@
             [
                 define('[].at', AT),
             ],
-            FILL:
-            [
-                define('[].fill', FILL),
-            ],
             FILTER:
             [
                 define('[].filter'),
@@ -3485,11 +3477,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 +3489,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 +3524,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 +3550,6 @@
                     AT
                 ),
                 define
-                (
-                    {
-                        expr:           '+("1000" + (FILL + 0)[33] + "000")',
-                        solutionType:   SolutionType.WEAK_ALGEBRAIC,
-                    },
-                    FILL
-                ),
-                define
                 (
                     {
                         expr:           '+("1000" + (FLAT + 0)[33] + "000")',
@@ -3692,6 +3664,104 @@
 
         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(0),
+                define(2, ARRAY_ITERATOR),
+                define(0, NO_FF_SRC),
+                define(0, NO_V8_SRC),
+                define(2, 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),
+            ]
+        );
+
+        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),
+            ]
+        );
+
         FROM_CHAR_CODE =
         defineList
         (
@@ -3700,30 +3770,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 +3876,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 +3885,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 +3909,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 +4458,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
@@ -5743,6 +5747,234 @@
         return figurator;
     }
 
+    /**
+     * 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 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;
+    }
+
+    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.
+     *
+     * @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} [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 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 strReplacement =
+                    replaceJoinedArrayString(array, insertion.joiner, 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 = allowZeroForEmptyElements ? '+[]' : '[[]]';
+                            arrayReplacement +=
+                            '[' + concatReplacement + '](' + elementReplacement + ')';
+                        }
+                        else
+                            arrayReplacement = '[' + elementReplacement + ']';
+                        var result = arrayReplacement.length > maxLength;
+                        return result;
+                    }
+                )
+            )
+                replacement = arrayReplacement;
+        }
+        return replacement;
+    }
+
     var ENCODING_TYPE_COMBINED      = 'combined';
     var ENCODING_TYPE_EXPRESSION    = 'expression';
     var ENCODING_TYPE_TEXT          = 'text';
@@ -5829,7 +6061,7 @@
     }
 
     function createCharKeyArrayString
-    (encoder, input, charMap, insertions, substitutions, forceString, maxLength)
+    (encoder, input, charMap, insertions, substitutions, areKeysFigures, maxLength)
     {
         var charKeyArray =
         _Array_prototype_map_call
@@ -5842,7 +6074,8 @@
             }
         );
         var charKeyArrayStr =
-        encoder.replaceStringArray(charKeyArray, insertions, substitutions, forceString, maxLength);
+        encoder.replaceStringArray
+        (charKeyArray, insertions, substitutions, !areKeysFigures, areKeysFigures, maxLength);
         return charKeyArrayStr;
     }
 
@@ -6028,10 +6261,17 @@
         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,14 +6282,14 @@
             true,
             figureMaxLength - figureLegend.length
         );
-        if (!keyFigureArrayStr)
+        if (!charIndexFigureArrayStr)
             return;
-        var formatter = encoder.findDefinition(MAPPER_FORMATTER);
-        var argName = 'undefined';
+        var formatMapper = encoder.findDefinition(FORMAT_MAPPER_SHORT);
+        var argName = formatMapper.argName;
         var accessor = '.indexOf(' + argName + ')';
-        var mapper = formatter(argName, accessor);
+        var mapper = formatMapper(accessor);
         var charIndexArrayStr =
-        createJSFuckArrayMapping(encoder, keyFigureArrayStr, mapper, figureLegend);
+        createJSFuckArrayMapping(encoder, charIndexFigureArrayStr, mapper, figureLegend);
         var output = encoder.createDictEncoding(legend, charIndexArrayStr, maxLength);
         return output;
     }
@@ -6186,13 +6426,6 @@
         return strCodes;
     }
 
-    function undefinedAsString(replacement)
-    {
-        if (replacement === '[][[]]')
-            replacement += '+[]';
-        return replacement;
-    }
-
     function wrapWithCall(str)
     {
         var output = this.resolveConstant('Function').replacement + '(' + str + ')()';
@@ -6342,15 +6575,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)
 
@@ -6863,7 +7096,7 @@
                 return output;
             },
 
-            _maxDecodableArgs: 65533, // Limit imposed by Internet Explorer.
+            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
 
             createDictEncoding:
             function (legend, charIndexArrayStr, maxLength, radix, coerceToInt)
@@ -6871,11 +7104,11 @@
                 var mapper;
                 if (radix)
                 {
-                    var formatter = this.findDefinition(MAPPER_FORMATTER);
-                    var argName = this.findDefinition(OPTIMAL_ARG_NAME);
+                    var formatMapper = this.findDefinition(FORMAT_MAPPER_LONG);
+                    var argName = formatMapper.argName;
                     var parseIntArg = (coerceToInt ? '+' : '') + argName;
                     var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
-                    mapper = formatter(argName, accessor);
+                    mapper = formatMapper(accessor);
                 }
                 else
                     mapper = '"".charAt.bind';
@@ -6892,232 +7125,11 @@
             function (array, maxLength)
             {
                 var result =
-                this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, maxLength);
+                this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, false, maxLength);
                 return result;
             },
 
-            replaceJoinedArrayString:
-            function (str, maxLength)
-            {
-                var options = { maxLength: maxLength, screwMode: SCREW_AS_BONDED_STRING };
-                var replacement = replaceStaticString(str, options);
-                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.
-             */
-
-            /**
-             * 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;
-            },
+            replaceStringArray: replaceStringArray,
         }
     );
 
@@ -8087,10 +8099,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);
             }