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
Feb 10, 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 19, 2018
Mar 19, 2018
Mar 19, 2018
Feb 9, 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
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
Dec 3, 2015
Dec 3, 2015
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
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
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
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jul 28, 2018
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
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
2045 lines (1877 sloc)
65.3 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)
76
if($.start === null || $.start === _b_.None){$.start = 0}
77
else if($.start < 0){
78
$.start += $.self.length
79
$.start = Math.max(0, $.start)
80
}
81
if($.end === null || $.end === _b_.None){$.end = $.self.length}
82
else if($.end < 0){
83
$.end += $.self.length
84
$.end = Math.max(0, $.end)
85
}
87
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
88
throw _b_.TypeError.$factory("slice indices must be integers " +
89
"or None or have an __index__ method")
90
}
107
if(!(typeof other === "string")){
108
try{return getattr(other, "__radd__")(self)}
109
catch(err){
110
throw _b_.TypeError.$factory("Can't convert " +
116
str.__contains__ = function(self, item){
117
if(!(typeof item == "string")){
118
throw _b_.TypeError.$factory("'in <string>' requires " +
119
"string as left operand, not " + item.__class__)
120
}
122
if(nbcar == 0) {return true} // a string contains the empty string
123
if(self.length == 0){return nbcar == 0}
124
for(var i = 0, len = self.length; i < len; i++){
125
if(self.substr(i, nbcar) == item){return true}
134
// __dir__must be assigned explicitely because attribute resolution for
135
// builtin classes doesn't use __mro__
139
if(other === undefined){ // compare object "self" to class "str"
140
return self === str
150
if(fmt.type && fmt.type != "s"){
151
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
159
if(fmt.sign !== undefined){
160
throw _b_.ValueError.$factory(
161
"Sign not allowed in string format specifier")
171
if(arg < 0) {pos += self.length}
172
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
173
throw _b_.IndexError.$factory("string index out of range")
174
}
175
if(isinstance(arg, slice)) {
176
var s = _b_.slice.$conv_for_seq(arg, self.length),
177
start = s.start,
178
stop = s.stop,
179
step = s.step
180
var res = "",
182
if(step > 0){
183
if(stop <= start){return ""}
184
for(var i = start; i < stop; i += step){res += self.charAt(i)}
186
if(stop >= start){return ''}
187
for(var i = start; i > stop; i += step){res += self.charAt(i)}
197
return str.__hashvalue__ || $B.$py_next_hash-- // for hash of string type (not instance of string)
200
//http://stackoverflow.com/questions/2909106/python-whats-a-correct-and-good-way-to-implement-hash
201
// this implementation for strings maybe good enough for us..
202
219
var items = self.split("") // list of all characters in string
220
return $B.$iterator(items, $str_iterator)
257
// left adjusted
258
return s + get_char_array(padding - s.length, flags.pad_char)
259
}
260
}
261
269
if(val.__class__ === $B.long_int){
270
s = $B.long_int.to_base(val, 10)
271
}else{
272
s = val.toString()
274
if(s[0] === "-"){
275
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
286
if(val === Infinity){
287
val = "inf"
288
}else if(val === -Infinity){
289
val = "-inf"
290
}else{
291
val = "nan"
313
var str_format = function(val, flags) {
314
// string format supports left and right padding
315
flags.pad_char = " " // even if 0 padding is defined, don't use it
321
if(val.__class__ === $B.long_int){
322
val = $B.long_int.to_base(val, 10)
323
}else{
324
val = parseInt(val)
342
var repr_format = function(val, flags) {
343
flags.pad_char = " " // even if 0 padding is defined, don't use it
344
return format_padding(repr(val), flags)
345
}
347
var ascii_format = function(val, flags) {
348
flags.pad_char = " " // even if 0 padding is defined, don't use it
349
return format_padding(ascii(val), flags)
350
}
362
flags.precision = parseInt(flags.precision, 10)
363
validate_precision(flags.precision)
364
}
365
return parseFloat(val)
366
}
369
var trailing_zeros = /(.*?)(0+)([eE].*)/,
370
leading_zeros = /\.(0*)/,
371
trailing_dot = /\.$/
373
var validate_precision = function(precision) {
374
// force precision to limits of javascript
379
var floating_point_format = function(val, upper, flags){
380
val = _float_helper(val, flags),
381
v = val.toString(),
382
v_len = v.length,
383
dot_idx = v.indexOf('.')
384
if(dot_idx < 0){dot_idx = v_len}
385
if(val < 1 && val > -1){
386
var zeros = leading_zeros.exec(v),
387
numzeros
388
if(zeros){
393
if(numzeros >= 4){
394
val = format_sign(val, flags) + format_float_precision(val, upper,
395
flags, _floating_g_exp_helper)
396
if(!flags.alternate){
409
return format_padding(format_sign(val, flags) +
410
format_float_precision(val, upper, flags,
411
function(val, precision) {
412
return val.toFixed(min(precision, v_len - dot_idx) +
413
numzeros)
414
}),
415
flags
416
)
417
}
418
419
if(dot_idx > flags.precision){
420
val = format_sign(val, flags) + format_float_precision(val, upper,
421
flags, _floating_g_exp_helper)
422
if(! flags.alternate){
434
return format_padding(format_sign(val, flags) +
435
format_float_precision(val, upper, flags,
436
function(val, precision) {
437
if(!flags.decimal_point){
438
precision = min(v_len - 1, 6)
439
}else if (precision > v_len){
440
if(! flags.alternate){
441
precision = v_len
442
}
444
if(precision < dot_idx){
445
precision = dot_idx
446
}
447
return val.toFixed(precision - dot_idx)
448
}),
449
flags
450
)
453
var _floating_g_exp_helper = function(val, precision, flags, upper){
454
if(precision){--precision}
457
var e_idx = val.lastIndexOf("e")
458
if(e_idx > val.length - 4){
459
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
462
return val
463
}
464
465
// fF
466
var floating_point_decimal_format = function(val, upper, flags) {
467
val = _float_helper(val, flags)
468
return format_padding(format_sign(val, flags) +
469
format_float_precision(val, upper, flags,
470
function(val, precision, flags) {
471
val = val.toFixed(precision)
472
if(precision === 0 && flags.alternate){
473
val += '.'
474
}
475
return val
476
}),
477
flags
478
)
479
}
480
481
var _floating_exp_helper = function(val, precision, flags, upper) {
482
val = val.toExponential(precision)
483
// pad exponent to two digits
496
return format_padding(format_sign(val, flags) +
497
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
523
if(flags.alternate){
524
if(ret.charAt(0) === "-"){
525
if(upper){ret = "-0X" + ret.slice(1)}
526
else{ret = "-0x" + ret.slice(1)}
527
}else{
528
if(upper){ret = "0X" + ret}
529
else{ret = "0x" + ret}
539
if(val.__class__ === $B.long_int){
540
ret = $B.long_int.to_base(8)
541
}else{
542
ret = parseInt(val)
543
ret = ret.toString(8)
559
if(flags.alternate){
560
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
561
else{ret = "0o" + ret}
566
var single_char_format = function(val, flags){
567
if(isinstance(val, str) && val.length == 1) return val
568
try{
576
var num_flag = function(c, flags){
577
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
578
flags.pad_char = "0"
584
flags.precision = (flags.precision || "") + c
585
}
586
}
587
588
var decimal_point_flag = function(val, flags) {
590
// can only have one decimal point
591
throw new UnsupportedChar()
592
}
593
flags.decimal_point = true
594
}
595
596
var neg_flag = function(val, flags){
597
flags.pad_char = " " // overrides '0' flag
614
"s": str_format,
615
"d": num_format,
616
"i": num_format,
617
"u": num_format,
618
"o": octal_format,
619
"r": repr_format,
620
"a": ascii_format,
621
"g": function(val, flags){
622
return floating_point_format(val, false, flags)
623
},
624
"G": function(val, flags){return floating_point_format(val, true, flags)},
625
"f": function(val, flags){
626
return floating_point_decimal_format(val, false, flags)
627
},
628
"F": function(val, flags){
629
return floating_point_decimal_format(val, true, flags)
630
},
631
"e": function(val, flags){
632
return floating_point_exponential_format(val, false, flags)
633
},
634
"E": function(val, flags){
635
return floating_point_exponential_format(val, true, flags)
636
},
637
"x": function(val, flags){return signed_hex_format(val, false, flags)},
638
"X": function(val, flags){return signed_hex_format(val, true, flags)},
639
"c": single_char_format,
640
"0": function(val, flags){return num_flag("0", flags)},
641
"1": function(val, flags){return num_flag("1", flags)},
642
"2": function(val, flags){return num_flag("2", flags)},
643
"3": function(val, flags){return num_flag("3", flags)},
644
"4": function(val, flags){return num_flag("4", flags)},
645
"5": function(val, flags){return num_flag("5", flags)},
646
"6": function(val, flags){return num_flag("6", flags)},
647
"7": function(val, flags){return num_flag("7", flags)},
648
"8": function(val, flags){return num_flag("8", flags)},
649
"9": function(val, flags){return num_flag("9", flags)},
650
"-": neg_flag,
651
" ": space_flag,
652
"+": sign_flag,
653
".": decimal_point_flag,
654
"#": alternate_flag
655
}
656
657
// exception thrown when an unsupported char is encountered in legacy format
704
if(self === undefined){
705
throw _b_.TypeError.$factory(
706
"not enough arguments for format string")
733
throw _b_.ValueError.$factory(
734
"unsupported format character '" + invalid_char +
735
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
736
") at index " + newpos)
737
}else if(err.name === "NotANumber"){
738
var try_char = s[newpos],
739
cls = self.__class__
740
if(!cls){
741
if(typeof(self) === "string"){
742
cls = "str"
743
}else{
749
throw _b_.TypeError.$factory("%" + try_char +
750
" format: a number is required, not " + cls)
751
}else{
783
}while(pos < length)
784
785
if(argpos !== null){
786
if(args.length > argpos){
787
throw _b_.TypeError.$factory(
788
"not enough arguments for format string")
789
}else if(args.length < argpos){
790
throw _b_.TypeError.$factory(
791
"not all arguments converted during string formatting")
793
}else if(nbph == 0){
794
throw _b_.TypeError.$factory(
795
"not all arguments converted during string formatting")
803
var $ = $B.args("__mul__", 2, {self: null, other: null},
804
["self", "other"], arguments, {}, null, null)
805
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
806
"Can't multiply sequence by non-int of type '" +
807
$B.get_class($.other).__name__ + "'")}
808
var $res = ""
809
for(var i = 0; i< $.other; i++){$res += $.self.valueOf()}
818
res = self.replace(/\\/g, "\\\\")
819
// special cases
820
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
821
replace(new RegExp("\b", "g"), "\\x08").
822
replace(new RegExp("\f", "g"), "\\x0c").
823
replace(new RegExp("\n", "g"), "\\n").
824
replace(new RegExp("\r", "g"), "\\r").
825
replace(new RegExp("\t", "g"), "\\t")
826
if(res.search('"') == -1 && res.search("'") == -1){
827
return "'" + res + "'"
828
}else if(self.search('"') == -1){
829
return '"' + res + '"'
830
}
831
var qesc = new RegExp("'", "g") // to escape single quote
832
res = "'" + res.replace(qesc, "\\'") + "'"
836
str.__setitem__ = function(self, attr, value){
837
throw _b_.TypeError.$factory(
838
"'str' object does not support item assignment")
848
if(typeof other !== "string"){throw _b_.TypeError.$factory(
849
"unorderable types: 'str' > " + $B.get_class(other).__name__ + "()")}
852
$comp_func += "" // source code
853
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
862
var $notimplemented = function(self, other){
863
throw NotImplementedError.$factory(
864
"OPERATOR not implemented for class str")
867
// Copy static methods from unicode
868
var from_unicode = [
869
"title",
870
"capitalize",
871
"casefold",
872
"islower",
873
"isupper",
874
"istitle",
875
"isspace",
876
"isalpha",
877
"isalnum",
878
"isdecimal",
879
"isdigit",
880
"isnumeric",
881
"isidentifier",
882
"isprintable",
883
"lower",
884
"swapcase",
885
"upper"
886
]
892
str.center = function(){
893
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
894
["self", "width", "fillchar"],
895
arguments, {fillchar:" "}, null, null),
896
self = $.self
908
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
909
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
911
if(!(typeof $.sub == "string")){throw _b_.TypeError.$factory(
912
"Can't convert '" + $B.get_class($.sub).__name__ +
913
"' object to str implicitly")}
917
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
918
else{_slice = _b_.slice.$factory($.start, $.self.length)}
923
if($.sub.length == 0){
924
if($.start == $.self.length){return 1}
925
else if(substr.length == 0){return 0}
926
return substr.length + 1
928
var n = 0,
929
pos = 0
930
while(pos < substr.length){
931
pos = substr.indexOf($.sub, pos)
932
if(pos >= 0){n++; pos += $.sub.length}
933
else{break}
945
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
946
res += String.fromCharCode(String.charCodeAt(char) + 13)
947
}else if(("m" < char && char <= "z") ||
948
("M" < char && char <= "Z")){
949
res += String.fromCharCode(String.charCodeAt(char) - 13)
958
// Return True if the string ends with the specified suffix, otherwise
959
// return False. suffix can also be a tuple of suffixes to look for.
960
// With optional start, test beginning at that position. With optional
964
["self", "suffix", "start", "end"],
965
arguments, {start: 0, end: null}, null, null)
972
var s = $.self.substring($.start, $.end)
973
for(var i = 0, len = suffixes.length; i < len; i++){
977
if(suffix.length <= s.length &&
978
s.substr(s.length - suffix.length) == suffix){return true}
984
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
985
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
986
var s = $B.$GetInt($.tabsize),
987
col = 0,
988
pos = 0,
989
res = ""
990
if(s == 1){return self.replace(/\t/g," ")}
991
while(pos < self.length){
999
res += car
1000
col = 0
1001
break
1002
default:
1003
res += car
1004
col++
1005
break
1006
}
1007
pos++
1008
}
1014
// Return the lowest index in the string where substring sub is found,
1015
// such that sub is contained in the slice s[start:end]. Optional
1016
// arguments start and end are interpreted as in slice notation.
1019
{self: null, sub: null, start: null, end: null},
1020
["self", "sub", "start", "end"],
1021
arguments, {start: 0, end: null}, null, null)
1025
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1026
throw _b_.TypeError.$factory("slice indices must be " +
1027
"integers or None or have an __index__ method")}
1028
var s = $.self.substring($.start, $.end)
1030
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1031
if(s.length + $.sub.length == 0){return -1}
1033
var last_search = s.length - $.sub.length
1034
for(var i = 0; i <= last_search; i++){
1035
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1046
// a.x[z]!r:...
1047
// the object has attributes :
1048
// - name : "a"
1049
// - name_ext : [".x", "[z]"]
1050
// - conv : r
1051
// - spec : rest of string after :
1059
// No : in the string : it only contains a name
1060
name = fmt_string
1061
}else{
1062
// name is before the first ":"
1063
// spec (the format specification) is after
1064
name = elts[0]
1068
var elts = name.split("!")
1069
if(elts.length > 1){
1070
name = elts[0]
1071
conv = elts[1] // conversion flag
1072
if(conv.length !== 1 || "ras".search(conv) == -1){
1073
throw _b_.ValueError.$factory("wrong conversion flag " + conv)
1078
// "name' may be a subscription or attribute
1079
// Put these "extensions" in the list "name_ext"
1080
function name_repl(match){
1081
name_ext.push(match)
1083
}
1084
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1085
name = name.replace(name_ext_re, name_repl)
1086
}
1093
var $ = $B.args("format", 1, {self: null}, ["self"],
1094
arguments, {}, "$args", "$kw")
1095
1096
// Parse self to detect formatting instructions
1097
// Create a list "parts" made of sections of the string :
1098
// - elements of even rank are literal text
1099
// - elements of odd rank are "format objects", built from the
1100
// format strings in self (of the form {...})
1111
text += "{"
1112
pos += 2
1113
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1120
// Store current literal text
1121
parts.push(text)
1122
1123
// Search the end of the format string, ie the } closing the
1124
// opening {. Since the string can contain other pairs {} for
1125
// nested formatting, an integer nb is incremented for each { and
1126
// decremented for each } ; the end of the format string is
1127
// reached when nb == 0
1128
var end = pos + 1,
1129
nb = 1
1130
while(end < _len){
1131
if(self.charAt(end) == "{"){nb++; end++}
1132
else if(self.charAt(end) == "}"){
1133
nb--; end++
1134
if(nb == 0){
1137
1138
// Create a format object, by function parse_format
1139
var fmt_obj = parse_format(fmt_string)
1140
1141
// If no name is explicitely provided, use the rank
1142
if(!fmt_obj.name){
1149
// In this case, evaluate them using the positional
1150
// or keyword arguments passed to format()
1152
if(/\d+/.exec(key)){
1153
// If key is numeric, search in positional
1154
// arguments
1177
if(text){parts.push(text)}
1178
// Apply formatting to the values passed to format()
1188
// Numerical reference : use positional arguments
1189
var pos = parseInt(fmt.name),
1199
// Attribute
1200
value = _b_.getattr(value, ext.substr(1))
1201
}else{
1202
// Subscription
1205
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1206
value = _b_.getattr(value, "__getitem__")(key)
1210
// If the conversion flag is set, first call a function to convert
1211
// the value
1212
if(fmt.conv == "a"){value = _b_.ascii(value)}
1213
else if(fmt.conv == "r"){value = _b_.repr(value)}
1214
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1228
throw NotImplementedError.$factory(
1229
"function format_map not implemented yet")
1249
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1250
"sequence item " + count + ": expected str instance, " +
1251
$B.get_class(obj2).__name__ + " found")}
1264
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1265
["self", "width", "fillchar"],
1266
arguments, {fillchar: " "}, null, null)
1273
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1274
arguments, {chars:_b_.None}, null, null)
1275
if($.chars === _b_.None){return $.self.trimLeft()}
1276
for(var i = 0; i < $.self.length; i++){
1277
if($.chars.indexOf($.self.charAt(i)) === -1){
1278
return $.self.substring(i)
1286
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1287
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1294
// If there is only one argument, it must be a dictionary mapping
1295
// Unicode ordinals (integers) or characters (strings of length 1) to
1296
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1298
if(! _b_.isinstance($.x, _b_.dict)){
1299
throw _b_.TypeError.$factory(
1300
"maketrans only argument must be a dict")
1303
for(var i = 0, len = items.length; i < len; i++){
1304
var k = items[i][0],
1305
v = items[i][1]
1306
if(! _b_.isinstance(k, _b_.int)){
1307
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1308
k = _b_.ord(k)
1309
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1312
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1313
throw _b_.TypeError.$factory("dictionary value " + v +
1321
// and in the resulting dictionary, each character in x will be mapped
1322
// to the character at the same position in y
1325
}else if($.x.length !== $.y.length){
1326
throw _b_.TypeError.$factory(
1327
"maketrans arguments must be strings or same length")
1333
if(! _b_.isinstance($.z, _b_.str)){
1334
throw _b_.TypeError.$factory(
1335
"maketrans third argument must be a string")
1341
for(var i = 0, len = $.x.length; i < len; i++){
1342
_t.$numeric_dict[_b_.ord($.x.charAt(i))] =
1343
_b_.ord($.y.charAt(i))
1344
}
1345
for(var k in toNone){
1346
_t.$numeric_dict[k] = _b_.None
1347
}
1348
return _t
1349
}
1350
}
1354
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1355
arguments, {}, null, null)
1360
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1361
$.self.substring(i + $.sep.length)])
1362
}
1363
1364
function $re_escape(str){
1365
var specials = "[.*+?|()$^"
1366
for(var i = 0, len = specials.length; i < len; i++){
1367
var re = new RegExp("\\"+specials.charAt(i), "g")
1368
str = str.replace(re, "\\"+specials.charAt(i))
1369
}
1370
return str
1377
var $ = $B.args("replace", 4,
1378
{self: null, old: null, $$new: null, count: null},
1379
["self", "old", "$$new", "count"],
1380
arguments, {count: -1}, null, null),
1381
count = $.count,
1382
self = $.self,
1383
old = $.old,
1384
_new = $.$$new
1391
"' object cannot be interpreted as an integer")
1392
}else if(isinstance(count, _b_.float)){
1393
throw _b_.TypeError.$factory("integer argument expected, got float")
1394
}
1395
if(count == 0){return self}
1396
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1397
if(old == ""){
1398
if(_new == ""){return self}
1399
if(self == ""){return _new}
1400
var elts = self.split("")
1401
if(count > -1 && elts.length >= count){
1402
var rest = elts.slice(count).join("")
1403
return _new + elts.slice(0, count).join(_new) + rest
1404
}else{return _new + elts.join(_new) + _new}
1419
if(count < 0){count = res.length}
1420
while(count > 0){
1421
pos = res.indexOf(old, pos)
1422
if(pos < 0){break}
1423
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1424
pos = pos + _new.length
1425
count--
1431
// Return the highest index in the string where substring sub is found,
1432
// such that sub is contained within s[start:end]. Optional arguments
1435
{self: null, sub: null, start: null, end: null},
1436
["self", "sub", "start", "end"],
1437
arguments, {start: 0, end: null}, null, null)
1449
for(var i = $.end - sublen; i >= $.start; i--){
1450
if($.self.substr(i, sublen) == $.sub){return i}
1457
var res = str.rfind.apply(null, arguments)
1458
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1463
var $ = $B.args("rjust",3,
1464
{self: null, width: null, fillchar: null},
1465
["self", "width", "fillchar"],
1466
arguments, {fillchar: " "}, null, null)
1474
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1475
arguments, {}, null, null)
1479
var items = str.partition(self, sep).reverse()
1480
for(var i = 0; i < items.length; i++){
1481
items[i] = items[i].split("").reverse().join("")
1487
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1488
["self", "sep", "maxsplit"], arguments,
1489
{sep: _b_.None, maxsplit: -1}, null, null),
1490
sep = $.sep
1493
var rev_str = reverse($.self),
1494
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1505
str.rstrip = function(self, x){
1506
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1507
arguments, {chars: _b_.None}, null, null)
1508
if($.chars === _b_.None){return $.self.trimRight()}
1510
if($.chars.indexOf($.self.charAt(j)) == -1){
1511
return $.self.substring(0, j + 1)
1518
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1519
["self", "sep", "maxsplit"], arguments,
1520
{sep: _b_.None, maxsplit: -1}, null, null),
1521
sep = $.sep,
1522
maxsplit = $.maxsplit,
1523
self = $.self,
1524
pos = 0
1525
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1526
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1527
if(sep === _b_.None){
1529
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1530
if(pos === self.length - 1){return [self]}
1531
var name = ""
1533
if(self.charAt(pos).search(/\s/) == -1){
1534
if(name == ""){name = self.charAt(pos)}
1535
else{name += self.charAt(pos)}
1555
var res = [],
1556
s = "",
1557
seplen = sep.length
1558
if(maxsplit == 0){return [self]}
1559
while(pos < self.length){
1560
if(self.substr(pos, seplen) == sep){
1580
["self", "keepends"], arguments, {keepends: false}, null, null)
1581
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1582
throw _b_.TypeError.$factory("integer argument expected, got " +
1589
start = pos,
1590
pos = 0,
1591
self = $.self
1592
while(pos < self.length){
1593
if(self.substr(pos, 2) == "\r\n"){
1594
res.push(self.substring(start, pos + 2))
1595
start = pos + 2
1597
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1598
res.push(self.substring(start, pos + 1))
1599
start = pos + 1
1600
pos = start
1601
}else{pos++}
1602
}
1603
var rest = self.substr(start)
1604
if(rest){res.push(rest)}
1605
return res
1606
}else{
1613
// Return True if string starts with the prefix, otherwise return False.
1614
// prefix can also be a tuple of prefixes to look for. With optional
1615
// start, test string beginning at that position. With optional end,
1617
var $ = $B.args("startswith", 4,
1618
{self: null, prefix: null, start: null, end: null},
1619
["self", "prefix", "start", "end"],
1620
arguments, {start: 0, end: null}, null, null)
1627
var s = $.self.substring($.start, $.end)
1628
for(var i = 0, len = prefixes.length; i < len; i++){
1639
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1640
arguments, {chars: _b_.None}, null, null)
1641
if($.chars === _b_.None){return $.self.trim()}
1642
for(var i = 0; i < $.self.length; i++){
1643
if($.chars.indexOf($.self.charAt(i)) == -1){
1644
break
1647
for(var j = $.self.length - 1; j >= i; j--){
1648
if($.chars.indexOf($.self.charAt(j)) == -1){
1649
break
1655
str.translate = function(self,table){
1656
var res = [],
1657
pos = 0
1658
if(isinstance(table, _b_.dict)){
1659
for(var i = 0, len = self.length; i < len; i++){
1660
var repl = _b_.dict.get(table,self.charCodeAt(i), -1)
1661
if(repl == -1){res[pos++] = self.charAt(i)}
1662
else if(repl !== None){res[pos++] = _b_.chr(repl)}
1670
["self", "width"], arguments, {}, null, null)
1671
if($.width <= self.length){return self}
1673
case "+":
1674
case "-":
1675
return self.charAt(0) +
1676
"0".repeat($.width - self.length) + self.substr(1)
1685
case "string":
1686
return arg
1687
case "number":
1688
if(isFinite(arg)){return arg.toString()}
1694
// class or its subclasses, but the attribute __str__ of the
1695
// class metaclass (usually "type") or its subclasses (usually
1696
// "object")
1697
// The metaclass is the attribute __class__ of the class dictionary
1701
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1702
encoding !== undefined){
1703
// str(bytes, encoding, errors) is equal to
1704
// bytes.decode(encoding, errors)
1705
return _b_.bytes.decode(arg, encoding || "utf-8",
1706
errors || "strict")
1707
}
1708
var f = $B.$getattr(arg, "__str__", null)
1709
if(f === null ||
1710
// if not better than object.__str__, try __repr__
1711
(arg.__class__ && arg.__class__ !== _b_.object &&
1712
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1713
var f = $B.$getattr(arg, "__repr__")
1714
}
1719
if($B.debug > 1){console.log(err)}
1720
console.log("Warning - no method __str__ or __repr__, " +
1721
"default to toString", arg)
1722
return arg.toString()
1728
if(cls === undefined){
1729
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1750
var args = [],
1751
pos = 0
1752
if(arguments.length > 0){
1753
var args = [arguments[0].valueOf()],
1754
pos = 1
1755
for(var i = 1, len = arguments.length; i < len; i++){
1756
args[pos++] = arguments[i]
1772
// Function to parse the 2nd argument of format()
1773
$B.parse_format_spec = function(spec){
1777
var pos = 0,
1778
aligns = "<>=^",
1779
digits = "0123456789",
1780
types = "bcdeEfFgGnosxX%",
1782
if(align_pos != -1){
1783
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1784
// If the second char is also an alignment specifier, the
1785
// first char is the fill value
1786
this.fill = spec.charAt(0)
1787
this.align = spec.charAt(1)
1788
pos = 2
1789
}else{
1790
// The first character defines alignment : fill defaults to ' '
1805
if(car == "+" || car == "-" || car == " "){
1806
this.sign = car
1807
pos++
1808
car = spec.charAt(pos)
1810
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1811
if(car == "0"){
1818
while(car && digits.indexOf(car) > -1){
1819
if(this.width === undefined){this.width = car}
1820
else{this.width += car}
1821
pos++
1822
car = spec.charAt(pos)
1824
if(this.width !== undefined){this.width = parseInt(this.width)}
1825
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1826
if(car == "."){
1827
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1828
throw _b_.ValueError.$factory(
1829
"Missing precision in format spec")
1831
this.precision = spec.charAt(pos + 1)
1832
pos += 2
1833
car = spec.charAt(pos)
1834
while(car && digits.indexOf(car) > -1){
1841
if(car && types.indexOf(car) > -1){
1842
this.type = car
1843
pos++
1844
car = spec.charAt(pos)
1845
}
1846
if(pos !== spec.length){
1851
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1852
(this.align || "") +
1853
(this.sign || "") +
1854
(this.alternate ? "#" : "") +
1855
(this.sign_aware ? "0" : "") +
1856
(this.width || "") +
1857
(this.comma ? "," : "") +
1858
(this.precision ? "." + this.precision : "") +
1859
(this.type || "")
1864
if(fmt.width && s.length < fmt.width){
1865
var fill = fmt.fill || " ",
1866
align = fmt.align || "<",
1867
missing = fmt.width - s.length
1869
case "<":
1870
return s + fill.repeat(missing)
1871
case ">":
1872
return fill.repeat(missing) + s
1873
case "=":
1874
if("+-".indexOf(s.charAt(0)) > -1){
1875
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1879
case "^":
1880
var left = parseInt(missing / 2)
1881
return fill.repeat(left) + s + fill.repeat(missing - left)
1894
$B.parse_fstring = function(string){
1895
// Parse a f-string
1896
var elts = [],
1897
pos = 0,
1921
}else{
1922
throw Error(" f-string: single '}' is not allowed")
1923
}
1924
}else{
1946
current += car
1947
i += 2
1948
}else{
1949
throw Error(" f-string: single '}' is not allowed")
1950
}
1951
}else{
1952
current += car
1953
i++
1954
}
1955
}
1957
}else{
1958
// End of expression is the } matching the opening {
1959
// There may be nested braces
1960
var i = pos,
1961
nb_braces = 1,
1983
// backslash is not allowed in expressions
1984
throw Error("f-string expression part cannot include a" +
1985
" backslash")
1992
throw Error("f-string: invalid conversion character:" +
1993
" expected 's', 'r', or 'a'")
1994
}else{
2008
if(string.substr(i, 3) == '"""'){
2009
var end = string.indexOf('"""', i + 3)
2010
if(end == -1){
2011
throw Error("f-string: unterminated string")
2012
}else{
2013
var trs = string.substring(i, end + 3)
2014
trs = trs.replace("\n", "\\n\\")
2019
var end = string.indexOf('"', i + 1)
2020
if(end == -1){
2021
throw Error("f-string: unterminated string")
2022
}else{
2023
current.expression += string.substring(i, end + 1)
2024
i = end + 1