No string interpolation about rapydscript HOT 7 OPEN

function __stringformat__() {
    // string-format from node.js
    var format, lookup, resolve,
    __slice = [].slice;
    String.prototype._format = function _format(){
        function lengthen(fname, length){
            if (length == undefined) return fname
            if (fname == undefined) return ''
            var l, arr;
            l = fname.length;
            if (l > length) {
                fname = fname.slice(0, l);
            } else {
                arr   = new Array(length - l);
                fname = fname + arr.join(" ");
            }   return fname;}
        var matches, l, i, lbound, rbound, pair, compensate = 0, result = this, maybekarg = arguments.length == 1, key
        matches = re('\\{[a-zA-Z_]*:([0-9]+)?\}').findall( this, true)
        l = matches.length
        for (i=0; i < l ; i++){
            m = matches[i]

            if (m[1] != undefined){
                pair = m[0].split(':')
                if ( pair[0] == '{' ){
                    // positional args
                    arguments[i] = lengthen(arguments[i], parseInt(m[1]) )
                    lbound = compensate + m.index + pair[0].length
                    rbound = lbound + pair[1].length
                    compensate += rbound - lbound
                    result = this.slice(0, lbound) + this.slice(rbound)
                }else{
                    if (maybekarg && pair[0] != undefined){
                        key = pair[0].slice(1)
                        arguments[0][key] = lengthen(arguments[0][key], parseInt(m[1]) )
                        lbound = compensate + m.index + pair[0].length
                        rbound = lbound + pair[1].length
                        compensate += rbound - lbound
                        result = this.slice(0, lbound) + this.slice(rbound)
                    }

                }

            }
        }
        return [result, arguments]
    }

    format = String.prototype.format = function () {
        //console('format arguments:', arguments)
        var args, explicit, idx, implicit, message, _this = this;
        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        if (args.length === 0) {
            return function () {
                var args;
                args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
                return _this.format.apply(_this, args);
            };
        }else{
            var raw = this._format.apply(this, arguments)
            args = raw[1]
            _this = raw[0]
        }
        idx = 0;
        explicit = implicit = false;
        message = 'cannot switch from {} to {} numbering'.format();
        return _this.replace(/([{}])\1|[{](.*?)(?:!(.+?))?[}]/g, function (match, literal, key, transformer) {
            var fn, value, _ref, _ref1, _ref2;
            if (literal) {
                return literal;
            }
            if (key.length) {
                explicit = true;
                if (implicit) {
                    throw new Error(message('implicit', 'explicit'));
                }
                value = (_ref = lookup(args, key)) != null ? _ref : '';
            } else {
                implicit = true;
                if (explicit) {
                    throw new Error(message('explicit', 'implicit'));
                }
                value = (_ref1 = args[idx++]) != null ? _ref1 : '';
            }
            value = value.toString();
            if (fn = format.transformers[transformer]) {
                return (_ref2 = fn.call(value)) != null ? _ref2 : '';
            } else {
                return value;
            }
        });
    };
    lookup = function (object, key) {
        var match;
        if (!/^(\d+)([.]|$)/.test(key)) {
            key = '0.' + key;
        }
        while (match = /(.+?)[.](.+)/.exec(key)) {
            object = resolve(object, match[1]);
            key = match[2];
        }
        return resolve(object, key);
    };
    resolve = function (object, key) {
        var value;
        value = object[key];
        if (typeof value === 'function') {
            return value.call(object);
        } else {
            return value;
        }
    };

    format.transformers = {};
}
__stringformat__();