1

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

     2

/* global window, exports, define */

     3

     4

!function() {

     5

    'use strict'

     6

     7

    var re = {

     8

        not_string: /[^s]/,

     9

        not_bool: /[^t]/,

    10

        not_type: /[^T]/,

    11

        not_primitive: /[^v]/,

    12

        number: /[diefg]/,

    13

        numeric_arg: /[bcdiefguxX]/,

    14

        json: /[j]/,

    15

        not_json: /[^j]/,

    16

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

    17

        modulo: /^\x25{2}/,

    18

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

    19

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

    20

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

    21

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

    22

        sign: /^[+-]/

    23

    }

    24

    25

    function sprintf(key) {

    26

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

    27

        return sprintf_format(sprintf_parse(key), arguments)

    28

    }

    29

    30

    function vsprintf(fmt, argv) {

    31

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

    32

    }

    33

    34

    function sprintf_format(parse_tree, argv) {

    35

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

    36

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

    37

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

    38

                output += parse_tree[i]

    39

            }

    40

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

    41

                ph = parse_tree[i] // convenience purposes only

    42

                if (ph.keys) { // keyword argument

    43

                    arg = argv[cursor]

    44

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

    45

                        if (arg == undefined) {

    46

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

    47

                        }

    48

                        arg = arg[ph.keys[k]]

    49

                    }

    50

                }

    51

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

    52

                    arg = argv[ph.param_no]

    53

                }

    54

                else { // positional argument (implicit)

    55

                    arg = argv[cursor++]

    56

                }

    57

    58

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

    59

                    arg = arg()

    60

                }

    61

    62

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

    63

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

    64

                }

    65

    66

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

    67

                    is_positive = arg >= 0

    68

                }

    69

    70

                switch (ph.type) {

    71

                    case 'b':

    72

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

    73

                        break

    74

                    case 'c':

    75

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

    76

                        break

    77

                    case 'd':

    78

                    case 'i':

    79

                        arg = parseInt(arg, 10)

    80

                        break

    81

                    case 'D':

    82

                        /*  

    83

    84

                            select date format with width

    85

                            select time format with precision

    86

                            %D  => 13:31 AM (default)

    87

                            %1D  => 13:31 AM

    88

                            %.1D  => 07/07/20

    89

                            %1.1D  => 07/07/20, 13:31 AM

    90

                            %1.2D  => 07/07/20, 13:31:55 AM

    91

                            %2.2D  => May 5, 2022, 9:29:16 AM

    92

                            %3.3D  => May 5, 2022 at 9:28:16 AM GMT+2

    93

                            %4.4D  => Thursday, May 5, 2022 at 9:26:59 AM Central European Summer Time

    94

    95

                            see meaning of DateTimeFormat's options "datestyle" and "timestyle" in MDN 

    96

                        */

    97

    98

                        let [datestyle, timestyle] = [ph.width, ph.precision].map(val => ({

    99

                            1: "short",

   100

                            2: "medium",

   101

                            3: "long",

   102

                            4: "full"

   103

                        }[val]));

   104

   105

                        if(timestyle === undefined && datestyle === undefined){

   106

                            timestyle = "short";

   107

                        }

   108

   109

                        let options = {

   110

                            dateStyle: datestyle,

   111

                            timeStyle: timestyle,

   112

                            hour12: false

   113

                        }

   114

   115

                        /* get lang from globals */

   116

                        let lang = get_current_lang_code();

   117

                        let f;

   118

                        try{

   119

                            f = new Intl.DateTimeFormat(lang, options);

   120

                        } catch(e) {

   121

                            f = new Intl.DateTimeFormat('en-US', options);

   122

                        }

   123

                        arg = f.format(arg);

   124

   125

                        /*    

   126

                            TODO: select with padding char

   127

                                  a: absolute time and date (default)

   128

                                  r: relative time

   129

                        */

   130

   131

                        break

   132

                    case 'j':

   133

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

   134

                        break

   135

                    case 'e':

   136

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

   137

                        break

   138

                    case 'f':

   139

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

   140

                        break

   141

                    case 'g':

   142

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

   143

                        break

   144

                    case 'o':

   145

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

   146

                        break

   147

                    case 's':

   148

                        arg = String(arg)

   149

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

   150

                        break

   151

                    case 't':

   152

                        arg = String(!!arg)

   153

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

   154

                        break

   155

                    case 'T':

   156

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

   157

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

   158

                        break

   159

                    case 'u':

   160

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

   161

                        break

   162

                    case 'v':

   163

                        arg = arg.valueOf()

   164

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

   165

                        break

   166

                    case 'x':

   167

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

   168

                        break

   169

                    case 'X':

   170

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

   171

                        break

   172

                }

   173

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

   174

                    output += arg

   175

                }

   176

                else {

   177

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

   178

                        sign = is_positive ? '+' : '-'

   179

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

   180

                    }

   181

                    else {

   182

                        sign = ''

   183

                    }

   184

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

   185

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

   186

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

   187

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

   188

                }

   189

            }

   190

        }

   191

        return output

   192

    }

   193

   194

    var sprintf_cache = Object.create(null)

   195

   196

    function sprintf_parse(fmt) {

   197

        if (sprintf_cache[fmt]) {

   198

            return sprintf_cache[fmt]

   199

        }

   200

   201

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

   202

        while (_fmt) {

   203

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

   204

                parse_tree.push(match[0])

   205

            }

   206

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

   207

                parse_tree.push('%')

   208

            }

   209

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

   210

                if (match[2]) {

   211

                    arg_names |= 1

   212

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

   213

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

   214

                        field_list.push(field_match[1])

   215

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

   216

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

   217

                                field_list.push(field_match[1])

   218

                            }

   219

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

   220

                                field_list.push(field_match[1])

   221

                            }

   222

                            else {

   223

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

   224

                            }

   225

                        }

   226

                    }

   227

                    else {

   228

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

   229

                    }

   230

                    match[2] = field_list

   231

                }

   232

                else {

   233

                    arg_names |= 2

   234

                }

   235

                if (arg_names === 3) {

   236

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

   237

                }

   238

   239

                parse_tree.push(

   240

                    {

   241

                        placeholder: match[0],

   242

                        param_no:    match[1],

   243

                        keys:        match[2],

   244

                        sign:        match[3],

   245

                        pad_char:    match[4],

   246

                        align:       match[5],

   247

                        width:       match[6],

   248

                        precision:   match[7],

   249

                        type:        match[8]

   250

                    }

   251

                )

   252

            }

   253

            else {

   254

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

   255

            }

   256

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

   257

        }

   258

        return sprintf_cache[fmt] = parse_tree

   259

    }

   260

   261

    /**

   262

     * export to either browser or node.js

   263

     */

   264

    /* eslint-disable quote-props */

   265

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

   266

        exports['sprintf'] = sprintf

   267

        exports['vsprintf'] = vsprintf

   268

    }

   269

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

   270

        window['sprintf'] = sprintf

   271

        window['vsprintf'] = vsprintf

   272

   273

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

   274

            define(function() {

   275

                return {

   276

                    'sprintf': sprintf,

   277

                    'vsprintf': vsprintf

   278

                }

   279

            })

   280

        }

   281

    }

   282

    /* eslint-enable quote-props */

   283

}(); // eslint-disable-line