jscrewit 3.1.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(); };
@@ -2933,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]',
@@ -3314,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")'),
         });
 
@@ -3404,10 +3404,11 @@
             [
                 define('[].at', AT),
             ],
-            FILTER:
+            CONCAT:
             [
-                define('[].filter'),
+                define({ expr: '"concat"', solutionType: SolutionType.COMBINED_STRING }),
             ],
+            FILTER:     '[].filter',
             FLAT:
             [
                 define('[].flat', FLAT),
@@ -3416,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{}")()'),
@@ -3439,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
@@ -3664,102 +3677,106 @@
 
         FH_R_PADDING_SHIFTS = [define(1, IE_SRC), define(0, NO_IE_SRC)];
 
-        var FORMAT_MAPPER_ENTRIES =
-        [
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(falsefalse){return function(undefined){return ' +
-                        'falsefalse' + accessor + '}}")()';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(undefined){return this' + accessor + '}")().bind';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return function(f){return this' + accessor + '}")().bind';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'f';
-                    return formatMapper;
-                })()
-            ),
-            define
-            (
-                (function () {
-                    var formatMapper =
-                    function (accessor)
-                    {
-                        var mapper =
-                        'Function("return falsefalse=>undefined=>falsefalse' + accessor + '")()';
-                        return mapper;
-                    };
-                    formatMapper.argName = 'undefined';
-                    return formatMapper;
-                })(),
-                ARROW
-            ),
-        ];
-
         FORMAT_MAPPER_LONG =
         defineList
         (
-            FORMAT_MAPPER_ENTRIES,
+            [
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(falsefalse){return function(undefined){return ' +
+                            'falsefalse' + accessor + '}}")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'undefined';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(f){return this' + accessor + '}")().bind';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'f';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return falsefalse=>undefined=>falsefalse' + accessor + '")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'undefined';
+                        return formatMapper;
+                    })(),
+                    ARROW
+                ),
+            ],
             [
                 define(0),
-                define(2, ARRAY_ITERATOR),
+                define(1, ARRAY_ITERATOR),
                 define(0, NO_FF_SRC),
                 define(0, NO_V8_SRC),
-                define(2, ARRAY_ITERATOR, CAPITAL_HTML),
+                define(1, ARRAY_ITERATOR, CAPITAL_HTML),
                 define(0, ARRAY_ITERATOR, AT),
                 define(0, ARRAY_ITERATOR, FLAT),
                 define(0, ARRAY_ITERATOR, NO_IE_SRC),
                 define(0, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC),
-                define(3),
+                define(2),
             ]
         );
 
         FORMAT_MAPPER_SHORT =
         defineList
         (
-            FORMAT_MAPPER_ENTRIES,
             [
-                define(0),
-                define(1, ARRAY_ITERATOR),
-                define(0, NO_FF_SRC),
-                define(0, NO_V8_SRC),
-                define(1, ARRAY_ITERATOR, CAPITAL_HTML),
-                define(0, ARRAY_ITERATOR, AT),
-                define(0, ARRAY_ITERATOR, FLAT),
-                define(0, ARRAY_ITERATOR, NO_IE_SRC),
-                define(0, ARRAY_ITERATOR, CAPITAL_HTML, IE_SRC),
-                define(3),
-            ]
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return function(undefined){return function(falsefalse){return ' +
+                            'undefined[1][undefined[0]' + accessor + ']}}")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'falsefalse';
+                        return formatMapper;
+                    })()
+                ),
+                define
+                (
+                    (function () {
+                        var formatMapper =
+                        function (accessor)
+                        {
+                            var mapper =
+                            'Function("return undefined=>falsefalse=>undefined[1][undefined[0]' +
+                            accessor + ']")()';
+                            return mapper;
+                        };
+                        formatMapper.argName = 'falsefalse';
+                        return formatMapper;
+                    })(),
+                    ARROW
+                ),
+            ],
+            [define(0), define(1)]
         );
 
         FROM_CHAR_CODE =
@@ -4974,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;
             }
@@ -5193,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 =
@@ -5288,6 +5305,8 @@
                 throwSyntaxError(this, 'Undefined regular padding block with length ' + length);
             },
 
+            _guardResolution:       noop,
+
             _replaceCharByAtob:     replaceCharByAtob,
 
             _replaceCharByCharCode: replaceCharByCharCode,
