To fix , you need 3 overrides. I do not recommend using the solution with useEval: false, since there will be a drop in performance in FF. I tested on version 6.7.0

Code:
Ext.define('Overrides.app.bind.Parser', {
    override: 'Ext.app.bind.Parser',

    privates: {

        //useEval: false,

        /**
         * Parses the expression tree and compiles it as a function
         *
         * @paramexpr
         * @param{Boolean}debug
         * @return{Function}
         * @private
         */
        parseSlot: function (expr, debug) {
            var me = this,
                defs = [],
                body = [],
                tokens = me.tokens || [],
                fn, code, i, length, temp;

            me.definitions = defs;
            me.body = body;

            body.push('return ' + me.compile(expr) + ';');

            // now we have the tokens
            length = tokens.length;
            code = 'var fm = Ext.util.Format,\nme,';
            temp = 'var a = Ext.Array.from(values);\nme = scope;\n';

            if (tokens.length) {
                for (i = 0; i < length; i++) {
                    code += 'v' + i + ((i === length - 1) ? ';' : ',');
                    temp += 'v' + i + ' = a[' + i + ']; ';
                }
            } else {
                code += 'v0;';
                temp += 'v0 = a[0];';
            }

            defs = Ext.Array.insert(defs, 0, [code]);
            body = Ext.Array.insert(body, 0, [temp]);
            body = body.join('\n');

            //<debug>
            if (debug) {
                body = 'debugger;\n' + body;
            }
            //</debug>

            // fix here
            defs.push(
                (me.useEval ? 'arguments[0]=' : 'return') + ' function (values, scope) {',
                body,
                '}'
            );

            code = defs.join('\n');

            fn = me.useEval ? me.evalFn(code) : (new Function('Ext', code))(Ext);

            me.definitions = me.body = null;

            return fn;
        }
    }

});
Code:
Ext.define('Overrides.util.XTemplateCompiler', {
    override: 'Ext.util.XTemplateCompiler',

    //useEval: false

    generate: function (tpl) {
        var me = this,
            // note: Ext here is properly sandboxed
            definitions = 'var fm=Ext.util.Format,ts=Object.prototype.toString;',
            code;

        // Track how many levels we use, so that we only "var" each level's variables once
        me.maxLevel = 0;

        me.body = [
            'var c0=values, a0=' + me.createArrayTest(0) +
            ', p0=parent, n0=xcount, i0=xindex, k0, v;\n'
        ];

        if (me.definitions) {
            if (typeof me.definitions === 'string') {
                me.definitions = [me.definitions, definitions];
            } else {
                me.definitions.push(definitions);
            }
        } else {
            me.definitions = [definitions];
        }

        me.switches = [];

        me.parse(tpl);

        // fix here
        me.definitions.push(
            (me.useEval ? 'arguments[0]=' : 'return') + ' function (' + me.fnArgs + ') {',
            me.body.join(''),
            '}'
        );

        code = me.definitions.join('\n');

        // Free up the arrays.
        me.definitions.length = me.body.length = me.switches.length = 0;
        me.definitions = me.body = me.switches = 0;

        return code;
    }

});
Code:
Ext.define('Overrides.Template', {
    override: 'Ext.Template',

    //useEval: false

    /**
     * Compiles the template into an internal function, eliminating the RegEx overhead.
     * @return{Ext.Template} this
     */
    compile: function () {
        var me = this,
            code;

        code = me.html.replace(me.compileARe, '\\\\')
            .replace(me.compileBRe, '\\n')
            .replace(me.compileCRe, "\\'")
            .replace(me.tokenRe, me.regexReplaceFn.bind(me));

        // fix here
        code = (this.disableFormats !== true ? 'var fm=Ext.util.Format;' : '') +
            (me.useEval ? 'arguments[0]=' : 'return') +
            " function(v){return ['" + code + "'];};";

        me.fn = me.useEval ? me.evalCompiled(code) : (new Function('Ext', code))(Ext);
        me.compiled = true;

        return me;
    }

});