Permalink
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Dec 20, 2018
Dec 20, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Jan 14, 2015
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 27, 2019
Mar 19, 2018
Mar 19, 2018
Feb 9, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 2, 2019
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Nov 12, 2018
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 2, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Dec 10, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 14, 2018
Mar 19, 2018
Mar 19, 2018
Jul 28, 2018
Mar 19, 2019
Nov 2, 2018
Nov 2, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jun 29, 2017
Jun 29, 2017
Jun 29, 2017
Jun 29, 2017
Jul 10, 2017
Jul 10, 2017
Mar 19, 2018
Mar 19, 2018
Newer
100644
2114 lines (1940 sloc)
67.2 KB
7
// Polyfill for older browsers
8
// The code does not use a regex to make it a bit faster.
9
// Implementation taken from a comment by Timo on the blog:
10
// http://blog.stevenlevithan.com/archives/faster-trim-javascript
11
String.prototype.trim = function () {
12
var c
13
for(var i = 0; i < this.length; i++){
14
c = this.charCodeAt(i)
15
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
16
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
17
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
18
continue
19
}else{break}
20
}
21
for(var j = this.length - 1; j >= i; j--){
22
c = this.charCodeAt(j)
24
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
25
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
26
continue
27
}else{break}
28
}
29
return this.substring(i, j + 1);
30
}
33
// Convenience method for browsers which do not have a native trimLeft
34
// (which is a nonstandard extension in Firefox and Chrome)
35
String.prototype.trimLeft = function () {
36
var c
37
for(var i = 0; i < this.length; i++){
38
c = this.charCodeAt(i)
40
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
41
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
42
continue
43
}else{break}
44
}
45
return this.substring(i)
49
String.prototype.trimRight = function () {
50
// Convenience method for browsers which do not have a native trimRight
51
// (which is a nonstandard extension in Firefox and Chrome)
52
var c
53
for(var j = this.length - 1; j >= 0; j--){
54
c = this.charCodeAt(j)
55
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
56
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
57
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
58
continue
59
}else{break}
60
}
61
return this.substring(0, j + 1)
79
if($.start === null || $.start === _b_.None){$.start = 0}
80
else if($.start < 0){
81
$.start += $.self.length
82
$.start = Math.max(0, $.start)
83
}
84
if($.end === null || $.end === _b_.None){$.end = $.self.length}
85
else if($.end < 0){
86
$.end += $.self.length
87
$.end = Math.max(0, $.end)
88
}
90
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
91
throw _b_.TypeError.$factory("slice indices must be integers " +
92
"or None or have an __index__ method")
93
}
110
if(!(typeof other === "string")){
111
try{return getattr(other, "__radd__")(self)}
112
catch(err){
113
throw _b_.TypeError.$factory("Can't convert " +
119
str.__contains__ = function(self, item){
120
if(!(typeof item == "string")){
121
throw _b_.TypeError.$factory("'in <string>' requires " +
122
"string as left operand, not " + item.__class__)
123
}
125
if(nbcar == 0) {return true} // a string contains the empty string
126
if(self.length == 0){return nbcar == 0}
127
for(var i = 0, len = self.length; i < len; i++){
128
if(self.substr(i, nbcar) == item){return true}
137
// __dir__must be assigned explicitely because attribute resolution for
138
// builtin classes doesn't use __mro__
142
if(other === undefined){ // compare object "self" to class "str"
143
return self === str
153
if(fmt.type && fmt.type != "s"){
154
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
162
if(fmt.sign !== undefined){
163
throw _b_.ValueError.$factory(
164
"Sign not allowed in string format specifier")
174
if(arg < 0) {pos += self.length}
175
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
176
throw _b_.IndexError.$factory("string index out of range")
177
}
178
if(isinstance(arg, slice)) {
179
var s = _b_.slice.$conv_for_seq(arg, self.length),
180
start = s.start,
181
stop = s.stop,
182
step = s.step
183
var res = "",
185
if(step > 0){
186
if(stop <= start){return ""}
187
for(var i = start; i < stop; i += step){res += self.charAt(i)}
189
if(stop >= start){return ''}
190
for(var i = start; i > stop; i += step){res += self.charAt(i)}
198
var prefix = 2,
199
suffix = 3,
200
mask = (2 ** 32 - 1)
201
function fnv(p){
202
if(p.length == 0){
203
return 0
204
}
206
var x = prefix
207
x = (x ^ (p.charCodeAt(0) << 7)) & mask
208
for(var i = 0, len = p.length; i < len; i++){
209
x = ((1000003 * x) ^ p.charCodeAt(i)) & mask
210
}
211
x = (x ^ p.length) & mask
212
x = (x ^ suffix) & mask
232
var items = self.split("") // list of all characters in string
233
return $B.$iterator(items, $str_iterator)
270
// left adjusted
271
return s + get_char_array(padding - s.length, flags.pad_char)
272
}
273
}
274
282
if(val.__class__ === $B.long_int){
283
s = $B.long_int.to_base(val, 10)
284
}else{
285
s = val.toString()
287
if(s[0] === "-"){
288
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
299
if(val === Infinity){
300
val = "inf"
301
}else if(val === -Infinity){
302
val = "-inf"
303
}else{
304
val = "nan"
326
var str_format = function(val, flags) {
327
// string format supports left and right padding
328
flags.pad_char = " " // even if 0 padding is defined, don't use it
334
if(val.__class__ === $B.long_int){
335
val = $B.long_int.to_base(val, 10)
336
}else{
337
val = parseInt(val)
355
var repr_format = function(val, flags) {
356
flags.pad_char = " " // even if 0 padding is defined, don't use it
357
return format_padding(repr(val), flags)
358
}
360
var ascii_format = function(val, flags) {
361
flags.pad_char = " " // even if 0 padding is defined, don't use it
362
return format_padding(ascii(val), flags)
363
}
375
flags.precision = parseInt(flags.precision, 10)
376
validate_precision(flags.precision)
377
}
378
return parseFloat(val)
379
}
382
var trailing_zeros = /(.*?)(0+)([eE].*)/,
383
leading_zeros = /\.(0*)/,
384
trailing_dot = /\.$/
386
var validate_precision = function(precision) {
387
// force precision to limits of javascript
392
var floating_point_format = function(val, upper, flags){
393
val = _float_helper(val, flags),
394
v = val.toString(),
395
v_len = v.length,
396
dot_idx = v.indexOf('.')
397
if(dot_idx < 0){dot_idx = v_len}
398
if(val < 1 && val > -1){
399
var zeros = leading_zeros.exec(v),
400
numzeros
401
if(zeros){
406
if(numzeros >= 4){
407
val = format_sign(val, flags) + format_float_precision(val, upper,
408
flags, _floating_g_exp_helper)
409
if(!flags.alternate){
422
return format_padding(format_sign(val, flags) +
423
format_float_precision(val, upper, flags,
424
function(val, precision) {
425
return val.toFixed(min(precision, v_len - dot_idx) +
426
numzeros)
427
}),
428
flags
429
)
430
}
431
432
if(dot_idx > flags.precision){
433
val = format_sign(val, flags) + format_float_precision(val, upper,
434
flags, _floating_g_exp_helper)
435
if(! flags.alternate){
447
return format_padding(format_sign(val, flags) +
448
format_float_precision(val, upper, flags,
449
function(val, precision) {
450
if(!flags.decimal_point){
451
precision = min(v_len - 1, 6)
452
}else if (precision > v_len){
453
if(! flags.alternate){
454
precision = v_len
455
}
457
if(precision < dot_idx){
458
precision = dot_idx
459
}
460
return val.toFixed(precision - dot_idx)
461
}),
462
flags
463
)
466
var _floating_g_exp_helper = function(val, precision, flags, upper){
467
if(precision){--precision}
470
var e_idx = val.lastIndexOf("e")
471
if(e_idx > val.length - 4){
472
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
475
return val
476
}
477
478
// fF
479
var floating_point_decimal_format = function(val, upper, flags) {
480
val = _float_helper(val, flags)
481
return format_padding(format_sign(val, flags) +
482
format_float_precision(val, upper, flags,
483
function(val, precision, flags) {
484
val = val.toFixed(precision)
485
if(precision === 0 && flags.alternate){
486
val += '.'
487
}
488
return val
489
}),
490
flags
491
)
492
}
493
494
var _floating_exp_helper = function(val, precision, flags, upper) {
495
val = val.toExponential(precision)
496
// pad exponent to two digits
509
return format_padding(format_sign(val, flags) +
510
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
536
if(flags.alternate){
537
if(ret.charAt(0) === "-"){
538
if(upper){ret = "-0X" + ret.slice(1)}
539
else{ret = "-0x" + ret.slice(1)}
540
}else{
541
if(upper){ret = "0X" + ret}
542
else{ret = "0x" + ret}
552
if(val.__class__ === $B.long_int){
553
ret = $B.long_int.to_base(8)
554
}else{
555
ret = parseInt(val)
556
ret = ret.toString(8)
572
if(flags.alternate){
573
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
574
else{ret = "0o" + ret}
579
var single_char_format = function(val, flags){
580
if(isinstance(val, str) && val.length == 1) return val
581
try{
589
var num_flag = function(c, flags){
590
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
591
flags.pad_char = "0"
597
flags.precision = (flags.precision || "") + c
598
}
599
}
600
601
var decimal_point_flag = function(val, flags) {
603
// can only have one decimal point
604
throw new UnsupportedChar()
605
}
606
flags.decimal_point = true
607
}
608
609
var neg_flag = function(val, flags){
610
flags.pad_char = " " // overrides '0' flag
627
"s": str_format,
628
"d": num_format,
629
"i": num_format,
630
"u": num_format,
631
"o": octal_format,
632
"r": repr_format,
633
"a": ascii_format,
634
"g": function(val, flags){
635
return floating_point_format(val, false, flags)
636
},
637
"G": function(val, flags){return floating_point_format(val, true, flags)},
638
"f": function(val, flags){
639
return floating_point_decimal_format(val, false, flags)
640
},
641
"F": function(val, flags){
642
return floating_point_decimal_format(val, true, flags)
643
},
644
"e": function(val, flags){
645
return floating_point_exponential_format(val, false, flags)
646
},
647
"E": function(val, flags){
648
return floating_point_exponential_format(val, true, flags)
649
},
650
"x": function(val, flags){return signed_hex_format(val, false, flags)},
651
"X": function(val, flags){return signed_hex_format(val, true, flags)},
652
"c": single_char_format,
653
"0": function(val, flags){return num_flag("0", flags)},
654
"1": function(val, flags){return num_flag("1", flags)},
655
"2": function(val, flags){return num_flag("2", flags)},
656
"3": function(val, flags){return num_flag("3", flags)},
657
"4": function(val, flags){return num_flag("4", flags)},
658
"5": function(val, flags){return num_flag("5", flags)},
659
"6": function(val, flags){return num_flag("6", flags)},
660
"7": function(val, flags){return num_flag("7", flags)},
661
"8": function(val, flags){return num_flag("8", flags)},
662
"9": function(val, flags){return num_flag("9", flags)},
663
"-": neg_flag,
664
" ": space_flag,
665
"+": sign_flag,
666
".": decimal_point_flag,
667
"#": alternate_flag
668
}
669
670
// exception thrown when an unsupported char is encountered in legacy format
717
if(self === undefined){
718
throw _b_.TypeError.$factory(
719
"not enough arguments for format string")
746
throw _b_.ValueError.$factory(
747
"unsupported format character '" + invalid_char +
748
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
749
") at index " + newpos)
750
}else if(err.name === "NotANumber"){
751
var try_char = s[newpos],
752
cls = self.__class__
753
if(!cls){
754
if(typeof(self) === "string"){
755
cls = "str"
756
}else{
762
throw _b_.TypeError.$factory("%" + try_char +
763
" format: a number is required, not " + cls)
764
}else{
796
}while(pos < length)
797
798
if(argpos !== null){
799
if(args.length > argpos){
800
throw _b_.TypeError.$factory(
801
"not enough arguments for format string")
802
}else if(args.length < argpos){
803
throw _b_.TypeError.$factory(
804
"not all arguments converted during string formatting")
806
}else if(nbph == 0){
807
throw _b_.TypeError.$factory(
808
"not all arguments converted during string formatting")
816
var $ = $B.args("__mul__", 2, {self: null, other: null},
817
["self", "other"], arguments, {}, null, null)
818
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
819
"Can't multiply sequence by non-int of type '" +
831
res = self.replace(/\\/g, "\\\\")
832
// special cases
833
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
834
replace(new RegExp("\b", "g"), "\\x08").
835
replace(new RegExp("\f", "g"), "\\x0c").
836
replace(new RegExp("\n", "g"), "\\n").
837
replace(new RegExp("\r", "g"), "\\r").
838
replace(new RegExp("\t", "g"), "\\t")
841
if(res.search('"') == -1 && res.search("'") == -1){
842
return "'" + res + "'"
843
}else if(self.search('"') == -1){
844
return '"' + res + '"'
845
}
846
var qesc = new RegExp("'", "g") // to escape single quote
847
res = "'" + res.replace(qesc, "\\'") + "'"
851
str.__setitem__ = function(self, attr, value){
852
throw _b_.TypeError.$factory(
853
"'str' object does not support item assignment")
855
var combining = []
856
for(var cp = 0x300; cp <= 0x36F; cp++){
857
combining.push(String.fromCharCode(cp))
858
}
859
var combining_re = new RegExp("(" + combining.join("|") + ")")
871
$comp_func += "" // source code
872
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
881
var $notimplemented = function(self, other){
882
throw NotImplementedError.$factory(
883
"OPERATOR not implemented for class str")
886
// Copy static methods from unicode
887
var from_unicode = [
888
"title",
889
"capitalize",
890
"casefold",
891
"islower",
892
"isupper",
893
"istitle",
894
"isspace",
895
"isalpha",
896
"isalnum",
897
"isdecimal",
898
"isdigit",
899
"isnumeric",
900
"isidentifier",
901
"isprintable",
902
"lower",
903
"swapcase",
904
"upper"
905
]
911
str.center = function(){
912
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
913
["self", "width", "fillchar"],
914
arguments, {fillchar:" "}, null, null),
915
self = $.self
927
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
928
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
936
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
937
else{_slice = _b_.slice.$factory($.start, $.self.length)}
942
if($.sub.length == 0){
943
if($.start == $.self.length){return 1}
944
else if(substr.length == 0){return 0}
945
return substr.length + 1
947
var n = 0,
948
pos = 0
949
while(pos < substr.length){
950
pos = substr.indexOf($.sub, pos)
951
if(pos >= 0){n++; pos += $.sub.length}
952
else{break}
957
str.encode = function(){
958
var $ = $B.args("encode", 3, {self: null, encoding: null, errors: null},
959
["self", "encoding", "errors"], arguments,
960
{encoding: "utf-8", errors: "strict"}, null, null)
961
if($.encoding == "rot13" || $.encoding == "rot_13"){
966
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
967
res += String.fromCharCode(String.charCodeAt(char) + 13)
968
}else if(("m" < char && char <= "z") ||
969
("M" < char && char <= "Z")){
970
res += String.fromCharCode(String.charCodeAt(char) - 13)
979
// Return True if the string ends with the specified suffix, otherwise
980
// return False. suffix can also be a tuple of suffixes to look for.
981
// With optional start, test beginning at that position. With optional
985
["self", "suffix", "start", "end"],
986
arguments, {start: 0, end: null}, null, null)
993
var s = $.self.substring($.start, $.end)
994
for(var i = 0, len = suffixes.length; i < len; i++){
998
if(suffix.length <= s.length &&
999
s.substr(s.length - suffix.length) == suffix){return true}
1005
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
1006
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
1007
var s = $B.$GetInt($.tabsize),
1008
col = 0,
1009
pos = 0,
1010
res = ""
1011
if(s == 1){return self.replace(/\t/g," ")}
1012
while(pos < self.length){
1020
res += car
1021
col = 0
1022
break
1023
default:
1024
res += car
1025
col++
1026
break
1027
}
1028
pos++
1029
}
1035
// Return the lowest index in the string where substring sub is found,
1036
// such that sub is contained in the slice s[start:end]. Optional
1037
// arguments start and end are interpreted as in slice notation.
1040
{self: null, sub: null, start: null, end: null},
1041
["self", "sub", "start", "end"],
1042
arguments, {start: 0, end: null}, null, null)
1046
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1047
throw _b_.TypeError.$factory("slice indices must be " +
1048
"integers or None or have an __index__ method")}
1049
var s = $.self.substring($.start, $.end)
1051
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1052
if(s.length + $.sub.length == 0){return -1}
1054
var last_search = s.length - $.sub.length
1055
for(var i = 0; i <= last_search; i++){
1056
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1067
// a.x[z]!r:...
1068
// the object has attributes :
1069
// - name : "a"
1070
// - name_ext : [".x", "[z]"]
1071
// - conv : r
1072
// - spec : rest of string after :
1080
// No : in the string : it only contains a name
1081
name = fmt_string
1082
}else{
1083
// name is before the first ":"
1084
// spec (the format specification) is after
1085
name = elts[0]
1089
var elts = name.split("!")
1090
if(elts.length > 1){
1091
name = elts[0]
1092
conv = elts[1] // conversion flag
1096
// "name' may be a subscription or attribute
1097
// Put these "extensions" in the list "name_ext"
1098
function name_repl(match){
1099
name_ext.push(match)
1101
}
1102
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1103
name = name.replace(name_ext_re, name_repl)
1104
}
1111
// Parse self to detect formatting instructions
1112
// Create a list "parts" made of sections of the string :
1113
// - elements of even rank are literal text
1114
// - elements of odd rank are "format objects", built from the
1115
// format strings in self (of the form {...})
1126
text += "{"
1127
pos += 2
1128
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1135
// Store current literal text
1136
parts.push(text)
1137
1138
// Search the end of the format string, ie the } closing the
1139
// opening {. Since the string can contain other pairs {} for
1140
// nested formatting, an integer nb is incremented for each { and
1141
// decremented for each } ; the end of the format string is
1142
// reached when nb == 0
1143
var end = pos + 1,
1144
nb = 1
1145
while(end < _len){
1146
if(self.charAt(end) == "{"){nb++; end++}
1147
else if(self.charAt(end) == "}"){
1148
nb--; end++
1149
if(nb == 0){
1154
var fmt_obj = $B.parse_format(fmt_string)
1155
fmt_obj.raw_name = fmt_obj.name
1156
fmt_obj.raw_spec = fmt_obj.spec
1191
return parts
1192
}
1193
1194
str.format = function(self) {
1195
var $ = $B.args("format", 1, {self: null}, ["self"],
1196
arguments, {}, "$args", "$kw")
1197
1198
var parts = $B.split_format($.self)
1199
1210
1211
if(fmt.spec !== undefined){
1212
// "spec" may contain "nested replacement fields"
1213
// In this case, evaluate them using the positional
1214
// or keyword arguments passed to format()
1215
function replace_nested(name, key){
1216
if(/\d+/.exec(key)){
1217
// If key is numeric, search in positional
1218
// arguments
1219
return _b_.tuple.__getitem__($.$args,
1220
parseInt(key))
1221
}else{
1222
// Else try in keyword arguments
1223
return _b_.dict.__getitem__($.$kw, key)
1224
}
1225
}
1226
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1227
replace_nested)
1228
}
1230
// Numerical reference : use positional arguments
1231
var pos = parseInt(fmt.name),
1241
// Attribute
1242
value = _b_.getattr(value, ext.substr(1))
1243
}else{
1244
// Subscription
1247
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1248
value = _b_.getattr(value, "__getitem__")(key)
1252
// If the conversion flag is set, first call a function to convert
1253
// the value
1254
if(fmt.conv == "a"){value = _b_.ascii(value)}
1255
else if(fmt.conv == "r"){value = _b_.repr(value)}
1256
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1270
throw NotImplementedError.$factory(
1271
"function format_map not implemented yet")
1281
str.isascii = function(self){
1282
// Return true if the string is empty or all characters in the string are
1283
// ASCII, false otherwise. ASCII characters have code points in the range
1284
// U+0000-U+007F.
1285
for(var i = 0, len = self.length; i < len; i++){
1286
if(self.charCodeAt(i) > 127){return false}
1287
}
1288
return true
1289
}
1290
1301
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1302
"sequence item " + count + ": expected str instance, " +
1316
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1317
["self", "width", "fillchar"],
1318
arguments, {fillchar: " "}, null, null)
1325
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1326
arguments, {chars:_b_.None}, null, null)
1327
if($.chars === _b_.None){return $.self.trimLeft()}
1328
for(var i = 0; i < $.self.length; i++){
1329
if($.chars.indexOf($.self.charAt(i)) === -1){
1330
return $.self.substring(i)
1338
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1339
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1344
// If there is only one argument, it must be a dictionary mapping
1345
// Unicode ordinals (integers) or characters (strings of length 1) to
1346
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1348
if(! _b_.isinstance($.x, _b_.dict)){
1349
throw _b_.TypeError.$factory(
1350
"maketrans only argument must be a dict")
1353
for(var i = 0, len = items.length; i < len; i++){
1354
var k = items[i][0],
1355
v = items[i][1]
1356
if(! _b_.isinstance(k, _b_.int)){
1357
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1358
k = _b_.ord(k)
1359
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1362
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1363
throw _b_.TypeError.$factory("dictionary value " + v +
1371
// and in the resulting dictionary, each character in x will be mapped
1372
// to the character at the same position in y
1375
}else if($.x.length !== $.y.length){
1376
throw _b_.TypeError.$factory(
1377
"maketrans arguments must be strings or same length")
1383
if(! _b_.isinstance($.z, _b_.str)){
1384
throw _b_.TypeError.$factory(
1385
"maketrans third argument must be a string")
1392
var key = _b_.ord($.x.charAt(i)),
1393
value = $.y.charAt(i)
1394
_b_.dict.$setitem(_t, key, value)
1405
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1406
arguments, {}, null, null)
1411
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1412
$.self.substring(i + $.sep.length)])
1413
}
1414
1415
function $re_escape(str){
1416
var specials = "[.*+?|()$^"
1417
for(var i = 0, len = specials.length; i < len; i++){
1418
var re = new RegExp("\\"+specials.charAt(i), "g")
1419
str = str.replace(re, "\\"+specials.charAt(i))
1420
}
1421
return str
1428
var $ = $B.args("replace", 4,
1429
{self: null, old: null, $$new: null, count: null},
1430
["self", "old", "$$new", "count"],
1431
arguments, {count: -1}, null, null),
1432
count = $.count,
1433
self = $.self,
1434
old = $.old,
1435
_new = $.$$new
1442
"' object cannot be interpreted as an integer")
1443
}else if(isinstance(count, _b_.float)){
1444
throw _b_.TypeError.$factory("integer argument expected, got float")
1445
}
1446
if(count == 0){return self}
1447
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1448
if(old == ""){
1449
if(_new == ""){return self}
1450
if(self == ""){return _new}
1451
var elts = self.split("")
1452
if(count > -1 && elts.length >= count){
1453
var rest = elts.slice(count).join("")
1454
return _new + elts.slice(0, count).join(_new) + rest
1455
}else{return _new + elts.join(_new) + _new}
1470
if(count < 0){count = res.length}
1471
while(count > 0){
1472
pos = res.indexOf(old, pos)
1473
if(pos < 0){break}
1474
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1475
pos = pos + _new.length
1476
count--
1482
// Return the highest index in the string where substring sub is found,
1483
// such that sub is contained within s[start:end]. Optional arguments
1486
{self: null, sub: null, start: null, end: null},
1487
["self", "sub", "start", "end"],
1488
arguments, {start: 0, end: null}, null, null)
1500
for(var i = $.end - sublen; i >= $.start; i--){
1501
if($.self.substr(i, sublen) == $.sub){return i}
1508
var res = str.rfind.apply(null, arguments)
1509
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1514
var $ = $B.args("rjust",3,
1515
{self: null, width: null, fillchar: null},
1516
["self", "width", "fillchar"],
1517
arguments, {fillchar: " "}, null, null)
1525
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1526
arguments, {}, null, null)
1530
var items = str.partition(self, sep).reverse()
1531
for(var i = 0; i < items.length; i++){
1532
items[i] = items[i].split("").reverse().join("")
1538
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1539
["self", "sep", "maxsplit"], arguments,
1540
{sep: _b_.None, maxsplit: -1}, null, null),
1541
sep = $.sep
1544
var rev_str = reverse($.self),
1545
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1556
str.rstrip = function(self, x){
1557
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1558
arguments, {chars: _b_.None}, null, null)
1559
if($.chars === _b_.None){return $.self.trimRight()}
1561
if($.chars.indexOf($.self.charAt(j)) == -1){
1562
return $.self.substring(0, j + 1)
1569
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1570
["self", "sep", "maxsplit"], arguments,
1571
{sep: _b_.None, maxsplit: -1}, null, null),
1572
sep = $.sep,
1573
maxsplit = $.maxsplit,
1574
self = $.self,
1575
pos = 0
1576
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1577
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1578
if(sep === _b_.None){
1580
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1581
if(pos === self.length - 1){return [self]}
1582
var name = ""
1584
if(self.charAt(pos).search(/\s/) == -1){
1585
if(name == ""){name = self.charAt(pos)}
1586
else{name += self.charAt(pos)}
1606
var res = [],
1607
s = "",
1608
seplen = sep.length
1609
if(maxsplit == 0){return [self]}
1610
while(pos < self.length){
1611
if(self.substr(pos, seplen) == sep){
1631
["self", "keepends"], arguments, {keepends: false}, null, null)
1632
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1633
throw _b_.TypeError.$factory("integer argument expected, got " +
1640
start = pos,
1641
pos = 0,
1642
self = $.self
1643
while(pos < self.length){
1644
if(self.substr(pos, 2) == "\r\n"){
1645
res.push(self.substring(start, pos + 2))
1646
start = pos + 2
1648
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1649
res.push(self.substring(start, pos + 1))
1650
start = pos + 1
1651
pos = start
1652
}else{pos++}
1653
}
1654
var rest = self.substr(start)
1655
if(rest){res.push(rest)}
1656
return res
1657
}else{
1664
// Return True if string starts with the prefix, otherwise return False.
1665
// prefix can also be a tuple of prefixes to look for. With optional
1666
// start, test string beginning at that position. With optional end,
1668
var $ = $B.args("startswith", 4,
1669
{self: null, prefix: null, start: null, end: null},
1670
["self", "prefix", "start", "end"],
1671
arguments, {start: 0, end: null}, null, null)
1678
var s = $.self.substring($.start, $.end)
1679
for(var i = 0, len = prefixes.length; i < len; i++){
1690
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1691
arguments, {chars: _b_.None}, null, null)
1692
if($.chars === _b_.None){return $.self.trim()}
1693
for(var i = 0; i < $.self.length; i++){
1694
if($.chars.indexOf($.self.charAt(i)) == -1){
1695
break
1698
for(var j = $.self.length - 1; j >= i; j--){
1699
if($.chars.indexOf($.self.charAt(j)) == -1){
1700
break
1708
getitem = $B.$getattr(table, "__getitem__")
1709
for(var i = 0, len = self.length; i < len; i++){
1710
try{
1711
var repl = getitem(self.charCodeAt(i))
1712
if(repl !== _b_.None){
1713
res.push(repl)
1714
}
1715
}catch(err){
1716
res.push(self.charAt(i))
1717
}
1724
["self", "width"], arguments, {}, null, null)
1725
if($.width <= self.length){return self}
1727
case "+":
1728
case "-":
1729
return self.charAt(0) +
1730
"0".repeat($.width - self.length) + self.substr(1)
1748
// class or its subclasses, but the attribute __str__ of the
1749
// class metaclass (usually "type") or its subclasses (usually
1750
// "object")
1751
// The metaclass is the attribute __class__ of the class dictionary
1755
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1756
encoding !== undefined){
1757
// str(bytes, encoding, errors) is equal to
1758
// bytes.decode(encoding, errors)
1759
// Arguments may be passed as keywords (cf. issue #1060)
1760
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
1761
["arg", "encoding", "errors"], arguments,
1762
{encoding: "utf-8", errors: "strict"}, null, null)
1763
return _b_.bytes.decode(arg, $.encoding, $.errors)
1765
var f = $B.$getattr(arg, "__str__", null)
1766
if(f === null ||
1767
// if not better than object.__str__, try __repr__
1768
(arg.__class__ && arg.__class__ !== _b_.object &&
1769
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1770
var f = $B.$getattr(arg, "__repr__")
1771
}
1776
if($B.debug > 1){console.log(err)}
1777
console.log("Warning - no method __str__ or __repr__, " +
1778
"default to toString", arg)
1779
return arg.toString()
1785
if(cls === undefined){
1786
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1810
var args = [],
1811
pos = 0
1812
if(arguments.length > 0){
1813
var args = [arguments[0].valueOf()],
1814
pos = 1
1815
for(var i = 1, len = arguments.length; i < len; i++){
1816
args[pos++] = arguments[i]
1832
// Function to parse the 2nd argument of format()
1833
$B.parse_format_spec = function(spec){
1836
var pos = 0,
1837
aligns = "<>=^",
1838
digits = "0123456789",
1839
types = "bcdeEfFgGnosxX%",
1841
if(align_pos != -1){
1842
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1843
// If the second char is also an alignment specifier, the
1844
// first char is the fill value
1845
this.fill = spec.charAt(0)
1846
this.align = spec.charAt(1)
1847
pos = 2
1848
}else{
1849
// The first character defines alignment : fill defaults to ' '
1864
if(car == "+" || car == "-" || car == " "){
1865
this.sign = car
1866
pos++
1867
car = spec.charAt(pos)
1869
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1870
if(car == "0"){
1879
while(car && digits.indexOf(car) > -1){
1880
if(this.width === undefined){this.width = car}
1881
else{this.width += car}
1882
pos++
1883
car = spec.charAt(pos)
1886
if(this.width === undefined && car == "{"){
1887
// Width is determined by a parameter
1888
var end_param_pos = spec.substr(pos).search("}")
1889
this.width = spec.substring(pos, end_param_pos)
1890
console.log("width", "[" + this.width + "]")
1891
pos += end_param_pos + 1
1892
}
1893
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1894
if(car == "."){
1895
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1896
throw _b_.ValueError.$factory(
1897
"Missing precision in format spec")
1899
this.precision = spec.charAt(pos + 1)
1900
pos += 2
1901
car = spec.charAt(pos)
1902
while(car && digits.indexOf(car) > -1){
1909
if(car && types.indexOf(car) > -1){
1910
this.type = car
1911
pos++
1912
car = spec.charAt(pos)
1913
}
1914
if(pos !== spec.length){
1920
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1921
(this.align || "") +
1922
(this.sign || "") +
1923
(this.alternate ? "#" : "") +
1924
(this.sign_aware ? "0" : "") +
1925
(this.width || "") +
1926
(this.comma ? "," : "") +
1927
(this.precision ? "." + this.precision : "") +
1928
(this.type || "")
1933
if(fmt.width && s.length < fmt.width){
1934
var fill = fmt.fill || " ",
1935
align = fmt.align || "<",
1936
missing = fmt.width - s.length
1938
case "<":
1939
return s + fill.repeat(missing)
1940
case ">":
1941
return fill.repeat(missing) + s
1942
case "=":
1943
if("+-".indexOf(s.charAt(0)) > -1){
1944
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1948
case "^":
1949
var left = parseInt(missing / 2)
1950
return fill.repeat(left) + s + fill.repeat(missing - left)
1963
$B.parse_fstring = function(string){
1964
// Parse a f-string
1965
var elts = [],
1966
pos = 0,
1990
}else{
1991
throw Error(" f-string: single '}' is not allowed")
1992
}
1993
}else{
2015
current += car
2016
i += 2
2017
}else{
2018
throw Error(" f-string: single '}' is not allowed")
2019
}
2020
}else{
2021
current += car
2022
i++
2023
}
2024
}
2026
}else{
2027
// End of expression is the } matching the opening {
2028
// There may be nested braces
2029
var i = pos,
2030
nb_braces = 1,
2052
// backslash is not allowed in expressions
2053
throw Error("f-string expression part cannot include a" +
2054
" backslash")
2061
throw Error("f-string: invalid conversion character:" +
2062
" expected 's', 'r', or 'a'")
2063
}else{
2077
if(string.substr(i, 3) == '"""'){
2078
var end = string.indexOf('"""', i + 3)
2079
if(end == -1){
2080
throw Error("f-string: unterminated string")
2081
}else{
2082
var trs = string.substring(i, end + 3)
2083
trs = trs.replace("\n", "\\n\\")
2088
var end = string.indexOf('"', i + 1)
2089
if(end == -1){
2090
throw Error("f-string: unterminated string")
2091
}else{
2092
current.expression += string.substring(i, end + 1)
2093
i = end + 1