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
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
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
2038 lines (1870 sloc)
64.9 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 = res.replace(/\\/g, "\\\\")
819
if(res.search('"') == -1 && res.search("'") == -1){
820
return "'" + res + "'"
821
}else if(self.search('"') == -1){
822
return '"' + res + '"'
823
}
824
var qesc = new RegExp("'", "g") // to escape single quote
825
res = "'" + res.replace(qesc, "\\'") + "'"
829
str.__setitem__ = function(self, attr, value){
830
throw _b_.TypeError.$factory(
831
"'str' object does not support item assignment")
841
if(typeof other !== "string"){throw _b_.TypeError.$factory(
842
"unorderable types: 'str' > " + $B.get_class(other).__name__ + "()")}
845
$comp_func += "" // source code
846
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
855
var $notimplemented = function(self, other){
856
throw NotImplementedError.$factory(
857
"OPERATOR not implemented for class str")
860
// Copy static methods from unicode
861
var from_unicode = [
862
"title",
863
"capitalize",
864
"casefold",
865
"islower",
866
"isupper",
867
"istitle",
868
"isspace",
869
"isalpha",
870
"isalnum",
871
"isdecimal",
872
"isdigit",
873
"isnumeric",
874
"isidentifier",
875
"isprintable",
876
"lower",
877
"swapcase",
878
"upper"
879
]
885
str.center = function(){
886
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
887
["self", "width", "fillchar"],
888
arguments, {fillchar:" "}, null, null),
889
self = $.self
901
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
902
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
904
if(!(typeof $.sub == "string")){throw _b_.TypeError.$factory(
905
"Can't convert '" + $B.get_class($.sub).__name__ +
906
"' object to str implicitly")}
910
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
911
else{_slice = _b_.slice.$factory($.start, $.self.length)}
916
if($.sub.length == 0){
917
if($.start == $.self.length){return 1}
918
else if(substr.length == 0){return 0}
919
return substr.length + 1
921
var n = 0,
922
pos = 0
923
while(pos < substr.length){
924
pos = substr.indexOf($.sub, pos)
925
if(pos >= 0){n++; pos += $.sub.length}
926
else{break}
938
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
939
res += String.fromCharCode(String.charCodeAt(char) + 13)
940
}else if(("m" < char && char <= "z") ||
941
("M" < char && char <= "Z")){
942
res += String.fromCharCode(String.charCodeAt(char) - 13)
951
// Return True if the string ends with the specified suffix, otherwise
952
// return False. suffix can also be a tuple of suffixes to look for.
953
// With optional start, test beginning at that position. With optional
957
["self", "suffix", "start", "end"],
958
arguments, {start: 0, end: null}, null, null)
965
var s = $.self.substring($.start, $.end)
966
for(var i = 0, len = suffixes.length; i < len; i++){
970
if(suffix.length <= s.length &&
971
s.substr(s.length - suffix.length) == suffix){return true}
977
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
978
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
979
var s = $B.$GetInt($.tabsize),
980
col = 0,
981
pos = 0,
982
res = ""
983
if(s == 1){return self.replace(/\t/g," ")}
984
while(pos < self.length){
992
res += car
993
col = 0
994
break
995
default:
996
res += car
997
col++
998
break
999
}
1000
pos++
1001
}
1007
// Return the lowest index in the string where substring sub is found,
1008
// such that sub is contained in the slice s[start:end]. Optional
1009
// arguments start and end are interpreted as in slice notation.
1012
{self: null, sub: null, start: null, end: null},
1013
["self", "sub", "start", "end"],
1014
arguments, {start: 0, end: null}, null, null)
1018
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1019
throw _b_.TypeError.$factory("slice indices must be " +
1020
"integers or None or have an __index__ method")}
1021
var s = $.self.substring($.start, $.end)
1023
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1024
if(s.length + $.sub.length == 0){return -1}
1026
var last_search = s.length - $.sub.length
1027
for(var i = 0; i <= last_search; i++){
1028
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1039
// a.x[z]!r:...
1040
// the object has attributes :
1041
// - name : "a"
1042
// - name_ext : [".x", "[z]"]
1043
// - conv : r
1044
// - spec : rest of string after :
1052
// No : in the string : it only contains a name
1053
name = fmt_string
1054
}else{
1055
// name is before the first ":"
1056
// spec (the format specification) is after
1057
name = elts[0]
1061
var elts = name.split("!")
1062
if(elts.length > 1){
1063
name = elts[0]
1064
conv = elts[1] // conversion flag
1065
if(conv.length !== 1 || "ras".search(conv) == -1){
1066
throw _b_.ValueError.$factory("wrong conversion flag " + conv)
1071
// "name' may be a subscription or attribute
1072
// Put these "extensions" in the list "name_ext"
1073
function name_repl(match){
1074
name_ext.push(match)
1076
}
1077
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1078
name = name.replace(name_ext_re, name_repl)
1079
}
1086
var $ = $B.args("format", 1, {self: null}, ["self"],
1087
arguments, {}, "$args", "$kw")
1088
1089
// Parse self to detect formatting instructions
1090
// Create a list "parts" made of sections of the string :
1091
// - elements of even rank are literal text
1092
// - elements of odd rank are "format objects", built from the
1093
// format strings in self (of the form {...})
1104
text += "{"
1105
pos += 2
1106
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1113
// Store current literal text
1114
parts.push(text)
1115
1116
// Search the end of the format string, ie the } closing the
1117
// opening {. Since the string can contain other pairs {} for
1118
// nested formatting, an integer nb is incremented for each { and
1119
// decremented for each } ; the end of the format string is
1120
// reached when nb == 0
1121
var end = pos + 1,
1122
nb = 1
1123
while(end < _len){
1124
if(self.charAt(end) == "{"){nb++; end++}
1125
else if(self.charAt(end) == "}"){
1126
nb--; end++
1127
if(nb == 0){
1130
1131
// Create a format object, by function parse_format
1132
var fmt_obj = parse_format(fmt_string)
1133
1134
// If no name is explicitely provided, use the rank
1135
if(!fmt_obj.name){
1142
// In this case, evaluate them using the positional
1143
// or keyword arguments passed to format()
1145
if(/\d+/.exec(key)){
1146
// If key is numeric, search in positional
1147
// arguments
1170
if(text){parts.push(text)}
1171
// Apply formatting to the values passed to format()
1181
// Numerical reference : use positional arguments
1182
var pos = parseInt(fmt.name),
1192
// Attribute
1193
value = _b_.getattr(value, ext.substr(1))
1194
}else{
1195
// Subscription
1198
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1199
value = _b_.getattr(value, "__getitem__")(key)
1203
// If the conversion flag is set, first call a function to convert
1204
// the value
1205
if(fmt.conv == "a"){value = _b_.ascii(value)}
1206
else if(fmt.conv == "r"){value = _b_.repr(value)}
1207
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1221
throw NotImplementedError.$factory(
1222
"function format_map not implemented yet")
1242
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1243
"sequence item " + count + ": expected str instance, " +
1244
$B.get_class(obj2).__name__ + " found")}
1257
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1258
["self", "width", "fillchar"],
1259
arguments, {fillchar: " "}, null, null)
1266
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1267
arguments, {chars:_b_.None}, null, null)
1268
if($.chars === _b_.None){return $.self.trimLeft()}
1269
for(var i = 0; i < $.self.length; i++){
1270
if($.chars.indexOf($.self.charAt(i)) === -1){
1271
return $.self.substring(i)
1279
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1280
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1287
// If there is only one argument, it must be a dictionary mapping
1288
// Unicode ordinals (integers) or characters (strings of length 1) to
1289
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1291
if(! _b_.isinstance($.x, _b_.dict)){
1292
throw _b_.TypeError.$factory(
1293
"maketrans only argument must be a dict")
1296
for(var i = 0, len = items.length; i < len; i++){
1297
var k = items[i][0],
1298
v = items[i][1]
1299
if(! _b_.isinstance(k, _b_.int)){
1300
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1301
k = _b_.ord(k)
1302
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1305
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1306
throw _b_.TypeError.$factory("dictionary value " + v +
1314
// and in the resulting dictionary, each character in x will be mapped
1315
// to the character at the same position in y
1318
}else if($.x.length !== $.y.length){
1319
throw _b_.TypeError.$factory(
1320
"maketrans arguments must be strings or same length")
1326
if(! _b_.isinstance($.z, _b_.str)){
1327
throw _b_.TypeError.$factory(
1328
"maketrans third argument must be a string")
1334
for(var i = 0, len = $.x.length; i < len; i++){
1335
_t.$numeric_dict[_b_.ord($.x.charAt(i))] =
1336
_b_.ord($.y.charAt(i))
1337
}
1338
for(var k in toNone){
1339
_t.$numeric_dict[k] = _b_.None
1340
}
1341
return _t
1342
}
1343
}
1347
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1348
arguments, {}, null, null)
1353
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1354
$.self.substring(i + $.sep.length)])
1355
}
1356
1357
function $re_escape(str){
1358
var specials = "[.*+?|()$^"
1359
for(var i = 0, len = specials.length; i < len; i++){
1360
var re = new RegExp("\\"+specials.charAt(i), "g")
1361
str = str.replace(re, "\\"+specials.charAt(i))
1362
}
1363
return str
1370
var $ = $B.args("replace", 4,
1371
{self: null, old: null, $$new: null, count: null},
1372
["self", "old", "$$new", "count"],
1373
arguments, {count: -1}, null, null),
1374
count = $.count,
1375
self = $.self,
1376
old = $.old,
1377
_new = $.$$new
1384
"' object cannot be interpreted as an integer")
1385
}else if(isinstance(count, _b_.float)){
1386
throw _b_.TypeError.$factory("integer argument expected, got float")
1387
}
1388
if(count == 0){return self}
1389
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1390
if(old == ""){
1391
if(_new == ""){return self}
1392
if(self == ""){return _new}
1393
var elts = self.split("")
1394
if(count > -1 && elts.length >= count){
1395
var rest = elts.slice(count).join("")
1396
return _new + elts.slice(0, count).join(_new) + rest
1397
}else{return _new + elts.join(_new) + _new}
1412
if(count < 0){count = res.length}
1413
while(count > 0){
1414
pos = res.indexOf(old, pos)
1415
if(pos < 0){break}
1416
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1417
pos = pos + _new.length
1418
count--
1424
// Return the highest index in the string where substring sub is found,
1425
// such that sub is contained within s[start:end]. Optional arguments
1428
{self: null, sub: null, start: null, end: null},
1429
["self", "sub", "start", "end"],
1430
arguments, {start: 0, end: null}, null, null)
1442
for(var i = $.end - sublen; i >= $.start; i--){
1443
if($.self.substr(i, sublen) == $.sub){return i}
1450
var res = str.rfind.apply(null, arguments)
1451
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1456
var $ = $B.args("rjust",3,
1457
{self: null, width: null, fillchar: null},
1458
["self", "width", "fillchar"],
1459
arguments, {fillchar: " "}, null, null)
1467
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1468
arguments, {}, null, null)
1472
var items = str.partition(self, sep).reverse()
1473
for(var i = 0; i < items.length; i++){
1474
items[i] = items[i].split("").reverse().join("")
1480
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1481
["self", "sep", "maxsplit"], arguments,
1482
{sep: _b_.None, maxsplit: -1}, null, null),
1483
sep = $.sep
1486
var rev_str = reverse($.self),
1487
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1498
str.rstrip = function(self, x){
1499
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1500
arguments, {chars: _b_.None}, null, null)
1501
if($.chars === _b_.None){return $.self.trimRight()}
1503
if($.chars.indexOf($.self.charAt(j)) == -1){
1504
return $.self.substring(0, j + 1)
1511
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1512
["self", "sep", "maxsplit"], arguments,
1513
{sep: _b_.None, maxsplit: -1}, null, null),
1514
sep = $.sep,
1515
maxsplit = $.maxsplit,
1516
self = $.self,
1517
pos = 0
1518
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1519
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1520
if(sep === _b_.None){
1522
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1523
if(pos === self.length - 1){return [self]}
1524
var name = ""
1526
if(self.charAt(pos).search(/\s/) == -1){
1527
if(name == ""){name = self.charAt(pos)}
1528
else{name += self.charAt(pos)}
1548
var res = [],
1549
s = "",
1550
seplen = sep.length
1551
if(maxsplit == 0){return [self]}
1552
while(pos < self.length){
1553
if(self.substr(pos, seplen) == sep){
1573
["self", "keepends"], arguments, {keepends: false}, null, null)
1574
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1575
throw _b_.TypeError.$factory("integer argument expected, got " +
1582
start = pos,
1583
pos = 0,
1584
self = $.self
1585
while(pos < self.length){
1586
if(self.substr(pos, 2) == "\r\n"){
1587
res.push(self.substring(start, pos + 2))
1588
start = pos + 2
1590
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1591
res.push(self.substring(start, pos + 1))
1592
start = pos + 1
1593
pos = start
1594
}else{pos++}
1595
}
1596
var rest = self.substr(start)
1597
if(rest){res.push(rest)}
1598
return res
1599
}else{
1606
// Return True if string starts with the prefix, otherwise return False.
1607
// prefix can also be a tuple of prefixes to look for. With optional
1608
// start, test string beginning at that position. With optional end,
1610
var $ = $B.args("startswith", 4,
1611
{self: null, prefix: null, start: null, end: null},
1612
["self", "prefix", "start", "end"],
1613
arguments, {start: 0, end: null}, null, null)
1620
var s = $.self.substring($.start, $.end)
1621
for(var i = 0, len = prefixes.length; i < len; i++){
1632
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1633
arguments, {chars: _b_.None}, null, null)
1634
if($.chars === _b_.None){return $.self.trim()}
1635
for(var i = 0; i < $.self.length; i++){
1636
if($.chars.indexOf($.self.charAt(i)) == -1){
1637
break
1640
for(var j = $.self.length - 1; j >= i; j--){
1641
if($.chars.indexOf($.self.charAt(j)) == -1){
1642
break
1648
str.translate = function(self,table){
1649
var res = [],
1650
pos = 0
1651
if(isinstance(table, _b_.dict)){
1652
for(var i = 0, len = self.length; i < len; i++){
1653
var repl = _b_.dict.get(table,self.charCodeAt(i), -1)
1654
if(repl == -1){res[pos++] = self.charAt(i)}
1655
else if(repl !== None){res[pos++] = _b_.chr(repl)}
1663
["self", "width"], arguments, {}, null, null)
1664
if($.width <= self.length){return self}
1666
case "+":
1667
case "-":
1668
return self.charAt(0) +
1669
"0".repeat($.width - self.length) + self.substr(1)
1678
case "string":
1679
return arg
1680
case "number":
1681
if(isFinite(arg)){return arg.toString()}
1687
// class or its subclasses, but the attribute __str__ of the
1688
// class metaclass (usually "type") or its subclasses (usually
1689
// "object")
1690
// The metaclass is the attribute __class__ of the class dictionary
1694
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1695
encoding !== undefined){
1696
// str(bytes, encoding, errors) is equal to
1697
// bytes.decode(encoding, errors)
1698
return _b_.bytes.decode(arg, encoding || "utf-8",
1699
errors || "strict")
1700
}
1711
if($B.debug > 1){console.log(err)}
1712
console.log("Warning - no method __str__ or __repr__, " +
1713
"default to toString", arg)
1721
if(cls === undefined){
1722
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1743
var args = [],
1744
pos = 0
1745
if(arguments.length > 0){
1746
var args = [arguments[0].valueOf()],
1747
pos = 1
1748
for(var i = 1, len = arguments.length; i < len; i++){
1749
args[pos++] = arguments[i]
1765
// Function to parse the 2nd argument of format()
1766
$B.parse_format_spec = function(spec){
1770
var pos = 0,
1771
aligns = "<>=^",
1772
digits = "0123456789",
1773
types = "bcdeEfFgGnosxX%",
1775
if(align_pos != -1){
1776
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1777
// If the second char is also an alignment specifier, the
1778
// first char is the fill value
1779
this.fill = spec.charAt(0)
1780
this.align = spec.charAt(1)
1781
pos = 2
1782
}else{
1783
// The first character defines alignment : fill defaults to ' '
1798
if(car == "+" || car == "-" || car == " "){
1799
this.sign = car
1800
pos++
1801
car = spec.charAt(pos)
1803
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1804
if(car == "0"){
1811
while(car && digits.indexOf(car) > -1){
1812
if(this.width === undefined){this.width = car}
1813
else{this.width += car}
1814
pos++
1815
car = spec.charAt(pos)
1817
if(this.width !== undefined){this.width = parseInt(this.width)}
1818
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1819
if(car == "."){
1820
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1821
throw _b_.ValueError.$factory(
1822
"Missing precision in format spec")
1824
this.precision = spec.charAt(pos + 1)
1825
pos += 2
1826
car = spec.charAt(pos)
1827
while(car && digits.indexOf(car) > -1){
1834
if(car && types.indexOf(car) > -1){
1835
this.type = car
1836
pos++
1837
car = spec.charAt(pos)
1838
}
1839
if(pos !== spec.length){
1844
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1845
(this.align || "") +
1846
(this.sign || "") +
1847
(this.alternate ? "#" : "") +
1848
(this.sign_aware ? "0" : "") +
1849
(this.width || "") +
1850
(this.comma ? "," : "") +
1851
(this.precision ? "." + this.precision : "") +
1852
(this.type || "")
1857
if(fmt.width && s.length < fmt.width){
1858
var fill = fmt.fill || " ",
1859
align = fmt.align || "<",
1860
missing = fmt.width - s.length
1862
case "<":
1863
return s + fill.repeat(missing)
1864
case ">":
1865
return fill.repeat(missing) + s
1866
case "=":
1867
if("+-".indexOf(s.charAt(0)) > -1){
1868
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1872
case "^":
1873
var left = parseInt(missing / 2)
1874
return fill.repeat(left) + s + fill.repeat(missing - left)
1887
$B.parse_fstring = function(string){
1888
// Parse a f-string
1889
var elts = [],
1890
pos = 0,
1914
}else{
1915
throw Error(" f-string: single '}' is not allowed")
1916
}
1917
}else{
1939
current += car
1940
i += 2
1941
}else{
1942
throw Error(" f-string: single '}' is not allowed")
1943
}
1944
}else{
1945
current += car
1946
i++
1947
}
1948
}
1950
}else{
1951
// End of expression is the } matching the opening {
1952
// There may be nested braces
1953
var i = pos,
1954
nb_braces = 1,
1976
// backslash is not allowed in expressions
1977
throw Error("f-string expression part cannot include a" +
1978
" backslash")
1985
throw Error("f-string: invalid conversion character:" +
1986
" expected 's', 'r', or 'a'")
1987
}else{
2001
if(string.substr(i, 3) == '"""'){
2002
var end = string.indexOf('"""', i + 3)
2003
if(end == -1){
2004
throw Error("f-string: unterminated string")
2005
}else{
2006
var trs = string.substring(i, end + 3)
2007
trs = trs.replace("\n", "\\n\\")
2012
var end = string.indexOf('"', i + 1)
2013
if(end == -1){
2014
throw Error("f-string: unterminated string")
2015
}else{
2016
current.expression += string.substring(i, end + 1)
2017
i = end + 1