8

        dispatch(value, oldval, index) {

     9

            this.fields[index] = value;    

    10

            console.log(value, index);

    11

            this.element.textContent = this.args.length == 1 ? vsprintf(this.args[0],this.fields) : this.fields.join(' ');

    20

    21

    |     fields: [],

    23

    24

emit "preamble:display"

    25

||

    26

/* https://github.com/alexei/sprintf.js/blob/master/src/sprintf.js */

    27

/* global window, exports, define */

    28

    29

!function() {

    30

    'use strict'

    31

    32

    var re = {

    33

        not_string: /[^s]/,

    34

        not_bool: /[^t]/,

    35

        not_type: /[^T]/,

    36

        not_primitive: /[^v]/,

    37

        number: /[diefg]/,

    38

        numeric_arg: /[bcdiefguxX]/,

    39

        json: /[j]/,

    40

        not_json: /[^j]/,

    41

        text: /^[^\x25]+/,

    42

        modulo: /^\x25{2}/,

    43

        placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,

    44

        key: /^([a-z_][a-z_\d]*)/i,

    45

        key_access: /^\.([a-z_][a-z_\d]*)/i,

    46

        index_access: /^\[(\d+)\]/,

    47

        sign: /^[+-]/

    48

    }

    49

    50

    function sprintf(key) {

    51

        // `arguments` is not an array, but should be fine for this call

    52

        return sprintf_format(sprintf_parse(key), arguments)

    53

    }

    54

    55

    function vsprintf(fmt, argv) {

    56

        return sprintf.apply(null, [fmt].concat(argv || []))

    57

    }

    58

    59

    function sprintf_format(parse_tree, argv) {

    60

        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign

    61

        for (i = 0; i < tree_length; i++) {

    62

            if (typeof parse_tree[i] === 'string') {

    63

                output += parse_tree[i]

    64

            }

    65

            else if (typeof parse_tree[i] === 'object') {

    66

                ph = parse_tree[i] // convenience purposes only

    67

                if (ph.keys) { // keyword argument

    68

                    arg = argv[cursor]

    69

                    for (k = 0; k < ph.keys.length; k++) {

    70

                        if (arg == undefined) {

    71

                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))

    72

                        }

    73

                        arg = arg[ph.keys[k]]

    74

                    }

    75

                }

    76

                else if (ph.param_no) { // positional argument (explicit)

    77

                    arg = argv[ph.param_no]

    78

                }

    79

                else { // positional argument (implicit)

    80

                    arg = argv[cursor++]

    81

                }

    82

    83

                if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {

    84

                    arg = arg()

    85

                }

    86

    87

                if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {

    88

                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))

    89

                }

    90

    91

                if (re.number.test(ph.type)) {

    92

                    is_positive = arg >= 0

    93

                }

    94

    95

                switch (ph.type) {

    96

                    case 'b':

    97

                        arg = parseInt(arg, 10).toString(2)

    98

                        break

    99

                    case 'c':

   100

                        arg = String.fromCharCode(parseInt(arg, 10))

   101

                        break

   102

                    case 'd':

   103

                    case 'i':

   104

                        arg = parseInt(arg, 10)

   105

                        break

   106

                    case 'j':

   107

                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)

   108

                        break

   109

                    case 'e':

   110

                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()

   111

                        break

   112

                    case 'f':

   113

                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)

   114

                        break

   115

                    case 'g':

   116

                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)

   117

                        break

   118

                    case 'o':

   119

                        arg = (parseInt(arg, 10) >>> 0).toString(8)

   120

                        break

   121

                    case 's':

   122

                        arg = String(arg)

   123

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   124

                        break

   125

                    case 't':

   126

                        arg = String(!!arg)

   127

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   128

                        break

   129

                    case 'T':

   130

                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()

   131

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   132

                        break

   133

                    case 'u':

   134

                        arg = parseInt(arg, 10) >>> 0

   135

                        break

   136

                    case 'v':

   137

                        arg = arg.valueOf()

   138

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   139

                        break

   140

                    case 'x':

   141

                        arg = (parseInt(arg, 10) >>> 0).toString(16)

   142

                        break

   143

                    case 'X':

   144

                        arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()

   145

                        break

   146

                }

   147

                if (re.json.test(ph.type)) {

   148

                    output += arg

   149

                }

   150

                else {

   151

                    if (re.number.test(ph.type) && (!is_positive || ph.sign)) {

   152

                        sign = is_positive ? '+' : '-'

   153

                        arg = arg.toString().replace(re.sign, '')

   154

                    }

   155

                    else {

   156

                        sign = ''

   157

                    }

   158

                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '

   159

                    pad_length = ph.width - (sign + arg).length

   160

                    pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''

   161

                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)

   162

                }

   163

            }

   164

        }

   165

        return output

   166

    }

   167

   168

    var sprintf_cache = Object.create(null)

   169

   170

    function sprintf_parse(fmt) {

   171

        if (sprintf_cache[fmt]) {

   172

            return sprintf_cache[fmt]

   173

        }

   174

   175

        var _fmt = fmt, match, parse_tree = [], arg_names = 0

   176

        while (_fmt) {

   177

            if ((match = re.text.exec(_fmt)) !== null) {

   178

                parse_tree.push(match[0])

   179

            }

   180

            else if ((match = re.modulo.exec(_fmt)) !== null) {

   181

                parse_tree.push('%')

   182

            }

   183

            else if ((match = re.placeholder.exec(_fmt)) !== null) {

   184

                if (match[2]) {

   185

                    arg_names |= 1

   186

                    var field_list = [], replacement_field = match[2], field_match = []

   187

                    if ((field_match = re.key.exec(replacement_field)) !== null) {

   188

                        field_list.push(field_match[1])

   189

                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {

   190

                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {

   191

                                field_list.push(field_match[1])

   192

                            }

   193

                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {

   194

                                field_list.push(field_match[1])

   195

                            }

   196

                            else {

   197

                                throw new SyntaxError('[sprintf] failed to parse named argument key')

   198

                            }

   199

                        }

   200

                    }

   201

                    else {

   202

                        throw new SyntaxError('[sprintf] failed to parse named argument key')

   203

                    }

   204

                    match[2] = field_list

   205

                }

   206

                else {

   207

                    arg_names |= 2

   208

                }

   209

                if (arg_names === 3) {

   210

                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')

   211

                }

   212

   213

                parse_tree.push(

   214

                    {

   215

                        placeholder: match[0],

   216

                        param_no:    match[1],

   217

                        keys:        match[2],

   218

                        sign:        match[3],

   219

                        pad_char:    match[4],

   220

                        align:       match[5],

   221

                        width:       match[6],

   222

                        precision:   match[7],

   223

                        type:        match[8]

   224

                    }

   225

                )

   226

            }

   227

            else {

   228

                throw new SyntaxError('[sprintf] unexpected placeholder')

   229

            }

   230

            _fmt = _fmt.substring(match[0].length)

   231

        }

   232

        return sprintf_cache[fmt] = parse_tree

   233

    }

   234

   235

    /**

   236

     * export to either browser or node.js

   237

     */

   238

    /* eslint-disable quote-props */

   239

    if (typeof exports !== 'undefined') {

   240

        exports['sprintf'] = sprintf

   241

        exports['vsprintf'] = vsprintf

   242

    }

   243

    if (typeof window !== 'undefined') {

   244

        window['sprintf'] = sprintf

   245

        window['vsprintf'] = vsprintf

   246

   247

        if (typeof define === 'function' && define['amd']) {

   248

            define(function() {

   249

                return {

   250

                    'sprintf': sprintf,

   251

                    'vsprintf': vsprintf

   252

                }

   253

            })

   254

        }

   255

    }

   256

    /* eslint-enable quote-props */

   257

}(); // eslint-disable-line    

   258

||