@@ -5496,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;)
                 {
@@ -5563,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)
@@ -5606,6 +5625,7 @@
                             var entries = this.constantDefinitions[constant];
                             if (_Array_isArray$1(entries))
                             {
+                                this._guardResolution(constant);
                                 solution =
                                 findOptimalSolution(this, constant, entries, SolutionType.OBJECT);
                             }
@@ -5624,6 +5644,12 @@
         }
     );
 
+    STATIC_ENCODER._guardResolution =
+    function (name)
+    {
+        throw _Error$1('Unable to resolve ' + name + ' statically');
+    };
+
     initStaticEncoder(STATIC_ENCODER);
 
     function createFigurator(startValues, joiner)
@@ -5747,6 +5773,49 @@
         return figurator;
     }
 
+    function joinWithMaxLength(maxLength)
+    {
+        for (var index = arguments.length; ;)
+        {
+            if (maxLength < 0)
+                return;
+            if (--index < 1)
+                break;
+            var str = arguments[index];
+            maxLength -= str.length;
+        }
+        var array = _Array_prototype_slice_call(arguments, 1);
+        var result = array.join('');
+        return result;
+    }
+
+    // Length of the shortest possible concat head replacement "[]".
+    var CONCAT_HEAD_MIN_LENGTH      = 2;
+
+    // The overhead of "[" + "]" plus the minimum concat head replacement length.
+    var CONCAT_HEAD_MIN_OVERHEAD    = 2 + CONCAT_HEAD_MIN_LENGTH;
+
+    // Length of the shortest possible concat part replacements "+[] and "![]".
+    var CONCAT_PART_MIN_LENGTH      = 3;
+
+    // The overhead of "[" + "](" + ")" plus the minimum concat part replacement length.
+    var CONCAT_PART_MIN_OVERHEAD    = 4 + CONCAT_PART_MIN_LENGTH;
+
+    // Length of the shortest possible joiner replacement "[]".
+    var JOINER_MIN_LENGTH           = 2;
+
+    // The overhead of "[" + "](" + ")" plus the minimum joiner replacement length.
+    var JOINING_MIN_OVERHEAD        = 4 + JOINER_MIN_LENGTH;
+
+    // Length of the shortest possible separator replacement "[]".
+    var SEPARATOR_MIN_LENGTH        = 2;
+
+    // The overhead of "[" + "](" + ")" plus the minimum separator replacement length.
+    var SEPARATION_MIN_OVERHEAD     = 4 + SEPARATOR_MIN_LENGTH;
+
+    // Length of the shortest possible sequence replacement "([]+[])".
+    var SEQUENCE_MIN_LENGTH         = 7;
+
     /**
      * An object that exposes properties used to split a string into an array of strings or to join
      * array elements into a string.
@@ -5762,6 +5831,81 @@
      * to join them into a single string.
      */
 
+    function createConcatenationReplacement
+    (encoder, array, allowZeroForEmptyElements, forceString, maxLength)
+    {
+        var concatReplacement = encoder.resolveConstant('CONCAT').replacement;
+        var concatCount = array.length - 1;
+        maxLength -=
+        CONCAT_HEAD_MIN_OVERHEAD + concatCount * (concatReplacement.length + CONCAT_PART_MIN_OVERHEAD);
+        if (maxLength < 0)
+            return;
+        var options = { screwMode: forceString ? SCREW_AS_STRING : SCREW_NORMAL };
+        var replacements = [];
+        for (var index = 0; index <= concatCount; ++index)
+        {
+            var element = array[index];
+            var elementReplacement = undefinedAsString(replaceStaticString(element, options));
+            var minLength = index ? CONCAT_PART_MIN_LENGTH : CONCAT_HEAD_MIN_LENGTH;
+            if (index)
+            {
+                if (elementReplacement === '[]')
+                    elementReplacement = allowZeroForEmptyElements ? '+[]' : '[[]]';
+                replacements.push('[', concatReplacement, '](', elementReplacement, ')');
+            }
+            else
+                replacements.push('[', elementReplacement, ']');
+            maxLength -= elementReplacement.length - minLength;
+            if (maxLength < 0)
+                return;
+        }
+        var concatenationReplacement = replacements.join('');
+        return concatenationReplacement;
+    }
+
+    function createSubstitutionsReplacement(encoder, substitutions, maxLength)
+    {
+        var substitutionCount = substitutions ? substitutions.length : 0;
+        if (!substitutionCount)
+            return '';
+        var splitReplacement = encoder.resolveConstant('SPLIT').replacement;
+        var joinReplacement = encoder.resolveConstant('JOIN').replacement;
+        maxLength -=
+        substitutionCount *
+        (
+            splitReplacement.length + SEPARATION_MIN_OVERHEAD +
+            joinReplacement.length + JOINING_MIN_OVERHEAD
+        );
+        if (maxLength < 0)
+            return;
+        var replacements = [];
+        for (var index = 0; index < substitutionCount; ++index)
+        {
+            var substitution = substitutions[index];
+            var separatorReplacement = undefinedAsString(encoder.replaceExpr(substitution.separator));
+            var joinerReplacement = undefinedAsString(encoder.replaceString(substitution.joiner));
+            maxLength -=
+            separatorReplacement.length - SEPARATOR_MIN_LENGTH +
+            joinerReplacement.length - JOINER_MIN_LENGTH;
+            if (maxLength < 0)
+                return;
+            replacements.push
+            (
+                '[',
+                splitReplacement,
+                '](',
+                separatorReplacement,
+                ')[',
+                joinReplacement,
+                '](',
+                joinerReplacement,
+                ')'
+            );
+        }
+        var substitutionsReplacement = replacements.join('');
+        return substitutionsReplacement;
+    }
+
     function replaceJoinedArrayString(array, joiner, maxLength)
     {
         var str = array.join(joiner);
@@ -5770,18 +5914,8 @@
         return replacement;
     }
 
