"use strict";

(function($B) {

var _b_ = $B.builtins

// build tables from data in unicode_data.js

var escape2cp = $B.escape2cp = {

b: '\b',

f: '\f',

n: '\n',

r: '\r',

t: '\t',

v: '\v'

}

$B.surrogates = function(s) {

var s1 = '',

escaped = false

for (var char of s) {

if (escaped) {

var echar = escape2cp[char]

if (echar !== undefined) {

s1 += echar

} else {

s1 += '\\' + char

}

escaped = false

} else if (char == '\\') {

escaped = true

} else {

s1 += char

}

}

var surrogates = [],

j = 0

for (var i = 0, len = s1.length; i < len; i++) {

var cp = s1.codePointAt(i)

if (cp >= 0x10000) {

surrogates.push(j)

i++

}

j++

}

return surrogates

}

$B.String = function(s) {

var srg = $B.surrogates(s)

return srg.length == 0 ? s : $B.make_String(s, srg)

}

$B.make_String = function(s, surrogates) {

var res = new String(s)

res.ob_type = str

res.surrogates = surrogates

return res

}

function pypos2jspos(s, pypos) {

// convert Python position to JS position

if (s.surrogates === undefined) {

return pypos

}

var nb = 0

while (s.surrogates[nb] < pypos) {

nb++

}

return pypos + nb

}

function jspos2pypos(s, jspos) {

// convert JS position to Python position

if (s.surrogates === undefined) {

return jspos

}

var nb = 0

while (s.surrogates[nb] + nb < jspos) {

nb++

}

return jspos - nb

}

function to_string(...args) {

if (args.length == 1) {

return conv_str(args[0])

}

var res = []

for (var arg of args) {

res.push(conv_str(arg))

}

return res

}

function conv_str(obj) {

if (typeof obj == 'string') {

return obj

} else if (obj.ob_type == str) {

return obj

} else if ($B.is_str(obj)) {

return obj.$brython_value

}

return $B.NULL

}

var str = _b_.str

str.$is_sequence = true

str.$to_string = to_string

function normalize_start_end($) {

var len

if (typeof $.self == "string") {

len = $.self.length

} else {

len = str.mp_length($.self)

}

if ($.start === null || $.start === _b_.None) {

$.start = 0

} else if ($.start < 0) {

$.start += len

$.start = Math.max(0, $.start)

}

if ($.end === null || $.end === _b_.None) {

$.end = len

} else if ($.end < 0) {

$.end += len

$.end = Math.max(0, $.end)

}

if (! $B.is_int($.start) || ! $B.is_int($.end)) {

$B.RAISE(_b_.TypeError, "slice indices must be integers " +

"or None or have an __index__ method")

}

if ($.self.surrogates) {

$.js_start = pypos2jspos($.self, $.start)

$.js_end = pypos2jspos($.self, $.end)

}

}

function reverse(s) {

// Reverse a string

return s.split("").reverse().join("")

}

function check_str(obj, prefix) {

if (! $B.is_str(obj)) {

$B.RAISE(_b_.TypeError, (prefix || '') +

"must be str, not " + $B.class_name(obj))

}

}

function to_chars(s) {

// Transform Javascript string s into a list of Python characters

// (2 JS chars if surrogate, 1 otherwise)

s = to_string(s)

return Array.from(s)

}

function preformat(_self, fmt) {

if (fmt.empty) {

return _b_.str.$factory(_self)

}

if (fmt.type && fmt.type != "s") {

$B.RAISE(_b_.ValueError, "Unknown format code '" + fmt.type +

"' for object of type 'str'")

}

return _self

}

function startswith(self, prefix, start, end) {

if (end === null) {

return self.startsWith(prefix, start)

} else if (end < start) {

return false

} else if (prefix.length > end - start) {

return false

} else {

return self.startsWith(prefix, start)

}

}

str.$getitem_slice = function(_self, slice) {

var len = str.mp_length(_self),

s = _b_.slice.$conv_for_seq(slice, len),

start = pypos2jspos(_self, s.start),

stop = pypos2jspos(_self, s.stop),

step = s.step

var res = ""

if (step > 0) {

if (stop <= start) {

return ""

}

for (let i = start; i < stop; i += step) {

res += _self[i]

}

} else {

if (stop >= start) {

return ''

}

for (let i = start; i > stop; i += step) {

res += _self[i]

}

}

return $B.String(res)

}

var prefix = 2,

suffix = 3

str.$getnewargs = function(self) {

return $B.fast_tuple([to_string(self)])

}

/* str_iterator start */

$B.str_iterator.tp_iter = function(self) {

return self

}

$B.str_iterator.tp_iternext = function*(self){

for (var char of self.it) {

yield char

}

}

var str_iterator_funcs = $B.str_iterator.tp_funcs = {}

str_iterator_funcs.__length_hint__ = function(self) {

return self.len

}

str_iterator_funcs.__reduce__ = function(self) {

return $B.fast_tuple([_b_.iter, $B.fast_tuple([self.obj]), 0])

}

str_iterator_funcs.__setstate__ = function(self, value) {

self.it = self.obj[Symbol.iterator]()

for (var i = 0; i < value; i++) {

self.it.next()

}

}

$B.str_iterator.tp_methods = ["__length_hint__", "__reduce__", "__setstate__"]

/* str_iterator end */

$B.set_func_names($B.str_iterator, 'builtins')

// Start of section for legacy formatting (with %)

var number_check = function(s, flags) {

if (! $B.$isinstance(s, [_b_.int, _b_.float])) {

var type = flags.conversion_type

$B.RAISE(_b_.TypeError, `%${type} format: a real number ` +

`is required, not ${$B.class_name(s)}`)

}

}

var get_char_array = function(size, char) {

if (size <= 0) {

return ""

}

return new Array(size + 1).join(char)

}

var format_padding = function(s, flags, minus_one) {

var padding = flags.padding

if (! padding) { // undefined

return s

}

s = s.toString()

padding = parseInt(padding, 10)

if (minus_one) { // numeric formatting where sign goes in front of padding

padding -= 1

}

if (! flags.left) {

return get_char_array(padding - s.length, flags.pad_char) + s

} else {

// left adjusted

return s + get_char_array(padding - s.length, flags.pad_char)

}

}

const max_precision = 2 ** 31 - 4,

max_repeat = 2 ** 30 - 1

var format_int_precision = function(val, flags) {

var precision = flags.precision

if (! precision) {

return _b_.str.$factory(val)

}

precision = parseInt(precision, 10)

if (precision > max_precision) {

$B.RAISE(_b_.OverflowError, 'precision too large')

}

var s

if ($B.is_big_int(val)) {

s = $B.int_value(val).toString()

} else {

s = val.toString()

}

if (precision - s.length > max_repeat) {

$B.RAISE(_b_.OverflowError, 'precision too large')

}

if (s[0] === "-") {

return "-" + "0".repeat(Math.max(0, precision - s.length + 1)) +

s.slice(1)

}

return "0".repeat(Math.max(0, precision - s.length)) + s

}

var format_float_precision = function(val, upper, flags, modifier) {

var precision = flags.precision

if (isFinite(val)) {

return modifier(val, precision, flags, upper)

}

if (val === Infinity) {

val = "inf"

} else if (val === -Infinity) {

val = "-inf"

} else {

val = "nan"

}

if (upper) {

return val.toUpperCase()

}

return val

}

var format_sign = function(val, flags) {

if (flags.sign) {

if (val >= 0 || isNaN(val) || val === Number.POSITIVE_INFINITY) {

return "+"

}

} else if (flags.space) {

if (val >= 0 || isNaN(val)) {

return " "

}

}

return ''

}

var str_format = function(val, flags) {

// string format supports left and right padding

flags.pad_char = " " // even if 0 padding is defined, don't use it

return format_padding(str.$factory(val), flags)

}

var num_format = function(val, flags) {

number_check(val, flags)

if ($B.$isinstance(val, _b_.float)) {

val = parseInt(val.value)

} else if (! $B.is_int(val)) {

val = parseInt(val)

} else if ($B.$isinstance(val, _b_.bool)) {

val = val ? 1 : 0

}

var s = format_int_precision(val, flags)

if (flags.pad_char === "0") {

if (val < 0) {

s = s.substring(1)

return "-" + format_padding(s, flags, true)

}

var sign = format_sign(val, flags)

if (sign !== "") {

return sign + format_padding(s, flags, true)

}

}

return format_padding(format_sign(val, flags) + s, flags)

}

var repr_format = function(val, flags) {

flags.pad_char = " " // even if 0 padding is defined, don't use it

return format_padding(_b_.repr(val), flags)

}

var ascii_format = function(val, flags, type) {

flags.pad_char = " " // even if 0 padding is defined, don't use it

var ascii

if (type == 'bytes') {

var repr = _b_.repr(val)

ascii = _b_.str.tp_funcs.encode(repr, 'ascii', 'backslashreplace')

ascii = $B.bytes_decode(ascii, 'ascii')

} else {

ascii = _b_.ascii(val)

}

return format_padding(ascii, flags)

}

// converts val to Javascript number and sets precision if missing

var _float_helper = function(val, flags) {

number_check(val, flags)

if (flags.precision === undefined) {

if (! flags.decimal_point) {

flags.precision = 6

} else {

flags.precision = 0

}

} else {

flags.precision = parseInt(flags.precision, 10)

validate_precision(flags.precision)

}

return $B.is_int(val) ? val : val.value

}

var validate_precision = function(precision) {

// force precision to limits of javascript

if (precision > 20) {

precision = 20

}

}

function handle_special_values(value, upper) {

var special

if (isNaN(value)) {

special = upper ? "NAN" : "nan"

} else if (value == Number.POSITIVE_INFINITY) {

special = upper ? "INF" : "inf"

} else if (value == Number.NEGATIVE_INFINITY) {

special = upper ? "-INF" : "-inf"

}

return special

}

// gG

var floating_point_format = function(value, upper, flags) {

var val = _float_helper(value, flags)

var special = handle_special_values(val, upper)

if (special) {

return format_padding(format_sign(val, flags) + special, flags)

}

var p = flags.precision

if (p == 0) {

p = 1

}

var exp_format = val.toExponential(p - 1),

e_index = exp_format.indexOf('e'),

exp = parseInt(exp_format.substr(e_index + 1)),

res

function remove_zeros(v) {

if (flags.alternate) {

return v

}

if (v.indexOf('.') > -1) {

while (v.endsWith('0')) {

v = v.substr(0, v.length - 1)

}

if (v.endsWith('.')) {

v = v.substr(0, v.length - 1)

}

}

return v

}

if (-4 <= exp && exp < p) {

/*

If m <= exp < p, where m is -4 for floats and -6 for Decimals, the

number is formatted with presentation type 'f' and precision p-1-exp

*/

flags.precision = Math.max(0, p - 1 - exp)

res = floating_point_decimal_format(value, upper, flags)

res = remove_zeros(res)

} else {

/*

Otherwise, the number is formatted with presentation type 'e' and

precision p-1

*/

flags.precision = Math.max(0, p - 1)

var delim = upper ? 'E' : 'e',

exp_fmt = floating_point_exponential_format(value, upper, flags),

parts = exp_fmt.split(delim)

parts[0] = remove_zeros(parts[0])

res = parts.join(delim)

}

return format_padding(format_sign(val, flags) + res, flags)

}

var roundDownToFixed = $B.roundDownToFixed = function(v, d) {

if (d == 0 && v.toString().indexOf('e') > -1) {

// with precision 0, never include "e"

return BigInt(v).toString()

}

const mul = Math.pow(10, d);

var is_neg = v < 0

if (is_neg) {

v = -v

}

var res_floor = (Math.floor(v * mul) / mul).toFixed(d),

res_ceil = (Math.ceil(v * mul) / mul).toFixed(d),

res

if (v - res_floor == res_ceil - v) {

// if two multiples are equally close, rounding is done toward

// the even choice

var last = res_floor[res_floor.length - 1]

res = last.match(/[02468]/) ? res_floor : res_ceil

} else {

res = v - res_floor < res_ceil - v ? res_floor : res_ceil

}

return is_neg ? '-' + res : res

}

// fF

var floating_point_decimal_format = function(val, upper, flags) {

val = _float_helper(val, flags)

var unpadded = format_float_precision(val, upper, flags,

function(val, precision, flags) {

// can't use val.toFixed(precision) because

// (2.5).toFixed(0) returns "3", not "2"...

var res = roundDownToFixed(val, precision)

if (precision === 0 && flags.alternate) {

res += '.'

}

if (Object.is(val, -0)) {

res = '-' + res

}

return res

})

return format_padding(format_sign(val, flags) + unpadded,

flags)

}

var _floating_exp_helper = function(val, precision, flags, upper) {

var is_neg = false,

val_pos = val.toString()

if (val < 0) {

is_neg = true

val_pos = val_pos.substr(1)

} else if (Object.is(val, -0)) {

is_neg = true

}

var parts = val_pos.split('.'),

exp = 0,

exp_sign = '+',

mant

if (parts[0] == '0') {

if (parts[1]) {

exp_sign = '-'

exp++

var i = 0

while (parts[1][i] == '0') {

i++

}

exp += i

mant = parts[1][i]

if (parts[1][i + 1]) {

mant += '.' + parts[1].substr(i + 1)

}

} else {

mant = '0'

}

} else {

exp = parts[0].length - 1

mant = parts[0][0]

if (parts[0].length > 1) {

mant += '.' + parts[0].substr(1) + (parts[1] || '')

} else if (parts[1]) {

mant += '.' + parts[1]

}

}

mant = parseFloat(mant)

// round mantissa to precision

mant = roundDownToFixed(parseFloat(mant), precision)

if (parseFloat(mant) == 10) {

// 9.5 is rounded to 10 !

parts = mant.split('.')

parts[0] = '1'

mant = parts.join('.')

exp = parseInt(exp) + (exp_sign == '+' ? 1 : -1)

if (exp == 0) {

exp_sign = '+'

}

}

if (flags.alternate && mant.indexOf('.') == -1) {

mant += '.'

}

if (exp.toString().length == 1) {

// exponent has at least 2 digits

exp = '0' + exp

}

return `${is_neg ? '-' : ''}${mant}${upper ? 'E' : 'e'}${exp_sign}${exp}`

}

// eE

var floating_point_exponential_format = function(value, upper, flags) {

var val = _float_helper(value, flags)

return format_padding(format_sign(val, flags) +

format_float_precision(val, upper, flags, _floating_exp_helper), flags)

}

$B.formatters = {

floating_point_format,

floating_point_decimal_format,

floating_point_exponential_format

}

var signed_hex_format = function(val, upper, flags) {

var ret

if (! $B.is_int(val)) {

$B.RAISE(_b_.TypeError,

`%X format: an integer is required, not ${$B.class_name(val)}`)

} else if ($B.$isinstance(val, _b_.bool)) {

val = val ? 1 : 0

}

if ($B.is_big_int(val)) {

ret = $B.int_value(val).toString(16)

} else {

ret = parseInt(val)

ret = ret.toString(16)

}

ret = format_int_precision(ret, flags)

if (upper) {ret = ret.toUpperCase()}

if (flags.pad_char === "0") {

if (val < 0) {

ret = ret.substring(1)

ret = "-" + format_padding(ret, flags, true)

}

var sign = format_sign(val, flags)

if (sign !== "") {

ret = sign + format_padding(ret, flags, true)

}

}

if (flags.alternate) {

if (ret.charAt(0) === "-") {

if (upper) {ret = "-0X" + ret.slice(1)} else {ret = "-0x" + ret.slice(1)}

} else {

if (upper) {ret = "0X" + ret} else {ret = "0x" + ret}

}

}

return format_padding(format_sign(val, flags) + ret, flags)

}

var octal_format = function(val, flags) {

number_check(val, flags)

var ret

if ($B.is_big_int(val)) {

ret = $B.int_value(val).toString(8)

} else {

ret = parseInt(val)

ret = ret.toString(8)

}

ret = format_int_precision(ret, flags)

if (flags.pad_char === "0") {

if (val < 0) {

ret = ret.substring(1)

ret = "-" + format_padding(ret, flags, true)

}

var sign = format_sign(val, flags)

if (sign !== "") {

ret = sign + format_padding(ret, flags, true)

}

}

if (flags.alternate) {

if (ret.charAt(0) === "-") {ret = "-0o" + ret.slice(1)} else {ret = "0o" + ret}

}

return format_padding(ret, flags)

}

function series_of_bytes(val, flags) {

if ($B.get_class(val).$buffer_protocol) {

var it = _b_.iter(val),

ints = []

while (true) {

try {

ints.push(_b_.next(it))

} catch (err) {

if ($B.is_exc(err, _b_.StopIteration)) {

var b = _b_.bytes.$factory(ints)

return format_padding($B.bytes_decode(b, "ascii"), flags)

}

throw err

}

}

} else {

try {

var bytes_obj = $B.$getattr(val, "__bytes__")()

return format_padding($B.bytes_decode(bytes_obj), flags)

} catch (err) {

if ($B.is_exc(err, _b_.AttributeError)) {

$B.RAISE(_b_.TypeError, "%b does not accept '" +

$B.class_name(val) + "'")

}

throw err

}

}

}

var single_char_format = function(val, flags, type) {

if (type == 'bytes') {

if ($B.is_int(val)) {

if ($B.is_big_int(val) || val < 0 || val > 255) {

$B.RAISE(_b_.OverflowError, "%c arg not in range(256)")

}

} else if ($B.$isinstance(val, [_b_.bytes, _b_.bytearray])) {

if (val.source.length > 1) {

$B.RAISE(_b_.TypeError,

"%c requires an integer in range(256) or a single byte")

}

val = val.source[0]

}

} else {

if ($B.is_str(val)) {

if (_b_.str.mp_length(val) == 1) {

return val

}

$B.RAISE(_b_.TypeError, "%c requires int or char")

} else if (! $B.is_int(val)) {

$B.RAISE(_b_.TypeError, "%c requires int or char")

}

if ($B.is_big_int(val)) {

val = $B.int_value(val)

if((val < 0 || val >= 0x110000) ||

(val < 0 || val >= 0x110000)){

$B.RAISE(_b_.OverflowError, '%c arg not in range(0x110000)')

}

}

}

return format_padding(_b_.chr(val), flags)

}

var num_flag = function(c, flags) {

if (c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left) {

flags.pad_char = "0"

return

}

if (!flags.decimal_point) {

flags.padding = (flags.padding || "") + c

} else {

flags.precision = (flags.precision || "") + c

}

}

var decimal_point_flag = function(val, flags) {

if (flags.decimal_point) {

// can only have one decimal point

throw new UnsupportedChar()

}

flags.decimal_point = true

}

var neg_flag = function(val, flags) {

flags.pad_char = " " // overrides '0' flag

flags.left = true

}

var space_flag = function(val, flags) {

flags.space = true

}

var sign_flag = function(val, flags) {

flags.sign = true

}

var alternate_flag = function(val, flags) {

flags.alternate = true

}

var char_mapping = {

"b": series_of_bytes,

"s": str_format,

"d": num_format,

"i": num_format,

"u": num_format,

"o": octal_format,

"r": repr_format,

"a": ascii_format,

"g": function(val, flags) {

return floating_point_format(val, false, flags)

},

"G": function(val, flags) {

return floating_point_format(val, true, flags)

},

"f": function(val, flags) {

return floating_point_decimal_format(val, false, flags)

},

"F": function(val, flags) {

return floating_point_decimal_format(val, true, flags)

},

"e": function(val, flags) {

return floating_point_exponential_format(val, false, flags)

},

"E": function(val, flags) {

return floating_point_exponential_format(val, true, flags)

},

"x": function(val, flags) {return signed_hex_format(val, false, flags)},

"X": function(val, flags) {return signed_hex_format(val, true, flags)},

"c": single_char_format,

"0": function(val, flags) {return num_flag("0", flags)},

"1": function(val, flags) {return num_flag("1", flags)},

"2": function(val, flags) {return num_flag("2", flags)},

"3": function(val, flags) {return num_flag("3", flags)},

"4": function(val, flags) {return num_flag("4", flags)},

"5": function(val, flags) {return num_flag("5", flags)},

"6": function(val, flags) {return num_flag("6", flags)},

"7": function(val, flags) {return num_flag("7", flags)},

"8": function(val, flags) {return num_flag("8", flags)},

"9": function(val, flags) {return num_flag("9", flags)},

"-": neg_flag,

" ": space_flag,

"+": sign_flag,

".": decimal_point_flag,

"#": alternate_flag

}

// exception thrown when an unsupported char is encountered in legacy format

var UnsupportedChar = function() {

this.name = "UnsupportedChar"

}

const conversion_flags = '#0- +',

length_modifiers = 'hlL',

conversion_types = 'diouxXeEfFgGcrsa'

function parse_mod_format(s, type, pos) {

var flags = {pad_char: ' '},

len = s.length,

start_pos = pos,

mo

pos++

while (pos < len) {

var char = s[pos]

if (char == '(') {

var end = s.substr(pos).indexOf(')')

if (end == -1) {

$B.RAISE(_b_.ValueError, 'incomplete format key')

} else {

flags.mapping_key = s.substr(pos + 1, end - 1)

pos += end + 1

}

} else if (conversion_flags.indexOf(char) > -1) {

flags.conversion_flag = char

if (char == '#') {

flags.alternate = true

} else if (char == '-') {

flags.left = true

} else if (char == '+') {

flags.sign = '+'

} else if (char == '0') {

flags.pad_char = '0'

} else if (char == ' ') {

flags.space = true

}

pos++

} else if (char == '*') {

flags.padding = '*'

pos++

} else if (mo = /^\d+/.exec(s.substr(pos))) {

flags.padding = mo[0]

pos += mo[0].length

} else if (char == '.') {

pos++

if (s[pos] == '*') {

flags.precision = '*'

pos++

} else if (mo = /^\d+/.exec(s.substr(pos))) {

flags.precision = mo[0]

pos += mo[0].length

} else {

flags.precision = "0"

}

} else if (length_modifiers.indexOf(char) > -1) {

flags.length_modifier = char

pos++

}else if((conversion_types.indexOf(char) > -1) ||

(char == 'b' && type == 'bytes')){

if (type == 'bytes') {

if (char == 's') {

// for bytes, 's' is an alias for 'b'

char = 'b'

} else if (char == 'r') {

char = 'a'

}

}

flags.conversion_type = char

flags.end = pos

flags.string = s.substring(start_pos, pos + 1)

if (flags.left && flags.pad_char == '0') {

// conversion flag "-" overrides "0" if both are given

flags.pad_char = ' '

}

return flags

} else {

$B.RAISE(_b_.ValueError, `invalid character in format: ${char}`)

}

}

$B.RAISE(_b_.ValueError, 'invalid format')

}

function is_mapping(obj) {

return _b_.hasattr(obj, 'keys') && _b_.hasattr(obj, '__getitem__')

}

$B.printf_format = function(s, type, args) {

// printf-style bytes or string formatting

// s is a string

// type is 'str' or 'bytes', the class of the original formatted object

// args are the arguments passed to %

var argpos = null,

getitem

if ($B.is_tuple(args)) {

argpos = 0

} else {

getitem = $B.$getattr(args, "__getitem__", _b_.None)

}

var ret = '', // return value

nbph = 0, // number of placeholders

pos = 0, // position in s

len = s.length

while (pos < len) {

var fmtpos = s.indexOf("%", pos)

if (fmtpos < 0) {

ret += s.substring(pos)

break

}

ret += s.substring(pos, fmtpos)

pos = fmtpos

if (s[pos + 1] == '%') {

ret += '%'

pos += 2

} else {

nbph++

if (nbph > 1) {

// issue 2184

if((! $B.is_tuple(args)) &&

! is_mapping(args)){

$B.RAISE(_b_.TypeError,

"not enough arguments for format string")

}

}

var fmt = parse_mod_format(s, type, pos)

pos = fmt.end + 1

if (fmt.padding == '*') {

// read value in arguments

if (args[argpos] === undefined) {

$B.RAISE(_b_.ValueError, 'no value for field width *')

}

fmt.padding = args[argpos]

argpos++

}

if (fmt.precision == '*') {

// read value in arguments

if (args[argpos] === undefined) {

$B.RAISE(_b_.ValueError, 'no value for precision *')

}

fmt.precision = args[argpos]

argpos++

}

var func = char_mapping[fmt.conversion_type],

value

if (fmt.mapping_key !== undefined) {

value = $B.$call(getitem, fmt.mapping_key)

} else {

if (argpos === null) {

value = args

} else {

value = args[argpos]

if (value === undefined) {

$B.RAISE(_b_.TypeError,

"not enough arguments for format string")

}

argpos++

}

}

ret += func(value, fmt, type)

}

}

if (argpos !== null) {

if (args.length > argpos) {

$B.RAISE(_b_.TypeError,

"not enough arguments for format string")

} else if (args.length < argpos) {

$B.RAISE(_b_.TypeError,

"not all arguments converted during string formatting")

}

} else if (nbph == 0) {

$B.RAISE(_b_.TypeError,

"not all arguments converted during string formatting")

}

return ret

}

var combining = []

for (var cp = 0x300; cp <= 0x36F; cp++) {

combining.push(String.fromCharCode(cp))

}

var combining_re = new RegExp("(" + combining.join("|") + ")", "g")