-    function undefinedAsString(replacement)
-    {
-        if (replacement === '[][[]]')
-            replacement += '+[]';
-        return replacement;
-    }
-
     /**
-     * Replaces a given array of strings with equivalent JSFuck code.
-     *
-     * Array elements may only contain characters with static definitions in their string
-     * representations.
+     * Replaces a given array of statically replaceable strings with equivalent JSFuck code.
      *
      * @function Encoder#replaceStringArray
      *
@@ -5790,7 +5924,7 @@
      *
      * @param {Delimiter[]} insertions
      * An array of delimiters of which at most one will be used to compose a joined string and split it
-     * into an array of strings.
+     * into an array of strings. Every joiner in the insertions must be a statically replaceable string.
      *
      * The encoder can pick an insertion and insert a joiner between any two adjacent elements to mark
      * the boundary between them. The separator is then used to split the concatenated string back into
@@ -5838,143 +5972,69 @@
         // applied.
         if (substitutions || count > 2)
         {
-            var preReplacement =
-            function ()
-            {
-                // Length of the shortest string replacement "([]+[])".
-                var STRING_REPLACEMENT_MIN_LENGTH = 7;
-
-                // This is for the overhead of "[" + "](" + ")" plus the length of the shortest
-                // separator replacement "[]".
-                var SEPARATOR_MIN_OVERHEAD = 6;
-
-                // This is for the overhead of "[" + "](" + ")" plus the length of the shortest
-                // joiner replacement "[]".
-                var JOINER_MIN_OVERHEAD = 6;
-
-                var joinCount = substitutions ? substitutions.length : 0;
-                var splitCount = joinCount + 1;
-                var maxSplitReplacementLength =
-                (maxLength - STRING_REPLACEMENT_MIN_LENGTH) / splitCount - SEPARATOR_MIN_OVERHEAD;
-                var splitReplacement =
-                this.replaceString('split', { maxLength: maxSplitReplacementLength, optimize: true });
-                if (!splitReplacement)
-                    return;
-                var preReplacement = '';
-                if (joinCount)
-                {
-                    var maxJoinReplacementLength =
-                    (
-                        maxLength - STRING_REPLACEMENT_MIN_LENGTH -
-                        splitCount * (splitReplacement.length + SEPARATOR_MIN_OVERHEAD)
-                    ) /
-                    joinCount -
-                    JOINER_MIN_OVERHEAD;
-                    var joinReplacement =
-                    this.replaceString('join', { maxLength: maxJoinReplacementLength });
-                    if (!joinReplacement)
-                        return;
-                    substitutions.forEach
-                    (
-                        function (substitution)
-                        {
-                            var separatorReplacement =
-                            undefinedAsString(this.replaceExpr(substitution.separator));
-                            var joinerReplacement =
-                            undefinedAsString(this.replaceString(substitution.joiner));
-                            preReplacement +=
-                            '[' + splitReplacement + '](' + separatorReplacement + ')[' +
-                            joinReplacement + '](' + joinerReplacement + ')';
-                        },
-                        this
-                    );
-                }
-                preReplacement += '[' + splitReplacement + ']';
-                return preReplacement;
-            }
-            .call(this);
+            var splitReplacement = this.resolveConstant('SPLIT').replacement;
+            var minSubstitutionsReplacementLength =
+            maxLength -
+            SEQUENCE_MIN_LENGTH -
+            splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD;
+            var substitutionsReplacement =
+            createSubstitutionsReplacement(this, substitutions, minSubstitutionsReplacementLength);
         }
-        if (!substitutions && count > 1)
-        {
-            var concatReplacement =
-            this.replaceString('concat', { maxLength: maxLength, optimize: true });
-        }
-        if (preReplacement)
+        if (substitutionsReplacement != null)
         // Approach 1: (array[0] + joiner + array[1] + joiner + array[2]...).split(separator)
         {
-            // 2 is for the additional overhead of "(" + ")".
-            var maxBulkLength = maxLength - (preReplacement.length + 2);
-            var optimalStrReplacement;
+            var maxBulkLength =
+            maxLength - substitutionsReplacement.length - splitReplacement.length -
+            SEPARATION_MIN_OVERHEAD + SEPARATOR_MIN_LENGTH;
+            var optimalSeqReplacement;
             var optimalSeparatorReplacement;
             insertions.forEach
             (
                 function (insertion)
                 {
-                    var strReplacement =
+                    var seqReplacement =
                     replaceJoinedArrayString(array, insertion.joiner, maxBulkLength);
-                    if (!strReplacement)
+                    if (!seqReplacement)
                         return;
                     var separatorReplacement = undefinedAsString(this.replaceExpr(insertion.separator));
-                    var bulkLength = strReplacement.length + separatorReplacement.length;
+                    var bulkLength = seqReplacement.length + separatorReplacement.length;
                     if (!(bulkLength > maxBulkLength))
                     {
                         maxBulkLength = bulkLength;
-                        optimalStrReplacement = strReplacement;
+                        optimalSeqReplacement = seqReplacement;
                         optimalSeparatorReplacement = separatorReplacement;
                     }
                 },
                 this
             );
-            if (optimalStrReplacement)
+            if (optimalSeqReplacement)
             {
                 replacement =
-                optimalStrReplacement + preReplacement + '(' + optimalSeparatorReplacement + ')';
+                optimalSeqReplacement + substitutionsReplacement + '[' + splitReplacement + '](' +
+                optimalSeparatorReplacement + ')';
                 maxLength = replacement.length - 1;
             }
         }
-        if
-        (
-            !substitutions &&
-            (
-                count <= 1 ||
-                concatReplacement &&
-                // 4 is the length of the shortest possible replacement "[[]]".
-                // 7 is the length of the shortest possible additional overhead for each following array
-                // element, as in "[" + "](+[])" or "[" + "](![])".
-                !(4 + (concatReplacement.length + 7) * (count - 1) > maxLength)
-            )
-        )
+        if (!substitutions)
         // Approach 2: [array[0]].concat(array[1]).concat(array[2])...
         {
-            var arrayReplacement;
-            var options = { screwMode: forceString ? SCREW_AS_STRING : SCREW_NORMAL };
-            if
-            (
-                !array.some
-                (
-                    function (element)
-                    {
-                        var elementReplacement =
-                        undefinedAsString(replaceStaticString(element, options));
-                        if (arrayReplacement)
-                        {
-                            if (elementReplacement === '[]')
-                                elementReplacement = allowZeroForEmptyElements ? '+[]' : '[[]]';
-                            arrayReplacement +=
-                            '[' + concatReplacement + '](' + elementReplacement + ')';
-                        }
-                        else
-                            arrayReplacement = '[' + elementReplacement + ']';
-                        var result = arrayReplacement.length > maxLength;
-                        return result;
-                    }
-                )
-            )
+            var arrayReplacement =
+            createConcatenationReplacement
+            (this, array, allowZeroForEmptyElements, forceString, maxLength);
+            if (arrayReplacement)
                 replacement = arrayReplacement;
         }
         return replacement;
     }
 
+    function undefinedAsString(replacement)
+    {
+        if (replacement === '[][[]]')
+            replacement += '+[]';
+        return replacement;
+    }
+
     var ENCODING_TYPE_COMBINED      = 'combined';
     var ENCODING_TYPE_EXPRESSION    = 'expression';
     var ENCODING_TYPE_TEXT          = 'text';
@@ -5982,6 +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:
@@ -6079,23 +6145,62 @@
         return charKeyArrayStr;
     }
 
-    function createJSFuckArrayMapping(encoder, arrayStr, mapper, legend)
+    function createLongStrCodesOutput(encoder, arrayReplacement, fromCharCode, arg, maxLength)
     {
-        var result =
-        arrayStr + '[' + encoder.replaceString('map', { optimize: true }) + '](' +
-        encoder.replaceExpr(mapper, true) + '(' + legend + '))';
-        return result;
+        var mapReplacement = encoder.resolveConstant('MAP').replacement;
+        var maxCharArrayLength = maxLength - JOINING_MIN_LENGTH;
+        var maxMapReplacementLength =
+        maxCharArrayLength - arrayReplacement.length - MAPPING_MIN_OVERHEAD;
+        if (mapReplacement.length > maxMapReplacementLength)
+            return;
+        var formatter = encoder.findDefinition(FROM_CHAR_CODE_CALLBACK_FORMATTER);
+        var formatterExpr = formatter(fromCharCode, arg);
+        var mapper = 'Function("return ' + formatterExpr + '")()';
+        var mapperReplacement = encoder._replaceMapper(mapper);
+        var charArrayReplacement =
+        joinWithMaxLength
+        (
+            maxCharArrayLength,
+            arrayReplacement,
+            '[',
+            mapReplacement,
+            '](',
+            mapperReplacement,
+            ')'
+        );
+        if (!charArrayReplacement)
+            return;
+        var replacement = encoder._joinCharArray(charArrayReplacement, maxLength);
+        return replacement;
     }
 
-    function createLongStrCodesOutput(encoder, strCodeArrayStr, fromCharCode, arg)
+    function createMappedArrayEncoding(encoder, arrayReplacement, mapper, legend, maxLength)
     {
-        var formatter = encoder.findDefinition(FROM_CHAR_CODE_CALLBACK_FORMATTER);
-        var formatterExpr = formatter(fromCharCode, arg);
-        var output =
-        strCodeArrayStr + '[' + encoder.replaceString('map', { optimize: true }) + '](' +
-        encoder.replaceExpr('Function("return ' + formatterExpr + '")()', true) + ')[' +
-        encoder.replaceString('join') + ']([])';
-        return output;
+        var mapReplacement = encoder.resolveConstant('MAP').replacement;
+        var maxCharArrayLength = maxLength - JOINING_MIN_LENGTH;
+        var maxMapReplacementLength =
+        // 2 is for the calling parentheses around the legend replacement.
+        maxCharArrayLength - arrayReplacement.length - MAPPING_MIN_OVERHEAD - legend.length - 2;
+        if (mapReplacement.length > maxMapReplacementLength)
+            return;
+        var mapperReplacement = encoder._replaceMapper(mapper);
+        var charArrayReplacement =
+        joinWithMaxLength
+        (
+            maxCharArrayLength,
+            arrayReplacement,
+            '[',
+            mapReplacement,
+            '](',
+            mapperReplacement,
+            '(',
+            legend,
+            '))'
+        );
+        if (!charArrayReplacement)
+            return;
+        var replacement = encoder._joinCharArray(charArrayReplacement, maxLength);
+        return replacement;
     }
 
     function createReindexMap(count, radix, amendingCount, coerceToInt)
@@ -6163,41 +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;
         }
     }
 
@@ -6256,8 +6378,7 @@
         var legend = encodeDictLegend(encoder, dictChars, maxLength - minCharIndexArrayStrLength);
         if (!legend)
             return;
-        var figureLegendInsertions =
-        encoder._callGetFigureLegendInsertions(getFigureLegendInsertions, figurator, figures);
+        var figureLegendInsertions = getFigureLegendInsertions(figurator, figures);
         var figureMaxLength = maxLength - legend.length;
         var figureLegend =
         encoder.replaceStringArray
@@ -6284,13 +6405,10 @@
         );
         if (!charIndexFigureArrayStr)
             return;
-        var formatMapper = encoder.findDefinition(FORMAT_MAPPER_SHORT);
-        var argName = formatMapper.argName;
-        var accessor = '.indexOf(' + argName + ')';
-        var mapper = formatMapper(accessor);
-        var charIndexArrayStr =
-        createJSFuckArrayMapping(encoder, charIndexFigureArrayStr, mapper, figureLegend);
-        var output = encoder.createDictEncoding(legend, charIndexArrayStr, maxLength);
+        var formatMapper = encoder._findFormatMapperShort();
+        var output =
+        encoder._createDblDictEncoding
+        (formatMapper, charIndexFigureArrayStr, figureLegend, legend, maxLength);
         return output;
     }
 
@@ -6798,7 +6916,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                193
+                194
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6853,7 +6971,7 @@
                     return output;
                 },
                 ENCODING_TYPE_TEXT,
-                347
+                173
             ),
 
             /* -------------------------------------------------------------------------------------- *\
@@ -6943,11 +7061,51 @@
     (
         Encoder.prototype,
         {
-            _callGetFigureLegendInsertions:
-            function (getFigureLegendInsertions, figurator, figures)
+            _createDblDictEncoding:
+            function (formatMapper, charIndexFigureArrayStr, figureLegend, legend, maxLength)
+            {
+                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 figureLegendInsertions = getFigureLegendInsertions(figurator, figures);
-                return figureLegendInsertions;
+                var mapper;
+                if (radix)
+                {
+                    var formatMapper = this.findDefinition(FORMAT_MAPPER_LONG);
+                    var argName = formatMapper.argName;
+                    var parseIntArg = (coerceToInt ? '+' : '') + argName;
+                    var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
+                    mapper = formatMapper(accessor);
+                }
+                else
+                    mapper = '"".charAt.bind';
+                var replacement =
+                createMappedArrayEncoding(this, charIndexArrayStr, mapper, legend, maxLength);
+                return replacement;
             },
 
             _encodeByCharCodes:
@@ -7044,7 +7202,7 @@
                 if (!charIndexArrayStr)
                     return;
                 var output =
-                this.createDictEncoding(legend, charIndexArrayStr, maxLength, radix, coerceToInt);
+                this._createDictEncoding(charIndexArrayStr, legend, radix, coerceToInt, maxLength);
                 return output;
             },
 
@@ -7092,41 +7250,33 @@
                     perfInfo.perfLog = perfLog;
                 delete this.perfLog;
                 if (output == null)
-                    throw new _Error$1('Encoding failed');
+                    throw _Error$1('Encoding failed');
                 return output;
             },
 
-            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
+            _findFormatMapperShort:
+            function ()
+            {
+                var formatMapper = this.findDefinition(FORMAT_MAPPER_SHORT);
+                return formatMapper;
+            },
 
-            createDictEncoding:
-            function (legend, charIndexArrayStr, maxLength, radix, coerceToInt)
+            _joinCharArray:
+            function (charArrayReplacement, maxLength)
             {
-                var mapper;
-                if (radix)
-                {
-                    var formatMapper = this.findDefinition(FORMAT_MAPPER_LONG);
-                    var argName = formatMapper.argName;
-                    var parseIntArg = (coerceToInt ? '+' : '') + argName;
-                    var accessor = '[parseInt(' + parseIntArg + ',' + radix + ')]';
-                    mapper = formatMapper(accessor);
-                }
-                else
-                    mapper = '"".charAt.bind';
-                var output =
-                createJSFuckArrayMapping(this, charIndexArrayStr, mapper, legend) + '[' +
-                this.replaceString('join') + ']([])';
-                if (!(output.length > maxLength))
-                    return output;
+                var joinReplacement = this.resolveConstant('JOIN').replacement;
+                var replacement =
+                joinWithMaxLength(maxLength, charArrayReplacement, '[', joinReplacement, ']([])');
+                return replacement;
             },
 
-            // Array elements may not contain the substring "false", because the value false could be
-            // used as a separator in the encoding.
-            replaceFalseFreeArray:
-            function (array, maxLength)
+            _maxDecodableArgs:  65533, // Limit imposed by Internet Explorer.
+
+            _replaceMapper:
+            function (mapper)
             {
-                var result =
-                this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, false, maxLength);
-                return result;
+                var mapperReplacement = this.replaceExpr(mapper, true);
+                return mapperReplacement;
             },
 
             replaceStringArray: replaceStringArray,
@@ -7872,7 +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()
@@ -8023,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))];