flt/tools
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f6658f3d52024969d91c2edc832f4c5368d55116
tools/name_code/web/brython.js
flt6 f6658f3d52 First commit 
Former-commit-id: 424079609133edcc501ae185509836ee1181a02c
2022-06-12 19:47:20 +08:00

45872 lines
1.2 MiB
Raw Blame History

// brython.js brython.info
// version [3, 10, 0, 'final', 0]
// implementation [3, 10, 5, 'final', 0]
// version compiled from commented, indented source files at
// github.com/brython-dev/brython
var __BRYTHON__ = __BRYTHON__ || {};
try {
eval("async function* f(){}");
} catch (err) {
console.warn(
"Your browser is not fully supported. If you are using " +
"Microsoft Edge, please upgrade to the latest version"
);
}
(function ($B) {
$B.isWebWorker =
"undefined" !== typeof WorkerGlobalScope &&
"function" === typeof importScripts &&
navigator instanceof WorkerNavigator;
$B.isNode = typeof process !== "undefined" && process.release.name === "node";
var _window;
if ($B.isNode) {
_window = {
location: { href: "", origin: "", pathname: "" },
navigator: { userLanguage: "" },
};
} else {
_window = self;
}
var href = _window.location.href;
$B.protocol = href.split(":")[0];
$B.BigInt = _window.BigInt;
$B.indexedDB = _window.indexedDB;
var $path;
if ($B.brython_path === undefined) {
var this_url;
if ($B.isWebWorker) {
this_url = _window.location.href;
if (this_url.startsWith("blob:")) {
this_url = this_url.substr(5);
}
} else {
var scripts = document.getElementsByTagName("script");
this_url = scripts[scripts.length - 1].src;
}
var elts = this_url.split("/");
elts.pop();
$path = $B.brython_path = elts.join("/") + "/";
} else {
if (!$B.brython_path.endsWith("/")) {
$B.brython_path += "/";
}
$path = $B.brython_path;
}
var path = _window.location.origin + _window.location.pathname,
path_elts = path.split("/");
path_elts.pop();
var $script_dir = ($B.script_dir = path_elts.join("/"));
$B.__ARGV = [];
$B.webworkers = {};
$B.file_cache = {};
$B.$py_src = {};
$B.path = [
$path + "Lib",
$path + "libs",
$script_dir,
$path + "Lib/site-packages",
];
$B.async_enabled = false;
if ($B.async_enabled) {
$B.block = {};
}
$B.imported = {};
$B.precompiled = {};
$B.frames_stack = [];
$B.builtins = Object.create(null);
$B.builtins_scope = {
id: "__builtins__",
module: "__builtins__",
binding: {},
};
$B.builtin_funcs = {};
$B.builtin_classes = [];
$B.__getattr__ = function (attr) {
return this[attr];
};
$B.__setattr__ = function (attr, value) {
if (["debug", "stdout", "stderr"].indexOf(attr) > -1) {
$B[attr] = value;
} else {
throw $B.builtins.AttributeError.$factory(
"__BRYTHON__ object has no attribute " + attr
);
}
};
$B.language = _window.navigator.userLanguage || _window.navigator.language;
$B.locale = "C";
$B.PyCF_ONLY_AST = 1024;
if ($B.isWebWorker) {
$B.charset = "utf-8";
} else {
$B.charset = document.characterSet || document.inputEncoding || "utf-8";
}
$B.max_int = Math.pow(2, 53) - 1;
$B.min_int = -$B.max_int;
$B.max_float = new Number(Number.MAX_VALUE);
$B.min_float = new Number(Number.MIN_VALUE);
$B.special_string_repr = {
8: "\\x08",
9: "\\t",
10: "\\n",
11: "\\x0b",
12: "\\x0c",
13: "\\r",
92: "\\\\",
160: "\\xa0",
};
$B.$py_next_hash = Math.pow(2, 53) - 1;
$B.$py_UUID = 0;
$B.lambda_magic = Math.random().toString(36).substr(2, 8);
$B.set_func_names = function (klass, module) {
if (klass.$infos) {
var name = klass.$infos.__name__;
klass.$infos.__module__ = module;
klass.$infos.__qualname__ = name;
} else {
var name = klass.__name__;
klass.$infos = { __name__: name, __module__: module, __qualname__: name };
}
klass.__module__ = module;
for (var attr in klass) {
if (typeof klass[attr] == "function") {
klass[attr].$infos = {
__doc__: klass[attr].__doc__ || "",
__module__: module,
__qualname__: name + "." + attr,
__name__: attr,
};
if (klass[attr].$type == "classmethod") {
klass[attr].__class__ = $B.method;
}
}
}
};
var has_storage = typeof Storage !== "undefined";
if (has_storage) {
$B.has_local_storage = false;
try {
if (localStorage) {
$B.local_storage = localStorage;
$B.has_local_storage = true;
}
} catch (err) {}
$B.has_session_storage = false;
try {
if (sessionStorage) {
$B.session_storage = sessionStorage;
$B.has_session_storage = true;
}
} catch (err) {}
} else {
$B.has_local_storage = false;
$B.has_session_storage = false;
}
$B.globals = function () {
return $B.frames_stack[$B.frames_stack.length - 1][3];
};
$B.scripts = {};
$B.$options = {};
$B.builtins_repr_check = function (builtin, args) {
var $ = $B.args(
"__repr__",
1,
{ self: null },
["self"],
args,
{},
null,
null
),
self = $.self,
_b_ = $B.builtins;
if (!_b_.isinstance(self, builtin)) {
throw _b_.TypeError.$factory(
"descriptor '__repr__' requires a " +
`'${builtin.$infos.__name__}' object but received a ` +
`'${$B.class_name(self)}'`
);
}
};
$B.update_VFS = function (scripts) {
$B.VFS = $B.VFS || {};
var vfs_timestamp = scripts.$timestamp;
if (vfs_timestamp !== undefined) {
delete scripts.$timestamp;
}
for (var script in scripts) {
if ($B.VFS.hasOwnProperty(script)) {
console.warn("Virtual File System: duplicate entry " + script);
}
$B.VFS[script] = scripts[script];
$B.VFS[script].timestamp = vfs_timestamp;
}
};
$B.add_files = function (files) {
$B.files = $B.files || {};
for (var file in files) {
$B.files[file] = files[file];
}
};
$B.has_file = function (file) {
return $B.files && $B.files.hasOwnProperty(file);
};
$B.python_to_js = function (src, script_id) {
$B.parse_options();
$B.meta_path = $B.$meta_path.slice();
if (!$B.use_VFS) {
$B.meta_path.shift();
}
if (script_id === undefined) {
script_id = "__main__";
}
var root = __BRYTHON__.py2js(src, script_id, script_id),
js = root.to_js();
js = "(function() {\n var $locals_" + script_id + " = {}\n" + js + "\n}())";
return js;
};
_window.py = function (src) {
var root = $B.py2js(src[0], "script", "script"),
js = root.to_js();
$B.set_import_paths();
new Function("$locals_script", js)({});
};
})(__BRYTHON__);
__BRYTHON__.implementation = [3, 10, 5, "final", 0];
__BRYTHON__.__MAGIC__ = "3.10.5";
__BRYTHON__.version_info = [3, 10, 0, "final", 0];
__BRYTHON__.compiled_date = "2022-03-08 08:39:38.604379";
__BRYTHON__.timestamp = 1646725178604;
__BRYTHON__.builtin_module_names = [
"_aio",
"_ajax",
"_ast",
"_base64",
"_binascii",
"_io_classes",
"_json",
"_jsre",
"_locale",
"_multiprocessing",
"_posixsubprocess",
"_profile",
"_sre_utils",
"_string",
"_strptime",
"_svg",
"_symtable",
"_webcomponent",
"_webworker",
"_zlib_utils",
"array",
"bry_re",
"builtins",
"dis",
"encoding_cp932",
"hashlib",
"html_parser",
"long_int",
"marshal",
"math",
"modulefinder",
"posix",
"python_re",
"python_re1",
"python_re2",
"random",
"unicodedata",
];
(function ($B) {
var _b_ = $B.builtins;
function ord(char) {
if (char.length == 1) {
return char.charCodeAt(0);
}
var code = 0x10000;
code += (char.charCodeAt(0) & 0x03ff) << 10;
code += char.charCodeAt(1) & 0x03ff;
return code;
}
function $last(array) {
return array[array.length - 1];
}
var ops = ".,:;+-*/%~^|&=<>[](){}@",
op2 = ["**", "//", ">>", "<<"],
augm_op = "+-*/%~^|&=<>@",
closing = { "}": "{", "]": "[", ")": "(" };
function Token(type, string, start, end, line) {
var res = { type, string, start, end, line };
res[0] = type;
res[1] = string;
res[2] = start.slice(0, 2);
res[3] = end;
res[4] = line;
return res;
}
var errors = {};
function TokenError(message, position) {
if (errors.TokenError === undefined) {
var $error_2 = {
$name: "TokenError",
$qualname: "TokenError",
$is_class: true,
__module__: "tokenize",
};
var error = (errors.TokenError = $B.$class_constructor(
"TokenError",
$error_2,
_b_.tuple.$factory([_b_.Exception]),
["_b_.Exception"],
[]
));
error.__doc__ = _b_.None;
error.$factory = function (message, position) {
return {
__class__: error,
msg: message,
lineno: position[0],
colno: position[1],
};
};
error.__str__ = function (self) {
var s = self.msg;
if (self.lineno > 1) {
s += ` (${self.lineno}, ${self.colno})`;
}
return s;
};
$B.set_func_names(error, "tokenize");
}
var exc = errors.TokenError.$factory(message, position);
console.log("error", exc.__class__, exc.args);
return exc;
}
function get_line_at(src, pos) {
var end = src.substr(pos).search(/[\r\n]/);
return end == -1 ? src.substr(pos) : src.substr(pos, end);
}
function get_comment(src, pos, line_num, line_start, token_name, line) {
var start = pos,
ix;
var t = [];
while (true) {
if (pos >= src.length || (ix = "\r\n".indexOf(src[pos])) > -1) {
t.push(
Token(
"COMMENT",
src.substring(start - 1, pos),
[line_num, start - line_start],
[line_num, pos - line_start + 1],
line
)
);
if (ix !== undefined) {
var nb = 1;
if (src[pos] == "\r" && src[pos + 1] == "\n") {
nb++;
} else if (src[pos] === undefined) {
nb = 0;
}
t.push(
Token(
token_name,
src.substr(pos, nb),
[line_num, pos - line_start + 1],
[line_num, pos - line_start + nb + 1],
line
)
);
if (src[pos] === undefined) {
t.push(
Token(
"NEWLINE",
"\n",
[line_num, pos - line_start + 1],
[line_num, pos - line_start + 2],
""
)
);
}
pos += nb;
}
return { t, pos };
}
pos++;
}
}
function test_num(num_type, char) {
switch (num_type) {
case "":
return $B.unicode_tables.Nd[ord(char)] !== undefined;
case "x":
return "0123456789abcdef".indexOf(char.toLowerCase()) > -1;
case "b":
return "01".indexOf(char) > -1;
case "o":
return "01234567".indexOf(char) > -1;
default:
throw Error("unknown num type " + num_type);
}
}
$B.tokenizer = function* (src) {
var unicode_tables = $B.unicode_tables,
whitespace = " \t\n",
operators = "*+-/%&^~=<>",
allowed_after_identifier = ",.()[]:;",
string_prefix = /^(r|u|R|U|f|F|fr|Fr|fR|FR|rf|rF|Rf|RF)$/,
bytes_prefix = /^(b|B|br|Br|bR|BR|rb|rB|Rb|RB)$/;
var state = "line_start",
char,
cp,
mo,
pos = 0,
start,
quote,
triple_quote,
escaped = false,
string_start,
string,
prefix,
name,
operator,
number,
num_type,
comment,
indent,
indents = [],
braces = [],
line_num = 0,
line_start = 1,
line;
yield Token("ENCODING", "utf-8", [0, 0], [0, 0], "");
while (pos < src.length) {
char = src[pos];
cp = src.charCodeAt(pos);
if (cp >= 0xd800 && cp <= 0xdbff) {
cp = ord(src.substr(pos, 2));
char = src.substr(pos, 2);
pos++;
}
pos++;
switch (state) {
case "line_start":
line = get_line_at(src, pos - 1);
line_start = pos;
line_num++;
if ((mo = /^\f?(\r\n|\r|\n)/.exec(src.substr(pos - 1)))) {
yield Token(
"NL",
mo[0],
[line_num, 0],
[line_num, mo[0].length],
line
);
pos += mo[0].length - 1;
continue;
} else if (char == "#") {
comment = get_comment(src, pos, line_num, line_start, "NL", line);
for (var item of comment.t) {
yield item;
}
pos = comment.pos;
state = "line_start";
continue;
}
indent = 0;
if (char == " ") {
indent = 1;
} else if (char == "\t") {
indent = 8;
}
if (indent) {
while (pos < src.length) {
if (src[pos] == " ") {
indent++;
} else if (src[pos] == "\t") {
indent += 8;
} else {
break;
}
pos++;
}
if (pos == src.length) {
line_num--;
break;
}
if (src[pos] == "#") {
var comment = get_comment(
src,
pos + 1,
line_num,
line_start,
"NL",
line
);
for (var item of comment.t) {
yield item;
}
pos = comment.pos;
continue;
} else if ((mo = /^\f?(\r\n|\r|\n)/.exec(src.substr(pos)))) {
yield Token(
"NL",
"",
[line_num, pos - line_start + 1],
[line_num, pos - line_start + 1 + mo[0].length],
line
);
pos += mo[0].length;
continue;
}
if (indents.length == 0 || indent > $last(indents)) {
indents.push(indent);
yield Token(
"INDENT",
"",
[line_num, 0],
[line_num, indent],
line
);
} else if (indent < $last(indents)) {
var ix = indents.indexOf(indent);
if (ix == -1) {
var error = Error(
"unindent does not match " + "any outer indentation level"
);
error.type = "IndentationError";
error.line_num = line_num;
throw error;
}
for (var i = indents.length - 1; i > ix; i--) {
indents.pop();
yield Token(
"DEDENT",
"",
[line_num, indent],
[line_num, indent],
line
);
}
}
state = null;
} else {
while (indents.length > 0) {
indents.pop();
yield Token(
"DEDENT",
"",
[line_num, indent],
[line_num, indent],
line
);
}
state = null;
pos--;
}
break;
case null:
switch (char) {
case '"':
case "'":
quote = char;
triple_quote = src[pos] == char && src[pos + 1] == char;
string_start = [line_num, pos - line_start, line_start];
if (triple_quote) {
pos += 2;
}
escaped = false;
state = "STRING";
string = "";
prefix = "";
break;
case "#":
var token_name = braces.length > 0 ? "NL" : "NEWLINE";
comment = get_comment(
src,
pos,
line_num,
line_start,
token_name,
line
);
for (var item of comment.t) {
yield item;
}
pos = comment.pos;
if (braces.length == 0) {
state = "line_start";
} else {
state = null;
line_num++;
line_start = pos + 1;
line = get_line_at(src, pos);
}
break;
case "0":
state = "NUMBER";
number = char;
num_type = "";
if (src[pos] && "xbo".indexOf(src[pos].toLowerCase()) > -1) {
number += src[pos];
num_type = src[pos].toLowerCase();
pos++;
}
break;
case ".":
if (src[pos] && unicode_tables.Nd[ord(src[pos])]) {
state = "NUMBER";
num_type = "";
number = char;
} else {
var op = char;
while (src[pos] == char) {
pos++;
op += char;
}
var dot_pos = pos - line_start - op.length + 1;
while (op.length >= 3) {
yield Token(
"OP",
"...",
[line_num, dot_pos],
[line_num, dot_pos + 3],
line
);
op = op.substr(3);
}
for (var i = 0; i < op.length; i++) {
yield Token(
"OP",
".",
[line_num, dot_pos],
[line_num, dot_pos + 1],
line
);
dot_pos++;
}
}
break;
case "\\":
if ((mo = /^\f?(\r\n|\r|\n)/.exec(src.substr(pos)))) {
line_num++;
pos += mo[0].length;
line_start = pos + 1;
line = get_line_at(src, pos);
} else {
yield Token(
"ERRORTOKEN",
char,
[line_num, pos - line_start],
[line_num, pos - line_start + 1],
line
);
}
break;
case "\n":
case "\r":
var token_name = braces.length > 0 ? "NL" : "NEWLINE";
mo = /^\f?(\r\n|\r|\n)/.exec(src.substr(pos - 1));
yield Token(
token_name,
mo[0],
[line_num, pos - line_start],
[line_num, pos - line_start + mo[0].length],
line
);
pos += mo[0].length - 1;
if (token_name == "NEWLINE") {
state = "line_start";
} else {
line_num++;
line_start = pos + 1;
line = get_line_at(src, pos);
}
break;
default:
if (unicode_tables.XID_Start[ord(char)]) {
state = "NAME";
name = char;
} else if (unicode_tables.Nd[ord(char)]) {
state = "NUMBER";
num_type = "";
number = char;
} else if (ops.indexOf(char) > -1) {
var op = char;
if (op2.indexOf(char + src[pos]) > -1) {
op = char + src[pos];
pos++;
}
if (
src[pos] == "=" &&
(op.length == 2 || augm_op.indexOf(op) > -1)
) {
op += src[pos];
pos++;
} else if (
(char == "-" && src[pos] == ">") ||
(char == ":" && src[pos] == "=")
) {
op += src[pos];
pos++;
}
if ("[({".indexOf(char) > -1) {
braces.push(char);
} else if ("])}".indexOf(char) > -1) {
if (braces && $last(braces) == closing[char]) {
braces.pop();
} else {
braces.push(char);
}
}
yield Token(
"OP",
op,
[line_num, pos - line_start - op.length + 1],
[line_num, pos - line_start + 1],
line
);
} else if (char == "!" && src[pos] == "=") {
yield Token(
"OP",
"!=",
[line_num, pos - line_start],
[line_num, pos - line_start + 2],
line
);
pos++;
} else if (char == " " || char == "\t") {
} else {
yield Token(
"ERRORTOKEN",
char,
[line_num, pos - line_start],
[line_num, pos - line_start + 1],
line
);
}
}
break;
case "NAME":
if (unicode_tables.XID_Continue[ord(char)]) {
name += char;
} else if (char == '"' || char == "'") {
if (string_prefix.exec(name) || bytes_prefix.exec(name)) {
state = "STRING";
quote = char;
triple_quote = src[pos] == quote && src[pos + 1] == quote;
prefix = name;
escaped = false;
string_start = [
line_num,
pos - line_start - name.length,
line_start,
];
if (triple_quote) {
pos += 2;
}
string = "";
} else {
yield Token(
"NAME",
name,
[line_num, pos - line_start - name.length],
[line_num, pos - line_start],
line
);
state = null;
pos--;
}
} else {
yield Token(
"NAME",
name,
[line_num, pos - line_start - name.length],
[line_num, pos - line_start],
line
);
state = null;
pos--;
}
break;
case "STRING":
switch (char) {
case quote:
if (!escaped) {
var string_line = line;
if (line_num > string_start[0]) {
string_line = src.substring(string_start[2] - 1, pos + 2);
}
if (!triple_quote) {
var full_string = prefix + quote + string + quote;
yield Token(
"STRING",
full_string,
string_start,
[line_num, pos - line_start + 1],
string_line
);
state = null;
} else if (char + src.substr(pos, 2) == quote.repeat(3)) {
var full_string =
prefix + quote.repeat(3) + string + quote.repeat(3);
triple_quote_line = line;
yield Token(
"STRING",
full_string,
string_start,
[line_num, pos - line_start + 3],
string_line
);
pos += 2;
state = null;
} else {
string += char;
}
} else {
string += char;
}
escaped = false;
break;
case "\r":
case "\n":
if (!escaped && !triple_quote) {
var quote_pos = string_start[1] + line_start - 1,
pos = quote_pos;
while (src[pos - 1] == " ") {
pos--;
}
while (pos < quote_pos) {
console.log("yield ERRORTOKEN, escaped", escaped);
yield Token(
"ERRORTOKEN",
" ",
[line_num, pos - line_start + 1],
[line_num, pos - line_start + 2],
line
);
pos++;
}
pos++;
yield Token(
"ERRORTOKEN",
quote,
[line_num, pos - line_start],
[line_num, pos - line_start + 1],
line
);
state = null;
pos++;
break;
}
string += char;
line_num++;
line_start = pos + 1;
if (char == "\r" && src[pos] == "\n") {
string += src[pos];
line_start++;
pos++;
}
line = get_line_at(src, pos);
escaped = false;
break;
case "\\":
string += char;
escaped = !escaped;
break;
default:
escaped = false;
string += char;
break;
}
break;
case "NUMBER":
if (test_num(num_type, char)) {
number += char;
} else if (char == "_" && !number.endsWith(".")) {
if (number.endsWith("_")) {
throw SyntaxError("consecutive _ in number");
} else if (
src[pos] === undefined ||
!test_num(num_type, src[pos])
) {
yield Token(
"NUMBER",
number,
[line_num, pos - line_start - number.length],
[line_num, pos - line_start],
line
);
state = null;
pos--;
} else {
number += char;
}
} else if (char == "." && number.indexOf(char) == -1) {
number += char;
} else if (
char.toLowerCase() == "e" &&
number.toLowerCase().indexOf("e") == -1
) {
if (
"+-".indexOf(src[pos]) > -1 ||
unicode_tables.Nd[ord(src[pos])]
) {
number += char;
} else {
yield Token(
"NUMBER",
number,
[line_num, pos - line_start - number.length],
[line_num, pos - line_start],
line
);
state = null;
pos--;
}
} else if (
(char == "+" || char == "-") &&
number.toLowerCase().endsWith("e")
) {
number += char;
} else if (char.toLowerCase() == "j") {
number += char;
yield Token(
"NUMBER",
number,
[line_num, pos - line_start - number.length + 1],
[line_num, pos - line_start + 1],
line
);
state = null;
} else {
yield Token(
"NUMBER",
number,
[line_num, pos - line_start - number.length],
[line_num, pos - line_start],
line
);
state = null;
pos--;
}
break;
}
}
if (braces.length > 0) {
throw SyntaxError("EOF in multi-line statement");
}
switch (state) {
case "line_start":
line_num++;
break;
case "NAME":
yield Token(
"NAME",
name,
[line_num, pos - line_start - name.length + 1],
[line_num, pos - line_start + 1],
line
);
break;
case "NUMBER":
yield Token(
"NUMBER",
number,
[line_num, pos - line_start - number.length + 1],
[line_num, pos - line_start + 1],
line
);
break;
case "STRING":
throw SyntaxError(
`unterminated string literal (detected at line ${line_num})`
);
}
if (!src.endsWith("\n") && char != " " && state != line_start) {
yield Token(
"NEWLINE",
"",
[line_num, pos - line_start + 1],
[line_num, pos - line_start + 2],
""
);
line_num++;
}
while (indents.length > 0) {
indents.pop();
yield Token("DEDENT", "", [line_num, 0], [line_num, 0], "");
}
yield Token("ENDMARKER", "", [line_num, 0], [line_num, 0], "");
};
})(__BRYTHON__);
(function ($B) {
$B.ast_classes = {
Add: "",
And: "",
AnnAssign: "target,annotation,value,simple",
Assert: "test,msg",
Assign: "targets,value,type_comment",
AsyncFor: "target,iter,body,orelse,type_comment",
AsyncFunctionDef: "name,args,body,decorator_list,returns,type_comment",
AsyncWith: "items,body,type_comment",
Attribute: "value,attr,ctx",
AugAssign: "target,op,value",
Await: "value",
BinOp: "left,op,right",
BitAnd: "",
BitOr: "",
BitXor: "",
BoolOp: "op,values",
Break: "",
Call: "func,args,keywords",
ClassDef: "name,bases,keywords,body,decorator_list",
Compare: "left,ops,comparators",
Constant: "value,kind",
Continue: "",
Del: "",
Delete: "targets",
Dict: "keys,values",
DictComp: "key,value,generators",
Div: "",
Eq: "",
ExceptHandler: "type,name,body",
Expr: "value",
Expression: "body",
FloorDiv: "",
For: "target,iter,body,orelse,type_comment",
FormattedValue: "value,conversion,format_spec",
FunctionDef: "name,args,body,decorator_list,returns,type_comment",
FunctionType: "argtypes,returns",
GeneratorExp: "elt,generators",
Global: "names",
Gt: "",
GtE: "",
If: "test,body,orelse",
IfExp: "test,body,orelse",
Import: "names",
ImportFrom: "module,names,level",
In: "",
Interactive: "body",
Invert: "",
Is: "",
IsNot: "",
JoinedStr: "values",
LShift: "",
Lambda: "args,body",
List: "elts,ctx",
ListComp: "elt,generators",
Load: "",
Lt: "",
LtE: "",
MatMult: "",
Match: "subject,cases",
MatchAs: "pattern,name",
MatchClass: "cls,patterns,kwd_attrs,kwd_patterns",
MatchMapping: "keys,patterns,rest",
MatchOr: "patterns",
MatchSequence: "patterns",
MatchSingleton: "value",
MatchStar: "name",
MatchValue: "value",
Mod: "",
Module: "body,type_ignores",
Mult: "",
Name: "id,ctx",
NamedExpr: "target,value",
Nonlocal: "names",
Not: "",
NotEq: "",
NotIn: "",
Or: "",
Pass: "",
Pow: "",
RShift: "",
Raise: "exc,cause",
Return: "value",
Set: "elts",
SetComp: "elt,generators",
Slice: "lower,upper,step",
Starred: "value,ctx",
Store: "",
Sub: "",
Subscript: "value,slice,ctx",
Try: "body,handlers,orelse,finalbody",
Tuple: "elts,ctx",
TypeIgnore: "lineno,tag",
UAdd: "",
USub: "",
UnaryOp: "op,operand",
While: "test,body,orelse",
With: "items,body,type_comment",
Yield: "value",
YieldFrom: "value",
alias: "name,asname",
arg: "arg,annotation,type_comment",
arguments: "posonlyargs,args,vararg,kwonlyargs,kw_defaults,kwarg,defaults",
boolop: ["And", "Or"],
cmpop: [
"Eq",
"NotEq",
"Lt",
"LtE",
"Gt",
"GtE",
"Is",
"IsNot",
"In",
"NotIn",
],
comprehension: "target,iter,ifs,is_async",
excepthandler: ["ExceptHandler"],
expr: [
"BoolOp",
"NamedExpr",
"BinOp",
"UnaryOp",
"Lambda",
"IfExp",
"Dict",
"Set",
"ListComp",
"SetComp",
"DictComp",
"GeneratorExp",
"Await",
"Yield",
"YieldFrom",
"Compare",
"Call",
"FormattedValue",
"JoinedStr",
"Constant",
"Attribute",
"Subscript",
"Starred",
"Name",
"List",
"Tuple",
"Slice",
],
expr_context: ["Load", "Store", "Del"],
keyword: "arg,value",
match_case: "pattern,guard,body",
mod: ["Module", "Interactive", "Expression", "FunctionType"],
operator: [
"Add",
"Sub",
"Mult",
"MatMult",
"Div",
"Mod",
"Pow",
"LShift",
"RShift",
"BitOr",
"BitXor",
"BitAnd",
"FloorDiv",
],
pattern: [
"MatchValue",
"MatchSingleton",
"MatchSequence",
"MatchMapping",
"MatchClass",
"MatchStar",
"MatchAs",
"MatchOr",
],
stmt: [
"FunctionDef",
"AsyncFunctionDef",
"ClassDef",
"Return",
"Delete",
"Assign",
"AugAssign",
"AnnAssign",
"For",
"AsyncFor",
"While",
"If",
"With",
"AsyncWith",
"Match",
"Raise",
"Try",
"Assert",
"Import",
"ImportFrom",
"Global",
"Nonlocal",
"Expr",
"Pass",
"Break",
"Continue",
],
type_ignore: ["TypeIgnore"],
unaryop: ["Invert", "Not", "UAdd", "USub"],
withitem: "context_expr,optional_vars",
};
var binary_ops = {
"+": "Add",
"-": "Sub",
"*": "Mult",
"/": "Div",
"//": "FloorDiv",
"%": "Mod",
"**": "Pow",
"<<": "LShift",
">>": "RShift",
"|": "BitOr",
"^": "BitXor",
"&": "BitAnd",
"@": "MatMult",
};
var boolean_ops = { and: "And", or: "Or" };
var comparison_ops = {
"==": "Eq",
"!=": "NotEq",
"<": "Lt",
"<=": "LtE",
">": "Gt",
">=": "GtE",
is: "Is",
is_not: "IsNot",
in: "In",
not_in: "NotIn",
};
var unary_ops = { unary_inv: "Invert", unary_pos: "UAdd", unary_neg: "USub" };
var op_types = ($B.op_types = [
binary_ops,
boolean_ops,
comparison_ops,
unary_ops,
]);
var _b_ = $B.builtins;
var ast = ($B.ast = {});
for (var kl in $B.ast_classes) {
var args = $B.ast_classes[kl],
js = "";
if (typeof args == "string") {
js = `ast.${kl} = function(${args}){\n`;
if (args.length > 0) {
for (var arg of args.split(",")) {
js += ` this.${arg} = ${arg}\n`;
}
}
js += "}";
} else {
js = `ast.${kl} = [${args.map((x) => "ast." + x).join(",")}]\n`;
}
eval(js);
ast[kl].$name = kl;
if (typeof args == "string") {
ast[kl]._fields = args.split(",");
}
}
$B.create_python_ast_classes = function () {
if ($B.python_ast_classes) {
return;
}
$B.python_ast_classes = {};
for (var klass in $B.ast_classes) {
$B.python_ast_classes[klass] = (function (kl) {
var cls = $B.make_class(kl, function (js_node) {
return {
__class__: $B.python_ast_classes[kl],
js_node,
};
});
if (typeof $B.ast_classes[kl] == "string") {
cls._fields = $B.ast_classes[kl].split(",");
}
cls.__mro__ = [$B.AST, _b_.object];
return cls;
})(klass);
}
};
var op2ast_class = ($B.op2ast_class = {}),
ast_types = [ast.BinOp, ast.BoolOp, ast.Compare, ast.UnaryOp];
for (var i = 0; i < 4; i++) {
for (var op in op_types[i]) {
op2ast_class[op] = [ast_types[i], ast[op_types[i][op]]];
}
}
})(__BRYTHON__);
(function ($B) {
$B.produce_ast = false;
Number.isInteger =
Number.isInteger ||
function (value) {
return (
typeof value === "number" &&
isFinite(value) &&
Math.floor(value) === value
);
};
Number.isSafeInteger =
Number.isSafeInteger ||
function (value) {
return (
Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER
);
};
var js, $pos, res, $op;
var _b_ = $B.builtins;
var _window;
if ($B.isNode) {
_window = { location: { href: "", origin: "", pathname: "" } };
} else {
_window = self;
}
$B.parser = {};
var clone = ($B.clone = function (obj) {
var res = {};
for (var attr in obj) {
res[attr] = obj[attr];
}
return res;
});
$B.last = function (table) {
if (table === undefined) {
console.log($B.frames_stack.slice());
}
return table[table.length - 1];
};
$B.list2obj = function (list, value) {
var res = {},
i = list.length;
if (value === undefined) {
value = true;
}
while (i-- > 0) {
res[list[i]] = value;
}
return res;
};
$B.op2method = {
operations: {
"**": "pow",
"//": "floordiv",
"<<": "lshift",
">>": "rshift",
"+": "add",
"-": "sub",
"*": "mul",
"/": "truediv",
"%": "mod",
"@": "matmul",
},
augmented_assigns: {
"//=": "ifloordiv",
">>=": "irshift",
"<<=": "ilshift",
"**=": "ipow",
"+=": "iadd",
"-=": "isub",
"*=": "imul",
"/=": "itruediv",
"%=": "imod",
"&=": "iand",
"|=": "ior",
"^=": "ixor",
"@=": "imatmul",
},
binary: { "&": "and", "|": "or", "~": "invert", "^": "xor" },
comparisons: {
"<": "lt",
">": "gt",
"<=": "le",
">=": "ge",
"==": "eq",
"!=": "ne",
},
boolean: { or: "or", and: "and", in: "in", not: "not", is: "is" },
subset: function () {
var res = {},
keys = [];
if (arguments[0] == "all") {
keys = Object.keys($B.op2method);
keys.splice(keys.indexOf("subset"), 1);
} else {
for (var arg of arguments) {
keys.push(arg);
}
}
for (var key of keys) {
var ops = $B.op2method[key];
if (ops === undefined) {
throw Error(key);
}
for (var attr in ops) {
res[attr] = ops[attr];
}
}
return res;
},
};
var $operators = $B.op2method.subset("all");
$B.method_to_op = {};
for (var category in $B.op2method) {
for (var op in $B.op2method[category]) {
var method = `__${$B.op2method[category][op]}__`;
$B.method_to_op[method] = op;
}
}
var $augmented_assigns = ($B.augmented_assigns =
$B.op2method.augmented_assigns);
var noassign = $B.list2obj(["True", "False", "None", "__debug__"]);
var $op_order = [
["or"],
["and"],
["not"],
["in", "not_in"],
["<", "<=", ">", ">=", "!=", "==", "is", "is_not"],
["|"],
["^"],
["&"],
[">>", "<<"],
["+", "-"],
["*", "@", "/", "//", "%"],
["unary_neg", "unary_inv", "unary_pos"],
["**"],
];
var $op_weight = {},
$weight = 1;
for (var _tmp of $op_order) {
for (var item of _tmp) {
$op_weight[item] = $weight;
}
$weight++;
}
var $loop_num = 0;
if ($B.ast_classes) {
var ast = $B.ast,
op2ast_class = $B.op2ast_class;
function ast_body(block_ctx) {
var body = [];
for (var child of block_ctx.node.children) {
var ctx = child.C.tree[0];
if (
["single_kw", "except", "decorator"].indexOf(ctx.type) > -1 ||
(ctx.type == "condition" && ctx.token == "elif")
) {
continue;
}
var child_ast = ast_or_obj(ctx);
if (ast.expr.indexOf(child_ast.constructor) > -1) {
if ($B.ast_from_js && child_ast.col_offset === undefined) {
console.log("no position", child_ast, child_ast.constructor.$name);
alert();
}
child_ast = new ast.Expr(child_ast);
copy_position(child_ast, child_ast.value);
if ($B.js_from_ast && child_ast.col_offset === undefined) {
console.log("Expr 179", child_ast);
console.log("child", child);
alert();
}
}
body.push(child_ast);
}
return body;
}
var ast_dump = ($B.ast_dump = function (tree, indent) {
indent = indent || 0;
if (tree === _b_.None) {
return "None";
} else if (typeof tree == "string") {
return `'${tree}'`;
} else if (typeof tree == "number") {
return tree + "";
} else if (tree.imaginary) {
return tree.value + "j";
} else if (Array.isArray(tree)) {
if (tree.length == 0) {
return "[]";
}
res = "[\n";
var items = [];
for (var x of tree) {
try {
items.push(ast_dump(x, indent + 1));
} catch (err) {
console.log("error", tree);
console.log("for item", x);
throw err;
}
}
res += items.join(",\n");
return res + "]";
} else if (tree.$name) {
return tree.$name + "()";
} else if (tree instanceof ast.MatchSingleton) {
console.log("dump singleton");
return `MatchSingleton(value=${$B.AST.$convert(tree.value)})`;
} else if (tree instanceof ast.Constant) {
var value = tree.value;
if (value === undefined) {
console.log("bizarre", tree);
}
if (value.imaginary) {
return `Constant(value=${_b_.repr(value.value)}j)`;
}
return `Constant(value=${$B.AST.$convert(value)})`;
}
var proto = Object.getPrototypeOf(tree).constructor;
var res = " ".repeat(indent) + proto.$name + "(";
if ($B.ast_classes[proto.$name] === undefined) {
console.log("pas dans ast_classes", tree, proto, proto.$name);
}
var attr_names = $B.ast_classes[proto.$name].split(","),
attrs = [];
if ([ast.Name].indexOf(proto) > -1) {
for (var attr of attr_names) {
if (tree[attr] !== undefined) {
attrs.push(`${attr}=${ast_dump(tree[attr])}`);
}
}
return res + attrs.join(", ") + ")";
}
for (var attr of attr_names) {
if (tree[attr] !== undefined) {
var value = tree[attr];
attrs.push(attr + "=" + ast_dump(tree[attr], indent + 1).trimStart());
}
}
if (attrs.length > 0) {
res += "\n";
res += attrs.map((x) => " ".repeat(indent + 1) + x).join(",\n");
}
res += ")";
return res;
});
}
function ast_or_obj(obj) {
if (obj.ast) {
return obj.ast();
} else {
console.log("no ast", obj.type || typeof obj, obj);
show_line(obj);
return obj;
}
}
var create_temp_name = ($B.parser.create_temp_name = function (prefix) {
var _prefix = prefix || "$temp";
return _prefix + $loop_num++;
});
var replace_node = ($B.parser.replace_node = function (
replace_what,
replace_with
) {
var parent = replace_what.parent;
var pos = replace_what.parent.children.indexOf(replace_what);
parent.children[pos] = replace_with;
replace_with.parent = parent;
replace_with.bindings = replace_what.bindings;
});
var chained_comp_num = 0;
var $_SyntaxError = ($B.parser.$_SyntaxError = function (C, msg, indent) {
var ctx_node = C;
while (ctx_node.type !== "node") {
ctx_node = ctx_node.parent;
}
var tree_node = ctx_node.node,
root = tree_node;
while (root.parent !== undefined) {
root = root.parent;
}
var module = tree_node.module || $get_module(C).module,
src = root.src,
line_num = tree_node.line_num;
if (C.$pos !== undefined) {
$pos = C.$pos;
}
if (src) {
line_num = src.substr(0, $pos).split("\n").length;
}
if (root.line_info) {
line_num = root.line_info;
}
if (indent === undefined) {
if (msg && Array.isArray(msg)) {
$B.$SyntaxError(module, msg[0], src, $pos, line_num, root);
}
if (msg === "Triple string end not found") {
$B.$SyntaxError(
module,
"invalid syntax : triple string end not found",
src,
$pos,
line_num,
root
);
}
var message = "invalid syntax";
if (msg && !msg.startsWith("token ")) {
message += " (" + msg + ")";
}
$B.$SyntaxError(module, message, src, $pos, line_num, root);
} else if (typeof indent == "number") {
throw $B.$IndentationError(module, msg, src, $pos, line_num, root);
} else {
throw $B.$IndentationError(
module,
msg,
src,
$pos,
line_num,
root,
indent
);
}
});
function check_assignment(C, kwargs) {
var once,
action = "assign to",
augmented = false;
if (kwargs) {
once = kwargs.once;
action = kwargs.action || action;
augmented = kwargs.augmented === undefined ? false : kwargs.augmented;
}
var ctx = C,
forbidden = [
"assert",
"import",
"raise",
"return",
"decorator",
"comprehension",
"await",
];
if (action != "delete") {
forbidden.push("del");
}
function report(wrong_type) {
if (augmented) {
$_SyntaxError(C, [
`'${wrong_type}' is an illegal expression ` +
"for augmented assignment",
]);
} else {
$_SyntaxError(C, [`cannot ${action} ${wrong_type}`]);
}
}
while (ctx) {
if (forbidden.indexOf(ctx.type) > -1) {
$_SyntaxError(C, "assign to " + ctx.type);
} else if (ctx.type == "expr") {
var assigned = ctx.tree[0];
if (assigned.type == "op") {
if ($B.op2method.comparisons[ctx.tree[0].op] !== undefined) {
report("comparison");
} else {
report("operator");
}
} else if (assigned.type == "call") {
report("function call");
} else if (assigned.type == "id") {
var name = assigned.value;
if (["None", "True", "False", "__debug__"].indexOf(name) > -1) {
report(name);
}
if (noassign[name] === true) {
report(keyword);
}
} else if (
["str", "int", "float", "complex"].indexOf(assigned.type) > -1
) {
report("literal");
} else if (assigned.type == "ellipsis") {
report("Ellipsis");
} else if (assigned.type == "genexpr") {
report("generator expression");
} else if (assigned.type == "packed") {
check_assignment(assigned.tree[0], { action, once: true });
} else if (assigned.type == "named_expr") {
report("named expression");
} else if (assigned.type == "list_or_tuple") {
for (var item of ctx.tree) {
check_assignment(item, { action, once: true });
}
}
} else if (ctx.type == "list_or_tuple") {
for (var item of ctx.tree) {
check_assignment(item, { action, once: true });
}
} else if (ctx.type == "ternary") {
report("conditional expression");
} else if (ctx.type == "op") {
report("operator");
} else if (ctx.type == "yield") {
report("yield expression");
} else if (ctx.comprehension) {
break;
}
if (once) {
break;
}
ctx = ctx.parent;
}
}
function remove_abstract_expr(tree) {
if (tree.length > 0 && $B.last(tree).type == "abstract_expr") {
tree.pop();
}
}
$B.format_indent = function (js, indent) {
var indentation = " ",
lines = js.split("\n"),
level = indent,
res = "",
last_is_closing_brace = false,
last_is_backslash = false,
last_is_var_and_comma = false;
for (var i = 0, len = lines.length; i < len; i++) {
var line = lines[i],
add_closing_brace = false,
add_spaces = true;
if (last_is_backslash) {
add_spaces = false;
} else if (last_is_var_and_comma) {
line = " " + line.trim();
} else {
line = line.trim();
}
if (
add_spaces &&
last_is_closing_brace &&
(line.startsWith("else") ||
line.startsWith("catch") ||
line.startsWith("finally"))
) {
res = res.substr(0, res.length - 1);
add_spaces = false;
}
last_is_closing_brace = line.endsWith("}");
if (line.startsWith("}")) {
level--;
} else if (line.endsWith("}")) {
line = line.substr(0, line.length - 1);
add_closing_brace = true;
}
if (level < 0) {
if ($B.debug > 2) {
console.log("wrong js indent");
console.log(res);
}
level = 0;
}
try {
res += (add_spaces ? indentation.repeat(level) : "") + line + "\n";
} catch (err) {
console.log(res);
throw err;
}
if (line.endsWith("{")) {
level++;
} else if (add_closing_brace) {
level--;
if (level < 0) {
level = 0;
}
try {
res += indentation.repeat(level) + "}\n";
} catch (err) {
console.log(res);
throw err;
}
}
last_is_backslash = line.endsWith("\\");
last_is_var_and_comma =
line.endsWith(",") &&
(line.startsWith("var ") || last_is_var_and_comma);
}
return res;
};
function show_line(ctx) {
var lnum = $get_node(ctx).line_num,
src = $get_module(ctx).src;
console.log("this", ctx, "\nline", lnum, src.split("\n")[lnum - 1]);
}
var $Node = ($B.parser.$Node = function (type) {
this.type = type;
this.children = [];
});
$Node.prototype.add = function (child) {
this.children[this.children.length] = child;
child.parent = this;
child.module = this.module;
};
$Node.prototype.ast = function () {
var root_ast = new ast.Module([], []);
root_ast.lineno = this.line_num;
for (var node of this.children) {
var t = node.C.tree[0];
if (
["single_kw", "except", "decorator"].indexOf(t.type) > -1 ||
(t.type == "condition" && t.token == "elif")
) {
continue;
}
var node_ast = ast_or_obj(node.C.tree[0]);
if (ast.expr.indexOf(node_ast.constructor) > -1) {
node_ast = new ast.Expr(node_ast);
copy_position(node_ast, node_ast.value);
}
root_ast.body.push(node_ast);
}
if (this.mode == "eval") {
if (
root_ast.body.length > 1 ||
!(root_ast.body[0] instanceof $B.ast.Expr)
) {
$_SyntaxError(this.children[0].C, [
"eval() argument must be an expression",
]);
}
root_ast = new $B.ast.Expression(root_ast.body[0].value);
copy_position(root_ast, root_ast.body);
}
return root_ast;
};
$Node.prototype.get_indent = function () {
var indent = 0,
node = this;
while (node.parent) {
indent++;
node = node.parent;
}
return indent;
};
$Node.prototype.insert = function (pos, child) {
this.children.splice(pos, 0, child);
child.parent = this;
child.module = this.module;
};
$Node.prototype.toString = function () {
return "<object 'Node'>";
};
$Node.prototype.show = function (indent) {
var res = "";
if (this.type === "module") {
for (var child of this.children) {
res += child.show(indent);
}
return res;
}
indent = indent || 0;
res += " ".repeat(indent);
res += this.C;
if (this.children.length > 0) {
res += "{";
}
res += "\n";
for (var child of this.children) {
res += child.show(indent + 4);
}
if (this.children.length > 0) {
res += " ".repeat(indent);
res += "}\n";
}
return res;
};
$Node.prototype.to_js = function (indent) {
if (this.js !== undefined) {
return this.js;
}
this.res = [];
this.unbound = [];
if (this.type === "module") {
for (var child of this.children) {
this.res.push(child.to_js());
}
this.js = this.res.join("");
return this.js;
}
indent = indent || 0;
var ctx_js = this.C.to_js();
if (ctx_js) {
this.res.push(" ".repeat(indent));
this.res.push(ctx_js);
if (this.children.length > 0) {
this.res.push("{");
}
this.res.push("\n");
for (var child of this.children) {
this.res.push(child.to_js(indent + 4));
}
if (this.children.length > 0) {
this.res.push(" ".repeat(indent));
this.res.push("}\n");
}
}
this.js = this.res.join("");
return this.js;
};
$Node.prototype.transform = function (rank) {
if (this.awaits && this.awaits.length > 0) {
this.parent.insert(rank, $NodeJS("var save_stack = $B.save_stack()"));
if (
!(this.C && this.C.tree.length > 0 && this.C.tree[0].type == "return")
) {
this.parent.insert(
rank + 2,
$NodeJS("$B.restore_stack(save_stack, $locals)")
);
}
delete this.awaits;
return 1;
}
if (this.has_yield && !this.has_yield.transformed) {
var parent = this.parent;
if (this.has_yield.from) {
var new_node = new $Node();
var new_ctx = new $NodeCtx(new_node);
var new_expr = new $ExprCtx(new_ctx, "js", false);
var _id = new $RawJSCtx(
new_expr,
`$locals.$expr${this.has_yield.from_num}`
);
var assign = new $AssignCtx(new_expr);
var right = new $ExprCtx(assign);
right.tree = this.has_yield.tree;
parent.insert(rank, new_node);
var pnode = $get_node(this.has_yield);
var n = this.has_yield.from_num;
var replace_with = `$B.$import("sys", [], {})
var _i${n} = _b_.iter($locals.$expr${n}),
_r${n}
var $failed${n} = false
try{
var _y${n} = _b_.next(_i${n})
}catch(_e){
$B.set_exc(_e)
$failed${n} = true
$B.pmframe = $B.last($B.frames_stack)
_e = $B.exception(_e)
if(_e.__class__ === _b_.StopIteration){
var _r${n} = $B.$getattr(_e, "value")
}else{
throw _e
}
}
if(! $failed${n}){
while(true){
var $failed1${n} = false
try{
$B.leave_frame({$locals})
var _s${n} = yield _y${n}
$B.frames_stack.push($top_frame)
}catch(_e){
if(_e.__class__ === _b_.GeneratorExit){
var $failed2${n} = false
try{
var _m${n} = $B.$getattr(_i${n}, "close")
}catch(_e1){
$failed2${n} = true
if(_e1.__class__ !== _b_.AttributeError){
throw _e1
}
}
if(! $failed2${n}){
$B.$call(_m${n})()
}
throw _e
}else if($B.is_exc(_e, [_b_.BaseException])){
var _x = $B.$call($B.$getattr($locals.sys, "exc_info"))()
var $failed3${n} = false
try{
var _m${n} = $B.$getattr(_i${n}, "throw")
}catch(err){
$failed3${n} = true
if($B.is_exc(err, [_b_.AttributeError])){
throw err
}
}
if(! $failed3${n}){
try{
_y${n} = $B.$call(_m${n}).apply(null,
_b_.list.$factory(_x${n}))
}catch(err){
if($B.$is_exc(err, [_b_.StopIteration])){
_r${n} = $B.$getattr(err, "value")
break
}
throw err
}
}
}
}
if(! $failed1${n}){
try{
if(_s${n} === _b_.None){
_y${n} = _b_.next(_i${n})
}else{
_y${n} = $B.$call($B.$getattr(_i${n}, "send"))(_s${n})
}
}catch(err){
if($B.is_exc(err, [_b_.StopIteration])){
_r${n} = $B.$getattr(err, "value")
break
}
throw err
}
}
}
}`;
parent.insert(rank + 1, $NodeJS(replace_with));
return 3;
}
parent.children.splice(rank, 1);
if (this.has_yield.tree.length === 0) {
new_node = $NodeJS("var result = _b_.None");
} else {
var new_node = new $Node();
var new_ctx = new $NodeCtx(new_node);
var new_expr = new $ExprCtx(new_ctx, "js", false);
var _id = new $RawJSCtx(new_expr, "var result");
var assign = new $AssignCtx(new_expr);
assign.tree[1] = this.has_yield.tree[0];
_id.parent = assign;
}
new_node.line_num = this.line_num;
parent.insert(rank, new_node);
var try_node = new $NodeJS("try");
try_node.add($NodeJS("$B.leave_frame({$locals})"));
try_node.add(this);
parent.insert(rank + 1, try_node);
this.has_yield.to_js = function () {
return "yield result";
};
this.has_yield.transformed = true;
var i = 0;
while (i < try_node.children.length) {
var offset = try_node.children[i].transform(i);
if (offset === undefined) {
offset = 1;
}
i += offset;
}
var catch_node = $NodeJS(`catch(err${this.line_num})`);
catch_node.add($NodeJS("$B.frames_stack.push($top_frame)"));
catch_node.add($NodeJS(`throw err${this.line_num}`));
parent.insert(rank + 2, catch_node);
parent.insert(rank + 3, $NodeJS("$B.frames_stack.push($top_frame)"));
return 2;
}
if (this.type === "module") {
this.__doc__ = $get_docstring(this);
var i = 0;
while (i < this.children.length) {
var offset = this.children[i].transform(i);
if (offset === undefined) {
offset = 1;
}
i += offset;
}
} else {
var elt = this.C.tree[0],
ctx_offset;
if (elt === undefined) {
console.log(this);
}
if (elt.transform !== undefined) {
ctx_offset = elt.transform(this, rank);
}
var i = 0;
while (i < this.children.length) {
var offset = this.children[i].transform(i);
if (offset === undefined) {
offset = 1;
}
i += offset;
}
if (ctx_offset === undefined) {
ctx_offset = 1;
}
return ctx_offset;
}
};
$Node.prototype.clone = function () {
var res = new $Node(this.type);
for (var attr in this) {
res[attr] = this[attr];
}
return res;
};
$Node.prototype.clone_tree = function () {
var res = new $Node(this.type);
for (var attr in this) {
res[attr] = this[attr];
}
res.children = [];
for (var child of this.children) {
res.add(child.clone_tree());
}
return res;
};
function set_position(ast_obj, position) {
if ($B.js_from_ast) {
ast_obj.lineno = position.start[0];
ast_obj.col_offset = position.start[1];
ast_obj.end_lineno = position.end[0];
ast_obj.end_col_offset = position.end[1];
}
}
function copy_position(target, origin) {
target.lineno = origin.lineno;
target.col_offset = origin.col_offset;
target.end_lineno = origin.end_lineno;
target.end_col_offset = origin.end_col_offset;
}
var $AbstractExprCtx = ($B.parser.$AbstractExprCtx = function (
C,
with_commas
) {
this.type = "abstract_expr";
this.with_commas = with_commas;
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree.push(this);
});
$AbstractExprCtx.prototype.toString = function () {
return "(abstract_expr " + this.with_commas + ") " + this.tree;
};
$AbstractExprCtx.prototype.transition = function (token, value) {
var C = this;
var packed = C.packed,
is_await = C.is_await,
position = C.position;
switch (token) {
case "await":
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "ellipsis":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
case "yield":
C.parent.tree.pop();
var commas = C.with_commas;
C = C.parent;
C.packed = packed;
C.is_await = is_await;
C.position = position;
}
switch (token) {
case "await":
return new $AbstractExprCtx(
new $AwaitCtx(new $ExprCtx(C, "await", false)),
true
);
case "id":
return new $IdCtx(new $ExprCtx(C, "id", commas), value);
case "str":
return new $StringCtx(new $ExprCtx(C, "str", commas), value);
case "JoinedStr":
return new JoinedStrCtx(new $ExprCtx(C, "str", commas), value);
case "bytes":
return new $StringCtx(new $ExprCtx(C, "bytes", commas), value);
case "int":
return new $NumberCtx("int", new $ExprCtx(C, "int", commas), value);
case "float":
return new $NumberCtx("float", new $ExprCtx(C, "float", commas), value);
case "imaginary":
return new $NumberCtx(
"imaginary",
new $ExprCtx(C, "imaginary", commas),
value
);
case "(":
return new $ListOrTupleCtx(new $ExprCtx(C, "tuple", commas), "tuple");
case "[":
return new $ListOrTupleCtx(new $ExprCtx(C, "list", commas), "list");
case "{":
return new $DictOrSetCtx(new $ExprCtx(C, "dict_or_set", commas));
case "ellipsis":
return new $EllipsisCtx(new $ExprCtx(C, "ellipsis", commas));
case "not":
if (C.type == "op" && C.op == "is") {
C.op = "is_not";
return C;
}
return new $NotCtx(new $ExprCtx(C, "not", commas));
case "lambda":
return new $LambdaCtx(new $ExprCtx(C, "lambda", commas));
case "op":
var tg = value;
switch (tg) {
case "*":
C.parent.tree.pop();
var commas = C.with_commas;
C = C.parent;
C.position = $token.value;
return new $PackedCtx(new $ExprCtx(C, "expr", commas));
case "-":
case "~":
case "+":
C.parent.tree.pop();
return new $AbstractExprCtx(
new $UnaryCtx(new $ExprCtx(C.parent, "unary", false), tg),
false
);
case "not":
C.parent.tree.pop();
var commas = C.with_commas;
C = C.parent;
return new $NotCtx(new $ExprCtx(C, "not", commas));
case "...":
return new $EllipsisCtx(new $ExprCtx(C, "ellipsis", commas));
}
$_SyntaxError(C, "token " + token + " after " + C);
case "in":
if (C.parent.type == "op" && C.parent.op == "not") {
C.parent.op = "not_in";
return C;
}
$_SyntaxError(C, "token " + token + " after " + C);
case "=":
if (C.parent.type == "yield") {
$_SyntaxError(C, ["assignment to yield expression not possible"]);
}
$_SyntaxError(C, "token " + token + " after " + C);
case "yield":
return new $AbstractExprCtx(new $YieldCtx(C), true);
case ":":
if (
C.parent.type == "sub" ||
(C.parent.type == "list_or_tuple" && C.parent.parent.type == "sub")
) {
return new $AbstractExprCtx(new $SliceCtx(C.parent), false);
}
return $transition(C.parent, token, value);
case ")":
case ",":
switch (C.parent.type) {
case "list_or_tuple":
case "slice":
case "call_arg":
case "op":
case "yield":
break;
case "match":
if (token == ",") {
C.parent.tree.pop();
var tuple = new $ListOrTupleCtx(C.parent, "tuple");
tuple.implicit = true;
tuple.has_comma = true;
tuple.tree = [C];
C.parent = tuple;
return tuple;
}
break;
case "annotation":
$_SyntaxError(C, "empty annotation");
default:
$_SyntaxError(C, token);
}
break;
case ".":
$_SyntaxError(C, "token " + token);
}
return $transition(C.parent, token, value);
};
$AbstractExprCtx.prototype.to_js = function () {
this.js_processed = true;
if (this.type === "list") {
return "[" + $to_js(this.tree) + "]";
}
return $to_js(this.tree);
};
var $AliasCtx = ($B.parser.$AliasCtx = function (C) {
this.type = "ctx_manager_alias";
this.parent = C;
this.tree = [];
C.tree[C.tree.length - 1].alias = this;
});
$AliasCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case ",":
case ":":
C.parent.set_alias(C.tree[0].tree[0]);
return $transition(C.parent, token, value);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
var $AnnotationCtx = ($B.parser.$AnnotationCtx = function (C) {
this.type = "annotation";
this.parent = C;
this.tree = [];
this.src = $get_module(this).src;
var rest = this.src.substr($pos);
if (rest.startsWith(":")) {
this.start = $pos + 1;
} else if (rest.startsWith("->")) {
this.start = $pos + 2;
}
this.string = "";
C.annotation = this;
var scope = $get_scope(C);
if (scope.binding.__annotations__ === undefined) {
scope.binding.__annotations__ = true;
C.create_annotations = true;
}
if (
scope.ntype == "def" &&
C.tree &&
C.tree.length > 0 &&
C.tree[0].type == "id"
) {
var name = C.tree[0].value;
if (scope.globals && scope.globals.has(name) > -1) {
$_SyntaxError(C, ["annotated name '" + name + "' can't be global"]);
}
scope.annotations = scope.annotations || new Set();
scope.annotations.add(name);
if (!C.$in_parens) {
scope.binding = scope.binding || {};
scope.binding[name] = true;
}
}
});
$AnnotationCtx.prototype.toString = function () {
return "(annotation) " + this.tree;
};
$AnnotationCtx.prototype.transition = function (token, value) {
var C = this;
this.string = this.src.substring(this.start, $pos);
if (token == "eol" && C.tree.length == 1 && C.tree[0].tree.length == 0) {
$_SyntaxError(C, "empty annotation");
} else if (token == ":" && C.parent.type != "def") {
$_SyntaxError(C, "more than one annotation");
} else if (token == "augm_assign") {
$_SyntaxError(C, "augmented assign as annotation");
} else if (token == "op") {
$_SyntaxError(C, "operator as annotation");
}
return $transition(C.parent, token);
};
$AnnotationCtx.prototype.to_js = function () {
if (this.tree[0].type == "expr" && this.tree[0].tree[0].type == "id") {
return `"${this.tree[0].tree[0].value}"`;
}
return $to_js(this.tree);
};
var $AssertCtx = ($B.parser.$AssertCtx = function (C) {
this.type = "assert";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$AssertCtx.prototype.ast = function () {
var msg = this.tree[1],
ast_obj = new ast.Assert(
ast_or_obj(this.tree[0]),
msg === undefined ? msg : ast_or_obj(msg)
);
set_position(ast_obj, this.position);
return ast_obj;
};
$AssertCtx.prototype.toString = function () {
return "(assert) " + this.tree;
};
$AssertCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ",") {
if (this.tree.length > 1) {
$_SyntaxError(C, "too many commas after assert");
}
return new $AbstractExprCtx(this, false);
}
if (token == "eol") {
return $transition(C.parent, token);
}
$_SyntaxError(C, token);
};
$AssertCtx.prototype.transform = function (node, rank) {
if (this.tree.length > 1) {
var condition = this.tree[0];
var message = this.tree[1];
} else {
var condition = this.tree[0];
var message = null;
}
if (
this.tree[0].type == "expr" &&
this.tree[0].name == "tuple" &&
this.tree[0].tree[0].tree.length > 1
) {
var warning = _b_.SyntaxWarning.$factory(
"assertion is always true, perhaps remove parentheses?"
);
var module = $get_module(this);
$B.$syntax_err_line(
warning,
module.filename,
module.src,
$pos,
$get_node(this).line_num
);
$B.imported._warnings.warn(warning);
}
var new_ctx = new $ConditionCtx(node.C, "if");
var not_ctx = new $NotCtx(new_ctx);
not_ctx.tree = [condition];
node.C = new_ctx;
var js = "throw _b_.AssertionError.$factory()";
if (message !== null) {
js =
"throw _b_.AssertionError.$factory(_b_.str.$factory(" +
message.to_js() +
"))";
}
node.add($NodeJS(js));
};
function make_assign(left, right, module) {
var node = new $Node();
node.id = module;
var C = new $NodeCtx(node);
var expr = new $ExprCtx(C, "left", true);
expr.tree = left.tree;
var assign = new $AssignCtx(expr);
assign.tree[1] = new $JSCode(right);
return node;
}
var $AssignCtx = ($B.parser.$AssignCtx = function (C, expression) {
check_assignment(C);
if (C.type == "expr" && C.tree[0].type == "lambda") {
$_SyntaxError(C, ["cannot assign to lambda"]);
}
this.type = "assign";
this.position = $token.value;
C.parent.tree.pop();
C.parent.tree.push(this);
this.parent = C.parent;
this.tree = [C];
var scope = $get_scope(this);
if (
C.type == "list_or_tuple" ||
(C.type == "expr" && C.tree[0].type == "list_or_tuple")
) {
if (C.type == "expr") {
C = C.tree[0];
}
C.bind_ids(scope);
} else if (C.type == "assign") {
check_assignment(C.tree[1]);
for (var elt of C.tree) {
var assigned = elt.tree[0];
if (assigned.type == "id") {
$bind(assigned.value, scope, this);
}
}
} else {
var assigned = C.tree[0];
if (assigned && assigned.type == "id") {
var name = assigned.value;
assigned.bound = true;
if (!scope.globals || !scope.globals.has(assigned.value)) {
var node = $get_node(this);
node.bound_before = Object.keys(scope.binding);
$bind(assigned.value, scope, this);
} else {
var module = $get_module(C);
assigned.global_module = module.module;
$bind(assigned.value, module, this);
}
} else if (assigned.type == "ellipsis") {
$_SyntaxError(C, ["cannot assign to Ellipsis"]);
} else if (assigned.type == "unary") {
$_SyntaxError(C, ["cannot assign to operator"]);
} else if (assigned.type == "packed") {
if (assigned.tree[0].name == "id") {
var id = assigned.tree[0].tree[0].value;
if (["None", "True", "False", "__debug__"].indexOf(id) > -1) {
$_SyntaxError(C, ["cannot assign to " + id]);
}
}
if (assigned.parent.in_tuple === undefined) {
$_SyntaxError(C, [
"starred assignment target must be in a list or tuple",
]);
}
}
}
});
$AssignCtx.prototype.ast = function () {
var value = ast_or_obj(this.tree[1]),
targets = [],
target = this.tree[0];
if (target.type == "expr" && target.tree[0].type == "list_or_tuple") {
target = target.tree[0];
}
if (target.type == "list_or_tuple") {
target = ast_or_obj(target);
for (var elt of target.elts) {
elt.ctx = new ast.Store();
if (elt instanceof ast.Starred) {
elt.value.ctx = new ast.Store();
}
}
target.ctx = new ast.Store();
targets = [target];
} else {
while (target.type == "assign") {
targets.splice(0, 0, ast_or_obj(target.tree[1]));
target = target.tree[0];
}
targets.splice(0, 0, ast_or_obj(target));
for (var tg of targets) {
tg.ctx = new ast.Store();
if (tg instanceof ast.Tuple) {
for (var elt of tg.elts) {
elt.ctx = new ast.Store();
}
}
}
}
value.ctx = new ast.Load();
var lineno = $get_node(this).line_num;
if (target.annotation) {
var ast_obj = new ast.AnnAssign(
ast_or_obj(target.tree[0]),
ast_or_obj(target.annotation.tree[0]),
value,
1
);
ast_obj.target.ctx = new ast.Store();
} else {
var ast_obj = new ast.Assign(targets, value);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$AssignCtx.prototype.guess_type = function () {
return;
};
$AssignCtx.prototype.toString = function () {
return "(assign) " + this.tree[0] + "=" + this.tree[1];
};
$AssignCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
if (C.tree[1].type == "abstract_expr") {
$_SyntaxError(C, "token " + token + " after " + C);
}
C.guess_type();
return $transition(C.parent, "eol");
}
console.log("token", token, "after C", C);
$_SyntaxError(C, "token " + token + " after " + C);
};
$AssignCtx.prototype.transform = function (node, rank) {
var scope = $get_scope(this);
var left = this.tree[0],
right = this.tree[1],
assigned = [];
while (left.type == "assign") {
assigned.push(left.tree[1]);
left = left.tree[0];
}
if (assigned.length > 0) {
assigned.push(left);
var ctx = node.C;
ctx.tree = [];
var nleft = new $RawJSCtx(ctx, "var $temp" + $loop_num);
nleft.tree = ctx.tree;
var nassign = new $AssignCtx(nleft);
nassign.tree[1] = right;
for (var elt of assigned) {
if (
elt.type == "expr" &&
elt.tree[0].type == "list_or_tuple" &&
elt.tree[0].real == "tuple" &&
elt.tree[0].tree.length == 1
) {
elt = elt.tree[0].tree[0];
}
var new_node = new $Node(),
node_ctx = new $NodeCtx(new_node);
new_node.locals = node.locals;
new_node.line_num = node.line_num;
node.parent.insert(rank + 1, new_node);
elt.parent = node_ctx;
var assign = new $AssignCtx(elt);
new $RawJSCtx(assign, "$temp" + $loop_num);
}
$loop_num++;
this.tree[0] = left;
return;
}
var left_items = null;
switch (left.type) {
case "expr":
if (left.tree.length > 1) {
left_items = left.tree;
} else if (
left.tree[0].type == "list_or_tuple" ||
left.tree[0].type == "target_list"
) {
left_items = left.tree[0].tree;
} else if (left.tree[0].type == "id") {
var name = left.tree[0].value;
if (scope.globals && scope.globals.has(name)) {
} else {
left.tree[0].bound = true;
}
}
break;
case "target_list":
case "list_or_tuple":
left_items = left.tree;
}
var right = this.tree[1];
if (left_items === null) {
if (left.tree[0].bound) {
if (right.type == "expr" && right.name == "int") {
node.bindings = node.bindings || {};
node.bindings[left.tree[0].value] = "int";
}
}
return;
}
var right_items = null;
if (
right.type == "list" ||
right.type == "tuple" ||
(right.type == "expr" && right.tree.length > 1)
) {
right_items = right.tree;
}
if (right_items !== null) {
if (right_items.length > left_items.length) {
throw Error(
"ValueError : too many values to unpack (expected " +
left_items.length +
")"
);
} else if (right_items.length < left_items.length) {
throw Error(
"ValueError : need more than " + right_items.length + " to unpack"
);
}
var new_nodes = [],
pos = 0;
var new_node = new $Node();
new_node.line_num = node.line_num;
new $NodeJSCtx(new_node, "void(0)");
new_nodes[pos++] = new_node;
var $var = "$temp" + $loop_num;
var new_node = new $Node();
new_node.line_num = node.line_num;
new $NodeJSCtx(new_node, "var " + $var + " = [], $pos = 0");
new_nodes[pos++] = new_node;
for (var right_item of right_items) {
var js = $var + "[$pos++] = " + right_item.to_js();
var new_node = new $Node();
new_node.line_num = node.line_num;
new $NodeJSCtx(new_node, js);
new_nodes[pos++] = new_node;
}
var this_node = $get_node(this);
for (var left_item of left_items) {
var new_node = new $Node();
new_node.id = this_node.module;
new_node.locals = this_node.locals;
new_node.line_num = node.line_num;
var C = new $NodeCtx(new_node);
left_item.parent = C;
var assign = new $AssignCtx(left_item, false);
assign.tree[1] = new $JSCode($var + "[" + i + "]");
new_nodes[pos++] = new_node;
}
node.parent.children.splice(rank, 1);
for (var i = new_nodes.length - 1; i >= 0; i--) {
node.parent.insert(rank, new_nodes[i]);
}
$loop_num++;
} else {
node.parent.children.splice(rank, 1);
var rname = create_temp_name("$right");
var rlname = create_temp_name("$rlist");
var new_node = $NodeJS(
"var " +
rname +
" = " +
"$B.$getattr($B.$iter(" +
right.to_js() +
'), "__next__");'
);
new_node.line_num = node.line_num;
node.parent.insert(rank++, new_node);
node.parent.insert(
rank++,
$NodeJS(
"var " +
rlname +
"=[], $pos=0;" +
"while(1){\n" +
"try{\n" +
rlname +
"[$pos++] = " +
rname +
"()" +
"}catch(err){\n" +
"break" +
"}" +
"}"
)
);
var packed = null;
var min_length = left_items.length;
for (var i = 0; i < left_items.length; i++) {
var expr = left_items[i];
if (
expr.type == "packed" ||
(expr.type == "expr" && expr.tree[0].type == "packed")
) {
packed = i;
min_length--;
break;
}
}
node.parent.insert(
rank++,
$NodeJS(
"if(" +
rlname +
".length<" +
min_length +
"){\n" +
"throw _b_.ValueError.$factory(" +
'"need more than " +' +
rlname +
'.length + " value" + (' +
rlname +
".length > 1 ?" +
' "s" : "") + " to unpack")}'
)
);
if (packed == null) {
node.parent.insert(
rank++,
$NodeJS(
"if(" +
rlname +
".length>" +
min_length +
"){\n" +
"throw _b_.ValueError.$factory(" +
'"too many values to unpack ' +
"(expected " +
left_items.length +
')"' +
")" +
"}"
)
);
}
left_items.forEach(function (left_item, i) {
var new_node = new $Node();
new_node.id = scope.id;
new_node.line_num = node.line_num;
node.parent.insert(rank++, new_node);
var C = new $NodeCtx(new_node);
left_item.parent = C;
left_item.in_tuple = true;
var assign = new $AssignCtx(left_item, false);
var js = rlname;
if (packed == null || i < packed) {
js += "[" + i + "]";
} else if (i == packed) {
js +=
".slice(" +
i +
"," +
rlname +
".length-" +
(left_items.length - i - 1) +
")";
} else {
js += "[" + rlname + ".length-" + (left_items.length - i) + "]";
}
assign.tree[1] = new $JSCode(js);
});
$loop_num++;
}
};
$AssignCtx.prototype.to_js = function () {
this.js_processed = true;
if (this.parent.type == "call") {
return (
'{$nat:"kw",name:' +
this.tree[0].to_js() +
",value:" +
this.tree[1].to_js() +
"}"
);
}
var left = this.tree[0];
while (left.type == "expr") {
left = left.tree[0];
}
var right = this.tree[1];
if (left.type == "attribute" || left.type == "sub") {
var right_js = right.to_js();
var res = "",
rvar = "",
$var = "$temp" + $loop_num;
if (
right.type == "expr" &&
right.tree[0] !== undefined &&
right.tree[0].type == "call" &&
("eval" == right.tree[0].func.value ||
"exec" == right.tree[0].func.value)
) {
res += "var " + $var + " = " + right_js + ";\n";
rvar = $var;
} else if (
right.type == "expr" &&
right.tree[0] !== undefined &&
right.tree[0].type == "sub"
) {
res += "var " + $var + " = " + right_js + ";\n";
rvar = $var;
} else {
rvar = right_js;
}
if (left.type == "attribute") {
$loop_num++;
left.func = "setattr";
var left_to_js = left.to_js();
left.func = "getattr";
if (left.assign_self) {
return res + left_to_js[0] + rvar + left_to_js[1] + rvar + ")";
}
res += left_to_js;
res = res.substr(0, res.length - 1);
return res + "," + rvar + ");_b_.None;";
}
if (left.type == "sub") {
var seq = left.value.to_js(),
temp = "$temp" + $loop_num,
type;
if (left.value.type == "id") {
type = $get_node(this).locals[left.value.value];
}
$loop_num++;
var res = "var " + temp + " = " + seq + "\n";
if (type !== "list") {
res +=
"if(Array.isArray(" + temp + ") && !" + temp + ".__class__){\n";
}
if (left.tree.length == 1) {
res +=
"$B.set_list_key(" +
temp +
"," +
(left.tree[0].to_js() + "" || "null") +
"," +
right.to_js() +
")";
} else if (left.tree.length == 2) {
res +=
"$B.set_list_slice(" +
temp +
"," +
(left.tree[0].to_js() + "" || "null") +
"," +
(left.tree[1].to_js() + "" || "null") +
"," +
right.to_js() +
")";
} else if (left.tree.length == 3) {
res +=
"$B.set_list_slice_step(" +
temp +
"," +
(left.tree[0].to_js() + "" || "null") +
"," +
(left.tree[1].to_js() + "" || "null") +
"," +
(left.tree[2].to_js() + "" || "null") +
"," +
right.to_js() +
")";
}
if (type == "list") {
return res;
}
res += "\n}else{\n";
if (left.tree.length == 1) {
res +=
"$B.$setitem(" +
left.value.to_js() +
"," +
left.tree[0].to_js() +
"," +
right_js +
")};_b_.None;";
} else {
left.func = "setitem";
res += left.to_js();
res = res.substr(0, res.length - 1);
left.func = "getitem";
res += "," + right_js + ")};_b_.None;";
}
return res;
}
}
return left.to_js() + " = " + right.to_js();
};
var $AsyncCtx = ($B.parser.$AsyncCtx = function (C) {
this.type = "async";
this.parent = C;
C.async = true;
C.position = $token.value;
});
$AsyncCtx.prototype.toString = function () {
return "(async)";
};
$AsyncCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "def") {
return $transition(C.parent, token, value);
} else if (token == "for" || token == "with") {
var ntype = $get_scope(C).ntype;
if (ntype !== "def" && ntype != "generator") {
$_SyntaxError(C, ["'async " + token + "' outside async function"]);
}
var ctx = $transition(C.parent, token, value);
ctx.parent.async = true;
return ctx;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
var $AttrCtx = ($B.parser.$AttrCtx = function (C) {
this.type = "attribute";
this.value = C.tree[0];
this.parent = C;
this.position = this.value.position;
if ($B.js_from_ast && this.position === undefined) {
console.log("pas de position pour Attr value", this);
alert();
}
C.tree.pop();
C.tree[C.tree.length] = this;
this.tree = [];
this.func = "getattr";
});
$AttrCtx.prototype.ast = function () {
var value = ast_or_obj(this.value),
attr = this.unmangled_name,
ctx = new ast.Load();
if (this.func == "setattr") {
ctx = new ast.Store();
} else if (this.func == "delattr") {
ctx = new ast.Delete();
}
var ast_obj = new ast.Attribute(value, attr, ctx);
set_position(ast_obj, this.position);
return ast_obj;
};
$AttrCtx.prototype.toString = function () {
return "(attr) " + this.value + "." + this.name;
};
$AttrCtx.prototype.transition = function (token, value) {
var C = this;
if (token === "id") {
var name = value;
if (name == "__debug__") {
$_SyntaxError(C, ["cannot assign to __debug__"]);
} else if (noassign[name] === true) {
$_SyntaxError(C, `'${name}' cannot be an attribute`);
}
C.unmangled_name = name;
name = $mangle(name, C);
C.name = name;
return C.parent;
}
$_SyntaxError(C, token);
};
$AttrCtx.prototype.to_js = function () {
this.js_processed = true;
var js = this.value.to_js();
if (this.func == "setattr" && this.value.type == "id") {
var scope = $get_scope(this),
parent = scope.parent;
if (scope.ntype == "def") {
if (parent.ntype == "class") {
var params = scope.C.tree[0].positional_list;
if (
this.value.value == params[0] &&
parent.C &&
parent.C.tree[0].args === undefined
) {
this.assign_self = true;
return [
js +
".__class__ && " +
js +
".__dict__ && !" +
js +
".__class__.$has_setattr && ! " +
js +
".$is_class ? _b_.dict.$setitem(" +
js +
".__dict__, '" +
this.name +
"', ",
") : $B.$setattr(" + js + ', "' + this.name + '", ',
];
}
}
}
}
if (this.func == "setattr") {
return "$B.$setattr(" + js + ',"' + this.name + '")';
} else {
return "$B.$getattr(" + js + ',"' + this.name + '")';
}
};
var $AugmentedAssignCtx = ($B.parser.$AugmentedAssignCtx = function (C, op) {
check_assignment(C, { augmented: true });
this.type = "augm_assign";
this.C = C;
this.parent = C.parent;
this.position = $token.value;
C.parent.tree.pop();
C.parent.tree[C.parent.tree.length] = this;
this.op = op;
this.tree = [C];
var scope = (this.scope = $get_scope(this));
if (C.type == "expr") {
var assigned = C.tree[0];
if (assigned.type == "id") {
var name = assigned.value;
if (
(scope.ntype == "def" || scope.ntype == "generator") &&
!scope.binding.hasOwnProperty(name)
) {
if (scope.globals === undefined || !scope.globals.has(name)) {
assigned.unbound = true;
}
}
}
}
$get_node(this).bound_before = Object.keys(scope.binding);
this.module = scope.module;
});
$AugmentedAssignCtx.prototype.ast = function () {
var target = ast_or_obj(this.tree[0]),
value = ast_or_obj(this.tree[1]);
target.ctx = new ast.Store();
value.ctx = new ast.Load();
var op = this.op.substr(0, this.op.length - 1),
ast_type_class = op2ast_class[op],
ast_class = ast_type_class[1];
var ast_obj = new ast.AugAssign(target, new ast_class(), value);
set_position(ast_obj, this.position);
return ast_obj;
};
$AugmentedAssignCtx.prototype.toString = function () {
return "(augm assign) " + this.tree;
};
$AugmentedAssignCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
if (C.tree[1].type == "abstract_expr") {
$_SyntaxError(C, "token " + token + " after " + C);
}
return $transition(C.parent, "eol");
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$AugmentedAssignCtx.prototype.to_js = function () {
var target = this.tree[0].tree[0];
if (target.type == "id") {
var left_bound_to_int =
this.tree[0].tree[0].bindingType(this.scope) == "int";
var target_scope = find_scope(target.value, $get_scope(this)),
scope_ref;
if (target_scope === undefined) {
scope_ref = "$locals";
} else {
scope_ref = "$locals_" + target_scope.id.replace(/\./g, "_");
}
target.augm_assign = true;
var right = this.tree[1].tree[0];
if (right.type == "int") {
var right_value = parseInt(right.value[1], right.value[0]);
if (right_value < $B.max_int && right_value > $B.min_int) {
var left_bound_to_int =
this.tree[0].tree[0].bindingType(this.scope) == "int";
if (left_bound_to_int && this.op !== "//=") {
var op1 = this.op.substr(0, this.op.length - 1),
tg_js = target.to_js();
return (
`${scope_ref}['${target.value}'] = ` +
`(typeof ${tg_js} == "number" && $B.is_safe_int(` +
`$locals.$result = ${tg_js} ${op1} ${right.to_js()}` +
`)) ? $locals.$result : $B.augm_assign(${tg_js}, ` +
`'${this.op}', ${right.to_js()})`
);
}
}
}
var right = this.tree[1].to_js();
return (
`${scope_ref}['${target.value}'] = ` +
`$B.augm_assign(${target.to_js()}, '${this.op}', ` +
right +
")"
);
} else if (target.type == "sub") {
return (
`$B.$setitem(($locals.$tg = ${target.value.to_js()}), ` +
`($locals.$key = ${target.tree[0].to_js()}), $B.augm_assign($B.$getitem(` +
`$locals.$tg, $locals.$key), '${this.op}', ${this.tree[1].to_js()}))`
);
} else if (target.type == "attribute") {
return (
`$B.$setattr(($locals.$tg = ${target.value.to_js()}), ` +
`'${target.name}', $B.augm_assign($B.$getattr(` +
`$locals.$tg, '${target.name}'), '${
this.op
}', ${this.tree[1].to_js()}))`
);
}
return "";
};
var $AwaitCtx = ($B.parser.$AwaitCtx = function (C) {
this.type = "await";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree.push(this);
var p = C;
while (p) {
if (p.type == "list_or_tuple") {
p.is_await = true;
}
p = p.parent;
}
var node = $get_node(this);
node.awaits = node.awaits || [];
node.awaits.push(this);
});
$AwaitCtx.prototype.ast = function () {
var ast_obj = new ast.Await(ast_or_obj(this.tree[0]));
set_position(ast_obj, this.position);
return ast_obj;
};
$AwaitCtx.prototype.transition = function (token, value) {
var C = this;
C.parent.is_await = true;
return $transition(C.parent, token, value);
};
$AwaitCtx.prototype.to_js = function () {
return `await $B.promise(${$to_js(this.tree)})`;
};
var $BodyCtx = ($B.parser.$BodyCtx = function (C) {
var ctx_node = C.parent;
while (ctx_node.type !== "node") {
ctx_node = ctx_node.parent;
}
var tree_node = ctx_node.node;
var body_node = new $Node();
body_node.is_body_node = true;
body_node.line_num = tree_node.line_num;
tree_node.insert(0, body_node);
return new $NodeCtx(body_node);
});
var set_loop_context = ($B.parser.set_loop_context = function (C, kw) {
var ctx_node = C;
while (ctx_node.type !== "node") {
ctx_node = ctx_node.parent;
}
var tree_node = ctx_node.node;
var loop_node = tree_node.parent;
var break_flag = false;
while (1) {
if (loop_node.type == "module") {
$_SyntaxError(C, kw + " outside of a loop");
} else {
var ctx = loop_node.C.tree[0];
if (ctx.type == "condition" && ctx.token == "while") {
this.loop_ctx = ctx;
ctx["has_" + kw] = true;
break;
}
switch (ctx.type) {
case "for":
this.loop_ctx = ctx;
ctx["has_" + kw] = true;
break_flag = true;
break;
case "def":
case "generator":
case "class":
$_SyntaxError(C, kw + " outside of a loop");
default:
loop_node = loop_node.parent;
}
if (break_flag) {
break;
}
}
}
});
var $BreakCtx = ($B.parser.$BreakCtx = function (C) {
this.type = "break";
this.position = $token.value;
this.parent = C;
C.tree[C.tree.length] = this;
set_loop_context.apply(this, [C, "break"]);
});
$BreakCtx.prototype.ast = function () {
var ast_obj = new ast.Break();
set_position(ast_obj, this.position);
return ast_obj;
};
$BreakCtx.prototype.toString = function () {
return "break ";
};
$BreakCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
return $transition(C.parent, "eol");
}
$_SyntaxError(C, token);
};
$BreakCtx.prototype.to_js = function () {
this.js_processed = true;
var res = ";$no_break" + this.loop_ctx.loop_num + " = false";
if (this.loop_ctx.type != "asyncfor") {
res += ";break";
} else {
res +=
";throw _b_.StopIteration.$factory(" + this.loop_ctx.loop_num + ")";
}
return res;
};
var $CallArgCtx = ($B.parser.$CallArgCtx = function (C) {
this.type = "call_arg";
this.parent = C;
this.start = $pos;
this.tree = [];
this.position = $token.value;
C.tree.push(this);
this.expect = "id";
});
$CallArgCtx.prototype.toString = function () {
return "call_arg " + this.tree;
};
$CallArgCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "await":
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "ellipsis":
case "not":
case "lambda":
if (C.expect == "id") {
C.expect = ",";
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
}
break;
case "=":
if (C.expect == ",") {
return new $ExprCtx(new $KwArgCtx(C), "kw_value", false);
}
break;
case "for":
if (this.parent.tree.length > 1) {
$_SyntaxError(C, "non-parenthesized generator expression");
}
return new $TargetListCtx(new $ForExpr(new GeneratorExpCtx(C)));
case "op":
if (C.expect == "id") {
var op = value;
C.expect = ",";
switch (op) {
case "+":
case "-":
case "~":
return $transition(new $AbstractExprCtx(C, false), token, op);
case "*":
C.parent.tree.pop();
return new $StarArgCtx(C.parent);
case "**":
C.parent.tree.pop();
return new $DoubleStarArgCtx(C.parent);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
case ")":
if (
C.parent.kwargs &&
$B.last(C.parent.tree).tree[0] &&
["kwarg", "star_arg", "double_star_arg"].indexOf(
$B.last(C.parent.tree).tree[0].type
) == -1
) {
$_SyntaxError(C, ["non-keyword argument after keyword argument"]);
}
return $transition(C.parent, token);
case ":":
if (C.expect == "," && C.parent.parent.type == "lambda") {
return $transition(C.parent.parent, token);
}
break;
case ",":
if (C.expect == ",") {
if (
C.parent.kwargs &&
["kwarg", "star_arg", "double_star_arg"].indexOf(
$B.last(C.parent.tree).tree[0].type
) == -1
) {
$_SyntaxError(C, ["non-keyword argument after keyword argument"]);
}
return $transition(C.parent, token, value);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$CallArgCtx.prototype.to_js = function () {
this.js_processed = true;
return $to_js(this.tree);
};
var $CallCtx = ($B.parser.$CallCtx = function (C) {
this.position = $token.value;
this.type = "call";
this.func = C.tree[0];
if (this.func !== undefined) {
this.func.parent = this;
}
this.parent = C;
if (C.type != "class") {
C.tree.pop();
C.tree[C.tree.length] = this;
} else {
C.args = this;
}
this.expect = "id";
this.tree = [];
this.start = $pos;
if (
this.func &&
this.func.type == "attribute" &&
this.func.name == "wait" &&
this.func.value.type == "id" &&
this.func.value.value == "time"
) {
console.log("call", this.func);
$get_node(this).blocking = { type: "wait", call: this };
}
if (this.func && this.func.value == "input") {
$get_node(this).blocking = { type: "input" };
}
});
$CallCtx.prototype.ast = function () {
var res = new ast.Call(ast_or_obj(this.func), [], []);
for (var call_arg of this.tree) {
if (call_arg.type == "double_star_arg") {
var value = ast_or_obj(call_arg.tree[0].tree[0]),
keyword = new ast.keyword(_b_.None, value);
delete keyword.arg;
res.keywords.push(keyword);
} else if (call_arg.type == "star_arg") {
var starred = new ast.Starred(ast_or_obj(call_arg.tree[0]));
set_position(starred, call_arg.position);
starred.ctx = new ast.Load();
res.args.push(starred);
} else if (call_arg.type == "genexpr") {
res.args.push(call_arg.ast());
} else {
var item = call_arg.tree[0];
if (item === undefined) {
continue;
}
if (item.type == "kwarg") {
res.keywords.push(
new ast.keyword(item.tree[0].value, ast_or_obj(item.tree[1]))
);
} else {
res.args.push(ast_or_obj(item));
}
}
}
set_position(res, this.position);
return res;
};
$CallCtx.prototype.toString = function () {
return "(call) " + this.func + "(" + this.tree + ")";
};
$CallCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case ",":
if (C.expect == "id") {
$_SyntaxError(C, token);
}
C.expect = "id";
return C;
case "await":
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
case "ellipsis":
C.expect = ",";
return $transition(new $CallArgCtx(C), token, value);
case ")":
C.end = $pos;
return C.parent;
case "op":
C.expect = ",";
switch (value) {
case "-":
case "~":
case "+":
C.expect = ",";
return $transition(new $CallArgCtx(C), token, value);
case "*":
C.has_star = true;
return new $StarArgCtx(C);
case "**":
C.has_dstar = true;
return new $DoubleStarArgCtx(C);
}
$_SyntaxError(C, token);
case "yield":
$_SyntaxError(C, token);
}
return $transition(C.parent, token, value);
};
$CallCtx.prototype.to_js = function () {
this.js_processed = true;
if (this.tree.length > 0) {
if (this.tree[this.tree.length - 1].tree.length == 0) {
this.tree.pop();
}
}
var func_js = this.func.to_js();
if (this.func !== undefined) {
switch (this.func.value) {
case "classmethod":
return "_b_.classmethod.$factory(" + $to_js(this.tree) + ")";
default:
if (this.func.type == "unary") {
var res = "$B.$getattr(" + $to_js(this.tree);
switch (this.func.op) {
case "+":
return res + ',"__pos__")()';
case "-":
return res + ',"__neg__")()';
case "~":
return res + ',"__invert__")()';
}
}
}
var _block = false;
var positional = [],
kw_args = [],
star_args = false,
dstar_args = [];
for (var arg of this.tree) {
var type;
switch (arg.type) {
case "star_arg":
star_args = true;
positional.push([arg.tree[0].tree[0].to_js(), "*"]);
break;
case "double_star_arg":
dstar_args.push(arg.tree[0].tree[0].to_js());
break;
case "id":
positional.push([arg.to_js(), "s"]);
break;
default:
type = arg.tree[0].type;
switch (type) {
case "expr":
positional.push([arg.to_js(), "s"]);
break;
case "kwarg":
kw_args.push(
arg.tree[0].tree[0].value + ":" + arg.tree[0].tree[1].to_js()
);
break;
case "list_or_tuple":
case "op":
positional.push([arg.to_js(), "s"]);
break;
default:
positional.push([arg.to_js(), "s"]);
break;
}
break;
}
}
var args_str;
if (star_args) {
var p = [];
for (var i = 0, len = positional.length; i < len; i++) {
arg = positional[i];
if (arg[1] == "*") {
p.push("_b_.list.$factory(" + arg[0] + ")");
} else {
var elt = [positional[i][0]];
i++;
while (i < len && positional[i][1] == "s") {
elt.push(positional[i][0]);
i++;
}
i--;
p.push("[" + elt.join(",") + "]");
}
}
args_str = p[0];
for (var i = 1; i < p.length; i++) {
args_str += ".concat(" + p[i] + ")";
}
} else {
for (var i = 0, len = positional.length; i < len; i++) {
positional[i] = positional[i][0];
}
args_str = positional.join(", ");
}
var kw_args_str = "{" + kw_args.join(", ") + "}";
if (dstar_args.length) {
kw_args_str =
'{$nat:"kw",kw:[' + kw_args_str + "," + dstar_args.join(", ") + "]}";
} else if (kw_args_str != "{}") {
kw_args_str = '{$nat:"kw",kw:' + kw_args_str + "}";
} else {
kw_args_str = "";
}
if (star_args && kw_args_str) {
args_str += ".concat([" + kw_args_str + "])";
} else {
if (args_str && kw_args_str) {
args_str += "," + kw_args_str;
} else if (!args_str) {
args_str = kw_args_str;
}
}
if (star_args) {
args_str = ".apply(null," + args_str + ")";
} else {
args_str = "(" + args_str + ")";
}
var default_res = "$B.$call(" + func_js + ")" + args_str;
if (
this.tree.length > -1 &&
this.func.type == "id" &&
this.func.is_builtin
) {
var classes = [
"complex",
"bytes",
"bytearray",
"object",
"memoryview",
"int",
"float",
"str",
"list",
"tuple",
"dict",
"set",
"frozenset",
"range",
"slice",
"zip",
"bool",
"type",
"classmethod",
"staticmethod",
"enumerate",
"reversed",
"property",
"$$super",
"zip",
"map",
"filter",
];
if ($B.builtin_funcs[this.func.value] !== undefined) {
if (classes.indexOf(this.func.value) == -1) {
return func_js + args_str;
} else {
return func_js + ".$factory" + args_str;
}
}
}
return default_res;
}
};
var $CaseCtx = ($B.parser.$CaseCtx = function (node_ctx) {
this.type = "case";
node_ctx.tree = [this];
this.parent = node_ctx;
this.tree = [];
this.expect = "as";
});
$CaseCtx.prototype.ast = function () {
var ast_obj = new ast.match_case(
ast_or_obj(this.tree[0]),
this.has_guard ? ast_or_obj(this.tree[1].tree[0]) : undefined,
ast_body(this.parent)
);
ast_obj.lineno = $get_node(this).line_num;
return ast_obj;
};
$CaseCtx.prototype.set_alias = function (name) {
this.alias = name;
};
$CaseCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "as":
C.expect = ":";
return new $AbstractExprCtx(new $AliasCtx(C));
case ":":
function is_irrefutable(pattern) {
var cause;
if (pattern.type == "capture_pattern") {
return pattern.tree[0];
} else if (pattern.type == "or_pattern") {
for (var subpattern of pattern.tree) {
if ((cause = is_irrefutable(subpattern))) {
return cause;
}
}
} else if (
pattern.type == "sequence_pattern" &&
pattern.token == "(" &&
pattern.tree.length == 1 &&
(cause = is_irrefutable(pattern.tree[0]))
) {
return cause;
}
return false;
}
var cause;
if ((cause = is_irrefutable(this.tree[0]))) {
$get_node(C).parent.irrefutable = cause;
}
switch (C.expect) {
case "id":
case "as":
case ":":
var last = $B.last(C.tree);
if (last && last.type == "sequence_pattern") {
remove_empty_pattern(last);
}
return $BodyCtx(C);
}
break;
case "op":
if (value == "|") {
return new $PatternCtx(new $PatternOrCtx(C));
}
$_SyntaxError(C, ["expected :"]);
case ",":
if (C.expect == ":" || C.expect == "as") {
return new $PatternCtx(new $PatternSequenceCtx(C));
}
case "if":
C.has_guard = true;
return new $AbstractExprCtx(new $ConditionCtx(C, token), false);
default:
$_SyntaxError(C, ["expected :"]);
}
};
$CaseCtx.prototype.to_js = function () {
var node = $get_node(this),
rank = node.parent.children.indexOf(node),
prefix = rank == 0 ? "if" : "else if";
if (this.has_guard) {
var guard = this.tree.pop(),
guard_js = guard.to_js().substr(3),
guard_js = guard_js.substr(0, guard_js.length - 1);
}
return (
prefix +
'(($locals.$line_info="' +
node.line_num +
"," +
node.module +
'") && $B.pattern_match(subject, ' +
$to_js(this.tree) +
(this.alias ? `, {as: "${this.alias.value}"}` : "") +
")" +
(this.has_guard ? " && " + guard_js : "") +
")"
);
};
var $ClassCtx = ($B.parser.$ClassCtx = function (C) {
this.type = "class";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.expect = "id";
var scope = (this.scope = $get_scope(this));
this.parent.node.parent_block = scope;
this.parent.node.bound = {};
this.parent.node.binding = { __annotations__: true };
});
$ClassCtx.prototype.ast = function () {
var decorators = get_decorators(this.parent.node),
bases = [],
keywords = [];
if (this.args) {
for (var arg of this.args.tree) {
if (arg.tree[0].type == "kwarg") {
keywords.push(
new ast.keyword(
arg.tree[0].tree[0].value,
ast_or_obj(arg.tree[0].tree[1])
)
);
} else {
bases.push(ast_or_obj(arg.tree[0]));
}
}
}
var ast_obj = new ast.ClassDef(
this.name,
bases,
keywords,
ast_body(this.parent),
decorators
);
set_position(ast_obj, this.position);
return ast_obj;
};
$ClassCtx.prototype.toString = function () {
return "(class) " + this.name + " " + this.tree + " args " + this.args;
};
$ClassCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
C.set_name(value);
C.expect = "(:";
return C;
}
break;
case "(":
if (C.name === undefined) {
$_SyntaxError(C, "missing class name");
}
return new $CallCtx(C);
case ":":
if (this.args) {
for (var arg of this.args.tree) {
var param = arg.tree[0];
if (
(param.type == "expr" && param.name == "id") ||
param.type == "kwarg"
) {
continue;
}
$_SyntaxError(C, "invalid class parameter");
}
}
return $BodyCtx(C);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$ClassCtx.prototype.set_name = function (name) {
var C = this.parent;
this.random = $B.UUID();
this.name = name;
this.id = C.node.module + "_" + name + "_" + this.random;
this.binding = {};
this.parent.node.id = this.id;
var scope = this.scope,
parent_block = scope;
var block = scope,
parent_classes = [];
while (block.ntype == "class") {
parent_classes.splice(0, 0, block.C.tree[0].name);
block = block.parent;
}
this.qualname = parent_classes.concat([name]).join(".");
while (parent_block.C && parent_block.C.tree[0].type == "class") {
parent_block = parent_block.parent;
}
while (
parent_block.C &&
"def" != parent_block.C.tree[0].type &&
"generator" != parent_block.C.tree[0].type
) {
parent_block = parent_block.parent;
}
this.parent.node.parent_block = parent_block;
$bind(name, scope, this);
if (scope.is_function) {
if (scope.C.tree[0].locals.indexOf(name) == -1) {
scope.C.tree[0].locals.push(name);
}
}
};
$ClassCtx.prototype.transform = function (node, rank) {
this.doc_string = $get_docstring(node);
this.module = $get_module(this).module.replace(/\./g, "_");
var indent = "\n" + " ".repeat(node.indent + 12),
instance_decl = new $Node(),
local_ns = "$locals_" + this.id.replace(/\./g, "_"),
js =
"var " +
local_ns +
" = {" +
"__annotations__: $B.empty_dict()}, " +
indent +
"$locals = " +
local_ns;
new $NodeJSCtx(instance_decl, js);
node.insert(0, instance_decl);
var global_scope = this.scope;
while (global_scope.parent_block.id !== "__builtins__") {
global_scope = global_scope.parent_block;
}
var global_ns = "$locals_" + global_scope.id.replace(/\./g, "_");
var js =
" ".repeat(node.indent + 4) +
'$locals.$name = "' +
this.name +
'"' +
indent +
'$locals.$qualname = "' +
this.qualname +
'"' +
indent +
"$locals.$is_class = true; " +
indent +
'$locals.$line_info = "' +
node.line_num +
"," +
this.module +
'";' +
indent +
'var $top_frame = ["' +
local_ns +
'", $locals,' +
'"' +
global_scope.id +
'", ' +
global_ns +
"]" +
indent +
"$locals.$f_trace = $B.enter_frame($top_frame);" +
indent +
"if($locals.$f_trace !== _b_.None){\n" +
"$locals.$f_trace = $B.trace_line()}";
node.insert(1, $NodeJS(js));
node.add(
$NodeJS(
"if($locals.$f_trace !== _b_.None){\n" + "$B.trace_return(_b_.None)}"
)
);
node.add($NodeJS("$B.leave_frame({$locals})"));
var ret_obj = new $Node();
new $NodeJSCtx(ret_obj, "return " + local_ns + ";");
node.insert(node.children.length, ret_obj);
var run_func = new $Node();
new $NodeJSCtx(run_func, ")();");
node.parent.insert(rank + 1, run_func);
var module_name = "$locals_" + this.module + ".__name__";
rank++;
node.parent.insert(
rank + 1,
$NodeJS(
"$" + this.name + "_" + this.random + ".__module__ = " + module_name
)
);
var scope = $get_scope(this);
var name_ref = ";$locals_" + scope.id.replace(/\./g, "_");
name_ref += '["' + this.name + '"]';
var js = [name_ref + ' = $B.$class_constructor("' + this.name],
pos = 1;
js[pos++] = '", $' + this.name + "_" + this.random;
if (this.args !== undefined) {
var arg_tree = this.args.tree,
args = [],
kw = [];
for (var _tmp of arg_tree) {
if (_tmp.tree[0].type == "kwarg") {
kw.push(_tmp.tree[0]);
} else {
args.push(_tmp.to_js());
}
}
js[pos++] = ", _b_.tuple.$factory([" + args.join(",") + "]),[";
var _re = new RegExp('"', "g"),
_r = [],
rpos = 0;
for (var arg of args) {
_r[rpos++] = '"' + arg.replace(_re, '\\"') + '"';
}
js[pos++] = _r.join(",") + "]";
_r = [];
rpos = 0;
for (var _tmp of kw) {
_r[rpos++] =
'["' + _tmp.tree[0].value + '",' + _tmp.tree[1].to_js() + "]";
}
js[pos++] = ",[" + _r.join(",") + "]";
} else {
js[pos++] = ", _b_.tuple.$factory([]),[],[]";
}
js[pos++] = ")";
var cl_cons = new $Node();
new $NodeJSCtx(cl_cons, js.join(""));
rank++;
node.parent.insert(rank + 1, cl_cons);
rank++;
var ds_node = new $Node();
js = name_ref + ".__doc__ = " + (this.doc_string || "_b_.None") + ";";
new $NodeJSCtx(ds_node, js);
node.parent.insert(rank + 1, ds_node);
if (scope.ntype == "module") {
var w_decl = new $Node();
new $NodeJSCtx(w_decl, '$locals["' + this.name + '"] = ' + this.name);
}
node.parent.insert(rank + 2, $NodeJS("_b_.None;"));
this.transformed = true;
};
$ClassCtx.prototype.to_js = function () {
this.js_processed = true;
return "var $" + this.name + "_" + this.random + " = (function()";
};
var Comprehension = {
admin_infos: function (comp) {
var id = comp.id,
node = $get_node(comp);
return (
`var $locals_${id} = {},
$locals = $locals_${id}
$locals.$line_info = '${node.line_num},${node.module}'\n` +
Comprehension.code(comp) +
`var $top_frame = ["${id}", $locals_${id}, "${comp.module}", $locals_${comp.module_ref}]
$locals.$f_trace = $B.enter_frame($top_frame)
`
);
},
code: function (comp) {
var node = $get_node(comp),
varnames = Object.keys(comp.varnames || {})
.map((x) => `'${x}'`)
.join(", ");
return `$locals.$comp_code = {
co_argcount: 1,
co_firstlineno:${node.line_num},
co_name: "<${comp.type}>",
co_flags: ${comp.type == "genexpr" ? 115 : 83},
co_freevars: $B.fast_tuple([]),
co_kwonlyargcount: 0,
co_posonlyargount: 0,
co_varnames: $B.fast_tuple(['.0', ${varnames}])
}
$locals['.0'] = expr\n`;
},
generators: function (comp) {
var comprehensions = [];
for (item of comp) {
if (item.type == "for") {
comprehensions.push(
new ast.comprehension(
ast_or_obj(item.tree[0]),
ast_or_obj(item.tree[1]),
[],
item.is_async ? 1 : 0
)
);
} else {
$B.last(comprehensions).ifs.push(ast_or_obj(item.tree[0]));
}
}
return comprehensions;
},
make_comp: function (comp, C) {
comp.comprehension = true;
comp.parent = C.parent;
comp.binding = {};
comp.id = comp.type + $B.UUID();
var scope = $get_scope(C);
comp.parent_block = scope;
while (scope) {
if (
scope.C &&
scope.C.tree &&
scope.C.tree.length > 0 &&
scope.C.tree[0].async
) {
comp.async = true;
break;
}
scope = scope.parent_block;
}
comp.module = $get_module(C).module;
comp.module_ref = comp.module.replace(/\./g, "_");
C.parent.tree[C.parent.tree.length - 1] = comp;
Comprehension.set_parent_block(C.tree[0], comp);
},
set_parent_block: function (ctx, parent_block) {
if (ctx.tree) {
for (var item of ctx.tree) {
if (item.comprehension) {
item.parent_block = parent_block;
}
Comprehension.set_parent_block(item, parent_block);
}
}
},
get_awaits: function (ctx, awaits) {
awaits = awaits || [];
if (ctx.type == "await") {
awaits.push(ctx);
} else if (ctx.tree) {
for (var item of ctx.tree) {
Comprehension.get_awaits(item, awaits);
}
}
return awaits;
},
has_await: function (ctx) {
var node = $get_node(ctx),
awaits = Comprehension.get_awaits(ctx);
for (var aw of awaits) {
var ix = node.awaits.indexOf(aw);
if (ix > -1) {
node.awaits.splice(ix, 1);
}
}
return awaits.length > 0;
},
};
var $ConditionCtx = ($B.parser.$ConditionCtx = function (C, token) {
this.type = "condition";
this.token = token;
this.parent = C;
this.tree = [];
this.position = $token.value;
this.node = $get_node(this);
this.scope = $get_scope(this);
if (token == "while") {
this.loop_num = $loop_num++;
}
if (token == "elif") {
var rank = this.node.parent.children.indexOf(this.node),
previous = this.node.parent.children[rank - 1];
previous.C.tree[0].orelse = this;
}
C.tree.push(this);
});
$ConditionCtx.prototype.ast = function () {
var types = { if: "If", while: "While", elif: "If" };
var res = new ast[types[this.token]](ast_or_obj(this.tree[0]));
if (this.orelse) {
if (this.orelse.token == "elif") {
res.orelse = [ast_or_obj(this.orelse)];
} else {
res.orelse = ast_or_obj(this.orelse);
}
} else {
res.orelse = [];
}
res.body = ast_body(this);
set_position(res, this.position);
return res;
};
$ConditionCtx.prototype.toString = function () {
return this.token + " " + this.tree;
};
$ConditionCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ":") {
if (C.tree[0].type == "abstract_expr" && C.tree[0].tree.length == 0) {
$_SyntaxError(C, "token " + token + " after " + C);
}
return $BodyCtx(C);
} else if (this.in_comp && this.token == "if") {
if (token == "]") {
return $transition(C.parent, token, value);
} else if (token == "if") {
var if_exp = new $ConditionCtx(C.parent, "if");
if_exp.in_comp = true;
return new $AbstractExprCtx(if_exp, false);
} else if (")]}".indexOf(token) > -1) {
return $transition(this.parent, token, value);
}
}
$_SyntaxError(C, ["expected ':'"]);
};
$ConditionCtx.prototype.transform = function (node, rank) {
var scope = $get_scope(this);
if (this.token == "while") {
node.parent.insert(
rank,
$NodeJS("var $no_break" + this.loop_num + " = true")
);
var module = $get_module(this).module;
if ($B.last(node.children).C.tree[0].type != "return") {
var js =
'$locals.$line_info = "' +
node.line_num +
"," +
module +
'";if($locals.$f_trace !== _b_.None){\n' +
"$B.trace_line()};_b_.None;";
node.add($NodeJS(js));
}
return 2;
}
};
$ConditionCtx.prototype.to_js = function () {
this.js_processed = true;
var tok = this.token;
if (tok == "elif") {
tok = "else if";
}
var res = [tok + "($B.$bool("];
if (tok == "while") {
res.push("$no_break" + this.loop_num + " && ");
} else if (tok == "else if") {
var line_info = $get_node(this).line_num + "," + $get_scope(this).id;
res.push('($B.set_line("' + line_info + '")) && ');
}
if (this.tree.length == 1) {
res.push($to_js(this.tree) + "))");
} else {
res.push(this.tree[0].to_js() + "))");
if (this.tree[1].tree.length > 0) {
res.push("{" + this.tree[1].to_js() + "}");
}
}
return res.join("");
};
var $ContinueCtx = ($B.parser.$ContinueCtx = function (C) {
this.type = "continue";
this.parent = C;
this.position = $token.value;
$get_node(this).is_continue = true;
C.tree[C.tree.length] = this;
set_loop_context.apply(this, [C, "continue"]);
});
$ContinueCtx.prototype.ast = function () {
var ast_obj = new ast.Continue();
set_position(ast_obj, this.position);
return ast_obj;
};
$ContinueCtx.prototype.toString = function () {
return "(continue)";
};
$ContinueCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
return C.parent;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$ContinueCtx.prototype.to_js = function () {
this.js_processed = true;
var js = "continue";
if (this.loop_ctx.has_break) {
js = `$locals["$no_break${this.loop_ctx.loop_num}"] = true;${js}`;
}
return js;
};
var $DebuggerCtx = ($B.parser.$DebuggerCtx = function (C) {
this.type = "continue";
this.parent = C;
C.tree[C.tree.length] = this;
});
$DebuggerCtx.prototype.toString = function () {
return "(debugger)";
};
$DebuggerCtx.prototype.transition = function (token, value) {
var C = this;
};
$DebuggerCtx.prototype.to_js = function () {
this.js_processed = true;
return "debugger";
};
var $DecoratorCtx = ($B.parser.$DecoratorCtx = function (C) {
this.type = "decorator";
this.parent = C;
C.tree[C.tree.length] = this;
this.tree = [];
this.position = $token.value;
});
$DecoratorCtx.prototype.toString = function () {
return "(decorator) " + this.tree;
};
$DecoratorCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "id" && C.tree.length == 0) {
return $transition(new $AbstractExprCtx(C, false), token, value);
}
if (token == "eol") {
return $transition(C.parent, token);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$DecoratorCtx.prototype.transform = function (node, rank) {
var func_rank = rank + 1,
children = node.parent.children,
decorators = [this.tree];
while (1) {
if (func_rank >= children.length) {
$_SyntaxError(node.C, ["decorator expects function"]);
} else if (children[func_rank].C.type == "node_js") {
func_rank++;
} else if (children[func_rank].C.tree[0].type == "decorator") {
decorators.push(children[func_rank].C.tree[0].tree);
children.splice(func_rank, 1);
} else {
break;
}
}
this.dec_ids = [];
var pos = 0;
for (var _ of decorators) {
this.dec_ids.push("$id" + $B.UUID());
}
var obj = children[func_rank].C.tree[0];
if (obj.type == "def") {
obj.decorated = true;
obj.alias = "$dec" + $B.UUID();
}
var tail = "",
scope = $get_scope(this),
ref = '$locals["';
if (scope.globals && scope.globals.has(obj.name)) {
var module = $get_module(this);
ref = "$locals_" + module.id + '["';
}
ref += obj.name + '"]';
var res = ref + " = ";
decorators.forEach(function (elt, i) {
res += "$B.$call(" + this.dec_ids[i] + ")(";
tail += ")";
}, this);
res += (obj.decorated ? obj.alias : ref) + tail + ";";
$bind(obj.name, scope, this);
node.parent.insert(func_rank + 1, $NodeJS(res));
this.decorators = decorators;
};
$DecoratorCtx.prototype.to_js = function () {
this.js_processed = true;
var res = [];
this.decorators.forEach(function (decorator, i) {
res.push("var " + this.dec_ids[i] + " = " + $to_js(decorator) + ";");
}, this);
return res.join("");
};
function get_decorators(node) {
var decorators = [];
var parent_node = node.parent;
var rank = parent_node.children.indexOf(node);
while (true) {
rank--;
if (rank < 0) {
break;
} else if (parent_node.children[rank].C.tree[0].type == "decorator") {
var deco = parent_node.children[rank].C.tree[0].tree[0];
decorators.splice(0, 0, ast_or_obj(deco));
} else {
break;
}
}
return decorators;
}
var $DefCtx = ($B.parser.$DefCtx = function (C) {
this.type = "def";
this.name = null;
this.parent = C;
this.tree = [];
this.async = C.async;
if (this.async) {
this.position = C.position;
} else {
this.position = $token.value;
}
this.locals = [];
C.tree[C.tree.length] = this;
this.enclosing = [];
var scope = (this.scope = $get_scope(this));
if (scope.C && scope.C.tree[0].type == "class") {
this.class_name = scope.C.tree[0].name;
}
C.node.binding = {};
var parent_block = scope;
while (parent_block.C && parent_block.C.tree[0].type == "class") {
parent_block = parent_block.parent;
}
while (parent_block.C && "def" != parent_block.C.tree[0].type) {
parent_block = parent_block.parent;
}
this.parent.node.parent_block = parent_block;
var pb = parent_block;
this.is_comp = pb.is_comp;
while (pb && pb.C) {
if (pb.C.tree[0].type == "def") {
this.inside_function = true;
break;
}
pb = pb.parent_block;
}
this.module = scope.module;
this.root = $get_module(this);
this.num = $loop_num;
$loop_num++;
this.positional_list = [];
this.default_list = [];
this.other_args = null;
this.other_kw = null;
this.after_star = [];
});
$DefCtx.prototype.ast = function () {
var args = {
posonlyargs: [],
args: [],
kwonlyargs: [],
kw_defaults: [],
defaults: [],
},
decorators = get_decorators(this.parent.node),
func_args = this.tree[1],
state = "arg",
default_value,
res;
args = ast_or_obj(func_args);
if (this.async) {
res = new ast.AsyncFunctionDef(this.name, args, [], decorators);
} else {
res = new ast.FunctionDef(this.name, args, [], decorators);
}
if (this.annotation) {
res.returns = ast_or_obj(this.annotation.tree[0]);
}
res.body = ast_body(this.parent);
set_position(res, this.position);
return res;
};
$DefCtx.prototype.set_name = function (name) {
if (["None", "True", "False"].indexOf(name) > -1) {
$_SyntaxError(this, "invalid function name");
}
var id_ctx = new $IdCtx(this, name);
this.name = name;
this.id = this.scope.id + "_" + name;
this.id = this.id.replace(/\./g, "_");
this.id += "_" + $B.UUID();
this.parent.node.id = this.id;
this.parent.node.module = this.module;
this.binding = {};
var scope = this.scope;
if (scope.globals !== undefined && scope.globals.has(name)) {
$bind(name, this.root, this);
} else {
$bind(name, scope, this);
}
id_ctx.bound = true;
if (scope.is_function) {
if (scope.C.tree[0].locals.indexOf(name) == -1) {
scope.C.tree[0].locals.push(name);
}
}
};
$DefCtx.prototype.toString = function () {
return "def " + this.name + "(" + this.tree + ")";
};
$DefCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.name) {
$_SyntaxError(C, "token " + token + " after " + C);
}
C.set_name(value);
return C;
case "(":
if (C.name == null) {
$_SyntaxError(C, "missing name in function definition");
}
C.has_args = true;
return new $FuncArgs(C);
case ")":
return C;
case "annotation":
return new $AbstractExprCtx(new $AnnotationCtx(C), true);
case ":":
if (C.has_args) {
return $BodyCtx(C);
} else {
$_SyntaxError(C, "missing function parameters");
}
case "eol":
if (C.has_args) {
$_SyntaxError(C, "missing colon");
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$DefCtx.prototype.transform = function (node, rank) {
if (this.is_comp) {
$get_node(this).is_comp = true;
}
if (this.transformed !== undefined) {
return;
}
var scope = this.scope;
this.doc_string = $get_docstring(node);
this.rank = rank;
var indent = node.indent + 12;
if (this.name.substr(0, 15) == "lambda_" + $B.lambda_magic) {
var pblock = scope.parent_block;
if (pblock.C && pblock.C.tree[0].type == "def") {
this.enclosing.push(pblock);
}
}
var pnode = this.parent.node;
while (pnode.parent && pnode.parent.is_def_func) {
this.enclosing.push(pnode.parent.parent);
pnode = pnode.parent.parent;
}
var defaults = [],
defs1 = [],
has_end_pos = false;
this.argcount = 0;
this.kwonlyargcount = 0;
this.kwonlyargsdefaults = [];
this.otherdefaults = [];
this.varnames = {};
this.args = [];
this.__defaults__ = [];
this.slots = [];
var slot_list = [],
slot_init = [],
annotations = [];
if (this.annotation) {
if (
this.annotation.type == "expr" &&
this.annotation.tree[0].type == "str"
) {
annotations.push('"return":' + this.annotation.to_js());
} else {
var ann_string = this.annotation.string.trim();
annotations.push(
`"return": $B.handle_annotation(` +
`"${ann_string.replace(/"/g, '\\"')}")`
);
}
}
this.func_name = this.tree[0].to_js();
var func_name1 = this.func_name;
if (this.decorated) {
this.func_name = "var " + this.alias;
func_name1 = this.alias;
}
var func_args = this.tree[1].tree;
for (var arg of func_args) {
if (arg.type == "end_positional") {
this.args.push("/");
slot_list.push('"/"');
has_end_pos = true;
} else {
this.args.push(arg.name);
this.varnames[arg.name] = true;
}
if (arg.type == "func_arg_id") {
if (this.star_arg) {
this.kwonlyargcount++;
if (arg.has_default) {
this.kwonlyargsdefaults.push(arg.name);
}
} else {
this.argcount++;
if (arg.has_default) {
this.otherdefaults.push(arg.name);
}
}
this.slots.push('"' + arg.name + '":null');
slot_list.push('"' + arg.name + '"');
slot_init.push('"' + arg.name + '": _' + arg.name);
if (arg.tree.length > 0) {
defaults.push('"' + arg.name + '"');
defs1.push(arg.name + ":" + $to_js(arg.tree));
this.__defaults__.push($to_js(arg.tree));
}
} else if (arg.type == "func_star_arg") {
if (arg.op == "*") {
this.star_arg = arg.name;
} else if (arg.op == "**") {
this.kw_arg = arg.name;
}
}
if (arg.annotation) {
var name = $mangle(arg.name, this);
if (
arg.annotation.type == "expr" &&
arg.annotation.tree[0].type == "str"
) {
annotations.push('"return":' + arg.annotation.to_js());
} else {
var ann_string = arg.annotation.string.trim();
annotations.push(
`"return": $B.handle_annotation(` +
`"${ann_string.replace(/"/g, '\\"')}")`
);
}
}
}
slot_init = "{" + slot_init.join(", ") + "}";
var flags = 67;
if (this.star_arg) {
flags |= 4;
}
if (this.kw_arg) {
flags |= 8;
}
if (this.type == "generator") {
flags |= 32;
}
if (this.async) {
flags |= 128;
}
var nodes = [],
js;
var global_scope = scope;
while (
global_scope.parent_block &&
global_scope.parent_block.id !== "__builtins__"
) {
global_scope = global_scope.parent_block;
}
var global_ns = "$locals_" + global_scope.id.replace(/\./g, "_");
var name = this.name + this.num;
var local_ns = "$locals_" + this.id,
h = "\n" + " ".repeat(indent);
js = "var " + local_ns + " = {}," + h + "$locals = " + local_ns + ";";
var new_node = new $Node();
new_node.locals_def = true;
new_node.func_node = node;
new $NodeJSCtx(new_node, js);
nodes.push(new_node);
var enter_frame_nodes = [
$NodeJS(
'$locals.$line_info = "' + node.line_num + "," + this.module + '"'
),
$NodeJS(
`var $top_frame = ["${this.id}", $locals,` +
'"' +
global_scope.id +
'", ' +
global_ns +
", " +
(this.is_comp ? this.name : name) +
"]"
),
$NodeJS("$locals.$f_trace = $B.enter_frame($top_frame)"),
$NodeJS("var $stack_length = $B.frames_stack.length;"),
];
if (this.type == "generator") {
enter_frame_nodes.push($NodeJS("$locals.$is_generator = true"));
}
if (this.async) {
enter_frame_nodes.splice(1, 0, $NodeJS(`$locals.$async = "${this.id}"`));
}
for (var _node of enter_frame_nodes) {
_node.enter_frame = true;
}
if (this.is_comp) {
nodes.push($NodeJS("var $defaults = {}"));
}
this.env = [];
var make_args_nodes = [];
var js =
local_ns +
' = $locals = $B.args("' +
this.name +
'", ' +
this.argcount +
", {" +
this.slots.join(", ") +
"}, " +
"[" +
slot_list.join(", ") +
"], arguments, $defaults, " +
this.other_args +
", " +
this.other_kw +
");";
var new_node = new $Node();
new $NodeJSCtx(new_node, js);
make_args_nodes.push(new_node);
var only_positional = false;
if (
this.other_args === null &&
this.other_kw === null &&
this.after_star.length == 0 &&
!has_end_pos
) {
only_positional = true;
nodes.push($NodeJS("var $len = arguments.length;"));
var new_node = new $Node();
var js =
"var last_arg;if($len > 0 && ((last_arg = " +
"arguments[$len - 1]) !== undefined) && last_arg.$nat " +
"!== undefined)";
new $NodeJSCtx(new_node, js);
nodes.push(new_node);
for (var item of make_args_nodes) {
new_node.add(item);
}
var else_node = new $Node();
new $NodeJSCtx(else_node, "else");
nodes.push(else_node);
var pos_len = this.slots.length;
var test_node = $NodeJS("if($len == " + pos_len + ")");
else_node.add(test_node);
test_node.add(
$NodeJS(local_ns + " = $locals = $B.conv_undef(" + slot_init + ")")
);
else_node.add(
$NodeJS(
"else if($len > " +
pos_len +
'){\n$B.wrong_nb_args("' +
this.name +
'", $len, ' +
pos_len +
", [" +
slot_list +
"])}"
)
);
if (pos_len > 0) {
else_node.add(
$NodeJS(
"else if($len + Object.keys($defaults).length < " +
pos_len +
'){\n$B.wrong_nb_args("' +
this.name +
'", $len, ' +
pos_len +
", [" +
slot_list +
"])}"
)
);
var subelse_node = $NodeJS("else");
else_node.add(subelse_node);
subelse_node.add(
$NodeJS(
local_ns + " = $locals = " + "$B.conv_undef(" + slot_init + ")"
)
);
subelse_node.add($NodeJS("var defparams = [" + slot_list + "]"));
subelse_node.add(
$NodeJS(
"for(var i = $len; i < defparams.length" +
"; i++){\n$locals[defparams[i]] = $defaults[defparams[i]]}"
)
);
}
} else {
nodes.push(make_args_nodes[0]);
if (make_args_nodes.length > 1) {
nodes.push(make_args_nodes[1]);
}
}
nodes = nodes.concat(enter_frame_nodes);
var is_method = scope.ntype == "class";
if (is_method) {
var scope_ref = "$locals_" + scope.parent_block.id.replace(/\./g, "_"),
class_ref = scope.C.tree[0].qualname;
var had_class = this.parent.node.binding["__class__"];
this.parent.node.binding["__class__"] = true;
nodes.push(
$NodeJS(
"$locals.__class__ = $B.get_method_class(" +
scope_ref +
', "' +
class_ref +
'")'
)
);
}
nodes.push($NodeJS("$B.js_this = this;"));
for (var i = nodes.length - 1; i >= 0; i--) {
node.children.splice(0, 0, nodes[i]);
}
var def_func_node = new $Node();
this.params = "";
if (only_positional) {
this.params = Object.keys(this.varnames)
.map((x) => "_" + x)
.join(", ");
}
new $NodeJSCtx(def_func_node, "");
def_func_node.is_def_func = true;
def_func_node.module = this.module;
var last_node = node.children[node.children.length - 1],
indent = last_node.get_indent(),
last_instr = last_node.C.tree[0];
if (last_instr.type != "return") {
js =
"if($locals.$f_trace !== _b_.None){\n$B.trace_return(_b_.None)}\n" +
" ".repeat(indent + 1);
js += "$B.leave_frame";
if (this.id.substr(0, 5) == "$exec") {
js += "_exec";
}
js += "({$locals});return _b_.None";
node.add($NodeJS(js));
}
var free_vars = [];
if (this.parent.node.referenced) {
for (var attr in this.parent.node.referenced) {
if (!this.parent.node.binding.hasOwnProperty(attr)) {
free_vars.push('"' + attr + '"');
}
}
}
if (this.parent.node.nonlocals) {
for (var key of this.parent.node.nonlocals) {
var attr = '"' + key + '"';
if (free_vars.indexOf(attr) == -1) {
free_vars.push(attr);
}
}
}
node.add(def_func_node);
var offset = 1,
indent = node.indent;
if (!this.is_comp) {
node.parent.insert(rank + offset++, $NodeJS(name + ".$is_func = true"));
if (this.$has_yield_in_cm) {
node.parent.insert(
rank + offset++,
$NodeJS(name + ".$has_yield_in_cm = true")
);
}
node.parent.insert(rank + offset++, $NodeJS(name + ".$infos = {"));
var __name__ = this.name;
if (__name__.substr(0, 15) == "lambda_" + $B.lambda_magic) {
__name__ = "<lambda>";
}
js = ' __name__:"' + __name__ + '",';
node.parent.insert(rank + offset++, $NodeJS(js));
var __qualname__ = __name__;
if (this.class_name) {
__qualname__ = this.class_name + "." + __name__;
}
js = ' __qualname__:"' + __qualname__ + '",';
node.parent.insert(rank + offset++, $NodeJS(js));
if (this.otherdefaults.length > 0) {
var def_names = [];
for (var _default of this.otherdefaults) {
def_names.push("$defaults." + _default);
}
node.parent.insert(
rank + offset++,
$NodeJS(
" __defaults__ : " +
"$B.fast_tuple([" +
def_names.join(", ") +
"]),"
)
);
} else {
node.parent.insert(
rank + offset++,
$NodeJS(" __defaults__ : " + "_b_.None,")
);
}
if (this.kwonlyargsdefaults.lengh > 0) {
var def_names = [];
for (var _default of this.kwonlyargsdefaults) {
def_names.push("$defaults." + _default);
}
node.parent.insert(
rank + offset++,
$NodeJS(
" __kwdefaults__ : " +
"$B.fast_tuple([" +
def_names.join(", ") +
"]),"
)
);
} else {
node.parent.insert(
rank + offset++,
$NodeJS(" __kwdefaults__ : " + "_b_.None,")
);
}
node.parent.insert(
rank + offset++,
$NodeJS(" __annotations__: {" + annotations.join(",") + "},")
);
node.parent.insert(
rank + offset++,
$NodeJS(" __dict__: $B.empty_dict(),")
);
node.parent.insert(
rank + offset++,
$NodeJS(" __doc__: " + (this.doc_string || "_b_.None") + ",")
);
var root = $get_module(this);
node.parent.insert(
rank + offset++,
$NodeJS(' __module__ : "' + root.module + '",')
);
for (var attr in this.parent.node.binding) {
if (attr == "__class__" && is_method && !had_class) {
continue;
}
this.varnames[attr] = true;
}
var co_varnames = [];
for (var attr in this.varnames) {
co_varnames.push('"' + attr + '"');
}
var CODE_MARKER = "___%%%-CODE-%%%___" + this.name + this.num;
var h = "\n" + " ".repeat(indent + 8);
js = " __code__:{" + h + " co_argcount:" + this.argcount;
var h1 = "," + h + " ".repeat(4);
var module = $get_module(this).module;
var co_name = this.name;
if (co_name.startsWith("lambda_" + $B.lambda_magic)) {
co_name = "<lambda>";
}
js +=
h1 +
"co_filename:$locals_" +
module.replace(/\./g, "_") +
'["__file__"] || "<string>"' +
h1 +
"co_firstlineno:" +
node.line_num +
h1 +
"co_flags:" +
flags +
h1 +
"co_freevars: [" +
free_vars +
"]" +
h1 +
"co_kwonlyargcount:" +
this.kwonlyargcount +
h1 +
'co_name: "' +
co_name +
'"' +
h1 +
"co_nlocals: " +
co_varnames.length +
h1 +
"co_posonlyargcount: " +
(this.pos_only || 0) +
h1 +
"co_varnames: $B.fast_tuple([" +
co_varnames.join(", ") +
"])" +
h +
"}\n" +
" ".repeat(indent + 4) +
"};";
js += "_b_.None;";
node.parent.insert(rank + offset++, $NodeJS(js));
}
this.default_str = "{" + defs1.join(", ") + "}";
if (!this.is_comp) {
var name1 = name;
if (this.type == "generator") {
name1 = `$B.generator.$factory(${name})`;
}
var res = "return " + name1;
if (this.async) {
if (this.type == "generator") {
res = `return $B.async_generator.$factory(${name})`;
} else {
res = "return $B.make_async(" + name1 + ")";
}
}
node.parent.insert(rank + offset++, $NodeJS(res + "}"));
node.parent.insert(
rank + offset++,
$NodeJS(
this.func_name +
" = " +
this.name +
"$" +
this.num +
"(" +
this.default_str +
")"
)
);
node.parent.insert(
rank + offset++,
$NodeJS(
func_name1 +
".$set_defaults = function(value){\nreturn " +
func_name1 +
" = " +
this.name +
"$" +
this.num +
"(value)}"
)
);
if (this.$has_yield_in_cm) {
node.parent.insert(
rank + offset++,
$NodeJS(`${func_name1}.$has_yield_in_cm = true`)
);
}
}
var parent = node;
for (
var pos = 0;
pos < parent.children.length &&
parent.children[pos] !== $B.last(enter_frame_nodes);
pos++
) {}
var try_node = $NodeJS("try"),
children = parent.children.slice(pos + 1);
parent.insert(pos + 1, try_node);
for (var child of children) {
if (child.is_def_func) {
for (var grand_child of child.children) {
try_node.add(grand_child);
}
} else {
try_node.add(child);
}
}
parent.children.splice(pos + 2, parent.children.length);
var except_node = $NodeJS("catch(err)");
except_node.add($NodeJS("$B.set_exc(err)"));
except_node.add(
$NodeJS(
"if((! err.$in_trace_func) && $locals.$f_trace !== _b_.None){\n" +
"$locals.$f_trace = $B.trace_exception()}"
)
);
except_node.add($NodeJS("$B.leave_frame({$locals});throw err"));
parent.add(except_node);
this.transformed = true;
return offset;
};
$DefCtx.prototype.to_js = function (func_name) {
this.js_processed = true;
if (this.is_comp) {
return (
"var " +
this.name +
" = " +
(this.async ? " async " : "") +
"function* (_expr)"
);
}
func_name = func_name || this.tree[0].to_js();
if (this.decorated) {
func_name = "var " + this.alias;
}
return (
"var " +
this.name +
"$" +
this.num +
" = function($defaults){\n" +
(this.async ? "async " : "") +
"function" +
(this.type == "generator" ? "* " : " ") +
this.name +
this.num +
"(" +
this.params +
")"
);
};
var $DelCtx = ($B.parser.$DelCtx = function (C) {
this.type = "del";
this.parent = C;
C.tree.push(this);
this.tree = [];
this.position = $token.value;
});
$DelCtx.prototype.ast = function () {
var targets;
if (this.tree[0].type == "list_or_tuple") {
targets = this.tree[0].tree.map(ast_or_obj);
} else if (
this.tree[0].type == "expr" &&
this.tree[0].tree[0].type == "list_or_tuple"
) {
targets = ast_or_obj(this.tree[0].tree[0]);
targets.ctx = new ast.Del();
for (var elt of targets.elts) {
elt.ctx = new ast.Del();
}
var ast_obj = new ast.Delete([targets]);
set_position(ast_obj, this.position);
return ast_obj;
} else {
targets = [ast_or_obj(this.tree[0].tree[0])];
}
for (var target of targets) {
target.ctx = new ast.Del();
}
var ast_obj = new ast.Delete(targets);
set_position(ast_obj, this.position);
return ast_obj;
};
$DelCtx.prototype.toString = function () {
return "del " + this.tree;
};
$DelCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
check_assignment(this.tree[0], { action: "delete" });
return $transition(C.parent, token);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$DelCtx.prototype.to_js = function () {
this.js_processed = true;
var C = this.parent;
if (this.tree[0].type == "list_or_tuple") {
var res = [];
for (var elt of this.tree[0].tree) {
var subdel = new $DelCtx(C);
subdel.tree = [elt];
res.push(subdel.to_js());
C.tree.pop();
}
this.tree = [];
return res.join(";");
} else if (
this.tree[0].type == "expr" &&
this.tree[0].tree[0].type == "list_or_tuple"
) {
this.tree[0] = this.tree[0].tree[0];
return this.to_js();
} else {
var expr = this.tree[0].tree[0];
switch (expr.type) {
case "id":
var scope = $get_scope(this),
is_global = false;
if (
(scope.ntype == "def" || scope.ntype == "generator") &&
scope.globals &&
scope.globals.has(expr.value)
) {
scope = scope.parent;
while (scope.parent && scope.parent.id !== "__builtins__") {
scope = scope.parent;
}
is_global = true;
}
var res =
'$B.$delete("' +
expr.value +
'"' +
(is_global ? ', "global"' : "") +
");";
delete scope.binding[expr.value];
return res;
case "list_or_tuple":
var res = [];
for (var elt of expr.tree) {
res.push("delete " + elt.to_js());
}
return res.join(";");
case "sub":
expr.func = "delitem";
js = expr.to_js();
expr.func = "getitem";
return js;
case "attribute":
return "_b_.delattr(" + expr.value.to_js() + ',"' + expr.name + '")';
default:
$_SyntaxError(this, ["cannot delete " + expr.type]);
}
}
};
var DictCompCtx = function (C) {
if (C.tree[0].type == "expr" && C.tree[0].tree[0].comprehension) {
var comp = C.tree[0].tree[0];
comp.parent_block = this;
}
this.type = "dictcomp";
this.position = $token.value;
this.comprehension = true;
this.parent = C.parent;
this.key = C.tree[0];
this.value = C.tree[1];
this.key.parent = this;
this.value.parent = this;
this.tree = [];
this.binding = {};
this.id = "dictcomp" + $B.UUID();
this.parent_block = $get_scope(C);
this.module = $get_module(C).module;
C.parent.tree[C.parent.tree.length - 1] = this;
this.type = "dictcomp";
Comprehension.make_comp(this, C);
};
DictCompCtx.prototype.ast = function () {
var ast_obj = new ast.DictComp(
ast_or_obj(this.key),
ast_or_obj(this.value),
Comprehension.generators(this.tree)
);
set_position(ast_obj, this.position);
return ast_obj;
};
DictCompCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "}") {
this.has_await = Comprehension.has_await(this);
return this.parent;
}
$_SyntaxError(C, "token " + token + "after list comp");
};
DictCompCtx.prototype.to_js = function () {
var node = $get_node(this),
indent = node.get_indent();
var id = this.id,
first_for = this.tree[0],
outmost_expr = first_for.tree[1].to_js();
first_for.comp_body = true;
first_for.iterable_is_outermost = true;
var module_id = this.module.replace(/\./g, "_");
var js =
`(${this.has_await ? "async " : ""}function(expr){` +
Comprehension.admin_infos(this) +
`\nvar $result_${id} = $B.empty_dict()\n`;
js += first_for.to_js(indent);
var nb = -1;
for (var i = 1; i < this.tree.length; i++) {
nb++;
var stmt = this.tree[i];
if (stmt.type == "for") {
stmt.comp_body = true;
js += "\n" + stmt.to_js(indent + nb);
} else if (stmt.type == "condition" && stmt.token == "if") {
js += "\n" + " ".repeat(12 + 4 * nb) + stmt.to_js() + "{";
}
}
var expr_has_await = Comprehension.has_await(this.value);
js +=
"\n" +
" ".repeat(16 + 4 * nb) +
(expr_has_await ? "var save_stack = $B.save_stack();\n" : "") +
`try{\n _b_.dict.$setitem($result_${id}, ${this.key.to_js()}, ` +
`${this.value.to_js()})\n}catch(err){\n` +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "") +
`$B.leave_frame($locals)\n` +
` throw err\n}` +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "");
for (var i = 0; i < this.tree.length; i++) {
js += "\n" + " ".repeat(12 + 4 * nb--) + "}";
}
js += `\n$B.leave_frame({$locals, value: _b_.None})`;
js += `\nreturn $result_${id}`;
js += `\n}\n)(${outmost_expr})`;
return js;
};
var $DictOrSetCtx = ($B.parser.$DictOrSetCtx = function (C) {
this.type = "dict_or_set";
this.real = "dict_or_set";
this.expect = "id";
this.closed = false;
this.start = $pos;
this.position = $token.value;
this.parent = C;
this.tree = [];
C.tree[C.tree.length] = this;
});
$DictOrSetCtx.prototype.ast = function () {
var ast_obj;
if (this.real == "dict") {
var keys = [],
values = [];
for (var i = 0, len = this.items.length; i < len; i++) {
if (this.items[i].packed) {
keys.push(_b_.None);
values.push(ast_or_obj(this.items[i]));
} else {
keys.push(ast_or_obj(this.items[i]));
values.push(ast_or_obj(this.items[i + 1]));
i++;
}
}
ast_obj = new ast.Dict(keys, values);
} else if (this.real == "set") {
var items = [];
for (var item of this.items) {
if (item.packed) {
var starred = new ast.Starred(ast_or_obj(item), new ast.Load());
set_position(starred, item.position);
items.push(starred);
} else {
items.push(ast_or_obj(item));
}
}
ast_obj = new ast.Set(items);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$DictOrSetCtx.prototype.toString = function () {
switch (this.real) {
case "dict":
return "(dict) {" + this.items + "}";
case "set":
return "(set) {" + this.tree + "}";
}
return "(dict_or_set) {" + this.tree + "}";
};
$DictOrSetCtx.prototype.transition = function (token, value) {
var C = this;
if (C.closed) {
switch (token) {
case "[":
return new $AbstractExprCtx(new $SubCtx(C.parent), false);
case "(":
return new $CallArgCtx(new $CallCtx(C.parent));
}
return $transition(C.parent, token, value);
} else {
if (C.expect == ",") {
switch (token) {
case "}":
switch (C.real) {
case "dict_or_set":
if (C.tree.length != 1) {
break;
}
C.real = "set";
case "set":
C.items = C.tree;
C.tree = [];
C.closed = true;
return C;
case "dict":
if ($B.last(this.tree).type == "abstract_expr") {
$_SyntaxError(C, [
"expression expected after dictionary key and ':'",
]);
} else if (C.nb_dict_items() % 2 != 0) {
$_SyntaxError(C, ["':' expected after dictionary key"]);
}
C.items = C.tree;
C.tree = [];
C.closed = true;
return C;
}
$_SyntaxError(C, "token " + token + " after " + C);
case ",":
if (C.real == "dict_or_set") {
C.real = "set";
}
if (C.real == "dict" && C.nb_dict_items() % 2) {
$_SyntaxError(C, ["':' expected after dictionary key"]);
}
C.expect = "id";
return C;
case ":":
if (C.real == "dict_or_set") {
C.real = "dict";
}
if (C.real == "dict") {
C.expect = "value";
C.value_pos = $pos;
return C;
} else {
$_SyntaxError(C, "token " + token + " after " + C);
}
case "for":
if (C.real == "set" && C.tree.length > 1) {
C.$pos = C.tree[0].$pos;
$_SyntaxError(C, [
"did you forget " +
"parentheses around the comprehension target?",
]);
}
if (C.real == "dict_or_set") {
return new $TargetListCtx(new $ForExpr(new SetCompCtx(this)));
} else {
return new $TargetListCtx(new $ForExpr(new DictCompCtx(this)));
}
}
$_SyntaxError(C, "token " + token + " after " + C);
} else if (C.expect == "id") {
switch (token) {
case "}":
if (C.tree.length == 0) {
C.items = [];
C.real = "dict";
} else {
C.items = C.tree;
}
C.tree = [];
C.closed = true;
return C;
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
C.expect = ",";
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
case "op":
switch (value) {
case "*":
case "**":
C.expect = ",";
var expr = new $AbstractExprCtx(C, false);
expr.packed = value.length;
if (C.real == "dict_or_set") {
C.real = value == "*" ? "set" : "dict";
} else if (
(C.real == "set" && value == "**") ||
(C.real == "dict" && value == "*")
) {
$_SyntaxError(C, "token " + token + " after " + C);
}
return expr;
case "+":
return C;
case "-":
case "~":
C.expect = ",";
var left = new $UnaryCtx(C, value);
if (value == "-") {
var op_expr = new $OpCtx(left, "unary_neg");
} else if (value == "+") {
var op_expr = new $OpCtx(left, "unary_pos");
} else {
var op_expr = new $OpCtx(left, "unary_inv");
}
return new $AbstractExprCtx(op_expr, false);
}
$_SyntaxError(C, "token " + token + " after " + C);
}
$_SyntaxError(C, "token " + token + " after " + C);
} else if (C.expect == "value") {
try {
C.expect = ",";
return $transition(new $AbstractExprCtx(C, false), token, value);
} catch (err) {
C.$pos = C.value_pos;
$_SyntaxError(C, [
"expression expected after " + "dictionary key and ':'",
]);
}
}
return $transition(C.parent, token, value);
}
};
$DictOrSetCtx.prototype.nb_dict_items = function () {
var nb = 0;
for (var item of this.tree) {
if (item.packed) {
nb += 2;
} else {
nb++;
}
}
return nb;
};
$DictOrSetCtx.prototype.packed_indices = function () {
var ixs = [];
this.items.forEach(function (t, i) {
if (t.type == "expr" && t.packed) {
ixs.push(i);
}
});
return ixs;
};
$DictOrSetCtx.prototype.unpack_dict = function (packed) {
var js = "",
res,
first,
i = 0,
item,
elts = [];
while (i < this.items.length) {
item = this.items[i];
first = i == 0;
if (item.type == "expr" && item.packed) {
res = "_b_.list.$factory(_b_.dict.items(" + item.to_js() + "))";
i++;
} else {
if (this.items[i + 1] === undefined) {
console.log(
"stack",
$B.frames_stack.slice(),
"this.items",
this.items,
"i",
i
);
}
res = "[[" + item.to_js() + "," + this.items[i + 1].to_js() + "]]";
i += 2;
}
if (!first) {
res = ".concat(" + res + ")";
}
js += res;
}
return js;
};
$DictOrSetCtx.prototype.unpack_set = function (packed) {
var js = "",
res;
this.items.forEach(function (t, i) {
if (packed.indexOf(i) > -1) {
res = "_b_.list.$factory(" + t.to_js() + ")";
} else {
res = "[" + t.to_js() + "]";
}
if (i > 0) {
res = ".concat(" + res + ")";
}
js += res;
});
return js;
};
$DictOrSetCtx.prototype.to_js = function () {
this.js_processed = true;
var packed = this.packed_indices();
if (this.real == "dict") {
if (packed.length > 0) {
return (
"_b_.dict.$factory(" +
this.unpack_dict(packed) +
")" +
$to_js(this.tree)
);
}
var res = [];
for (var i = 0; i < this.items.length; i += 2) {
res.push(
"[" + this.items[i].to_js() + "," + this.items[i + 1].to_js() + "]"
);
}
return "_b_.dict.$factory([" + res.join(",") + "])" + $to_js(this.tree);
} else if (packed.length > 0) {
return "_b_.set.$factory(" + this.unpack_set(packed) + ")";
}
return "_b_.set.$factory([" + $to_js(this.items) + "])" + $to_js(this.tree);
};
var $DoubleStarArgCtx = ($B.parser.$DoubleStarArgCtx = function (C) {
this.type = "double_star_arg";
this.parent = C;
this.tree = [];
C.tree[C.tree.length] = this;
});
$DoubleStarArgCtx.prototype.toString = function () {
return "**" + this.tree;
};
$DoubleStarArgCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
return $transition(new $AbstractExprCtx(C, false), token, value);
case ",":
case ")":
return $transition(C.parent, token);
case ":":
if (C.parent.parent.type == "lambda") {
return $transition(C.parent.parent, token);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$DoubleStarArgCtx.prototype.to_js = function () {
this.js_processed = true;
return '{$nat:"pdict",arg:' + $to_js(this.tree) + "}";
};
var $EllipsisCtx = ($B.parser.$EllipsisCtx = function (C) {
this.type = "ellipsis";
this.parent = C;
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$EllipsisCtx.prototype.ast = function () {
var ast_obj = new ast.Constant({ type: "ellipsis" });
set_position(ast_obj, this.position);
return ast_obj;
};
$EllipsisCtx.prototype.toString = function () {
return "ellipsis";
};
$EllipsisCtx.prototype.transition = function (token, value) {
var C = this;
return $transition(C.parent, token, value);
};
$EllipsisCtx.prototype.to_js = function () {
this.js_processed = true;
return '$B.builtins["Ellipsis"]';
};
var $EndOfPositionalCtx = ($B.parser.$EndOfConditionalCtx = function (C) {
this.type = "end_positional";
this.parent = C;
C.has_end_positional = true;
C.parent.pos_only = C.tree.length;
C.tree.push(this);
});
$EndOfPositionalCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "," || token == ")") {
return $transition(C.parent, token, value);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$EndOfPositionalCtx.prototype.to_js = function () {
return "/";
};
var $ExceptCtx = ($B.parser.$ExceptCtx = function (C) {
this.type = "except";
this.parent = C;
C.tree[C.tree.length] = this;
this.tree = [];
this.expect = "id";
this.scope = $get_scope(this);
});
$ExceptCtx.prototype.ast = function () {
var ast_obj = new ast.ExceptHandler(
this.tree.length == 1 ? ast_or_obj(this.tree[0]) : undefined,
this.has_alias ? this.tree[0].alias : undefined,
ast_body(this.parent)
);
ast_obj.lineno = $get_node(this).line_num;
return ast_obj;
};
$ExceptCtx.prototype.toString = function () {
return "(except) ";
};
$ExceptCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case "not":
case "lambda":
if (C.expect == "id") {
C.expect = "as";
return $transition(new $AbstractExprCtx(C, false), token, value);
}
case "as":
if (C.expect == "as" && C.has_alias === undefined) {
C.expect = "alias";
C.has_alias = true;
return C;
}
case "id":
if (C.expect == "alias") {
C.expect = ":";
C.set_alias(value);
return C;
}
break;
case ":":
var _ce = C.expect;
if (_ce == "id" || _ce == "as" || _ce == ":") {
return $BodyCtx(C);
}
break;
case "(":
if (C.expect == "id" && C.tree.length == 0) {
C.parenth = true;
return C;
}
break;
case ")":
if (C.expect == "," || C.expect == "as") {
C.expect = "as";
return C;
}
case ",":
if (
C.parenth !== undefined &&
C.has_alias === undefined &&
(C.expect == "as" || C.expect == ",")
) {
C.expect = "id";
return C;
} else if (C.parenth === undefined) {
$_SyntaxError(C, ["multiple exception types must be parenthesized"]);
}
}
console.log("error", C, token);
$_SyntaxError(C, "token " + token + " after " + C.expect);
};
$ExceptCtx.prototype.set_alias = function (alias) {
this.tree[0].alias = $mangle(alias, this);
$bind(alias, this.scope, this);
};
$ExceptCtx.prototype.transform = function (node, rank) {
var linenum_node = $NodeJS("void(0)");
linenum_node.line_num = node.line_num;
node.insert(0, linenum_node);
var last_child = $B.last(node.children);
if (
last_child.C.tree &&
last_child.C.tree[0] &&
last_child.C.tree[0].type == "return"
) {
} else {
node.add($NodeJS("$B.del_exc()"));
}
};
$ExceptCtx.prototype.to_js = function () {
this.js_processed = true;
switch (this.tree.length) {
case 0:
return "else";
case 1:
if (this.tree[0].name == "Exception") {
return "else if(1)";
}
}
var res = [];
for (var elt of this.tree) {
res.push(elt.to_js());
}
var lnum = "";
if ($B.debug > 0) {
var module = $get_module(this);
lnum =
'($locals.$line_info = "' +
$get_node(this).line_num +
"," +
module.id +
'") && ';
}
return (
"else if(" +
lnum +
"$B.is_exc(" +
this.error_name +
",[" +
res.join(",") +
"]))"
);
};
var $ExprCtx = ($B.parser.$ExprCtx = function (C, name, with_commas) {
this.type = "expr";
this.name = name;
this.$pos = $pos;
this.position = C.position;
if ($B.js_from_ast && this.position === undefined) {
console.log("no position", C);
throw Error("...");
}
this.with_commas = with_commas;
this.expect = ",";
this.parent = C;
if (C.packed) {
this.packed = C.packed;
}
this.tree = [];
C.tree[C.tree.length] = this;
});
$ExprCtx.prototype.ast = function () {
var res = ast_or_obj(this.tree[0]);
if (this.packed) {
} else if (this.annotation) {
res = new ast.AnnAssign(
res,
ast_or_obj(this.annotation.tree[0]),
undefined,
1
);
}
set_position(res, this.position);
return res;
};
$ExprCtx.prototype.toString = function () {
return "(expr " + this.with_commas + ") " + this.tree;
};
$ExprCtx.prototype.transition = function (token, value) {
var C = this;
if (
python_keywords.indexOf(token) > -1 &&
["as", "else", "if", "for", "from", "in"].indexOf(token) == -1
) {
C.$pos = $pos;
$_SyntaxError(C, `'${token}' after expression`);
}
switch (token) {
case "bytes":
case "float":
case "id":
case "imaginary":
case "int":
case "lambda":
case "pass":
case "str":
case "JoinedStr":
if (C.parent.type == "dict_or_set" && C.parent.expect == ",") {
$_SyntaxError(C, ["invalid syntax. Perhaps you forgot a comma?"]);
}
$_SyntaxError(C, "token " + token + " after " + C);
break;
case "{":
if (
C.tree[0].type != "id" ||
["print", "exec"].indexOf(C.tree[0].value) == -1
) {
$_SyntaxError(C, "token " + token + " after " + C);
}
return new $DictOrSetCtx(C);
case "[":
case "(":
case ".":
case "not":
if (C.expect == "expr") {
C.expect = ",";
return $transition(new $AbstractExprCtx(C, false), token, value);
}
}
switch (token) {
case "not":
if (C.expect == ",") {
return new $ExprNot(C);
}
break;
case "in":
if (C.parent.type == "target_list") {
return $transition(C.parent, token);
}
if (C.expect == ",") {
return $transition(C, "op", "in");
}
case ",":
if (C.expect == ",") {
if (
C.with_commas ||
["assign", "return"].indexOf(C.parent.type) > -1
) {
if ($parent_match(C, { type: "yield", from: true })) {
$_SyntaxError(C, "no implicit tuple for yield from");
}
C.parent.tree.pop();
var tuple = new $ListOrTupleCtx(C.parent, "tuple");
tuple.implicit = true;
tuple.has_comma = true;
tuple.tree = [C];
C.parent = tuple;
return tuple;
}
}
return $transition(C.parent, token);
case ".":
return new $AttrCtx(C);
case "[":
if (C.tree[0].type == "id") {
delete C.tree[0].bound;
}
return new $AbstractExprCtx(new $SubCtx(C), true);
case "(":
return new $CallCtx(C);
case "op":
var op_parent = C.parent,
op = value;
if (op_parent.type == "ternary" && op_parent.in_else) {
var new_op = new $OpCtx(C, op);
return new $AbstractExprCtx(new_op, false);
}
var op1 = C.parent,
repl = null;
while (1) {
if (op1.type == "unary" && op !== "**") {
repl = op1;
op1 = op1.parent;
} else if (op1.type == "expr") {
op1 = op1.parent;
} else if (
op1.type == "op" &&
$op_weight[op1.op] >= $op_weight[op] &&
!(op1.op == "**" && op == "**")
) {
repl = op1;
op1 = op1.parent;
} else if (op1.type == "not" && $op_weight["not"] > $op_weight[op]) {
repl = op1;
op1 = op1.parent;
} else {
break;
}
}
if (repl === null) {
if (op1.type == "op") {
var right = op1.tree.pop(),
expr = new $ExprCtx(op1, "operand", C.with_commas);
expr.tree.push(right);
right.parent = expr;
var new_op = new $OpCtx(expr, op);
return new $AbstractExprCtx(new_op, false);
}
while (C.parent !== op1) {
C = C.parent;
op_parent = C.parent;
}
C.parent.tree.pop();
var expr = new $ExprCtx(op_parent, "operand", C.with_commas);
expr.expect = ",";
C.parent = expr;
var new_op = new $OpCtx(C, op);
return new $AbstractExprCtx(new_op, false);
} else {
if (op === "and" || op === "or") {
while (
repl.parent.type == "not" ||
(repl.parent.type == "expr" && repl.parent.parent.type == "not")
) {
repl = repl.parent;
op_parent = repl.parent;
}
}
}
if (repl.type == "op") {
var _flag = false;
switch (repl.op) {
case "<":
case "<=":
case "==":
case "!=":
case "is":
case ">=":
case ">":
_flag = true;
}
if (_flag) {
switch (op) {
case "<":
case "<=":
case "==":
case "!=":
case "is":
case ">=":
case ">":
case "in":
case "not_in":
repl.ops = repl.ops || [repl.op];
repl.ops.push(op);
return new $AbstractExprCtx(repl, false);
}
}
}
repl.parent.tree.pop();
var expr = new $ExprCtx(repl.parent, "operand", false);
expr.tree = [op1];
repl.parent = expr;
var new_op = new $OpCtx(repl, op);
return new $AbstractExprCtx(new_op, false);
case "augm_assign":
var parent = C;
while (parent) {
if (parent.type == "assign" || parent.type == "augm_assign") {
$_SyntaxError(C, "augmented assignment inside assignment");
} else if (parent.type == "op") {
$_SyntaxError(C, ["cannot assign to operator"]);
} else if (parent.type == "list_or_tuple") {
$_SyntaxError(C, [
`'${parent.real}' is an illegal` +
" expression for augmented assignment",
]);
} else if (["list", "tuple"].indexOf(parent.name) > -1) {
$_SyntaxError(C, [
`'${parent.name}' is an illegal` +
" expression for augmented assignment",
]);
} else if (["dict_or_set"].indexOf(parent.name) > -1) {
$_SyntaxError(C, [
`'${parent.tree[0].real} display'` +
" is an illegal expression for augmented assignment",
]);
}
parent = parent.parent;
}
if (C.expect == ",") {
return new $AbstractExprCtx(new $AugmentedAssignCtx(C, value), true);
}
return $transition(C.parent, token, value);
case ":":
if (
C.parent.type == "sub" ||
(C.parent.type == "list_or_tuple" && C.parent.parent.type == "sub")
) {
return new $AbstractExprCtx(new $SliceCtx(C.parent), false);
} else if (C.parent.type == "slice") {
return $transition(C.parent, token, value);
} else if (C.parent.type == "node") {
if (C.tree.length == 1) {
var child = C.tree[0];
check_assignment(child);
if (["id", "sub", "attribute"].indexOf(child.type) > -1) {
return new $AbstractExprCtx(new $AnnotationCtx(C), false);
} else if (
child.real == "tuple" &&
child.expect == "," &&
child.tree.length == 1
) {
return new $AbstractExprCtx(
new $AnnotationCtx(child.tree[0]),
false
);
}
}
$_SyntaxError(C, "invalid target for annotation");
}
break;
case "=":
function has_parent(ctx, type) {
while (ctx.parent) {
if (ctx.parent.type == type) {
return ctx.parent;
}
ctx = ctx.parent;
}
return false;
}
var annotation;
if (C.expect == ",") {
if (C.parent.type == "call_arg") {
if (C.tree[0].type != "id") {
$_SyntaxError(C, [
"expression cannot contain" +
' assignment, perhaps you meant "=="?',
]);
}
return new $AbstractExprCtx(new $KwArgCtx(C), true);
} else if ((annotation = has_parent(C, "annotation"))) {
return $transition(annotation, token, value);
} else if (C.parent.type == "op") {
$_SyntaxError(C, ["cannot assign to operator"]);
} else if (C.parent.type == "not") {
$_SyntaxError(C, ["cannot assign to operator"]);
} else if (C.parent.type == "with") {
$_SyntaxError(C, ["expected :"]);
} else if (C.parent.type == "list_or_tuple") {
for (var i = 0; i < C.parent.tree.length; i++) {
var item = C.parent.tree[i];
if (item.type == "expr" && item.name == "operand") {
$_SyntaxError(C, ["cannot assign to operator"]);
}
}
if (
C.parent.real == "list" ||
(C.parent.real == "tuple" && !C.parent.implicit)
) {
$_SyntaxError(C, [
"invalid syntax. " +
"Maybe you meant '==' or ':=' instead of '=' ?",
]);
}
} else if (C.parent.type == "expr" && C.parent.name == "iterator") {
$_SyntaxError(C, ["expected :"]);
} else if (C.parent.type == "lambda") {
if (C.parent.parent.parent.type != "node") {
$_SyntaxError(C, [
"expression cannot contain" +
' assignment, perhaps you meant "=="?',
]);
}
} else if (C.parent.type == "target_list") {
$_SyntaxError(C, "assign to target in iteration");
}
while (C.parent !== undefined) {
C = C.parent;
if (C.type == "condition") {
$_SyntaxError(C, [
"invalid syntax. Maybe you" +
" meant '==' or ':=' instead of '='?",
]);
} else if (C.type == "augm_assign") {
$_SyntaxError(C, "assignment inside augmented assignment");
}
}
C = C.tree[0];
return new $AbstractExprCtx(new $AssignCtx(C), true);
}
break;
case ":=":
var ptype = C.parent.type;
if (["node", "assign", "kwarg", "annotation"].indexOf(ptype) > -1) {
$_SyntaxError(C, ":= invalid, parent " + ptype);
} else if (ptype == "func_arg_id" && C.parent.tree.length > 0) {
$_SyntaxError(C, ":= invalid, parent " + ptype);
} else if (
ptype == "call_arg" &&
C.parent.parent.type == "call" &&
C.parent.parent.parent.type == "lambda"
) {
$_SyntaxError(C, ":= invalid inside function arguments");
}
if (C.tree.length == 1 && C.tree[0].type == "id") {
var scope = $get_scope(C),
name = C.tree[0].value;
if (["None", "True", "False"].indexOf(name) > -1) {
$_SyntaxError(C, [
`cannot use assignment expressions with ${name}`,
]);
} else if (name == "__debug__") {
$_SyntaxError(C, ["cannot assign to __debug__"]);
}
while (scope.comprehension) {
scope = scope.parent_block;
}
C.tree[0].binding_scope = $bind(name, scope, C);
return new $AbstractExprCtx(new NamedExprCtx(C), false);
}
$_SyntaxError(C, "token " + token + " after " + C);
case "if":
var in_comp = false,
ctx = C.parent;
while (ctx) {
if (ctx.comprehension) {
in_comp = true;
break;
} else if (ctx.type == "list_or_tuple") {
break;
} else if (ctx.type == "comp_for") {
break;
} else if (ctx.type == "comp_if") {
in_comp = true;
break;
} else if (ctx.type == "call_arg" || ctx.type == "sub") {
break;
} else if (ctx.type == "expr") {
if (ctx.parent.type == "comp_iterable") {
in_comp = true;
break;
}
}
ctx = ctx.parent;
}
if (in_comp) {
break;
}
var ctx = C;
while (
ctx.parent &&
(ctx.parent.type == "op" ||
ctx.parent.type == "not" ||
ctx.parent.type == "unary" ||
(ctx.parent.type == "expr" && ctx.parent.name == "operand"))
) {
ctx = ctx.parent;
}
return new $AbstractExprCtx(new $TernaryCtx(ctx), true);
case "eol":
if (
C.tree.length == 2 &&
C.tree[0].type == "id" &&
["print", "exec"].indexOf(C.tree[0].value) > -1
) {
$_SyntaxError(C, [
"Missing parentheses in call " + "to '" + C.tree[0].value + "'.",
]);
}
if (
["dict_or_set", "list_or_tuple", "str"].indexOf(C.parent.type) == -1
) {
var t = C.tree[0];
if (t.type == "packed") {
$pos = t.pos;
$_SyntaxError(C, ["can't use starred expression here"]);
} else if (t.type == "call" && t.func.type == "packed") {
$pos = t.func.pos;
$_SyntaxError(C, ["can't use starred expression here"]);
}
}
}
return $transition(C.parent, token);
};
$ExprCtx.prototype.to_js = function (arg) {
var res;
this.js_processed = true;
if (this.type == "list") {
res = "[" + $to_js(this.tree) + "]";
} else if (this.tree.length == 1) {
if (this.tree[0].to_js === undefined) {
console.log("pas de to_js", this);
}
res = this.tree[0].to_js(arg);
} else {
res = "_b_.tuple.$factory([" + $to_js(this.tree) + "])";
}
if (this.is_await) {
res = "await ($B.promise(" + res + "))";
}
if (this.name == "call") {
res += "()";
}
return res;
};
var $ExprNot = ($B.parser.$ExprNot = function (C) {
this.type = "expr_not";
this.parent = C;
this.tree = [];
C.tree[C.tree.length] = this;
});
$ExprNot.prototype.transition = function (token, value) {
var C = this;
if (token == "in") {
C.parent.tree.pop();
var op1 = C.parent;
while (op1.type !== "expr") {
op1 = op1.parent;
}
return op1.transition("op", "not_in");
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$ExprNot.prototype.toString = function () {
return "(expr_not)";
};
var $ForExpr = ($B.parser.$ForExpr = function (C) {
if (C.node && C.node.parent.is_comp) {
C.node.parent.first_for = this;
}
this.type = "for";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree.push(this);
this.loop_num = $loop_num;
this.scope = $get_scope(this);
if (this.scope.is_comp) {
}
this.module = this.scope.module;
$loop_num++;
});
$ForExpr.prototype.ast = function () {
var target = ast_or_obj(this.tree[0]),
iter = ast_or_obj(this.tree[1]),
orelse = this.orelse ? ast_or_obj(this.orelse) : [],
type_comment,
body = ast_body(this.parent);
var klass = this.async ? ast.AsyncFor : ast.For;
var res = new klass(target, iter, body, orelse, type_comment);
set_position(res, this.position);
return res;
};
$ForExpr.prototype.toString = function () {
return "(for) " + this.tree;
};
function bind_target(targets, scope, C) {
check_assignment(targets);
if (Array.isArray(targets)) {
for (var target of targets) {
bind_target(target, scope, C);
}
} else if (targets instanceof $ListOrTupleCtx) {
for (var target of targets.tree) {
bind_target(target, scope, C);
}
} else if (targets.type == "expr" && targets.tree[0] instanceof $IdCtx) {
$bind(targets.tree[0].value, scope, C);
}
}
$ForExpr.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "in":
var targets = C.tree[0].tree,
named_expr_ids = {};
if (C.parent.comprehension) {
for (var item of C.parent.tree[0].tree) {
if (item.type == "named_expr" && item.target.type == "id") {
named_expr_ids[item.target.value] = item;
}
}
}
bind_target(targets, this.scope, this);
if (C.tree[0].tree.length == 0) {
$_SyntaxError(C, "missing target between 'for' and 'in'");
}
return new $AbstractExprCtx(new $ExprCtx(C, "iterator", true), false);
case ":":
if (C.tree.length < 2 || C.tree[1].tree[0].type == "abstract_expr") {
$_SyntaxError(C, "token " + token + " after " + C);
}
return $BodyCtx(C);
}
if (this.parent.comprehension) {
switch (token) {
case "]":
if (this.parent.type == "listcomp") {
return $transition(this.parent, token, value);
}
break;
case ")":
if (this.parent.type == "genexpr") {
return $transition(this.parent, token, value);
}
break;
case "}":
if (this.parent.type == "dictcomp" || this.parent.type == "setcomp") {
return $transition(this.parent, token, value);
}
break;
case "for":
return new $TargetListCtx(new $ForExpr(this.parent));
case "if":
var if_ctx = new $ConditionCtx(this.parent, "if");
if_ctx.in_comp = true;
return new $AbstractExprCtx(if_ctx, false);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
function tg_to_js(target, iterable, unpack) {
if (target.type == "simple") {
var item = target.item;
var assign,
assign_to = unpack
? target.starred
? `${iterable}.read_rest()`
: `${iterable}.read_one()`
: target.starred
? `$B.read_rest(${iterable})`
: iterable;
switch (item.type) {
case "id":
assign = `${item.to_js()} = ${assign_to}`;
break;
case "sub":
assign =
"$B.$setitem(" +
item.value.to_js() +
", " +
item.tree[0].to_js() +
", " +
assign_to +
")";
break;
case "attribute":
assign =
"$B.$setattr(" +
item.value.to_js() +
', "' +
item.name +
'", ' +
assign_to +
")";
break;
case "packed":
assign =
item.tree[0].to_js() +
(unpacked
? " = $next_${id}.read_rest()"
: " = $B.rest_iter($next_${id})");
break;
default:
console.log("-- unexpected target type", item.type, item);
break;
}
if (assign) {
return assign + "\n";
}
} else {
var new_id = $B.UUID(),
nb_targets = target.items.length,
has_starred = false,
nb_after_starred;
for (var i = 0, len = target.items.length; i < len; i++) {
if (target.items[i].starred) {
has_starred = true;
nb_after_starred = len - i - 1;
break;
}
}
var nxt = unpack ? `${iterable}.read_one()` : iterable;
var js =
`try{\n var $next_${new_id} = $B.unpacker(${nxt}, ` +
`${nb_targets}, ${has_starred}, ${nb_after_starred})\n}` +
`catch(err){\n console.log("erreur");$B.leave_frame($locals); throw err\n}\n`;
for (var item of target.items) {
js += tg_to_js(item, `$next_${new_id}`, true);
}
}
return js + "\n";
}
function make_target(target) {
if (target.type == "expr") {
return make_target(target.tree[0]);
} else if (target.tree === undefined || target.tree.length == 0) {
var res = { type: "simple", item: target };
} else if (target.tree.length > 1 || target.implicit_tuple) {
var res = { type: "tuple", items: target.tree.map(make_target) };
} else if (target.tree[0].type == "list_or_tuple") {
var res = { type: "tuple", items: target.tree[0].tree.map(make_target) };
} else {
var item = target.tree[0];
if (item.type == "expr") {
item = item.tree[0];
}
var res = { type: "simple", item };
if (target.packed) {
res = make_target(target.tree[0]);
res.starred = true;
} else if (target.tree[0].type == "packed") {
res = make_target(target.tree[0].tree[0]);
res.starred = true;
}
}
return res;
}
$ForExpr.prototype.to_js = function (indent) {
this.js_processed = true;
var node = $get_node(this),
indent = indent || node.get_indent(),
targets = this.tree[0].tree,
iterable = this.tree[1],
id = $B.UUID();
if (node.module === undefined) {
var module_id = $get_module(this).module;
} else {
var module_id = node.module;
}
module_id = module_id.replace(/\./g, "_");
var target = make_target(this.tree[0]);
var assignment = tg_to_js(target, `$next_${id}`);
var it = this.iterable_is_outermost ? "expr" : iterable.to_js(),
iteration = this.comp_body
? ""
: `var $no_break${this.loop_num} = true\n`;
if (this.async) {
iteration +=
`var $iter_${id} = ${it}\n` +
`var $type_${id} = _b_.type.$factory($iter_${id})\n` +
`$iter_${id} = $B.$call($B.$getattr($type_${id}, "__aiter__"))($iter_${id})\n` +
`var $next_func_${id} = $B.$call(` +
`$B.$getattr($type_${id}, '__anext__'))\n` +
`while(true){\n` +
` try{\n` +
` var $next_${id} = await $B.promise($next_func_${id}($iter_${id}))\n` +
` }catch(err){\n` +
` if($B.is_exc(err, [_b_.StopAsyncIteration])){\nbreak}\n` +
` else{\nthrow err}\n` +
` }\n`;
} else {
iteration +=
`var $next_func_${id} = $B.next_of(${it})\n` +
`while(true){\n` +
` try{\n` +
` var $next_${id} = $next_func_${id}()\n` +
` }catch(err){\n` +
` if($B.is_exc(err, [_b_.StopIteration])){\nbreak}\n` +
` else{\n$B.leave_frame({$locals, value: _b_.None});throw err}\n` +
` }\n`;
}
var body = "";
if (!this.comp_body) {
for (var child of node.children) {
body += "\n" + child.to_js();
}
body +=
`;$locals.$line_info = "${node.line_num},${module_id}";` +
"if($locals.$f_trace !== _b_.None){$B.trace_line()};_b_.None;";
body += "\n}\n";
node.children = [];
}
return (iteration + assignment + body)
.split("\n")
.map((x) => " ".repeat(indent) + x)
.join("\n");
};
var $FromCtx = ($B.parser.$FromCtx = function (C) {
this.type = "from";
this.parent = C;
this.module = "";
this.names = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.expect = "module";
this.scope = $get_scope(this);
});
$FromCtx.prototype.ast = function () {
var module = this.module,
level = 0;
while (module.length > 0 && module.startsWith(".")) {
level++;
module = module.substr(1);
}
var res = { module: module || undefined, names: [], level };
for (var name of this.names) {
if (Array.isArray(name)) {
res.names.push(new ast.alias(name[0], name[1]));
} else {
res.names.push(new ast.alias(name));
}
}
var ast_obj = new ast.ImportFrom(res.module, res.names, res.level);
set_position(ast_obj, this.position);
return ast_obj;
};
$FromCtx.prototype.add_name = function (name) {
this.names[this.names.length] = name;
if (name == "*") {
this.scope.blurred = true;
}
};
$FromCtx.prototype.bind_names = function () {
var scope = $get_scope(this);
for (var name of this.names) {
if (Array.isArray(name)) {
name = name[1];
}
$bind(name, scope, this);
}
};
$FromCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "module") {
C.module += value;
return C;
} else if (C.expect == "id") {
C.add_name(value);
C.expect = ",";
return C;
} else if (C.expect == "alias") {
C.names[C.names.length - 1] = [$B.last(C.names), value];
C.expect = ",";
return C;
}
break;
case ".":
if (C.expect == "module") {
if (token == "id") {
C.module += value;
} else {
C.module += ".";
}
return C;
}
break;
case "ellipsis":
if (C.expect == "module") {
C.module += "...";
return C;
}
break;
case "import":
if (C.names.length > 0) {
$_SyntaxError(C, ["only one 'import' allowed after 'from'"]);
}
if (C.expect == "module") {
C.expect = "id";
return C;
}
case "op":
if (value == "*" && C.expect == "id" && C.names.length == 0) {
if ($get_scope(C).ntype !== "module") {
$_SyntaxError(C, ["import * only allowed at module level"]);
}
C.add_name("*");
C.expect = "eol";
return C;
}
case ",":
if (C.expect == ",") {
C.expect = "id";
return C;
}
case "eol":
switch (C.expect) {
case ",":
case "eol":
C.bind_names();
return $transition(C.parent, token);
case "id":
$_SyntaxError(C, [
"trailing comma not allowed without " + "surrounding parentheses",
]);
default:
$_SyntaxError(C, ["invalid syntax"]);
}
case "as":
if (C.expect == "," || C.expect == "eol") {
C.expect = "alias";
return C;
}
case "(":
if (C.expect == "id") {
C.expect = "id";
return C;
}
case ")":
if (C.expect == "," || C.expect == "id") {
C.expect = "eol";
return C;
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$FromCtx.prototype.toString = function () {
return "(from) " + this.module + " (import) " + this.names;
};
$FromCtx.prototype.to_js = function () {
this.js_processed = true;
var scope = $get_scope(this),
module = $get_module(this),
mod = module.module,
res = [],
pos = 0,
indent = $get_node(this).indent,
head = " ".repeat(indent);
if (mod.startsWith("$exec")) {
var frame = $B.last($B.frames_stack)[1];
if (frame.module && frame.module.__name__) {
mod = frame.module.__name__;
}
}
var mod_elts = this.module.split(".");
for (var i = 0; i < mod_elts.length; i++) {
module.imports[mod_elts.slice(0, i + 1).join(".")] = true;
}
var _mod = this.module.replace(/\$/g, ""),
$package,
packages = [];
while (_mod.length > 0) {
if (_mod.charAt(0) == ".") {
if ($package === undefined) {
if ($B.imported[mod] !== undefined) {
$package = $B.imported[mod].__package__;
packages = $package.split(".");
}
} else {
$package = $B.imported[$package].__package__;
packages.pop();
}
if ($package === undefined) {
return (
"throw _b_.SystemError.$factory(\"Parent module '' " +
'not loaded, cannot perform relative import")'
);
} else if ($package === "None") {
console.log("package is None !");
}
_mod = _mod.substr(1);
} else {
break;
}
}
if (_mod) {
packages.push(_mod);
}
this.module = packages.join(".");
var mod_name = this.module.replace(/\$/g, "");
res[pos++] = 'var module = $B.$import("';
res[pos++] = mod_name + '",["';
var names = [];
for (var i = 0, len = this.names.length; i < len; i++) {
if (Array.isArray(this.names[i])) {
names.push(this.names[i][0]);
} else {
names.push(this.names[i]);
}
}
res[pos++] = names.join('","') + '"], {';
var sep = "";
for (var attr in this.aliases) {
res[pos++] = sep + '"' + attr + '": "' + this.aliases[attr] + '"';
sep = ",";
}
res[pos++] = "}, {});";
if (this.names[0] == "*") {
scope.blurred = true;
res[pos++] = "\n" + head + "$B.import_all($locals, module);";
} else {
for (var name of this.names) {
var alias = name;
if (Array.isArray(name)) {
alias = name[1];
name = name[0];
}
module.imports[this.module + "." + name] = true;
res[pos++] =
"\n" +
head +
'$locals["' +
alias +
'"] = $B.$getattr($B.imported["' +
mod_name +
'"], "' +
name +
'");';
}
}
res[pos++] = "\n" + head + "_b_.None;";
return res.join("");
};
var $FuncArgs = ($B.parser.$FuncArgs = function (C) {
this.type = "func_args";
this.parent = C;
this.tree = [];
this.names = [];
C.tree[C.tree.length] = this;
this.expect = "id";
this.has_default = false;
this.has_star_arg = false;
this.has_kw_arg = false;
});
$FuncArgs.prototype.ast = function () {
var args = {
posonlyargs: [],
args: [],
kwonlyargs: [],
kw_defaults: [],
defaults: [],
},
state = "arg",
default_value;
for (var arg of this.tree) {
if (arg.type == "end_positional") {
args.posonlyargs = args.args;
args.args = [];
} else if (arg.type == "func_star_arg") {
state = "kwonly";
if (arg.op == "*" && arg.name != "*") {
args.vararg = new ast.arg(arg.name);
} else if (arg.op == "**") {
args.kwarg = new ast.arg(arg.name);
}
} else {
default_value = false;
if (arg.has_default) {
default_value = ast_or_obj(arg.tree[0]);
}
var argument = new ast.arg(arg.name);
if (arg.annotation) {
argument.annotation = ast_or_obj(arg.annotation.tree[0]);
}
if (state == "kwonly") {
args.kwonlyargs.push(argument);
if (default_value) {
args.kw_defaults.push(default_value);
} else {
args.kw_defaults.push(_b_.None);
}
} else {
args.args.push(argument);
if (default_value) {
args.defaults.push(default_value);
}
}
}
}
return new ast.arguments(
args.posonlyargs,
args.args,
args.vararg,
args.kwonlyargs,
args.kw_defaults,
args.kwarg,
args.defaults
);
};
$FuncArgs.prototype.toString = function () {
return "func args " + this.tree;
};
$FuncArgs.prototype.transition = function (token, value) {
var C = this;
function check() {
if (C.tree.length == 0) {
return;
}
var last = $B.last(C.tree);
if (C.has_default && !last.has_default) {
if (last.type == "func_star_arg" || last.type == "end_positional") {
return;
}
if (C.names.indexOf("*") > -1) {
return;
}
$_SyntaxError(C, ["non-default argument follows default argument"]);
}
if (last.has_default) {
C.has_default = true;
}
}
switch (token) {
case "id":
if (C.has_kw_arg) {
$_SyntaxError(C, "duplicate keyword argument");
}
if (C.expect == "id") {
C.expect = ",";
if (C.names.indexOf(value) > -1) {
$_SyntaxError(C, [
"duplicate argument " + value + " in function definition",
]);
}
}
return new $FuncArgIdCtx(C, value);
case ",":
if (C.expect == ",") {
check();
C.expect = "id";
return C;
}
$_SyntaxError(C, "token " + token + " after " + C);
case ")":
check();
var last = $B.last(C.tree);
if (last && last.type == "func_star_arg") {
if (last.name == "*") {
if (C.op == "*") {
$_SyntaxError(C, ["named arguments must follow bare *"]);
} else {
$_SyntaxError(C, "invalid syntax");
}
}
}
return $transition(C.parent, token, value);
case "op":
if (C.has_kw_arg) {
$_SyntaxError(C, "duplicate keyword argument");
}
var op = value;
C.expect = ",";
if (op == "*") {
if (C.has_star_arg) {
$_SyntaxError(C, "duplicate star argument");
}
return new $FuncStarArgCtx(C, "*");
} else if (op == "**") {
return new $FuncStarArgCtx(C, "**");
} else if (op == "/") {
if (C.has_end_positional) {
$_SyntaxError(C, ["duplicate / in function parameters"]);
} else if (C.has_star_arg) {
$_SyntaxError(C, ["/ after * in function parameters"]);
}
return new $EndOfPositionalCtx(C);
}
$_SyntaxError(C, "token " + op + " after " + C);
case ":":
if (C.parent.type == "lambda") {
return $transition(C.parent, token);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$FuncArgs.prototype.to_js = function () {
this.js_processed = true;
return $to_js(this.tree);
};
var $FuncArgIdCtx = ($B.parser.$FuncArgIdCtx = function (C, name) {
this.type = "func_arg_id";
if (["None", "True", "False"].indexOf(name) > -1) {
$_SyntaxError(C, "invalid name");
}
this.name = name;
this.parent = C;
this.position = $token.value;
if (C.has_star_arg) {
C.parent.after_star.push(name);
} else {
C.parent.positional_list.push(name);
}
if (C.parent.type != "lambda") {
var node = $get_node(this);
if (node.binding.hasOwnProperty(name)) {
$_SyntaxError(C, [
"duplicate argument '" + name + "' in function definition",
]);
}
$bind(name, node, this);
}
this.tree = [];
C.tree[C.tree.length] = this;
var ctx = C;
while (ctx.parent !== undefined) {
if (ctx.type == "def") {
ctx.locals.push(name);
break;
}
ctx = ctx.parent;
}
this.expect = "=";
});
$FuncArgIdCtx.prototype.toString = function () {
return "func arg id " + this.name + "=" + this.tree;
};
$FuncArgIdCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "=":
if (C.expect == "=") {
C.has_default = true;
var def_ctx = C.parent.parent;
if (C.parent.has_star_arg) {
def_ctx.default_list.push(def_ctx.after_star.pop());
} else {
def_ctx.default_list.push(def_ctx.positional_list.pop());
}
return new $AbstractExprCtx(C, false);
}
break;
case ",":
case ")":
if (
C.parent.has_default &&
C.tree.length == 0 &&
C.parent.has_star_arg === undefined
) {
$pos -= C.name.length;
$_SyntaxError(C, ["non-default argument follows default argument"]);
} else {
return $transition(C.parent, token);
}
case ":":
if (C.parent.parent.type == "lambda") {
return $transition(C.parent.parent, ":");
}
if (C.has_default) {
$_SyntaxError(C, "token " + token + " after " + C);
}
return new $AbstractExprCtx(new $AnnotationCtx(C), false);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$FuncArgIdCtx.prototype.to_js = function () {
this.js_processed = true;
return this.name + $to_js(this.tree);
};
var $FuncStarArgCtx = ($B.parser.$FuncStarArgCtx = function (C, op) {
this.type = "func_star_arg";
this.op = op;
this.parent = C;
this.node = $get_node(this);
C.has_star_arg = op == "*";
C.has_kw_arg = op == "**";
C.tree[C.tree.length] = this;
});
$FuncStarArgCtx.prototype.toString = function () {
return "(func star arg " + this.op + ") " + this.name;
};
$FuncStarArgCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.name === undefined) {
if (C.parent.names.indexOf(value) > -1) {
$_SyntaxError(C, [
"duplicate argument " + value + " in function definition",
]);
}
}
if (["None", "True", "False"].indexOf(value) > -1) {
$_SyntaxError(C, "invalid name");
}
C.set_name(value);
C.parent.names.push(value);
return C;
case ",":
case ")":
if (C.name === undefined) {
C.set_name("*");
C.parent.names.push("*");
}
return $transition(C.parent, token);
case ":":
if (C.parent.parent.type == "lambda") {
return $transition(C.parent.parent, ":");
}
if (C.name === undefined) {
$_SyntaxError(C, "annotation on an unnamed parameter");
}
return new $AbstractExprCtx(new $AnnotationCtx(C), false);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$FuncStarArgCtx.prototype.set_name = function (name) {
this.name = name;
if (this.parent.parent.type != "lambda") {
if (this.node.binding.hasOwnProperty(name)) {
$_SyntaxError(C, [
"duplicate argument '" + name + "' in function definition",
]);
}
$bind(name, this.node, this);
}
var ctx = this.parent;
while (ctx.parent !== undefined) {
if (ctx.type == "def") {
ctx.locals.push(name);
break;
}
ctx = ctx.parent;
}
if (this.op == "*") {
ctx.other_args = '"' + name + '"';
} else {
ctx.other_kw = '"' + name + '"';
}
};
var GeneratorExpCtx = function (C) {
this.type = "genexpr";
this.tree = [C.tree[0]];
this.tree[0].parent = this;
this.position = C.position;
Comprehension.make_comp(this, C);
};
GeneratorExpCtx.prototype.ast = function () {
var res = new ast.GeneratorExp(
ast_or_obj(this.tree[0]),
Comprehension.generators(this.tree.slice(1))
);
set_position(res, this.position);
return res;
};
GeneratorExpCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ")") {
this.has_await = Comprehension.has_await(this);
if (this.parent.type == "call") {
return this.parent.parent;
}
return this.parent;
}
$_SyntaxError(C, "token " + token + "after gen expr");
};
GeneratorExpCtx.prototype.to_js = function () {
var node = $get_node(this),
indent = node.get_indent();
var id = this.id,
expr = this.tree[0],
first_for = this.tree[1],
outmost_expr = first_for.tree[1].to_js();
first_for.comp_body = true;
first_for.iterable_is_outermost = true;
var module_id = this.module.replace(/\./g, "_");
var js =
`(${this.has_await ? "async " : ""}function(expr){
var $locals_${id} = {},
$locals = $locals_${id}
$locals.$line_info = '${node.line_num},${node.module}'\n` +
Comprehension.code(this) +
`
var $top_frame = ["${id}", $locals_${id}, "${this.module}", $locals_${module_id}]
$locals.$f_trace = $B.enter_frame($top_frame)
` +
`var ${id} = ${this.has_await ? "async " : ""}function*(expr){
var $top_frame = ["${id}", $locals_${id}, "${
this.module
}", $locals_${module_id}]
$locals.$f_trace = $B.enter_frame($top_frame)
`;
js += first_for.to_js(indent);
var nb = -1;
for (var i = 2; i < this.tree.length; i++) {
nb++;
var stmt = this.tree[i];
if (stmt.type == "for") {
stmt.comp_body = true;
js += "\n" + stmt.to_js(indent + nb);
} else if (stmt.type == "condition" && stmt.token == "if") {
js += "\n" + " ".repeat(12 + 4 * nb) + stmt.to_js() + "{";
}
}
var expr_has_await = Comprehension.has_await(expr);
js +=
"\n" +
" ".repeat(16 + 4 * nb) +
(expr_has_await ? "var save_stack = $B.save_stack();\n" : "") +
`try{
var result = ${expr.to_js()}
}catch(err){
` +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "") +
`
$B.leave_frame($locals)
throw err
}
` +
(expr_has_await ? "\n$B.restore_stack(save_stack, $locals);" : "") +
`
try{
$B.leave_frame($locals)
yield result
$B.frames_stack.push($top_frame)
}catch(err1){
$B.frames_stack.push($top_frame)
throw err1
}`;
for (var i = 1; i < this.tree.length; i++) {
js += "\n" + " ".repeat(12 + 4 * nb--) + "}";
}
js += `
$B.leave_frame($locals)
}
$B.leave_frame($locals)
return $B.generator.$factory(${id})(expr)
}
)(${outmost_expr})`;
return js;
};
var $GlobalCtx = ($B.parser.$GlobalCtx = function (C) {
this.type = "global";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.expect = "id";
this.scope = $get_scope(this);
this.scope.globals = this.scope.globals || new Set();
this.module = $get_module(this);
if (this.module.module !== "<module>") {
while (this.module.module != this.module.id) {
this.module = this.module.parent_block;
}
}
this.module.binding = this.module.binding || {};
this.$pos = $pos;
});
$GlobalCtx.prototype.ast = function () {
var ast_obj = new ast.Global(this.tree.map((item) => item.value));
set_position(ast_obj, this.position);
return ast_obj;
};
$GlobalCtx.prototype.toString = function () {
return "global " + this.tree;
};
function check_global_nonlocal(C, value, type) {
var scope = C.scope;
if (type == "nonlocal" && scope.globals && scope.globals.has(value)) {
$_SyntaxError(C, [`name '${value}' is nonlocal and global`]);
}
if (type == "global" && scope.nonlocals && scope.nonlocals.has(value)) {
$_SyntaxError(C, [`name '${value}' is nonlocal and global`]);
}
if (["def", "generator"].indexOf(scope.ntype) > -1) {
var params = scope.C.tree[0];
if (params.locals && params.locals.indexOf(value) > -1) {
$_SyntaxError(C, [`name '${value}' is parameter and ${type}`]);
}
if (scope.binding[value]) {
console.log("scope ntype", scope);
$_SyntaxError(C, [
`name '${value}' is assigned to before ${type} declaration`,
]);
}
if (scope.referenced && scope.referenced[value]) {
$_SyntaxError(C, [
`name '${value}' is used prior to ${type} declaration`,
]);
}
}
}
$GlobalCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
check_global_nonlocal(C, value, "global");
new $IdCtx(C, value);
C.add(value);
C.expect = ",";
return C;
}
break;
case ",":
if (C.expect == ",") {
C.expect = "id";
return C;
}
break;
case "eol":
if (C.expect == ",") {
return $transition(C.parent, token);
}
break;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$GlobalCtx.prototype.add = function (name) {
if (this.scope.annotations && this.scope.annotations.has(name)) {
$_SyntaxError(this, ["annotated name '" + name + "' can't be global"]);
}
if (this.scope.type == "module") {
return;
}
if (this.scope.binding && this.scope.binding[name]) {
console.log("error globals, scope", this.scope);
$pos = this.$pos - 1;
$_SyntaxError(this, [`name '${name}' is parameter and global`]);
}
this.scope.globals.add(name);
var mod = this.scope.parent_block;
if (this.module.module.startsWith("$exec")) {
while (mod && mod.parent_block !== this.module) {
mod._globals = mod._globals || new Map();
mod._globals.set(name, this.module.id);
delete mod.binding[name];
mod = mod.parent_block;
}
}
this.module.binding[name] = true;
};
$GlobalCtx.prototype.to_js = function () {
this.js_processed = true;
return "";
};
var $IdCtx = ($B.parser.$IdCtx = function (C, value) {
this.type = "id";
this.value = value;
this.parent = C;
this.tree = [];
C.tree[C.tree.length] = this;
this.position = $token.value;
var scope = (this.scope = $get_scope(this));
this.blurred_scope = this.scope.blurred;
this.env = clone(this.scope.binding);
if (["def", "generator"].indexOf(scope.ntype) > -1) {
if (!(C instanceof $GlobalCtx) && !(C instanceof $NonlocalCtx)) {
scope.referenced = scope.referenced || {};
if (!$B.builtins[this.value]) {
scope.referenced[this.value] = true;
}
}
}
if (C.parent.type == "call_arg") {
this.call_arg = true;
}
var ctx = C;
while (ctx.parent !== undefined) {
switch (ctx.type) {
case "ctx_manager_alias":
$bind(value, scope, this);
break;
case "list_or_tuple":
case "dict_or_set":
case "call_arg":
case "def":
case "lambda":
if (ctx.vars === undefined) {
ctx.vars = [value];
} else if (ctx.vars.indexOf(value) == -1) {
ctx.vars.push(value);
}
if (this.call_arg && ctx.type == "lambda") {
if (ctx.locals === undefined) {
ctx.locals = [value];
} else {
ctx.locals.push(value);
}
}
}
ctx = ctx.parent;
}
var target_list = $parent_match(C, { type: "target_list" });
if (target_list) {
this.no_bindings = true;
this.bound = true;
}
if (["def", "generator"].indexOf(scope.ntype) > -1) {
var _ctx = this.parent;
while (_ctx) {
if (_ctx.comprehension) {
this.in_comp = true;
break;
}
_ctx = _ctx.parent;
}
if (C.type == "expr" && C.parent.type == "comp_if") {
} else if (C.type == "global") {
if (scope.globals === undefined) {
scope.globals = new Set([value]);
} else {
scope.globals.add(value);
}
}
}
});
$IdCtx.prototype.ast = function () {
var ast_obj;
if (["True", "False", "None"].indexOf(this.value) > -1) {
ast_obj = new ast.Constant(_b_[this.value]);
} else {
ast_obj = new ast.Name(
this.value,
this.bound ? new ast.Store() : new ast.Load()
);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$IdCtx.prototype.toString = function () {
return "(id) " + this.value + ":" + (this.tree || "");
};
$IdCtx.prototype.transition = function (token, value) {
var C = this;
if (C.value == "case" && C.parent.parent.type == "node") {
var start = C.parent.$pos,
src = $get_module(this).src;
try {
var flag = line_ends_with_comma(src.substr(start));
} catch (err) {
$pos = start + err.offset;
$_SyntaxError(C, [err.message]);
}
if (flag) {
var node = $get_node(C),
parent = node.parent;
if (!node.parent || !node.parent.is_match) {
$_SyntaxError(C, '"case" not inside "match"');
} else {
if (node.parent.irrefutable) {
var name = node.parent.irrefutable,
msg = name == "_" ? "wildcard" : `name capture '${name}'`;
$_SyntaxError(C, [`${msg} makes remaining patterns unreachable`]);
}
}
return $transition(
new $PatternCtx(new $CaseCtx(C.parent.parent)),
token,
value
);
}
} else if (C.value == "match" && C.parent.parent.type == "node") {
var start = C.parent.$pos,
src = $get_module(this).src,
flag = line_ends_with_comma(src.substr(start));
if (flag) {
return $transition(
new $AbstractExprCtx(new $MatchCtx(C.parent.parent), true),
token,
value
);
}
}
switch (token) {
case "=":
if (
C.parent.type == "expr" &&
C.parent.parent !== undefined &&
C.parent.parent.type == "call_arg"
) {
return new $AbstractExprCtx(new $KwArgCtx(C.parent), false);
}
return $transition(C.parent, token, value);
case ".":
delete this.bound;
return $transition(C.parent, token, value);
case "op":
return $transition(C.parent, token, value);
case "id":
case "str":
case "JoinedStr":
case "int":
case "float":
case "imaginary":
if (["print", "exec"].indexOf(C.value) > -1) {
$_SyntaxError(C, [
"missing parenthesis in call to '" + C.value + "'",
]);
}
$_SyntaxError(C, "token " + token + " after " + C);
}
if (this.parent.parent.type == "packed") {
if ([".", "[", "("].indexOf(token) == -1) {
return this.parent.parent.transition(token, value);
}
}
return $transition(C.parent, token, value);
};
$IdCtx.prototype.firstBindingScopeId = function () {
var scope = this.scope,
found = [],
nb = 0;
while (scope) {
if (scope.globals && scope.globals.has(this.value)) {
return $get_module(this).id;
}
if (scope.binding && scope.binding[this.value]) {
return scope.id;
}
scope = scope.parent;
}
};
$IdCtx.prototype.boundBefore = function (scope) {
function test(node, name) {
if (node.bindings && node.bindings[name]) {
var ctx = node.C.tree[0];
if (
["def", "generator"].indexOf(ctx.type) > -1 &&
ctx.locals.indexOf(name) > -1
) {
return false;
}
return true;
}
}
var node = $get_node(this),
found = false;
var $test = false;
if ($test) {
console.log(this.value, "bound before");
console.log("node", node);
console.log("scope", scope);
}
if (
(scope.ntype == "def" || scope.ntype == "generator") &&
scope.C.tree[0].args.indexOf(this.value) > -1
) {
return true;
}
while (!found && node.parent) {
var pnode = node.parent;
if (test(pnode, this.value)) {
if ($test) {
console.log("bound in", pnode);
}
return pnode.bindings[this.value];
}
for (var i = 0; i < pnode.children.length; i++) {
var child = pnode.children[i];
if (child === node) {
break;
}
if (test(child, this.value)) {
if ($test) {
console.log("bound in child", child);
}
return child.bindings[this.value];
}
}
if (pnode === scope) {
break;
}
node = pnode;
}
return found;
};
$IdCtx.prototype.bindingType = function (scope) {
var nb = 0,
node = $get_node(this),
found = false,
unknown,
ix;
while (!found && node.parent && nb++ < 100) {
var pnode = node.parent;
if (pnode.bindings && pnode.bindings[this.value]) {
return pnode.bindings[this.value];
}
for (var i = 0; i < pnode.children.length; i++) {
var child = pnode.children[i];
if (child === node) {
break;
}
if (child.bindings && child.bindings[this.value]) {
found = child.bindings[this.value];
ix = i;
}
}
if (found) {
for (var j = ix + 1; j < pnode.children.length; j++) {
child = pnode.children[j];
if (child.children.length > 0) {
unknown = true;
break;
} else if (child === node) {
break;
}
}
return found || unknown;
}
if (pnode === scope) {
break;
}
node = pnode;
}
return found;
};
$IdCtx.prototype.to_js = function (arg) {
var innermost = $get_scope(this),
scope = innermost,
found = [];
if (this.result !== undefined && scope.ntype == "generator") {
return this.result;
}
var val = $mangle(this.value, this);
var $test = false;
if ($test) {
console.log(
"ENTER IdCtx.py2js line",
$get_node(this).line_num,
"\nthis",
this,
"\nscope",
scope
);
}
if (val == "__BRYTHON__" || val == "$B") {
return val;
}
if (val.startsWith("comp_result_" + $B.lambda_magic)) {
if (this.bound) {
return "var " + val;
}
return val;
}
this.js_processed = true;
if (scope._globals && scope._globals.has(val)) {
this.global_module = scope._globals.get(val);
}
if (this.global_module) {
if (this.bound) {
return (
"$locals_" +
this.global_module.replace(/\./g, "_") +
'["' +
val +
'"]'
);
} else {
return (
'$B.$check_def_global("' +
val +
'", $locals_' +
this.global_module.replace(/\./g, "_") +
")"
);
}
}
var is_local = scope.binding[val] !== undefined,
this_node = $get_node(this),
bound_before = scope.comprehension ? [] : this_node.bound_before;
if ($test) {
console.log(
"scope",
this.scope,
"\nbound before",
bound_before,
"\nthis",
this
);
}
this.nonlocal = scope.nonlocals && scope.nonlocals.has(val);
this.unbound =
this.unbound ||
(is_local &&
!this.bound &&
bound_before &&
bound_before.indexOf(val) == -1);
if (
!this.bound &&
scope.C &&
scope.ntype == "class" &&
scope.C.tree[0].name == val
) {
return '$B.$search("' + val + '")';
}
if (this.unbound && !this.nonlocal) {
if (
scope.ntype == "def" ||
scope.ntype == "generator" ||
scope.comprehension
) {
return `$B.$local_search('${val}')`;
} else {
return '$B.$search("' + val + '")';
}
}
if ($test) {
console.log("innermost", innermost);
}
var search_ids = ['"' + innermost.id + '"'];
var gs = innermost;
while (true) {
if ($test) {
console.log(val, gs.id, gs, search_ids);
alert();
}
if (gs.parent_block) {
if (gs.parent_block == $B.builtins_scope) {
break;
} else if (gs.parent_block.id === undefined) {
break;
}
gs = gs.parent_block;
}
if (innermost.ntype != "class" || gs.parent_block === $B.builtins_scope) {
search_ids.push('"' + gs.id + '"');
}
}
search_ids = "[" + search_ids.join(", ") + "]";
if (innermost.globals && innermost.globals.has(val)) {
search_ids = ['"' + gs.id + '"'];
innermost = gs;
}
if ($test) {
console.log("search ids", search_ids);
}
if (this.nonlocal || this.bound) {
var bscope = this.firstBindingScopeId();
if ($test) {
console.log("binding", bscope);
}
if (bscope !== undefined) {
return "$locals_" + bscope.replace(/\./g, "_") + '["' + val + '"]';
} else if (this.bound) {
return (
"$locals_" + innermost.id.replace(/\./g, "_") + '["' + val + '"]'
);
}
}
var global_ns = "$locals_" + gs.id.replace(/\./g, "_");
while (1) {
if (scope.globals !== undefined && scope.globals.has(val)) {
if ($test) {
console.log("in globals of", scope.id, "globals", gs);
}
if (this.boundBefore(gs)) {
if ($test) {
console.log("bound before in gs", gs, global_ns);
}
return global_ns + '["' + val + '"]';
} else {
if ($test) {
console.log("use global search", this);
}
if (this.augm_assign) {
return global_ns + '["' + val + '"]';
} else {
return (
'$B.$check_def("' + val + '", ' + global_ns + '["' + val + '"])'
);
}
}
}
if ($test) {
console.log(
"scope",
scope.id,
scope,
"\ninnermost",
innermost,
"\nscope is innermost",
scope === innermost,
"\nbound_before",
bound_before,
"\nfound",
found.slice()
);
}
if (scope === innermost) {
if (bound_before && bound_before.length > 0) {
if (bound_before.indexOf(val) > -1) {
if ($test) {
console.log("add innermost because of bound_before", scope);
}
found.push(scope);
} else if (
scope.C &&
scope.C.tree[0].type == "def" &&
scope.C.tree[0].env.indexOf(val) > -1
) {
found.push(scope);
}
} else {
if (scope.binding[val]) {
if ($test) {
console.log(
val,
"in bindings of",
scope.id,
this_node.locals[val]
);
}
if (this_node.locals[val] === undefined) {
if (
!scope.is_comp &&
(!scope.parent_block || !scope.parent_block.is_comp)
) {
found.push(scope);
}
} else {
found.push(scope);
break;
}
if ($test) {
console.log(val, "found in", scope.id);
}
}
}
} else {
if (scope.binding === undefined) {
console.log("scope", scope, val, "no binding", innermost);
}
if (innermost.binding[val] && innermost.ntype == "class") {
if (
scope.binding[val] &&
(!scope.parent_block || scope.parent_block.id == "__builtins__")
) {
found.push(scope);
}
} else if (scope.binding[val]) {
found.push(scope);
}
}
if (scope.parent_block) {
scope = scope.parent_block;
} else {
break;
}
}
this.found = found;
if ($test) {
console.log(val, "found", found || "<undef>");
for (var item of found) {
console.log(item.id);
}
}
if (this.nonlocal && found[0] === innermost) {
found.shift();
}
if (found.length > 0) {
if (found[0].C && found[0] === innermost && val.charAt(0) != "$") {
var locs = this_node.locals || {},
nonlocs = innermost.nonlocals;
try {
if (
locs[val] === undefined &&
!this.augm_assign &&
(innermost.type != "def" || innermost.type != "generator") &&
innermost.ntype != "class" &&
innermost.C.tree[0].args &&
innermost.C.tree[0].args.indexOf(val) == -1 &&
(nonlocs === undefined || nonlocs[val] === undefined)
) {
if ($test) {
console.log(
"$local search",
val,
"found",
found,
"innermost",
innermost,
"this",
this
);
}
this.result = '$B.$local_search("' + val + '")';
return this.result;
}
} catch (err) {
console.log("error", val, innermost);
throw err;
}
}
if (found.length > 1 && found[0].C) {
if (found[0].C.tree[0].type == "class") {
var ns0 = "$locals_" + found[0].id.replace(/\./g, "_"),
ns1 = "$locals_" + found[1].id.replace(/\./g, "_"),
res;
if (bound_before) {
if (bound_before.indexOf(val) > -1) {
this.found = found[0].binding[val];
res = ns0;
} else {
this.found = found[1].binding[val];
res = ns1;
}
this.result = res + '["' + val + '"]';
return this.result;
} else {
this.found = false;
var res = ns0 + '["' + val + '"] !== undefined ? ';
res += ns0 + '["' + val + '"] : ';
this.result = "(" + res + ns1 + '["' + val + '"])';
return this.result;
}
}
}
var scope = found[0];
if ($test) {
console.log(val, "in scope", scope);
}
this.found = scope.binding[val];
var scope_ns = "$locals_" + scope.id.replace(/\./g, "_");
if (scope.C === undefined && !scope.comprehension) {
if ($test) {
console.log("module level", scope.id, scope.module);
}
if (scope.id == "__builtins__") {
if (gs.blurred) {
val = "(" + global_ns + '["' + val + '"] || _b_.' + val + ")";
} else {
val = "_b_." + val;
this.is_builtin = true;
}
} else {
if ($test) {
console.log("name found at module level");
}
if (this.bound || this.augm_assign) {
val = scope_ns + '["' + val + '"]';
} else {
if (scope === innermost && this.env[val] === undefined) {
this.result = '$B.$search("' + val + '")';
return this.result;
} else {
if ($test) {
console.log("boudn before ?", scope, this.boundBefore(scope));
}
if (this.boundBefore(scope)) {
val = scope_ns + '["' + val + '"]';
} else {
if ($test) {
console.log("use check def", scope);
}
val =
'$B.$check_def("' +
val +
'",' +
scope_ns +
'["' +
val +
'"])';
}
}
}
}
} else if (scope === innermost) {
if ($test) {
console.log("scope is innermost", scope.id);
}
if (scope.globals && scope.globals.has(val)) {
val = global_ns + '["' + val + '"]';
} else if (!this.bound && !this.augm_assign) {
if (this.boundBefore(scope)) {
val = '$locals["' + val + '"]';
} else {
val = '$B.$check_def_local("' + val + '",$locals["' + val + '"])';
}
} else {
val = '$locals["' + val + '"]';
}
} else if (!this.augm_assign) {
val =
'$B.$check_def_free("' + val + '",' + scope_ns + '["' + val + '"])';
} else {
val = scope_ns + '["' + val + '"]';
}
this.result = val + $to_js(this.tree, "");
return this.result;
} else {
this.unknown_binding = true;
this.result = '$B.$global_search("' + val + '", ' + search_ids + ")";
return this.result;
}
};
var $ImportCtx = ($B.parser.$ImportCtx = function (C) {
this.type = "import";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.expect = "id";
});
$ImportCtx.prototype.ast = function () {
var names = [];
for (var item of this.tree) {
var alias = new ast.alias(item.name);
if (item.alias != item.name) {
alias.asname = item.alias;
}
names.push(alias);
}
var ast_obj = new ast.Import(names);
set_position(ast_obj, this.position);
return ast_obj;
};
$ImportCtx.prototype.toString = function () {
return "import " + this.tree;
};
$ImportCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
new $ImportedModuleCtx(C, value);
C.expect = ",";
return C;
}
if (C.expect == "qual") {
C.expect = ",";
C.tree[C.tree.length - 1].name += "." + value;
C.tree[C.tree.length - 1].alias += "." + value;
return C;
}
if (C.expect == "alias") {
C.expect = ",";
C.tree[C.tree.length - 1].alias = value;
return C;
}
break;
case ".":
if (C.expect == ",") {
C.expect = "qual";
return C;
}
break;
case ",":
if (C.expect == ",") {
C.expect = "id";
return C;
}
break;
case "as":
if (C.expect == ",") {
C.expect = "alias";
return C;
}
break;
case "eol":
if (C.expect == ",") {
C.bind_names();
return $transition(C.parent, token);
}
break;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$ImportCtx.prototype.bind_names = function () {
var scope = $get_scope(this);
for (var item of this.tree) {
if (item.name == item.alias) {
var name = item.name,
parts = name.split("."),
bound = name;
if (parts.length > 1) {
bound = parts[0];
}
} else {
bound = item.alias;
}
$bind(bound, scope, this);
}
};
$ImportCtx.prototype.to_js = function () {
this.js_processed = true;
var scope = $get_scope(this),
res = [],
module = $get_module(this);
for (var item of this.tree) {
var mod_name = item.name,
aliases =
item.name == item.alias
? "{}"
: '{"' + mod_name + '" : "' + item.alias + '"}',
localns = "$locals_" + scope.id.replace(/\./g, "_"),
mod_elts = item.name.split(".");
for (var i = 0; i < mod_elts.length; i++) {
module.imports[mod_elts.slice(0, i + 1).join(".")] = true;
}
var js =
'$B.$import("' +
mod_name +
'", [],' +
aliases +
"," +
localns +
", true);";
res.push(js);
}
return res.join("") + "_b_.None;";
};
var $ImportedModuleCtx = ($B.parser.$ImportedModuleCtx = function (C, name) {
this.type = "imported module";
this.parent = C;
this.name = name;
this.alias = name;
C.tree[C.tree.length] = this;
});
$ImportedModuleCtx.prototype.toString = function () {
return " (imported module) " + this.name;
};
$ImportedModuleCtx.prototype.transition = function (token, value) {
var C = this;
};
$ImportedModuleCtx.prototype.to_js = function () {
this.js_processed = true;
return '"' + this.name + '"';
};
var JoinedStrCtx = ($B.parser.JoinedStrCtx = function (C, values) {
this.type = "JoinedStr";
this.parent = C;
this.tree = [];
this.position = $token.value;
this.scope = $get_scope(C);
var line_num = $get_node(C).line_num;
for (var value of values) {
if (typeof value == "string") {
new $StringCtx(
this,
"'" + value.replace(new RegExp("'", "g"), "\\" + "'") + "'"
);
} else {
if (value.format !== undefined) {
value.format = new JoinedStrCtx(this, value.format);
this.tree.pop();
}
var src = value.expression.trimStart(),
save_pos = $pos,
root = $create_root_node(
src,
this.scope.module,
this.scope.id,
this.scope.parent_block,
line_num
);
root.binding = $B.clone(this.scope.binding);
try {
dispatch_tokens(root);
} catch (err) {
err.args[1][1] += line_num - 1;
var line_start = save_pos,
source = $get_module(this).src;
while (line_start-- > 0 && source[line_start] != "\n") {}
err.args[1][2] += value.start + save_pos - line_start;
err.lineno += line_num - 1;
err.args[1][3] = $get_module(this).src.split("\n")[line_num - 1];
throw err;
}
$pos = save_pos;
var expr = root.children[0].C.tree[0];
this.tree.push(expr);
expr.parent = this;
expr.elt = value;
}
}
C.tree.push(this);
this.raw = false;
this.$pos = $pos;
});
JoinedStrCtx.prototype.ast = function () {
var res = { type: "JoinedStr", values: [] };
var state;
for (var item of this.tree) {
if (item instanceof $StringCtx) {
if (state == "string") {
$B.last(res.values).value += eval(item.value);
} else {
var item_ast = new ast.Constant(eval(item.value));
set_position(item_ast, item.position);
res.values.push(item_ast);
}
state = "string";
} else {
var conv_num = { a: 97, r: 114, s: 115 },
format = item.elt.format;
format = format === undefined ? format : ast_or_obj(format);
value = new ast.FormattedValue(
ast_or_obj(item),
conv_num[item.elt.conversion] || -1,
format
);
set_position(value, this.position);
var format = item.format;
if (format !== undefined) {
value.format = item.format.ast();
}
res.values.push(value);
state = "formatted_value";
}
}
var ast_obj = new ast.JoinedStr(res.values);
set_position(ast_obj, this.position);
return ast_obj;
};
JoinedStrCtx.prototype.toString = function () {
return "f-string " + (this.tree || "");
};
JoinedStrCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "[":
return new $AbstractExprCtx(new $SubCtx(C.parent), false);
case "(":
C.parent.tree[0] = C;
return new $CallCtx(C.parent);
case "str":
if (C.tree.length > 0 && typeof $B.last(C.tree) == "string") {
C.tree[C.tree.length - 1] = $B.last(C.tree) + eval(value);
} else {
new $StringCtx(this, value);
}
return C;
case "JoinedStr":
var joined_expr = new JoinedStrCtx(C.parent, value);
C.parent.tree.pop();
if (
C.tree.length > 0 &&
$B.last(C.tree) instanceof $StringCtx &&
joined_expr.tree[0] instanceof $StringCtx
) {
$B.last(C.tree).value += " + " + joined_expr.tree[0].value;
C.tree = C.tree.concat(joined_expr.tree.slice(1));
} else {
C.tree = C.tree.concat(joined_expr.tree);
}
return C;
}
return $transition(C.parent, token, value);
};
JoinedStrCtx.prototype.to_js = function () {
this.js_processed = true;
var res = "",
elts = [];
for (var value of this.tree) {
if (value instanceof $StringCtx) {
elts.push(value.to_js());
} else {
var elt = value.elt,
js = value.to_js();
var pos = 0,
br_stack = [];
switch (elt.conversion) {
case "a":
js = "_b_.ascii(" + js + ")";
break;
case "r":
js = "_b_.repr(" + js + ")";
break;
case "s":
js = "_b_.str.$factory(" + js + ")";
break;
}
var fmt = elt.format;
if (fmt !== undefined) {
js = "_b_.str.format('{0:' + " + fmt.to_js() + " + '}', " + js + ")";
} else {
if (elt.conversion === null) {
js = "_b_.str.$factory(" + js + ")";
}
}
elts.push(js);
}
}
return "$B.String(" + (elts.join(" + ") || "''") + ")";
};
var $JSCode = ($B.parser.$JSCode = function (js) {
this.js = js;
});
$JSCode.prototype.toString = function () {
return this.js;
};
$JSCode.prototype.transition = function (token, value) {
var C = this;
};
$JSCode.prototype.to_js = function () {
this.js_processed = true;
return this.js;
};
var $KwArgCtx = ($B.parser.$KwArgCtx = function (C) {
this.type = "kwarg";
this.parent = C.parent;
this.position = $token.value;
this.tree = [C.tree[0]];
C.parent.tree.pop();
C.parent.tree.push(this);
C.parent.parent.has_kw = true;
var value = this.tree[0].value;
var ctx = C.parent.parent;
if (ctx.kwargs === undefined) {
ctx.kwargs = [value];
} else if (ctx.kwargs.indexOf(value) == -1) {
ctx.kwargs.push(value);
} else {
$_SyntaxError(C, ["keyword argument repeated"]);
}
});
$KwArgCtx.prototype.toString = function () {
return "kwarg " + this.tree[0] + "=" + this.tree[1];
};
$KwArgCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ",") {
return new $CallArgCtx(C.parent.parent);
}
return $transition(C.parent, token);
};
$KwArgCtx.prototype.to_js = function () {
this.js_processed = true;
var key = this.tree[0].value;
var res = '{$nat:"kw",name:"' + key + '",';
return res + "value:" + $to_js(this.tree.slice(1, this.tree.length)) + "}";
};
var $LambdaCtx = ($B.parser.$LambdaCtx = function (C) {
this.type = "lambda";
this.parent = C;
C.tree[C.tree.length] = this;
this.tree = [];
this.position = $token.value;
this.args_start = $pos + 6;
this.vars = [];
this.locals = [];
this.node = $get_node(this);
this.positional_list = [];
this.default_list = [];
this.other_args = null;
this.other_kw = null;
this.after_star = [];
});
$LambdaCtx.prototype.ast = function () {
var args;
if (this.args.length == 0) {
args = new ast.arguments([], [], undefined, [], [], undefined, []);
} else {
args = this.args[0].ast();
}
var ast_obj = new ast.Lambda(args, ast_or_obj(this.tree[0]));
set_position(ast_obj, this.position);
return ast_obj;
};
$LambdaCtx.prototype.toString = function () {
return "(lambda) " + this.args_start + " " + this.body_start;
};
$LambdaCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ":" && C.args === undefined) {
C.args = C.tree;
C.tree = [];
C.body_start = $pos;
return new $AbstractExprCtx(C, false);
}
if (C.args !== undefined) {
C.body_end = $pos;
return $transition(C.parent, token);
}
if (C.args === undefined && token != "(") {
return $transition(new $FuncArgs(C), token, value);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$LambdaCtx.prototype.to_js = function () {
this.js_processed = true;
var C = this.parent,
node = this.node,
module = $get_module(this),
src = $get_src(C),
args = src.substring(this.args_start, this.body_start),
body = src.substring(this.body_start + 1, this.body_end);
body = body.replace(/\\\n/g, " ");
var scope = $get_scope(this);
var rand = $B.UUID(),
func_name = "lambda_" + $B.lambda_magic + "_" + rand,
py = "def " + func_name + "(" + args + "):\n";
py += " return (" + body + "\n)";
var lambda_name = "lambda" + rand,
module_name = module.id.replace(/\./g, "_");
var root = $B.py2js(py, module_name, lambda_name, scope, node.line_num);
var js = root.to_js();
var params = `$locals_${lambda_name}`,
args = "{}";
if (module.is_comp) {
params += `, $locals_${module.id.replace(/\./g, "_")}`;
args +=
`, typeof $locals_${module.id.replace(/\./g, "_")} ` +
` === "undefined" ? {} : $locals_${module.id.replace(/\./g, "_")}`;
}
js =
`(function(${params}){\n` +
js +
`\nreturn $locals.${func_name}})(${args})`;
$B.clear_ns(lambda_name);
$B.$py_src[lambda_name] = null;
delete $B.$py_src[lambda_name];
return js;
};
var ListCompCtx = function (C) {
this.type = "listcomp";
this.tree = [C.tree[0]];
this.tree[0].parent = this;
this.position = $token.value;
Comprehension.make_comp(this, C);
};
ListCompCtx.prototype.ast = function () {
var res = new ast.ListComp(
ast_or_obj(this.tree[0]),
Comprehension.generators(this.tree.slice(1))
);
set_position(res, this.position);
return res;
};
ListCompCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "]") {
this.has_await = Comprehension.has_await(this);
return this.parent;
}
$_SyntaxError(C, "token " + token + "after list comp");
};
ListCompCtx.prototype.to_js = function () {
var node = $get_node(this),
indent = node.get_indent();
var id = this.id,
expr = this.tree[0],
first_for = this.tree[1],
outmost_expr = first_for.tree[1].to_js();
first_for.comp_body = true;
first_for.iterable_is_outermost = true;
var js =
`(${this.has_await ? "async " : ""}function(expr){` +
Comprehension.admin_infos(this) +
`var $result_${id} = []\n`;
js += first_for.to_js(indent);
var nb = -1;
for (var i = 2; i < this.tree.length; i++) {
nb++;
var stmt = this.tree[i];
if (stmt.type == "for") {
stmt.comp_body = true;
js += "\n" + stmt.to_js(indent + nb);
} else if (stmt.type == "condition" && stmt.token == "if") {
js += "\n" + " ".repeat(12 + 4 * nb) + stmt.to_js() + "{";
}
}
var expr_has_await = Comprehension.has_await(expr);
js +=
"\n" +
" ".repeat(16 + 4 * nb) +
(expr_has_await ? "var save_stack = $B.save_stack();\n" : "") +
`try{\n` +
` $result_${id}.push(${expr.to_js()})\n` +
`}catch(err){\n` +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "") +
`$B.leave_frame($locals); throw err\n}` +
(expr_has_await ? "\n$B.restore_stack(save_stack, $locals);" : "");
for (var i = 1; i < this.tree.length; i++) {
js += "\n" + " ".repeat(12 + 4 * nb--) + "}";
}
js += `\n$B.leave_frame({$locals, value: _b_.None})`;
js += `\nreturn $result_${id}`;
js += `\n}\n)(${outmost_expr})`;
return js;
};
var $ListOrTupleCtx = ($B.parser.$ListOrTupleCtx = function (C, real) {
this.type = "list_or_tuple";
this.start = $pos;
this.real = real;
this.expect = "id";
this.closed = false;
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$ListOrTupleCtx.prototype.ast = function () {
var elts = this.tree.map(ast_or_obj),
ast_obj;
if (this.real == "list") {
ast_obj = new ast.List(elts, new ast.Load());
} else if (this.real == "tuple") {
ast_obj = new ast.Tuple(elts, new ast.Load());
} else {
console.log("list_or_tuple ast, real", this.real);
return this;
}
set_position(ast_obj, this.position);
return ast_obj;
};
$ListOrTupleCtx.prototype.toString = function () {
switch (this.real) {
case "list":
return "(list) [" + this.tree + "]";
default:
return "(tuple) (" + this.tree + ")";
}
};
$ListOrTupleCtx.prototype.transition = function (token, value) {
var C = this;
if (C.closed) {
if (token == "[") {
return new $AbstractExprCtx(new $SubCtx(C.parent), false);
}
if (token == "(") {
return new $CallCtx(C.parent);
}
return $transition(C.parent, token, value);
} else {
if (C.expect == ",") {
switch (C.real) {
case "tuple":
if (token == ")") {
var close = true;
if (C.tree.length == 1) {
var grandparent = C.parent.parent;
grandparent.tree.pop();
grandparent.tree.push(C.tree[0]);
C.tree[0].parent = grandparent;
return C.tree[0];
}
if (
C.packed ||
(C.type == "list_or_tuple" &&
C.tree.length == 1 &&
C.tree[0].type == "expr" &&
C.tree[0].tree[0].type == "packed")
) {
$_SyntaxError(C, ["cannot use starred expression here"]);
}
if (close) {
C.close();
}
if (C.parent.type == "packed") {
return C.parent.parent;
}
return C.parent;
}
break;
case "list":
if (token == "]") {
C.close();
if (C.parent.type == "packed") {
if (C.parent.tree.length > 0) {
return C.parent.tree[0];
} else {
return C.parent.parent;
}
}
return C.parent;
}
break;
}
switch (token) {
case ",":
if (C.real == "tuple") {
C.has_comma = true;
}
C.expect = "id";
return C;
case "for":
if (C.real == "list") {
if (this.tree.length > 1) {
$_SyntaxError(C, [
"did you forget " +
"parentheses around the comprehension target?",
]);
}
return new $TargetListCtx(new $ForExpr(new ListCompCtx(C)));
} else {
return new $TargetListCtx(new $ForExpr(new GeneratorExpCtx(C)));
}
}
return $transition(C.parent, token, value);
} else if (C.expect == "id") {
switch (C.real) {
case "tuple":
if (token == ")") {
C.close();
return C.parent;
}
if (token == "eol" && C.implicit === true) {
C.close();
return $transition(C.parent, token);
}
break;
case "list":
if (token == "]") {
C.close();
return C;
}
break;
}
switch (token) {
case "=":
if (C.real == "tuple" && C.implicit === true) {
C.close();
C.parent.tree.pop();
var expr = new $ExprCtx(C.parent, "tuple", false);
expr.tree = [C];
C.parent = expr;
return $transition(C.parent, token);
}
$_SyntaxError(C, "unexpected = inside list");
break;
case ")":
break;
case "]":
if (C.real == "tuple" && C.implicit === true) {
return $transition(C.parent, token, value);
} else {
break;
}
$_SyntaxError(C, 'unexpected "if" inside list');
case ",":
$_SyntaxError(C, "unexpected comma inside list");
case "str":
case "JoinedStr":
case "int":
case "float":
case "imaginary":
case "ellipsis":
case "lambda":
case "yield":
case "id":
case "(":
case "[":
case "{":
case "await":
case "not":
case ":":
C.expect = ",";
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
case "op":
if ("+-~*".indexOf(value) > -1 || value == "**") {
C.expect = ",";
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
}
$_SyntaxError(C, "unexpected operator: " + value);
default:
$_SyntaxError(C, "token " + token);
}
} else {
return $transition(C.parent, token, value);
}
}
};
$ListOrTupleCtx.prototype.close = function () {
this.closed = true;
this.src = $get_module(this).src;
for (var i = 0, len = this.tree.length; i < len; i++) {
var elt = this.tree[i];
if (
elt.type == "expr" &&
elt.tree[0].type == "list_or_tuple" &&
elt.tree[0].real == "tuple" &&
elt.tree[0].tree.length == 1 &&
elt.tree[0].expect == ","
) {
this.tree[i] = elt.tree[0].tree[0];
this.tree[i].parent = this;
}
}
};
$ListOrTupleCtx.prototype.get_src = function () {
var src = $get_module(this).src;
var scope = $get_scope(this);
if (scope.comments === undefined) {
return src;
}
for (var comment of scope.comments) {
var start = comment[0],
len = comment[1];
src =
src.substr(0, start) +
" ".repeat(len + 1) +
src.substr(start + len + 1);
}
return src;
};
$ListOrTupleCtx.prototype.bind_ids = function (scope) {
for (var item of this.tree) {
if (item.type == "id") {
$bind(item.value, scope, this);
item.bound = true;
} else if (item.type == "expr" && item.tree[0].type == "id") {
$bind(item.tree[0].value, scope, this);
item.tree[0].bound = true;
} else if (item.type == "expr" && item.tree[0].type == "packed") {
var ctx = item.tree[0].tree[0];
if (ctx.type == "expr" && ctx.tree[0].type == "id") {
$bind(ctx.tree[0].value, scope, this);
ctx.tree[0].bound = true;
}
} else if (
item.type == "list_or_tuple" ||
(item.type == "expr" && item.tree[0].type == "list_or_tuple")
) {
if (item.type == "expr") {
item = item.tree[0];
}
item.bind_ids(scope);
}
}
};
$ListOrTupleCtx.prototype.packed_indices = function () {
var ixs = [];
for (var i = 0; i < this.tree.length; i++) {
var t = this.tree[i];
if (t.type == "expr") {
t = t.tree[0];
if (
t.type == "packed" ||
(t.type == "call" && t.func.type == "packed")
) {
ixs.push(i);
}
}
}
return ixs;
};
$ListOrTupleCtx.prototype.unpack = function (packed) {
var js = "",
res;
for (var i = 0; i < this.tree.length; i++) {
if (packed.indexOf(i) > -1) {
res = "_b_.list.$factory(" + this.tree[i].to_js() + ")";
} else {
res = "[" + this.tree[i].to_js() + "]";
}
if (i > 0) {
res = ".concat(" + res + ")";
}
js += res;
}
return js;
};
$ListOrTupleCtx.prototype.to_js = function () {
this.js_processed = true;
var scope = $get_scope(this),
sc = scope,
scope_id = scope.id.replace(/\//g, "_"),
pos = 0;
var root = $get_module(this),
module_name = root.module;
switch (this.real) {
case "list":
var packed = this.packed_indices();
if (packed.length > 0) {
return "$B.$list(" + this.unpack(packed) + ")";
}
return "$B.$list([" + $to_js(this.tree) + "])";
case "tuple":
var packed = this.packed_indices();
if (packed.length > 0) {
return "$B.fast_tuple(" + this.unpack(packed) + ")";
}
if (this.tree.length == 1 && this.has_comma === undefined) {
return this.tree[0].to_js();
}
return "$B.fast_tuple([" + $to_js(this.tree) + "])";
}
};
var $MatchCtx = ($B.parser.$MatchCtx = function (node_ctx) {
this.type = "match";
this.position = $token.value;
node_ctx.tree = [this];
node_ctx.node.is_match = true;
this.parent = node_ctx;
this.tree = [];
this.expect = "as";
});
$MatchCtx.prototype.ast = function () {
var res = new ast.Match(ast_or_obj(this.tree[0]), ast_body(this.parent));
set_position(res, this.position);
res.$line_num = $get_node(this).line_num;
return res;
};
$MatchCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "as":
return new $AbstractExprCtx(new $AliasCtx(C));
case ":":
if (this.tree[0].type == "list_or_tuple") {
remove_abstract_expr(this.tree[0].tree);
}
switch (C.expect) {
case "id":
case "as":
case ":":
return $BodyCtx(C);
}
break;
}
};
$MatchCtx.prototype.to_js = function () {
return "var subject = " + $to_js(this.tree) + ";if(true)";
};
var NamedExprCtx = function (C) {
this.type = "named_expr";
this.position = $token.value;
this.target = C.tree[0];
this.target.scope_ref = this.target.binding_scope.id.replace(/\./g, "_");
C.tree.pop();
C.tree.push(this);
this.parent = C;
this.target.parent = this;
this.tree = [];
this.$pos = $pos;
};
NamedExprCtx.prototype.ast = function () {
var res = new ast.NamedExpr(
ast_or_obj(this.target),
ast_or_obj(this.tree[0])
);
res.target.ctx = new ast.Store();
set_position(res, this.position);
return res;
};
NamedExprCtx.prototype.transition = function (token, value) {
return $transition(this.parent, token, value);
};
NamedExprCtx.prototype.to_js = function () {
return (
`($locals_${this.target.scope_ref}.${this.target.value} ` +
`= ${this.tree[0].to_js()})`
);
};
var $NodeCtx = ($B.parser.$NodeCtx = function (node) {
this.node = node;
node.C = this;
this.tree = [];
this.type = "node";
var scope = null;
var tree_node = node;
while (tree_node.parent && tree_node.parent.type != "module") {
var ntype = tree_node.parent.C.tree[0].type,
_break_flag = false;
switch (ntype) {
case "def":
case "class":
case "generator":
scope = tree_node.parent;
_break_flag = true;
}
if (_break_flag) {
break;
}
tree_node = tree_node.parent;
}
if (scope === null) {
scope = tree_node.parent || tree_node;
}
this.node.locals = clone(scope.binding);
this.scope = scope;
});
$NodeCtx.prototype.toString = function () {
return "node " + this.tree;
};
$NodeCtx.prototype.transition = function (token, value) {
var C = this;
if (this.node.parent && this.node.parent.C) {
var pctx = this.node.parent.C;
if (pctx.tree && pctx.tree.length == 1 && pctx.tree[0].type == "match") {
if (token != "eol" && (token !== "id" || value !== "case")) {
C.$pos = $pos;
$_SyntaxError(C, 'line does not start with "case"');
}
}
}
if (this.tree.length == 0 && this.node.parent) {
var rank = this.node.parent.children.indexOf(this.node);
if (rank > 0) {
var previous = this.node.parent.children[rank - 1];
if (
previous.C.tree[0].type == "try" &&
["except", "finally"].indexOf(token) == -1
) {
$_SyntaxError(C, ["expected 'except' or 'finally' block"]);
}
}
}
switch (token) {
case ",":
if (C.tree && C.tree.length == 0) {
$_SyntaxError(C, "token " + token + " after " + C);
}
var first = C.tree[0];
C.tree = [];
var implicit_tuple = new $ListOrTupleCtx(C);
implicit_tuple.real = "tuple";
implicit_tuple.implicit = 0;
implicit_tuple.tree.push(first);
first.parent = implicit_tuple;
return implicit_tuple;
case "[":
case "(":
case "{":
case ".":
case "bytes":
case "float":
case "id":
case "imaginary":
case "int":
case "str":
case "JoinedStr":
case "not":
case "lambda":
var expr = new $AbstractExprCtx(C, true);
return $transition(expr, token, value);
case "assert":
return new $AbstractExprCtx(new $AssertCtx(C), false, true);
case "async":
return new $AsyncCtx(C);
case "await":
return new $AbstractExprCtx(new $AwaitCtx(C), true);
case "break":
return new $BreakCtx(C);
case "class":
return new $ClassCtx(C);
case "continue":
return new $ContinueCtx(C);
case "__debugger__":
return new $DebuggerCtx(C);
case "def":
return new $DefCtx(C);
case "del":
return new $AbstractExprCtx(new $DelCtx(C), true);
case "elif":
try {
var previous = $previous(C);
} catch (err) {
$_SyntaxError(C, "'elif' does not follow 'if'");
}
if (
["condition"].indexOf(previous.type) == -1 ||
previous.token == "while"
) {
$_SyntaxError(C, "elif after " + previous.type);
}
return new $AbstractExprCtx(new $ConditionCtx(C, token), false);
case "ellipsis":
var expr = new $AbstractExprCtx(C, true);
return $transition(expr, token, value);
case "else":
var previous = $previous(C);
if (["condition", "except", "for"].indexOf(previous.type) == -1) {
$_SyntaxError(C, "else after " + previous.type);
}
return new $SingleKwCtx(C, token);
case "except":
var previous = $previous(C);
if (["try", "except"].indexOf(previous.type) == -1) {
$_SyntaxError(C, "except after " + previous.type);
}
return new $ExceptCtx(C);
case "finally":
var previous = $previous(C);
if (
["try", "except"].indexOf(previous.type) == -1 &&
(previous.type != "single_kw" || previous.token != "else")
) {
$_SyntaxError(C, "finally after " + previous.type);
}
return new $SingleKwCtx(C, token);
case "for":
return new $TargetListCtx(new $ForExpr(C));
case "from":
return new $FromCtx(C);
case "global":
return new $GlobalCtx(C);
case "if":
case "while":
return new $AbstractExprCtx(new $ConditionCtx(C, token), false);
case "import":
return new $ImportCtx(C);
case "lambda":
return new $LambdaCtx(C);
case "nonlocal":
return new $NonlocalCtx(C);
case "op":
switch (value) {
case "*":
var expr = new $AbstractExprCtx(C, true);
return $transition(expr, token, value);
case "+":
case "-":
case "~":
C.position = $token.value;
var expr = new $ExprCtx(C, "unary", true);
return new $AbstractExprCtx(new $UnaryCtx(expr, value), false);
case "@":
return new $DecoratorCtx(C);
}
break;
case "pass":
return new $PassCtx(C);
case "raise":
return new $AbstractExprCtx(new $RaiseCtx(C), true);
case "return":
return new $AbstractExprCtx(new $ReturnCtx(C), true);
case "try":
return new $TryCtx(C);
case "with":
return new $AbstractExprCtx(new $WithCtx(C), false);
case "yield":
return new $AbstractExprCtx(new $YieldCtx(C), true);
case "eol":
if (C.tree.length == 0) {
C.node.parent.children.pop();
return C.node.parent.C;
}
return C;
}
console.log("token", token, value);
$_SyntaxError(C, "token " + token + " after " + C);
};
$NodeCtx.prototype.to_js = function () {
if (this.js !== undefined) {
return this.js;
}
this.js_processed = true;
this.js = "";
if (this.tree[0]) {
var is_not_def = ["def", "generator"].indexOf(this.scope.ntype) == -1;
if (this.tree[0].annotation) {
if (is_not_def) {
if (
this.tree[0].type == "expr" &&
!this.tree[0].$in_parens &&
this.tree[0].tree[0].type == "id"
) {
var js = "";
if (this.create_annotations) {
js += "$locals.__annotations__ = $B.empty_dict();";
}
return (
js +
"_b_.dict.$setitem($locals.__annotations__, '" +
this.tree[0].tree[0].value +
"', " +
this.tree[0].annotation.to_js() +
");"
);
} else if (
this.tree[0].type == "def" ||
this.tree[0].type == "generator"
) {
this.js = this.tree[0].annotation.to_js() + ";";
} else {
this.js = "";
}
} else if (["def", "generator"].indexOf(this.tree[0].type) == -1) {
this.tree = [];
}
} else if (
this.tree[0].type == "assign" &&
!this.tree[0].tree[0].$in_parens &&
this.tree[0].tree[0].annotation
) {
var left = this.tree[0].tree[0],
right = this.tree[0].tree[1];
if (this.create_annotations) {
this.js += "$locals.__annotations__ = $B.empty_dict();";
}
this.js += "var $value = " + right.to_js() + ";";
this.tree[0].tree.splice(1, 1);
new $RawJSCtx(this.tree[0], "$value");
var ann = left.annotation;
if (ann.type == "expr" && ann.tree[0].type == "str") {
ann_string = ann.to_js();
} else {
ann_string = ann.string.trim();
ann_string = `"${ann_string.replace(/"/g, '\\"')}"`;
ann_string = `$B.handle_annotation(${ann_string})`;
}
if (left.tree[0] && left.tree[0].type == "id" && is_not_def) {
this.js +=
"_b_.dict.$setitem($locals.__annotations__, '" +
left.tree[0].value +
"', " +
ann_string +
");";
} else {
this.js += $to_js(this.tree) + ";";
if (is_not_def) {
this.js += ann_string;
}
return this.js;
}
}
}
if (this.node.children.length == 0) {
this.js += $to_js(this.tree) + ";";
} else {
this.js += $to_js(this.tree);
}
return this.js;
};
var $NodeJS = ($B.parser.$NodeJS = function (js) {
var node = new $Node();
new $NodeJSCtx(node, js);
return node;
});
var $NodeJSCtx = ($B.parser.$NodeJSCtx = function (node, js) {
this.node = node;
node.C = this;
this.type = "node_js";
this.tree = [js];
});
$NodeJSCtx.prototype.toString = function () {
return "js " + js;
};
$NodeJSCtx.prototype.to_js = function () {
this.js_processed = true;
return this.tree[0];
};
var $NonlocalCtx = ($B.parser.$NonlocalCtx = function (C) {
this.type = "nonlocal";
this.parent = C;
this.tree = [];
this.position = $token.value;
this.names = {};
C.tree[C.tree.length] = this;
this.expect = "id";
this.scope = $get_scope(this);
this.scope.nonlocals = this.scope.nonlocals || new Set();
if (this.scope.C === undefined) {
$_SyntaxError(C, ["nonlocal declaration not allowed at module level"]);
}
});
$NonlocalCtx.prototype.toString = function () {
return "nonlocal " + this.tree;
};
$NonlocalCtx.prototype.ast = function () {
var ast_obj = new ast.Nonlocal(this.tree.map((item) => item.value));
set_position(ast_obj, this.position);
return ast_obj;
};
$NonlocalCtx.prototype.add = function (name) {
if (this.scope.binding[name] == "arg") {
$_SyntaxError(C, ["name '" + name + "' is parameter and nonlocal"]);
}
this.names[name] = [false, $pos];
this.scope.nonlocals.add(name);
};
$NonlocalCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
check_global_nonlocal(C, value, "nonlocal");
new $IdCtx(C, value);
C.add(value);
C.expect = ",";
return C;
}
break;
case ",":
if (C.expect == ",") {
C.expect = "id";
return C;
}
break;
case "eol":
if (C.expect == ",") {
return $transition(C.parent, token);
}
break;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$NonlocalCtx.prototype.transform = function (node, rank) {
var C = this.parent,
pscope = this.scope.parent_block;
if (pscope.C === undefined) {
$_SyntaxError(C, [
"no binding for nonlocal '" +
$B.last(Object.keys(this.names)) +
"' found",
]);
} else {
while (pscope !== undefined && pscope.C !== undefined) {
for (var name in this.names) {
if (pscope.binding[name] !== undefined) {
this.names[name] = [true];
}
}
pscope = pscope.parent_block;
}
for (var name in this.names) {
if (!this.names[name][0]) {
console.log("nonlocal error, C " + C);
$pos = this.names[name][1];
$_SyntaxError(C, ["no binding for nonlocal '" + name + "' found"]);
}
}
}
};
$NonlocalCtx.prototype.to_js = function () {
this.js_processed = true;
return "";
};
var $NotCtx = ($B.parser.$NotCtx = function (C) {
this.type = "not";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$NotCtx.prototype.ast = function () {
var ast_obj = new ast.UnaryOp(new ast.Not(), ast_or_obj(this.tree[0]));
set_position(ast_obj, this.position);
return ast_obj;
};
$NotCtx.prototype.toString = function () {
return "not (" + this.tree + ")";
};
$NotCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "in":
C.parent.parent.tree.pop();
return new $ExprCtx(new $OpCtx(C.parent, "not_in"), "op", false);
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
case "op":
var a = value;
if ("+" == a || "-" == a || "~" == a) {
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
}
}
return $transition(C.parent, token);
};
$NotCtx.prototype.to_js = function () {
this.js_processed = true;
return "!$B.$bool(" + $to_js(this.tree) + ")";
};
var $NumberCtx = ($B.parser.$NumberCtx = function (type, C, value) {
this.type = type;
this.value = value;
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$NumberCtx.prototype.ast = function () {
var ast_obj = new ast.Constant({ type: this.type, value: this.value });
set_position(ast_obj, this.position);
return ast_obj;
};
$NumberCtx.prototype.toString = function () {
return this.type + " " + this.value;
};
$NumberCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "id" && value == "_") {
$_SyntaxError(C, ["invalid decimal literal"]);
}
return $transition(C.parent, token, value);
};
$NumberCtx.prototype.to_js = function () {
this.js_processed = true;
var type = this.type,
value = this.value;
if (type == "int") {
var v = parseInt(value[1], value[0]);
if (v > $B.min_int && v < $B.max_int) {
return v;
} else {
var v = $B.long_int.$factory(value[1], value[0]);
return '$B.fast_long_int("' + v.value + '", ' + v.pos + ")";
}
} else if (type == "float") {
if (/^\d+$/.exec(value) || /^\d+\.\d*$/.exec(value)) {
return "(new Number(" + this.value + "))";
}
return "_b_.float.$factory(" + value + ")";
} else if (type == "imaginary") {
return (
"$B.make_complex(0," + $NumberCtx.prototype.to_js.bind(value)() + ")"
);
}
};
var $OpCtx = ($B.parser.$OpCtx = function (C, op) {
this.type = "op";
this.op = op;
this.parent = C.parent;
this.position = $token.value;
this.tree = [C];
this.scope = $get_scope(this);
if (C.type == "expr") {
if (["int", "float", "str"].indexOf(C.tree[0].type) > -1) {
this.left_type = C.tree[0].type;
} else if (C.tree[0].type == "id") {
var binding = this.scope.binding[C.tree[0].value];
if (binding) {
this.left_type = binding.type;
}
}
}
C.parent.tree.pop();
C.parent.tree.push(this);
});
$OpCtx.prototype.ast = function () {
var ast_type_class = op2ast_class[this.op],
op_type = ast_type_class[0],
ast_class = ast_type_class[1],
ast_obj;
if (op_type === ast.Compare) {
var left = ast_or_obj(this.tree[0]),
ops = [new ast_class()];
if (this.ops) {
for (var op of this.ops.slice(1)) {
ops.push(new op2ast_class[op][1]());
}
ast_obj = new ast.Compare(
left,
ops,
this.tree.slice(1).map(ast_or_obj)
);
} else {
ast_obj = new ast.Compare(left, ops, [ast_or_obj(this.tree[1])]);
}
} else if (op_type === ast.UnaryOp) {
ast_obj = new op_type(new ast_class(), ast_or_obj(this.tree[1]));
} else if (op_type === ast.BoolOp) {
var values = [this.tree[1]],
main_op = this.op,
ctx = this;
while (ctx.tree[0].type == "op" && ctx.tree[0].op == main_op) {
values.splice(0, 0, ctx.tree[0].tree[1]);
ctx = ctx.tree[0];
}
values.splice(0, 0, ctx.tree[0]);
ast_obj = new op_type(new ast_class(), values.map(ast_or_obj));
} else {
ast_obj = new op_type(
ast_or_obj(this.tree[0]),
new ast_class(),
ast_or_obj(this.tree[1])
);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$OpCtx.prototype.toString = function () {
return "(op " + this.op + ") [" + this.tree + "]";
};
$OpCtx.prototype.transition = function (token, value) {
var C = this;
if (C.op === undefined) {
$_SyntaxError(C, ["C op undefined " + C]);
}
switch (token) {
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
return $transition(new $AbstractExprCtx(C, false), token, value);
case "op":
switch (value) {
case "+":
case "-":
case "~":
return new $UnaryCtx(C, value);
}
default:
if (C.tree[C.tree.length - 1].type == "abstract_expr") {
$_SyntaxError(C, "token " + token + " after " + C);
}
}
return $transition(C.parent, token);
};
$OpCtx.prototype.to_js = function () {
this.js_processed = true;
var comps = {
"==": "eq",
"!=": "ne",
">=": "ge",
"<=": "le",
"<": "lt",
">": "gt",
};
if (comps[this.op] !== undefined) {
if (this.ops) {
var i = 0,
tests = [];
for (var op of this.ops) {
var method = comps[op];
tests.push(
`$B.rich_comp('__${method}__', ` +
`${i == 0 ? this.tree[i].to_js() : "$locals.$op"}, ` +
`$locals.$op = ${this.tree[i + 1].to_js()})`
);
i++;
}
return tests.join(" && ");
}
var method = comps[this.op];
if (this.tree[0].type == "expr" && this.tree[1].type == "expr") {
var t0 = this.tree[0].tree[0],
t1 = this.tree[1].tree[0],
js0 = t0.to_js(),
js1 = t1.to_js();
switch (t1.type) {
case "int":
switch (t0.type) {
case "int":
if (
Number.isSafeInteger(t0.value) &&
Number.isSafeInteger(t1.value)
) {
return js0 + this.op + js1;
} else {
return (
"$B.$getattr(" +
this.tree[0].to_js() +
',"__' +
method +
'__")(' +
this.tree[1].to_js() +
")"
);
}
case "str":
switch (this.op) {
case "==":
return "false";
case "!=":
return "true";
default:
return (
'$B.$TypeError("unorderable types: ' +
" int() " +
this.op +
' str()")'
);
}
case "id":
return (
"(typeof " +
js0 +
' == "number" ? ' +
js0 +
this.op +
js1 +
' : $B.rich_comp("__' +
method +
'__",' +
this.tree[0].to_js() +
"," +
this.tree[1].to_js() +
"))"
);
}
break;
case "str":
switch (t0.type) {
case "str":
return js0 + ".valueOf() " + this.op + js1 + ".valueOf()";
case "int":
switch (this.op) {
case "==":
return "false";
case "!=":
return "true";
default:
return (
'$B.$TypeError("unorderable types: ' +
" str() " +
this.op +
' int()")'
);
}
case "id":
return (
"(typeof " +
js0 +
' == "string" ? ' +
js0 +
this.op +
js1 +
' : $B.rich_comp("__' +
method +
'__",' +
this.tree[0].to_js() +
"," +
this.tree[1].to_js() +
"))"
);
}
break;
case "id":
if (t0.type == "id") {
return (
"typeof " +
js0 +
'!="object" && typeof ' +
js0 +
'!="function" && typeof ' +
js0 +
" == typeof " +
js1 +
" ? " +
js0 +
this.op +
js1 +
' : $B.rich_comp("__' +
method +
'__",' +
this.tree[0].to_js() +
"," +
this.tree[1].to_js() +
")"
);
}
break;
}
}
}
switch (this.op) {
case "and":
var op0 = this.tree[0].to_js(),
op1 = this.tree[1].to_js();
if (this.wrap !== undefined) {
return (
"(function(){var " +
this.wrap.name +
" = " +
this.wrap.js +
";return $B.$test_expr($B.$test_item(" +
op0 +
") && $B.$test_item(" +
op1 +
"))})()"
);
} else {
return (
"$B.$test_expr($B.$test_item(" +
op0 +
")&&" +
"$B.$test_item(" +
op1 +
"))"
);
}
case "or":
var res = "$B.$test_expr($B.$test_item(" + this.tree[0].to_js() + ")||";
return res + "$B.$test_item(" + this.tree[1].to_js() + "))";
case "in":
return "$B.$is_member(" + $to_js(this.tree) + ")";
case "not_in":
return "!$B.$is_member(" + $to_js(this.tree) + ")";
case "unary_neg":
case "unary_pos":
case "unary_inv":
var op, method;
if (this.op == "unary_neg") {
op = "-";
method = "__neg__";
} else if (this.op == "unary_pos") {
op = "+";
method = "__pos__";
} else {
op = "~";
method = "__invert__";
}
if (this.tree[1].type == "expr") {
var x = this.tree[1].tree[0];
switch (x.type) {
case "int":
var v = parseInt(x.value[1], x.value[0]);
if (Number.isSafeInteger(v)) {
return op + v;
}
return "$B.$getattr(" + x.to_js() + ', "' + method + '")()';
case "float":
return "_b_.float.$factory(" + op + x.value + ")";
case "imaginary":
return "$B.make_complex(0," + op + x.value + ")";
}
}
return "$B.$getattr(" + this.tree[1].to_js() + ',"' + method + '")()';
case "is":
return (
"$B.$is(" + this.tree[0].to_js() + ", " + this.tree[1].to_js() + ")"
);
case "is_not":
return (
"! $B.$is(" + this.tree[0].to_js() + ", " + this.tree[1].to_js() + ")"
);
case "+":
return (
"$B.add(" + this.tree[0].to_js() + ", " + this.tree[1].to_js() + ")"
);
case "*":
case "-":
var op = this.op,
vars = [],
has_float_lit = false,
scope = $get_scope(this);
function is_simple(elt) {
if (elt.type == "expr" && elt.tree[0].type == "int") {
return true;
} else if (elt.type == "expr" && elt.tree[0].type == "float") {
has_float_lit = true;
return true;
} else if (
elt.type == "expr" &&
elt.tree[0].type == "list_or_tuple" &&
elt.tree[0].real == "tuple" &&
elt.tree[0].tree.length == 1 &&
elt.tree[0].tree[0].type == "expr"
) {
return is_simple(elt.tree[0].tree[0].tree[0]);
} else if (elt.type == "expr" && elt.tree[0].type == "id") {
var _var = elt.tree[0].to_js();
if (vars.indexOf(_var) == -1) {
vars.push(_var);
}
return true;
} else if (elt.type == "op" && ["*", "+", "-"].indexOf(elt.op) > -1) {
for (var i = 0; i < elt.tree.length; i++) {
if (!is_simple(elt.tree[i])) {
return false;
}
}
return true;
}
return false;
}
function get_type(ns, v) {
var t;
if (["int", "float", "str"].indexOf(v.type) > -1) {
t = v.type;
} else if (v.type == "id" && ns[v.value]) {
t = ns[v.value].type;
}
return t;
}
var e0 = this.tree[0],
e1 = this.tree[1];
if (is_simple(this)) {
var v0 = this.tree[0].tree[0],
v1 = this.tree[1].tree[0];
if (vars.length == 0 && !has_float_lit) {
return this.simple_js();
} else if (vars.length == 0) {
return "new Number(" + this.simple_js() + ")";
} else {
var ns = scope.binding,
t0 = get_type(ns, v0),
t1 = get_type(ns, v1);
if (
(t0 == "float" && t1 == "float") ||
(this.op == "+" && t0 == "str" && t1 == "str")
) {
this.result_type = t0;
return v0.to_js() + this.op + v1.to_js();
} else if (
["int", "float"].indexOf(t0) > -1 &&
["int", "float"].indexOf(t1) > -1
) {
if (t0 == "int" && t1 == "int") {
this.result_type = "int";
} else {
this.result_type = "float";
}
switch (this.op) {
case "-":
return "$B.sub(" + v0.to_js() + "," + v1.to_js() + ")";
case "*":
return "$B.mul(" + v0.to_js() + "," + v1.to_js() + ")";
}
}
var tests = [],
tests1 = [],
pos = 0;
for (var _var of vars) {
tests.push(
_var + ".valueOf && typeof " + _var + '.valueOf() == "number"'
);
tests1.push("typeof " + _var + ' == "number"');
}
var res = [tests.join(" && ") + " ? "];
res.push("(" + tests1.join(" && ") + " ? ");
res.push(this.simple_js());
res.push(" : new Number(" + this.simple_js() + ")");
res.push(")");
var t0 = this.tree[0].to_js(),
t1 = this.tree[1].to_js();
if (this.op == "+") {
res.push(
" : (typeof " +
t0 +
' == "string" && typeof ' +
t1 +
' == "string") ? ' +
t0 +
"+" +
t1
);
}
res.push(
`: $B.rich_op("__${$operators[this.op]}__",` + t0 + "," + t1 + ")"
);
return "(" + res.join("") + ")";
}
}
if (comps[this.op] !== undefined) {
return (
'$B.rich_comp("__' +
$operators[this.op] +
'__",' +
e0.to_js() +
"," +
e1.to_js() +
")"
);
} else {
return (
`$B.rich_op("__${$operators[this.op]}__", ` +
e0.to_js() +
", " +
e1.to_js() +
")"
);
}
default:
if (comps[this.op] !== undefined) {
return (
'$B.rich_comp("__' +
$operators[this.op] +
'__",' +
this.tree[0].to_js() +
"," +
this.tree[1].to_js() +
")"
);
} else {
return (
`$B.rich_op("__${$operators[this.op]}__", ` +
this.tree[0].to_js() +
", " +
this.tree[1].to_js() +
")"
);
}
}
};
$OpCtx.prototype.simple_js = function () {
var op = this.op;
function sjs(elt) {
if (elt.type == "op") {
return elt.simple_js();
} else if (
elt.type == "expr" &&
elt.tree[0].type == "list_or_tuple" &&
elt.tree[0].real == "tuple" &&
elt.tree[0].tree.length == 1 &&
elt.tree[0].tree[0].type == "expr"
) {
return "(" + elt.tree[0].tree[0].tree[0].simple_js() + ")";
} else {
return elt.tree[0].to_js();
}
}
if (op == "+") {
return "$B.add(" + sjs(this.tree[0]) + "," + sjs(this.tree[1]) + ")";
} else if (op == "-") {
return "$B.sub(" + sjs(this.tree[0]) + "," + sjs(this.tree[1]) + ")";
} else if (op == "*") {
return "$B.mul(" + sjs(this.tree[0]) + "," + sjs(this.tree[1]) + ")";
} else if (op == "/") {
return "$B.div(" + sjs(this.tree[0]) + "," + sjs(this.tree[1]) + ")";
} else {
return sjs(this.tree[0]) + op + sjs(this.tree[1]);
}
};
var $PackedCtx = ($B.parser.$PackedCtx = function (C) {
this.type = "packed";
this.position = $token.value;
if (C.parent.type == "list_or_tuple" && C.parent.parent.type == "node") {
for (var i = 0; i < C.parent.tree.length; i++) {
var child = C.parent.tree[i];
if (
child.type == "expr" &&
child.tree.length > 0 &&
child.tree[0].type == "packed"
) {
$_SyntaxError(C, ["two starred expressions in assignment"]);
}
}
}
this.parent = C;
this.tree = [];
this.pos = $pos - 1;
C.tree[C.tree.length] = this;
});
$PackedCtx.prototype.ast = function () {
var ast_obj = new ast.Starred(ast_or_obj(this.tree[0]), new ast.Load());
set_position(ast_obj, this.position);
return ast_obj;
};
$PackedCtx.prototype.toString = function () {
return "(packed) " + this.tree;
};
$PackedCtx.prototype.transition = function (token, value) {
var C = this;
if (C.tree.length > 0 && token == "[") {
return $transition(C.tree[0], token, value);
}
switch (token) {
case "id":
var expr = new $AbstractExprCtx(C, false);
expr.packed = true;
C.parent.expect = ",";
var id = $transition(expr, token, value);
return id;
case "[":
C.parent.expect = ",";
return new $ListOrTupleCtx(C, "list");
case "(":
C.parent.expect = ",";
return new $ListOrTupleCtx(C, "tuple");
case "str":
C.parent.expect = ",";
return new $StringCtx(C, value);
case "JoinedStr":
C.parent.expect = ",";
return new JoinedStrCtx(C, value);
case "]":
return $transition(C.parent, token, value);
case "{":
C.parent.expect = ",";
return new $DictOrSetCtx(C);
case "op":
switch (value) {
case "+":
case "-":
case "~":
C.parent.expect = ",";
return new $UnaryCtx(C, value);
default:
$_SyntaxError(C, ["can't use starred expression here"]);
}
}
return C.parent.transition(token, C);
};
$PackedCtx.prototype.to_js = function () {
this.js_processed = true;
return $to_js(this.tree);
};
var $PassCtx = ($B.parser.$PassCtx = function (C) {
this.type = "pass";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$PassCtx.prototype.ast = function () {
var ast_obj = new ast.Pass();
set_position(ast_obj, this.position);
return ast_obj;
};
$PassCtx.prototype.toString = function () {
return "(pass)";
};
$PassCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "eol") {
return C.parent;
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$PassCtx.prototype.to_js = function () {
this.js_processed = true;
return "void(0)";
};
var $PatternCtx = ($B.parser.$PatternCtx = function (C) {
this.type = "pattern";
this.parent = C;
this.tree = [];
C.tree.push(this);
this.expect = "id";
});
$PatternCtx.prototype.transition = function (token, value) {
var C = this;
switch (C.expect) {
case "id":
switch (token) {
case "str":
case "int":
case "float":
case "imaginary":
C.expect = ",";
return new $PatternLiteralCtx(C, token, value);
case "op":
switch (value) {
case "-":
case "+":
C.expect = ",";
return new $PatternLiteralCtx(C, { sign: value });
case "*":
C.expect = "starred_id";
return C;
default:
$_SyntaxError(C);
}
case "id":
C.expect = ",";
if (["None", "True", "False"].indexOf(value) > -1) {
return new $PatternLiteralCtx(C, token, value);
} else {
return new $PatternCaptureCtx(C, value);
}
break;
case "[":
return new $PatternCtx(new $PatternSequenceCtx(C.parent, token));
case "(":
return new $PatternCtx(new $PatternGroupCtx(C.parent, token));
case "{":
return new $PatternMappingCtx(C.parent, token);
case "JoinedStr":
$_SyntaxError(C, [
"patterns may only match " + "literals and attribute lookups",
]);
}
break;
case "starred_id":
if (token == "id") {
var capture = new $PatternCaptureCtx(C, value);
capture.starred = true;
return capture;
}
$_SyntaxError(C, "expected id after *");
case "number":
switch (token) {
case "int":
case "float":
case "imaginary":
C.expect = ",";
return new $PatternLiteralCtx(C, token, value, C.sign);
default:
$_SyntaxError(C);
}
case ",":
switch (token) {
case ",":
if (C.parent instanceof $PatternSequenceCtx) {
return new $PatternCtx(C.parent);
}
return new $PatternCtx(new $PatternSequenceCtx(C.parent));
case ":":
return $BodyCtx(C);
}
}
return C.parent.transition(token, value);
};
function as_pattern(C, token, value) {
if (C.expect == "as") {
if (token == "as") {
C.expect = "alias";
return C;
} else {
return $transition(C.parent, token, value);
}
} else if (C.expect == "alias") {
if (token == "id") {
if (value == "_") {
$_SyntaxError(C, ["alias cannot be _"]);
}
if (C.bindings().indexOf(value) > -1) {
$_SyntaxError(C, [
`multiple assignments to name '${value}' in pattern`,
]);
}
C.alias = value;
return C.parent;
} else {
$_SyntaxError(C, "bad alias");
}
}
}
var $PatternCaptureCtx = function (C, value) {
this.type = "capture_pattern";
this.parent = C.parent;
C.parent.tree.pop();
C.parent.tree.push(this);
this.tree = [value];
this.position = $token.value;
this.expect = ".";
this.$pos = $pos;
};
$PatternCaptureCtx.prototype.ast = function () {
var ast_obj;
try {
if (this.tree.length > 1) {
var pattern = new ast.Name(this.tree[0].value, new ast.Load());
set_position(pattern, this.position);
for (var i = 1; i < this.tree.length; i += 2) {
pattern = new ast.Attribute(pattern, this.tree[i], new ast.Load());
copy_position(pattern, pattern.value);
}
pattern = new ast.MatchValue(pattern);
copy_position(pattern, pattern.value);
} else if (this.starred) {
var v = this.tree[0];
if (v == "_") {
ast_obj = new ast.MatchStar();
} else {
ast_obj = new ast.MatchStar(v);
}
set_position(ast_obj, this.position);
} else {
var pattern = this.tree[0];
if (typeof pattern == "string") {
} else if (pattern.type == "group_pattern") {
pattern = pattern.ast();
} else {
console.log("bizarre", pattern);
pattern = $NumberCtx.prototype.ast.bind(this)();
}
if (pattern == "_") {
pattern = new ast.MatchAs();
set_position(pattern, this.position);
}
}
if (this.alias) {
if (typeof pattern == "string") {
pattern = new ast.MatchAs(undefined, pattern);
set_position(pattern, this.position);
}
ast_obj = new ast.MatchAs(pattern, this.alias);
} else if (this.tree.length > 1 || pattern instanceof ast.MatchAs) {
ast_obj = pattern;
} else if (typeof pattern == "string") {
ast_obj = new ast.MatchAs(undefined, pattern);
} else if (!this.starred) {
ast_obj = new ast.MatchAs(undefined, pattern);
}
set_position(ast_obj, this.position);
return ast_obj;
} catch (err) {
console.log("error capture ast");
show_line(this);
throw err;
}
};
$PatternCaptureCtx.prototype.bindings = function () {
var bindings = this.tree[0] == "_" ? [] : this.tree.slice();
if (this.alias) {
bindings.push(this.alias);
}
return bindings;
};
$PatternCaptureCtx.prototype.transition = function (token, value) {
var C = this;
switch (C.expect) {
case ".":
if (token == ".") {
C.type = "value_pattern";
C.expect = "id";
if (C.tree.length == 1) {
new $IdCtx(C, C.tree.pop());
} else {
C.tree.push(".");
}
return C;
} else if (token == "(") {
return new $PatternCtx(new $PatternClassCtx(C));
} else if (C.parent instanceof $PatternMappingCtx) {
return C.parent.transition(token, value);
} else {
C.expect = "as";
return C.transition(token, value);
}
case "as":
case "alias":
var res = as_pattern(C, token, value);
return res;
case "id":
if (token == "id") {
C.tree.push(value);
C.expect = ".";
return C;
}
}
return $transition(C.parent, token, value);
};
$PatternCaptureCtx.prototype.to_js = function () {
var js;
if (this.tree.length == 1) {
js = "{capture";
if (this.starred == true) {
js += "_starred";
}
js += `: '${this.tree[0]}'`;
} else {
js = this.tree[0].to_js();
for (var i = 1, len = this.tree.length; i < len; i += 2) {
js = "$B.$getattr(" + js + ', "' + this.tree[i] + '")';
}
js = `{value: ${js}`;
}
if (this.alias) {
js += `, alias: '${this.alias}'`;
}
return js + "}";
};
$PatternClassCtx = function (C) {
this.type = "class_pattern";
this.tree = [];
this.parent = C.parent;
this.position = $token.value;
this.class_id = new $IdCtx(C, C.tree[0]);
C.tree.pop();
this.attrs = C.tree.slice(2);
C.parent.tree.pop();
C.parent.tree.push(this);
this.expect = ",";
this.keywords = [];
this.positionals = [];
this.bound_names = [];
};
$PatternClassCtx.prototype.ast = function () {
var cls = new ast.Name(this.class_id.value);
set_position(cls, this.position);
cls.ctx = new ast.Load();
var patterns = [],
kwd_attrs = [],
kwd_patterns = [];
for (var item of this.tree) {
if (item.is_keyword) {
kwd_attrs.push(item.tree[0]);
kwd_patterns.push(ast_or_obj(item.tree[1]));
} else {
try {
patterns.push(ast_or_obj(item));
} catch (err) {
console.log("error in class pattern item");
show_line(this);
throw err;
}
}
}
var ast_obj = new ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns);
set_position(ast_obj, this.position);
if (this.alias) {
ast_obj = new ast.MatchAs(ast_obj, this.alias);
set_position(ast_obj, this.position);
}
return ast_obj;
};
$PatternClassCtx.prototype.bindings = function () {
var bindings = this.bound_names;
if (this.alias) {
bindings.push(this.alias);
}
return bindings;
};
$PatternClassCtx.prototype.transition = function (token, value) {
var C = this;
function check_last_arg() {
var last = $B.last(C.tree),
bound;
if (last instanceof $PatternCaptureCtx) {
if (!last.is_keyword && C.keywords.length > 0) {
$_SyntaxError(C, "positional argument after keyword");
}
if (last.is_keyword) {
if (C.keywords.indexOf(last.tree[0]) > -1) {
$_SyntaxError(C, [`keyword argument repeated: ${last.tree[0]}`]);
}
C.keywords.push(last.tree[0]);
bound = last.tree[1].bindings();
} else {
bound = last.bindings();
}
for (var b of bound) {
if (C.bound_names.indexOf(b) > -1) {
$_SyntaxError(C, [
"multiple assignments " + `to name '${b}' in pattern`,
]);
}
}
C.bound_names = C.bound_names.concat(bound);
}
}
switch (this.expect) {
case ",":
switch (token) {
case "=":
var current = $B.last(this.tree);
if (current instanceof $PatternCaptureCtx) {
if (this.keywords.indexOf(current.tree[0]) > -1) {
$_SyntaxError(C, [
"attribute name repeated in class pattern: " +
current.tree[0],
]);
}
current.is_keyword = true;
return new $PatternCtx(current);
}
$_SyntaxError(this, "= after non-capture");
case ",":
check_last_arg();
return new $PatternCtx(this);
case ")":
check_last_arg();
if ($B.last(this.tree).tree.length == 0) {
this.tree.pop();
}
C.expect = "as";
return C;
default:
$_SyntaxError(this);
}
case "as":
case "alias":
return as_pattern(C, token, value);
}
return $transition(C.parent, token, value);
};
$PatternClassCtx.prototype.to_js = function () {
var i = 0,
args = [],
kwargs = [];
var klass = this.class_id.to_js();
for (var i = 0, len = this.attrs.length; i < len; i += 2) {
klass = "$B.$getattr(" + klass + ', "' + this.attrs[i] + '")';
}
i = 0;
for (var item of this.tree) {
if (item instanceof $PatternCaptureCtx && item.tree.length > 1) {
kwargs.push(item.tree[0] + ": " + item.tree[1].to_js());
} else {
args.push(item.to_js());
}
}
var js =
"{class: " +
klass +
", args: [" +
args.join(", ") +
"], " +
"keywords: {" +
kwargs.join(", ") +
"}";
if (this.alias) {
js += `, alias: "${this.alias}"`;
}
return js + "}";
};
var $PatternGroupCtx = function (C) {
this.type = "group_pattern";
this.parent = C;
this.position = $token.value;
this.tree = [];
var first_pattern = C.tree.pop();
this.expect = ",|";
C.tree.push(this);
};
function remove_empty_pattern(C) {
var last = $B.last(C.tree);
if (last && last instanceof $PatternCtx && last.tree.length == 0) {
C.tree.pop();
}
}
$PatternGroupCtx.prototype.ast = function () {
var ast_obj;
if (this.tree.length == 1 && !this.has_comma) {
ast_obj = this.tree[0].ast();
} else {
ast_obj = $PatternSequenceCtx.prototype.ast.bind(this)();
}
if (this.alias) {
ast_obj = new ast.MatchAs(ast_obj, this.alias);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$PatternGroupCtx.prototype.bindings = function () {
var bindings = [];
for (var item of this.tree) {
bindings = bindings.concat(item.bindings());
}
if (this.alias) {
bindings.push(this.alias);
}
return bindings;
};
$PatternGroupCtx.prototype.transition = function (token, value) {
var C = this;
switch (C.expect) {
case ",|":
if (token == ")") {
remove_empty_pattern(C);
C.expect = "as";
return C;
} else if (token == ",") {
C.expect = "id";
C.has_comma = true;
return C;
} else if (token == "op" && value == "|") {
var opctx = new $PatternOrCtx(C.parent);
opctx.parenthese = true;
return new $PatternCtx(opctx);
} else if (this.token === undefined) {
return $transition(C.parent, token, value);
}
$_SyntaxError(C);
case "as":
case "alias":
return as_pattern(C, token, value);
case "id":
if (token == ")") {
remove_empty_pattern(C);
C.expect = "as";
return C;
}
C.expect = ",|";
return $transition(new $PatternCtx(C), token, value);
}
console.log("error", this, token, value);
$_SyntaxError(C, "token " + token + " after " + C);
};
$PatternGroupCtx.prototype.to_js = function () {
if (this.has_comma) {
var js = "{sequence: [" + $to_js(this.tree) + "]";
} else {
var js = "{group: [" + $to_js(this.tree) + "]";
}
if (this.alias) {
js += `, alias: "${this.alias}"`;
}
return js + "}";
};
var $PatternLiteralCtx = function (C, token, value, sign) {
this.type = "literal_pattern";
this.parent = C.parent;
this.position = $token.value;
C.parent.tree.pop();
C.parent.tree.push(this);
if (token.sign) {
this.tree = [{ sign: token.sign }];
this.expect = "number";
} else {
if (token == "str") {
this.tree = [];
new $StringCtx(this, value);
} else if (token == "JoinedStr") {
$_SyntaxError(this, ["patterns cannot include f-strings"]);
} else {
this.tree = [{ type: token, value, sign }];
}
this.expect = "op";
}
};
$PatternLiteralCtx.prototype.ast = function () {
var lineno = $get_node(this).line_num;
try {
var first = this.tree[0],
result;
if (first.type == "str") {
var v = $StringCtx.prototype.ast.bind(first)();
result = new ast.MatchValue(v);
} else if (first.type == "id") {
result = new ast.MatchSingleton(_b_[first.value]);
} else {
first.position = this.position;
var num = $NumberCtx.prototype.ast.bind(first)(),
res = new ast.MatchValue(num);
if (first.sign && first.sign != "+") {
var op = { "+": ast.UAdd, "-": ast.USub, "~": ast.Invert }[
first.sign
];
var unary_op = new ast.UnaryOp(new op(), res.value);
set_position(unary_op, this.position);
res = new ast.MatchValue(unary_op);
set_position(res, this.position);
}
if (this.tree.length == 1) {
result = res;
} else {
this.tree[2].position = this.position;
var num2 = $NumberCtx.prototype.ast.bind(this.tree[2])(),
binop = new ast.BinOp(
res.value,
this.tree[1] == "+" ? new ast.Add() : new ast.Sub(),
num2
);
set_position(binop, this.position);
result = new ast.MatchValue(binop);
}
}
set_position(result, this.position);
if (this.tree.length == 2) {
result = new ast.MatchValue(
new ast.BinOp(
ast_or_obj(this.tree[0]),
C.num_sign == "+" ? ast.Add : ast.Sub,
ast_or_obj(this.tree[1])
)
);
}
if (this.alias) {
result = new ast.MatchAs(result, this.alias);
}
set_position(result, this.position);
return result;
} catch (err) {
console.log("error pattern literal ast", this);
show_line(this);
throw err;
}
};
$PatternLiteralCtx.prototype.bindings = function () {
if (this.alias) {
return [this.alias];
}
return [];
};
$PatternLiteralCtx.prototype.transition = function (token, value) {
var C = this;
switch (C.expect) {
case "op":
if (token == "op") {
switch (value) {
case "+":
case "-":
if (["int", "float"].indexOf(C.tree[0].type) > -1) {
C.expect = "imaginary";
this.tree.push(value);
C.num_sign = value;
return C;
}
$_SyntaxError(C, ["patterns cannot include operators"]);
default:
return $transition(C.parent, token, value);
}
}
break;
case "number":
switch (token) {
case "int":
case "float":
case "imaginary":
var last = $B.last(C.tree);
if (this.tree.token === undefined) {
last.type = token;
last.value = value;
C.expect = "op";
return C;
}
default:
$_SyntaxError(C);
}
case "imaginary":
switch (token) {
case "imaginary":
C.tree.push({ type: token, value, sign: C.num_sign });
return C.parent;
default:
$_SyntaxError(C, "expected imaginary");
}
case "as":
case "alias":
return as_pattern(C, token, value);
}
if (token == "as" && C.tree.length == 1) {
C.expect = "as";
return C.transition(token, value);
}
return $transition(C.parent, token, value);
};
$PatternLiteralCtx.prototype.to_js = function () {
function int_to_num(item) {
var v = parseInt(item.value[1], item.value[0]);
return item.sign == "-" ? -v : v;
}
var res = "",
first = this.tree[0],
num_value;
if (first instanceof $StringCtx) {
res = first.to_js();
} else {
switch (first.type) {
case "id":
res = "_b_." + first.value;
num_value = first.value == "True" ? 1 : 0;
break;
case "str":
res = first.value;
break;
case "int":
res = int_to_num(first);
break;
case "float":
res = (first.sign == "-" ? "-" : "") + first.value;
break;
case "imaginary":
var v = $NumberCtx.prototype.to_js.bind(first.value)();
res +=
"$B.make_complex(0, " + (first.sign == "-" ? "-" : "") + v + ")";
if (first.value == 0) {
num_value = 0;
}
break;
}
}
if (this.tree.length > 1) {
var v = $NumberCtx.prototype.to_js.bind(this.tree[2].value)();
res =
"$B.make_complex(" +
res +
"," +
(this.tree[1] == "-" ? "-" : "") +
v +
")";
}
this.js_value = res;
this.num_value = num_value === undefined ? res : num_value;
var js = "{literal: " + res;
if (this.alias) {
js += `, alias: '${this.alias}'`;
}
return js + "}";
};
var $PatternMappingCtx = function (C) {
this.type = "mapping_pattern";
this.parent = C;
this.position = $token.value;
C.tree.pop();
this.tree = [];
C.tree.push(this);
this.expect = "key_value_pattern";
this.literal_keys = [];
this.bound_names = [];
};
$PatternMappingCtx.prototype.ast = function () {
var keys = [],
patterns = [];
for (var item of this.tree) {
keys.push(ast_or_obj(item.tree[0]).value);
if (item.tree[0] instanceof $PatternLiteralCtx) {
patterns.push(ast_or_obj(item.tree[1]));
} else {
patterns.push(ast_or_obj(item.tree[2]));
}
}
var res = new ast.MatchMapping(keys, patterns);
if (this.double_star) {
res.rest = this.double_star.tree[0];
}
set_position(res, this.position);
return res;
};
$PatternMappingCtx.prototype.bindings = function () {
var bindings = [];
for (var item of this.tree) {
bindings = bindings.concat(item.bindings());
}
if (this.rest) {
bindings = bindings.concat(this.rest.bindings());
}
if (this.alias) {
bindings.push(this.alias);
}
return bindings;
};
$PatternMappingCtx.prototype.transition = function (token, value) {
var C = this;
function check_duplicate_names() {
var last = $B.last(C.tree),
bindings;
if (last instanceof $PatternKeyValueCtx) {
if (C.double_star) {
C.$pos = C.double_star.$pos;
$_SyntaxError(C, [
"can't use starred name here (consider moving to end)",
]);
}
if (last.tree[0].type == "value_pattern") {
bindings = last.tree[2].bindings();
} else {
bindings = last.tree[1].bindings();
}
for (var binding of bindings) {
if (C.bound_names.indexOf(binding) > -1) {
$_SyntaxError(C, [
`multiple assignments to name '${binding}'` + " in pattern",
]);
}
}
C.bound_names = C.bound_names.concat(bindings);
}
}
switch (C.expect) {
case "key_value_pattern":
if (token == "}" || token == ",") {
check_duplicate_names();
if (C.double_star) {
var ix = C.tree.indexOf(C.double_star);
if (ix != C.tree.length - 1) {
C.$pos = C.double_star.$pos;
$_SyntaxError(C, [
"can't use starred name here (consider moving to end)",
]);
}
C.rest = C.tree.pop();
}
return token == "," ? C : C.parent;
}
if (token == "op" && value == "**") {
C.expect = "capture_pattern";
return C;
}
var p = new $PatternCtx(C);
try {
var lit_or_val = p.transition(token, value);
} catch (err) {
$_SyntaxError(C, [
"mapping pattern keys may only " +
"match literals and attribute lookups",
]);
}
if (lit_or_val instanceof $PatternLiteralCtx) {
C.tree.pop();
new $PatternKeyValueCtx(C, lit_or_val);
return lit_or_val;
} else if (lit_or_val instanceof $PatternCaptureCtx) {
C.has_value_pattern_keys = true;
C.tree.pop();
new $PatternKeyValueCtx(C, lit_or_val);
C.expect = ".";
return this;
} else {
console.log("lit_or_val", lit_or_val);
$_SyntaxError(C, "expected key or **");
}
case "capture_pattern":
var p = new $PatternCtx(C);
var capture = $transition(p, token, value);
if (capture instanceof $PatternCaptureCtx) {
if (C.double_star) {
C.$pos = capture.$pos;
$_SyntaxError(C, ["only one double star pattern is accepted"]);
}
if (value == "_") {
$_SyntaxError(C, "**_ is not valid");
}
if (C.bound_names.indexOf(value) > -1) {
$_SyntaxError(C, ["duplicate binding: " + value]);
}
C.bound_names.push(value);
capture.double_star = true;
C.double_star = capture;
C.expect = ",";
return C;
} else {
$_SyntaxError(this, "expected identifier");
}
case ",":
if (token == ",") {
C.expect = "key_value_pattern";
return C;
} else if (token == "}") {
C.expect = "key_value_pattern";
return C.transition(token, value);
}
$_SyntaxError(C, "token " + token + "after C " + C);
case ".":
if (C.tree.length > 0) {
var last = $B.last(C.tree);
if (last instanceof $PatternKeyValueCtx) {
new $IdCtx(last, last.tree[0].tree[0]);
C.expect = "key_value_pattern";
return $transition(last.tree[0], token, value);
}
}
$_SyntaxError(C, "token " + token + "after " + C);
}
return $transition(C.parent, token, value);
};
$PatternMappingCtx.prototype.to_js = function () {
var js = "{mapping: [" + $to_js(this.tree) + "]";
if (this.rest) {
js += ", rest: '" + this.rest.tree[0] + "'";
}
return js + "}";
};
var $PatternKeyValueCtx = function (C, literal_or_value) {
this.type = "pattern_key_value";
this.parent = C;
this.tree = [literal_or_value];
literal_or_value.parent = this;
this.expect = ":";
C.tree.push(this);
};
$PatternKeyValueCtx.prototype.bindings =
$PatternMappingCtx.prototype.bindings;
$PatternKeyValueCtx.prototype.transition = function (token, value) {
var C = this;
switch (C.expect) {
case ":":
switch (token) {
case ":":
var key_obj = this.tree[0];
if (key_obj instanceof $PatternLiteralCtx) {
var key = $B.AST.$convert(key_obj.tree[0]);
if (_b_.list.__contains__(this.parent.literal_keys, key)) {
$pos--;
$_SyntaxError(C, [
`mapping pattern checks ` +
`duplicate key (${_b_.repr(key)})`,
]);
}
this.parent.literal_keys.push(key);
}
this.expect = ",";
return new $PatternCtx(this);
default:
$_SyntaxError(C, "expected :");
}
case ",":
switch (token) {
case "}":
return $transition(C.parent, token, value);
case ",":
C.parent.expect = "key_value_pattern";
return $transition(C.parent, token, value);
case "op":
if (value == "|") {
return new $PatternCtx(new $PatternOrCtx(C));
}
}
$_SyntaxError(C, "expected , or }");
}
return $transition(C.parent, token, value);
};
$PatternKeyValueCtx.prototype.to_js = function () {
var key, value;
if (this.tree[0].type == "value_pattern") {
key = this.tree[1].to_js();
for (var i = 2, len = this.tree[0].tree.length; i < len; i += 2) {
key = "$B.$getattr(" + key + ', "' + this.tree[0].tree[i] + '")';
}
key = "{value: " + key + "}";
value = this.tree[2].to_js();
} else {
key = this.tree[0].to_js();
value = this.tree[1].to_js();
}
return "[" + key + "," + value + "]";
};
var $PatternOrCtx = function (C) {
this.type = "or_pattern";
this.parent = C;
this.position = $token.value;
var first_pattern = C.tree.pop();
if (
first_pattern instanceof $PatternGroupCtx &&
first_pattern.expect != "as"
) {
first_pattern = first_pattern.tree[0];
}
this.tree = [first_pattern];
first_pattern.parent = this;
this.expect = "|";
C.tree.push(this);
this.check_reachable();
};
$PatternOrCtx.prototype.ast = function () {
var ast_obj = new ast.MatchOr(this.tree.map(ast_or_obj));
set_position(ast_obj, this.position);
if (this.alias) {
ast_obj = new ast.MatchAs(ast_obj, this.alias);
}
set_position(ast_obj, this.position);
return ast_obj;
};
$PatternOrCtx.prototype.bindings = function () {
var names;
for (var subpattern of this.tree) {
if (subpattern.bindings === undefined) {
console.log("no binding", subpattern);
}
var subbindings = subpattern.bindings();
if (names === undefined) {
names = subbindings;
} else {
for (var item of names) {
if (subbindings.indexOf(item) == -1) {
$_SyntaxError(this, ["alternative patterns bind different names"]);
}
}
for (var item of subbindings) {
if (names.indexOf(item) == -1) {
$_SyntaxError(this, ["alternative patterns bind different names"]);
}
}
}
}
if (this.alias) {
return names.concat(this.alias);
}
return names;
};
$PatternOrCtx.prototype.check_reachable = function () {
var item = $B.last(this.tree);
var capture;
if (item.type == "capture_pattern") {
capture = item.tree[0];
} else if (
item.type == "group_pattern" &&
item.tree.length == 1 &&
item.tree[0].type == "capture_pattern"
) {
capture = item.tree[0].tree[0];
} else if (item instanceof $PatternOrCtx) {
item.check_reachable();
}
if (capture) {
var msg = capture == "_" ? "wildcard" : `name capture '${capture}'`;
$_SyntaxError(this, [`${msg} makes remaining patterns unreachable`]);
}
};
$PatternOrCtx.prototype.transition = function (token, value) {
function set_alias() {
var last = $B.last(C.tree);
if (last.alias) {
C.alias = last.alias;
delete last.alias;
}
}
var C = this;
if (["as", "alias"].indexOf(C.expect) > -1) {
return as_pattern(C, token, value);
}
if (token == "op" && value == "|") {
for (var item of C.tree) {
if (item.alias) {
$_SyntaxError(C, "no as pattern inside or pattern");
}
}
C.check_reachable();
return new $PatternCtx(C);
} else if (token == ")" && C.parenthese) {
set_alias();
C.bindings();
delete C.parenthese;
C.expect = "as";
return C;
}
set_alias();
C.bindings();
return $transition(C.parent, token, value);
};
$PatternOrCtx.prototype.to_js = function () {
var res = "{or : [" + $to_js(this.tree) + "]";
if (this.alias) {
res += `, alias: '${this.alias}'`;
}
return res + "}";
};
var $PatternSequenceCtx = function (C, token) {
this.type = "sequence_pattern";
this.parent = C;
this.position = $token.value;
this.tree = [];
this.bound_names = [];
var first_pattern = C.tree.pop();
if (token === undefined) {
this.bound_names = first_pattern.bindings();
this.tree = [first_pattern];
if (first_pattern.starred) {
this.has_star = true;
}
first_pattern.parent = this;
} else {
this.token = token;
}
this.expect = ",";
C.tree.push(this);
};
$PatternSequenceCtx.prototype.ast = function () {
var ast_obj = new ast.MatchSequence(this.tree.map(ast_or_obj));
set_position(ast_obj, this.position);
if (this.alias) {
ast_obj = new ast.MatchAs(ast_obj, this.alias);
set_position(ast_obj, this.position);
}
return ast_obj;
};
$PatternSequenceCtx.prototype.bindings =
$PatternMappingCtx.prototype.bindings;
$PatternSequenceCtx.prototype.transition = function (token, value) {
function check_duplicate_names() {
var last = $B.last(C.tree);
if (!(last instanceof $PatternCtx)) {
var last_bindings = last.bindings();
for (var b of last_bindings) {
if (C.bound_names.indexOf(b) > -1) {
$_SyntaxError(C, [
"multiple assignments to name '" + b + "' in pattern",
]);
}
}
if (last.starred) {
if (C.has_star) {
$_SyntaxError(C, ["multiple starred names in sequence pattern"]);
}
C.has_star = true;
}
C.bound_names = C.bound_names.concat(last_bindings);
}
}
var C = this;
if (C.expect == ",") {
if (
(C.token == "[" && token == "]") ||
(C.token == "(" && token == ")")
) {
var nb_starred = 0;
for (var item of C.tree) {
if (item instanceof $PatternCaptureCtx && item.starred) {
nb_starred++;
if (nb_starred > 1) {
$_SyntaxError(C, ["multiple starred names in sequence pattern"]);
}
}
}
C.expect = "as";
check_duplicate_names();
remove_empty_pattern(C);
return C;
} else if (token == ",") {
check_duplicate_names();
C.expect = "id";
return C;
} else if (token == "op" && value == "|") {
remove_empty_pattern(C);
return new $PatternCtx(new $PatternOrCtx(C));
} else if (this.token === undefined) {
check_duplicate_names();
return $transition(C.parent, token, value);
}
$_SyntaxError(C);
} else if (C.expect == "as") {
if (token == "as") {
this.expect = "alias";
return C;
}
return $transition(C.parent, token, value);
} else if (C.expect == "alias") {
if ((token = "id")) {
C.alias = value;
return C.parent;
}
$_SyntaxError(C, "expected alias");
} else if (C.expect == "id") {
C.expect = ",";
return $transition(new $PatternCtx(C), token, value);
}
};
$PatternSequenceCtx.prototype.to_js = function () {
var js = "{sequence: [" + $to_js(this.tree) + "]";
if (this.alias) {
js += `, alias: '${this.alias}'`;
}
return js + "}";
};
var $RaiseCtx = ($B.parser.$RaiseCtx = function (C) {
this.type = "raise";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.scope_type = $get_scope(this).ntype;
});
$RaiseCtx.prototype.ast = function () {
var ast_obj = new ast.Raise(...this.tree.map(ast_or_obj));
set_position(ast_obj, this.position);
return ast_obj;
};
$RaiseCtx.prototype.toString = function () {
return " (raise) " + this.tree;
};
$RaiseCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.tree.length == 0) {
return new $IdCtx(new $ExprCtx(C, "exc", false), value);
}
break;
case "from":
if (C.tree.length > 0) {
return new $AbstractExprCtx(C, false);
}
break;
case "eol":
remove_abstract_expr(this.tree);
return $transition(C.parent, token);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$RaiseCtx.prototype.to_js = function () {
var pnode = $get_node(this).parent,
except_node;
while (pnode) {
if (pnode.C && pnode.C.tree[0].type == "except") {
except_node = pnode;
break;
}
pnode = pnode.parent;
}
var __context__ = "_b_.None",
__cause__;
if (except_node) {
__context__ = except_node.C.tree[0].error_name;
}
if (this.tree.length == 2) {
__context__ = this.tree[1].to_js();
__cause__ = __context__;
}
this.js_processed = true;
var exc = this.tree.length == 0 ? "undefined" : this.tree[0].to_js();
return `$B.$raise(${exc}, ${__context__}, ${__cause__})`;
};
var $RawJSCtx = ($B.parser.$RawJSCtx = function (C, js) {
this.type = "raw_js";
C.tree[C.tree.length] = this;
this.parent = C;
this.js = js;
});
$RawJSCtx.prototype.toString = function () {
return "(js) " + this.js;
};
$RawJSCtx.prototype.transition = function (token, value) {
var C = this;
};
$RawJSCtx.prototype.to_js = function () {
this.js_processed = true;
return this.js;
};
var $ReturnCtx = ($B.parser.$ReturnCtx = function (C) {
this.type = "return";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
this.scope = $get_scope(this);
if (["def", "generator"].indexOf(this.scope.ntype) == -1) {
$_SyntaxError(C, ["'return' outside function"]);
}
var node = (this.node = $get_node(this));
while (node.parent) {
if (node.parent.C) {
var elt = node.parent.C.tree[0];
if (elt.type == "for") {
elt.has_return = true;
break;
} else if (elt.type == "try") {
elt.has_return = true;
} else if (elt.type == "single_kw" && elt.token == "finally") {
elt.has_return = true;
}
}
node = node.parent;
}
});
$ReturnCtx.prototype.ast = function () {
var res = new ast.Return();
if (this.tree.length > 0) {
res.value = ast_or_obj(this.tree[0]);
}
set_position(res, this.position);
return res;
};
$ReturnCtx.prototype.toString = function () {
return "return " + this.tree;
};
$ReturnCtx.prototype.transition = function (token, value) {
var C = this;
if (
token == "eol" &&
this.tree.length == 1 &&
this.tree[0].type == "abstract_expr"
) {
this.tree.pop();
}
return $transition(C.parent, token);
};
$ReturnCtx.prototype.to_js = function () {
this.js_processed = true;
var expr = this.tree.length == 0 ? "_b_.None" : $to_js(this.tree);
var scope = this.scope;
if (scope.ntype == "generator") {
return (
"var $res = " +
expr +
"; $B.leave_frame({$locals});" +
"return $B.generator_return($res)"
);
}
var indent = " ".repeat(this.node.indent - 1);
var js =
"var $res = " +
expr +
";\n" +
indent +
"if($locals.$f_trace !== _b_.None){\n$B.trace_return($res)}\n" +
indent +
"$B.leave_frame";
if (scope.id.substr(0, 6) == "$exec_") {
js += "_exec";
}
js += "({$locals});\n";
if (this.is_await) {
js += indent + "$B.restore_stack(save_stack, $locals)\n";
}
js += indent + "return $res";
return js;
};
var SetCompCtx = function (C) {
this.type = "setcomp";
this.tree = [C.tree[0]];
this.tree[0].parent = this;
Comprehension.make_comp(this, C);
};
SetCompCtx.prototype.ast = function () {
var res = new ast.SetComp(
ast_or_obj(this.tree[0]),
Comprehension.generators(this.tree.slice(1))
);
res.lineno = $get_node(this).line_num;
return res;
};
SetCompCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "}") {
this.has_await = Comprehension.has_await(this);
return this.parent;
}
$_SyntaxError(C, "token " + token + "after list comp");
};
SetCompCtx.prototype.to_js = function () {
var node = $get_node(this),
indent = node.get_indent();
var id = this.id,
expr = this.tree[0],
first_for = this.tree[1],
outmost_expr = first_for.tree[1].to_js();
first_for.comp_body = true;
first_for.iterable_is_outermost = true;
var module_id = this.module.replace(/\./g, "_");
var js =
`(${this.has_await ? "async " : ""}function(expr){` +
Comprehension.admin_infos(this) +
`\nvar $result_${id} = _b_.set.$factory()\n`;
js += first_for.to_js(indent);
var nb = -1;
for (var i = 2; i < this.tree.length; i++) {
nb++;
var stmt = this.tree[i];
if (stmt.type == "for") {
stmt.comp_body = true;
js += "\n" + stmt.to_js(indent + nb);
} else if (stmt.type == "condition" && stmt.token == "if") {
js += "\n" + " ".repeat(12 + 4 * nb) + stmt.to_js() + "{";
}
}
var expr_has_await = Comprehension.has_await(expr);
js +=
"\n" +
" ".repeat(16 + 4 * nb) +
(expr_has_await ? "var save_stack = $B.save_stack();\n" : "") +
`try{\n_b_.set.add($result_${id}, ${expr.to_js()})\n` +
`}catch(err){\n` +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "") +
`$B.leave_frame($locals); throw err\n` +
"\n}" +
(expr_has_await ? "$B.restore_stack(save_stack, $locals);" : "");
for (var i = 1; i < this.tree.length; i++) {
js += "\n" + " ".repeat(12 + 4 * nb--) + "}";
}
js += `\n$B.leave_frame({$locals, value: _b_.None})`;
js += `\nreturn $result_${id}`;
js += `\n}\n)(${outmost_expr})`;
return js;
};
var $SingleKwCtx = ($B.parser.$SingleKwCtx = function (C, token) {
this.type = "single_kw";
this.token = token;
this.parent = C;
this.tree = [];
C.tree[C.tree.length] = this;
if (token == "else") {
var node = C.node,
rank = node.parent.children.indexOf(node),
pctx = node.parent.children[rank - 1].C;
pctx.tree[0].orelse = this;
if (pctx.tree.length > 0) {
var elt = pctx.tree[0];
if (
elt.type == "for" ||
elt.type == "asyncfor" ||
(elt.type == "condition" && elt.token == "while")
) {
elt.has_break = true;
elt.else_node = $get_node(this);
this.loop_num = elt.loop_num;
}
}
}
});
$SingleKwCtx.prototype.ast = function () {
return ast_body(this.parent);
};
$SingleKwCtx.prototype.toString = function () {
return this.token;
};
$SingleKwCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ":") {
return $BodyCtx(C);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$SingleKwCtx.prototype.transform = function (node, rank) {
if (this.token == "finally") {
var scope = $get_scope(this);
node.insert(
0,
$NodeJS(
"var $exit;" +
"if($B.frames_stack.length < $stack_length){\n" +
"$exit = true;" +
"$B.frames_stack.push($top_frame)" +
"}"
)
);
var scope_id = scope.id.replace(/\./g, "_");
var last_child = node.children[node.children.length - 1];
if (last_child.C.tree[0].type != "return") {
node.add($NodeJS("if($exit){\n$B.leave_frame({$locals})}"));
}
}
};
$SingleKwCtx.prototype.to_js = function () {
this.js_processed = true;
if (this.token == "finally") {
return this.token;
}
if (this.loop_num !== undefined) {
return "if($no_break" + this.loop_num + ")";
}
return this.token;
};
var $SliceCtx = ($B.parser.$SliceCtx = function (C) {
this.type = "slice";
this.parent = C;
this.position = $token.value;
this.tree = C.tree.length > 0 ? [C.tree.pop()] : [];
C.tree.push(this);
});
$SliceCtx.prototype.ast = function () {
var slice = new ast.Slice();
var attrs = ["lower", "upper", "step"];
for (var i = 0; i < this.tree.length; i++) {
var item = this.tree[i];
if (item.type !== "abstract_expr") {
slice[attrs[i]] = ast_or_obj(item);
}
}
set_position(slice, this.position);
return slice;
};
$SliceCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ":") {
return new $AbstractExprCtx(C, false);
}
return $transition(C.parent, token, value);
};
$SliceCtx.prototype.to_js = function () {
for (var i = 0; i < this.tree.length; i++) {
if (this.tree[i].type == "abstract_expr") {
this.tree[i].to_js = function () {
return "_b_.None";
};
}
}
return "_b_.slice.$factory(" + $to_js(this.tree) + ")";
};
var $StarArgCtx = ($B.parser.$StarArgCtx = function (C) {
this.type = "star_arg";
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$StarArgCtx.prototype.toString = function () {
return "(star arg) " + this.tree;
};
$StarArgCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.parent.type == "target_list") {
C.tree.push(value);
C.parent.expect = ",";
return C.parent;
}
return $transition(new $AbstractExprCtx(C, false), token, value);
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case "not":
case "lambda":
return $transition(new $AbstractExprCtx(C, false), token, value);
case ",":
case ")":
if (C.tree.length == 0) {
$_SyntaxError(C, "unnamed star argument");
}
return $transition(C.parent, token);
case ":":
if (C.parent.parent.type == "lambda") {
return $transition(C.parent.parent, token);
}
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$StarArgCtx.prototype.to_js = function () {
this.js_processed = true;
return '{$nat:"ptuple",arg:' + $to_js(this.tree) + "}";
};
var $StringCtx = ($B.parser.$StringCtx = function (C, value) {
this.type = "str";
this.parent = C;
this.position = $token.value;
function prepare(value) {
value = value.replace(/\n/g, "\\n\\\n");
value = value.replace(/\r/g, "\\r\\\r");
return value;
}
this.is_bytes = value.charAt(0) == "b";
if (!this.is_bytes) {
this.value = prepare(value);
} else {
this.value = prepare(value.substr(1));
}
C.tree.push(this);
this.tree = [this.value];
this.raw = false;
this.$pos = $pos;
});
$StringCtx.prototype.ast = function () {
var value;
if (!this.is_bytes) {
try {
value = eval(this.value);
} catch (err) {
console.log("error str ast", this.value);
throw err;
}
} else {
value = _b_.bytes.$new(_b_.bytes, eval(this.value), "ISO-8859-1");
}
var ast_obj = new ast.Constant(value);
set_position(ast_obj, this.position);
return ast_obj;
};
$StringCtx.prototype.toString = function () {
return "string " + (this.value || "");
};
$StringCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "[":
return new $AbstractExprCtx(new $SubCtx(C.parent), false);
case "(":
C.parent.tree[0] = C;
return new $CallCtx(C.parent);
case "str":
if (
(this.is_bytes && !value.startsWith("b")) ||
(!this.is_bytes && value.startsWith("b"))
) {
C.$pos = $pos;
$_SyntaxError(C, ["cannot mix bytes and nonbytes literals"]);
}
C.value += " + " + (this.is_bytes ? value.substr(1) : value);
return C;
case "JoinedStr":
C.parent.tree.pop();
var joined_str = new JoinedStrCtx(C.parent, value);
if (typeof joined_str.tree[0] == "string") {
joined_str.tree[0] = eval(this.value) + joined_str.tree[0];
} else {
joined_str.tree.splice(0, 0, this);
}
return joined_str;
}
return $transition(C.parent, token, value);
};
$StringCtx.prototype.to_js = function () {
this.js_processed = true;
if (!this.is_bytes) {
return "$B.String(" + this.value + ")";
} else {
return "_b_.bytes.$new(_b_.bytes, " + this.value + ", 'ISO-8859-1')";
}
};
var $SubCtx = ($B.parser.$SubCtx = function (C) {
this.type = "sub";
this.func = "getitem";
this.value = C.tree[0];
this.position = this.value.position;
if ($B.js_from_ast && this.position === undefined) {
console.log("pas de position pour sub value", this.value);
alert();
}
C.tree.pop();
C.tree[C.tree.length] = this;
this.parent = C;
this.tree = [];
});
$SubCtx.prototype.ast = function () {
var slice;
if (this.tree.length > 1) {
var slice_items = this.tree.map((x) => ast_or_obj(x));
slice = new ast.Tuple(slice_items);
set_position(slice, this.position);
} else {
slice = ast_or_obj(this.tree[0]);
}
slice.ctx = new ast.Load();
var value = ast_or_obj(this.value);
if (value.ctx) {
value.ctx = new ast.Load();
}
var ast_obj = new ast.Subscript(value, slice, new ast.Load());
set_position(ast_obj, this.position);
return ast_obj;
};
$SubCtx.prototype.toString = function () {
return "(sub) (value) " + this.value + " (tree) " + this.tree;
};
$SubCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
case "imaginary":
case "int":
case "float":
case "str":
case "JoinedStr":
case "bytes":
case "[":
case "(":
case "{":
case ".":
case "not":
case "lambda":
var expr = new $AbstractExprCtx(C, false);
return $transition(expr, token, value);
case "]":
if (C.parent.packed) {
return C.parent;
}
if (C.tree[0].tree.length > 0) {
return C.parent;
}
break;
case ":":
return new $AbstractExprCtx(new $SliceCtx(C), false);
case ",":
return new $AbstractExprCtx(C, false);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$SubCtx.prototype.to_js = function () {
this.js_processed = true;
if (this.func == "getitem" && this.value.type == "id") {
var type = $get_node(this).locals[this.value.value],
val = this.value.to_js();
if (type == "list" || type == "tuple") {
if (this.tree.length == 1) {
return "$B.list_key(" + val + ", " + this.tree[0].to_js() + ")";
} else if (this.tree.length == 2) {
return (
"$B.list_slice(" +
val +
", " +
(this.tree[0].to_js() || "null") +
"," +
(this.tree[1].to_js() || "null") +
")"
);
} else if (this.tree.length == 3) {
return (
"$B.list_slice_step(" +
val +
", " +
(this.tree[0].to_js() || "null") +
"," +
(this.tree[1].to_js() || "null") +
"," +
(this.tree[2].to_js() || "null") +
")"
);
}
}
}
if (this.func == "getitem" && this.tree.length == 1) {
if (this.tree[0].type == "slice") {
return (
`$B.getitem_slice(${this.value.to_js()}, ` +
`${this.tree[0].to_js()})`
);
}
return (
"$B.$getitem(" + this.value.to_js() + "," + this.tree[0].to_js() + ")"
);
}
if (this.func == "delitem" && this.tree.length == 1) {
if (this.tree[0].type == "slice") {
return (
`$B.delitem_slice(${this.value.to_js()}, ` +
`${this.tree[0].to_js()})`
);
}
return (
"$B.$delitem(" + this.value.to_js() + "," + this.tree[0].to_js() + ")"
);
}
var res = "",
shortcut = false;
if (this.func !== "delitem" && this.tree.length == 1 && !this.in_sub) {
var expr = "",
x = this;
shortcut = true;
while (x.value.type == "sub") {
expr += "[" + x.tree[0].to_js() + "]";
x.value.in_sub = true;
x = x.value;
}
var subs =
x.value.to_js() +
"[" +
x.tree[0].to_js() +
"]" +
"((Array.isArray(" +
x.value.to_js() +
") || typeof " +
x.value.to_js() +
' == "string") && ' +
subs +
" !== undefined ?" +
subs +
expr +
" : ";
}
var val = this.value.to_js();
res += "$B.$getattr(" + val + ',"__' + this.func + '__")(';
if (this.tree.length == 1) {
res += this.tree[0].to_js() + ")";
} else {
var res1 = [];
for (var elt of this.tree) {
if (elt.type == "abstract_expr") {
res1.push("_b_.None");
} else {
res1.push(elt.to_js());
}
}
res += "_b_.tuple.$factory([" + res1.join(",") + "]))";
}
return shortcut ? res + ")" : res;
};
var $TargetListCtx = ($B.parser.$TargetListCtx = function (C) {
this.type = "target_list";
this.parent = C;
this.tree = [];
this.position = $token.value;
this.expect = "id";
this.nb_packed = 0;
C.tree[C.tree.length] = this;
});
$TargetListCtx.prototype.ast = function () {
if (this.tree.length == 1 && !this.implicit_tuple) {
var item = ast_or_obj(this.tree[0]);
item.ctx = new ast.Store();
if (item instanceof ast.Tuple) {
for (var target of item.elts) {
target.ctx = new ast.Store();
}
}
return item;
} else {
var items = [];
for (var item of this.tree) {
item = ast_or_obj(item);
if (item.hasOwnProperty("ctx")) {
item.ctx = new ast.Store();
}
items.push(item);
}
var ast_obj = new ast.Tuple(items, new ast.Store());
set_position(ast_obj, this.position);
return ast_obj;
}
};
$TargetListCtx.prototype.toString = function () {
return "(target list) " + this.tree;
};
$TargetListCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
C.expect = ",";
return new $IdCtx(new $ExprCtx(C, "target", false), value);
}
case "op":
if (C.expect == "id" && value == "*") {
this.nb_packed++;
return new $PackedCtx(C);
}
case "(":
case "[":
if (C.expect == "id") {
C.expect = ",";
return new $ListOrTupleCtx(C, token == "(" ? "tuple" : "list");
}
case ")":
case "]":
if (C.expect == ",") {
return C.parent;
}
case ",":
if (C.expect == ",") {
C.expect = "id";
C.implicit_tuple = true;
return C;
}
}
if (C.expect == ",") {
return $transition(C.parent, token, value);
} else if (token == "in") {
return $transition(C.parent, token, value);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$TargetListCtx.prototype.to_js = function () {
this.js_processed = true;
return $to_js(this.tree);
};
var $TernaryCtx = ($B.parser.$TernaryCtx = function (C) {
this.type = "ternary";
this.position = $token.value;
C.parent.tree.pop();
var expr = new $ExprCtx(C.parent, "ternary", false);
expr.tree.push(this);
this.parent = expr;
this.tree = [C];
C.parent = this;
});
$TernaryCtx.prototype.ast = function () {
var ast_obj = new ast.IfExp(
ast_or_obj(this.tree[1]),
ast_or_obj(this.tree[0]),
ast_or_obj(this.tree[2])
);
set_position(ast_obj, this.position);
return ast_obj;
};
$TernaryCtx.prototype.toString = function () {
return "(ternary) " + this.tree;
};
$TernaryCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "else") {
C.in_else = true;
return new $AbstractExprCtx(C, false);
} else if (!C.in_else) {
$_SyntaxError(C, "token " + token + " after " + C);
} else if (token == ",") {
if (
["assign", "augm_assign", "node", "return"].indexOf(C.parent.type) > -1
) {
C.parent.tree.pop();
var t = new $ListOrTupleCtx(C.parent, "tuple");
t.implicit = true;
t.tree[0] = C;
C.parent = t;
t.expect = "id";
return t;
}
}
return $transition(C.parent, token, value);
};
$TernaryCtx.prototype.to_js = function () {
this.js_processed = true;
var res = "$B.$bool(" + this.tree[1].to_js() + ") ? ";
res += this.tree[0].to_js() + " : ";
return res + this.tree[2].to_js();
};
var $TryCtx = ($B.parser.$TryCtx = function (C) {
this.type = "try";
this.parent = C;
this.position = $token.value;
C.tree[C.tree.length] = this;
});
$TryCtx.prototype.ast = function () {
var node = this.parent.node,
res = {
body: ast_body(this.parent),
handlers: [],
orelse: [],
finalbody: [],
};
var rank = node.parent.children.indexOf(node);
for (var child of node.parent.children.slice(rank + 1)) {
var t = child.C.tree[0],
type = t.type;
if (type == "single_kw") {
type = t.token;
}
if (type == "except") {
res.handlers.push(ast_or_obj(t));
} else if (type == "else") {
res.orelse = ast_body(child.C);
} else if (type == "finally") {
res.finalbody = ast_body(child.C);
} else {
break;
}
}
var res = new ast.Try(res.body, res.handlers, res.orelse, res.finalbody);
set_position(res, this.position);
return res;
};
$TryCtx.prototype.toString = function () {
return "(try) ";
};
$TryCtx.prototype.transition = function (token, value) {
var C = this;
if (token == ":") {
return $BodyCtx(C);
}
$_SyntaxError(C, "token " + token + " after " + C);
};
$TryCtx.prototype.transform = function (node, rank) {
if (node.parent.children.length == rank + 1) {
$_SyntaxError(node.C, ["unexpected EOF while parsing"]);
}
var scope = $get_scope(this);
var error_name = (this.error_name = create_temp_name("$err"));
var failed_name = "$locals." + create_temp_name("$failed");
var js = failed_name + " = false;\n" + " ".repeat(node.indent + 4) + "try";
new $NodeJSCtx(node, js);
node.has_return = this.has_return;
var catch_node = $NodeJS("catch(" + error_name + ")");
node.parent.insert(rank + 1, catch_node);
catch_node.add($NodeJS("$B.set_exc(" + error_name + ")"));
catch_node.add(
$NodeJS(
"if($locals.$f_trace !== _b_.None)" +
"{\n$locals.$f_trace = $B.trace_exception()}"
)
);
catch_node.add(
$NodeJS(
failed_name +
" = true;" +
"$B.pmframe = $B.last($B.frames_stack);" +
"if(false){\n}"
)
);
var pos = rank + 2,
has_default = false,
has_else = false,
has_finally = false;
while (1) {
if (pos == node.parent.children.length) {
break;
}
var ctx = node.parent.children[pos].C.tree[0];
if (ctx === undefined) {
break;
}
if (ctx.type == "except") {
if (has_else) {
$_SyntaxError(C, "'except' or 'finally' after 'else'");
}
if (has_finally) {
$_SyntaxError(C, "'except' after 'finally'");
}
ctx.error_name = error_name;
if (
ctx.tree.length > 0 &&
ctx.tree[0].alias !== null &&
ctx.tree[0].alias !== undefined
) {
var alias = ctx.tree[0].alias;
node.parent.children[pos].insert(
0,
$NodeJS(
'$locals["' + alias + '"] = $B.exception(' + error_name + ")"
)
);
}
catch_node.insert(
catch_node.children.length,
node.parent.children[pos]
);
if (ctx.tree.length == 0) {
if (has_default) {
$_SyntaxError(C, "more than one except: line");
}
has_default = true;
}
node.parent.children.splice(pos, 1);
} else if (ctx.type == "single_kw" && ctx.token == "finally") {
has_finally = true;
var finally_node = node.parent.children[pos];
pos++;
} else if (ctx.type == "single_kw" && ctx.token == "else") {
if (has_else) {
$_SyntaxError(C, "more than one 'else'");
}
if (has_finally) {
$_SyntaxError(C, "'else' after 'finally'");
}
has_else = true;
var else_body = node.parent.children[pos];
node.parent.children.splice(pos, 1);
} else {
break;
}
}
if (!has_default) {
var new_node = new $Node(),
ctx = new $NodeCtx(new_node);
catch_node.insert(catch_node.children.length, new_node);
new $SingleKwCtx(ctx, "else");
new_node.add($NodeJS("throw " + error_name));
}
if (has_else) {
var else_node = new $Node();
else_node.module = scope.module;
new $NodeJSCtx(else_node, "if(!" + failed_name + ")");
for (var elt of else_body.children) {
else_node.add(elt);
}
if (has_finally) {
finally_node.insert(0, else_node);
} else {
node.parent.insert(pos, else_node);
}
pos++;
}
$loop_num++;
};
$TryCtx.prototype.to_js = function () {
this.js_processed = true;
return "try";
};
var $UnaryCtx = ($B.parser.$UnaryCtx = function (C, op) {
this.type = "unary";
this.op = op;
this.parent = C;
this.tree = [];
this.position = $token.value;
C.tree.push(this);
});
$UnaryCtx.prototype.ast = function () {
var op = { "+": ast.UAdd, "-": ast.USub, "~": ast.Invert }[this.op],
ast_obj = new ast.UnaryOp(new op(), ast_or_obj(this.tree[0]));
set_position(ast_obj, this.position);
return ast_obj;
};
$UnaryCtx.prototype.toString = function () {
return "(unary) " + this.op;
};
$UnaryCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "op":
if ("+" == value || "-" == value) {
if (C.op === value) {
C.op = "+";
} else {
C.op = "-";
}
return C;
}
case "int":
case "float":
case "imaginary":
if (C.parent.type == "packed") {
$_SyntaxError(C, ["can't use starred expression here"]);
}
var res = new $NumberCtx(token, C, value);
console.log("new number after unary", res);
alert();
return res;
case "id":
return $transition(new $AbstractExprCtx(C, false), token, value);
}
if (this.tree.length == 0 || this.tree[0].type == "abstract_expr") {
$_SyntaxError(C, "token " + token + "after C" + C);
}
return $transition(C.parent, token, value);
};
$UnaryCtx.prototype.to_js = function () {
this.js_processed = true;
var operand = this.tree[0].tree[0];
switch (operand.type) {
case "float":
return "_b_.float.$factory(" + this.op + operand.value + ")";
case "int":
var value = eval(operand.to_js());
if (value.__class__ != $B.long_int) {
return eval(this.op + value);
}
}
var method = { "-": "__neg__", "+": "__pos__", "~": "__invert__" }[this.op];
return "$B.$call($B.$getattr(" + operand.to_js() + ', "' + method + '"))()';
};
var $WithCtx = ($B.parser.$WithCtx = function (C) {
this.type = "with";
this.parent = C;
this.position = $token.value;
C.tree[C.tree.length] = this;
this.tree = [];
this.expect = "as";
this.scope = $get_scope(this);
});
$WithCtx.prototype.ast = function () {
var withitems = [],
withitem;
for (var item of this.tree) {
withitem = new ast.withitem(ast_or_obj(item.tree[0]));
if (item.alias) {
withitem.optional_vars = ast_or_obj(item.alias.tree[0]);
withitem.optional_vars.ctx = new ast.Store();
}
withitems.push(withitem);
}
var klass = this.async ? ast.AsyncWith : ast.With;
var ast_obj = new klass(withitems, ast_body(this.parent));
set_position(ast_obj, this.position);
return ast_obj;
};
$WithCtx.prototype.toString = function () {
return "(with) " + this.tree;
};
$WithCtx.prototype.transition = function (token, value) {
var C = this;
switch (token) {
case "id":
if (C.expect == "id") {
C.expect = "as";
return $transition(new $AbstractExprCtx(C, false), token, value);
}
$_SyntaxError(C, "token " + token + " after " + C);
case "as":
return new $AbstractExprCtx(new $AliasCtx(C));
case ":":
switch (C.expect) {
case "id":
case "as":
case ":":
return $BodyCtx(C);
}
break;
case "(":
if (C.expect == "id" && C.tree.length == 0) {
C.parenth = true;
return C;
} else if (C.expect == "alias") {
C.expect = ":";
return new $TargetListCtx(C, false);
}
break;
case ")":
if (C.expect == "," || C.expect == "as") {
C.expect = ":";
return C;
}
break;
case ",":
if (
C.parenth !== undefined &&
C.has_alias === undefined &&
(C.expect == "," || C.expect == "as")
) {
C.expect = "id";
return C;
} else if (C.expect == "as") {
C.expect = "id";
return C;
} else if (C.expect == ":") {
C.expect = "id";
return C;
}
break;
}
$_SyntaxError(C, "token " + token + " after " + C.expect);
};
$WithCtx.prototype.set_alias = function (ctx) {
var ids = [];
if (ctx.type == "id") {
ids = [ctx];
} else if (ctx.type == "list_or_tuple") {
for (var expr of ctx.tree) {
if (expr.type == "expr" && expr.tree[0].type == "id") {
ids.push(expr.tree[0]);
}
}
}
for (var i = 0, len = ids.length; i < len; i++) {
var id_ctx = ids[i];
$bind(id_ctx.value, this.scope, this);
id_ctx.bound = true;
if (this.scope.ntype !== "module") {
this.scope.C.tree[0].locals.push(id_ctx.value);
}
}
};
$WithCtx.prototype.transform = function (node, rank) {
while (this.tree.length > 1) {
var suite = node.children,
item = this.tree.pop(),
new_node = new $Node(),
ctx = new $NodeCtx(new_node),
with_ctx = new $WithCtx(ctx);
item.parent = with_ctx;
with_ctx.tree = [item];
with_ctx.async = this.async;
for (var elt of suite) {
new_node.add(elt);
}
node.children = [new_node];
}
if (this.transformed) {
return;
}
this.prefix = "";
if (this.tree.length > 1) {
var nw = new $Node(),
ctx = new $NodeCtx(nw);
nw.parent = node;
nw.module = node.module;
nw.indent = node.indent + 4;
var wc = new $WithCtx(ctx);
wc.async = this.async;
wc.tree = this.tree.slice(1);
for (var elt of node.children) {
nw.add(elt);
}
node.children = [nw];
this.transformed = true;
return;
}
if (this.async) {
return this.transform_async(node, rank);
}
var top_try_node = $NodeJS("try");
node.parent.insert(rank + 1, top_try_node);
var num = (this.num = $loop_num++);
top_try_node.ctx_manager_num = num;
this.cm_name = this.prefix + "$ctx_manager" + num;
this.cmexit_name = this.prefix + "$ctx_manager_exit" + num;
this.exc_name = this.prefix + "$exc" + num;
this.err_name = "$err" + num;
this.val_name = "$value" + num;
this.yield_name = this.prefix + "$yield" + num;
if (this.tree[0].alias === null) {
this.tree[0].alias = "$temp";
}
if (
this.tree[0].type == "expr" &&
this.tree[0].tree[0].type == "list_or_tuple"
) {
if (
this.tree[1].type != "expr" ||
this.tree[1].tree[0].type != "list_or_tuple"
) {
$_SyntaxError(C);
}
if (
this.tree[0].tree[0].tree.length != this.tree[1].tree[0].tree.length
) {
$_SyntaxError(C, ["wrong number of alias"]);
}
var ids = this.tree[0].tree[0].tree,
alias = this.tree[1].tree[0].tree;
this.tree.shift();
this.tree.shift();
for (var i = ids.length - 1; i >= 0; i--) {
ids[i].alias = alias[i].value;
this.tree.splice(0, 0, ids[i]);
}
}
var block = node.children;
node.children = [];
var try_node = new $Node();
new $NodeJSCtx(try_node, "try");
top_try_node.add(try_node);
if (this.tree[0].alias) {
var new_node = new $Node(),
ctx = new $NodeCtx(new_node);
try_node.add(new_node);
this.tree[0].alias.tree[0].parent = ctx;
var assign = new $AssignCtx(this.tree[0].alias.tree[0]);
assign.tree.push(new $RawJSCtx(ctx, this.val_name));
}
for (var elt of block) {
try_node.add(elt);
}
var catch_node = new $Node();
new $NodeJSCtx(catch_node, "catch(" + this.err_name + ")");
var js =
this.exc_name +
" = false;" +
this.err_name +
" = $B.exception(" +
this.err_name +
", true)\n" +
" ".repeat(node.indent + 4) +
"var $b = " +
this.cmexit_name +
"(" +
this.err_name +
".__class__," +
this.err_name +
"," +
"$B.$getattr(" +
this.err_name +
', "__traceback__"));';
js += "\nif(!$B.$bool($b)){\nthrow " + this.err_name + "}";
catch_node.add($NodeJS(js));
top_try_node.add(catch_node);
var finally_node = new $Node();
new $NodeJSCtx(finally_node, "finally");
finally_node.C.type = "single_kw";
finally_node.C.token = "finally";
finally_node.C.in_ctx_manager = true;
finally_node.is_except = true;
finally_node.in_ctx_manager = true;
var js = "if(" + this.exc_name;
js += "){\n" + this.cmexit_name + "(_b_.None, _b_.None, _b_.None);";
if (this.scope.ntype == "generator") {
js += "delete " + this.cmexit_name;
}
js += "};";
finally_node.add($NodeJS(js));
node.parent.insert(rank + 2, finally_node);
this.transformed = true;
};
$WithCtx.prototype.transform_async = function (node, rank) {
var scope = $get_scope(this),
expr = this.tree[0],
alias = this.tree[0].alias;
var new_nodes = [];
var num = (this.num = $loop_num++);
(this.cm_name = "$ctx_manager" + num),
(this.cmexit_name = "$ctx_manager_exit" + num);
this.exc_name = "$exc" + num;
var cmtype_name = "$ctx_mgr_type" + num,
cmenter_name = "$ctx_manager_enter" + num,
err_name = "$err" + num;
var js =
"var " +
this.cm_name +
" = $locals." +
this.cm_name +
" = " +
expr.to_js() +
",";
new_nodes.push($NodeJS(js));
new_nodes.push(
$NodeJS(
" " + cmtype_name + " = _b_.type.$factory(" + this.cm_name + "),"
)
);
new_nodes.push(
$NodeJS(
" " +
this.cmexit_name +
" = $B.$call($B.$getattr(" +
cmtype_name +
', "__aexit__")),'
)
);
new_nodes.push(
$NodeJS(
" " +
cmenter_name +
" = $B.$call($B.$getattr(" +
cmtype_name +
', "__aenter__"))' +
"(" +
this.cm_name +
"),"
)
);
new_nodes.push($NodeJS(" " + this.exc_name + " = false"));
js = "";
if (alias) {
if (alias.tree[0].tree[0].type != "list_or_tuple") {
var js =
alias.tree[0].to_js() +
" = " +
"await ($B.promise(" +
cmenter_name +
"))";
new_nodes.push($NodeJS(js));
} else {
var new_node = new $Node(),
ctx = new $NodeCtx(new_node),
expr = new $ExprCtx(ctx, "left", false);
new_node.parent = scope;
expr.tree.push(alias.tree[0].tree[0]);
alias.tree[0].tree[0].parent = expr;
var assign = new $AssignCtx(expr);
new $RawJSCtx(assign, "await ($B.promise(" + cmenter_name + "))");
new_nodes.push(new_node);
}
} else {
new_nodes.push($NodeJS("await ($B.promise(" + cmenter_name + "))"));
}
var try_node = new $NodeJS("try");
for (var child of node.children) {
try_node.add(child);
}
new_nodes.push(try_node);
var catch_node = new $NodeJS("catch(err)");
new_nodes.push(catch_node);
catch_node.add($NodeJS(this.exc_name + " = true"));
catch_node.add(
$NodeJS("var " + err_name + ' = $B.imported["_sys"].exc_info()')
);
var if_node = $NodeJS(
"if(! await ($B.promise(" +
this.cmexit_name +
"(" +
this.cm_name +
", " +
err_name +
"[0], " +
err_name +
"[1], " +
err_name +
"[2]))))"
);
catch_node.add(if_node);
if_node.add($NodeJS("$B.$raise()"));
var else_node = $NodeJS("if(! " + this.exc_name + ")");
new_nodes.push(else_node);
else_node.add(
$NodeJS(
"await ($B.promise(" +
this.cmexit_name +
"(" +
this.cm_name +
", _b_.None, _b_.None, _b_.None)))"
)
);
node.parent.children.splice(rank, 1);
for (var i = new_nodes.length - 1; i >= 0; i--) {
node.parent.insert(rank, new_nodes[i]);
}
node.children = [];
return 0;
};
$WithCtx.prototype.to_js = function () {
this.js_processed = true;
var indent = $get_node(this).indent,
h = " ".repeat(indent),
num = this.num;
var head = this.prefix == "" ? "var " : this.prefix,
cm_name = "$ctx_manager" + num,
cme_name = head + "$ctx_manager_exit" + num,
exc_name = head + "$exc" + num,
val_name = "$value" + num;
return (
"var " +
cm_name +
" = $locals." +
cm_name +
" = " +
this.tree[0].to_js() +
"\n" +
h +
cme_name +
" = $B.$getattr(" +
cm_name +
',"__exit__")\n' +
h +
"var " +
val_name +
" = $B.$getattr(" +
cm_name +
',"__enter__")()\n' +
h +
exc_name +
" = true\n"
);
};
var $YieldCtx = ($B.parser.$YieldCtx = function (C, is_await) {
this.type = "yield";
this.parent = C;
this.tree = [];
this.is_await = is_await;
this.position = $token.value;
C.tree[C.tree.length] = this;
if (C.type == "list_or_tuple" && C.tree.length > 1) {
$_SyntaxError(C, "non-parenthesized yield");
}
if ($parent_match(C, { type: "annotation" })) {
$_SyntaxError(C, ["'yield' outside function"]);
}
var parent = this;
while (true) {
var list_or_tuple = $parent_match(parent, { type: "list_or_tuple" });
if (list_or_tuple) {
list_or_tuple.yields = list_or_tuple.yields || [];
list_or_tuple.yields.push([this, $pos]);
parent = list_or_tuple;
} else {
break;
}
}
var parent = this;
while (true) {
var set_or_dict = $parent_match(parent, { type: "dict_or_set" });
if (set_or_dict) {
set_or_dict.yields = set_or_dict.yields || [];
set_or_dict.yields.push([this, $pos]);
parent = set_or_dict;
} else {
break;
}
}
var root = $get_module(this);
root.yields_func_check = root.yields_func_check || [];
root.yields_func_check.push([this, $pos]);
var scope = (this.scope = $get_scope(this, true)),
node = $get_node(this);
node.has_yield = this;
var in_comp = $parent_match(this, { type: "comprehension" });
if ($get_scope(this).id.startsWith("lc" + $B.lambda_magic)) {
delete node.has_yield;
}
if (in_comp) {
var outermost_expr = in_comp.tree[0].tree[1];
var parent = C;
while (parent) {
if (parent === outermost_expr) {
break;
}
parent = parent.parent;
}
if (!parent) {
$_SyntaxError(C, ["'yield' inside list comprehension"]);
}
}
var in_lambda = false,
parent = C;
while (parent) {
if (parent.type == "lambda") {
in_lambda = true;
this.in_lambda = true;
break;
}
parent = parent.parent;
}
var parent = node.parent;
while (parent) {
if (
parent.C &&
parent.C.tree.length > 0 &&
parent.C.tree[0].type == "with"
) {
scope.C.tree[0].$has_yield_in_cm = true;
break;
}
parent = parent.parent;
}
if (!in_lambda) {
switch (C.type) {
case "node":
break;
case "assign":
case "list_or_tuple":
break;
default:
$_SyntaxError(C, "yield atom must be inside ()");
}
}
});
$YieldCtx.prototype.ast = function () {
var ast_obj;
if (this.from) {
ast_obj = new ast.YieldFrom(ast_or_obj(this.tree[0]));
} else if (this.tree.length == 1) {
ast_obj = new ast.Yield(ast_or_obj(this.tree[0]));
} else {
ast_obj = new ast.Yield();
}
set_position(ast_obj, this.position);
return ast_obj;
};
$YieldCtx.prototype.toString = function () {
return "(yield) " + (this.from ? "(from) " : "") + this.tree;
};
$YieldCtx.prototype.transition = function (token, value) {
var C = this;
if (token == "from") {
if (C.tree[0].type != "abstract_expr") {
$_SyntaxError(C, "'from' must follow 'yield'");
}
C.from = true;
C.from_num = $B.UUID();
return C.tree[0];
} else {
remove_abstract_expr(C.tree);
}
return $transition(C.parent, token);
};
$YieldCtx.prototype.transform = function (node, rank) {
var parent = node.parent;
while (parent) {
if (parent.ctx_manager_num !== undefined) {
node.parent.insert(
rank + 1,
$NodeJS("$top_frame[1].$has_yield_in_cm = true")
);
break;
}
parent = parent.parent;
}
};
$YieldCtx.prototype.to_js = function () {
if (this.from) {
return `_r${this.from_num}`;
} else {
return "yield " + $to_js(this.tree);
}
};
$YieldCtx.prototype.check_in_function = function () {
if (this.in_lambda) {
return;
}
var scope = $get_scope(this),
in_func = scope.is_function,
func_scope = scope;
if (!in_func && scope.comprehension) {
var parent = scope.parent_block;
while (parent.comprehension) {
parent = parent_block;
}
in_func = parent.is_function;
func_scope = parent;
}
if (!in_func) {
$_SyntaxError(this.parent, ["'yield' outside function"]);
} else {
var def = func_scope.C.tree[0];
if (!this.is_await) {
def.type = "generator";
}
}
};
var $add_line_num = ($B.parser.$add_line_num = function (
node,
rank,
line_info
) {
if (node.type == "module") {
var i = 0;
while (i < node.children.length) {
i += $add_line_num(node.children[i], i);
}
} else if (node.type !== "marker") {
var elt = node.C.tree[0],
offset = 1,
flag = true,
pnode = node,
_line_info;
while (pnode.parent !== undefined) {
pnode = pnode.parent;
}
var mod_id = node.module || pnode.id;
var line_num = node.line_num;
if (line_num === undefined) {
flag = false;
}
if (
(elt.type == "condition" && elt.token == "elif") ||
elt.type == "except" ||
elt.type == "single_kw" ||
elt.type == "case"
) {
flag = false;
}
if (flag) {
_line_info =
line_info === undefined ? line_num + "," + mod_id : line_info;
var js =
';$locals.$line_info = "' +
_line_info +
'";if($locals.$f_trace !== _b_.None){$B.trace_line()};' +
"_b_.None;";
var new_node = new $Node();
new_node.is_line_num = true;
new $NodeJSCtx(new_node, js);
node.parent.insert(rank, new_node);
offset = 2;
}
var i = 0;
while (i < node.children.length) {
i += $add_line_num(node.children[i], i, line_info);
}
return offset;
} else {
return 1;
}
});
function find_scope(name, scope) {
if (scope.binding[name]) {
return scope;
} else if (scope.globals && scope.globals.has(name)) {
return $get_module(scope.C);
} else if (scope.nonlocals && scope.nonlocals.has(name)) {
var parent_block = scope.parent_block;
while (parent_block) {
if (parent_block.binding[name]) {
return parent_block;
}
parent_block = parent_block.parent_block;
}
}
}
var $bind = ($B.parser.$bind = function (name, scope, C) {
name = $mangle(name, C);
if (scope.nonlocals && scope.nonlocals.has(name)) {
var parent_block = scope.parent_block;
while (parent_block) {
if (parent_block.binding[name]) {
return parent_block;
}
parent_block = parent_block.parent_block;
}
return;
}
if (scope.globals && scope.globals.has(name)) {
var module = $get_module(C);
module.binding[name] = true;
return module;
}
if (!C.no_bindings) {
var node = $get_node(C);
node.bindings = node.bindings || {};
node.bindings[name] = true;
}
scope.binding = scope.binding || {};
if (!scope.binding.hasOwnProperty(name)) {
scope.binding[name] = true;
}
scope.varnames = scope.varnames || {};
if (scope.varnames[name] === undefined) {
scope.varnames[name] = true;
}
return scope;
});
function $parent_match(ctx, obj) {
var flag;
while (ctx.parent) {
flag = true;
for (var attr in obj) {
if (ctx.parent[attr] != obj[attr]) {
flag = false;
break;
}
}
if (flag) {
return ctx.parent;
}
ctx = ctx.parent;
}
return false;
}
var $previous = ($B.parser.$previous = function (C) {
var previous = C.node.parent.children[C.node.parent.children.length - 2];
if (!previous || !previous.C) {
$_SyntaxError(C, "keyword not following correct keyword");
}
return previous.C.tree[0];
});
var $get_docstring = ($B.parser.$get_docstring = function (node) {
var doc_string = "";
if (node.children.length > 0) {
var firstchild = node.children[0];
if (
firstchild.C.tree &&
firstchild.C.tree.length > 0 &&
firstchild.C.tree[0].type == "expr"
) {
var expr = firstchild.C.tree[0].tree[0];
if (expr.type == "str" && !Array.isArray(expr.tree[0])) {
doc_string = firstchild.C.tree[0].tree[0].to_js();
}
}
}
return doc_string;
});
var $get_scope = ($B.parser.$get_scope = function (C, flag) {
var ctx_node = C.parent;
while (true) {
if (ctx_node.type === "node") {
break;
} else if (ctx_node.comprehension) {
return ctx_node;
}
ctx_node = ctx_node.parent;
}
var tree_node = ctx_node.node,
scope = null;
while (tree_node.parent && tree_node.parent.type !== "module") {
var ntype = tree_node.parent.C.tree[0].type;
switch (ntype) {
case "def":
case "class":
case "generator":
var scope = tree_node.parent;
scope.ntype = ntype;
scope.is_function = ntype != "class";
return scope;
}
tree_node = tree_node.parent;
}
var scope = tree_node.parent || tree_node;
scope.ntype = "module";
return scope;
});
var $get_line_num = ($B.parser.$get_line_num = function (C) {
var ctx_node = $get_node(C),
line_num = ctx_node.line_num;
if (ctx_node.line_num === undefined) {
ctx_node = ctx_node.parent;
while (ctx_node && ctx_node.line_num === undefined) {
ctx_node = ctx_node.parent;
}
if (ctx_node && ctx_node.line_num) {
line_num = ctx_node.line_num;
}
}
return line_num;
});
var $get_module = ($B.parser.$get_module = function (C) {
var ctx_node = C instanceof $NodeCtx ? C : C.parent;
while (ctx_node.type !== "node") {
ctx_node = ctx_node.parent;
}
var tree_node = ctx_node.node;
if (tree_node.ntype == "module") {
return tree_node;
}
var scope = null;
while (tree_node.parent.type != "module") {
tree_node = tree_node.parent;
}
scope = tree_node.parent;
scope.ntype = "module";
return scope;
});
var $get_src = ($B.parser.$get_src = function (C) {
var node = $get_node(C);
while (node.parent !== undefined) {
node = node.parent;
}
return node.src;
});
var $get_node = ($B.parser.$get_node = function (C) {
var ctx = C;
while (ctx.parent) {
ctx = ctx.parent;
}
return ctx.node;
});
var $to_js_map = ($B.parser.$to_js_map = function (tree_element) {
if (tree_element.to_js !== undefined) {
return tree_element.to_js();
}
console.log("no to_js", tree_element);
throw Error("no to_js() for " + tree_element);
});
var $to_js = ($B.parser.$to_js = function (tree, sep) {
if (sep === undefined) {
sep = ",";
}
try {
return tree.map($to_js_map).join(sep);
} catch (err) {
console.log("error", err, "\ntree", tree);
throw err;
}
});
var $mangle = ($B.parser.$mangle = function (name, C) {
if (name.substr(0, 2) == "__" && name.substr(name.length - 2) !== "__") {
var klass = null,
scope = $get_scope(C);
while (true) {
if (scope.ntype == "module") {
return name;
} else if (scope.ntype == "class") {
var class_name = scope.C.tree[0].name;
while (class_name.charAt(0) == "_") {
class_name = class_name.substr(1);
}
return "_" + class_name + name;
} else {
if (scope.parent && scope.parent.C) {
scope = $get_scope(scope.C.tree[0]);
} else {
return name;
}
}
}
} else {
return name;
}
});
$B.nb_debug_lines = 0;
var $transition = ($B.parser.$transition = function (C, token, value) {
if ($B.nb_debug_lines > 100) {
alert("too many debug lines");
$B.nb_debug_lines = 0;
}
if ($B.track_transitions) {
console.log("C", C, "token", token, value, "$pos", $pos);
$B.nb_debug_lines++;
}
return C.transition(token, value);
});
$B.forbidden = [];
$B.aliased_names = Object.create(null);
var s_escaped = 'abfnrtvxuU"0123456789' + "'" + "\\",
is_escaped = {};
for (var i = 0; i < s_escaped.length; i++) {
is_escaped[s_escaped.charAt(i)] = true;
}
function SurrogatePair(value) {
value = value - 0x10000;
return (
String.fromCharCode(0xd800 | (value >> 10)) +
String.fromCharCode(0xdc00 | (value & 0x3ff))
);
}
function test_num(num_lit) {
var len = num_lit.length,
pos = 0,
char,
elt = null,
subtypes = { b: "binary", o: "octal", x: "hexadecimal" },
digits_re = /[_\d]/;
function error(message) {
throw SyntaxError(message);
}
function check(elt) {
if (elt.value.length == 0) {
var t = subtypes[elt.subtype] || "decimal";
error("invalid " + t + " literal");
} else if (elt.value[elt.value.length - 1].match(/[\-+_]/)) {
var t = subtypes[elt.subtype] || "decimal";
error("invalid " + t + " literal");
} else {
elt.value = elt.value.replace(/_/g, "");
elt.length = pos;
return elt;
}
}
while (pos < len) {
var char = num_lit[pos];
if (char.match(digits_re)) {
if (elt === null) {
elt = { value: char };
} else {
if (char == "_" && elt.value.match(/[._+\-]$/)) {
error("consecutive _ at " + pos);
} else if (
char == "_" &&
elt.subtype == "float" &&
elt.value.match(/e$/i)
) {
error("syntax error");
} else if (elt.subtype == "b" && !char.match(/[01_]/)) {
error(`invalid digit '${char}' in binary literal`);
} else if (elt.subtype == "o" && !char.match(/[0-7_]/)) {
error(`invalid digit '${char}' in octal literal`);
} else if (
elt.subtype === undefined &&
elt.value.startsWith("0") &&
!char.match(/[0_]/)
) {
error(
"leading zeros in decimal integer literals are not" +
" permitted; use an 0o prefix for octal integers"
);
}
elt.value += char;
}
pos++;
} else if (char.match(/[oxb]/i)) {
if (elt.value == "0") {
elt.subtype = char.toLowerCase();
if (elt.subtype == "x") {
digits_re = /[_\da-fA-F]/;
}
elt.value = "";
pos++;
} else {
error("invalid char " + char);
}
} else if (char == ".") {
if (elt === null) {
error("invalid char in " + num_lit + " pos " + pos + ": " + char);
} else if (elt.subtype === undefined) {
elt.subtype = "float";
if (elt.value.endsWith("_")) {
error("invalid decimal literal");
}
elt.value = elt.value.replace(/_/g, "") + char;
pos++;
} else {
return check(elt);
}
} else if (char.match(/e/i)) {
if (num_lit[pos + 1] === undefined) {
error("nothing after e");
} else if (elt && subtypes[elt.subtype] !== undefined) {
error("syntax error");
} else if (elt && elt.value.endsWith("_")) {
error("syntax error");
} else if (num_lit[pos + 1].match(/[+\-0-9_]/)) {
if (elt && elt.value) {
if (elt.exp) {
elt.length = pos;
return elt;
}
elt.subtype = "float";
elt.value += char;
elt.exp = true;
pos++;
} else {
error("unexpected e");
}
} else {
return check(elt);
}
} else if (char.match(/[\+\-]/i)) {
if (elt === null) {
elt = { value: char };
pos++;
} else if (elt.value.search(/e$/i) > -1) {
elt.value += char;
pos++;
} else {
return check(elt);
}
} else if (char.match(/j/i)) {
if (elt && (!elt.subtype || elt.subtype == "float")) {
elt.imaginary = true;
check(elt);
elt.length++;
return elt;
} else {
error("invalid syntax");
}
} else {
break;
}
}
return check(elt);
}
var opening = { ")": "(", "}": "{", "]": "[" };
function line_ends_with_comma(src) {
var expect = ":",
braces = [];
for (token of $B.tokenizer(src)) {
if (expect == ":") {
if (token.type == "OP" && token.string == ":" && braces.length == 0) {
expect = "eol";
} else if (token.type == "OP") {
if ("([{".indexOf(token.string) > -1) {
braces.push(token);
} else if (")]}".indexOf(token.string) > -1) {
if (braces.length == 0) {
var err = SyntaxError(`unmatched '${token.string}'`);
err.offset = token.start[1];
throw err;
} else if ($B.last(braces).string != opening[token.string]) {
var err = SyntaxError(
"closing parenthesis " +
`'${token.string}' does not match opening ` +
`parenthesis '${$B.last(braces).string}'`
);
err.offset = token.start[1];
throw err;
} else {
braces.pop();
}
}
} else if (token.type == "NEWLINE") {
return false;
}
} else {
return token.type == "NEWLINE";
}
}
return false;
}
function prepare_number(n) {
n = n.replace(/_/g, "");
if (n.startsWith(".")) {
if (n.endsWith("j")) {
return {
type: "imaginary",
value: prepare_number(n.substr(0, n.length - 1)),
};
} else {
return { type: "float", value: n };
}
pos = j;
} else if (n.startsWith("0") && n != "0") {
var num = test_num(n),
base;
if (num.imaginary) {
return { type: "imaginary", value: prepare_number(num.value) };
}
if (num.subtype == "float") {
return { type: num.subtype, value: num.value };
}
if (num.subtype === undefined) {
base = 10;
} else {
base = { b: 2, o: 8, x: 16 }[num.subtype];
}
if (base !== undefined) {
return { type: "int", value: [base, num.value] };
}
} else {
var num = test_num(n);
if (num.subtype == "float") {
if (num.imaginary) {
return {
type: "imaginary",
value: prepare_number(num.value),
};
} else {
return {
type: "float",
value: num.value,
};
}
} else {
if (num.imaginary) {
return {
type: "imaginary",
value: prepare_number(num.value),
};
} else {
return {
type: "int",
value: [10, num.value],
};
}
}
}
}
function test_escape(C, text, string_start, antislash_pos) {
var seq_end, mo;
mo = /^[0-7]{1,3}/.exec(text.substr(antislash_pos + 1));
if (mo) {
return [String.fromCharCode(parseInt(mo[0], 8)), 1 + mo[0].length];
}
switch (text[antislash_pos + 1]) {
case "x":
var mo = /^[0-9A-F]{0,2}/i.exec(text.substr(antislash_pos + 2));
if (mo[0].length != 2) {
seq_end = antislash_pos + mo[0].length + 1;
$pos = string_start + seq_end + 2;
$_SyntaxError(C, [
"(unicode error) 'unicodeescape' codec can't decode " +
`bytes in position ${antislash_pos}-${seq_end}: truncated ` +
"\\xXX escape",
]);
} else {
return [String.fromCharCode(parseInt(mo[0], 16)), 2 + mo[0].length];
}
case "u":
var mo = /^[0-9A-F]{0,4}/i.exec(text.substr(antislash_pos + 2));
if (mo[0].length != 4) {
seq_end = antislash_pos + mo[0].length + 1;
$pos = string_start + seq_end + 2;
$_SyntaxError(C, [
"(unicode error) 'unicodeescape' codec can't decode " +
`bytes in position ${antislash_pos}-${seq_end}: truncated ` +
"\\uXXXX escape",
]);
} else {
return [String.fromCharCode(parseInt(mo[0], 16)), 2 + mo[0].length];
}
case "U":
var mo = /^[0-9A-F]{0,8}/i.exec(text.substr(antislash_pos + 2));
if (mo[0].length != 8) {
seq_end = antislash_pos + mo[0].length + 1;
$pos = string_start + seq_end + 2;
$_SyntaxError(C, [
"(unicode error) 'unicodeescape' codec can't decode " +
`bytes in position ${antislash_pos}-${seq_end}: truncated ` +
"\\uXXXX escape",
]);
} else {
var value = parseInt(mo[0], 16);
if (value > 0x10ffff) {
$_SyntaxError("invalid unicode escape " + mo[0]);
} else if (value >= 0x10000) {
return [SurrogatePair(value), 2 + mo[0].length];
} else {
return [String.fromCharCode(value), 2 + mo[0].length];
}
}
}
}
function prepare_string(C, s, position) {
var len = s.length,
pos = 0,
string_modifier,
_type = "string";
while (pos < len) {
if (s[pos] == '"' || s[pos] == "'") {
quote = s[pos];
string_modifier = s.substr(0, pos);
if (s.substr(pos, 3) == quote.repeat(3)) {
_type = "triple_string";
inner = s.substring(pos + 3, s.length - 3);
} else {
inner = s.substring(pos + quote.length, len - quote.length);
}
break;
}
pos++;
}
var result = { quote };
var mods = { r: "raw", f: "fstring", b: "bytes" };
for (var mod of string_modifier) {
result[mods[mod]] = true;
}
var raw = C.type == "str" && C.raw,
string_start = $pos + pos + 1,
bytes = false,
fstring = false,
sm_length,
end = null;
if (string_modifier) {
switch (string_modifier) {
case "r":
raw = true;
break;
case "u":
break;
case "b":
bytes = true;
break;
case "rb":
case "br":
bytes = true;
raw = true;
break;
case "f":
fstring = true;
sm_length = 1;
break;
case "fr":
case "rf":
fstring = true;
sm_length = 2;
raw = true;
break;
}
string_modifier = false;
}
var escaped = false,
zone = "",
end = 0,
src = inner;
while (end < src.length) {
if (escaped) {
if (src.charAt(end) == "a" && !raw) {
zone = zone.substr(0, zone.length - 1) + "\u0007";
} else {
zone += src.charAt(end);
if (raw && src.charAt(end) == "\\") {
zone += "\\";
}
}
escaped = false;
end++;
} else if (src.charAt(end) == "\\") {
if (raw) {
if (end < src.length - 1 && src.charAt(end + 1) == quote) {
zone += "\\\\" + quote;
end += 2;
} else {
zone += "\\\\";
end++;
}
escaped = true;
} else {
if (src.charAt(end + 1) == "\n") {
end += 2;
} else if (src.substr(end + 1, 2) == "N{") {
var end_lit = end + 3,
re = new RegExp("[-a-zA-Z0-9 ]+"),
search = re.exec(src.substr(end_lit));
if (search === null) {
$_SyntaxError(
C,
"(unicode error) " + "malformed \\N character escape",
pos
);
}
var end_lit = end_lit + search[0].length;
if (src.charAt(end_lit) != "}") {
$_SyntaxError(
C,
"(unicode error) " + "malformed \\N character escape"
);
}
var description = search[0].toUpperCase();
if ($B.unicodedb === undefined) {
var xhr = new XMLHttpRequest();
xhr.open("GET", $B.brython_path + "unicode.txt", false);
xhr.onreadystatechange = function () {
if (this.readyState == 4) {
if (this.status == 200) {
$B.unicodedb = this.responseText;
} else {
console.log("Warning - could not " + "load unicode.txt");
}
}
};
xhr.send();
}
if ($B.unicodedb !== undefined) {
var re = new RegExp("^([0-9A-F]+);" + description + ";.*$", "m");
search = re.exec($B.unicodedb);
if (search === null) {
$_SyntaxError(
C,
"(unicode error) " + "unknown Unicode character name"
);
}
var cp = "0x" + search[1];
zone += String.fromCodePoint(eval(cp));
end = end_lit + 1;
} else {
end++;
}
} else {
var esc = test_escape(C, src, string_start, end);
if (esc) {
if (esc[0] == "\\") {
zone += "\\\\";
} else {
zone += esc[0];
}
end += esc[1];
} else {
if (
end < src.length - 1 &&
is_escaped[src.charAt(end + 1)] === undefined
) {
zone += "\\";
}
zone += "\\";
escaped = true;
end++;
}
}
}
} else if (src.charAt(end) == "\n" && _type != "triple_string") {
console.log(pos, end, src.substring(pos, end));
$_SyntaxError(C, ["EOL while scanning string literal"]);
} else {
zone += src.charAt(end);
end++;
}
}
var $string = zone,
string = "";
for (var i = 0; i < $string.length; i++) {
var $car = $string.charAt(i);
if ($car == quote) {
if (raw || i == 0 || $string.charAt(i - 1) != "\\") {
string += "\\";
} else if (_type == "triple_string") {
var j = i - 1;
while ($string.charAt(j) == "\\") {
j--;
}
if ((i - j - 1) % 2 == 0) {
string += "\\";
}
}
}
string += $car;
}
if (fstring) {
try {
var re = new RegExp("\\\\" + quote, "g"),
string_no_bs = string.replace(re, quote);
var elts = $B.parse_fstring(string_no_bs);
} catch (err) {
if (err.position) {
$pos += err.position;
}
$_SyntaxError(C, [err.message]);
}
}
if (bytes) {
result.value = "b" + quote + string + quote;
} else if (fstring) {
result.value = elts;
} else {
result.value = quote + string + quote;
}
C.raw = raw;
return result;
}
function unindent(src) {
var lines = src.split("\n"),
line,
global_indent,
indent,
unindented_lines = [];
for (var line_num = 0, len = lines.length; line_num < len; line_num++) {
line = lines[line_num];
indent = line.match(/^\s*/)[0];
if (indent != line) {
if (global_indent === undefined) {
if (indent.length == 0) {
return src;
}
global_indent = indent;
var start = global_indent.length;
unindented_lines.push(line.substr(start));
} else if (line.startsWith(global_indent)) {
unindented_lines.push(line.substr(start));
} else {
throw SyntaxError(
"first line starts at " +
`column ${start}, line ${line_num} at column ` +
line.match(/\s*/).length +
"\n " +
line
);
}
} else {
unindented_lines.push("");
}
}
return unindented_lines.join("\n");
}
function handle_errortoken(C, token) {
if (token.string == "'" || token.string == '"') {
$_SyntaxError(C, [
"unterminated string literal " + `(detected at line ${token.start[0]})`,
]);
}
$_SyntaxError(C, "invalid token " + token[1] + _b_.ord(token[1]));
}
var python_keywords = [
"class",
"return",
"break",
"for",
"lambda",
"try",
"finally",
"raise",
"def",
"from",
"nonlocal",
"while",
"del",
"global",
"with",
"as",
"elif",
"else",
"if",
"yield",
"assert",
"import",
"except",
"raise",
"in",
"pass",
"with",
"continue",
"__debugger__",
"async",
"await",
];
var $token = {};
var dispatch_tokens = ($B.parser.dispatch_tokens = function (root) {
var src = root.src;
var tokenizer = $B.tokenizer(src);
var braces_close = { ")": "(", "]": "[", "}": "{" },
braces_open = "([{",
braces_stack = [];
var unsupported = [];
var $indented = [
"class",
"def",
"for",
"condition",
"single_kw",
"try",
"except",
"with",
"match",
"case",
];
var module = root.module;
var lnum = root.line_num === undefined ? 1 : root.line_num;
var node = new $Node();
node.line_num = lnum;
root.add(node);
var C = null,
expect_indent = false,
indent = 0;
var line2pos = { 0: 0, 1: 0 },
line_num = 1;
for (var pos = 0, len = src.length; pos < len; pos++) {
if (src[pos] == "\n") {
line_num++;
line2pos[line_num] = pos + 1;
}
}
while (true) {
try {
var token = tokenizer.next();
} catch (err) {
C = C || new $NodeCtx(node);
if (err.type == "IndentationError") {
$pos = line2pos[err.line_num];
$_SyntaxError(C, err.message, 1);
} else if (err instanceof SyntaxError) {
if (braces_stack.length > 0) {
var last_brace = $B.last(braces_stack),
start = last_brace.start;
C.$pos = line2pos[start[0]] + start[1];
$_SyntaxError(C, [`'${last_brace.string}' was ` + "never closed"]);
}
$_SyntaxError(C, err.message);
}
throw err;
}
if (token.done) {
throw Error("token done without ENDMARKER.");
}
token = token.value;
$token.value = token;
if (token[2] === undefined) {
console.log("token incomplet", token, "module", module, root);
console.log("src", src);
}
if (token.start === undefined) {
console.log("no start", token);
}
lnum = token.start[0];
$pos = line2pos[lnum] + token.start[1];
if (
expect_indent &&
["INDENT", "COMMENT", "NL"].indexOf(token.type) == -1
) {
C = C || new $NodeCtx(node);
$_SyntaxError(C, "expected an indented block", expect_indent);
}
switch (token.type) {
case "ENDMARKER":
if (root.yields_func_check) {
var save_pos = $pos;
for (const _yield of root.yields_func_check) {
$pos = _yield[1];
_yield[0].check_in_function();
}
$pos = save_pos;
}
if (indent != 0) {
$_SyntaxError(node.C, "expected an indented block", 1);
}
if (node.C === undefined || node.C.tree.length == 0) {
node.parent.children.pop();
}
return;
case "ENCODING":
case "TYPE_COMMENT":
continue;
case "NL":
if (!node.C || node.C.tree.length == 0) {
node.line_num++;
}
continue;
case "COMMENT":
var end = line2pos[token.end[0]] + token.end[1];
root.comments.push([$pos, end - $pos]);
continue;
case "ERRORTOKEN":
C = C || new $NodeCtx(node);
if (token.string != " ") {
handle_errortoken(C, token);
}
continue;
}
switch (token[0]) {
case "NAME":
case "NUMBER":
case "OP":
case "STRING":
C = C || new $NodeCtx(node);
}
switch (token[0]) {
case "NAME":
var name = token[1];
if (python_keywords.indexOf(name) > -1) {
if (unsupported.indexOf(name) > -1) {
$_SyntaxError(C, "Unsupported Python keyword '" + name + "'");
}
C = $transition(C, name);
} else if (name == "not") {
C = $transition(C, "not");
} else if (typeof $operators[name] == "string") {
C = $transition(C, "op", name);
} else {
C = $transition(C, "id", name);
}
continue;
case "OP":
var op = token[1];
if (
(op.length == 1 && "()[]{}.,=".indexOf(op) > -1) ||
[":="].indexOf(op) > -1
) {
if (braces_open.indexOf(op) > -1) {
braces_stack.push(token);
} else if (braces_close[op]) {
if (braces_stack.length == 0) {
$_SyntaxError(C, "unmatched '" + op + "'");
} else {
var last_brace = $B.last(braces_stack);
if (last_brace.string == braces_close[op]) {
braces_stack.pop();
} else {
$_SyntaxError(C, [
`closing parenthesis '${op}' does not ` +
`match opening parenthesis '` +
`${last_brace.string}'`,
]);
}
}
}
C = $transition(C, token[1]);
} else if (op == ":") {
C = $transition(C, ":");
if (C.node && C.node.is_body_node) {
node = C.node;
}
} else if (op == "...") {
C = $transition(C, "ellipsis");
} else if (op == "->") {
C = $transition(C, "annotation");
} else if (op == ";") {
if (C.type == "node" && C.tree.length == 0) {
$_SyntaxError(C, "statement cannot start with ;");
}
$transition(C, "eol");
var new_node = new $Node();
new_node.line_num = token[2][0] + 1;
C = new $NodeCtx(new_node);
node.parent.add(new_node);
node = new_node;
} else if ($augmented_assigns[op]) {
C = $transition(C, "augm_assign", op);
} else {
C = $transition(C, "op", op);
}
continue;
case "STRING":
var prepared = prepare_string(C, token[1], token[2]);
if (prepared.value instanceof Array) {
C = $transition(C, "JoinedStr", prepared.value);
} else {
C = $transition(C, "str", prepared.value);
}
continue;
case "NUMBER":
try {
var prepared = prepare_number(token[1]);
} catch (err) {
$_SyntaxError(C, [err.message]);
}
C = $transition(C, prepared.type, prepared.value);
continue;
case "NEWLINE":
if (C && C.node && C.node.is_body_node) {
expect_indent = C.node.parent;
}
C = C || new $NodeCtx(node);
$transition(C, "eol");
var new_node = new $Node();
new_node.line_num = token[2][0] + 1;
if (
node.parent.children.length > 0 &&
node.parent.children[0].is_body_node
) {
node.parent.parent.add(new_node);
} else {
node.parent.add(new_node);
}
C = new $NodeCtx(new_node);
node = new_node;
continue;
case "DEDENT":
indent--;
node.parent.children.pop();
node.parent.parent.add(node);
C = new $NodeCtx(node);
continue;
case "INDENT":
indent++;
if (!expect_indent) {
C = C || new $NodeCtx(node);
$_SyntaxError(C, "unexpected indent", $pos);
}
expect_indent = false;
continue;
}
}
});
var $create_root_node = ($B.parser.$create_root_node = function (
src,
module,
locals_id,
parent_block,
line_num
) {
var root = new $Node("module");
root.module = module;
root.id = locals_id;
root.binding = {
__doc__: true,
__name__: true,
__file__: true,
__package__: true,
};
root.parent_block = parent_block;
root.line_num = line_num;
root.indent = -1;
root.comments = [];
root.imports = {};
if (typeof src == "object") {
root.is_comp = src.is_comp;
root.filename = src.filename;
if (src.has_annotations) {
root.binding.__annotations__ = true;
}
src = src.src;
}
src = src.replace(/\r\n/gm, "\n");
if (src.endsWith("\\") && !src.endsWith("\\\\")) {
src = src.substr(0, src.length - 1);
}
if (src.charAt(src.length - 1) != "\n") {
src += "\n";
}
root.src = src;
return root;
});
$B.py2js = function (src, module, locals_id, parent_scope, line_num) {
$pos = 0;
if (typeof module == "object") {
var __package__ = module.__package__;
module = module.__name__;
} else {
var __package__ = "";
}
parent_scope = parent_scope || $B.builtins_scope;
var t0 = new Date().getTime(),
has_annotations = true,
line_info,
ix,
filename;
if (typeof src == "object") {
var has_annotations = src.has_annotations,
line_info = src.line_info || `1,${locals_id}`;
(ix = src.ix), (filename = src.filename);
if (line_info !== undefined) {
line_num = parseInt(line_info.split(",")[0]);
}
src = src.src;
} else if (line_num !== undefined) {
line_info = `${line_num},${module}`;
} else {
line_num = 1;
}
var locals_is_module = Array.isArray(locals_id);
if (locals_is_module) {
locals_id = locals_id[0];
}
var local_ns = "$locals_" + locals_id.replace(/\./g, "_"),
global_ns = "$locals_" + module.replace(/\./g, "_"),
root = $create_root_node(
{ src: src, has_annotations: has_annotations, filename: filename },
module,
locals_id,
parent_scope,
line_num
);
dispatch_tokens(root);
if ($B.produce_ast) {
var _ast = root.ast();
if ($B.produce_ast == 2) {
console.log(ast_dump(_ast));
}
if ($B.js_from_ast) {
var symtable = $B._PySymtable_Build(_ast, locals_id);
var js_from_ast = $B.js_from_root(_ast, symtable, filename);
if (true) {
root._ast = _ast;
root.to_js = function () {
return js_from_ast;
};
return root;
}
}
}
if (ix != undefined) {
root.ix = ix;
}
root.transform();
var js =
"var $B = __BRYTHON__,\n" +
" _b_ = __BRYTHON__.builtins,\n" +
" $locals = " +
local_ns +
";\n";
var offset = 0;
root.insert(0, $NodeJS(js));
offset++;
root.insert(
offset++,
$NodeJS(local_ns + '.__package__ = "' + __package__ + '"')
);
if (root.binding.__annotations__) {
root.insert(
offset++,
$NodeJS("$locals.__annotations__ = $B.empty_dict()")
);
}
var enter_frame_pos = offset,
js =
'var $top_frame = ["' +
locals_id.replace(/\./g, "_") +
'", ' +
local_ns +
', "' +
module.replace(/\./g, "_") +
'", ' +
global_ns +
"]\n$locals.$f_trace = $B.enter_frame($top_frame)\n" +
"var $stack_length = $B.frames_stack.length;";
root.insert(offset++, $NodeJS(js));
var try_node = new $NodeJS("try"),
children = root.children.slice(enter_frame_pos + 1, root.children.length);
root.insert(enter_frame_pos + 1, try_node);
if (children.length == 0) {
children = [$NodeJS("")];
}
for (var child of children) {
try_node.add(child);
}
try_node.add($NodeJS("$B.leave_frame({$locals, value: _b_.None})"));
root.children.splice(enter_frame_pos + 2, root.children.length);
var catch_node = $NodeJS("catch(err)");
catch_node.add($NodeJS("$B.leave_frame({$locals, value: _b_.None})"));
catch_node.add($NodeJS("throw err"));
root.add(catch_node);
$add_line_num(root, null, line_info);
var t1 = new Date().getTime();
if ($B.debug > 2) {
if (module == locals_id) {
console.log("module " + module + " translated in " + (t1 - t0) + " ms");
}
}
$B.compile_time += t1 - t0;
return root;
};
$B.set_import_paths = function () {
var meta_path = [],
path_hooks = [];
if ($B.use_VFS) {
meta_path.push($B.finders.VFS);
}
if ($B.$options.static_stdlib_import !== false && $B.protocol != "file") {
meta_path.push($B.finders.stdlib_static);
if ($B.path.length > 3) {
$B.path.shift();
$B.path.shift();
}
}
if ($B.protocol !== "file") {
meta_path.push($B.finders.path);
path_hooks.push($B.url_hook);
}
if ($B.$options.cpython_import) {
if ($B.$options.cpython_import == "replace") {
$B.path.pop();
}
meta_path.push($B.finders.CPython);
}
$B.meta_path = meta_path;
$B.path_hooks = path_hooks;
};
$B.parse_options = function (options) {
if (options === undefined) {
options = { debug: 1 };
} else if (typeof options == "number") {
options = { debug: options };
} else if (typeof options !== "object") {
console.warn("ignoring invalid argument passed to brython():", options);
options = { debug: 1 };
}
if (options.debug === undefined) {
options.debug = 1;
}
$B.debug = options.debug;
_b_.__debug__ = $B.debug > 0;
$B.compile_time = 0;
if (options.profile === undefined) {
options.profile = 0;
}
$B.profile = options.profile;
if (options.indexedDB === undefined) {
options.indexedDB = true;
}
if (options.static_stdlib_import === undefined) {
options.static_stdlib_import = true;
}
$B.static_stdlib_import = options.static_stdlib_import;
$B.$options = options;
$B.set_import_paths();
var $href = ($B.script_path = _window.location.href),
$href_elts = $href.split("/");
$href_elts.pop();
if ($B.isWebWorker || $B.isNode) {
$href_elts.pop();
}
$B.curdir = $href_elts.join("/");
if (options.pythonpath !== undefined) {
$B.path = options.pythonpath;
$B.$options.static_stdlib_import = false;
}
options.python_extension = options.python_extension || ".py";
if (options.python_paths) {
for (var path of options.python_paths) {
var lang, prefetch;
if (typeof path !== "string") {
lang = path.lang;
prefetch = path.prefetch;
path = path.path;
}
$B.path.push(path);
if (
path.slice(-7).toLowerCase() == ".vfs.js" &&
(prefetch === undefined || prefetch === true)
) {
$B.path_importer_cache[path + "/"] =
$B.imported["_importlib"].VFSPathFinder(path);
}
if (lang) {
_importlib.optimize_import_for_path(path, lang);
}
}
}
if (!($B.isWebWorker || $B.isNode)) {
var path_links = document.querySelectorAll("head link[rel~=pythonpath]"),
_importlib = $B.imported["_importlib"];
for (var i = 0, e; (e = path_links[i]); ++i) {
var href = e.href;
if ((" " + e.rel + " ").indexOf(" prepend ") != -1) {
$B.path.unshift(href);
} else {
$B.path.push(href);
}
var filetype = e.hreflang;
if (filetype) {
if (filetype.slice(0, 2) == "x-") {
filetype = filetype.slice(2);
}
_importlib.optimize_import_for_path(e.href, filetype);
}
}
}
if ($B.$options.args) {
$B.__ARGV = $B.$options.args;
} else {
$B.__ARGV = _b_.list.$factory([]);
}
};
if (!($B.isWebWorker || $B.isNode)) {
var observer = new MutationObserver(function (mutations) {
for (var i = 0; i < mutations.length; i++) {
for (var j = 0; j < mutations[i].addedNodes.length; j++) {
checkPythonScripts(mutations[i].addedNodes[j]);
}
}
});
observer.observe(document.documentElement, {
childList: true,
subtree: true,
});
}
function checkPythonScripts(addedNode) {
if (addedNode.tagName == "SCRIPT" && addedNode.type == "text/python") {
var options = {};
for (var attr of addedNode.attributes) {
if (attr.nodeName == "type") {
continue;
} else if (attr.nodeName == "debug") {
options[attr.nodeName] = parseInt(attr.nodeValue);
} else {
options[attr.nodeName] = attr.nodeValue;
}
}
}
}
var brython = ($B.parser.brython = function (options) {
$B.parse_options(options);
if (!($B.isWebWorker || $B.isNode)) {
observer.disconnect();
_run_scripts(options);
}
});
$B.run_script = function (src, name, url, run_loop) {
try {
var root = $B.py2js({ src: src, filename: url }, name, name),
js = root.to_js(),
script = {
__doc__: root.__doc__,
js: js,
__name__: name,
$src: src,
__file__: url,
};
$B.file_cache[script.__file__] = src;
if ($B.debug > 1) {
console.log($B.format_indent(js, 0));
}
} catch (err) {
$B.handle_error(err);
}
if ($B.hasOwnProperty("VFS") && $B.has_indexedDB) {
var imports1 = Object.keys(root.imports).slice(),
imports = imports1.filter(function (item) {
return $B.VFS.hasOwnProperty(item);
});
for (var name of Object.keys(imports)) {
if ($B.VFS.hasOwnProperty(name)) {
var submodule = $B.VFS[name],
type = submodule[0];
if (type == ".py") {
var src = submodule[1],
subimports = submodule[2],
is_package = submodule.length == 4;
if (type == ".py") {
required_stdlib_imports(subimports);
}
for (var mod of subimports) {
if (imports.indexOf(mod) == -1) {
imports.push(mod);
}
}
}
}
}
for (var j = 0; j < imports.length; j++) {
$B.tasks.push([$B.inImported, imports[j]]);
}
root = null;
}
$B.tasks.push(["execute", script]);
if (run_loop) {
$B.loop();
}
};
var $log = ($B.$log = function (js) {
js.split("\n").forEach(function (line, i) {
console.log(i + 1, ":", line);
});
});
var _run_scripts = ($B.parser._run_scripts = function (options) {
if (options === undefined) {
options = {};
}
var kk = Object.keys(_window);
var defined_ids = {},
$elts = [],
webworkers = [];
var ids = options.ids || options.ipy_id;
if (ids !== undefined) {
if (!Array.isArray(ids)) {
throw _b_.ValueError.$factory("ids is not a list");
}
var scripts = [];
for (var id of options.ids) {
var elt = document.getElementById(id);
if (elt === null) {
throw _b_.KeyError.$factory(`no script with id '${id}'`);
}
if (elt.tagName !== "SCRIPT") {
throw _b_.KeyError.$factory(`element ${id} is not a script`);
}
scripts.push(elt);
}
} else {
var scripts = document.getElementsByTagName("script");
}
for (var i = 0; i < scripts.length; i++) {
var script = scripts[i];
if (script.type == "text/python" || script.type == "text/python3") {
if (script.className == "webworker") {
if (script.id === undefined) {
throw _b_.AttributeError.$factory(
"webworker script has no attribute 'id'"
);
}
webworkers.push(script);
} else {
$elts.push(script);
}
}
}
var first_script = true,
module_name;
if (options.ipy_id !== undefined) {
module_name = "__main__";
var $src = "",
js,
root;
for (var elt of $elts) {
$src += elt.innerHTML || elt.textContent;
}
try {
root = $B.py2js($src, module_name, module_name);
js = root.to_js();
if ($B.debug > 1) {
$log(js);
}
eval(js);
$B.clear_ns(module_name);
root = null;
js = null;
} catch ($err) {
root = null;
js = null;
console.log($err);
if ($B.debug > 1) {
console.log($err);
for (var attr in $err) {
console.log(attr + " : ", $err[attr]);
}
}
if ($err.$py_error === undefined) {
console.log("Javascript error", $err);
$err = _b_.RuntimeError.$factory($err + "");
}
var $trace =
$B.$getattr($err, "info") + "\n" + $err.__name__ + ": " + $err.args;
try {
$B.$getattr($B.stderr, "write")($trace);
} catch (print_exc_err) {
console.log($trace);
}
throw $err;
}
} else {
if ($elts.length > 0) {
if (options.indexedDB && $B.has_indexedDB && $B.hasOwnProperty("VFS")) {
$B.tasks.push([$B.idb_open]);
}
}
for (var i = 0; i < $elts.length; i++) {
var elt = $elts[i];
if (elt.id) {
if (defined_ids[elt.id]) {
throw Error(
"Brython error : Found 2 scripts with the " +
"same id '" +
elt.id +
"'"
);
} else {
defined_ids[elt.id] = true;
}
}
}
var src;
for (var i = 0, len = webworkers.length; i < len; i++) {
var worker = webworkers[i];
if (worker.src) {
$B.tasks.push([
$B.ajax_load_script,
{ name: worker.id, url: worker.src, is_ww: true },
]);
} else {
src = worker.innerHTML || worker.textContent;
src = unindent(src);
src = src.replace(/^\n/, "");
$B.webworkers[worker.id] = src;
}
}
for (var i = 0; i < $elts.length; i++) {
var elt = $elts[i];
if (elt.type == "text/python" || elt.type == "text/python3") {
if (elt.id) {
module_name = elt.id;
} else {
if (first_script) {
module_name = "__main__";
first_script = false;
} else {
module_name = "__main__" + $B.UUID();
}
while (defined_ids[module_name] !== undefined) {
module_name = "__main__" + $B.UUID();
}
}
if (elt.src) {
$B.tasks.push([
$B.ajax_load_script,
{ name: module_name, url: elt.src },
]);
} else {
src = elt.innerHTML || elt.textContent;
src = unindent(src);
src = src.replace(/^\n/, "");
$B.tasks.push([
$B.run_script,
src,
module_name,
$B.script_path + "#" + module_name,
true,
]);
}
}
}
}
if (options.ipy_id === undefined) {
$B.loop();
}
});
$B.$operators = $operators;
$B.$Node = $Node;
$B.$NodeJSCtx = $NodeJSCtx;
$B.brython = brython;
})(__BRYTHON__);
var brython = __BRYTHON__.brython;
if (__BRYTHON__.isNode) {
global.__BRYTHON__ = __BRYTHON__;
module.exports = { __BRYTHON__ };
}
(function ($B) {
var _b_ = $B.builtins;
if ($B.VFS_timestamp && $B.VFS_timestamp > $B.timestamp) {
$B.timestamp = $B.VFS_timestamp;
}
function idb_load(evt, module) {
var res = evt.target.result;
var timestamp = $B.timestamp;
if (
res === undefined ||
res.timestamp != $B.timestamp ||
($B.VFS[module] && res.source_ts !== $B.VFS[module].timestamp)
) {
if ($B.VFS[module] !== undefined) {
var elts = $B.VFS[module],
ext = elts[0],
source = elts[1];
if (ext == ".py") {
var imports = elts[2],
is_package = elts.length == 4,
source_ts = elts.timestamp,
__package__;
if (is_package) {
__package__ = module;
} else {
var parts = module.split(".");
parts.pop();
__package__ = parts.join(".");
}
$B.imported[module] = $B.module.$factory(module, "", __package__);
try {
var root = $B.py2js(source, module, module),
js = root.to_js();
} catch (err) {
$B.handle_error(err);
}
delete $B.imported[module];
if ($B.debug > 1) {
console.log("precompile", module);
}
} else {
console.log("bizarre", module, ext);
}
} else {
}
} else {
if (res.is_package) {
$B.precompiled[module] = [res.content];
} else {
$B.precompiled[module] = res.content;
}
if (res.imports.length > 0) {
if ($B.debug > 1) {
console.log(module, "imports", res.imports);
}
var subimports = res.imports.split(",");
for (var i = 0; i < subimports.length; i++) {
var subimport = subimports[i];
if (subimport.startsWith(".")) {
var url_elts = module.split("."),
nb_dots = 0;
while (subimport.startsWith(".")) {
nb_dots++;
subimport = subimport.substr(1);
}
var elts = url_elts.slice(0, nb_dots);
if (subimport) {
elts = elts.concat([subimport]);
}
subimport = elts.join(".");
}
if (
!$B.imported.hasOwnProperty(subimport) &&
!$B.precompiled.hasOwnProperty(subimport)
) {
if ($B.VFS.hasOwnProperty(subimport)) {
var submodule = $B.VFS[subimport],
ext = submodule[0],
source = submodule[1];
if (submodule[0] == ".py") {
$B.tasks.splice(0, 0, [idb_get, subimport]);
} else {
add_jsmodule(subimport, source);
}
}
}
}
}
}
loop();
}
function store_precompiled(module, js, source_ts, imports, is_package) {
var db = $B.idb_cx.result,
tx = db.transaction("modules", "readwrite"),
store = tx.objectStore("modules"),
cursor = store.openCursor(),
data = {
name: module,
content: js,
imports: imports,
origin: origin,
timestamp: __BRYTHON__.timestamp,
source_ts: source_ts,
is_package: is_package,
},
request = store.put(data);
if ($B.debug > 1) {
console.log("store precompiled", module, "package", is_package);
}
document.dispatchEvent(
new CustomEvent("precompile", { detail: "cache module " + module })
);
var ix = $B.outdated.indexOf(module);
if (ix > -1) {
$B.outdated.splice(ix, 1);
}
request.onsuccess = function (evt) {
$B.tasks.splice(0, 0, [idb_get, module]);
loop();
};
}
function idb_get(module) {
var db = $B.idb_cx.result,
tx = db.transaction("modules", "readonly");
try {
var store = tx.objectStore("modules");
req = store.get(module);
req.onsuccess = function (evt) {
idb_load(evt, module);
};
} catch (err) {
console.info("error", err);
}
}
$B.idb_open = function (obj) {
$B.idb_name = "brython-cache";
var idb_cx = ($B.idb_cx = indexedDB.open($B.idb_name));
idb_cx.onsuccess = function () {
var db = idb_cx.result;
if (!db.objectStoreNames.contains("modules")) {
var version = db.version;
db.close();
console.info("create object store", version);
idb_cx = indexedDB.open($B.idb_name, version + 1);
idb_cx.onupgradeneeded = function () {
console.info("upgrade needed");
var db = $B.idb_cx.result,
store = db.createObjectStore("modules", { keyPath: "name" });
store.onsuccess = loop;
};
idb_cx.onversionchanged = function () {
console.log("version changed");
};
idb_cx.onsuccess = function () {
console.info("db opened", idb_cx);
var db = idb_cx.result,
store = db.createObjectStore("modules", { keyPath: "name" });
store.onsuccess = loop;
};
} else {
if ($B.debug > 1) {
console.info("using indexedDB for stdlib modules cache");
}
var tx = db.transaction("modules", "readwrite"),
store = tx.objectStore("modules"),
record,
outdated = [];
var openCursor = store.openCursor();
openCursor.onerror = function (evt) {
console.log("open cursor error", evt);
};
openCursor.onsuccess = function (evt) {
cursor = evt.target.result;
if (cursor) {
record = cursor.value;
if (record.timestamp == $B.timestamp) {
if (
!$B.VFS ||
!$B.VFS[record.name] ||
$B.VFS[record.name].timestamp == record.source_ts
) {
if (record.is_package) {
$B.precompiled[record.name] = [record.content];
} else {
$B.precompiled[record.name] = record.content;
}
if ($B.debug > 1) {
console.info("load from cache", record.name);
}
} else {
outdated.push(record.name);
}
} else {
outdated.push(record.name);
}
cursor.continue();
} else {
if ($B.debug > 1) {
console.log("done");
}
$B.outdated = outdated;
loop();
}
};
}
};
idb_cx.onupgradeneeded = function () {
console.info("upgrade needed");
var db = idb_cx.result,
store = db.createObjectStore("modules", { keyPath: "name" });
store.onsuccess = loop;
};
idb_cx.onerror = function () {
console.info("could not open indexedDB database");
$B.idb_cx = null;
$B.idb_name = null;
$B.$options.indexedDB = false;
loop();
};
};
$B.ajax_load_script = function (script) {
var url = script.url,
name = script.name,
rel_path = url.substr($B.script_dir.length + 1);
if ($B.files && $B.files.hasOwnProperty(rel_path)) {
$B.tasks.splice(0, 0, [
$B.run_script,
atob($B.files[rel_path].content),
name,
url,
true,
]);
loop();
} else if ($B.protocol != "file") {
var req = new XMLHttpRequest(),
qs = $B.$options.cache
? ""
: (url.search(/\?/) > -1 ? "&" : "?") + Date.now();
req.open("GET", url + qs, true);
req.onreadystatechange = function () {
if (this.readyState == 4) {
if (this.status == 200) {
var src = this.responseText;
if (script.is_ww) {
$B.webworkers[name] = src;
} else {
$B.tasks.splice(0, 0, [$B.run_script, src, name, url, true]);
}
loop();
} else if (this.status == 404) {
throw Error(url + " not found");
}
}
};
req.send();
} else {
throw _b_.IOError.$factory(
"can't load external script at " +
script.url +
" (Ajax calls not supported with protocol file:///)"
);
}
};
function add_jsmodule(module, source) {
source += "\nvar $locals_" + module.replace(/\./g, "_") + " = $module";
$B.precompiled[module] = source;
}
var inImported = ($B.inImported = function (module) {
if ($B.imported.hasOwnProperty(module)) {
} else if (__BRYTHON__.VFS && __BRYTHON__.VFS.hasOwnProperty(module)) {
var elts = __BRYTHON__.VFS[module];
if (elts === undefined) {
console.log("bizarre", module);
}
var ext = elts[0],
source = elts[1],
is_package = elts.length == 4;
if (ext == ".py") {
if ($B.idb_cx && !$B.idb_cx.$closed) {
$B.tasks.splice(0, 0, [idb_get, module]);
}
} else {
add_jsmodule(module, source);
}
} else {
console.log("bizarre", module);
}
loop();
});
var loop = ($B.loop = function () {
if ($B.tasks.length == 0) {
if ($B.idb_cx && !$B.idb_cx.$closed) {
var db = $B.idb_cx.result,
tx = db.transaction("modules", "readwrite"),
store = tx.objectStore("modules");
while ($B.outdated.length > 0) {
var module = $B.outdated.pop(),
req = store.delete(module);
req.onsuccess = (function (mod) {
return function (event) {
if ($B.debug > 1) {
console.info("delete outdated", mod);
}
document.dispatchEvent(
new CustomEvent("precompile", {
detail: "remove outdated " + mod + " from cache",
})
);
};
})(module);
}
document.dispatchEvent(
new CustomEvent("precompile", { detail: "close" })
);
$B.idb_cx.result.close();
$B.idb_cx.$closed = true;
}
document.dispatchEvent(
new CustomEvent("brython_done", { detail: $B.obj_dict($B.$options) })
);
return;
}
var task = $B.tasks.shift(),
func = task[0],
args = task.slice(1);
if (func == "execute") {
try {
var script = task[1],
script_id = script.__name__.replace(/\./g, "_"),
module = $B.module.$factory(script.__name__);
module.$src = script.$src;
module.__file__ = script.__file__;
$B.imported[script_id] = module;
new Function("$locals_" + script_id, script.js)(module);
} catch (err) {
if (err.__class__ === undefined) {
console.log("Javascript error", err);
var lineNumber = err.lineNumber;
if (lineNumber !== undefined) {
console.log("around line", lineNumber);
console.log(
script.js
.split("\n")
.slice(lineNumber - 4, lineNumber)
.join("\n")
);
}
if ($B.is_recursion_error(err)) {
err = _b_.RecursionError.$factory("too much recursion");
} else {
$B.print_stack();
err = _b_.RuntimeError.$factory(err + "");
}
}
$B.handle_error(err);
}
loop();
} else {
try {
func.apply(null, args);
} catch (err) {
$B.handle_error(err);
}
}
});
$B.tasks = [];
$B.has_indexedDB = self.indexedDB !== undefined;
function required_stdlib_imports(imports, start) {
var nb_added = 0;
start = start || 0;
for (var i = start; i < imports.length; i++) {
var module = imports[i];
if ($B.imported.hasOwnProperty(module)) {
continue;
}
var mod_obj = $B.VFS[module];
if (mod_obj === undefined) {
console.log("undef", module);
}
if (mod_obj[0] == ".py") {
var subimports = mod_obj[2];
subimports.forEach(function (subimport) {
if (
!$B.imported.hasOwnProperty(subimport) &&
imports.indexOf(subimport) == -1
) {
if ($B.VFS.hasOwnProperty(subimport)) {
imports.push(subimport);
nb_added++;
}
}
});
}
}
if (nb_added) {
required_stdlib_imports(imports, imports.length - nb_added);
}
return imports;
}
})(__BRYTHON__);
__BRYTHON__.builtins.object = (function ($B) {
var _b_ = $B.builtins;
var object = {
$infos: { __name__: "object" },
$is_class: true,
$native: true,
};
var opnames = [
"add",
"sub",
"mul",
"truediv",
"floordiv",
"mod",
"pow",
"lshift",
"rshift",
"and",
"xor",
"or",
];
var opsigns = [
"+",
"-",
"*",
"/",
"//",
"%",
"**",
"<<",
">>",
"&",
"^",
"|",
];
object.__delattr__ = function (self, attr) {
if (
self.__dict__ &&
self.__dict__.$string_dict &&
self.__dict__.$string_dict[attr] !== undefined
) {
delete self.__dict__.$string_dict[attr];
return _b_.None;
} else if (self.__dict__ === undefined && self[attr] !== undefined) {
delete self[attr];
return _b_.None;
} else {
var klass = self.__class__;
if (klass) {
var prop = $B.$getattr(klass, attr);
if (prop.__class__ === _b_.property) {
if (prop.__delete__ !== undefined) {
prop.__delete__(self);
return _b_.None;
}
}
}
}
throw $B.attr_error(attr, self);
};
object.__dir__ = function (self) {
var objects;
if (self.$is_class) {
objects = [self].concat(self.__mro__);
} else {
var klass = self.__class__ || $B.get_class(self);
objects = [self, klass].concat(klass.__mro__);
}
var res = [];
for (var i = 0, len = objects.length; i < len; i++) {
for (var attr in objects[i]) {
if (attr.charAt(0) == "$") {
if (attr.charAt(1) == "$") {
res.push(attr.substr(2));
}
continue;
}
if (!isNaN(parseInt(attr.charAt(0)))) {
continue;
}
if (attr == "__mro__") {
continue;
}
res.push(attr);
}
}
if (self.__dict__) {
for (var attr in self.__dict__.$string_dict) {
if (attr.charAt(0) != "$") {
res.push(attr);
}
}
}
res = _b_.list.$factory(_b_.set.$factory(res));
_b_.list.sort(res);
return res;
};
object.__eq__ = function (self, other) {
if (self === other) {
return true;
}
return _b_.NotImplemented;
};
object.__format__ = function () {
var $ = $B.args(
"__format__",
2,
{ self: null, spec: null },
["self", "spec"],
arguments,
{},
null,
null
);
if ($.spec !== "") {
throw _b_.TypeError.$factory(
"non-empty format string passed to object.__format__"
);
}
return _b_.getattr($.self, "__str__")();
};
object.__ge__ = function () {
return _b_.NotImplemented;
};
object.__getattribute__ = function (obj, attr) {
var klass = obj.__class__ || $B.get_class(obj),
is_own_class_instance_method = false;
var $test = false;
if ($test) {
console.log("attr", attr, "de", obj, "klass", klass);
}
if (attr === "__class__") {
return klass;
}
var res = obj[attr];
if (Array.isArray(obj) && Array.prototype[attr] !== undefined) {
res = undefined;
}
if (res === undefined && obj.__dict__) {
var dict = obj.__dict__;
if (dict.$string_dict.hasOwnProperty(attr)) {
if ($test) {
console.log("__dict__ hasOwnProperty", attr, dict.$string_dict[attr]);
}
return dict.$string_dict[attr][0];
}
}
if (res === undefined) {
function check(obj, kl, attr) {
var v = kl[attr];
if (v !== undefined) {
return v;
}
}
res = check(obj, klass, attr);
if (res === undefined) {
var mro = klass.__mro__;
for (var i = 0, len = mro.length; i < len; i++) {
res = check(obj, mro[i], attr);
if (res !== undefined) {
if ($test) {
console.log("found in", mro[i]);
}
break;
}
}
} else {
if (res.__class__ !== $B.method && res.__get__ === undefined) {
is_own_class_instance_method = true;
}
}
} else {
if (res.__set__ === undefined) {
return res;
}
}
if (res !== undefined) {
if ($test) {
console.log(res);
}
if (res.__class__ && _b_.issubclass(res.__class__, _b_.property)) {
return $B.$getattr(res, "__get__")(obj, klass);
}
if (res.__class__ === $B.method) {
if ($test) {
console.log("res is method");
}
if (res.__get__ === undefined) {
console.log("bizarre", obj, attr, res);
}
return res.__get__(obj, klass);
}
var get = res.__get__;
if (get === undefined && res.__class__) {
var get = res.__class__.__get__;
for (
var i = 0;
i < res.__class__.__mro__.length && get === undefined;
i++
) {
get = res.__class__.__mro__[i].__get__;
}
}
if ($test) {
console.log("get", get);
}
var __get__ =
get === undefined ? null : $B.$getattr(res, "__get__", null);
if ($test) {
console.log("__get__", __get__);
}
if (__get__ !== null) {
try {
return __get__.apply(null, [obj, klass]);
} catch (err) {
throw err;
}
}
if (typeof res == "object") {
if (__get__ && typeof __get__ == "function") {
get_func = function (x, y) {
return __get__.apply(x, [y, klass.$factory]);
};
}
}
if (__get__ === null && typeof res == "function") {
__get__ = function (x) {
return x;
};
}
if (__get__ !== null) {
res.__name__ = attr;
if (attr == "__new__" || res.__class__ === $B.builtin_function) {
res.$type = "staticmethod";
}
var res1 = __get__.apply(null, [res, obj, klass]);
if ($test) {
console.log("res", res, "res1", res1);
}
if (typeof res1 == "function") {
if (res1.__class__ === $B.method) {
return res;
}
if (res.$type == "staticmethod") {
return res;
} else {
var self = res.__class__ === $B.method ? klass : obj,
method = function () {
var args = [self];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(arguments[i]);
}
return res.apply(this, args);
};
method.__class__ = $B.method;
method.__get__ = function (obj, cls) {
var clmethod = res.bind(null, cls);
clmethod.__class__ = $B.method;
clmethod.$infos = {
__self__: cls,
__func__: res,
__name__: res.$infos.__name__,
__qualname__: cls.$infos.__name__ + "." + res.$infos.__name__,
};
return clmethod;
};
method.__get__.__class__ = $B.method_wrapper;
method.__get__.$infos = res.$infos;
if (klass.$infos === undefined) {
console.log("no $infos", klass);
console.log($B.last($B.frames_stack));
}
method.$infos = {
__self__: self,
__func__: res,
__name__: attr,
__qualname__: klass.$infos.__name__ + "." + attr,
};
if ($test) {
console.log("return method", method);
}
if (is_own_class_instance_method) {
obj.$method_cache = obj.$method_cache || {};
obj.$method_cache[attr] = [method, res];
}
return method;
}
} else {
return res1;
}
}
return res;
} else {
throw _b_.AttributeError.$factory(attr);
}
};
object.__gt__ = function () {
return _b_.NotImplemented;
};
object.__hash__ = function (self) {
var hash = self.__hashvalue__;
if (hash !== undefined) {
return hash;
}
return (self.__hashvalue__ = $B.$py_next_hash--);
};
object.__init__ = function () {
if (arguments.length == 0) {
throw _b_.TypeError.$factory(
"descriptor '__init__' of 'object' " + "object needs an argument"
);
}
return _b_.None;
};
object.__init_subclass__ = function () {
var $ = $B.args("__init_subclass__", 0, {}, [], arguments, {}, null, null);
return _b_.None;
};
object.__init_subclass__.$type = "staticmethod";
object.__le__ = function () {
return _b_.NotImplemented;
};
object.__lt__ = function () {
return _b_.NotImplemented;
};
object.__mro__ = [];
object.__new__ = function (cls, ...args) {
if (cls === undefined) {
throw _b_.TypeError.$factory("object.__new__(): not enough arguments");
}
var init_func = $B.$getattr(cls, "__init__");
if (init_func === object.__init__) {
if (args.length > 0) {
throw _b_.TypeError.$factory("object() takes no parameters");
}
}
var res = Object.create(null);
$B.update_obj(res, { __class__: cls, __dict__: $B.empty_dict() });
return res;
};
object.__ne__ = function (self, other) {
if (self === other) {
return false;
}
var eq = $B.$getattr(self.__class__ || $B.get_class(self), "__eq__", null);
if (eq !== null) {
var res = $B.$call(eq)(self, other);
if (res === _b_.NotImplemented) {
return res;
}
return !$B.$bool(res);
}
return _b_.NotImplemented;
};
object.__reduce__ = function (self) {
function _reconstructor(cls) {
return $B.$call(cls)();
}
_reconstructor.$infos = { __qualname__: "_reconstructor" };
var res = [_reconstructor];
res.push(
_b_.tuple.$factory([self.__class__].concat(self.__class__.__mro__))
);
var d = $B.empty_dict();
for (var attr in self.__dict__.$string_dict) {
_b_.dict.$setitem(
d.$string_dict,
attr,
self.__dict__.$string_dict[attr][0]
);
}
console.log("object.__reduce__, d", d);
res.push(d);
return _b_.tuple.$factory(res);
};
function __newobj__(cls) {
return $B.$getattr(cls, "__new__").apply(null, arguments);
}
__newobj__.$infos = { __name__: "__newobj__", __qualname__: "__newobj__" };
_b_.__newobj__ = __newobj__;
object.__reduce_ex__ = function (self) {
var res = [__newobj__];
var arg2 = _b_.tuple.$factory([self.__class__]);
if (Array.isArray(self)) {
self.forEach(function (item) {
arg2.push(item);
});
}
res.push(arg2);
var d = $B.empty_dict(),
nb = 0;
if (self.__dict__ === undefined) {
throw _b_.TypeError.$factory(
"cannot pickle '" + $B.class_name(self) + "' object"
);
}
for (var attr in self.__dict__.$string_dict) {
if (attr == "__class__" || attr.startsWith("$")) {
continue;
}
_b_.dict.$setitem(d, attr, self.__dict__.$string_dict[attr][0]);
nb++;
}
if (nb == 0) {
d = _b_.None;
}
res.push(d);
res.push(_b_.None);
return _b_.tuple.$factory(res);
};
object.__repr__ = function (self) {
if (self === object) {
return "<class 'object'>";
}
if (self.__class__ === _b_.type) {
return "<class '" + self.__name__ + "'>";
}
var module = self.__class__.$infos.__module__;
if (
module !== undefined &&
!module.startsWith("$") &&
module !== "builtins"
) {
return (
"<" +
self.__class__.$infos.__module__ +
"." +
$B.class_name(self) +
" object>"
);
} else {
return "<" + $B.class_name(self) + " object>";
}
};
object.__setattr__ = function (self, attr, val) {
if (val === undefined) {
throw _b_.TypeError.$factory(
"can't set attributes of built-in/extension type 'object'"
);
} else if (self.__class__ === object) {
if (object[attr] === undefined) {
throw $B.attr_error(attr, self);
} else {
throw _b_.AttributeError.$factory(
"'object' object attribute '" + attr + "' is read-only"
);
}
}
if (self.__dict__) {
_b_.dict.$setitem(self.__dict__, attr, val);
} else {
self[attr] = val;
}
return _b_.None;
};
object.__setattr__.__get__ = function (obj) {
return function (attr, val) {
object.__setattr__(obj, attr, val);
};
};
object.__setattr__.__str__ = function () {
return "method object.setattr";
};
object.__str__ = function (self) {
var len = arguments.length;
if (len == 0) {
throw _b_.TypeError.$factory(
"descriptor '__str__' of 'object' " + "object needs an argument"
);
} else if (len > 1) {
throw _b_.TypeError.$factory(
"descriptor '__str__' of 'object' " + "expects 1 argument, got " + len
);
} else if (self.$nat == "kw") {
throw _b_.TypeError.$factory(
"descriptor '__str__' of 'object' " + "doesn't accept keyword arguments"
);
}
if (self.$is_class || self.$factory) {
var class_str = $B.$getattr(
self.__class__ || $B.get_class(self),
"__str__",
null
);
if (class_str !== null && class_str !== object.__str__) {
return class_str(self);
}
var class_repr = $B.$getattr(
self.__class__ || $B.get_class(self),
"__repr__",
null
);
if (class_repr !== null && class_repr !== object.__repr__) {
return class_repr(self);
}
} else {
var repr_func = $B.$getattr(self, "__repr__");
return $B.$call(repr_func)();
}
};
object.__subclasshook__ = function () {
return _b_.NotImplemented;
};
object.$factory = function () {
var res = { __class__: object },
args = [res].concat(Array.prototype.slice.call(arguments));
object.__init__.apply(null, args);
return res;
};
$B.set_func_names(object, "builtins");
$B.make_class = function (qualname, factory) {
var A = {
__class__: _b_.type,
__mro__: [object],
$infos: {
__qualname__: qualname,
__name__: $B.last(qualname.split(".")),
},
$is_class: true,
};
A.$factory = factory;
return A;
};
return object;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
$B.$class_constructor = function (
class_name,
class_obj,
bases,
parents_names,
kwargs
) {
bases = bases || [];
var metaclass;
var module = class_obj.__module__;
if (module === undefined) {
module = class_obj.__module__ = $B.last($B.frames_stack)[2];
}
for (var i = 0; i < bases.length; i++) {
if (bases[i] === undefined) {
$B.line_info = class_obj.$def_line;
throw $B.name_error(parents_names[i]);
}
}
var extra_kwargs = {},
prepare_kwargs = {};
if (kwargs) {
for (var i = 0; i < kwargs.length; i++) {
var key = kwargs[i][0],
val = kwargs[i][1];
if (key == "metaclass") {
metaclass = val;
} else {
extra_kwargs[key] = val;
}
prepare_kwargs[key] = val;
}
}
var mro0 = class_obj;
if (class_obj.__eq__ !== undefined && class_obj.__hash__ === undefined) {
class_obj.__hash__ = _b_.None;
}
var orig_bases = bases.slice(),
use_mro_entries = false;
for (var i = 0; i < bases.length; i++) {
if (bases[i] === undefined || bases[i].__mro__ === undefined) {
var mro_entries = $B.$getattr(bases[i], "__mro_entries__", _b_.None);
if (mro_entries !== _b_.None) {
var entries = _b_.list.$factory(mro_entries(bases));
bases.splice(i, 1, ...entries);
use_mro_entries = true;
i--;
continue;
}
}
}
if (metaclass === undefined) {
metaclass = meta_from_bases(class_name, module, bases);
}
var prepare = $B.$getattr(metaclass, "__prepare__", _b_.None),
cl_dict = $B.$call(prepare)(class_name, bases);
if (cl_dict.__class__ !== _b_.dict) {
var set_class_item = $B.$getattr(cl_dict, "__setitem__");
} else {
var set_class_item = function (attr, value) {
cl_dict.$string_dict[attr] = [value, cl_dict.$order++];
};
}
for (var attr in class_obj) {
if (attr == "__annotations__") {
if (cl_dict.$string_dict[attr] === undefined) {
cl_dict.$string_dict[attr] = [$B.empty_dict(), cl_dict.$order++];
}
for (var key in class_obj[attr].$string_dict) {
$B.$setitem(
cl_dict.$string_dict[attr][0],
key,
class_obj[attr].$string_dict[key][0]
);
}
} else {
if (attr.charAt(0) != "$") {
set_class_item(attr, class_obj[attr]);
}
}
}
if (use_mro_entries) {
set_class_item("__orig_bases__", _b_.tuple.$factory(orig_bases));
}
var class_dict = {
__bases__: bases,
__class__: metaclass,
__dict__: cl_dict,
};
if (cl_dict.__class__ === _b_.dict) {
for (var key in cl_dict.$string_dict) {
class_dict[key] = cl_dict.$string_dict[key][0];
}
} else {
var get_class_item = $B.$getattr(cl_dict, "__getitem__");
var it = _b_.iter(cl_dict);
while (true) {
try {
var key = _b_.next(it);
class_dict[key] = get_class_item(key);
} catch (err) {
break;
}
}
}
class_dict.__mro__ = _b_.type.mro(class_dict).slice(1);
var is_instanciable = true,
non_abstract_methods = {},
abstract_methods = {},
mro = [class_dict].concat(class_dict.__mro__);
for (var i = 0; i < mro.length; i++) {
var kdict = i == 0 ? mro0 : mro[i];
for (var attr in kdict) {
if (non_abstract_methods[attr]) {
continue;
}
var v = kdict[attr];
if (typeof v == "function") {
if (
v.__isabstractmethod__ === true ||
(v.$attrs && v.$attrs.__isabstractmethod__)
) {
is_instanciable = false;
abstract_methods[attr] = true;
} else {
non_abstract_methods[attr] = true;
}
} else {
non_abstract_methods[attr] = true;
}
}
}
var _slots = class_obj.__slots__;
if (_slots !== undefined) {
if (typeof _slots == "string") {
_slots = [_slots];
} else {
_slots = _b_.list.$factory(_slots);
}
cl_dict.__slots__ = _slots;
}
for (var i = 0; i < mro.length - 1; i++) {
for (var attr in mro[i]) {
if (attr == "__setattr__") {
cl_dict.$has_setattr = true;
break;
} else if (mro[i][attr]) {
if (
mro[i][attr].__get__ ||
(mro[i][attr].__class__ && mro[i][attr].__class__.__get__)
) {
cl_dict.$has_setattr = true;
break;
}
}
}
}
var meta_new = _b_.type.__getattribute__(metaclass, "__new__");
var kls = meta_new(metaclass, class_name, bases, cl_dict, {
$nat: "kw",
kw: extra_kwargs,
});
kls.__module__ = module;
kls.$infos = {
__module__: module,
__name__: class_name,
__qualname__: class_obj.$qualname,
};
kls.$subclasses = [];
if (kls.__bases__ === undefined || kls.__bases__.length == 0) {
kls.__bases__ = $B.fast_tuple([_b_.object]);
}
for (var attr in class_obj) {
if (attr.charAt(0) != "$") {
if (typeof class_obj[attr] == "function") {
class_obj[attr].$infos.$class = kls;
}
}
}
if (kls.__class__ === metaclass) {
var meta_init = _b_.type.__getattribute__(metaclass, "__init__");
meta_init(kls, class_name, bases, cl_dict);
}
for (var i = 0; i < bases.length; i++) {
bases[i].$subclasses = bases[i].$subclasses || [];
bases[i].$subclasses.push(kls);
}
if (!is_instanciable) {
function nofactory() {
throw _b_.TypeError.$factory(
"Can't instantiate abstract class " +
"interface with abstract methods " +
Object.keys(abstract_methods).join(", ")
);
}
kls.$factory = nofactory;
}
kls.__qualname__ = class_name;
return kls;
};
function meta_from_bases(class_name, module, bases) {
var metaclass;
if (bases && bases.length > 0) {
metaclass = bases[0].__class__;
if (metaclass === undefined) {
if (typeof bases[0] == "function") {
if (bases.length != 1) {
throw _b_.TypeError.$factory(
"A Brython class " +
"can inherit at most 1 Javascript constructor"
);
}
metaclass = bases[0].__class__ = $B.JSMeta;
$B.set_func_names(bases[0], module);
} else {
throw _b_.TypeError.$factory(
"Argument of " +
class_name +
"is not a class (type '" +
$B.class_name(bases[0]) +
"')"
);
}
}
for (var i = 1; i < bases.length; i++) {
var mc = bases[i].__class__;
if (mc === metaclass || _b_.issubclass(metaclass, mc)) {
} else if (_b_.issubclass(mc, metaclass)) {
metaclass = mc;
} else if (
metaclass.__bases__ &&
metaclass.__bases__.indexOf(mc) == -1
) {
throw _b_.TypeError.$factory(
"metaclass conflict: the " +
"metaclass of a derived class must be a (non-" +
"strict) subclass of the metaclasses of all its bases"
);
}
}
} else {
metaclass = _b_.type;
}
return metaclass;
}
var type = $B.make_class("type", function (obj, bases, cl_dict) {
var len = arguments.length;
if (len == 1) {
if (obj === undefined) {
return $B.UndefinedClass;
}
return obj.__class__ || $B.get_class(obj);
} else if (len == 3) {
var module = $B.last($B.frames_stack)[2],
meta = meta_from_bases(obj, module, bases);
return type.__new__(meta, obj, bases, cl_dict);
} else {
throw _b_.TypeError.$factory("type() takes 1 or 3 arguments");
}
});
type.__call__ = function () {
var extra_args = [],
klass = arguments[0];
for (var i = 1, len = arguments.length; i < len; i++) {
extra_args.push(arguments[i]);
}
var new_func = _b_.type.__getattribute__(klass, "__new__");
var instance = new_func.apply(null, arguments),
instance_class = instance.__class__ || $B.get_class(instance);
if (instance_class === klass) {
var init_func = _b_.type.__getattribute__(klass, "__init__");
if (init_func !== _b_.object.__init__) {
var args = [instance].concat(extra_args);
init_func.apply(null, args);
}
}
return instance;
};
type.__class__ = type;
type.__format__ = function (klass, fmt_spec) {
return _b_.str.$factory(klass);
};
type.__getattribute__ = function (klass, attr) {
switch (attr) {
case "__bases__":
var res = klass.__bases__;
res.__class__ = _b_.tuple;
if (res.length == 0) {
}
return res;
case "__class__":
return klass.__class__;
case "__doc__":
return klass.__doc__ || _b_.None;
case "__setattr__":
if (klass["__setattr__"] !== undefined) {
var func = klass["__setattr__"];
} else {
var func = function (obj, key, value) {
obj[key] = value;
};
}
return method_wrapper.$factory(attr, klass, func);
case "__delattr__":
if (klass["__delattr__"] !== undefined) {
return klass["__delattr__"];
}
return method_wrapper.$factory(attr, klass, function (key) {
delete klass[key];
});
}
var res = klass[attr];
var $test = false;
if ($test) {
console.log("attr", attr, "of", klass, res, res + "");
}
if (
res === undefined &&
klass.__slots__ &&
klass.__slots__.indexOf(attr) > -1
) {
return member_descriptor.$factory(attr, klass);
}
if (
klass.__class__ &&
klass.__class__[attr] &&
klass.__class__[attr].__get__ &&
klass.__class__[attr].__set__
) {
if ($test) {
console.log("data descriptor");
}
return klass.__class__[attr].__get__(klass);
}
if (res === undefined) {
var v = klass[attr];
if (v === undefined) {
var mro = klass.__mro__;
if (mro === undefined) {
console.log("pas de mro pour", klass);
}
for (var i = 0; i < mro.length; i++) {
var v = mro[i][attr];
if (v !== undefined) {
res = v;
break;
}
}
} else {
res = v;
}
if (res === undefined) {
var meta = klass.__class__ || $B.get_class(klass),
res = meta[attr];
if ($test) {
console.log("search in meta", meta, res);
}
if (res === undefined) {
var meta_mro = meta.__mro__;
for (var i = 0; i < meta_mro.length; i++) {
var res = meta_mro[i][attr];
if (res !== undefined) {
break;
}
}
}
if (res !== undefined) {
if ($test) {
console.log("found in meta", res, typeof res);
}
if (res.__class__ === _b_.property) {
return res.fget(klass);
}
if (typeof res == "function") {
var meta_method = res.bind(null, klass);
meta_method.__class__ = $B.method;
meta_method.$infos = {
__self__: klass,
__func__: res,
__name__: attr,
__qualname__: klass.$infos.__name__ + "." + attr,
__module__: res.$infos ? res.$infos.__module__ : "",
};
if ($test) {
console.log(
"return method from meta",
meta_method,
meta_method + ""
);
}
return meta_method;
}
}
if (res === undefined) {
var getattr = meta.__getattr__;
if (getattr === undefined) {
for (var i = 0; i < meta_mro.length; i++) {
if (meta_mro[i].__getattr__ !== undefined) {
getattr = meta_mro[i].__getattr__;
break;
}
}
}
if (getattr !== undefined) {
return getattr(klass, attr);
}
}
}
}
if (res !== undefined) {
if ($test) {
console.log("res", res);
}
if (res.__class__ === _b_.property) {
return res;
}
if (res.__get__) {
if (res.__class__ === method) {
var result = res.__get__(res.__func__, klass);
result.$infos = {
__func__: res,
__name__: res.$infos.__name__,
__qualname__: klass.$infos.__name__ + "." + res.$infos.__name__,
__self__: klass,
};
} else {
result = res.__get__(klass);
}
return result;
} else if (res.__class__ && res.__class__.__get__) {
if (!(attr.startsWith("__") && attr.endsWith("__"))) {
return res.__class__.__get__(res, _b_.None, klass);
}
}
if (typeof res == "function") {
if (res.$infos === undefined && $B.debug > 1) {
console.log(
"warning: no attribute $infos for",
res,
"klass",
klass,
"attr",
attr
);
}
if ($test) {
console.log("res is function", res);
}
if (attr == "__new__" || res.__class__ === $B.builtin_function) {
res.$type = "staticmethod";
}
if (attr == "__class_getitem__" && res.__class__ !== $B.method) {
res = _b_.classmethod.$factory(res);
}
if (attr == "__init_subclass__") {
res = _b_.classmethod.$factory(res);
}
if (res.__class__ === $B.method) {
return res.__get__(null, klass);
} else {
if ($test) {
console.log("return res", res);
}
return res;
}
} else {
return res;
}
}
};
type.__hash__ = function (cls) {
return _b_.hash(cls);
};
type.__init__ = function () {
if (arguments.length == 0) {
throw _b_.TypeError.$factory(
"descriptor '__init__' of 'type' " + "object needs an argument"
);
}
};
type.__init_subclass__ = function () {
var $ = $B.args(
"__init_subclass__",
1,
{},
[],
arguments,
{},
"args",
"kwargs"
);
if ($.kwargs !== undefined) {
if (
$.kwargs.__class__ !== _b_.dict ||
Object.keys($.kwargs.$string_dict).length > 0
) {
throw _b_.TypeError.$factory(
"__init_subclass__() takes no keyword arguments"
);
}
}
return _b_.None;
};
type.__instancecheck__ = function (cls, instance) {
var kl = instance.__class__ || $B.get_class(instance);
if (kl === cls) {
return true;
} else {
for (var i = 0; i < kl.__mro__.length; i++) {
if (kl.__mro__[i] === cls) {
return true;
}
}
}
return false;
};
type.__instancecheck__.$type = "staticmethod";
type.__name__ = {
__get__: function (self) {
return self.$infos.__name__;
},
__set__: function (self, value) {
self.$infos.__name__ = value;
},
__str__: function (self) {
return "type";
},
__eq__: function (self, other) {
return self.$infos.__name__ == other;
},
};
type.__new__ = function (meta, name, bases, cl_dict, extra_kwargs) {
extra_kwargs =
extra_kwargs === undefined ? { $nat: "kw", kw: {} } : extra_kwargs;
var module = cl_dict.$string_dict.__module__;
if (module) {
module = module[0];
} else {
module = $B.last($B.frames_stack)[2];
}
var class_dict = {
__class__: meta,
__bases__: bases,
__dict__: cl_dict,
$infos: { __name__: name, __module__: module, __qualname__: name },
$is_class: true,
$has_setattr: cl_dict.$has_setattr,
};
class_dict.__mro__ = type.mro(class_dict).slice(1);
var items = $B.dict_to_list(cl_dict);
for (var i = 0; i < items.length; i++) {
var key = items[i][0],
v = items[i][1];
if (key === "__module__") {
continue;
}
if (v === undefined) {
continue;
}
class_dict[key] = v;
if (v.__class__) {
var set_name = $B.$getattr(v.__class__, "__set_name__", _b_.None);
if (set_name !== _b_.None) {
set_name(v, class_dict, key);
}
}
if (typeof v == "function") {
if (v.$infos === undefined) {
console.log("type new", v, v + "");
console.log($B.frames_stack.slice());
} else {
v.$infos.$class = class_dict;
v.$infos.__qualname__ = name + "." + v.$infos.__name__;
if (v.$infos.$defaults) {
var $defaults = v.$infos.$defaults;
$B.Function.__setattr__(v, "__defaults__", $defaults);
}
}
}
}
var sup = _b_.super.$factory(class_dict, class_dict);
var init_subclass = _b_.super.__getattribute__(sup, "__init_subclass__");
init_subclass(extra_kwargs);
return class_dict;
};
type.__or__ = function () {
var $ = $B.args(
"__or__",
2,
{ cls: null, other: null },
["cls", "other"],
arguments,
{},
null,
null
),
cls = $.cls,
other = $.other;
if (other !== _b_.None && !_b_.isinstance(other, type)) {
return _b_.NotImplemented;
}
return $B.UnionType.$factory([cls, other]);
};
type.__prepare__ = function () {
return $B.empty_dict();
};
type.__qualname__ = {
__get__: function (self) {
return self.$infos.__qualname__ || self.$infos.__name__;
},
__set__: function (self, value) {
self.$infos.__qualname__ = value;
},
__str__: function (self) {
console.log("type.__qualname__");
},
__eq__: function (self, other) {
return self.$infos.__qualname__ == other;
},
};
type.__repr__ = function (kls) {
$B.builtins_repr_check(type, arguments);
if (kls.$infos === undefined) {
console.log("no $infos", kls);
}
var qualname = kls.$infos.__qualname__;
if (
kls.$infos.__module__ &&
kls.$infos.__module__ != "builtins" &&
!kls.$infos.__module__.startsWith("$")
) {
qualname = kls.$infos.__module__ + "." + qualname;
}
return "<class '" + qualname + "'>";
};
type.__ror__ = function () {
var len = arguments.length;
if (len != 1) {
throw _b_.TypeError.$factory(`expected 1 argument, got ${len}`);
}
return _b_.NotImplemented;
};
type.mro = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory(
"unbound method type.mro() needs an argument"
);
}
var bases = cls.__bases__,
seqs = [],
pos1 = 0;
for (var i = 0; i < bases.length; i++) {
if (bases[i] === _b_.str) {
bases[i] = $B.StringSubclass;
}
var bmro = [],
pos = 0;
if (bases[i] === undefined || bases[i].__mro__ === undefined) {
if (bases[i].__class__ === undefined) {
return [_b_.object];
} else {
throw _b_.TypeError.$factory(
"Object passed as base class is not a class"
);
}
}
bmro[pos++] = bases[i];
var _tmp = bases[i].__mro__;
if (_tmp[0] === bases[i]) {
_tmp.splice(0, 1);
}
for (var k = 0; k < _tmp.length; k++) {
bmro[pos++] = _tmp[k];
}
seqs[pos1++] = bmro;
}
seqs[pos1++] = bases.slice();
var mro = [cls],
mpos = 1;
while (1) {
var non_empty = [],
pos = 0;
for (var i = 0; i < seqs.length; i++) {
if (seqs[i].length > 0) {
non_empty[pos++] = seqs[i];
}
}
if (non_empty.length == 0) {
break;
}
for (var i = 0; i < non_empty.length; i++) {
var seq = non_empty[i],
candidate = seq[0],
not_head = [],
pos = 0;
for (var j = 0; j < non_empty.length; j++) {
var s = non_empty[j];
if (s.slice(1).indexOf(candidate) > -1) {
not_head[pos++] = s;
}
}
if (not_head.length > 0) {
candidate = null;
} else {
break;
}
}
if (candidate === null) {
throw _b_.TypeError.$factory(
"inconsistent hierarchy, no C3 MRO is possible"
);
}
mro[mpos++] = candidate;
for (var i = 0; i < seqs.length; i++) {
var seq = seqs[i];
if (seq[0] === candidate) {
seqs[i].shift();
}
}
}
if (mro[mro.length - 1] !== _b_.object) {
mro[mpos++] = _b_.object;
}
return mro;
};
type.__subclasscheck__ = function (self, subclass) {
var klass = self;
if (klass === _b_.str) {
klass = $B.StringSubclass;
} else if (klass === _b_.float) {
klass = $B.FloatSubclass;
}
if (subclass.__bases__ === undefined) {
return self === _b_.object;
}
return subclass.__bases__.indexOf(klass) > -1;
};
$B.set_func_names(type, "builtins");
_b_.type = type;
var wrapper_descriptor = $B.make_class("wrapper_descriptor");
$B.set_func_names(wrapper_descriptor, "builtins");
type.__call__.__class__ = wrapper_descriptor;
var $instance_creator = ($B.$instance_creator = function (klass) {
if (klass.prototype && klass.prototype.constructor == klass) {
return function () {
return new klass(...arguments);
};
}
if (klass.$instanciable !== undefined) {
return function () {
throw _b_.TypeError.$factory(
"Can't instantiate abstract class interface " +
"with abstract methods"
);
};
}
var metaclass = klass.__class__ || $B.get_class(klass),
call_func,
factory;
if (
metaclass === _b_.type &&
(!klass.__bases__ || klass.__bases__.length == 0)
) {
if (klass.hasOwnProperty("__new__")) {
if (klass.hasOwnProperty("__init__")) {
factory = function () {
var obj = klass.__new__.bind(null, klass).apply(null, arguments);
klass.__init__.bind(null, obj).apply(null, arguments);
return obj;
};
} else {
factory = function () {
return klass.__new__.bind(null, klass).apply(null, arguments);
};
}
} else if (klass.hasOwnProperty("__init__")) {
factory = function () {
var obj = { __class__: klass, __dict__: $B.empty_dict() };
klass.__init__.bind(null, obj).apply(null, arguments);
return obj;
};
} else {
factory = function () {
if (arguments.length > 0) {
if (
arguments.length == 1 &&
arguments[0].$nat &&
Object.keys(arguments[0].kw).length == 0
) {
} else {
throw _b_.TypeError.$factory("object() takes no parameters");
}
}
var res = Object.create(null);
$B.update_obj(res, { __class__: klass, __dict__: $B.empty_dict() });
return res;
};
}
} else {
call_func = _b_.type.__getattribute__(metaclass, "__call__");
var factory = function () {
return call_func.bind(null, klass).apply(null, arguments);
};
}
factory.__class__ = $B.Function;
factory.$infos = {
__name__: klass.$infos.__name__,
__module__: klass.$infos.__module__,
};
return factory;
});
var method_wrapper = ($B.method_wrapper = $B.make_class(
"method_wrapper",
function (attr, klass, method) {
var f = function () {
return method.apply(null, arguments);
};
f.$infos = { __name__: attr, __module__: klass.__module__ };
return f;
}
));
method_wrapper.__str__ = method_wrapper.__repr__ = function (self) {
return "<method '" + self.$infos.__name__ + "' of function object>";
};
var member_descriptor = $B.make_class(
"member_descriptor",
function (attr, cls) {
return { __class__: member_descriptor, cls: cls, attr: attr };
}
);
member_descriptor.__str__ = member_descriptor.__repr__ = function (self) {
return (
"<member '" +
self.attr +
"' of '" +
self.cls.$infos.__name__ +
"' objects>"
);
};
$B.set_func_names(member_descriptor, "builtins");
var method = ($B.method = $B.make_class("method", function (func, cls) {
var f = function () {
return $B.$call(func).bind(null, cls).apply(null, arguments);
};
f.__class__ = method;
f.$infos = func.$infos;
return f;
}));
method.__eq__ = function (self, other) {
return (
self.$infos !== undefined &&
other.$infos !== undefined &&
self.$infos.__func__ === other.$infos.__func__ &&
self.$infos.__self__ === other.$infos.__self__
);
};
method.__ne__ = function (self, other) {
return !$B.method.__eq__(self, other);
};
method.__get__ = function (self) {
var f = function () {
return self(arguments);
};
f.__class__ = $B.method_wrapper;
f.$infos = method.$infos;
return f;
};
method.__getattribute__ = function (self, attr) {
var infos = self.$infos;
if (infos && infos[attr]) {
if (attr == "__code__") {
var res = { __class__: $B.Code };
for (var attr in infos.__code__) {
res[attr] = infos.__code__[attr];
}
return res;
} else {
return infos[attr];
}
} else if (method.hasOwnProperty(attr)) {
return _b_.object.__getattribute__(self, attr);
} else {
return $B.Function.__getattribute__(self.$infos.__func__, attr);
}
};
method.__repr__ = method.__str__ = function (self) {
return (
"<bound method " +
self.$infos.__qualname__ +
" of " +
_b_.str.$factory(self.$infos.__self__) +
">"
);
};
method.__setattr__ = function (self, key, value) {
if (key == "__class__") {
throw _b_.TypeError.$factory(
"__class__ assignment only supported " +
"for heap types or ModuleType subclasses"
);
}
throw $B.attr_error(attr, self);
};
$B.set_func_names(method, "builtins");
$B.method_descriptor = $B.make_class("method_descriptor");
$B.classmethod_descriptor = $B.make_class("classmethod_descriptor");
$B.GenericAlias = $B.make_class(
"GenericAlias",
function (origin_class, items) {
return {
__class__: $B.GenericAlias,
origin_class,
items,
};
}
);
$B.GenericAlias.__args__ = {
__get__: function (self) {
return $B.fast_tuple(self.items);
},
};
$B.GenericAlias.__call__ = function (self, ...args) {
return self.origin_class.$factory.apply(null, args);
};
$B.GenericAlias.__eq__ = function (self, other) {
return (
$B.rich_comp("__eq__", self.origin_class, other.origin_class) &&
$B.rich_comp("__eq__", self.items, other.items)
);
};
$B.GenericAlias.__getitem__ = function (self, item) {
throw _b_.TypeError.$factory(
"descriptor '__getitem__' for '" +
self.origin_class.$infos.__name__ +
"' objects doesn't apply to a '" +
$B.class_name(item) +
"' object"
);
};
$B.GenericAlias.__or__ = function (self, other) {
var $ = $B.args(
"__or__",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
);
return $B.UnionType.$factory([self, other]);
};
$B.GenericAlias.__origin__ = {
__get__: function (self) {
return self.origin_class;
},
};
$B.GenericAlias.__parameters__ = {
__get__: function (self) {
return $B.fast_tuple([]);
},
};
$B.GenericAlias.__repr__ = function (self) {
var items = [];
for (var i = 0, len = self.items.length; i < len; i++) {
if (self.items[i] === _b_.Ellipsis) {
items.push("...");
} else {
if (self.items[i].$is_class) {
items.push(self.items[i].$infos.__name__);
} else {
items.push(_b_.repr(self.items[i]));
}
}
}
return self.origin_class.$infos.__qualname__ + "[" + items.join(", ") + "]";
};
$B.set_func_names($B.GenericAlias, "types");
$B.UnionType = $B.make_class("UnionType", function (items) {
return {
__class__: $B.UnionType,
items,
};
});
$B.UnionType.__repr__ = function (self) {
var t = [];
for (var item of self.items) {
if (item.$is_class) {
t.push(item.$infos.__name__);
} else {
t.push(_b_.repr(item));
}
}
return t.join(" | ");
};
$B.set_func_names($B.UnionType, "types");
_b_.object.__class__ = type;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins,
_window = self,
isWebWorker =
"undefined" !== typeof WorkerGlobalScope &&
"function" === typeof importScripts &&
navigator instanceof WorkerNavigator;
$B.args = function (
fname,
argcount,
slots,
var_names,
args,
$dobj,
extra_pos_args,
extra_kw_args
) {
if (fname.startsWith("lambda_" + $B.lambda_magic)) {
fname = "<lambda>";
}
var has_kw_args = false,
nb_pos = args.length,
filled = 0,
extra_kw,
only_positional;
var end_positional = var_names.indexOf("/");
if (end_positional != -1) {
var_names.splice(end_positional, 1);
only_positional = var_names.slice(0, end_positional);
}
if (nb_pos > 0 && args[nb_pos - 1] && args[nb_pos - 1].$nat) {
nb_pos--;
if (Object.keys(args[nb_pos].kw).length > 0) {
has_kw_args = true;
var kw_args = args[nb_pos].kw;
if (Array.isArray(kw_args)) {
var kwa = kw_args[0];
for (var i = 1, len = kw_args.length; i < len; i++) {
var kw_arg = kw_args[i];
if (kw_arg.__class__ === _b_.dict) {
for (var k in kw_arg.$numeric_dict) {
throw _b_.TypeError.$factory(
fname + "() keywords must be strings"
);
}
for (var k in kw_arg.$object_dict) {
throw _b_.TypeError.$factory(
fname + "() keywords must be strings"
);
}
for (var k in kw_arg.$string_dict) {
if (kwa[k] !== undefined) {
throw _b_.TypeError.$factory(
fname + "() got multiple values for argument '" + k + "'"
);
}
kwa[k] = kw_arg.$string_dict[k][0];
}
} else {
var it = _b_.iter(kw_arg),
getitem = $B.$getattr(kw_arg, "__getitem__");
while (true) {
try {
var k = _b_.next(it);
if (typeof k !== "string") {
throw _b_.TypeError.$factory(
fname + "() keywords must be strings"
);
}
if (kwa[k] !== undefined) {
throw _b_.TypeError.$factory(
fname + "() got multiple values for argument '" + k + "'"
);
}
kwa[k] = getitem(k);
} catch (err) {
if ($B.is_exc(err, [_b_.StopIteration])) {
break;
}
throw err;
}
}
}
}
kw_args = kwa;
}
}
}
if (extra_pos_args) {
slots[extra_pos_args] = [];
slots[extra_pos_args].__class__ = _b_.tuple;
}
if (extra_kw_args) {
extra_kw = $B.empty_dict();
}
if (nb_pos > argcount) {
if (extra_pos_args === null || extra_pos_args == "*") {
msg =
fname +
"() takes " +
argcount +
" positional argument" +
(argcount > 1 ? "s" : "") +
" but more were given";
throw _b_.TypeError.$factory(msg);
} else {
for (var i = argcount; i < nb_pos; i++) {
slots[extra_pos_args].push(args[i]);
}
nb_pos = argcount;
}
}
for (var i = 0; i < nb_pos; i++) {
slots[var_names[i]] = args[i];
filled++;
}
if (filled == argcount && argcount === var_names.length && !has_kw_args) {
if (extra_kw_args) {
slots[extra_kw_args] = extra_kw;
}
return slots;
}
if (has_kw_args) {
for (var key in kw_args) {
var value = kw_args[key];
if (slots[key] === undefined) {
if (extra_kw_args) {
extra_kw.$string_dict[key] = [value, extra_kw.$order++];
} else {
throw _b_.TypeError.$factory(
fname + "() got an unexpected keyword argument '" + key + "'"
);
}
} else if (slots.hasOwnProperty(key) && slots[key] !== null) {
if (key == extra_pos_args) {
throw _b_.TypeError.$factory(
`${fname}() got an unexpected ` + `keyword argument '${key}'`
);
}
throw _b_.TypeError.$factory(
fname + "() got multiple values for argument '" + key + "'"
);
} else if (only_positional && only_positional.indexOf(key) > -1) {
throw _b_.TypeError.$factory(
`${fname}() got some ` +
`positional-only arguments passed as keyword ` +
`arguments: '${key}'`
);
} else {
slots[key] = value;
}
}
}
var missing = [];
for (var attr in slots) {
if (slots[attr] === null) {
if ($dobj[attr] !== undefined) {
slots[attr] = $dobj[attr];
} else {
missing.push(attr);
}
}
}
if (missing.length > 0) {
if (missing.length == 1) {
var arg_type = "positional";
if (var_names.indexOf(missing[0]) >= argcount) {
arg_type = "required keyword-only";
}
throw _b_.TypeError.$factory(
fname + ` missing 1 ${arg_type} argument: '${missing[0]}'`
);
} else {
var missing_positional = missing.filter(
(arg) => var_names.indexOf(arg) < argcount
),
missing_kwonly = missing.filter(
(arg) => var_names.indexOf(arg) >= argcount
);
function format_missing(m, type) {
var msg =
m.length + ` required ${type} argument` + (m.length > 1 ? "s" : "");
m = m.map((x) => `'${x}'`);
if (m.length > 1) {
m[m.length - 1] = " and " + m[m.length - 1];
for (var i = 0; i < m.length - 2; i++) {
m[i] = m[i] + ", ";
}
}
return msg + ": " + m.join("");
}
var msg = fname + " missing ";
if (missing_positional.length > 0) {
msg += format_missing(missing_positional, "positional");
} else {
msg += format_missing(missing_kwonly, "keyword-only");
}
throw _b_.TypeError.$factory(msg);
}
}
if (extra_kw_args) {
slots[extra_kw_args] = extra_kw;
}
return slots;
};
$B.wrong_nb_args = function (name, received, expected, positional) {
if (received < expected) {
var missing = expected - received;
throw _b_.TypeError.$factory(
name +
"() missing " +
missing +
" positional argument" +
(missing > 1 ? "s" : "") +
": " +
positional.slice(received)
);
} else {
throw _b_.TypeError.$factory(
name +
"() takes " +
expected +
" positional argument" +
(expected > 1 ? "s" : "") +
" but more were given"
);
}
};
$B.get_class = function (obj) {
if (obj === null) {
return $B.$NoneDict;
}
if (obj === undefined) {
return $B.UndefinedClass;
}
var klass = obj.__class__;
if (klass === undefined) {
switch (typeof obj) {
case "number":
if (obj % 1 === 0) {
return _b_.int;
}
return _b_.float;
case "string":
return _b_.str;
case "boolean":
return _b_.bool;
case "function":
if (obj.$is_js_func) {
return $B.JSObj;
}
obj.__class__ = $B.Function;
return $B.Function;
case "object":
if (Array.isArray(obj)) {
if (Object.getPrototypeOf(obj) === Array.prototype) {
obj.__class__ = _b_.list;
return _b_.list;
}
} else if (obj.constructor === Number) {
return _b_.float;
} else if (typeof Node !== "undefined" && obj instanceof Node) {
if (obj.tagName) {
return $B.imported["browser.html"][obj.tagName] || $B.DOMNode;
}
return $B.DOMNode;
}
break;
}
}
if (klass === undefined) {
return $B.JSObj;
}
return klass;
};
$B.class_name = function (obj) {
var klass = $B.get_class(obj);
if (klass === $B.JSObj) {
return "Javascript " + obj.constructor.name;
} else {
return klass.$infos.__name__;
}
};
$B.next_of = function (iterator) {
if (iterator.__class__ === _b_.range) {
var obj = { ix: iterator.start };
if (iterator.step > 0) {
return function () {
if (obj.ix >= iterator.stop) {
throw _b_.StopIteration.$factory("");
}
var res = obj.ix;
obj.ix += iterator.step;
return res;
};
} else {
return function () {
if (obj.ix <= iterator.stop) {
throw _b_.StopIteration.$factory("");
}
var res = obj.ix;
obj.ix += iterator.step;
return res;
};
}
}
return $B.$call($B.$getattr(_b_.iter(iterator), "__next__"));
};
$B.unpacker = function (obj, nb_targets, has_starred, nb_after_starred) {
var t = _b_.list.$factory(obj),
len = t.length,
min_len = has_starred ? len - 1 : len;
if (len < min_len) {
throw _b_.ValueError.$factory(
`not enough values to unpack (expected ${min_length}, got ${len})`
);
}
if (!has_starred && len > nb_targets) {
console.log("iterable", obj, "t", t, "nb_targets", nb_targets);
throw _b_.ValueError.$factory(
`too many values to unpack (expected ${nb_targets})`
);
}
t.index = -1;
t.read_one = function () {
t.index++;
return t[t.index];
};
t.read_rest = function () {
t.index++;
var res = t.slice(t.index, t.length - nb_after_starred);
t.index = t.length - nb_after_starred - 1;
return res;
};
return t;
};
$B.rest_iter = function (next_func) {
var res = [];
while (true) {
try {
res.push(next_func());
} catch (err) {
if ($B.is_exc(err, [_b_.StopIteration])) {
return $B.fast_tuple(res);
}
throw err;
}
}
};
$B.set_lineno = function (locals, lineno) {
locals.$lineno = lineno;
if (locals.$f_trace !== _b_.None) {
$B.trace_line();
}
return true;
};
$B.handle_annotation = function (annotation_string) {
if (
$B.imported.__future__ &&
$B.frames_stack.length > 0 &&
$B.last($B.frames_stack)[3].annotations ===
$B.imported.__future__.annotations
) {
return annotation_string;
} else {
return _b_.eval(annotation_string);
}
};
$B.copy_namespace = function () {
var ns = {};
for (const frame of $B.frames_stack) {
for (const kv of [frame[1], frame[3]]) {
for (var key in kv) {
if (!key.startsWith("$")) {
ns[key] = kv[key];
}
}
}
}
return ns;
};
$B.clear_ns = function (name) {
if (name.startsWith("__ge")) {
console.log("clear ns", name);
}
var len = name.length;
$B.$py_src[name] = null;
delete $B.$py_src[name];
var alt_name = name.replace(/\./g, "_");
if (alt_name != name) {
$B.clear_ns(alt_name);
}
};
$B.$search = function (name, global_ns) {
var frame = $B.last($B.frames_stack);
if (frame[1][name] !== undefined) {
return frame[1][name];
} else if (frame[3][name] !== undefined) {
return frame[3][name];
} else if (_b_[name] !== undefined) {
return _b_[name];
} else {
if (
frame[0] == frame[2] ||
frame[1].$type == "class" ||
frame[1].$exec_locals
) {
throw $B.name_error(name);
} else {
throw _b_.UnboundLocalError.$factory(
"local variable '" + name + "' referenced before assignment"
);
}
}
};
$B.$global_search = function (name, search_ids) {
var ns = {};
for (var i = 0; i < $B.frames_stack.length; i++) {
var frame = $B.frames_stack[i];
if (search_ids.indexOf(frame[0]) > -1) {
if (frame[1].$is_not_dict) {
try {
return $B.$getitem(frame[1], name);
} catch (err) {
if (!$B.is_exc(err, [_b_.KeyError])) {
throw err;
}
}
} else if (frame[1][name] !== undefined) {
return frame[1][name];
}
}
if (search_ids.indexOf(frame[2]) > -1) {
if (frame[3][name] !== undefined) {
return frame[3][name];
}
}
}
for (var i = 0; i < search_ids.length; i++) {
var search_id = search_ids[i];
if ($B.imported[search_id] && $B.imported[search_id][name]) {
return $B.imported[search_id][name];
}
}
throw $B.name_error(name);
};
$B.$local_search = function (name) {
var frame = $B.last($B.frames_stack);
if (frame[1][name] !== undefined) {
return frame[1][name];
} else {
throw _b_.UnboundLocalError.$factory(
"local variable '" + name + "' referenced before assignment"
);
}
};
$B.get_method_class = function (ns, qualname) {
var refs = qualname.split("."),
klass = ns;
while (refs.length > 0) {
var ref = refs.shift();
if (klass[ref] === undefined) {
var fake_class = $B.make_class(qualname);
return fake_class;
}
klass = klass[ref];
}
return klass;
};
$B.$check_def = function (name, value) {
if (value !== undefined) {
return value;
} else if (_b_[name] !== undefined) {
return _b_[name];
} else {
var frame = $B.last($B.frames_stack);
if (frame[1].$is_not_dict) {
try {
return $B.$getitem(frame[1], name);
} catch (err) {
if (!$B.is_exc(err, [_b_.KeyError])) {
throw err;
}
}
} else if (frame[1][name] !== undefined) {
return frame[1][name];
}
if (frame[3][name] !== undefined) {
return frame[3][name];
}
}
throw $B.name_error(name);
};
$B.$check_def_global = function (name, ns) {
var res = ns[name];
if (res === undefined) {
throw $B.name_error(name);
}
return res;
};
$B.$check_def_local = function (name, value) {
if (value !== undefined) {
return value;
}
throw _b_.UnboundLocalError.$factory(
"local variable '" + name + "' referenced before assignment"
);
};
$B.$check_def_free = function (name, value) {
if (value !== undefined) {
return value;
}
var res;
for (var i = $B.frames_stack.length - 1; i >= 0; i--) {
res = $B.frames_stack[i][1][name];
if (res !== undefined) {
return res;
}
res = $B.frames_stack[i][3][name];
if (res !== undefined) {
return res;
}
}
throw _b_.NameError.$factory(
"free variable '" +
name +
"' referenced before assignment in enclosing scope"
);
};
$B.$check_def_free1 = function (name, scope_id) {
var res;
for (var i = $B.frames_stack.length - 1; i >= 0; i--) {
var frame = $B.frames_stack[i];
res = frame[1][name];
if (res !== undefined) {
return res;
}
if (frame[1].$parent) {
res = frame[1].$parent[name];
if (res !== undefined) {
return res;
}
}
if (frame[2] == scope_id) {
res = frame[3][name];
if (res !== undefined) {
return res;
}
}
}
throw _b_.NameError.$factory(
"free variable '" +
name +
"' referenced before assignment in enclosing scope"
);
};
$B.$JS2Py = function (src) {
if (typeof src === "number") {
if (src % 1 === 0) {
return src;
}
return _b_.float.$factory(src);
}
if (src === null || src === undefined) {
return _b_.None;
}
if (Array.isArray(src) && Object.getPrototypeOf(src) === Array.prototype) {
src.$brython_class = "js";
}
return src;
};
$B.list_key = function (obj, key) {
key = $B.$GetInt(key);
if (key < 0) {
key += obj.length;
}
var res = obj[key];
if (res === undefined) {
throw _b_.IndexError.$factory("list index out of range");
}
return res;
};
$B.list_slice = function (obj, start, stop) {
if (start === null) {
start = 0;
} else {
start = $B.$GetInt(start);
if (start < 0) {
start = Math.max(0, start + obj.length);
}
}
if (stop === null) {
return obj.slice(start);
}
stop = $B.$GetInt(stop);
if (stop < 0) {
stop += obj.length;
}
return obj.slice(start, stop);
};
$B.list_slice_step = function (obj, start, stop, step) {
if (step === null || step == 1) {
return $B.list_slice(obj, start, stop);
}
if (step == 0) {
throw _b_.ValueError.$factory("slice step cannot be zero");
}
step = $B.$GetInt(step);
if (start === null) {
start = step >= 0 ? 0 : obj.length - 1;
} else {
start = $B.$GetInt(start);
if (start < 0) {
start = Math.min(0, start + obj.length);
}
}
if (stop === null) {
stop = step >= 0 ? obj.length : -1;
} else {
stop = $B.$GetInt(stop);
if (stop < 0) {
stop = Math.max(0, stop + obj.length);
}
}
var res = [];
if (step > 0) {
for (var i = start; i < stop; i += step) {
res.push(obj[i]);
}
} else {
for (var i = start; i > stop; i += step) {
res.push(obj[i]);
}
}
return res;
};
function index_error(obj) {
var type = typeof obj == "string" ? "string" : "list";
throw _b_.IndexError.$factory(type + " index out of range");
}
$B.$getitem = function (obj, item) {
var is_list = Array.isArray(obj) && obj.__class__ === _b_.list,
is_dict = obj.__class__ === _b_.dict && !obj.$jsobj;
if (typeof item == "number") {
if (is_list || typeof obj == "string") {
item = item >= 0 ? item : obj.length + item;
if (obj[item] !== undefined) {
return obj[item];
} else {
index_error(obj);
}
} else if (is_dict) {
if (obj.$numeric_dict[item] !== undefined) {
return obj.$numeric_dict[item][0];
}
}
} else if (item.valueOf && typeof item.valueOf() == "string" && is_dict) {
var res = obj.$string_dict[item];
if (res !== undefined) {
return res[0];
}
throw _b_.KeyError.$factory(item);
}
if (obj.$is_class) {
var class_gi = $B.$getattr(obj, "__class_getitem__", _b_.None);
if (class_gi !== _b_.None) {
return class_gi(item);
} else if (obj.__class__) {
class_gi = $B.$getattr(obj.__class__, "__getitem__", _b_.None);
if (class_gi !== _b_.None) {
return class_gi(obj, item);
} else {
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj.__class__) + "' object is not subscriptable"
);
}
}
}
if (is_list) {
return _b_.list.$getitem(obj, item);
}
if (is_dict) {
return _b_.dict.$getitem(obj, item);
}
var gi = $B.$getattr(
obj.__class__ || $B.get_class(obj),
"__getitem__",
_b_.None
);
if (gi !== _b_.None) {
return gi(obj, item);
}
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object is not subscriptable"
);
};
$B.getitem_slice = function (obj, slice) {
var res;
if (Array.isArray(obj) && obj.__class__ === _b_.list) {
if (slice.start === _b_.None && slice.stop === _b_.None) {
if (slice.step === _b_.None || slice.step == 1) {
res = obj.slice();
} else if (slice.step == -1) {
res = obj.slice().reverse();
}
} else if (slice.step === _b_.None) {
if (slice.start === _b_.None) {
slice.start = 0;
}
if (slice.stop === _b_.None) {
slice.stop = obj.length;
}
if (typeof slice.start == "number" && typeof slice.stop == "number") {
if (slice.start < 0) {
slice.start += obj.length;
}
if (slice.stop < 0) {
slice.stop += obj.length;
}
res = obj.slice(slice.start, slice.stop);
}
}
if (res) {
res.__class__ = obj.__class__;
res.__brython__ = true;
return res;
} else {
return _b_.list.$getitem(obj, slice);
}
}
return $B.$getattr(obj, "__getitem__")(slice);
};
$B.set_list_key = function (obj, key, value) {
try {
key = $B.$GetInt(key);
} catch (err) {
if (_b_.isinstance(key, _b_.slice)) {
var s = _b_.slice.$conv_for_seq(key, obj.length);
return $B.set_list_slice_step(obj, s.start, s.stop, s.step, value);
}
}
if (key < 0) {
key += obj.length;
}
if (obj[key] === undefined) {
console.log(obj, key);
throw _b_.IndexError.$factory("list assignment index out of range");
}
obj[key] = value;
};
$B.set_list_slice = function (obj, start, stop, value) {
if (start === null) {
start = 0;
} else {
start = $B.$GetInt(start);
if (start < 0) {
start = Math.max(0, start + obj.length);
}
}
if (stop === null) {
stop = obj.length;
}
stop = $B.$GetInt(stop);
if (stop < 0) {
stop = Math.max(0, stop + obj.length);
}
var res = _b_.list.$factory(value);
obj.splice.apply(obj, [start, stop - start].concat(res));
};
$B.set_list_slice_step = function (obj, start, stop, step, value) {
if (step === null || step == 1) {
return $B.set_list_slice(obj, start, stop, value);
}
if (step == 0) {
throw _b_.ValueError.$factory("slice step cannot be zero");
}
step = $B.$GetInt(step);
if (start === null) {
start = step > 0 ? 0 : obj.length - 1;
} else {
start = $B.$GetInt(start);
}
if (stop === null) {
stop = step > 0 ? obj.length : -1;
} else {
stop = $B.$GetInt(stop);
}
var repl = _b_.list.$factory(value),
j = 0,
test,
nb = 0;
if (step > 0) {
test = function (i) {
return i < stop;
};
} else {
test = function (i) {
return i > stop;
};
}
for (var i = start; test(i); i += step) {
nb++;
}
if (nb != repl.length) {
throw _b_.ValueError.$factory(
"attempt to assign sequence of size " +
repl.length +
" to extended slice of size " +
nb
);
}
for (var i = start; test(i); i += step) {
obj[i] = repl[j];
j++;
}
};
$B.$setitem = function (obj, item, value) {
if (
Array.isArray(obj) &&
obj.__class__ === undefined &&
typeof item == "number" &&
!_b_.isinstance(obj, _b_.tuple)
) {
if (item < 0) {
item += obj.length;
}
if (obj[item] === undefined) {
throw _b_.IndexError.$factory("list assignment index out of range");
}
obj[item] = value;
return;
} else if (obj.__class__ === _b_.dict) {
_b_.dict.$setitem(obj, item, value);
return;
} else if (obj.__class__ === _b_.list) {
return _b_.list.$setitem(obj, item, value);
}
var si = $B.$getattr(
obj.__class__ || $B.get_class(obj),
"__setitem__",
null
);
if (si === null) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object does not support item assignment"
);
}
return si(obj, item, value);
};
$B.$delitem = function (obj, item) {
if (
Array.isArray(obj) &&
obj.__class__ === _b_.list &&
typeof item == "number" &&
!_b_.isinstance(obj, _b_.tuple)
) {
if (item < 0) {
item += obj.length;
}
if (obj[item] === undefined) {
throw _b_.IndexError.$factory("list deletion index out of range");
}
obj.splice(item, 1);
return;
} else if (obj.__class__ === _b_.dict) {
_b_.dict.__delitem__(obj, item);
return;
} else if (obj.__class__ === _b_.list) {
return _b_.list.__delitem__(obj, item);
}
var di = $B.$getattr(
obj.__class__ || $B.get_class(obj),
"__delitem__",
null
);
if (di === null) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object doesn't support item deletion"
);
}
return di(obj, item);
};
$B.delitem_slice = function (obj, slice) {
if (Array.isArray(obj) && obj.__class__ === _b_.list) {
if (slice.start === _b_.None && slice.stop === _b_.None) {
if (slice.step === _b_.None || slice.step == 1 || slice.step == -1) {
while (obj.length > 0) {
obj.pop();
}
return _b_.None;
}
} else if (slice.step === _b_.None) {
if (slice.start === _b_.None) {
slice.start = 0;
}
if (slice.stop === _b_.None) {
slice.stop = obj.length;
}
if (typeof slice.start == "number" && typeof slice.stop == "number") {
if (slice.start < 0) {
slice.start += obj.length;
}
if (slice.stop < 0) {
slice.stop += obj.length;
}
obj.splice(slice.start, slice.stop - slice.start);
return _b_.None;
}
}
}
var di = $B.$getattr(
obj.__class__ || $B.get_class(obj),
"__delitem__",
null
);
if (di === null) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object doesn't support item deletion"
);
}
return di(obj, slice);
};
$B.augm_assign = function (left, op, right) {
var op1 = op.substr(0, op.length - 1);
if (typeof left == "number" && typeof right == "number" && op != "//=") {
var res = eval(left + " " + op1 + " " + right);
if (
res <= $B.max_int &&
res >= $B.min_int &&
res.toString().search(/e/i) == -1
) {
return res;
} else {
res = eval(`${BigInt(left)}n ${op1} ${BigInt(right)}n`);
var pos = res > 0n,
res = res + "";
return pos
? $B.fast_long_int(res, true)
: $B.fast_long_int(res.substr(1), false);
}
} else if (
typeof left == "string" &&
typeof right == "string" &&
op == "+="
) {
return left + right;
} else {
var method = $B.op2method.augmented_assigns[op],
augm_func = $B.$getattr(left, "__" + method + "__", null);
if (augm_func !== null) {
return $B.$call(augm_func)(right);
} else {
var method1 = $B.op2method.operations[op1];
if (method1 === undefined) {
method1 = $B.op2method.binary[op1];
}
return $B.rich_op(`__${method1}__`, left, right);
}
}
};
$B.extend = function (fname, arg) {
for (var i = 2; i < arguments.length; i++) {
var mapping = arguments[i];
var it = _b_.iter(mapping),
getter = $B.$getattr(mapping, "__getitem__");
while (true) {
try {
var key = _b_.next(it);
if (typeof key !== "string") {
throw _b_.TypeError.$factory(fname + "() keywords must be strings");
}
if (arg[key] !== undefined) {
throw _b_.TypeError.$factory(
fname + "() got multiple values for argument '" + key + "'"
);
}
arg[key] = getter(key);
} catch (err) {
if (_b_.isinstance(err, [_b_.StopIteration])) {
break;
}
throw err;
}
}
}
return arg;
};
$B.extend_list = function () {
var res = Array.prototype.slice.call(arguments, 0, arguments.length - 1),
last = $B.last(arguments);
var it = _b_.iter(last);
while (true) {
try {
res.push(_b_.next(it));
} catch (err) {
if (_b_.isinstance(err, [_b_.StopIteration])) {
break;
}
throw err;
}
}
return res;
};
$B.$test_item = function (expr) {
$B.$test_result = expr;
return _b_.bool.$factory(expr);
};
$B.$test_expr = function () {
return $B.$test_result;
};
$B.$is = function (a, b) {
if (a instanceof Number && b instanceof Number) {
return a.valueOf() == b.valueOf();
}
if (
(a === _b_.int && b == $B.long_int) ||
(a === $B.long_int && b === _b_.int)
) {
return true;
}
return a === b;
};
$B.conv_undef = function (obj) {
var res = {};
for (var key in obj) {
res[key] = obj[key] === undefined ? $B.Undefined : obj[key];
}
return res;
};
$B.$is_member = function (item, _set) {
var f, _iter, method;
try {
method = $B.$getattr(
_set.__class__ || $B.get_class(_set),
"__contains__"
);
} catch (err) {}
if (method) {
return $B.$call(method)(_set, item);
}
try {
_iter = _b_.iter(_set);
} catch (err) {}
if (_iter) {
while (1) {
try {
var elt = _b_.next(_iter);
if ($B.rich_comp("__eq__", elt, item)) {
return true;
}
} catch (err) {
return false;
}
}
}
try {
f = $B.$getattr(_set, "__getitem__");
} catch (err) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(_set) + "' object is not iterable"
);
}
if (f) {
var i = -1;
while (1) {
i++;
try {
var elt = f(i);
if ($B.rich_comp("__eq__", elt, item)) {
return true;
}
} catch (err) {
if (err.__class__ === _b_.IndexError) {
return false;
}
throw err;
}
}
}
};
$B.$call = function (callable) {
if (callable.__class__ === $B.method) {
return callable;
} else if (callable.$factory) {
return callable.$factory;
} else if (callable.$is_class) {
return (callable.$factory = $B.$instance_creator(callable));
} else if (callable.$is_js_class) {
return (callable.$factory = function () {
return new callable(...arguments);
});
} else if (callable.$in_js_module) {
return function () {
var res = callable(...arguments);
return res === undefined ? _b_.None : res;
};
} else if (callable.$is_func || typeof callable == "function") {
return callable;
}
try {
return $B.$getattr(callable, "__call__");
} catch (err) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(callable) + "' object is not callable"
);
}
};
var $io = $B.make_class("io", function (out) {
return {
__class__: $io,
out,
};
});
$io.flush = function (self) {
console[self.out].apply(null, self.buf);
self.buf = [];
};
$io.write = function (self, msg) {
if (self.buf === undefined) {
self.buf = [];
}
if (typeof msg != "string") {
throw _b_.TypeError.$factory(
"write() argument must be str, not " + $B.class_name(msg)
);
}
self.buf.push(msg);
return _b_.None;
};
if (console.error !== undefined) {
$B.stderr = $io.$factory("error");
} else {
$B.stderr = $io.$factory("log");
}
$B.stdout = $io.$factory("log");
$B.stdin = {
__class__: $io,
__original__: true,
closed: false,
len: 1,
pos: 0,
read: function () {
return "";
},
readline: function () {
return "";
},
};
$B.make_iterator_class = function (name) {
var klass = {
__class__: _b_.type,
__mro__: [_b_.object],
$factory: function (items) {
return {
__class__: klass,
__dict__: $B.empty_dict(),
counter: -1,
items: items,
len: items.length,
};
},
$infos: { __name__: name },
$is_class: true,
__iter__: function (self) {
self.counter = self.counter === undefined ? -1 : self.counter;
self.len = self.items.length;
return self;
},
__len__: function (self) {
return self.items.length;
},
__next__: function (self) {
if (typeof self.test_change == "function" && self.test_change()) {
throw _b_.RuntimeError.$factory(
"dictionary changed size during iteration"
);
}
self.counter++;
if (self.counter < self.items.length) {
var item = self.items[self.counter];
if (self.items.$brython_class == "js") {
item = $B.$JS2Py(item);
}
return item;
}
throw _b_.StopIteration.$factory("StopIteration");
},
__reduce_ex__: function (self, protocol) {
return $B.fast_tuple([_b_.iter, _b_.tuple.$factory([self.items])]);
},
};
$B.set_func_names(klass, "builtins");
return klass;
};
function $err(op, klass, other) {
var msg =
"unsupported operand type(s) for " +
op +
" : '" +
klass.$infos.__name__ +
"' and '" +
$B.class_name(other) +
"'";
throw _b_.TypeError.$factory(msg);
}
var r_opnames = [
"add",
"sub",
"mul",
"truediv",
"floordiv",
"mod",
"pow",
"lshift",
"rshift",
"and",
"xor",
"or",
];
var ropsigns = [
"+",
"-",
"*",
"/",
"//",
"%",
"**",
"<<",
">>",
"&",
"^",
"|",
];
$B.make_rmethods = function (klass) {
for (var r_opname of r_opnames) {
if (
klass["__r" + r_opname + "__"] === undefined &&
klass["__" + r_opname + "__"]
) {
klass["__r" + r_opname + "__"] = (function (name) {
return function (self, other) {
return klass["__" + name + "__"](other, self);
};
})(r_opname);
}
}
};
$B.UUID = function () {
return $B.$py_UUID++;
};
$B.$GetInt = function (value) {
if (typeof value == "number" || value.constructor === Number) {
return value;
} else if (typeof value === "boolean") {
return value ? 1 : 0;
} else if (_b_.isinstance(value, _b_.int)) {
return value;
} else if (_b_.isinstance(value, _b_.float)) {
return value.valueOf();
}
if (!value.$is_class) {
try {
var v = $B.$getattr(value, "__int__")();
return v;
} catch (e) {}
try {
var v = $B.$getattr(value, "__index__")();
return v;
} catch (e) {}
}
throw _b_.TypeError.$factory(
"'" +
$B.class_name(value) +
"' object cannot be interpreted as an integer"
);
};
$B.to_num = function (obj, methods) {
var expected_class = {
__complex__: _b_.complex,
__float__: _b_.float,
__index__: _b_.int,
__int__: _b_.int,
};
var klass = obj.__class__ || $B.get_class(obj);
for (var i = 0; i < methods.length; i++) {
var missing = {},
method = $B.$getattr(klass, methods[i], missing);
if (method !== missing) {
var res = method(obj);
if (!_b_.isinstance(res, expected_class[methods[i]])) {
console.log(res, methods[i], expected_class[methods[i]]);
throw _b_.TypeError.$factory(
methods[i] +
"returned non-" +
expected_class[methods[i]].$infos.__name__ +
"(type " +
$B.get_class(res) +
")"
);
}
return res;
}
}
return null;
};
$B.PyNumber_Index = function (item) {
switch (typeof item) {
case "boolean":
return item ? 1 : 0;
case "number":
return item;
case "object":
if (item.__class__ === $B.long_int) {
return item;
}
if (_b_.isinstance(item, _b_.int)) {
return item.$brython_value;
}
var method = $B.$getattr(item, "__index__", _b_.None);
if (method !== _b_.None) {
method =
typeof method == "function"
? method
: $B.$getattr(method, "__call__");
return $B.int_or_bool(method());
} else {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(item) +
"' object cannot be interpreted as an integer"
);
}
default:
throw _b_.TypeError.$factory(
"'" +
$B.class_name(item) +
"' object cannot be interpreted as an integer"
);
}
};
$B.int_or_bool = function (v) {
switch (typeof v) {
case "boolean":
return v ? 1 : 0;
case "number":
return v;
case "object":
if (v.__class__ === $B.long_int) {
return v;
} else {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(v) +
"' object cannot be interpreted as an integer"
);
}
default:
throw _b_.TypeError.$factory(
"'" +
$B.class_name(v) +
"' object cannot be interpreted as an integer"
);
}
};
$B.enter_frame = function (frame) {
$B.frames_stack.push(frame);
if ($B.tracefunc && $B.tracefunc !== _b_.None) {
if (
frame[4] === $B.tracefunc ||
($B.tracefunc.$infos &&
frame[4] &&
frame[4] === $B.tracefunc.$infos.__func__)
) {
$B.tracefunc.$frame_id = frame[0];
return _b_.None;
} else {
for (var i = $B.frames_stack.length - 1; i >= 0; i--) {
if ($B.frames_stack[i][0] == $B.tracefunc.$frame_id) {
return _b_.None;
}
}
try {
return $B.tracefunc(
$B._frame.$factory($B.frames_stack, $B.frames_stack.length - 1),
"call",
_b_.None
);
} catch (err) {
err.$in_trace_func = true;
throw err;
}
}
}
return _b_.None;
};
$B.trace_exception = function () {
var top_frame = $B.last($B.frames_stack);
if (top_frame[0] == $B.tracefunc.$current_frame_id) {
return _b_.None;
}
var trace_func = top_frame[1].$f_trace,
exc = top_frame[1].$current_exception,
frame_obj = $B._frame.$factory(
$B.frames_stack,
$B.frames_stack.length - 1
);
return trace_func(
frame_obj,
"exception",
$B.fast_tuple([exc.__class__, exc, $B.traceback.$factory(exc)])
);
};
$B.trace_line = function () {
var top_frame = $B.last($B.frames_stack);
if (top_frame[0] == $B.tracefunc.$current_frame_id) {
return _b_.None;
}
var trace_func = top_frame[1].$f_trace,
frame_obj = $B._frame.$factory(
$B.frames_stack,
$B.frames_stack.length - 1
);
return trace_func(frame_obj, "line", _b_.None);
};
$B.set_line = function (line_info) {
var top_frame = $B.last($B.frames_stack);
if ($B.tracefunc && top_frame[0] == $B.tracefunc.$current_frame_id) {
return _b_.None;
}
top_frame[1].$line_info = line_info;
var trace_func = top_frame[1].$f_trace;
if (trace_func !== _b_.None) {
var frame_obj = $B._frame.$factory(
$B.frames_stack,
$B.frames_stack.length - 1
);
top_frame[1].$ftrace = trace_func(frame_obj, "line", _b_.None);
}
return true;
};
$B.trace_return = function (value) {
var top_frame = $B.last($B.frames_stack),
trace_func = top_frame[1].$f_trace,
frame_obj = $B._frame.$factory(
$B.frames_stack,
$B.frames_stack.length - 1
);
if (top_frame[0] == $B.tracefunc.$current_frame_id) {
return _b_.None;
}
trace_func(frame_obj, "return", value);
};
$B.leave_frame = function (arg) {
if ($B.frames_stack.length == 0) {
console.log("empty stack");
return;
}
if (arg && arg.value !== undefined && $B.tracefunc) {
if ($B.last($B.frames_stack)[1].$f_trace === undefined) {
$B.last($B.frames_stack)[1].$f_trace = $B.tracefunc;
}
if ($B.last($B.frames_stack)[1].$f_trace !== _b_.None) {
$B.trace_return(arg.value);
}
}
var frame = $B.frames_stack.pop();
if (frame[1].$is_generator) {
if (frame[1].$context_managers) {
var ctx_managers = frame[1].$context_managers;
} else {
var ctx_managers = [];
for (var key in frame[1]) {
if (key.startsWith("$ctx_manager")) {
ctx_managers.push(frame[1][key]);
}
}
}
if (ctx_managers.length > 0 && $B.frames_stack.length > 0) {
var caller = $B.last($B.frames_stack);
caller[1].$ctx_managers_in_gen =
caller[1].$ctx_managers_in_gen || new Set();
for (var cm of ctx_managers) {
caller[1].$ctx_managers_in_gen.add(cm);
}
}
}
frame[1].$current_exception = undefined;
if (frame[1].$ctx_managers_in_gen) {
for (var cm of frame[1].$ctx_managers_in_gen) {
$B.$call($B.$getattr(cm, "__exit__"))(_b_.None, _b_.None, _b_.None);
}
}
return _b_.None;
};
$B.leave_frame_exec = function (arg) {
if ($B.profile > 0) {
$B.$profile.return();
}
if ($B.frames_stack.length == 0) {
console.log("empty stack");
return;
}
var frame = $B.last($B.frames_stack);
$B.frames_stack.pop();
if (frame[1].$ctx_managers_in_gen) {
for (var cm of frame[1].$ctx_managers_in_gen) {
$B.$call($B.$getattr(cm, "__exit__"))(_b_.None, _b_.None, _b_.None);
}
}
for (var i = $B.frames_stack.length - 1; i >= 0; i--) {
if ($B.frames_stack[i][2] == frame[2]) {
$B.frames_stack[i][3] = frame[3];
}
}
};
var min_int = Math.pow(-2, 53),
max_int = Math.pow(2, 53) - 1;
$B.is_safe_int = function () {
for (var i = 0; i < arguments.length; i++) {
var arg = arguments[i];
if (
typeof arg != "number" ||
isNaN(arg) ||
arg < min_int ||
arg > max_int
) {
return false;
}
}
return true;
};
$B.add = function (x, y) {
if (
x.valueOf &&
typeof x.valueOf() == "number" &&
y.valueOf &&
typeof y.valueOf() == "number"
) {
if (typeof x == "number" && typeof y == "number") {
var z = x + y;
if (z < $B.max_int && z > $B.min_int) {
return z;
} else if (z === Infinity) {
return _b_.float.$factory("inf");
} else if (z === -Infinity) {
return _b_.float.$factory("-inf");
} else if (isNaN(z)) {
return _b_.float.$factory("nan");
}
return $B.long_int.__add__(
$B.long_int.$factory(x),
$B.long_int.$factory(y)
);
} else {
return new Number(x + y);
}
} else if (typeof x == "string" && typeof y == "string") {
return x + y;
}
try {
var method = $B.$getattr(x.__class__ || $B.get_class(x), "__add__");
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"unsupported operand type(s) for " +
"+: '" +
$B.class_name(x) +
"' and '" +
$B.class_name(y) +
"'"
);
}
throw err;
}
var res = $B.$call(method)(x, y);
if (res === _b_.NotImplemented) {
return $B.rich_op("__add__", x, y);
}
return res;
};
$B.div = function (x, y) {
var z = x / y;
if (
x > min_int &&
x < max_int &&
y > min_int &&
y < max_int &&
z > min_int &&
z < max_int
) {
return z;
} else {
return $B.long_int.__truediv__(
$B.long_int.$factory(x),
$B.long_int.$factory(y)
);
}
};
$B.eq = function (x, y) {
if (x > min_int && x < max_int && y > min_int && y < max_int) {
return x == y;
}
return $B.long_int.__eq__($B.long_int.$factory(x), $B.long_int.$factory(y));
};
$B.floordiv = function (x, y) {
var z = x / y;
if (
x > min_int &&
x < max_int &&
y > min_int &&
y < max_int &&
z > min_int &&
z < max_int
) {
return Math.floor(z);
} else {
return $B.long_int.__floordiv__(
$B.long_int.$factory(x),
$B.long_int.$factory(y)
);
}
};
$B.mul = function (x, y) {
var z =
typeof x != "number" || typeof y != "number" ? new Number(x * y) : x * y;
if (
x > min_int &&
x < max_int &&
y > min_int &&
y < max_int &&
z > min_int &&
z < max_int
) {
return z;
} else if (
(typeof x == "number" || x.__class__ === $B.long_int) &&
(typeof y == "number" || y.__class__ === $B.long_int)
) {
if (
(typeof x == "number" && isNaN(x)) ||
(typeof y == "number" && isNaN(y))
) {
return _b_.float.$factory("nan");
}
switch (x) {
case Infinity:
case -Infinity:
if (y == 0) {
return _b_.float.$factory("nan");
} else {
return y > 0 ? x : -x;
}
}
return $B.long_int.__mul__(
$B.long_int.$factory(x),
$B.long_int.$factory(y)
);
} else {
return z;
}
};
$B.sub = function (x, y) {
if (x instanceof Number && y instanceof Number) {
return x - y;
}
var z =
typeof x != "number" || typeof y != "number" ? new Number(x - y) : x - y;
if (
x > min_int &&
x < max_int &&
y > min_int &&
y < max_int &&
z > min_int &&
z < max_int
) {
return z;
} else if (
(typeof x == "number" || x.__class__ === $B.long_int) &&
(typeof y == "number" || y.__class__ === $B.long_int)
) {
if (typeof x == "number" && typeof y == "number") {
if (isNaN(x) || isNaN(y)) {
return _b_.float.$factory("nan");
} else if (x === Infinity || x === -Infinity) {
if (y === x) {
return _b_.float.$factory("nan");
} else {
return x;
}
} else if (y === Infinity || y === -Infinity) {
if (y === x) {
return _b_.float.$factory("nan");
} else {
return -y;
}
}
}
if (
(typeof x == "number" && isNaN(x)) ||
(typeof y == "number" && isNaN(y))
) {
return _b_.float.$factory("nan");
}
return $B.long_int.__sub__(
$B.long_int.$factory(x),
$B.long_int.$factory(y)
);
} else {
return z;
}
};
$B.ge = function (x, y) {
if (typeof x == "number" && typeof y == "number") {
return x >= y;
} else if (typeof x == "number" && typeof y != "number") {
return !y.pos;
} else if (typeof x != "number" && typeof y == "number") {
return x.pos === true;
} else {
return $B.long_int.__ge__(x, y);
}
};
$B.gt = function (x, y) {
if (typeof x == "number" && typeof y == "number") {
return x > y;
} else if (typeof x == "number" && typeof y != "number") {
return !y.pos;
} else if (typeof x != "number" && typeof y == "number") {
return x.pos === true;
} else {
return $B.long_int.__gt__(x, y);
}
};
var reversed_op = {
__lt__: "__gt__",
__le__: "__ge__",
__gt__: "__lt__",
__ge__: "__le__",
};
var method2comp = { __lt__: "<", __le__: "<=", __gt__: ">", __ge__: ">=" };
$B.rich_comp = function (op, x, y) {
if (x === undefined) {
throw _b_.RuntimeError.$factory("error in rich comp");
}
var x1 = x.valueOf ? x.valueOf() : x,
y1 = y.valueOf ? y.valueOf() : y;
if (
typeof x1 == "number" &&
typeof y1 == "number" &&
x.__class__ === undefined &&
y.__class__ === undefined
) {
switch (op) {
case "__eq__":
return x1 == y1;
case "__ne__":
return x1 != y1;
case "__le__":
return x1 <= y1;
case "__lt__":
return x1 < y1;
case "__ge__":
return x1 >= y1;
case "__gt__":
return x1 > y1;
}
}
var res;
if (x.$is_class || x.$factory) {
if (op == "__eq__") {
return x === y;
} else if (op == "__ne__") {
return !(x === y);
} else {
throw _b_.TypeError.$factory(
"'" +
method2comp[op] +
"' not supported between instances of '" +
$B.class_name(x) +
"' and '" +
$B.class_name(y) +
"'"
);
}
}
var x_class_op = $B.$call($B.$getattr(x.__class__ || $B.get_class(x), op)),
rev_op = reversed_op[op] || op;
if (x.__class__ && y.__class__) {
if (y.__class__.__mro__.indexOf(x.__class__) > -1) {
var rev_func = $B.$getattr(y, rev_op);
res = $B.$call($B.$getattr(y, rev_op))(x);
if (res !== _b_.NotImplemented) {
return res;
}
}
}
res = x_class_op(x, y);
if (res !== _b_.NotImplemented) {
return res;
}
var y_class_op = $B.$call(
$B.$getattr(y.__class__ || $B.get_class(y), rev_op)
);
res = y_class_op(y, x);
if (res !== _b_.NotImplemented) {
return res;
}
if (op == "__eq__") {
return _b_.False;
} else if (op == "__ne__") {
return _b_.True;
}
throw _b_.TypeError.$factory(
"'" +
method2comp[op] +
"' not supported between instances of '" +
$B.class_name(x) +
"' and '" +
$B.class_name(y) +
"'"
);
};
var opname2opsign = { __sub__: "-", __xor__: "^", __mul__: "*" };
$B.rich_op = function (op, x, y) {
var x_class = x.__class__ || $B.get_class(x),
y_class = y.__class__ || $B.get_class(y),
rop = "__r" + op.substr(2),
method;
if (x_class === y_class) {
if (x_class === _b_.int) {
return _b_.int[op](x, y);
} else if (x_class === _b_.bool) {
return (_b_.bool[op] || _b_.int[op])(x, y);
}
try {
method = $B.$call($B.$getattr(x_class, op));
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
var kl_name = $B.class_name(x);
throw _b_.TypeError.$factory(
"unsupported operand type(s) " +
"for " +
opname2opsign[op] +
" : '" +
kl_name +
"' and '" +
kl_name +
"'"
);
}
throw err;
}
return method(x, y);
}
if (_b_.issubclass(y_class, x_class)) {
var reflected_left = $B.$getattr(x_class, rop),
reflected_right = $B.$getattr(y_class, rop);
if (reflected_right !== reflected_left) {
return reflected_right(y, x);
}
}
var res;
try {
var attr = $B.$getattr(x, op);
method = $B.$getattr(x_class, op);
} catch (err) {
if (err.__class__ !== _b_.AttributeError) {
throw err;
}
res = $B.$call($B.$getattr(y, rop))(x);
if (res !== _b_.NotImplemented) {
return res;
}
throw _b_.TypeError.$factory(
`unsupported operand type(s) for '${$B.method_to_op[op]}' :` +
` '${$B.class_name(x)}' and '${$B.class_name(y)}'`
);
}
res = method(x, y);
if (res === _b_.NotImplemented) {
try {
var reflected = $B.$getattr(y, rop),
method = $B.$getattr(y_class, rop);
} catch (err) {
if (err.__class__ !== _b_.AttributeError) {
throw err;
}
throw _b_.TypeError.$factory(
`unsupported operand type(s) for '${$B.method_to_op[op]}' :` +
` '${$B.class_name(x)}' and '${$B.class_name(y)}'`
);
}
res = method(y, x);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
`unsupported operand type(s) for '${$B.method_to_op[op]}' :` +
` '${$B.class_name(x)}' and '${$B.class_name(y)}'`
);
}
return res;
} else {
return res;
}
};
$B.is_none = function (o) {
return o === undefined || o === null || o == _b_.None;
};
var repr_stack = new Set();
$B.repr = {
enter: function (obj) {
if (repr_stack.has(obj)) {
return true;
} else {
repr_stack.add(obj);
}
},
leave: function (obj) {
repr_stack.delete(obj);
},
};
})(__BRYTHON__);
(function ($B) {
var DEFAULT_MIN_MERGE = 32;
var DEFAULT_MIN_GALLOPING = 7;
var DEFAULT_TMP_STORAGE_LENGTH = 256;
var POWERS_OF_TEN = [1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9];
function log10(x) {
if (x < 1e5) {
if (x < 1e2) {
return x < 1e1 ? 0 : 1;
}
if (x < 1e4) {
return x < 1e3 ? 2 : 3;
}
return 4;
}
if (x < 1e7) {
return x < 1e6 ? 5 : 6;
}
if (x < 1e9) {
return x < 1e8 ? 7 : 8;
}
return 9;
}
function alphabeticalCompare(a, b) {
if (a === b) {
return 0;
}
if (~~a === a && ~~b === b) {
if (a === 0 || b === 0) {
return a < b ? -1 : 1;
}
if (a < 0 || b < 0) {
if (b >= 0) {
return -1;
}
if (a >= 0) {
return 1;
}
a = -a;
b = -b;
}
al = log10(a);
bl = log10(b);
var t = 0;
if (al < bl) {
a *= POWERS_OF_TEN[bl - al - 1];
b /= 10;
t = -1;
} else if (al > bl) {
b *= POWERS_OF_TEN[al - bl - 1];
a /= 10;
t = 1;
}
if (a === b) {
return t;
}
return a < b ? -1 : 1;
}
var aStr = String(a);
var bStr = String(b);
if (aStr === bStr) {
return 0;
}
return aStr < bStr ? -1 : 1;
}
function minRunLength(n) {
var r = 0;
while (n >= DEFAULT_MIN_MERGE) {
r |= n & 1;
n >>= 1;
}
return n + r;
}
function makeAscendingRun(array, lo, hi, compare) {
var runHi = lo + 1;
if (runHi === hi) {
return 1;
}
if (compare(array[runHi++], array[lo]) < 0) {
while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
runHi++;
}
reverseRun(array, lo, runHi);
} else {
while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
runHi++;
}
}
return runHi - lo;
}
function reverseRun(array, lo, hi) {
hi--;
while (lo < hi) {
var t = array[lo];
array[lo++] = array[hi];
array[hi--] = t;
}
}
function binaryInsertionSort(array, lo, hi, start, compare) {
if (start === lo) {
start++;
}
for (; start < hi; start++) {
var pivot = array[start];
var left = lo;
var right = start;
while (left < right) {
var mid = (left + right) >>> 1;
if (compare(pivot, array[mid]) < 0) {
right = mid;
} else {
left = mid + 1;
}
}
var n = start - left;
switch (n) {
case 3:
array[left + 3] = array[left + 2];
case 2:
array[left + 2] = array[left + 1];
case 1:
array[left + 1] = array[left];
break;
default:
while (n > 0) {
array[left + n] = array[left + n - 1];
n--;
}
}
array[left] = pivot;
}
}
function gallopLeft(value, array, start, length, hint, compare) {
var lastOffset = 0,
maxOffset = 0,
offset = 1;
if (compare(value, array[start + hint]) > 0) {
maxOffset = length - hint;
while (
offset < maxOffset &&
compare(value, array[start + hint + offset]) > 0
) {
lastOffset = offset;
offset = (offset << 1) + 1;
if (offset <= 0) {
offset = maxOffset;
}
}
if (offset > maxOffset) {
offset = maxOffset;
}
lastOffset += hint;
offset += hint;
} else {
maxOffset = hint + 1;
while (
offset < maxOffset &&
compare(value, array[start + hint - offset]) <= 0
) {
lastOffset = offset;
offset = (offset << 1) + 1;
if (offset <= 0) {
offset = maxOffset;
}
}
if (offset > maxOffset) {
offset = maxOffset;
}
var tmp = lastOffset;
lastOffset = hint - offset;
offset = hint - tmp;
}
lastOffset++;
while (lastOffset < offset) {
var m = lastOffset + ((offset - lastOffset) >>> 1);
if (compare(value, array[start + m]) > 0) {
lastOffset = m + 1;
} else {
offset = m;
}
}
return offset;
}
function gallopRight(value, array, start, length, hint, compare) {
var lastOffset = 0,
maxOffset = 0,
offset = 1;
if (compare(value, array[start + hint]) < 0) {
maxOffset = hint + 1;
while (
offset < maxOffset &&
compare(value, array[start + hint - offset]) < 0
) {
lastOffset = offset;
offset = (offset << 1) + 1;
if (offset <= 0) {
offset = maxOffset;
}
}
if (offset > maxOffset) {
offset = maxOffset;
}
var tmp = lastOffset;
lastOffset = hint - offset;
offset = hint - tmp;
} else {
maxOffset = length - hint;
while (
offset < maxOffset &&
compare(value, array[start + hint + offset]) >= 0
) {
lastOffset = offset;
offset = (offset << 1) + 1;
if (offset <= 0) {
offset = maxOffset;
}
}
if (offset > maxOffset) {
offset = maxOffset;
}
lastOffset += hint;
offset += hint;
}
lastOffset++;
while (lastOffset < offset) {
var m = lastOffset + ((offset - lastOffset) >>> 1);
if (compare(value, array[start + m]) < 0) {
offset = m;
} else {
lastOffset = m + 1;
}
}
return offset;
}
var TIM_SORT_ASSERTION = "TimSortAssertion";
var TimSortAssertion = function (message) {
this.name = TIM_SORT_ASSERTION;
this.message = message;
};
var TimSort = function (array, compare) {
var self = {
array: array,
compare: compare,
minGallop: DEFAULT_MIN_GALLOPING,
length: array.length,
tmpStorageLength: DEFAULT_TMP_STORAGE_LENGTH,
stackLength: 0,
runStart: null,
runLength: null,
stackSize: 0,
pushRun: function (runStart, runLength) {
this.runStart[this.stackSize] = runStart;
this.runLength[this.stackSize] = runLength;
this.stackSize += 1;
},
mergeRuns: function () {
while (this.stackSize > 1) {
var n = this.stackSize - 2;
if (
(n >= 1 &&
this.runLength[n - 1] <=
this.runLength[n] + this.runLength[n + 1]) ||
(n >= 2 &&
this.runLength[n - 2] <=
this.runLength[n] + this.runLength[n - 1])
) {
if (this.runLength[n - 1] < this.runLength[n + 1]) {
n--;
}
} else if (this.runLength[n] > this.runLength[n + 1]) {
break;
}
this.mergeAt(n);
}
},
forceMergeRuns: function () {
while (this.stackSize > 1) {
var n = this.stackSize - 2;
if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) {
n--;
}
this.mergeAt(n);
}
},
mergeAt: function (i) {
var compare = this.compare,
array = this.array,
start1 = this.runStart[i],
length1 = this.runLength[i],
start2 = this.runStart[i + 1],
length2 = this.runLength[i + 1];
this.runLength[i] = length1 + length2;
if (i === this.stackSize - 3) {
this.runStart[i + 1] = this.runStart[i + 2];
this.runLength[i + 1] = this.runLength[i + 2];
}
this.stackSize--;
var k = gallopRight(array[start2], array, start1, length1, 0, compare);
start1 += k;
length1 -= k;
if (length1 === 0) {
return;
}
length2 = gallopLeft(
array[start1 + length1 - 1],
array,
start2,
length2,
length2 - 1,
compare
);
if (length2 === 0) {
return;
}
if (length1 <= length2) {
this.mergeLow(start1, length1, start2, length2);
} else {
this.mergeHigh(start1, length1, start2, length2);
}
},
mergeLow: function (start1, length1, start2, length2) {
var compare = this.compare,
array = this.array,
tmp = this.tmp,
i = 0;
for (var i = 0; i < length1; i++) {
tmp[i] = array[start1 + i];
}
var cursor1 = 0,
cursor2 = start2,
dest = start1;
array[dest++] = array[cursor2++];
if (--length2 === 0) {
for (var i = 0; i < length1; i++) {
array[dest + i] = tmp[cursor1 + i];
}
return;
}
if (length1 === 1) {
for (var i = 0; i < length2; i++) {
array[dest + i] = array[cursor2 + i];
}
array[dest + length2] = tmp[cursor1];
return;
}
var minGallop = this.minGallop;
while (true) {
var count1 = 0,
count2 = 0,
exit = false;
do {
if (compare(array[cursor2], tmp[cursor1]) < 0) {
array[dest++] = array[cursor2++];
count2++;
count1 = 0;
if (--length2 === 0) {
exit = true;
break;
}
} else {
array[dest++] = tmp[cursor1++];
count1++;
count2 = 0;
if (--length1 === 1) {
exit = true;
break;
}
}
} while ((count1 | count2) < minGallop);
if (exit) {
break;
}
do {
count1 = gallopRight(
array[cursor2],
tmp,
cursor1,
length1,
0,
compare
);
if (count1 !== 0) {
for (var i = 0; i < count1; i++) {
array[dest + i] = tmp[cursor1 + i];
}
dest += count1;
cursor1 += count1;
length1 -= count1;
if (length1 <= 1) {
exit = true;
break;
}
}
array[dest++] = array[cursor2++];
if (--length2 === 0) {
exit = true;
break;
}
count2 = gallopLeft(
tmp[cursor1],
array,
cursor2,
length2,
0,
compare
);
if (count2 !== 0) {
for (var i = 0; i < count2; i++) {
array[dest + i] = array[cursor2 + i];
}
dest += count2;
cursor2 += count2;
length2 -= count2;
if (length2 === 0) {
exit = true;
break;
}
}
array[dest++] = tmp[cursor1++];
if (--length1 === 1) {
exit = true;
break;
}
minGallop--;
} while (
count1 >= DEFAULT_MIN_GALLOPING ||
count2 >= DEFAULT_MIN_GALLOPING
);
if (exit) {
break;
}
if (minGallop < 0) {
minGallop = 0;
}
minGallop += 2;
}
this.minGallop = minGallop;
if (minGallop < 1) {
this.minGallop = 1;
}
if (length1 === 1) {
for (var i = 0; i < length2; i++) {
array[dest + i] = array[cursor2 + i];
}
array[dest + length2] = tmp[cursor1];
} else if (length1 === 0) {
throw new TimSortAssertion(
"mergeLow preconditions were not respected"
);
} else {
for (var i = 0; i < length1; i++) {
array[dest + i] = tmp[cursor1 + i];
}
}
},
mergeHigh: function (start1, length1, start2, length2) {
var compare = this.compare,
array = this.array,
tmp = this.tmp,
i = 0;
for (var i = 0; i < length2; i++) {
tmp[i] = array[start2 + i];
}
var cursor1 = start1 + length1 - 1,
cursor2 = length2 - 1,
dest = start2 + length2 - 1,
customCursor = 0,
customDest = 0;
array[dest--] = array[cursor1--];
if (--length1 === 0) {
customCursor = dest - (length2 - 1);
for (var i = 0; i < length2; i++) {
array[customCursor + i] = tmp[i];
}
return;
}
if (length2 === 1) {
dest -= length1;
cursor1 -= length1;
customDest = dest + 1;
customCursor = cursor1 + 1;
for (var i = length1 - 1; i >= 0; i--) {
array[customDest + i] = array[customCursor + i];
}
array[dest] = tmp[cursor2];
return;
}
var minGallop = this.minGallop;
while (true) {
var count1 = 0,
count2 = 0,
exit = false;
do {
if (compare(tmp[cursor2], array[cursor1]) < 0) {
array[dest--] = array[cursor1--];
count1++;
count2 = 0;
if (--length1 === 0) {
exit = true;
break;
}
} else {
array[dest--] = tmp[cursor2--];
count2++;
count1 = 0;
if (--length2 === 1) {
exit = true;
break;
}
}
} while ((count1 | count2) < minGallop);
if (exit) {
break;
}
do {
count1 =
length1 -
gallopRight(
tmp[cursor2],
array,
start1,
length1,
length1 - 1,
compare
);
if (count1 !== 0) {
dest -= count1;
cursor1 -= count1;
length1 -= count1;
customDest = dest + 1;
customCursor = cursor1 + 1;
for (var i = count1 - 1; i >= 0; i--) {
array[customDest + i] = array[customCursor + i];
}
if (length1 === 0) {
exit = true;
break;
}
}
array[dest--] = tmp[cursor2--];
if (--length2 === 1) {
exit = true;
break;
}
count2 =
length2 -
gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
if (count2 !== 0) {
dest -= count2;
cursor2 -= count2;
length2 -= count2;
customDest = dest + 1;
customCursor = cursor2 + 1;
for (var i = 0; i < count2; i++) {
array[customDest + i] = tmp[customCursor + i];
}
if (length2 <= 1) {
exit = true;
break;
}
}
array[dest--] = array[cursor1--];
if (--length1 === 0) {
exit = true;
break;
}
minGallop--;
} while (
count1 >= DEFAULT_MIN_GALLOPING ||
count2 >= DEFAULT_MIN_GALLOPING
);
if (exit) {
break;
}
if (minGallop < 0) {
minGallop = 0;
}
minGallop += 2;
}
this.minGallop = minGallop;
if (minGallop < 1) {
this.minGallop = 1;
}
if (length2 === 1) {
dest -= length1;
cursor1 -= length1;
customDest = dest + 1;
customCursor = cursor1 + 1;
for (var i = length1 - 1; i >= 0; i--) {
array[customDest + i] = array[customCursor + i];
}
array[dest] = tmp[cursor2];
} else if (length2 == 0) {
throw new TimSortAssertion(
"mergeHigh preconditions were not respected"
);
} else {
customCursor = dest - (length2 - 1);
for (var i = 0; i < length2; i++) {
array[customCursor + i] = tmp[i];
}
}
},
};
if (self.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) {
self.tmpStorageLength = self.length >>> 1;
}
self.tmp = new Array(self.tmpStorageLength);
self.stackLength =
self.length < 120
? 5
: self.length < 1542
? 10
: self.length < 119151
? 19
: 40;
self.runStart = new Array(self.stackLength);
self.runLength = new Array(self.stackLength);
return self;
};
function tim_sort(array, compare, lo, hi) {
if (!Array.isArray(array)) {
throw _b_.TypeError.$factory("Can only sort arrays");
}
if (!compare) {
compare = alphabeticalCompare;
} else if (typeof compare !== "function") {
hi = lo;
lo = compare;
compare = alphabeticalCompare;
}
if (!lo) {
lo = 0;
}
if (!hi) {
hi = array.length;
}
var remaining = hi - lo;
if (remaining < 2) {
return;
}
var runLength = 0;
if (remaining < DEFAULT_MIN_MERGE) {
runLength = makeAscendingRun(array, lo, hi, compare);
binaryInsertionSort(array, lo, hi, lo + runLength, compare);
return;
}
var ts = new TimSort(array, compare);
var minRun = minRunLength(remaining);
do {
runLength = makeAscendingRun(array, lo, hi, compare);
if (runLength < minRun) {
var force = remaining;
if (force > minRun) {
force = minRun;
}
binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
runLength = force;
}
ts.pushRun(lo, runLength);
ts.mergeRuns();
remaining -= runLength;
lo += runLength;
} while (remaining !== 0);
ts.forceMergeRuns();
}
function tim_sort_safe(array, compare) {
try {
tim_sort(array, compare, 0, array.length);
} catch (e) {
if (e.name == TIM_SORT_ASSERTION) {
array.sort(compare);
} else {
throw e;
}
}
}
$B.$TimSort = tim_sort_safe;
$B.$AlphabeticalCompare = alphabeticalCompare;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
_b_.__debug__ = false;
$B.$comps = { ">": "gt", ">=": "ge", "<": "lt", "<=": "le" };
$B.$inv_comps = { ">": "lt", ">=": "le", "<": "gt", "<=": "ge" };
var check_nb_args = ($B.check_nb_args = function (name, expected, args) {
var len = args.length,
last = args[len - 1];
if (last && last.$nat == "kw") {
var kw = last.kw;
if (Array.isArray(kw) && kw[1] && kw[1].__class__ === _b_.dict) {
if (Object.keys(kw[1].$string_dict).length == 0) {
len--;
}
}
}
if (len != expected) {
if (expected == 0) {
throw _b_.TypeError.$factory(
name + "() takes no argument" + " (" + len + " given)"
);
} else {
throw _b_.TypeError.$factory(
name +
"() takes exactly " +
expected +
" argument" +
(expected < 2 ? "" : "s") +
" (" +
len +
" given)"
);
}
}
});
var check_no_kw = ($B.check_no_kw = function (name, x, y) {
if (x === undefined) {
console.log("x undef", name, x, y);
}
if (
(x.$nat && x.kw && x.kw[0] && x.kw[0].length > 0) ||
(y !== undefined && y.$nat)
) {
throw _b_.TypeError.$factory(name + "() takes no keyword arguments");
}
});
var NoneType = {
$factory: function () {
return None;
},
$infos: { __name__: "NoneType", __module__: "builtins" },
__bool__: function (self) {
return False;
},
__class__: _b_.type,
__hash__: function (self) {
return 0;
},
__mro__: [_b_.object],
__repr__: function (self) {
return "None";
},
__str__: function (self) {
return "None";
},
$is_class: true,
};
NoneType.__setattr__ = function (self, attr) {
return no_set_attr(NoneType, attr);
};
var None = { __class__: NoneType };
for (var $op in $B.$comps) {
var key = $B.$comps[$op];
switch (key) {
case "ge":
case "gt":
case "le":
case "lt":
NoneType["__" + key + "__"] = (function (op) {
return function (other) {
return _b_.NotImplemented;
};
})($op);
}
}
for (var $func in None) {
if (typeof None[$func] == "function") {
None[$func].__str__ = (function (f) {
return function () {
return "<method-wrapper " + f + " of NoneType object>";
};
})($func);
}
}
$B.set_func_names(NoneType, "builtins");
function __build_class__() {
throw _b_.NotImplementedError.$factory("__build_class__");
}
function abs(obj) {
check_nb_args("abs", 1, arguments);
check_no_kw("abs", obj);
if (isinstance(obj, _b_.int)) {
if (obj.__class__ === $B.long_int) {
return {
__class__: $B.long_int,
value: obj.value,
pos: true,
};
} else {
return _b_.int.$factory(Math.abs(obj));
}
}
if (isinstance(obj, _b_.float)) {
return _b_.float.$factory(Math.abs(_b_.float.numerator(obj)));
}
var klass = obj.__class__ || $B.get_class(obj);
try {
var method = $B.$getattr(klass, "__abs__");
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"Bad operand type for abs(): '" + $B.class_name(obj) + "'"
);
}
throw err;
}
return $B.$call(method)(obj);
}
function aiter(async_iterable) {
return $B.$call($B.$getattr(async_iterable, "__aiter__"))();
}
function all(obj) {
check_nb_args("all", 1, arguments);
check_no_kw("all", obj);
var iterable = iter(obj);
while (1) {
try {
var elt = next(iterable);
if (!$B.$bool(elt)) {
return false;
}
} catch (err) {
return true;
}
}
}
function anext(async_iterator, _default) {
var missing = {},
$ = $B.args(
"anext",
2,
{ async_iterator: null, _default: null },
["async_iterator", "_default"],
arguments,
{ _default: missing },
null,
null
);
var awaitable = $B.$call($B.$getattr(async_iterator, "__anext__"))();
return awaitable;
}
function any(obj) {
check_nb_args("any", 1, arguments);
check_no_kw("any", obj);
var iterable = iter(obj);
while (1) {
try {
var elt = next(iterable);
if ($B.$bool(elt)) {
return true;
}
} catch (err) {
return false;
}
}
}
function ascii(obj) {
check_nb_args("ascii", 1, arguments);
check_no_kw("ascii", obj);
var res = repr(obj),
res1 = "",
cp;
for (var i = 0; i < res.length; i++) {
cp = res.charCodeAt(i);
if (cp < 128) {
res1 += res.charAt(i);
} else if (cp < 256) {
res1 += "\\x" + cp.toString(16);
} else {
var s = cp.toString(16);
if (s.length % 2 == 1) {
s = "0" + s;
}
res1 += "\\u" + s;
}
}
return res1;
}
function $builtin_base_convert_helper(obj, base) {
var prefix = "";
switch (base) {
case 2:
prefix = "0b";
break;
case 8:
prefix = "0o";
break;
case 16:
prefix = "0x";
break;
default:
console.log("invalid base:" + base);
}
if (obj.__class__ === $B.long_int) {
var res = prefix + $B.long_int.to_base(obj, base);
if (!obj.pos) {
res = "-" + res;
}
return res;
}
var value = $B.$GetInt(obj);
if (value === undefined) {
throw _b_.TypeError.$factory(
"Error, argument must be an integer or" +
" contains an __index__ function"
);
}
if (value >= 0) {
return prefix + value.toString(base);
}
return "-" + prefix + (-value).toString(base);
}
function bin_hex_oct(base, obj) {
if (isinstance(obj, _b_.int)) {
return $builtin_base_convert_helper(obj, base);
} else {
try {
var klass = obj.__class__ || $B.get_class(obj),
method = $B.$getattr(klass, "__index__");
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(obj) +
"' object cannot be interpreted as an integer"
);
}
throw err;
}
var res = $B.$call(method)(obj);
return $builtin_base_convert_helper(res, base);
}
}
function bin(obj) {
check_nb_args("bin", 1, arguments);
check_no_kw("bin", obj);
return bin_hex_oct(2, obj);
}
function breakpoint() {
$B.$import("sys", []);
var missing = {},
hook = $B.$getattr($B.imported.sys, "breakpointhook", missing);
if (hook === missing) {
throw _b_.RuntimeError.$factory("lost sys.breakpointhook");
}
return $B.$call(hook).apply(null, arguments);
}
function callable(obj) {
check_nb_args("callable", 1, arguments);
check_no_kw("callable", obj);
return hasattr(obj, "__call__");
}
function chr(i) {
check_nb_args("chr", 1, arguments);
check_no_kw("chr", i);
i = $B.PyNumber_Index(i);
if (i < 0 || i > 1114111) {
throw _b_.ValueError.$factory("Outside valid range");
} else if (i >= 0x10000 && i <= 0x10ffff) {
var code = i - 0x10000;
return (
String.fromCodePoint(0xd800 | (code >> 10)) +
String.fromCodePoint(0xdc00 | (code & 0x3ff))
);
} else {
return String.fromCodePoint(i);
}
}
var classmethod = $B.make_class("classmethod", function (func) {
check_nb_args("classmethod", 1, arguments);
check_no_kw("classmethod", func);
var f = function () {
return func.apply(null, arguments);
};
f.__class__ = $B.method;
if (func.$attrs) {
for (var key in func.$attrs) {
f[key] = func.$attrs[key];
}
}
f.$infos = { __func__: func, __name__: func.$infos.__name__ };
f.__get__ = function (obj, cls) {
var method = function () {
return f(cls, ...arguments);
};
method.__class__ = $B.method;
method.$infos = {
__self__: cls,
__func__: f,
__name__: func.$infos.__name__,
__qualname__: cls.$infos.__name__ + "." + func.$infos.__name__,
};
return method;
};
f.__get__.__class__ = $B.method_wrapper;
f.__get__.$infos = func.$infos;
return f;
});
$B.set_func_names(classmethod, "builtins");
var code = ($B.code = $B.make_class("code"));
code.__repr__ = code.__str__ = function (self) {
return "<code object " + self.co_name + ", file " + self.co_filename + ">";
};
code.__getattribute__ = function (self, attr) {
return self[attr];
};
$B.set_func_names(code, "builtins");
function compile() {
var $ = $B.args(
"compile",
6,
{
source: null,
filename: null,
mode: null,
flags: null,
dont_inherit: null,
optimize: null,
_feature_version: null,
},
[
"source",
"filename",
"mode",
"flags",
"dont_inherit",
"optimize",
"_feature_version",
],
arguments,
{ flags: 0, dont_inherit: false, optimize: -1, _feature_version: 0 },
null,
null
);
var module_name = "$exec_" + $B.UUID();
$.__class__ = code;
$.co_flags = $.flags;
$.name = "<module>";
var interactive = $.mode == "single" && $.flags & 0x200;
if (_b_.isinstance($.source, _b_.bytes)) {
var encoding = "utf-8",
lfpos = $.source.source.indexOf(10),
first_line,
second_line;
if (lfpos == -1) {
first_line = $.source;
} else {
first_line = _b_.bytes.$factory($.source.source.slice(0, lfpos));
}
first_line = _b_.bytes.decode(first_line, "latin-1");
var encoding_re = /^[\t\f]*#.*?coding[:=][\t]*([-_.a-zA-Z0-9]+)/;
var mo = first_line.match(encoding_re);
if (mo) {
encoding = mo[1];
} else if (lfpos > -1) {
var rest = $.source.source.slice(lfpos + 1);
lfpos = rest.indexOf(10);
if (lfpos > -1) {
second_line = _b_.bytes.$factory(rest.slice(0, lfpos));
} else {
second_line = _b_.bytes.$factory(rest);
}
second_line = _b_.bytes.decode(second_line, "latin-1");
var mo = second_line.match(encoding_re);
if (mo) {
encoding = mo[1];
}
}
$.source = _b_.bytes.decode($.source, encoding);
}
if (!_b_.isinstance($.filename, [_b_.bytes, _b_.str])) {
$B.imported._warnings.warn(
_b_.DeprecationWarning.$factory(
`path should be string, bytes, or os.PathLike, ` +
`not ${$B.class_name($.filename)}`
)
);
}
if (interactive && !$.source.endsWith("\n")) {
var lines = $.source.split("\n");
if ($B.last(lines).startsWith(" ")) {
throw _b_.SyntaxError.$factory("unexpected EOF while parsing");
}
}
var root = $B.parser.$create_root_node(
{ src: $.source, filename: $.filename },
module_name,
module_name
);
root.mode = $.mode;
root.parent_block = $B.builtins_scope;
$B.parser.dispatch_tokens(root, $.source);
if ($.flags == $B.PyCF_ONLY_AST) {
$B.create_python_ast_classes();
var _ast = root.ast(),
klass = _ast.constructor.$name;
return $B.python_ast_classes[klass].$factory(_ast);
}
return $;
}
var __debug__ = $B.debug > 0;
function delattr(obj, attr) {
check_no_kw("delattr", obj, attr);
check_nb_args("delattr", 2, arguments);
if (typeof attr != "string") {
throw _b_.TypeError.$factory(
"attribute name must be string, not '" + $B.class_name(attr) + "'"
);
}
return $B.$getattr(obj, "__delattr__")(attr);
}
$B.$delete = function (name, is_global) {
function del(obj) {
if (obj.__class__ === $B.generator) {
obj.js_gen.return();
}
}
var found = false,
frame = $B.last($B.frames_stack);
if (!is_global) {
if (frame[1][name] !== undefined) {
found = true;
del(frame[1][name]);
delete frame[1][name];
}
} else {
if (frame[2] != frame[0] && frame[3][name] !== undefined) {
found = true;
del(frame[3][name]);
delete frame[3][name];
}
}
if (!found) {
throw $B.name_error(name);
}
};
function dir(obj) {
if (obj === undefined) {
var frame = $B.last($B.frames_stack);
(locals_obj = frame[1]), (res = _b_.list.$factory()), (pos = 0);
for (var attr in locals_obj) {
if (attr.charAt(0) == "$" && attr.charAt(1) != "$") {
continue;
}
res[pos++] = attr;
}
_b_.list.sort(res);
return res;
}
check_nb_args("dir", 1, arguments);
check_no_kw("dir", obj);
var klass = obj.__class__ || $B.get_class(obj);
if (obj.$is_class) {
var dir_func = $B.$getattr(obj.__class__, "__dir__");
return $B.$call(dir_func)(obj);
}
try {
var res = $B.$call($B.$getattr(obj, "__dir__"))();
res = _b_.list.$factory(res);
return res;
} catch (err) {}
var res = [],
pos = 0;
for (var attr in obj) {
if (
attr.charAt(0) !== "$" &&
attr !== "__class__" &&
obj[attr] !== undefined
) {
res[pos++] = attr;
}
}
res.sort();
return res;
}
function divmod(x, y) {
check_no_kw("divmod", x, y);
check_nb_args("divmod", 2, arguments);
var klass = x.__class__ || $B.get_class(x);
var dm = $B.$getattr(klass, "__divmod__", _b_.None);
if (dm !== _b_.None) {
return dm(x, y);
}
return _b_.tuple.$factory([
$B.$getattr(klass, "__floordiv__")(x, y),
$B.$getattr(klass, "__mod__")(x, y),
]);
}
var enumerate = $B.make_class("enumerate", function () {
var $ns = $B.args(
"enumerate",
2,
{ iterable: null, start: null },
["iterable", "start"],
arguments,
{ start: 0 },
null,
null
),
_iter = iter($ns["iterable"]),
start = $ns["start"];
return {
__class__: enumerate,
__name__: "enumerate iterator",
counter: start - 1,
iter: _iter,
start: start,
};
});
enumerate.__iter__ = function (self) {
self.counter = self.start - 1;
return self;
};
enumerate.__next__ = function (self) {
self.counter++;
return $B.fast_tuple([self.counter, next(self.iter)]);
};
$B.set_func_names(enumerate, "builtins");
function make_proxy(dict, lineno) {
const handler = {
get: function (target, prop) {
console.log("get proxy attr", prop, target);
if (prop == "__class__") {
return _b_.dict;
} else if (prop == "$lineno") {
return lineno;
}
if (target.$string_dict.hasOwnProperty(prop)) {
return target.$string_dict[prop][0];
}
return undefined;
},
set: function (target, prop, value) {
_b_.dict.$setitem(target, prop, value);
},
};
return new Proxy(dict, handler);
}
function eval1(src, mode, _globals, _locals) {
var frame = $B.last($B.frames_stack);
var lineno = frame[1].$lineno;
$B.exec_scope = $B.exec_scope || {};
if (src.endsWith("\\\n")) {
var exc = _b_.SyntaxError.$factory("");
var lines = src.split("\n"),
line = lines[lines.length - 2];
exc.args = [
"unexpected EOF while parsing",
["<string>", lines.length - 1, 1, line],
];
throw exc;
}
var local_name = "locals_exec",
global_name = "globals_exec",
exec_locals = {},
exec_globals = {};
var handler = {
get: function (obj, prop) {
return obj[prop];
},
set: function (obj, prop, value) {
if (["__file__", "$lineno"].indexOf(prop) == -1) {
obj[prop] = value;
}
},
};
if (_globals === _b_.None) {
exec_locals = new Proxy(frame[1], handler);
exec_globals = new Proxy(frame[3], handler);
} else {
if (_globals.__class__ !== _b_.dict) {
throw _b_.TypeError.$factory(
`${mode}() globals must be ` +
"a dict, not " +
$B.class_name(_globals)
);
}
exec_globals = {};
if (_globals.$jsobj) {
exec_globals = new Proxy(_globals.$jsobj, handler);
} else {
if (_globals.$jsobj) {
exec_globals = _globals.$jsobj;
} else {
exec_globals = _globals.$jsobj = {};
}
for (var key in _globals.$string_dict) {
_globals.$jsobj[key] = _globals.$string_dict[key][0];
if (key == "__name__") {
global_name = _globals.$jsobj[key];
}
}
}
if (exec_globals.__builtins__ === undefined) {
exec_globals.__builtins__ = _b_.__builtins__;
}
if (_locals === _b_.None) {
exec_locals = exec_globals;
} else {
if (global_name == local_name) {
global_name += "_globals";
}
if (_locals.$jsobj) {
for (var key in _locals.$jsobj) {
exec_globals[key] = _locals.$jsobj[key];
}
} else {
if (_locals.$jsobj) {
exec_locals = _locals.$jsobj;
} else {
exec_locals = _locals.$jsobj = { $dict: _locals };
}
for (var key in _locals.$string_dict) {
_locals.$jsobj[key] = _locals.$string_dict[key][0];
}
exec_locals.$getitem = $B.$call(
$B.$getattr(_locals.__class__, "__getitem__")
);
var missing = $B.$getattr(_locals.__class__, "__missing__", null);
if (missing) {
exec_locals.$missing = $B.$call(missing);
}
}
}
}
var root = $B.parser.$create_root_node(
src,
"<module>",
frame[0],
frame[2],
1
);
root.mode = mode;
$B.parser.dispatch_tokens(root);
var _ast = root.ast(),
symtable = $B._PySymtable_Build(_ast, "exec"),
js = $B.js_from_root(_ast, symtable, "<string>", {
local_name,
exec_locals,
global_name,
exec_globals,
});
var save_frames_stack = $B.frames_stack.slice();
$B.frames_stack = [];
var top_frame = [local_name, exec_locals, global_name, exec_globals];
top_frame.is_exec_top = true;
exec_locals.$f_trace = $B.enter_frame(top_frame);
if (mode == "eval") {
js = "return " + js;
}
var exec_func = new Function(
"$B",
"_b_",
"locals",
local_name,
global_name,
js
);
try {
var res = exec_func($B, _b_, exec_locals, exec_locals, exec_globals);
} catch (err) {
$B.frames_stack = save_frames_stack;
throw err;
}
if (_globals !== _b_.None) {
for (var key in exec_globals) {
if (!key.startsWith("$")) {
_b_.dict.$setitem(_globals, key, exec_globals[key]);
}
}
if (_locals !== _b_.None) {
for (var key in exec_locals) {
if (!key.startsWith("$")) {
_b_.dict.$setitem(_locals, key, exec_locals[key]);
}
}
}
}
$B.frames_stack = save_frames_stack;
return res;
}
function $$eval(src, _globals, _locals) {
var $ = $B.args(
"eval",
4,
{ src: null, globals: null, locals: null, mode: null },
["src", "globals", "locals", "mode"],
arguments,
{ globals: _b_.None, locals: _b_.None, mode: "eval" },
null,
null
),
src = $.src,
_globals = $.globals,
_locals = $.locals,
mode = $.mode;
if (
$.src.mode &&
$.src.mode == "single" &&
["<console>", "<stdin>"].indexOf($.src.filename) > -1
) {
_b_.print(">", $.src.source.trim());
}
if (src.__class__ === code) {
mode = src.mode;
src = src.source;
} else if (!src.valueOf || typeof src.valueOf() !== "string") {
throw _b_.TypeError.$factory(
`${mode}() arg 1 must be a string,` + " bytes or code object"
);
} else {
src = src.valueOf();
}
if ($B.js_from_ast) {
return eval1(src, mode, _globals, _locals);
}
var current_frame = $B.frames_stack[$B.frames_stack.length - 1];
if (current_frame !== undefined) {
var current_locals_id = current_frame[0].replace(/\./g, "_"),
current_globals_id = current_frame[2].replace(/\./g, "_");
}
var stack_len = $B.frames_stack.length;
var globals_id = "$exec_" + $B.UUID(),
globals_name = globals_id,
locals_id = "$exec_" + $B.UUID(),
parent_scope;
if (_globals === _b_.None) {
if (current_locals_id == current_globals_id) {
locals_id = globals_id;
}
var local_scope = {
module: globals_id,
id: locals_id,
binding: {},
bindings: {},
};
for (var attr in current_frame[1]) {
local_scope.binding[attr] = true;
local_scope.bindings[attr] = true;
}
var global_scope = {
module: globals_id,
id: globals_id,
binding: {},
bindings: {},
};
for (var attr in current_frame[3]) {
global_scope.binding[attr] = true;
global_scope.bindings[attr] = true;
}
local_scope.parent_block = global_scope;
global_scope.parent_block = $B.builtins_scope;
parent_scope = local_scope;
eval("$locals_" + parent_scope.id + " = current_frame[1]");
} else {
if (_globals.__class__ != _b_.dict) {
throw _b_.TypeError.$factory(
"exec() globals must be a dict, not " + $B.class_name(_globals)
);
}
if (_globals.globals_id) {
globals_id = globals_name = _globals.globals_id;
}
_globals.globals_id = globals_id;
if (_locals === _globals || _locals === _b_.None) {
locals_id = globals_id;
parent_scope = $B.builtins_scope;
} else {
var grandparent_scope = {
id: globals_id,
parent_block: $B.builtins_scope,
binding: {},
};
parent_scope = {
id: locals_id,
parent_block: grandparent_scope,
binding: {},
};
for (var attr in _globals.$string_dict) {
grandparent_scope.binding[attr] = true;
}
for (var attr in _locals.$string_dict) {
parent_scope.binding[attr] = true;
}
}
}
eval(
"var $locals_" + globals_id + " = {}\nvar $locals_" + locals_id + " = {}"
);
if (_globals === _b_.None) {
var gobj = current_frame[3],
ex = "var $locals_" + globals_id + " = gobj;",
obj = {};
eval(ex);
for (var attr in gobj) {
if (attr.startsWith("$")) {
continue;
}
obj[attr] = gobj[attr];
}
eval("$locals_" + globals_id + " = obj");
} else {
var globals_is_dict = false;
if (_globals.$jsobj) {
var items = _globals.$jsobj;
} else {
var items = _b_.dict.$to_obj(_globals);
_globals.$jsobj = items;
globals_is_dict = true;
}
eval("$locals_" + globals_id + " = _globals.$jsobj");
for (var item in items) {
try {
eval("$locals_" + globals_id + '["' + item + '"] = items.' + item);
} catch (err) {
console.log(err);
console.log("error setting", item);
break;
}
}
}
_globals.$is_namespace = true;
if (_locals === _b_.None) {
if (_globals !== _b_.None) {
eval("var $locals_" + locals_id + " = $locals_" + globals_id);
} else {
var lobj = current_frame[1],
ex = "",
obj = {};
for (var attr in current_frame[1]) {
if (attr.startsWith("$")) {
continue;
}
obj[attr] = lobj[attr];
}
eval("$locals_" + locals_id + " = obj");
}
} else {
var items;
if (_locals.$jsobj) {
items = _locals.$jsobj;
} else if (_locals.__class__ !== _b_.dict) {
items = _locals;
} else {
items = _b_.dict.$to_obj(_locals);
_locals.$jsobj = items;
}
for (var item in items) {
try {
eval("$locals_" + locals_id + '["' + item + '"] = items.' + item);
} catch (err) {
console.log(err);
console.log("error setting", item);
break;
}
}
eval("$locals_" + locals_id + ".$exec_locals = true");
eval(
"$locals_" +
locals_id +
".$is_not_dict = " +
(_locals.__class__ !== _b_.dict)
);
}
_locals.$is_namespace = true;
if (
_globals === _b_.None &&
_locals === _b_.None &&
current_frame[0] == current_frame[2]
) {
} else {
eval("$locals_" + locals_id + ".$src = src");
}
var root = $B.py2js(src, globals_id, locals_id, parent_scope),
js,
gns,
lns;
if (
_globals !== _b_.None &&
(_locals === _b_.None || _locals === _globals)
) {
for (var attr in _globals.$string_dict) {
root.binding[attr] = true;
}
}
function update_namespaces() {
var gns = eval("$locals_" + globals_id);
if ($B.frames_stack[$B.frames_stack.length - 1][2] == globals_id) {
gns = $B.frames_stack[$B.frames_stack.length - 1][3];
}
if (_locals !== _b_.None) {
var lns = eval("$locals_" + locals_id);
}
if (_globals !== _b_.None) {
if (globals_is_dict) {
var jsobj = _globals.$jsobj;
delete _globals.$jsobj;
}
for (var attr in gns) {
if (attr.charAt(0) != "$") {
if (globals_is_dict) {
_b_.dict.$setitem(_globals, attr, gns[attr]);
} else {
_globals.$jsobj[attr] = gns[attr];
}
}
}
for (var attr in _globals.$string_dict) {
if (attr.startsWith("$")) {
delete _globals.$string_dict[attr];
}
}
} else {
for (var attr in gns) {
if (attr !== "$src") {
current_frame[3][attr] = gns[attr];
}
}
}
if (_locals !== _b_.None) {
for (var attr in lns) {
if (attr.charAt(0) != "$") {
if (_locals.$jsobj) {
_locals.$jsobj[attr] = lns[attr];
} else if (_locals.__class__ !== _b_.dict) {
$B.$setitem(_locals, attr, lns[attr]);
} else {
_b_.dict.$setitem(_locals, attr, lns[attr]);
}
}
}
} else {
for (var attr in lns) {
if (attr !== "$src") {
current_frame[1][attr] = lns[attr];
}
}
}
}
try {
var try_node = root.children[root.children.length - 2],
instr = try_node.children[try_node.children.length - 2];
var type = instr.C.tree[0].type;
switch (type) {
case "expr":
case "list_or_tuple":
case "op":
case "ternary":
case "unary":
var children = try_node.children;
root.children.splice(root.children.length - 2, 2);
for (var i = 0; i < children.length - 1; i++) {
root.add(children[i]);
}
break;
default:
if (mode == "eval") {
throw _b_.SyntaxError.$factory(
"eval() argument must be an expression",
"<string>",
1,
1,
src
);
}
}
if (mode != "eval") {
var last = $B.last(root.children),
js = last.to_js();
if (["node_js"].indexOf(last.C.type) == -1) {
last.to_js = function () {
while (js.endsWith("\n")) {
js = js.substr(0, js.length - 1);
}
while (js.endsWith(";")) {
js = js.substr(0, js.length - 1);
}
return "return (" + js + ")";
};
}
js = root.to_js();
var locals_obj = eval("$locals_" + locals_id),
globals_obj = eval("$locals_" + globals_id);
if (_globals === _b_.None) {
var res = new Function(
"$locals_" + globals_id,
"$locals_" + locals_id,
js
)(globals_obj, locals_obj);
} else {
current_globals_obj = current_frame[3];
current_locals_obj = current_frame[1];
var res = new Function(
"$locals_" + globals_id,
"$locals_" + locals_id,
"$locals_" + current_globals_id,
"$locals_" + current_locals_id,
js
)(globals_obj, locals_obj, current_globals_obj, current_locals_obj);
}
if (
$.src.mode &&
$.src.mode == "single" &&
$.src.filename == "<stdin>"
) {
if (res !== _b_.None && res !== undefined) {
_b_.print(_b_.repr(res));
}
}
} else {
js = root.to_js();
var res = eval(js);
}
if (
$.src.filename == "<console>" &&
$.src.mode == "single" &&
res !== undefined &&
res !== _b_.None
) {
_b_.print(res);
}
update_namespaces();
if (res === undefined) {
return _b_.None;
}
return res;
} catch (err) {
update_namespaces();
err.src = src;
err.module = globals_id;
if (err.$py_error === undefined) {
console.log(
"Javascript error",
Object.getPrototypeOf(err).name,
err.message
);
var lineNumber = err.lineNumber;
if (lineNumber !== undefined) {
console.log("around JS line", lineNumber);
console.log(
js
.split("\n")
.slice(lineNumber - 5, lineNumber + 5)
.join("\n")
);
var lines_before = js.split("\n").slice(0, lineNumber),
re = new RegExp('line_info = "(.*?)"', "g"),
matches = new String(lines_before).matchAll(re),
line_info;
for (var match of matches) {
line_info = match[1];
}
if (line_info) {
console.log("around source line", line_info.split(",")[0]);
}
}
throw $B.exception(err);
}
if (globals_is_dict) {
delete _globals.$jsobj;
}
throw err;
} finally {
if ($B.frames_stack.length == stack_len + 1) {
$B.frames_stack.pop();
}
root = null;
js = null;
gns = null;
lns = null;
$B.clear_ns(globals_id);
$B.clear_ns(locals_id);
}
}
$$eval.$is_func = true;
function exec(src, globals, locals) {
var missing = {};
var $ = $B.args(
"exec",
3,
{ src: null, globals: null, locals: null },
["src", "globals", "locals"],
arguments,
{ globals: _b_.None, locals: _b_.None },
null,
null
),
src = $.src,
globals = $.globals,
locals = $.locals;
return $$eval(src, globals, locals, "exec") || _b_.None;
}
exec.$is_func = true;
function exit() {
throw _b_.SystemExit;
}
exit.__repr__ = exit.__str__ = function () {
return "Use exit() or Ctrl-Z plus Return to exit";
};
var filter = $B.make_class("filter", function (func, iterable) {
check_no_kw("filter", func, iterable);
check_nb_args("filter", 2, arguments);
iterable = iter(iterable);
if (func === _b_.None) {
func = $B.$bool;
}
return {
__class__: filter,
func: func,
iterable: iterable,
};
});
filter.__iter__ = function (self) {
return self;
};
filter.__next__ = function (self) {
while (true) {
var _item = next(self.iterable);
if (self.func(_item)) {
return _item;
}
}
};
$B.set_func_names(filter, "builtins");
function format(value, format_spec) {
var $ = $B.args(
"format",
2,
{ value: null, format_spec: null },
["value", "format_spec"],
arguments,
{ format_spec: "" },
null,
null
);
var klass = value.__class__ || $B.get_class(value);
try {
var method = $B.$getattr(klass, "__format__");
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.NotImplementedError(
"__format__ is not implemented " +
"for object '" +
_b_.str.$factory(value) +
"'"
);
}
throw err;
}
return $B.$call(method)(value, $.format_spec);
}
function attr_error(attr, obj) {
var cname = $B.get_class(obj);
var msg = "bad operand type for unary #: '" + cname + "'";
switch (attr) {
case "__neg__":
throw _b_.TypeError.$factory(msg.replace("#", "-"));
case "__pos__":
throw _b_.TypeError.$factory(msg.replace("#", "+"));
case "__invert__":
throw _b_.TypeError.$factory(msg.replace("#", "~"));
case "__call__":
throw _b_.TypeError.$factory(
"'" + cname + "'" + " object is not callable"
);
default:
throw $B.attr_error(attr, obj);
}
}
function getattr() {
var missing = {};
var $ = $B.args(
"getattr",
3,
{ obj: null, attr: null, _default: null },
["obj", "attr", "_default"],
arguments,
{ _default: missing },
null,
null
);
return $B.$getattr(
$.obj,
$.attr,
$._default === missing ? undefined : $._default
);
}
function in_mro(klass, attr) {
if (klass === undefined) {
return false;
}
if (klass.hasOwnProperty(attr)) {
return klass[attr];
}
var mro = klass.__mro__;
for (var i = 0, len = mro.length; i < len; i++) {
if (mro[i].hasOwnProperty(attr)) {
return mro[i][attr];
}
}
return false;
}
$B.$getattr = function (obj, attr, _default) {
var res;
if (
obj.$method_cache &&
obj.$method_cache[attr] &&
obj.__class__ &&
obj.__class__[attr] == obj.$method_cache[attr][1]
) {
return obj.$method_cache[attr][0];
}
var rawname = attr;
if (obj === undefined) {
console.log("get attr", attr, "of undefined");
}
var is_class = obj.$is_class || obj.$factory;
var klass = obj.__class__;
var $test = false;
if ($test) {
console.log("$getattr", attr, "\nobj", obj, "\nklass", klass);
}
if (
klass !== undefined &&
!klass.$native &&
klass.__bases__ &&
klass.__getattribute__ === undefined &&
(klass.__bases__.length == 0 ||
(klass.__bases__.length == 1 && klass.__bases__[0] === _b_.object))
) {
if ($test) {
console.log("class without parent", klass);
console.log("\nobj[attr]", obj[attr]);
}
if (obj[attr] !== undefined) {
return obj[attr];
} else if (
obj.__dict__ &&
obj.__dict__.$string_dict.hasOwnProperty(attr) &&
!(klass.hasOwnProperty(attr) && klass[attr].__get__)
) {
return obj.__dict__.$string_dict[attr][0];
} else if (klass.hasOwnProperty(attr)) {
if (
typeof klass[attr] != "function" &&
attr != "__dict__" &&
klass[attr].__get__ === undefined
) {
var kl = klass[attr].__class__;
if (!in_mro(kl, "__get__")) {
return klass[attr];
}
}
}
}
if ($test) {
console.log("attr", attr, "of", obj, "class", klass, "isclass", is_class);
}
if (klass === undefined) {
if (typeof obj == "string") {
klass = _b_.str;
} else if (typeof obj == "number") {
klass = obj % 1 == 0 ? _b_.int : _b_.float;
} else if (obj instanceof Number) {
klass = _b_.float;
} else {
klass = $B.get_class(obj);
if (klass === undefined) {
if ($test) {
console.log("no class", attr, obj.hasOwnProperty(attr), obj[attr]);
}
res = obj[attr];
if (res !== undefined) {
if (typeof res == "function") {
var f = function () {
return res.apply(obj, arguments);
};
f.$infos = { __name__: attr, __qualname__: attr };
return f;
} else {
return $B.$JS2Py(res);
}
}
if (_default !== undefined) {
return _default;
}
throw $B.attr_error(rawname, obj);
}
}
}
switch (attr) {
case "__call__":
if (typeof obj == "function") {
res = function () {
return obj.apply(null, arguments);
};
res.__class__ = method_wrapper;
res.$infos = { __name__: "__call__" };
return res;
}
break;
case "__class__":
return klass;
case "__dict__":
if (is_class) {
var proxy = {};
for (var key in obj) {
if (!key.startsWith("$")) {
proxy[key] = obj[key];
}
}
proxy.__dict__ = $B.getset_descriptor.$factory(obj, "__dict__");
return $B.mappingproxy.$factory(proxy);
} else if (!klass.$native) {
if (obj[attr] !== undefined) {
return obj[attr];
} else if (obj.$infos) {
if (obj.$infos.hasOwnProperty("__dict__")) {
return obj.$infos.__dict__;
} else if (obj.$infos.hasOwnProperty("__func__")) {
return obj.$infos.__func__.$infos.__dict__;
}
}
return $B.obj_dict(obj, function (attr) {
return ["__class__"].indexOf(attr) > -1;
});
}
case "__doc__":
for (var i = 0; i < builtin_names.length; i++) {
if (obj === _b_[builtin_names[i]]) {
_get_builtins_doc();
return $B.builtins_doc[builtin_names[i]];
}
}
break;
case "__mro__":
if (obj.$is_class) {
return _b_.tuple.$factory([obj].concat(obj.__mro__));
} else if (
obj.__dict__ &&
obj.__dict__.$string_dict.__mro__ !== undefined
) {
return obj.__dict__.$string_dict.__mro__;
}
throw $B.attr_error(attr, obj);
case "__subclasses__":
if (klass.$factory || klass.$is_class) {
var subclasses = obj.$subclasses || [];
return function () {
return subclasses;
};
}
break;
}
if (typeof obj == "function") {
var value = obj[attr];
if (value !== undefined) {
if (attr == "__module__") {
return value;
}
}
}
if (!is_class && klass.$native) {
if (obj.$method_cache && obj.$method_cache[attr]) {
return obj.$method_cache[attr];
}
if ($test) {
console.log("native class", klass, klass[attr]);
}
if (attr == "__doc__" && klass[attr] === undefined && klass.$infos) {
_get_builtins_doc();
klass[attr] = $B.builtins_doc[klass.$infos.__name__];
}
if (klass[attr] === undefined) {
var object_attr = _b_.object[attr];
if ($test) {
console.log("object attr", object_attr);
}
if (object_attr !== undefined) {
klass[attr] = object_attr;
} else {
if ($test) {
console.log("obj[attr]", obj[attr]);
}
var attrs = obj.__dict__;
if (attrs && (object_attr = attrs.$string_dict[attr]) !== undefined) {
return object_attr[0];
}
if (_default === undefined) {
throw $B.attr_error(attr, obj);
}
return _default;
}
}
if (klass.$descriptors && klass.$descriptors[attr] !== undefined) {
return klass[attr](obj);
}
if (typeof klass[attr] == "function") {
var func = klass[attr];
if (attr == "__new__") {
func.$type = "staticmethod";
}
if (func.$type == "staticmethod") {
return func;
}
var self = klass[attr].__class__ == $B.method ? klass : obj,
method = klass[attr].bind(null, self);
method.__class__ = $B.method;
method.$infos = {
__func__: func,
__name__: attr,
__self__: self,
__qualname__: klass.$infos.__name__ + "." + attr,
};
if (typeof obj == "object") {
obj.__class__ = klass;
obj.$method_cache = obj.$method_cache || {};
obj.$method_cache[attr] = method;
}
return method;
} else if (klass[attr] !== undefined) {
return klass[attr];
}
attr_error(rawname, klass);
}
var mro, attr_func;
if (is_class) {
attr_func = _b_.type.__getattribute__;
} else {
attr_func = klass.__getattribute__;
if (attr_func === undefined) {
var mro = klass.__mro__;
if (mro === undefined) {
console.log(obj, attr, "no mro, klass", klass);
}
for (var i = 0, len = mro.length; i < len; i++) {
attr_func = mro[i]["__getattribute__"];
if (attr_func !== undefined) {
break;
}
}
}
}
if (typeof attr_func !== "function") {
console.log(attr + " is not a function " + attr_func, klass);
}
var odga = _b_.object.__getattribute__;
if ($test) {
console.log(
"attr_func is odga ?",
attr_func,
attr_func === odga,
"\nobj[attr]",
obj[attr]
);
}
if (attr_func === odga) {
res = obj[attr];
if (Array.isArray(obj) && Array.prototype[attr] !== undefined) {
res = undefined;
} else if (res === null) {
return null;
} else if (false && res === undefined && obj[attr] !== undefined) {
if (_default === undefined) {
throw $B.attr_error(attr, obj);
}
return _default;
} else if (res !== undefined) {
if ($test) {
console.log(obj, attr, obj[attr], res.__set__ || res.$is_class);
}
if (res.$is_property) {
return property.__get__(res);
}
if (res.__set__ === undefined || res.$is_class) {
if ($test) {
console.log("return", res, res + "", res.__set__, res.$is_class);
}
return res;
}
}
}
if ($test) {
console.log("no result with object.__getattribute__");
}
try {
res = attr_func(obj, attr);
if ($test) {
console.log("result of attr_func", res);
}
} catch (err) {
var getattr;
if (klass === $B.module) {
getattr = obj.__getattr__;
if (getattr) {
try {
return getattr(attr);
} catch (err) {
if (_default !== undefined) {
return _default;
}
throw err;
}
}
} else {
var getattr = in_mro(klass, "__getattr__");
if (getattr) {
if (attr == "strange") {
console.log("essaie getattr", obj, klass, attr);
}
try {
if (klass === $B.module) {
res = getattr(attr);
} else {
res = getattr(obj, attr);
}
return res;
} catch (err) {
if (_default !== undefined) {
return _default;
}
throw err;
}
}
}
if (_default !== undefined) {
return _default;
}
throw err;
}
if (res !== undefined) {
return res;
}
if (_default !== undefined) {
return _default;
}
var cname = klass.$infos.__name__;
if (is_class) {
cname = obj.$infos.__name__;
}
attr_error(rawname, is_class ? obj : klass);
};
function globals() {
check_nb_args("globals", 0, arguments);
var res = $B.obj_dict($B.last($B.frames_stack)[3]);
res.$jsobj.__BRYTHON__ = $B.JSObj.$factory($B);
res.$is_namespace = true;
return res;
}
function hasattr(obj, attr) {
check_no_kw("hasattr", obj, attr);
check_nb_args("hasattr", 2, arguments);
try {
$B.$getattr(obj, attr);
return true;
} catch (err) {
return false;
}
}
var hash_cache = {};
function hash(obj) {
check_no_kw("hash", obj);
check_nb_args("hash", 1, arguments);
if (obj.__hashvalue__ !== undefined) {
return obj.__hashvalue__;
}
if (isinstance(obj, _b_.bool)) {
return _b_.int.$factory(obj);
}
if (
obj.$is_class ||
obj.__class__ === _b_.type ||
obj.__class__ === $B.Function
) {
return (obj.__hashvalue__ = $B.$py_next_hash--);
}
if (typeof obj == "string") {
var cached = hash_cache[obj];
if (cached !== undefined) {
return cached;
} else {
return (hash_cache[obj] = _b_.str.__hash__(obj));
}
}
var klass = obj.__class__ || $B.get_class(obj);
if (klass === undefined) {
throw _b_.TypeError.$factory(
"unhashable type: '" + _b_.str.$factory($B.JSObj.$factory(obj)) + "'"
);
}
var hash_method = $B.$getattr(klass, "__hash__", _b_.None);
if (hash_method === _b_.None) {
throw _b_.TypeError.$factory(
"unhashable type: '" + $B.class_name(obj) + "'"
);
}
if (hash_method.$infos.__func__ === _b_.object.__hash__) {
if ($B.$getattr(obj, "__eq__").$infos.__func__ !== _b_.object.__eq__) {
throw _b_.TypeError.$factory(
"unhashable type: '" + $B.class_name(obj) + "'",
"hash"
);
} else {
return (obj.__hashvalue__ = _b_.object.__hash__(obj));
}
} else {
return $B.$call(hash_method)(obj);
}
}
function _get_builtins_doc() {
if ($B.builtins_doc === undefined) {
var url = $B.brython_path;
if (url.charAt(url.length - 1) == "/") {
url = url.substr(0, url.length - 1);
}
url += "/builtins_docstrings.js";
var f = _b_.open(url);
eval(f.$content);
$B.builtins_doc = docs;
}
}
function help(obj) {
if (obj === undefined) {
obj = "help";
}
if (typeof obj == "string" && _b_[obj] !== undefined) {
_get_builtins_doc();
var _doc = $B.builtins_doc[obj];
if (_doc !== undefined && _doc != "") {
_b_.print(_doc);
return;
}
}
for (var i = 0; i < builtin_names.length; i++) {
if (obj === _b_[builtin_names[i]]) {
_get_builtins_doc();
_b_.print((_doc = $B.builtins_doc[builtin_names[i]]));
}
}
if (typeof obj == "string") {
$B.$import("pydoc");
var pydoc = $B.imported["pydoc"];
$B.$getattr($B.$getattr(pydoc, "help"), "__call__")(obj);
return;
}
try {
return $B.$getattr(obj, "__doc__");
} catch (err) {
return "";
}
}
help.__repr__ = help.__str__ = function () {
return (
"Type help() for interactive help, or help(object) " +
"for help about object."
);
};
function hex(obj) {
check_no_kw("hex", obj);
check_nb_args("hex", 1, arguments);
return bin_hex_oct(16, obj);
}
function id(obj) {
check_no_kw("id", obj);
check_nb_args("id", 1, arguments);
if (
isinstance(obj, [_b_.str, _b_.int, _b_.float]) &&
!isinstance(obj, $B.long_int)
) {
return $B.$getattr(_b_.str.$factory(obj), "__hash__")();
} else if (obj.$id !== undefined) {
return obj.$id;
} else {
return (obj.$id = $B.UUID());
}
}
function __import__(mod_name, globals, locals, fromlist, level) {
var $ = $B.args(
"__import__",
5,
{ name: null, globals: null, locals: null, fromlist: null, level: null },
["name", "globals", "locals", "fromlist", "level"],
arguments,
{ globals: None, locals: None, fromlist: _b_.tuple.$factory(), level: 0 },
null,
null
);
return $B.$__import__($.name, $.globals, $.locals, $.fromlist);
}
function input(msg) {
var res = prompt(msg || "") || "";
if ($B.imported["sys"] && $B.imported["sys"].ps1) {
var ps1 = $B.imported["sys"].ps1,
ps2 = $B.imported["sys"].ps2;
if (msg == ps1 || msg == ps2) {
console.log(msg, res);
}
}
return res;
}
function isinstance(obj, cls) {
check_no_kw("isinstance", obj, cls);
check_nb_args("isinstance", 2, arguments);
if (obj === null) {
return cls === None;
}
if (obj === undefined) {
return false;
}
if (Array.isArray(cls)) {
for (var kls of cls) {
if (isinstance(obj, kls)) {
return true;
}
}
return false;
}
if (cls.__class__ === $B.GenericAlias) {
throw _b_.TypeError.$factory(
"isinstance() arg 2 cannot be a parameterized generic"
);
}
if (
!cls.__class__ ||
!(cls.$factory !== undefined || cls.$is_class !== undefined)
) {
throw _b_.TypeError.$factory(
"isinstance() arg 2 must be a type " + "or tuple of types"
);
}
if (cls === _b_.int && (obj === True || obj === False)) {
return True;
}
if (cls === _b_.bool) {
switch (typeof obj) {
case "string":
return false;
case "number":
return false;
case "boolean":
return true;
}
}
var klass = obj.__class__;
if (klass == undefined) {
if (typeof obj == "string") {
if (cls == _b_.str) {
return true;
} else if ($B.builtin_classes.indexOf(cls) > -1) {
return false;
}
} else if (obj.contructor === Number && Number.isFinite(obj)) {
if (cls == _b_.float) {
return true;
}
} else if (typeof obj == "number" && Number.isFinite(obj)) {
if (Number.isFinite(obj) && cls == _b_.int) {
return true;
}
}
klass = $B.get_class(obj);
}
if (klass === undefined) {
return false;
}
function check(kl, cls) {
if (kl === cls) {
return true;
} else if (cls === _b_.str && kl === $B.StringSubclass) {
return true;
} else if (cls === _b_.int && kl === $B.IntSubclass) {
return true;
}
}
if (check(klass, cls)) {
return true;
}
var mro = klass.__mro__;
for (var i = 0; i < mro.length; i++) {
if (check(mro[i], cls)) {
return true;
}
}
var instancecheck = $B.$getattr(
cls.__class__ || $B.get_class(cls),
"__instancecheck__",
_b_.None
);
if (instancecheck !== _b_.None) {
return instancecheck(cls, obj);
}
return false;
}
function issubclass(klass, classinfo) {
check_no_kw("issubclass", klass, classinfo);
check_nb_args("issubclass", 2, arguments);
if (
!klass.__class__ ||
!(klass.$factory !== undefined || klass.$is_class !== undefined)
) {
throw _b_.TypeError.$factory("issubclass() arg 1 must be a class");
}
if (isinstance(classinfo, _b_.tuple)) {
for (var i = 0; i < classinfo.length; i++) {
if (issubclass(klass, classinfo[i])) {
return true;
}
}
return false;
}
if (classinfo.__class__ === $B.GenericAlias) {
throw _b_.TypeError.$factory(
"issubclass() arg 2 cannot be a parameterized generic"
);
}
if (classinfo.$factory || classinfo.$is_class) {
if (klass === classinfo || klass.__mro__.indexOf(classinfo) > -1) {
return true;
}
}
var sch = $B.$getattr(
classinfo.__class__ || $B.get_class(classinfo),
"__subclasscheck__",
_b_.None
);
if (sch == _b_.None) {
return false;
}
return sch(classinfo, klass);
}
var iterator_class = $B.make_class("iterator", function (getitem, len) {
return {
__class__: iterator_class,
getitem: getitem,
len: len,
counter: -1,
};
});
iterator_class.__next__ = function (self) {
self.counter++;
if (self.len !== null && self.counter == self.len) {
throw _b_.StopIteration.$factory("");
}
try {
return self.getitem(self.counter);
} catch (err) {
throw _b_.StopIteration.$factory("");
}
};
$B.set_func_names(iterator_class, "builtins");
callable_iterator = $B.make_class(
"callable_iterator",
function (func, sentinel) {
return {
__class__: callable_iterator,
func: func,
sentinel: sentinel,
};
}
);
callable_iterator.__iter__ = function (self) {
return self;
};
callable_iterator.__next__ = function (self) {
var res = self.func();
if ($B.rich_comp("__eq__", res, self.sentinel)) {
throw _b_.StopIteration.$factory();
}
return res;
};
$B.set_func_names(callable_iterator, "builtins");
$B.$iter = function (obj, sentinel) {
if (sentinel === undefined) {
var klass = obj.__class__ || $B.get_class(obj);
try {
var _iter = $B.$call($B.$getattr(klass, "__iter__"));
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
try {
var gi_method = $B.$call($B.$getattr(klass, "__getitem__")),
gi = function (i) {
return gi_method(obj, i);
},
ln = len(obj);
return iterator_class.$factory(gi, len);
} catch (err) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object is not iterable"
);
}
}
throw err;
}
var res = $B.$call(_iter)(obj);
try {
$B.$getattr(res, "__next__");
} catch (err) {
if (isinstance(err, _b_.AttributeError)) {
throw _b_.TypeError.$factory(
"iter() returned non-iterator of type '" + $B.class_name(res) + "'"
);
}
}
return res;
} else {
return callable_iterator.$factory(obj, sentinel);
}
};
function iter() {
var $ = $B.args(
"iter",
1,
{ obj: null },
["obj"],
arguments,
{},
"args",
"kw"
),
sentinel;
if ($.args.length > 0) {
var sentinel = $.args[0];
}
return $B.$iter($.obj, sentinel);
}
function len(obj) {
check_no_kw("len", obj);
check_nb_args("len", 1, arguments);
var klass = obj.__class__ || $B.get_class(obj);
try {
var method = $B.$getattr(klass, "__len__");
} catch (err) {
throw _b_.TypeError.$factory(
"object of type '" + $B.class_name(obj) + "' has no len()"
);
}
return $B.$call(method)(obj);
}
function locals() {
check_nb_args("locals", 0, arguments);
var res = $B.obj_dict($B.clone($B.last($B.frames_stack)[1]));
res.$is_namespace = true;
delete res.$jsobj.__annotations__;
return res;
}
var map = $B.make_class("map", function () {
var $ = $B.args(
"map",
2,
{ func: null, it1: null },
["func", "it1"],
arguments,
{},
"args",
null
),
func = $B.$call($.func);
var iter_args = [$B.$iter($.it1)];
$.args.forEach(function (item) {
iter_args.push($B.$iter(item));
});
var obj = { __class__: map, args: iter_args, func: func };
return obj;
});
map.__iter__ = function (self) {
return self;
};
map.__next__ = function (self) {
var args = [];
for (var i = 0; i < self.args.length; i++) {
args.push(next(self.args[i]));
}
return self.func.apply(null, args);
};
$B.set_func_names(map, "builtins");
function $extreme(args, op) {
var $op_name = "min";
if (op === "__gt__") {
$op_name = "max";
}
var $ = $B.args($op_name, 0, {}, [], args, {}, "args", "kw");
var has_default = false,
func = false;
for (var attr in $.kw.$string_dict) {
switch (attr) {
case "key":
func = $.kw.$string_dict[attr][0];
break;
case "default":
var default_value = $.kw.$string_dict[attr][0];
has_default = true;
break;
default:
throw _b_.TypeError.$factory(
"'" + attr + "' is an invalid keyword argument for this function"
);
}
}
if (!func || func === _b_.None) {
func = (x) => x;
}
if ($.args.length == 0) {
throw _b_.TypeError.$factory($op_name + " expected 1 arguments, got 0");
} else if ($.args.length == 1) {
var $iter = iter($.args[0]),
res = null,
x_value,
extr_value;
while (true) {
try {
var x = next($iter);
if (res === null) {
extr_value = func(x);
res = x;
} else {
x_value = func(x);
if ($B.rich_comp(op, x_value, extr_value)) {
res = x;
extr_value = x_value;
}
}
} catch (err) {
if (err.__class__ == _b_.StopIteration) {
if (res === null) {
if (has_default) {
return default_value;
} else {
throw _b_.ValueError.$factory(
$op_name + "() arg is an empty sequence"
);
}
} else {
return res;
}
}
throw err;
}
}
} else {
if (has_default) {
throw _b_.TypeError.$factory(
"Cannot specify a default for " +
$op_name +
"() with multiple positional arguments"
);
}
if ($B.last(args).$nat) {
var _args = [$.args].concat($B.last(args));
} else {
var _args = [$.args];
}
return $extreme.call(null, _args, op);
}
}
function max() {
return $extreme(arguments, "__gt__");
}
var memoryview = $B.make_class("memoryview", function (obj) {
check_no_kw("memoryview", obj);
check_nb_args("memoryview", 1, arguments);
if (obj.__class__ === memoryview) {
return obj;
}
if ($B.get_class(obj).$buffer_protocol) {
return {
__class__: memoryview,
obj: obj,
format: "B",
itemsize: 1,
ndim: 1,
shape: _b_.tuple.$factory([_b_.len(obj)]),
strides: _b_.tuple.$factory([1]),
suboffsets: _b_.tuple.$factory([]),
c_contiguous: true,
f_contiguous: true,
contiguous: true,
};
} else {
throw _b_.TypeError.$factory(
"memoryview: a bytes-like object " +
"is required, not '" +
$B.class_name(obj) +
"'"
);
}
});
(memoryview.$match_sequence_pattern = true),
(memoryview.__eq__ = function (self, other) {
if (other.__class__ !== memoryview) {
return false;
}
return $B.$getattr(self.obj, "__eq__")(other.obj);
});
memoryview.__getitem__ = function (self, key) {
if (isinstance(key, _b_.int)) {
var start = key * self.itemsize;
if (self.format == "I") {
var res = self.obj.source[start],
coef = 256;
for (var i = 1; i < 4; i++) {
res += self.obj.source[start + i] * coef;
coef *= 256;
}
return res;
} else if ("B".indexOf(self.format) > -1) {
if (key > self.obj.source.length - 1) {
throw _b_.KeyError.$factory(key);
}
return self.obj.source[key];
} else {
return self.obj.source[key];
}
}
var res = self.obj.__class__.__getitem__(self.obj, key);
if (key.__class__ === _b_.slice) {
return memoryview.$factory(res);
}
};
memoryview.__len__ = function (self) {
return len(self.obj) / self.itemsize;
};
memoryview.__setitem__ = function (self, key, value) {
try {
$B.$setitem(self.obj, key, value);
} catch (err) {
throw _b_.TypeError.$factory("cannot modify read-only memory");
}
};
memoryview.cast = function (self, format) {
switch (format) {
case "B":
return memoryview.$factory(self.obj);
case "I":
var res = memoryview.$factory(self.obj),
objlen = len(self.obj);
res.itemsize = 4;
res.format = "I";
if (objlen % 4 != 0) {
throw _b_.TypeError.$factory(
"memoryview: length is not " + "a multiple of itemsize"
);
}
return res;
}
};
memoryview.hex = function (self) {
var res = "",
bytes = _b_.bytes.$factory(self);
bytes.source.forEach(function (item) {
res += item.toString(16);
});
return res;
};
memoryview.tobytes = function (self) {
return _b_.bytes.$factory(self.obj);
};
memoryview.tolist = function (self) {
if (self.itemsize == 1) {
return _b_.list.$factory(_b_.bytes.$factory(self.obj));
} else if (self.itemsize == 4) {
if (self.format == "I") {
var res = [];
for (var i = 0; i < self.obj.source.length; i += 4) {
var item = self.obj.source[i],
coef = 256;
for (var j = 1; j < 4; j++) {
item += coef * self.obj.source[i + j];
coef *= 256;
}
res.push(item);
}
return res;
}
}
};
$B.set_func_names(memoryview, "builtins");
function min() {
return $extreme(arguments, "__lt__");
}
function next(obj) {
check_no_kw("next", obj);
var missing = {},
$ = $B.args(
"next",
2,
{ obj: null, def: null },
["obj", "def"],
arguments,
{ def: missing },
null,
null
);
var klass = obj.__class__ || $B.get_class(obj),
ga = $B.$call($B.$getattr(klass, "__next__"));
if (ga !== undefined) {
try {
return $B.$call(ga)(obj);
} catch (err) {
if (err.__class__ === _b_.StopIteration && $.def !== missing) {
return $.def;
}
throw err;
}
}
throw _b_.TypeError.$factory(
"'" + $B.class_name(obj) + "' object is not an iterator"
);
}
var NotImplementedType = $B.make_class("NotImplementedType", function () {
return NotImplemented;
});
NotImplementedType.__repr__ = NotImplementedType.__str__ = function (self) {
return "NotImplemented";
};
$B.set_func_names(NotImplementedType, "builtins");
var NotImplemented = { __class__: NotImplementedType };
function $not(obj) {
return !$B.$bool(obj);
}
function oct(obj) {
check_no_kw("oct", obj);
check_nb_args("oct", 1, arguments);
return bin_hex_oct(8, obj);
}
function ord(c) {
check_no_kw("ord", c);
check_nb_args("ord", 1, arguments);
if (typeof c.valueOf() == "string") {
if (c.length == 1) {
return c.charCodeAt(0);
}
if (
(0xd800 <= c[0] && c[0] <= 0xdbff) ||
(0xdc00 <= c[1] && c[1] <= 0xdfff)
) {
throw _b_.TypeError.$factory(
"ord() expected a character, but " +
"string of length " +
c.length +
" found"
);
}
var code = 0x10000;
code += (c.charCodeAt(0) & 0x03ff) << 10;
code += c.charCodeAt(1) & 0x03ff;
return code;
}
switch ($B.get_class(c)) {
case _b_.str:
if (c.length == 1) {
return c.charCodeAt(0);
}
throw _b_.TypeError.$factory(
"ord() expected a character, but " +
"string of length " +
c.length +
" found"
);
case _b_.bytes:
case _b_.bytearray:
if (c.source.length == 1) {
return c.source[0];
}
throw _b_.TypeError.$factory(
"ord() expected a character, but " +
"string of length " +
c.source.length +
" found"
);
default:
throw _b_.TypeError.$factory(
"ord() expected a character, but " + $B.class_name(c) + " was found"
);
}
}
function pow() {
var $ = $B.args(
"pow",
3,
{ x: null, y: null, mod: null },
["x", "y", "mod"],
arguments,
{ mod: None },
null,
null
),
x = $.x,
y = $.y,
z = $.mod;
var klass = x.__class__ || $B.get_class(x);
if (z === _b_.None) {
return $B.rich_op("__pow__", x, y);
} else {
if (x != _b_.int.$factory(x) || y != _b_.int.$factory(y)) {
throw _b_.TypeError.$factory(
"pow() 3rd argument not allowed " +
"unless all arguments are integers"
);
}
return $B.$call($B.$getattr(klass, "__pow__"))(x, y, z);
}
}
function $print() {
var $ns = $B.args("print", 0, {}, [], arguments, {}, "args", "kw");
var ks = $ns["kw"].$string_dict;
var end =
ks["end"] === undefined || ks["end"] === None ? "\n" : ks["end"][0],
sep = ks["sep"] === undefined || ks["sep"] === None ? " " : ks["sep"][0],
file = ks["file"] === undefined ? $B.stdout : ks["file"][0],
args = $ns["args"],
writer = $B.$getattr(file, "write");
var items = [];
for (var i = 0, len = args.length; i < len; i++) {
var arg = _b_.str.$factory(args[i]);
writer(arg);
if (i < len - 1) {
writer(sep);
}
}
writer(end);
var flush = $B.$getattr(file, "flush", None);
if (flush !== None) {
$B.$call(flush)();
}
return None;
}
$print.__name__ = "print";
$print.is_func = true;
var property = $B.make_class("property", function (fget, fset, fdel, doc) {
var res = { __class__: property };
property.__init__(res, fget, fset, fdel, doc);
return res;
});
property.__init__ = function (self, fget, fset, fdel, doc) {
var $ = $B.args(
"__init__",
5,
{ self: null, fget: null, fset: null, fdel: null, doc: null },
["self", "fget", "fset", "fdel", "doc"],
arguments,
{ fget: _b_.None, fset: _b_.None, fdel: _b_.None, doc: _b_.None },
null,
null
),
self = $.self,
fget = $.fget,
fset = $.fset,
fdel = $.fdel,
doc = $.doc;
self.__doc__ = doc || "";
self.$type = fget.$type;
self.fget = fget;
self.fset = fset;
self.fdel = fdel;
self.$is_property = true;
if (fget && fget.$attrs) {
for (var key in fget.$attrs) {
self[key] = fget.$attrs[key];
}
}
self.__delete__ = fdel;
self.getter = function (fget) {
return property.$factory(fget, self.fset, self.fdel, self.__doc__);
};
self.setter = function (fset) {
return property.$factory(self.fget, fset, self.fdel, self.__doc__);
};
self.deleter = function (fdel) {
return property.$factory(self.fget, self.fset, fdel, self.__doc__);
};
};
property.__get__ = function (self, obj) {
if (self.fget === undefined) {
throw _b_.AttributeError.$factory("unreadable attribute");
}
return $B.$call(self.fget)(obj);
};
property.__repr__ = function (self) {
$B.builtins_repr_check(property, arguments);
return _b_.repr(self.fget(self));
};
property.__set__ = function (self, obj, value) {
if (self.fset === undefined) {
throw _b_.AttributeError.$factory("can't set attribute");
}
$B.$getattr(self.fset, "__call__")(obj, value);
};
$B.set_func_names(property, "builtins");
function quit() {
throw _b_.SystemExit;
}
quit.__repr__ = quit.__str__ = function () {
return "Use quit() or Ctrl-Z plus Return to exit";
};
function repr(obj) {
check_no_kw("repr", obj);
check_nb_args("repr", 1, arguments);
var klass = obj.__class__ || $B.get_class(obj);
return $B.$call($B.$getattr(klass, "__repr__"))(obj);
}
var reversed = $B.make_class("reversed", function (seq) {
check_no_kw("reversed", seq);
check_nb_args("reversed", 1, arguments);
var klass = seq.__class__ || $B.get_class(seq),
rev_method = $B.$getattr(klass, "__reversed__", null);
if (rev_method !== null) {
return $B.$call(rev_method)(seq);
}
try {
var method = $B.$getattr(klass, "__getitem__");
} catch (err) {
throw _b_.TypeError.$factory("argument to reversed() must be a sequence");
}
var res = {
__class__: reversed,
$counter: _b_.len(seq),
getter: function (i) {
return $B.$call(method)(seq, i);
},
};
return res;
});
reversed.__iter__ = function (self) {
return self;
};
reversed.__next__ = function (self) {
self.$counter--;
if (self.$counter < 0) {
throw _b_.StopIteration.$factory("");
}
return self.getter(self.$counter);
};
$B.set_func_names(reversed, "builtins");
function round() {
var $ = $B.args(
"round",
2,
{ number: null, ndigits: null },
["number", "ndigits"],
arguments,
{ ndigits: None },
null,
null
),
arg = $.number,
n = $.ndigits === None ? 0 : $.ndigits;
if (!isinstance(arg, [_b_.int, _b_.float])) {
var klass = arg.__class__ || $B.get_class(arg);
try {
return $B.$call($B.$getattr(klass, "__round__")).apply(null, arguments);
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"type " + $B.class_name(arg) + " doesn't define __round__ method"
);
} else {
throw err;
}
}
}
if (
isinstance(arg, _b_.float) &&
(arg.value === Infinity || arg.value === -Infinity)
) {
throw _b_.OverflowError.$factory(
"cannot convert float infinity to integer"
);
}
if (!isinstance(n, _b_.int)) {
throw _b_.TypeError.$factory(
"'" + $B.class_name(n) + "' object cannot be interpreted as an integer"
);
}
var mult = Math.pow(10, n),
x = arg * mult,
floor = Math.floor(x),
diff = Math.abs(x - floor),
res;
if (diff == 0.5) {
if (floor % 2) {
floor += 1;
}
res = _b_.int.__truediv__(floor, mult);
} else {
res = _b_.int.__truediv__(Math.round(x), mult);
}
if ($.ndigits === None) {
return res.valueOf();
} else if (arg instanceof Number) {
return new Number(res);
} else {
return res.valueOf();
}
}
function setattr() {
var $ = $B.args(
"setattr",
3,
{ obj: null, attr: null, value: null },
["obj", "attr", "value"],
arguments,
{},
null,
null
),
obj = $.obj,
attr = $.attr,
value = $.value;
if (!(typeof attr == "string")) {
throw _b_.TypeError.$factory("setattr(): attribute name must be string");
}
return $B.$setattr(obj, attr, value);
}
$B.$setattr = function (obj, attr, value) {
if (obj === undefined) {
console.log("obj undef", attr, value);
}
var $test = false;
if (attr == "__dict__") {
if (!isinstance(value, _b_.dict)) {
throw _b_.TypeError.$factory(
"__dict__ must be set to a dictionary, " +
"not a '" +
$B.class_name(value) +
"'"
);
}
if (obj.$infos) {
obj.$infos.__dict__ = value;
return None;
}
obj.__dict__ = value;
return None;
} else if (attr == "__class__") {
function error(msg) {
throw _b_.TypeError.$factory(msg);
}
if (value.__class__) {
if (value.__module__ == "builtins") {
error(
"__class__ assignement only " +
"supported for heap types or ModuleType subclasses"
);
} else if (Array.isArray(value.__bases__)) {
for (var i = 0; i < value.__bases__.length; i++) {
if (
value.__bases__[i] !== _b_.object &&
value.__bases__[i].__module__ == "builtins"
) {
error(
"__class__ assignment: '" +
$B.class_name(obj) +
"' object layout differs from '" +
$B.class_name(value) +
"'"
);
}
}
}
}
obj.__class__ = value;
return None;
} else if (attr == "__doc__" && obj.__class__ === _b_.property) {
obj[attr] = value;
}
if ($test) {
console.log("set attr", attr, "to", obj);
}
if (obj.$factory || obj.$is_class) {
var metaclass = obj.__class__;
if ($test) {
console.log("obj is class", metaclass, metaclass[attr]);
}
if (
metaclass &&
metaclass[attr] &&
metaclass[attr].__get__ &&
metaclass[attr].__set__
) {
metaclass[attr].__set__(obj, value);
return None;
}
if (attr == "__module__") {
obj.$infos.__module__ = value;
return _b_.None;
}
if (obj.$infos && obj.$infos.__module__ == "builtins") {
throw _b_.TypeError.$factory(
"can't set attributes of built-in/extension type '" +
obj.$infos.__name__ +
"'"
);
}
obj[attr] = value;
if (attr == "__init__" || attr == "__new__") {
obj.$factory = $B.$instance_creator(obj);
} else if (attr == "__bases__") {
obj.__mro__ = _b_.type.mro(obj);
}
if ($test) {
console.log("after setattr", obj);
}
return None;
}
var res = obj[attr],
klass = obj.__class__ || $B.get_class(obj);
if ($test) {
console.log(
"set attr",
attr,
"of obj",
obj,
"class",
klass,
"obj[attr]",
obj[attr]
);
}
if (res === undefined && klass) {
res = klass[attr];
if (res === undefined) {
var mro = klass.__mro__,
_len = mro.length;
for (var i = 0; i < _len; i++) {
res = mro[i][attr];
if (res !== undefined) {
break;
}
}
}
}
if ($test) {
console.log("set attr", attr, "klass", klass, "found in class", res);
}
if (res !== undefined && res !== null) {
if (res.__get__ && res.__set__ === undefined) {
throw _b_.AttributeError.$factory("can't set attribute '" + attr + "'");
}
if (res.__set__ !== undefined) {
res.__set__(res, obj, value);
return None;
}
var rcls = res.__class__,
__set1__;
if (rcls !== undefined) {
var __set1__ = rcls.__set__;
if (__set1__ === undefined) {
var mro = rcls.__mro__;
for (var i = 0, _len = mro.length; i < _len; i++) {
__set1__ = mro[i].__set__;
if (__set1__) {
break;
}
}
}
}
if (__set1__ !== undefined) {
var __set__ = $B.$getattr(res, "__set__", null);
if (__set__ && typeof __set__ == "function") {
__set__.apply(res, [obj, value]);
return None;
}
} else if (
klass &&
klass.$descriptors !== undefined &&
klass[attr] !== undefined
) {
var setter = klass[attr].setter;
if (typeof setter == "function") {
setter(obj, value);
return None;
} else {
throw _b_.AttributeError.$factory("readonly attribute");
}
}
}
var _setattr = false;
if (klass !== undefined) {
_setattr = klass.__setattr__;
if (_setattr === undefined) {
var mro = klass.__mro__;
for (var i = 0, _len = mro.length - 1; i < _len; i++) {
_setattr = mro[i].__setattr__;
if (_setattr) {
break;
}
}
}
}
var special_attrs = ["__module__"];
if (
klass &&
klass.__slots__ &&
special_attrs.indexOf(attr) == -1 &&
!_setattr
) {
var _slots = true;
for (var kl of klass.__mro__) {
if (kl === _b_.object || kl === _b_.type) {
break;
}
if (!kl.__slots__) {
_slots = false;
break;
}
}
if (_slots) {
function mangled_slots(klass) {
if (klass.__slots__) {
if (Array.isArray(klass.__slots__)) {
return klass.__slots__.map(function (item) {
if (item.startsWith("__") && !item.endsWith("_")) {
return "_" + klass.$infos.__name__ + item;
} else {
return item;
}
});
} else {
return klass.__slots__;
}
}
return [];
}
var has_slot = false;
if (mangled_slots(klass).indexOf(attr) > -1) {
has_slot = true;
} else {
for (var i = 0; i < klass.__mro__.length; i++) {
var kl = klass.__mro__[i];
if (mangled_slots(kl).indexOf(attr) > -1) {
has_slot = true;
break;
}
}
}
if (!has_slot) {
throw $B.attr_error(attr, klass);
}
}
}
if ($test) {
console.log("attr", attr, "use _setattr", _setattr);
}
if (!_setattr) {
if (obj.__dict__ === undefined) {
obj[attr] = value;
} else {
_b_.dict.$setitem(obj.__dict__, attr, value);
}
if ($test) {
console.log("no setattr, obj", obj);
}
} else {
_setattr(obj, attr, value);
}
return None;
};
function sorted() {
var $ = $B.args(
"sorted",
1,
{ iterable: null },
["iterable"],
arguments,
{},
null,
"kw"
);
var _list = _b_.list.$factory(iter($.iterable)),
args = [_list];
for (var i = 1; i < arguments.length; i++) {
args.push(arguments[i]);
}
_b_.list.sort.apply(null, args);
return _list;
}
var staticmethod = $B.make_class("staticmethod", function (func) {
var f = {
$infos: func.$infos,
__get__: function () {
return func;
},
};
f.__get__.__class__ = $B.method_wrapper;
f.__get__.$infos = func.$infos;
return f;
});
$B.set_func_names(staticmethod, "builtins");
function sum(iterable, start) {
var $ = $B.args(
"sum",
2,
{ iterable: null, start: null },
["iterable", "start"],
arguments,
{ start: 0 },
null,
null
),
iterable = $.iterable,
start = $.start;
if (_b_.isinstance(start, [_b_.str, _b_.bytes])) {
throw _b_.TypeError.$factory(
"sum() can't sum bytes" + " [use b''.join(seq) instead]"
);
}
var res = start,
iterable = iter(iterable);
while (1) {
try {
var _item = next(iterable);
res = $B.add(res, _item);
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
break;
} else {
throw err;
}
}
}
return res;
}
$B.missing_super2 = function (obj) {
obj.$missing = true;
return obj;
};
var $$super = $B.make_class("super", function (_type, object_or_type) {
var no_object_or_type = object_or_type === undefined;
if (_type === undefined && object_or_type === undefined) {
var frame = $B.last($B.frames_stack),
pyframe = $B.imported["_sys"].Getframe();
if (pyframe.f_code && pyframe.f_code.co_varnames) {
_type = frame[1].__class__;
if (_type === undefined) {
throw _b_.RuntimeError.$factory("super(): no arguments");
}
object_or_type = frame[1][pyframe.f_code.co_varnames[0]];
} else {
throw _b_.RuntimeError.$factory("super(): no arguments");
}
}
if (!no_object_or_type && Array.isArray(object_or_type)) {
object_or_type = object_or_type[0];
}
return {
__class__: $$super,
__thisclass__: _type,
__self_class__: object_or_type,
};
});
$$super.__get__ = function (self, instance, klass) {
return $$super.$factory(self.__thisclass__, instance);
};
$$super.__getattribute__ = function (self, attr) {
var mro = self.__thisclass__.__mro__,
res;
if (self.__thisclass__.$is_js_class) {
if (attr == "__init__") {
return function () {
mro[0].$js_func.call(self.__self_class__, ...arguments);
};
}
}
var sc = self.__self_class__;
if (sc !== undefined) {
if (!sc.$is_class) {
sc = sc.__class__ || $B.get_class(sc);
}
var sc_mro = [sc].concat(sc.__mro__);
for (var i = 0; i < sc_mro.length; i++) {
if (sc_mro[i] === self.__thisclass__) {
mro = sc_mro.slice(i + 1);
break;
}
}
}
var $test = false;
var f;
for (var i = 0, len = mro.length; i < len; i++) {
if (mro[i][attr] !== undefined) {
f = mro[i][attr];
break;
}
}
if (f === undefined) {
if ($$super[attr] !== undefined) {
return (function (x) {
return function () {
var args = [x];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(arguments[i]);
}
return $$super[attr].apply(null, args);
};
})(self);
}
if ($test) {
console.log("no attr", attr, self, "mro", mro);
}
throw $B.attr_error(attr, self);
}
if ($test) {
console.log(
"super",
attr,
self,
"mro",
mro,
"found in mro[0]",
mro[0],
f,
f + ""
);
}
if (f.$type == "staticmethod" || attr == "__new__") {
return f;
} else if (typeof f != "function") {
return f;
} else {
if (f.__class__ === $B.method) {
f = f.$infos.__func__;
}
var callable = $B.$call(f);
var method = function () {
var res = callable(self.__self_class__, ...arguments);
if ($test) {
console.log(
"calling super",
self.__self_class__,
attr,
f,
"res",
res
);
}
return res;
};
method.__class__ = $B.method;
var module;
if (f.$infos !== undefined) {
module = f.$infos.__module__;
} else if (f.__class__ === property) {
module = f.fget.$infos.__module;
} else if (f.$is_class) {
module = f.__module__;
}
method.$infos = {
__self__: self.__self_class__,
__func__: f,
__name__: attr,
__module__: module,
__qualname__: self.__thisclass__.$infos.__name__ + "." + attr,
};
return method;
}
throw $B.attr_error(attr, self);
};
$$super.__init__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory(
"descriptor '__init__' of 'super' " + "object needs an argument"
);
}
if (cls.__class__ !== $$super) {
throw _b_.TypeError.$factory(
"descriptor '__init__' requires a" +
" 'super' object but received a '" +
$B.class_name(cls) +
"'"
);
}
};
$$super.__repr__ = function (self) {
$B.builtins_repr_check($$super, arguments);
var res = "<super: <class '" + self.__thisclass__.$infos.__name__ + "'>";
if (self.__self_class__ !== undefined) {
res += ", <" + self.__self_class__.__class__.$infos.__name__ + " object>";
} else {
res += ", NULL";
}
return res + ">";
};
$B.set_func_names($$super, "builtins");
function vars() {
var def = {},
$ = $B.args(
"vars",
1,
{ obj: null },
["obj"],
arguments,
{ obj: def },
null,
null
);
if ($.obj === def) {
return _b_.locals();
} else {
try {
return $B.$getattr($.obj, "__dict__");
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"vars() argument must have __dict__ attribute"
);
}
throw err;
}
}
}
var $Reader = $B.make_class("Reader");
$Reader.__enter__ = function (self) {
return self;
};
$Reader.__exit__ = function (self) {
return false;
};
$Reader.__iter__ = function (self) {
return iter($Reader.readlines(self));
};
$Reader.__len__ = function (self) {
return self.lines.length;
};
$Reader.close = function (self) {
self.closed = true;
};
$Reader.flush = function (self) {
return None;
};
$Reader.read = function () {
var $ = $B.args(
"read",
2,
{ self: null, size: null },
["self", "size"],
arguments,
{ size: -1 },
null,
null
),
self = $.self,
size = $B.$GetInt($.size);
if (self.closed === true) {
throw _b_.ValueError.$factory("I/O operation on closed file");
}
if (size < 0) {
size = self.$length - self.$counter;
}
if (self.$binary) {
res = _b_.bytes.$factory(
self.$content.source.slice(self.$counter, self.$counter + size)
);
} else {
res = self.$content.substr(self.$counter, size);
}
self.$counter += size;
return res;
};
$Reader.readable = function (self) {
return true;
};
function make_lines(self) {
if (self.$lines === undefined) {
if (!self.$binary) {
self.$lines = self.$content.split("\n");
if ($B.last(self.$lines) == "") {
self.$lines.pop();
}
self.$lines = self.$lines.map((x) => x + "\n");
} else {
var lines = [],
pos = 0,
source = self.$content.source;
while (pos < self.$length) {
var ix = source.indexOf(10, pos);
if (ix == -1) {
lines.push({ __class__: _b_.bytes, source: source.slice(pos) });
break;
} else {
lines.push({
__class__: _b_.bytes,
source: source.slice(pos, ix + 1),
});
pos = ix + 1;
}
}
self.$lines = lines;
}
}
}
$Reader.readline = function (self, size) {
var $ = $B.args(
"readline",
2,
{ self: null, size: null },
["self", "size"],
arguments,
{ size: -1 },
null,
null
),
self = $.self,
size = $B.$GetInt($.size);
self.$lc = self.$lc === undefined ? -1 : self.$lc;
if (self.closed === true) {
throw _b_.ValueError.$factory("I/O operation on closed file");
}
if (self.$binary) {
var ix = self.$content.source.indexOf(10, self.$counter);
if (ix == -1) {
var rest = self.$content.source.slice(self.$counter);
self.$counter = self.$content.source.length;
return _b_.bytes.$factory(rest);
} else {
var res = {
__class__: _b_.bytes,
source: self.$content.source.slice(self.$counter, ix + 1),
};
self.$counter = ix + 1;
return res;
}
} else {
if (self.$counter == self.$content.length) {
return "";
}
var ix = self.$content.indexOf("\n", self.$counter);
if (ix == -1) {
var rest = self.$content.substr(self.$counter);
self.$counter = self.$content.length;
return rest;
} else {
var res = self.$content.substring(self.$counter, ix + 1);
self.$counter = ix + 1;
self.$lc += 1;
return res;
}
}
};
$Reader.readlines = function () {
var $ = $B.args(
"readlines",
2,
{ self: null, hint: null },
["self", "hint"],
arguments,
{ hint: -1 },
null,
null
),
self = $.self,
hint = $B.$GetInt($.hint);
var nb_read = 0;
if (self.closed === true) {
throw _b_.ValueError.$factory("I/O operation on closed file");
}
self.$lc = self.$lc === undefined ? -1 : self.$lc;
make_lines(self);
if (hint < 0) {
var lines = self.$lines.slice(self.$lc + 1);
} else {
var lines = [];
while (self.$lc < self.$lines.length && nb_read < hint) {
self.$lc++;
lines.push(self.$lines[self.$lc]);
}
}
return lines;
};
$Reader.seek = function (self, offset, whence) {
if (self.closed === True) {
throw _b_.ValueError.$factory("I/O operation on closed file");
}
if (whence === undefined) {
whence = 0;
}
if (whence === 0) {
self.$counter = offset;
} else if (whence === 1) {
self.$counter += offset;
} else if (whence === 2) {
self.$counter = self.$length + offset;
}
return None;
};
$Reader.seekable = function (self) {
return true;
};
$Reader.tell = function (self) {
return self.$counter;
};
$Reader.writable = function (self) {
return false;
};
$B.set_func_names($Reader, "builtins");
var $BufferedReader = $B.make_class("_io.BufferedReader", function (content) {
return {
__class__: $BufferedReader,
$binary: true,
$content: content,
$read_func: $B.$getattr(content, "read"),
};
});
$BufferedReader.__mro__ = [$Reader, _b_.object];
$BufferedReader.read = function (self, size) {
if (self.$read_func === undefined) {
return $Reader.read(self, size === undefined ? -1 : size);
}
return self.$read_func(size || -1);
};
var $TextIOWrapper = $B.make_class("_io.TextIOWrapper", function () {
var $ = $B.args(
"TextIOWrapper",
6,
{
buffer: null,
encoding: null,
errors: null,
newline: null,
line_buffering: null,
write_through: null,
},
[
"buffer",
"encoding",
"errors",
"newline",
"line_buffering",
"write_through",
],
arguments,
{
encoding: "utf-8",
errors: _b_.None,
newline: _b_.None,
line_buffering: _b_.False,
write_through: _b_.False,
},
null,
null
);
return {
__class__: $TextIOWrapper,
$content: _b_.bytes.decode($.buffer.$content, $.encoding),
encoding: $.encoding,
errors: $.errors,
newline: $.newline,
};
});
$TextIOWrapper.__mro__ = [$Reader, _b_.object];
$B.set_func_names($TextIOWrapper, "builtins");
$B.Reader = $Reader;
$B.TextIOWrapper = $TextIOWrapper;
$B.BufferedReader = $BufferedReader;
function $url_open() {
var $ = $B.args(
"open",
3,
{ file: null, mode: null, encoding: null },
["file", "mode", "encoding"],
arguments,
{ mode: "r", encoding: "utf-8" },
"args",
"kw"
),
file = $.file,
mode = $.mode,
encoding = $.encoding,
result = {};
if (mode.search("w") > -1) {
throw _b_.IOError.$factory("Browsers cannot write on disk");
} else if (["r", "rb"].indexOf(mode) == -1) {
throw _b_.ValueError.$factory("Invalid mode '" + mode + "'");
}
if (isinstance(file, _b_.str)) {
var is_binary = mode.search("b") > -1;
if ($B.file_cache.hasOwnProperty($.file)) {
result.content = $B.file_cache[$.file];
if (is_binary) {
result.content = _b_.str.encode(result.content, "utf-8");
}
} else if ($B.files && $B.files.hasOwnProperty($.file)) {
var $res = atob($B.files[$.file].content);
var source = [];
for (const char of $res) {
source.push(char.charCodeAt(0));
}
result.content = _b_.bytes.$factory(source);
if (!is_binary) {
try {
result.content = _b_.bytes.decode(result.content, encoding);
} catch (error) {
result.error = error;
}
}
} else if ($B.protocol != "file") {
var req = new XMLHttpRequest();
req.overrideMimeType("text/plain;charset=x-user-defined");
req.onreadystatechange = function () {
if (this.readyState != 4) {
return;
}
var status = this.status;
if (status == 404) {
result.error = _b_.FileNotFoundError.$factory(file);
} else if (status != 200) {
result.error = _b_.IOError.$factory(
"Could not open file " + file + " : status " + status
);
} else {
var bytes = [];
for (var i = 0, len = this.response.length; i < len; i++) {
var cp = this.response.codePointAt(i);
if (cp > 0xf700) {
cp -= 0xf700;
}
bytes.push(cp);
}
result.content = _b_.bytes.$factory(bytes);
if (!is_binary) {
try {
result.content = _b_.bytes.decode(result.content, encoding);
} catch (error) {
result.error = error;
}
}
}
};
var fake_qs = $B.$options.cache ? "" : "?foo=" + new Date().getTime();
req.open("GET", encodeURI(file + fake_qs), false);
req.send();
} else {
throw _b_.FileNotFoundError.$factory(
"cannot use 'open()' with protocol 'file'"
);
}
if (result.error !== undefined) {
throw result.error;
}
var res = {
$binary: is_binary,
$content: result.content,
$counter: 0,
$encoding: encoding,
$length: is_binary
? result.content.source.length
: result.content.length,
closed: False,
mode,
name: file,
};
res.__class__ = is_binary ? $BufferedReader : $TextIOWrapper;
return res;
} else {
throw _b_.TypeError.$factory(
"invalid argument for open(): " + _b_.str.$factory(file)
);
}
}
var zip = $B.make_class("zip", function () {
var res = { __class__: zip, items: [] };
if (arguments.length == 0) {
return res;
}
var $ns = $B.args("zip", 0, {}, [], arguments, {}, "args", "kw");
var _args = $ns["args"],
strict = $ns.kw.$string_dict.strict && $ns.kw.$string_dict.strict[0];
var args = [],
nexts = [],
only_lists = true,
min_len;
for (var i = 0; i < _args.length; i++) {
if (only_lists && Array.isArray(_args[i])) {
if (strict) {
if (i == 0) {
var len = _args[i].length;
} else if (_args[i] != len) {
throw _b_.ValueError.$factory(
`zip() argument ${i} ` +
`is ${_args[i] > len ? "longer" : "shorter"} ` +
`than argument ${i - 1}`
);
}
}
if (min_len === undefined || _args[i].length < min_len) {
min_len = _args[i].length;
}
} else {
only_lists = false;
}
var _next = $B.$call($B.$getattr(iter(_args[i]), "__next__"));
args.push(_next);
}
var rank = 0,
items = [];
if (only_lists) {
$B.nb_zip_list = $B.nb_zip_list === undefined ? 1 : $B.nb_zip_list + 1;
for (var i = 0; i < min_len; i++) {
var line = [];
for (var j = 0; j < _args.length; j++) {
line.push(_args[j][i]);
}
items.push($B.fast_tuple(line));
}
res.items = items;
return zip_iterator.$factory(items);
}
function* iterator(args) {
while (true) {
var line = [],
flag = true;
for (var i = 0; i < args.length; i++) {
try {
line.push(args[i]());
} catch (err) {
if (err.__class__ == _b_.StopIteration) {
if (strict) {
if (i > 0) {
throw _b_.ValueError.$factory(
`zip() argument ${i + 1} is shorter ` + `than argument ${i}`
);
} else {
for (var j = 1; j < args.length; j++) {
var exhausted = true;
try {
args[j]();
exhausted = false;
} catch (err) {}
if (!exhausted) {
throw _b_.ValueError.$factory(
`zip() argument ${j + 1} is longer ` +
`than argument ${i + 1}`
);
}
}
}
}
flag = false;
break;
} else {
throw err;
}
}
}
if (!flag) {
return;
}
yield $B.fast_tuple(line);
}
}
return $B.generator.$factory(iterator, "zip")(args);
});
var zip_iterator = $B.make_iterator_class("zip");
zip.__iter__ = function (self) {
return zip_iterator.$factory(self.items);
};
$B.set_func_names(zip, "builtins");
function no_set_attr(klass, attr) {
if (klass[attr] !== undefined) {
throw _b_.AttributeError.$factory(
"'" +
klass.$infos.__name__ +
"' object attribute '" +
attr +
"' is read-only"
);
} else {
throw $B.attr_error(attr, klass);
}
}
var True = true;
var False = false;
var ellipsis = $B.make_class("ellipsis", function () {
return Ellipsis;
});
ellipsis.__repr__ = function (self) {
return "Ellipsis";
};
var Ellipsis = { __class__: ellipsis };
for (var $key in $B.$comps) {
switch ($B.$comps[$key]) {
case "ge":
case "gt":
case "le":
case "lt":
ellipsis["__" + $B.$comps[$key] + "__"] = (function (k) {
return function (other) {
throw _b_.TypeError.$factory(
"unorderable types: ellipsis() " + k + " " + $B.class_name(other)
);
};
})($key);
}
}
for (var $func in Ellipsis) {
if (typeof Ellipsis[$func] == "function") {
Ellipsis[$func].__str__ = (function (f) {
return function () {
return "<method-wrapper " + f + " of Ellipsis object>";
};
})($func);
}
}
$B.set_func_names(ellipsis);
var FunctionCode = $B.make_class("function code");
var FunctionGlobals = $B.make_class("function globals");
$B.Function = {
__class__: _b_.type,
__code__: { __class__: FunctionCode, __name__: "function code" },
__globals__: { __class__: FunctionGlobals, __name__: "function globals" },
__mro__: [_b_.object],
$infos: { __name__: "function", __module__: "builtins" },
$is_class: true,
};
$B.Function.__delattr__ = function (self, attr) {
if (attr == "__dict__") {
throw _b_.TypeError.$factory("can't deleted function __dict__");
}
};
$B.Function.__dir__ = function (self) {
var infos = self.$infos || {},
attrs = self.$attrs || {};
return Object.keys(infos).concat(Object.keys(attrs));
};
$B.Function.__eq__ = function (self, other) {
return self === other;
};
$B.Function.__get__ = function (self, obj) {
if (obj === _b_.None) {
return self;
}
var method = function () {
return self(obj, ...arguments);
};
method.__class__ = $B.method;
if (self.$infos === undefined) {
console.log("no $infos", self);
console.log($B.last($B.frames_stack));
}
method.$infos = {
__name__: self.$infos.__name__,
__qualname__: $B.class_name(obj) + "." + self.$infos.__name__,
__self__: obj,
__func__: self,
};
return method;
};
$B.Function.__getattribute__ = function (self, attr) {
if (self.$infos && self.$infos[attr] !== undefined) {
if (attr == "__code__") {
var res = { __class__: code };
for (var attr in self.$infos.__code__) {
res[attr] = self.$infos.__code__[attr];
}
res.name = self.$infos.__name__;
res.filename = self.$infos.__code__.co_filename;
res.co_code = self + "";
return res;
} else if (attr == "__annotations__") {
return $B.obj_dict(self.$infos[attr]);
} else if (self.$infos.hasOwnProperty(attr)) {
return self.$infos[attr];
}
} else if (
self.$infos &&
self.$infos.__dict__ &&
self.$infos.__dict__.$string_dict[attr] !== undefined
) {
return self.$infos.__dict__.$string_dict[attr][0];
} else if (attr == "__closure__") {
var free_vars = self.$infos.__code__.co_freevars;
if (free_vars.length == 0) {
return None;
}
var cells = [];
for (var i = 0; i < free_vars.length; i++) {
try {
cells.push($B.cell.$factory($B.$check_def_free(free_vars[i])));
} catch (err) {
cells.push($B.cell.$factory(None));
}
}
return _b_.tuple.$factory(cells);
} else if (attr == "__globals__") {
return $B.obj_dict($B.imported[self.$infos.__module__]);
} else if (self.$attrs && self.$attrs[attr] !== undefined) {
return self.$attrs[attr];
} else {
return _b_.object.__getattribute__(self, attr);
}
};
$B.Function.__repr__ = function (self) {
if (self.$infos === undefined) {
return "<function " + self.name + ">";
} else {
return "<function " + self.$infos.__qualname__ + ">";
}
};
$B.Function.__mro__ = [_b_.object];
$B.Function.__setattr__ = function (self, attr, value) {
if (attr == "__closure__") {
throw _b_.AttributeError.$factory("readonly attribute");
} else if (attr == "__defaults__") {
if (value === _b_.None) {
value = [];
} else if (!isinstance(value, _b_.tuple)) {
throw _b_.TypeError.$factory(
"__defaults__ must be set to a tuple object"
);
}
var set_func = self.$set_defaults;
if (set_func === undefined) {
throw _b_.AttributeError.$factory(
"cannot set attribute " + attr + " of " + _b_.str.$factory(self)
);
}
if (self.$infos && self.$infos.__code__) {
var argcount = self.$infos.__code__.co_argcount,
varnames = self.$infos.__code__.co_varnames,
params = varnames.slice(0, argcount),
$defaults = {};
for (var i = value.length - 1; i >= 0; i--) {
var pos = params.length - value.length + i;
if (pos < 0) {
break;
}
$defaults[params[pos]] = value[i];
}
} else {
throw _b_.AttributeError.$factory(
"cannot set attribute " + attr + " of " + _b_.str.$factory(self)
);
}
var klass = self.$infos.$class;
var new_func = set_func($defaults);
new_func.$set_defaults = set_func;
if (klass) {
klass[self.$infos.__name__] = new_func;
new_func.$infos.$class = klass;
new_func.$infos.__defaults__ = value;
} else {
self.$infos.$defaults = value;
self.$infos.__defaults__ = value;
}
return _b_.None;
}
if (self.$infos[attr] !== undefined) {
self.$infos[attr] = value;
} else {
self.$attrs = self.$attrs || {};
self.$attrs[attr] = value;
}
};
$B.Function.$factory = function () {};
$B.set_func_names($B.Function, "builtins");
_b_.__BRYTHON__ = __BRYTHON__;
$B.builtin_funcs = [
"__build_class__",
"abs",
"aiter",
"all",
"anext",
"any",
"ascii",
"bin",
"breakpoint",
"callable",
"chr",
"compile",
"delattr",
"dir",
"divmod",
"eval",
"exec",
"exit",
"format",
"getattr",
"globals",
"hasattr",
"hash",
"help",
"hex",
"id",
"input",
"isinstance",
"issubclass",
"iter",
"len",
"locals",
"max",
"min",
"next",
"oct",
"open",
"ord",
"pow",
"print",
"quit",
"repr",
"round",
"setattr",
"sorted",
"sum",
"vars",
];
var builtin_function = ($B.builtin_function = $B.make_class(
"builtin_function_or_method",
function (f) {
f.__class__ = builtin_function;
return f;
}
));
builtin_function.__getattribute__ = $B.Function.__getattribute__;
builtin_function.__reduce_ex__ = builtin_function.__reduce__ = function (
self
) {
return self.$infos.__name__;
};
builtin_function.__repr__ = builtin_function.__str__ = function (self) {
return "<built-in function " + self.$infos.__name__ + ">";
};
$B.set_func_names(builtin_function, "builtins");
var method_wrapper = $B.make_class("method_wrapper");
method_wrapper.__repr__ = method_wrapper.__str__ = function (self) {
return "<method wrapper '" + self.$infos.__name__ + "' of function object>";
};
$B.set_func_names(method_wrapper, "builtins");
var wrapper_descriptor = ($B.wrapper_descriptor =
$B.make_class("wrapper_descriptor"));
wrapper_descriptor.__getattribute__ = $B.Function.__getattribute__;
wrapper_descriptor.__repr__ = wrapper_descriptor.__str__ = function (self) {
return (
"<slot wrapper '" +
self.$infos.__name__ +
"' of '" +
self.__objclass__.$infos.__name__ +
"' object>"
);
};
$B.set_func_names(wrapper_descriptor, "builtins");
$B.builtin_classes = [
"bool",
"bytearray",
"bytes",
"classmethod",
"complex",
"dict",
"enumerate",
"filter",
"float",
"frozenset",
"int",
"list",
"map",
"memoryview",
"object",
"property",
"range",
"reversed",
"set",
"slice",
"staticmethod",
"str",
"super",
"tuple",
"type",
"zip",
];
var other_builtins = [
"Ellipsis",
"False",
"None",
"True",
"__debug__",
"__import__",
"copyright",
"credits",
"license",
"NotImplemented",
];
var builtin_names = $B.builtin_funcs
.concat($B.builtin_classes)
.concat(other_builtins);
for (var i = 0; i < builtin_names.length; i++) {
var name = builtin_names[i],
orig_name = name,
name1 = name;
if (name == "open") {
name1 = "$url_open";
}
if (name == "super") {
name1 = "$$super";
}
if (name == "eval") {
name1 = "$$eval";
}
if (name == "print") {
name1 = "$print";
}
try {
_b_[name] = eval(name1);
if ($B.builtin_funcs.indexOf(orig_name) > -1) {
_b_[name].__class__ = builtin_function;
_b_[name].$infos = {
__module__: "builtins",
__name__: orig_name,
__qualname__: orig_name,
};
}
} catch (err) {}
}
_b_["open"] = $url_open;
_b_["print"] = $print;
_b_["super"] = $$super;
_b_.object.__init__.__class__ = wrapper_descriptor;
_b_.object.__new__.__class__ = builtin_function;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
$B.del_exc = function () {
var frame = $B.last($B.frames_stack);
frame[1].$current_exception = undefined;
};
$B.set_exc = function (exc) {
var frame = $B.last($B.frames_stack);
if (frame === undefined) {
console.log("no frame", exc, exc.__class__, exc.args, exc.$stack);
}
frame[1].$current_exception = $B.exception(exc);
};
$B.get_exc = function () {
var frame = $B.last($B.frames_stack);
return frame[1].$current_exception;
};
$B.$raise = function (arg, cause) {
var active_exc = $B.get_exc();
if (arg === undefined) {
if (active_exc !== undefined) {
throw active_exc;
}
throw _b_.RuntimeError.$factory("No active exception to reraise");
} else if (_b_.isinstance(arg, BaseException)) {
if (
arg.__class__ === _b_.StopIteration &&
$B.last($B.frames_stack)[1].$is_generator
) {
arg = _b_.RuntimeError.$factory("generator raised StopIteration");
}
arg.__context__ = active_exc === undefined ? _b_.None : active_exc;
arg.__cause__ = cause || _b_.None;
arg.__suppress_context__ = cause !== undefined;
throw arg;
} else if (arg.$is_class && _b_.issubclass(arg, BaseException)) {
if (arg === _b_.StopIteration) {
if ($B.last($B.frames_stack)[1].$is_generator) {
throw _b_.RuntimeError.$factory("generator raised StopIteration");
}
}
var exc = $B.$call(arg)();
exc.__context__ = active_exc === undefined ? _b_.None : active_exc;
exc.__cause__ = cause || _b_.None;
exc.__suppress_context__ = cause !== undefined;
throw exc;
} else {
throw _b_.TypeError.$factory("exceptions must derive from BaseException");
}
};
$B.$syntax_err_line = function (exc, module, src, pos, line_num, filename) {
var pos2line = {},
lnum = 1,
module = module.charAt(0) == "$" ? "<string>" : module;
if (src === undefined) {
exc.$line_info = line_num + "," + module;
exc.args = $B.fast_tuple([
$B.$getitem(exc.args, 0),
$B.fast_tuple([module, line_num, 0, 0]),
]);
} else {
var line_pos = { 1: 0 };
for (var i = 0, len = src.length; i < len; i++) {
pos2line[i] = lnum;
if (src.charAt(i) == "\n") {
line_pos[++lnum] = i;
}
}
while (line_num === undefined) {
line_num = pos2line[pos];
pos--;
}
exc.$line_info = line_num + "," + module;
var lines = src.split("\n"),
line = lines[line_num - 1],
lpos = pos - line_pos[line_num],
len = line.length;
exc.text = line + "\n";
lpos -= len - line.length;
if (lpos < 0) {
lpos = 0;
}
while (line.charAt(0) == " ") {
line = line.substr(1);
if (lpos > 0) {
lpos--;
}
}
exc.offset = lpos + 1;
exc.args = $B.fast_tuple([
$B.$getitem(exc.args, 0),
$B.fast_tuple([filename, line_num, lpos, line]),
]);
}
exc.lineno = line_num;
exc.msg = exc.args[0];
exc.filename = filename;
};
$B.$SyntaxError = function (module, msg, src, pos, line_num, root) {
if (root !== undefined && root.line_info !== undefined) {
line_num = root.line_info;
}
var exc = _b_.SyntaxError.$factory(msg);
$B.$syntax_err_line(exc, module, src, pos, line_num, root.filename);
throw exc;
};
$B.$IndentationError = function (
module,
msg,
src,
pos,
line_num,
root,
indented_node
) {
$B.frames_stack.push([
module,
{ $line_info: line_num + "," + module },
module,
{ $src: src },
]);
if (root !== undefined && root.line_info !== undefined) {
line_num = root.line_info;
}
if (indented_node) {
var type = indented_node.C.tree[0].type;
switch (type) {
case "class":
type = "class definition";
break;
case "condition":
type = `'${indented_node.C.tree[0].token}' statement`;
break;
case "def":
type = "function definition";
break;
case "case":
case "for":
case "match":
case "try":
case "while":
case "with":
type = `'${type}' statement`;
break;
case "single_kw":
type = `'${indented_node.C.tree[0].token}' statement`;
break;
}
msg += ` after ${type} on line ${indented_node.line_num}`;
}
var exc = _b_.IndentationError.$factory(msg);
$B.$syntax_err_line(exc, module, src, pos, line_num, root.filename);
throw exc;
};
$B.print_stack = function (stack) {
stack = stack || $B.frames_stack;
var trace = [];
stack.forEach(function (frame) {
var line_info = frame[1].$line_info;
if (line_info !== undefined) {
var info = line_info.split(",");
if (info[1].startsWith("$exec")) {
info[1] = "<module>";
}
trace.push(info[1] + " line " + info[0]);
var src = $B.file_cache[frame[3].__file__];
if (src) {
var lines = src.split("\n"),
line = lines[parseInt(info[0]) - 1];
trace.push(" " + line.trim());
}
}
});
console.log("print stack ok", trace);
return trace.join("\n");
};
var traceback = ($B.traceback = $B.make_class(
"traceback",
function (exc, stack) {
var frame = $B.last($B.frames_stack);
if (stack === undefined) {
stack = exc.$stack;
}
return {
__class__: traceback,
$stack: stack,
exc: exc,
};
}
));
traceback.__getattribute__ = function (self, attr) {
var line_info;
if (
attr === "tb_frame" ||
attr === "tb_lineno" ||
attr === "tb_lasti" ||
attr === "tb_next"
) {
if (self.$stack.length == 0) {
console.log("no stack", attr);
}
var first_frame = self.$stack[0];
line_info =
self.exc.$line_infos[self.exc.$line_infos.length - self.$stack.length];
}
switch (attr) {
case "tb_frame":
return frame.$factory(self.$stack);
case "tb_lineno":
var lineno;
if (
line_info === undefined ||
first_frame[0].startsWith($B.lambda_magic)
) {
if (
first_frame[4] &&
first_frame[4].$infos &&
first_frame[4].$infos.__code__
) {
lineno = first_frame[4].$infos.__code__.co_firstlineno;
} else {
lineno = -1;
}
} else {
lineno = parseInt(line_info.split(",")[0]);
}
return lineno;
case "tb_lasti":
if (line_info === undefined) {
console.log("no line info", self.$stack);
return "";
} else {
var info = line_info.split(","),
src,
file;
for (var i = self.$stack.length - 1; i >= 0; i--) {
var fr = self.$stack[i];
if (fr[2] == info[1].replace(/\./g, "_")) {
file = fr[3].__file__;
src = fr[3].$src;
break;
}
}
if (src === undefined) {
if ($B.file_cache.hasOwnProperty(file)) {
src = $B.file_cache[file];
} else if ($B.imported[info[1]] && $B.imported[info[1]].__file__) {
src = $B.file_cache[$B.imported[info[1]].__file__];
console.log(
"from filecache",
line_info,
$B.imported[info[1]].__file__
);
}
}
if (src !== undefined) {
try {
return src.split("\n")[parseInt(info[0] - 1)].trim();
} catch (err) {
console.log("error in attr tb_lasti of", self);
console.log(src, info);
throw err;
}
} else {
console.log("stack", self.$stack);
console.log(file);
console.log("no src for", info);
return "";
}
}
case "tb_next":
if (self.$stack.length <= 1) {
return _b_.None;
} else {
return traceback.$factory(self.exc, self.$stack.slice(1));
}
default:
return _b_.object.__getattribute__(self, attr);
}
};
$B.set_func_names(traceback, "builtins");
var frame = $B.make_class("frame", function (stack, pos) {
var fs = stack;
var res = { __class__: frame, f_builtins: {}, $stack: stack.slice() };
if (pos === undefined) {
pos = 0;
}
res.$pos = pos;
if (fs.length) {
var _frame = fs[pos],
locals_id = _frame[0],
filename;
try {
res.f_locals = $B.obj_dict(_frame[1]);
} catch (err) {
console.log("err " + err);
throw err;
}
res.f_globals = $B.obj_dict(_frame[3]);
if (_frame[3].__file__ !== undefined) {
filename = _frame[3].__file__;
}
if (locals_id.startsWith("$exec")) {
filename = "<string>";
}
if (_frame[1].$line_info === undefined) {
res.f_lineno = _frame[1].$lineno || -1;
} else {
var line_info = _frame[1].$line_info.split(",");
res.f_lineno = parseInt(line_info[0]);
var module_name = line_info[1];
if ($B.imported.hasOwnProperty(module_name)) {
filename = $B.imported[module_name].__file__;
}
res.f_lineno = parseInt(_frame[1].$line_info.split(",")[0]);
}
var co_name = locals_id.startsWith("$exec") ? "<module>" : locals_id;
if (locals_id == _frame[2]) {
co_name = "<module>";
} else if (locals_id.startsWith("lc" + $B.lambda_magic)) {
co_name = "<listcomp>";
} else {
if (_frame[1].$name) {
co_name = _frame[1].$name;
} else if (_frame[1].$comprehension) {
co_name = "<" + _frame[1].$comprehension + ">";
} else if (_frame[1].$list_comp) {
co_name = "<listcomp>";
} else if (_frame.length > 4) {
if (_frame[4].$infos) {
co_name = _frame[4].$infos.__name__;
} else {
co_name = _frame[4].name;
}
if (_frame[4].$infos === undefined) {
if (_frame[4].name.startsWith("__ge")) {
co_name = "<genexpr>";
} else if (
_frame[4].name.startsWith("set_comp" + $B.lambda_magic)
) {
co_name = "<setcomp>";
} else if (_frame[4].name.startsWith("lambda" + $B.lambda_magic)) {
co_name = "<lambda>";
}
} else if (filename === undefined && _frame[4].$infos.__code__) {
filename = _frame[4].$infos.__code__.co_filename;
if (filename === undefined) {
filename = _frame[4].$infos.__module__;
}
res.f_lineno = _frame[4].$infos.__code__.co_firstlineno;
}
}
}
if (_frame.length > 4 && _frame[4].$infos !== undefined) {
res.f_code = _frame[4].$infos.__code__;
} else {
res.f_code = { co_name: co_name, co_filename: filename };
if (_frame[1].$comp_code) {
$B.update_obj(res.f_code, _frame[1].$comp_code);
}
}
res.f_code.__class__ = $B.code;
res.f_code.co_code = _b_.None;
if (filename === undefined) {
res.f_code.co_filename = "<string>";
}
}
return res;
});
frame.__delattr__ = function (self, attr) {
if (attr == "f_trace") {
$B.last(self.$stack)[1].$f_trace = _b_.None;
}
};
frame.__getattr__ = function (self, attr) {
if (attr == "f_back") {
if (self.$pos > 0) {
return frame.$factory(
self.$stack.slice(0, self.$stack.length - 1),
self.$pos - 1
);
} else {
return _b_.None;
}
} else if (attr == "clear") {
return function () {};
} else if (attr == "f_trace") {
var locals = $B.last(self.$stack)[1];
if (locals.$f_trace === undefined) {
return _b_.None;
}
return locals.$f_trace;
}
};
frame.__setattr__ = function (self, attr, value) {
if (attr == "f_trace") {
$B.last(self.$stack)[1].$f_trace = value;
}
};
frame.__str__ = frame.__repr__ = function (self) {
return (
"<frame object, file " +
self.f_code.co_filename +
", line " +
self.f_lineno +
", code " +
self.f_code.co_name +
">"
);
};
$B.set_func_names(frame, "builtins");
$B._frame = frame;
var BaseException = (_b_.BaseException = {
__class__: _b_.type,
__bases__: [_b_.object],
__mro__: [_b_.object],
args: [],
$infos: { __name__: "BaseException", __module__: "builtins" },
$is_class: true,
});
BaseException.__init__ = function (self) {
var args = arguments[1] === undefined ? [] : [arguments[1]];
self.args = _b_.tuple.$factory(args);
};
BaseException.__repr__ = function (self) {
var res = self.__class__.$infos.__name__ + "(";
if (self.args[0] !== undefined) {
res += _b_.repr(self.args[0]);
}
if (self.args.length > 1) {
res += ", " + _b_.repr($B.fast_tuple(self.args.slice(1)));
}
return res + ")";
};
BaseException.__str__ = function (self) {
if (self.args.length > 0 && self.args[0] !== _b_.None) {
return _b_.str.$factory(self.args[0]);
}
return "";
};
BaseException.__new__ = function (cls) {
var err = _b_.BaseException.$factory();
err.__class__ = cls;
err.__dict__ = $B.empty_dict();
return err;
};
var getExceptionTrace = function (exc, includeInternal) {
if (exc.__class__ === undefined) {
if ($B.debug > 1) {
console.log("no class", exc);
}
return exc + "";
}
var info = "";
if (exc.$js_exc !== undefined && includeInternal) {
info += "\nJS stack:\n" + exc.$js_exc.stack + "\n";
}
info += "Traceback (most recent call last):";
var line_info = exc.$line_info,
src;
for (var i = 0; i < exc.$stack.length; i++) {
src = undefined;
var frame = exc.$stack[i];
if (!frame[1]) {
continue;
}
if (frame.exec_obj) {
line_info = [frame.exec_obj.$lineno, frame[2]];
src = frame.exec_src;
} else if (frame[1].$line_info) {
var $line_info = frame[1].$line_info;
line_info = $line_info.split(",");
} else if (frame[1].$lineno) {
line_info = [frame[1].$lineno, frame[2]];
}
var file = frame[1].__file__ || frame[3].__file__;
if (src == undefined) {
if (file && $B.file_cache[file]) {
src = $B.file_cache[file];
} else {
console.log("pas de __file__ ou de file_cache[__file]");
console.log(exc.$stack);
if ($B.imported[frame[2]] === undefined) {
var file = frame[3].__file__,
src = $B.file_cache[file];
} else {
var file = $B.imported[frame[2]].__file__,
src = $B.file_cache[file];
}
}
}
var module = line_info[1],
is_exec = module.charAt(0) == "$";
if (is_exec) {
module = "<module>";
}
info += "\n File " + file + " line " + line_info[0];
if (frame.length > 4) {
if (frame[4].$infos) {
var name = frame[4].$infos.__name__;
if (name.startsWith("lc" + $B.lambda_magic)) {
info += ", in <listcomp>";
} else if (name.startsWith("lambda_" + $B.lambda_magic)) {
info += ", in <lambda>";
} else {
info += ", in " + name;
}
} else if (frame[4].name.startsWith("__ge")) {
info += ", in <genexpr>";
} else if (frame[4].name.startsWith("set_comp" + $B.lambda_magic)) {
info += ", in <setcomp>";
} else if (frame[4].name.startsWith("lc" + $B.lambda_magic)) {
info += ", in <listcomp>";
} else {
console.log("frame[4]", frame[4]);
}
} else if (frame[1].$list_comp) {
info += ", in <listcomp>";
} else if (frame[1].$dict_comp) {
info += ", in <dictcomp>";
} else {
info += ", in <module>";
}
if (src !== undefined && !is_exec) {
var lines = src.split("\n"),
line = lines[parseInt(line_info[0]) - 1];
if (line === undefined) {
console.log(
"bizarre, src",
src,
"frame",
frame,
"line_info",
line_info
);
}
if (line) {
line = line.replace(/^[ ]+/g, "");
}
info += "\n " + line;
}
}
if (exc.__class__ === _b_.SyntaxError) {
info +=
"\n File " +
exc.args[1][0] +
", line " +
exc.args[1][1] +
"\n " +
exc.args[1][3];
}
return info;
};
BaseException.__getattr__ = function (self, attr) {
if (attr == "info") {
return getExceptionTrace(self, false);
} else if (attr == "infoWithInternal") {
return getExceptionTrace(self, true);
} else if (attr == "__traceback__") {
if (self.$traceback !== undefined) {
return self.$traceback;
}
return traceback.$factory(self);
} else if (attr == "__context__") {
var frame = $B.last($B.frames_stack),
ctx = frame[1].$current_exception;
return ctx || _b_.None;
} else {
throw $B.attr_error(attr, self);
}
};
BaseException.with_traceback = function (self, tb) {
self.$traceback = tb;
return self;
};
$B.deep_copy = function (stack) {
var res = [];
for (const s of stack) {
var item = [s[0], {}, s[2], {}];
if (s[4] !== undefined) {
item.push(s[4]);
}
for (const i of [1, 3]) {
for (var key in s[i]) {
item[i][key] = s[i][key];
}
}
res.push(item);
}
return res;
};
$B.save_stack = function () {
return $B.deep_copy($B.frames_stack);
};
$B.restore_stack = function (stack, locals) {
$B.frames_stack = stack;
$B.frames_stack[$B.frames_stack.length - 1][1] = locals;
};
$B.freeze = function (err) {
function get_line_info(frame) {
var line_info = frame[1].$line_info;
if (!line_info) {
line_info = `${frame[1].$lineno},${frame[2]}`;
}
return line_info;
}
if (err.$stack === undefined) {
err.$line_infos = [];
for (var frame of $B.frames_stack) {
err.$line_infos.push(get_line_info(frame));
}
err.$stack = $B.frames_stack.slice();
if ($B.frames_stack.length) {
err.$line_info = get_line_info($B.last($B.frames_stack));
}
}
};
var show_stack = ($B.show_stack = function (stack) {
stack = stack || $B.frames_stack;
for (const frame of stack) {
console.log(frame[0], frame[1].$line_info);
}
});
var be_factory = `
function (){
var err = Error()
err.args = $B.fast_tuple(Array.prototype.slice.call(arguments))
err.__class__ = _b_.BaseException
err.$py_error = true
$B.freeze(err)
// placeholder
err.__cause__ = _b_.None // XXX fix me
err.__context__ = _b_.None // XXX fix me
err.__suppress_context__ = false // XXX fix me
return err}`;
eval("BaseException.$factory = " + be_factory);
BaseException.$factory.$infos = {
__name__: "BaseException",
__qualname__: "BaseException",
};
$B.set_func_names(BaseException);
_b_.BaseException = BaseException;
$B.exception = function (js_exc, in_ctx_manager) {
if (!js_exc.__class__) {
var exc = Error();
exc.__name__ =
"Internal Javascript error: " + (js_exc.__name__ || js_exc.name);
exc.__class__ = _b_.Exception;
exc.$js_exc = js_exc;
if ($B.is_recursion_error(js_exc)) {
return _b_.RecursionError.$factory("too much recursion");
} else if (js_exc.name == "ReferenceError") {
exc.__name__ = "NameError";
exc.__class__ = _b_.NameError;
} else if (js_exc.name == "InternalError") {
exc.__name__ = "RuntimeError";
exc.__class__ = _b_.RuntimeError;
}
exc.__cause__ = _b_.None;
exc.__context__ = _b_.None;
exc.__suppress_context__ = false;
var $message =
"<Javascript " +
js_exc.name +
">: " +
(js_exc.message || "<" + js_exc + ">");
exc.args = _b_.tuple.$factory([$message]);
exc.$py_error = true;
console.log("js error", exc.args);
console.log(js_exc.stack);
console.log("frames_stack", $B.frames_stack.slice());
if ($B.js_from_ast) {
for (var frame of $B.frames_stack) {
var src = undefined;
var file = frame[1].__file__ || frame[3].__file__;
if (file && $B.file_cache[file]) {
src = $B.file_cache[file];
}
console.log("line", frame[1].$lineno, "file", file, "in", frame[0]);
if (src !== undefined) {
var lines = src.split("\n"),
line = lines[frame[1].$lineno - 1];
console.log(" " + line);
}
}
}
$B.freeze(exc);
} else {
var exc = js_exc;
$B.freeze(exc);
if (in_ctx_manager) {
var current_locals = $B.last($B.frames_stack)[0];
for (var i = 0, len = exc.$stack.length; i < len; i++) {
if (exc.$stack[i][0] == current_locals) {
exc.$stack = exc.$stack.slice(i);
exc.$traceback = traceback.$factory(exc);
break;
}
}
}
}
return exc;
};
$B.is_exc = function (exc, exc_list) {
if (exc.__class__ === undefined) {
exc = $B.exception(exc);
}
var this_exc_class = exc.$is_class ? exc : exc.__class__;
for (var i = 0; i < exc_list.length; i++) {
var exc_class = exc_list[i];
if (this_exc_class === undefined) {
console.log("exc class undefined", exc);
}
if (_b_.issubclass(this_exc_class, exc_class)) {
return true;
}
}
return false;
};
$B.is_recursion_error = function (js_exc) {
var msg = js_exc + "",
parts = msg.split(":"),
err_type = parts[0].trim(),
err_msg = parts[1].trim();
return (
(err_type == "InternalError" && err_msg == "too much recursion") ||
(err_type == "Error" && err_msg == "Out of stack space") ||
(err_type == "RangeError" &&
err_msg == "Maximum call stack size exceeded")
);
};
var $make_exc = ($B.$make_exc = function (names, parent) {
if (parent === undefined) {
console.log("pas de parent", names);
}
var _str = [],
pos = 0;
for (var i = 0; i < names.length; i++) {
var name = names[i],
code = "";
if (Array.isArray(name)) {
var code = name[1],
name = name[0];
}
$B.builtins_scope[name] = true;
var $exc = be_factory.replace(/BaseException/g, name);
$exc = $exc.replace("// placeholder", code);
_str[pos++] =
"_b_." +
name +
" = {__class__:_b_.type, " +
"__bases__: [_b_." +
parent.$infos.__name__ +
"], " +
"__mro__: [_b_." +
parent.$infos.__name__ +
"].concat(parent.__mro__), $is_class: true," +
"$infos: {__name__:'" +
name +
"'}}";
_str[pos++] = "_b_." + name + ".$factory = " + $exc;
_str[pos++] =
"_b_." +
name +
'.$factory.$infos = {__name__: "' +
name +
'", __qualname__: "' +
name +
'"}';
_str[pos++] = "$B.set_func_names(_b_." + name + ", 'builtins')";
}
try {
eval(_str.join(";"));
} catch (err) {
console.log("--err" + err);
throw err;
}
});
$make_exc(
["SystemExit", "KeyboardInterrupt", "GeneratorExit", "Exception"],
BaseException
);
$make_exc(
[
["StopIteration", "err.value = arguments[0]"],
["StopAsyncIteration", "err.value = arguments[0]"],
"ArithmeticError",
"AssertionError",
"BufferError",
"EOFError",
["ImportError", "err.name = arguments[0]"],
"LookupError",
"MemoryError",
"OSError",
"ReferenceError",
"RuntimeError",
["SyntaxError", "err.msg = arguments[0]"],
"SystemError",
"TypeError",
"ValueError",
"Warning",
],
_b_.Exception
);
$make_exc(
["FloatingPointError", "OverflowError", "ZeroDivisionError"],
_b_.ArithmeticError
);
$make_exc(
[["ModuleNotFoundError", "err.name = arguments[0]"]],
_b_.ImportError
);
$make_exc(["IndexError", "KeyError"], _b_.LookupError);
$make_exc(
[
"BlockingIOError",
"ChildProcessError",
"ConnectionError",
"FileExistsError",
"FileNotFoundError",
"InterruptedError",
"IsADirectoryError",
"NotADirectoryError",
"PermissionError",
"ProcessLookupError",
"TimeoutError",
],
_b_.OSError
);
$make_exc(
[
"BrokenPipeError",
"ConnectionAbortedError",
"ConnectionRefusedError",
"ConnectionResetError",
],
_b_.ConnectionError
);
$make_exc(["NotImplementedError", "RecursionError"], _b_.RuntimeError);
$make_exc(["IndentationError"], _b_.SyntaxError);
$make_exc(["TabError"], _b_.IndentationError);
$make_exc(["UnicodeError"], _b_.ValueError);
$make_exc(
["UnicodeDecodeError", "UnicodeEncodeError", "UnicodeTranslateError"],
_b_.UnicodeError
);
$make_exc(
[
"DeprecationWarning",
"PendingDeprecationWarning",
"RuntimeWarning",
"SyntaxWarning",
"UserWarning",
"FutureWarning",
"ImportWarning",
"UnicodeWarning",
"BytesWarning",
"ResourceWarning",
"EncodingWarning",
],
_b_.Warning
);
$make_exc(
["EnvironmentError", "IOError", "VMSError", "WindowsError"],
_b_.OSError
);
var js =
'\nvar $ = $B.args("AttributeError", 1, {"msg": null, "name":null, "obj":null}, ' +
'["msg", "name", "obj"], arguments, ' +
'{msg: _b_.None, name: _b_.None, obj: _b_.None}, "*", null);\n' +
"err.args = $B.fast_tuple($.msg === _b_.None ? [] : [$.msg])\n;" +
"err.name = $.name\nerr.obj = $.obj\n";
$make_exc([["AttributeError", js]], _b_.Exception);
_b_.AttributeError.__str__ = function (self) {
var msg = self.args[0];
var suggestion = offer_suggestions_for_attribute_error(self);
if (suggestion) {
msg += `. Did you mean: '${suggestion}'?`;
}
return msg;
};
$B.set_func_names(_b_.AttributeError, "builtins");
$B.attr_error = function (name, obj) {
if (obj.$is_class) {
var msg = `type object '${obj.$infos.__name__}'`;
} else {
var msg = `'${$B.class_name(obj)}' object`;
}
msg += ` has no attribute '${name}'`;
return _b_.AttributeError.$factory({ $nat: "kw", kw: { name, obj, msg } });
};
var js =
'\nvar $ = $B.args("NameError", 1, {"msg": null, "name":null}, ' +
'["msg", "name"], arguments, ' +
'{msg: _b_.None, name: _b_.None}, "*", null);\n' +
"err.args = $B.fast_tuple($.msg === _b_.None ? [] : [$.msg])\n;" +
"err.name = $.name\n";
$make_exc([["NameError", js]], _b_.Exception);
_b_.NameError.__str__ = function (self) {
if (self.args.length > 0) {
return self.args[0];
}
var msg = `name '${self.name}' is not defined`,
suggestion = offer_suggestions_for_name_error(self);
if (suggestion) {
msg += `. Did you mean: '${suggestion}'?`;
}
return msg;
};
$B.set_func_names(_b_.NameError, "builtins");
$make_exc(["UnboundLocalError"], _b_.NameError);
$B.name_error = function (name, obj) {
return _b_.NameError.$factory({ $nat: "kw", kw: { name } });
};
$B.$TypeError = function (msg) {
throw _b_.TypeError.$factory(msg);
};
var se = _b_.SyntaxError.$factory;
_b_.SyntaxError.$factory = function () {
var arg = arguments[0];
if (arg.__class__ === _b_.SyntaxError) {
return arg;
}
var exc = se.apply(null, arguments),
frame = $B.last($B.frames_stack);
if (frame) {
line_info = frame[1].$line_info;
if (line_info === undefined) {
line_info = `${frame[1].$lineno},${frame[2]}`;
}
exc.filename = frame[3].__file__;
exc.lineno = parseInt(line_info.split(",")[0]);
var src = $B.file_cache[frame[3].__file__];
if (src) {
lines = src.split("\n");
exc.text = lines[exc.lineno - 1];
}
exc.offset = arg.offset;
}
return exc;
};
var MAX_CANDIDATE_ITEMS = 750,
MAX_STRING_SIZE = 40,
MOVE_COST = 2,
CASE_COST = 1,
SIZE_MAX = 65535;
function LEAST_FIVE_BITS(n) {
return n & 31;
}
function levenshtein_distance(a, b, max_cost) {
if (a == b) {
return 0;
}
if (a.length < b.length) {
[a, b] = [b, a];
}
while (a.length && a[0] == b[0]) {
a = a.substr(1);
b = b.substr(1);
}
while (a.length && a[a.length - 1] == b[b.length - 1]) {
a = a.substr(0, a.length - 1);
b = b.substr(0, b.length - 1);
}
if (b.length == 0) {
return a.length * MOVE_COST;
}
if ((b.length - a.length) * MOVE_COST > max_cost) {
return max_cost + 1;
}
var buffer = [];
for (var i = 0; i < a.length; i++) {
buffer[i] = (i + 1) * MOVE_COST;
}
var result = 0;
for (var b_index = 0; b_index < b.length; b_index++) {
var code = b[b_index];
var distance = (result = b_index * MOVE_COST);
var minimum = SIZE_MAX;
for (var index = 0; index < a.length; index++) {
var substitute = distance + substitution_cost(code, a[index]);
distance = buffer[index];
var insert_delete = Math.min(result, distance) + MOVE_COST;
result = Math.min(insert_delete, substitute);
buffer[index] = result;
if (result < minimum) {
minimum = result;
}
}
if (minimum > max_cost) {
return max_cost + 1;
}
}
return result;
}
function substitution_cost(a, b) {
if (LEAST_FIVE_BITS(a) != LEAST_FIVE_BITS(b)) {
return MOVE_COST;
}
if (a == b) {
return 0;
}
if (a.toLowerCase() == b.toLowerCase()) {
return CASE_COST;
}
return MOVE_COST;
}
function calculate_suggestions(dir, name) {
if (dir.length >= MAX_CANDIDATE_ITEMS) {
return null;
}
var suggestion_distance = 2 ** 52,
suggestion = null;
for (var item of dir) {
var max_distance = ((name.length + item.length + 3) * MOVE_COST) / 6;
max_distance = Math.min(max_distance, suggestion_distance - 1);
var current_distance = levenshtein_distance(name, item, max_distance);
if (current_distance > max_distance) {
continue;
}
if (!suggestion || current_distance < suggestion_distance) {
suggestion = item;
suggestion_distance = current_distance;
}
}
return suggestion;
}
function offer_suggestions_for_attribute_error(exc) {
var name = exc.name,
obj = exc.obj;
var dir = _b_.dir(obj),
suggestions = calculate_suggestions(dir, name);
return suggestions;
}
function offer_suggestions_for_name_error(exc) {
var name = exc.name,
frame = $B.last(exc.$stack);
var locals = Object.keys(frame[1]).filter((x) => !x.startsWith("$"));
var suggestion = calculate_suggestions(locals, name);
if (suggestion) {
return suggestion;
}
if (frame[2] != frame[0]) {
var globals = Object.keys(frame[3]).filter((x) => !x.startsWith("$"));
var suggestion = calculate_suggestions(globals, name);
if (suggestion) {
return suggestion;
}
}
}
$B.handle_error = function (err) {
if (err.$handled) {
return;
}
err.$handled = true;
if ($B.debug > 1) {
console.log("handle error", err.__class__, err.args, "stderr", $B.stderr);
console.log(err);
}
if (err.__class__ !== undefined) {
var name = $B.class_name(err),
trace = $B.$getattr(err, "info");
if (name == "SyntaxError" || name == "IndentationError") {
var offset = err.args[1][2];
trace +=
"\n " +
" ".repeat(offset) +
"^" +
"\n" +
name +
": " +
err.args[0];
} else {
trace += "\n" + name + ": " + _b_.str.$factory(err);
}
} else {
console.log(err);
trace = err + "";
}
try {
$B.$getattr($B.stderr, "write")(trace);
var flush = $B.$getattr($B.stderr, "flush", _b_.None);
if (flush !== _b_.None) {
flush();
}
} catch (print_exc_err) {
console.debug(trace);
}
throw err;
};
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins,
None = _b_.None,
range = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "range" },
$is_class: true,
$native: true,
$match_sequence_pattern: true,
$descriptors: { start: true, step: true, stop: true },
};
range.__contains__ = function (self, other) {
if (range.__len__(self) == 0) {
return false;
}
try {
other = $B.int_or_bool(other);
} catch (err) {
try {
range.index(self, other);
return true;
} catch (err) {
return false;
}
}
var sub = $B.sub(other, self.start),
fl = $B.floordiv(sub, self.step),
res = $B.mul(self.step, fl);
if ($B.eq(res, sub)) {
if ($B.gt(self.stop, self.start)) {
return $B.ge(other, self.start) && $B.gt(self.stop, other);
} else {
return $B.ge(self.start, other) && $B.gt(other, self.stop);
}
} else {
return false;
}
};
range.__delattr__ = function (self, attr, value) {
throw _b_.AttributeError.$factory("readonly attribute");
};
range.__eq__ = function (self, other) {
if (_b_.isinstance(other, range)) {
var len = range.__len__(self);
if (!$B.eq(len, range.__len__(other))) {
return false;
}
if (len == 0) {
return true;
}
if (!$B.eq(self.start, other.start)) {
return false;
}
if (len == 1) {
return true;
}
return $B.eq(self.step, other.step);
}
return false;
};
function compute_item(r, i) {
var len = range.__len__(r);
if (len == 0) {
return r.start;
} else if (i > len) {
return r.stop;
}
return $B.add(r.start, $B.mul(r.step, i));
}
range.__getitem__ = function (self, rank) {
if (_b_.isinstance(rank, _b_.slice)) {
var norm = _b_.slice.$conv_for_seq(rank, range.__len__(self)),
substep = $B.mul(self.step, norm.step),
substart = compute_item(self, norm.start),
substop = compute_item(self, norm.stop);
return range.$factory(substart, substop, substep);
}
if (typeof rank != "number") {
rank = $B.$GetInt(rank);
}
if ($B.gt(0, rank)) {
rank = $B.add(rank, range.__len__(self));
}
var res = $B.add(self.start, $B.mul(rank, self.step));
if (
($B.gt(self.step, 0) &&
($B.ge(res, self.stop) || $B.gt(self.start, res))) ||
($B.gt(0, self.step) && ($B.ge(self.stop, res) || $B.gt(res, self.start)))
) {
throw _b_.IndexError.$factory("range object index out of range");
}
return res;
};
range.__hash__ = function (self) {
var len = range.__len__(self);
if (len == 0) {
return _b_.hash(_b_.tuple.$factory([0, None, None]));
}
if (len == 1) {
return _b_.hash(_b_.tuple.$factory([1, self.start, None]));
}
return _b_.hash(_b_.tuple.$factory([len, self.start, self.step]));
};
var RangeIterator = {
__class__: _b_.type,
__mro__: [_b_.object],
__iter__: function (self) {
return self;
},
__next__: function (self) {
return _b_.next(self.obj);
},
$infos: { __name__: "range_iterator", __module__: "builtins" },
$is_class: true,
};
RangeIterator.$factory = function (obj) {
return { __class__: RangeIterator, obj: obj };
};
$B.set_func_names(RangeIterator, "builtins");
range.__iter__ = function (self) {
var res = {
__class__: range,
start: self.start,
stop: self.stop,
step: self.step,
};
if (self.$safe) {
res.$counter = self.start - self.step;
} else {
res.$counter = $B.sub(self.start, self.step);
}
return RangeIterator.$factory(res);
};
range.__len__ = function (self) {
var len;
if ($B.gt(self.step, 0)) {
if ($B.ge(self.start, self.stop)) {
return 0;
}
var n = $B.sub(self.stop, $B.add(1, self.start)),
q = $B.floordiv(n, self.step);
len = $B.add(1, q);
} else {
if ($B.ge(self.stop, self.start)) {
return 0;
}
var n = $B.sub(self.start, $B.add(1, self.stop)),
q = $B.floordiv(n, $B.mul(-1, self.step));
len = $B.add(1, q);
}
if ($B.maxsize === undefined) {
$B.maxsize = $B.long_int.__pow__($B.long_int.$factory(2), 63);
$B.maxsize = $B.long_int.__sub__($B.maxsize, 1);
}
return len;
};
range.__next__ = function (self) {
if (self.$safe) {
self.$counter += self.step;
if (
(self.step > 0 && self.$counter >= self.stop) ||
(self.step < 0 && self.$counter <= self.stop)
) {
throw _b_.StopIteration.$factory("");
}
} else {
self.$counter = $B.add(self.$counter, self.step);
if (
($B.gt(self.step, 0) && $B.ge(self.$counter, self.stop)) ||
($B.gt(0, self.step) && $B.ge(self.stop, self.$counter))
) {
throw _b_.StopIteration.$factory("");
}
}
return self.$counter;
};
range.__reversed__ = function (self) {
var n = $B.sub(range.__len__(self), 1);
return range.$factory(
$B.add(self.start, $B.mul(n, self.step)),
$B.sub(self.start, self.step),
$B.mul(-1, self.step)
);
};
range.__repr__ = function (self) {
$B.builtins_repr_check(range, arguments);
var res =
"range(" +
_b_.str.$factory(self.start) +
", " +
_b_.str.$factory(self.stop);
if (self.step != 1) {
res += ", " + _b_.str.$factory(self.step);
}
return res + ")";
};
range.__setattr__ = function (self, attr, value) {
throw _b_.AttributeError.$factory("readonly attribute");
};
range.start = function (self) {
return self.start;
};
(range.step = function (self) {
return self.step;
}),
(range.stop = function (self) {
return self.stop;
});
range.count = function (self, ob) {
if (_b_.isinstance(ob, [_b_.int, _b_.float, _b_.bool])) {
return _b_.int.$factory(range.__contains__(self, ob));
} else {
var comp = function (other) {
return $B.rich_comp("__eq__", ob, other);
},
it = range.__iter__(self),
_next = RangeIterator.__next__,
nb = 0;
while (true) {
try {
if (comp(_next(it))) {
nb++;
}
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
return nb;
}
throw err;
}
}
}
};
range.index = function (self, other) {
var $ = $B.args(
"index",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
),
self = $.self,
other = $.other;
try {
other = $B.int_or_bool(other);
} catch (err) {
var comp = function (x) {
return $B.rich_comp("__eq__", other, x);
},
it = range.__iter__(self),
_next = RangeIterator.__next__,
nb = 0;
while (true) {
try {
if (comp(_next(it))) {
return nb;
}
nb++;
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
throw _b_.ValueError.$factory(
_b_.str.$factory(other) + " not in range"
);
}
throw err;
}
}
}
var sub = $B.sub(other, self.start),
fl = $B.floordiv(sub, self.step),
res = $B.mul(self.step, fl);
if ($B.eq(res, sub)) {
if (
($B.gt(self.stop, self.start) &&
$B.ge(other, self.start) &&
$B.gt(self.stop, other)) ||
($B.ge(self.start, self.stop) &&
$B.ge(self.start, other) &&
$B.gt(other, self.stop))
) {
return fl;
} else {
throw _b_.ValueError.$factory(
_b_.str.$factory(other) + " not in range"
);
}
} else {
throw _b_.ValueError.$factory(_b_.str.$factory(other) + " not in range");
}
};
range.$factory = function () {
var $ = $B.args(
"range",
3,
{ start: null, stop: null, step: null },
["start", "stop", "step"],
arguments,
{ start: null, stop: null, step: null },
null,
null
),
start = $.start,
stop = $.stop,
step = $.step,
safe;
if (stop === null && step === null) {
if (start == null) {
throw _b_.TypeError.$factory("range expected 1 arguments, got 0");
}
stop = $B.PyNumber_Index(start);
safe = typeof stop === "number";
return {
__class__: range,
start: 0,
stop: stop,
step: 1,
$is_range: true,
$safe: safe,
};
}
if (step === null) {
step = 1;
}
start = $B.PyNumber_Index(start);
stop = $B.PyNumber_Index(stop);
step = $B.PyNumber_Index(step);
if (step == 0) {
throw _b_.ValueError.$factory("range arg 3 must not be zero");
}
safe =
typeof start == "number" &&
typeof stop == "number" &&
typeof step == "number";
return {
__class__: range,
start: start,
stop: stop,
step: step,
$is_range: true,
$safe: safe,
};
};
$B.set_func_names(range, "builtins");
var slice = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "slice" },
$is_class: true,
$native: true,
$descriptors: { start: true, step: true, stop: true },
};
slice.__eq__ = function (self, other) {
var conv1 = conv_slice(self),
conv2 = conv_slice(other);
return conv1[0] == conv2[0] && conv1[1] == conv2[1] && conv1[2] == conv2[2];
};
slice.__repr__ = function (self) {
$B.builtins_repr_check(slice, arguments);
return (
"slice(" +
_b_.str.$factory(self.start) +
", " +
_b_.str.$factory(self.stop) +
", " +
_b_.str.$factory(self.step) +
")"
);
};
slice.__setattr__ = function (self, attr, value) {
throw _b_.AttributeError.$factory("readonly attribute");
};
function conv_slice(self) {
var attrs = ["start", "stop", "step"],
res = [];
for (var i = 0; i < attrs.length; i++) {
var val = self[attrs[i]];
if (val === _b_.None) {
res.push(val);
} else {
try {
res.push($B.PyNumber_Index(val));
} catch (err) {
throw _b_.TypeError.$factory(
"slice indices must be " +
"integers or None or have an __index__ method"
);
}
}
}
return res;
}
slice.$conv_for_seq = function (self, len) {
var step = self.step === None ? 1 : $B.PyNumber_Index(self.step),
step_is_neg = $B.gt(0, step),
len_1 = $B.sub(len, 1);
if (step == 0) {
throw _b_.ValueError.$factory("slice step cannot be zero");
}
var start;
if (self.start === None) {
start = step_is_neg ? len_1 : 0;
} else {
start = $B.PyNumber_Index(self.start);
if ($B.gt(0, start)) {
start = $B.add(start, len);
if ($B.gt(0, start)) {
start = 0;
}
}
if ($B.ge(start, len)) {
start = step < 0 ? len_1 : len;
}
}
if (self.stop === None) {
stop = step_is_neg ? -1 : len;
} else {
stop = $B.PyNumber_Index(self.stop);
if ($B.gt(0, stop)) {
stop = $B.add(stop, len);
}
if ($B.ge(stop, len)) {
stop = step_is_neg ? len_1 : len;
}
}
return { start: start, stop: stop, step: step };
};
slice.start = function (self) {
return self.start;
};
slice.step = function (self) {
return self.step;
};
slice.stop = function (self) {
return self.stop;
};
slice.indices = function (self, length) {
var $ = $B.args(
"indices",
2,
{ self: null, length: null },
["self", "length"],
arguments,
{},
null,
null
);
var len = $B.$GetInt($.length);
if (len < 0) {
_b_.ValueError.$factory("length should not be negative");
}
var _step = self.step == _b_.None ? 1 : self.step;
if (_step < 0) {
var _start = self.start,
_stop = self.stop;
_start =
_start == _b_.None
? len - 1
: _start < 0
? _b_.max(-1, _start + len)
: _b_.min(len - 1, self.start);
_stop =
self.stop == _b_.None
? -1
: _stop < 0
? _b_.max(-1, _stop + len)
: _b_.min(len - 1, self.stop);
} else {
var _start = self.start == _b_.None ? 0 : _b_.min(len, self.start);
var _stop = self.stop == _b_.None ? len : _b_.min(len, self.stop);
if (_start < 0) {
_start = _b_.max(0, _start + len);
}
if (_stop < 0) {
_stop = _b_.max(0, _stop + len);
}
}
return _b_.tuple.$factory([_start, _stop, _step]);
};
slice.$factory = function () {
var $ = $B.args(
"slice",
3,
{ start: null, stop: null, step: null },
["start", "stop", "step"],
arguments,
{ stop: null, step: null },
null,
null
),
start,
stop,
step;
if ($.stop === null && $.step === null) {
start = _b_.None;
stop = $.start;
step = _b_.None;
} else {
start = $.start;
stop = $.stop;
step = $.step === null ? _b_.None : $.step;
}
var res = { __class__: slice, start: start, stop: stop, step: step };
conv_slice(res);
return res;
};
$B.set_func_names(slice, "builtins");
_b_.range = range;
_b_.slice = slice;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var from_unicode = {},
to_unicode = {};
$B.to_bytes = function (obj) {
var res;
if (_b_.isinstance(obj, [bytes, bytearray])) {
res = obj.source;
} else {
var ga = $B.$getattr(obj, "tobytes", null);
if (ga !== null) {
res = $B.$call(ga)().source;
} else {
throw _b_.TypeError.$factory(
"object doesn't support the buffer protocol"
);
}
}
return res;
};
function _strip(self, cars, lr) {
if (cars === undefined) {
cars = [];
var ws = "\r\n \t";
for (var i = 0, len = ws.length; i < len; i++) {
cars.push(ws.charCodeAt(i));
}
} else if (_b_.isinstance(cars, bytes)) {
cars = cars.source;
} else {
throw _b_.TypeError.$factory("Type str doesn't support the buffer API");
}
if (lr == "l") {
for (var i = 0, len = self.source.length; i < len; i++) {
if (cars.indexOf(self.source[i]) == -1) {
break;
}
}
return bytes.$factory(self.source.slice(i));
}
for (var i = self.source.length - 1; i >= 0; i--) {
if (cars.indexOf(self.source[i]) == -1) {
break;
}
}
return bytes.$factory(self.source.slice(0, i + 1));
}
function invalid(other) {
return !_b_.isinstance(other, [bytes, bytearray]);
}
var bytearray = {
__class__: _b_.type,
__mro__: [_b_.object],
$buffer_protocol: true,
$infos: { __module__: "builtins", __name__: "bytearray" },
$is_class: true,
};
var mutable_methods = [
"__delitem__",
"clear",
"copy",
"count",
"index",
"pop",
"remove",
"reverse",
"sort",
];
mutable_methods.forEach(function (method) {
bytearray[method] = (function (m) {
return function (self) {
var args = [self.source],
pos = 1;
for (var i = 1, len = arguments.length; i < len; i++) {
args[pos++] = arguments[i];
}
return _b_.list[m].apply(null, args);
};
})(method);
});
bytearray.__hash__ = _b_.None;
var bytearray_iterator = $B.make_iterator_class("bytearray_iterator");
bytearray.__iter__ = function (self) {
return bytearray_iterator.$factory(self.source);
};
bytearray.__mro__ = [_b_.object];
bytearray.__repr__ = bytearray.__str__ = function (self) {
return "bytearray(" + bytes.__repr__(self) + ")";
};
bytearray.__setitem__ = function (self, arg, value) {
if (_b_.isinstance(arg, _b_.int)) {
if (!_b_.isinstance(value, _b_.int)) {
throw _b_.TypeError.$factory("an integer is required");
} else if (value > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
var pos = arg;
if (arg < 0) {
pos = self.source.length + pos;
}
if (pos >= 0 && pos < self.source.length) {
self.source[pos] = value;
} else {
throw _b_.IndexError.$factory("list index out of range");
}
} else if (_b_.isinstance(arg, _b_.slice)) {
var start = arg.start === _b_.None ? 0 : arg.start;
var stop = arg.stop === _b_.None ? self.source.length : arg.stop;
if (start < 0) {
start = self.source.length + start;
}
if (stop < 0) {
stop = self.source.length + stop;
}
self.source.splice(start, stop - start);
try {
var $temp = _b_.list.$factory(value);
for (var i = $temp.length - 1; i >= 0; i--) {
if (!_b_.isinstance($temp[i], _b_.int)) {
throw _b_.TypeError.$factory("an integer is required");
} else if ($temp[i] > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
self.source.splice(start, 0, $temp[i]);
}
} catch (err) {
throw _b_.TypeError.$factory("can only assign an iterable");
}
} else {
throw _b_.TypeError.$factory(
"list indices must be integer, not " + $B.class_name(arg)
);
}
};
bytearray.append = function (self, b) {
if (arguments.length != 2) {
throw _b_.TypeError.$factory(
"append takes exactly one argument (" +
(arguments.length - 1) +
" given)"
);
}
if (!_b_.isinstance(b, _b_.int)) {
throw _b_.TypeError.$factory("an integer is required");
}
if (b > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
self.source[self.source.length] = b;
};
bytearray.extend = function (self, b) {
if (self.in_iteration) {
throw _b_.BufferError.$factory(
"Existing exports of data: object " + "cannot be re-sized"
);
}
if (b.__class__ === bytearray || b.__class__ === bytes) {
b.source.forEach(function (item) {
self.source.push(item);
});
return _b_.None;
}
var it = _b_.iter(b);
while (true) {
try {
bytearray.__add__(self, _b_.next(it));
} catch (err) {
if (err === _b_.StopIteration) {
break;
}
throw err;
}
}
return _b_.None;
};
bytearray.insert = function (self, pos, b) {
if (arguments.length != 3) {
throw _b_.TypeError.$factory(
"insert takes exactly 2 arguments (" +
(arguments.length - 1) +
" given)"
);
}
if (!_b_.isinstance(b, _b_.int)) {
throw _b_.TypeError.$factory("an integer is required");
}
if (b > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
_b_.list.insert(self.source, pos, b);
};
bytearray.$factory = function () {
var args = [bytearray];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(arguments[i]);
}
return bytearray.__new__.apply(null, args);
};
var bytes = {
__class__: _b_.type,
__mro__: [_b_.object],
$buffer_protocol: true,
$infos: { __module__: "builtins", __name__: "bytes" },
$is_class: true,
};
bytes.__add__ = function (self, other) {
if (_b_.isinstance(other, bytes)) {
return self.__class__.$factory(self.source.concat(other.source));
} else if (_b_.isinstance(other, bytearray)) {
return self.__class__.$factory(
bytes.__add__(self, bytes.$factory(other))
);
} else if (_b_.isinstance(other, _b_.memoryview)) {
return self.__class__.$factory(
bytes.__add__(self, _b_.memoryview.tobytes(other))
);
}
throw _b_.TypeError.$factory(
"can't concat bytes to " + _b_.str.$factory(other)
);
};
bytes.__contains__ = function (self, other) {
if (typeof other == "number") {
return self.source.indexOf(other) > -1;
}
if (self.source.length < other.source.length) {
return false;
}
var len = other.source.length;
for (var i = 0; i < self.source.length - other.source.length + 1; i++) {
var flag = true;
for (var j = 0; j < len; j++) {
if (other.source[i + j] != self.source[j]) {
flag = false;
break;
}
}
if (flag) {
return true;
}
}
return false;
};
var bytes_iterator = $B.make_iterator_class("bytes_iterator");
bytes.__iter__ = function (self) {
return bytes_iterator.$factory(self.source);
};
bytes.__eq__ = function (self, other) {
if (invalid(other)) {
return false;
}
return $B.$getattr(self.source, "__eq__")(other.source);
};
bytes.__ge__ = function (self, other) {
if (invalid(other)) {
return _b_.NotImplemented;
}
return _b_.list.__ge__(self.source, other.source);
};
bytes.__getitem__ = function (self, arg) {
var i;
if (_b_.isinstance(arg, _b_.int)) {
var pos = arg;
if (arg < 0) {
pos = self.source.length + pos;
}
if (pos >= 0 && pos < self.source.length) {
return self.source[pos];
}
throw _b_.IndexError.$factory("index out of range");
} else if (_b_.isinstance(arg, _b_.slice)) {
var s = _b_.slice.$conv_for_seq(arg, self.source.length),
start = s.start,
stop = s.stop,
step = s.step;
var res = [],
i = null,
pos = 0;
if (step > 0) {
stop = Math.min(stop, self.source.length);
if (stop <= start) {
return bytes.$factory([]);
}
for (var i = start; i < stop; i += step) {
res[pos++] = self.source[i];
}
} else {
if (stop >= start) {
return bytes.$factory([]);
}
stop = Math.max(0, stop);
for (var i = start; i >= stop; i += step) {
res[pos++] = self.source[i];
}
}
return bytes.$factory(res);
} else if (_b_.isinstance(arg, _b_.bool)) {
return self.source.__getitem__(_b_.int.$factory(arg));
}
};
bytes.__gt__ = function (self, other) {
if (invalid(other)) {
return _b_.NotImplemented;
}
return _b_.list.__gt__(self.source, other.source);
};
bytes.__hash__ = function (self) {
if (self === undefined) {
return bytes.__hashvalue__ || $B.$py_next_hash--;
}
var hash = 1;
for (var i = 0, len = self.source.length; i < len; i++) {
hash = (101 * hash + self.source[i]) & 0xffffffff;
}
return hash;
};
bytes.__init__ = function () {
return _b_.None;
};
bytes.__le__ = function (self, other) {
if (invalid(other)) {
return _b_.NotImplemented;
}
return _b_.list.__le__(self.source, other.source);
};
bytes.__len__ = function (self) {
return self.source.length;
};
bytes.__lt__ = function (self, other) {
if (invalid(other)) {
return _b_.NotImplemented;
}
return _b_.list.__lt__(self.source, other.source);
};
bytes.__mod__ = function (self, args) {
var s = decode(self, "ascii", "strict"),
res = _b_.str.__mod__(s, args);
return _b_.str.encode(res, "ascii");
};
bytes.__mul__ = function () {
var $ = $B.args(
"__mul__",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
),
other = $B.PyNumber_Index($.other);
var t = [],
source = $.self.source,
slen = source.length;
for (var i = 0; i < other; i++) {
for (var j = 0; j < slen; j++) {
t.push(source[j]);
}
}
var res = bytes.$factory();
res.source = t;
return res;
};
bytes.__ne__ = function (self, other) {
return !bytes.__eq__(self, other);
};
bytes.__new__ = function (cls, source, encoding, errors) {
var $ = $B.args(
"__new__",
4,
{ cls: null, source: null, encoding: null, errors: null },
["cls", "source", "encoding", "errors"],
arguments,
{ source: [], encoding: "utf-8", errors: "strict" },
null,
null
);
return bytes.$new($.cls, $.source, $.encoding, $.errors);
};
bytes.$new = function (cls, source, encoding, errors) {
var self = { __class__: cls },
int_list = [],
pos = 0;
if (source === undefined) {
} else if (typeof source == "number" || _b_.isinstance(source, _b_.int)) {
var i = source;
while (i--) {
int_list[pos++] = 0;
}
} else {
if (typeof source == "string" || _b_.isinstance(source, _b_.str)) {
if (encoding === undefined) {
throw _b_.TypeError.$factory("string argument without an encoding");
}
int_list = encode(source, encoding || "utf-8", errors || "strict");
} else {
int_list = _b_.list.$factory(source);
for (var i = 0; i < int_list.length; i++) {
try {
var item = _b_.int.$factory(int_list[i]);
} catch (err) {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(int_list[i]) +
"' object " +
"cannot be interpreted as an integer"
);
}
if (item < 0 || item > 255) {
throw _b_.ValueError.$factory(
"bytes must be in range" + "(0, 256)"
);
}
}
}
}
self.source = int_list;
self.encoding = encoding;
self.errors = errors;
return self;
};
bytes.__repr__ = bytes.__str__ = function (self) {
var t = $B.special_string_repr,
res = "";
for (var i = 0, len = self.source.length; i < len; i++) {
var s = self.source[i];
if (t[s] !== undefined) {
res += t[s];
} else if (s < 32 || s >= 128) {
var hx = s.toString(16);
hx = (hx.length == 1 ? "0" : "") + hx;
res += "\\x" + hx;
} else if (s == "\\".charCodeAt(0)) {
res += "\\\\";
} else {
res += String.fromCharCode(s);
}
}
if (res.indexOf("'") > -1 && res.indexOf('"') == -1) {
return 'b"' + res + '"';
} else {
return "b'" + res.replace(new RegExp("'", "g"), "\\'") + "'";
}
};
bytes.__reduce_ex__ = function (self) {
return bytes.__repr__(self);
};
bytes.capitalize = function (self) {
var src = self.source,
len = src.length,
buffer = src.slice();
if (buffer[0] > 96 && buffer[0] < 123) {
buffer[0] -= 32;
}
for (var i = 1; i < len; ++i) {
if (buffer[i] > 64 && buffer[i] < 91) {
buffer[i] += 32;
}
}
return bytes.$factory(buffer);
};
bytes.center = function () {
var $ = $B.args(
"center",
3,
{ self: null, width: null, fillbyte: null },
["self", "width", "fillbyte"],
arguments,
{ fillbyte: bytes.$factory([32]) },
null,
null
);
var diff = $.width - $.self.source.length;
if (diff <= 0) {
return bytes.$factory($.self.source);
}
var ljust = bytes.ljust(
$.self,
$.self.source.length + Math.floor(diff / 2),
$.fillbyte
);
return bytes.rjust(ljust, $.width, $.fillbyte);
};
bytes.count = function () {
var $ = $B.args(
"count",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: -1 },
null,
null
);
var n = 0,
index = -1,
len = 0;
if (typeof $.sub == "number") {
if ($.sub < 0 || $.sub > 255)
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
len = 1;
} else if (!$.sub.__class__) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name($.sub) +
"'"
);
} else if (!$.sub.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name($.sub) +
"'"
);
} else {
len = $.sub.source.length;
}
do {
index = bytes.find($.self, $.sub, Math.max(index + len, $.start), $.end);
if (index != -1) {
n++;
}
} while (index != -1);
return n;
};
bytes.decode = function (self, encoding, errors) {
var $ = $B.args(
"decode",
3,
{ self: null, encoding: null, errors: null },
["self", "encoding", "errors"],
arguments,
{ encoding: "utf-8", errors: "strict" },
null,
null
);
switch ($.errors) {
case "strict":
case "ignore":
case "replace":
case "surrogateescape":
case "surrogatepass":
case "xmlcharrefreplace":
case "backslashreplace":
return decode($.self, $.encoding, $.errors);
default:
}
};
bytes.endswith = function () {
var $ = $B.args(
"endswith",
4,
{ self: null, suffix: null, start: null, end: null },
["self", "suffix", "start", "end"],
arguments,
{ start: -1, end: -1 },
null,
null
);
if (_b_.isinstance($.suffix, bytes)) {
var start =
$.start == -1
? $.self.source.length - $.suffix.source.length
: Math.min($.self.source.length - $.suffix.source.length, $.start);
var end =
$.end == -1
? $.start == -1
? $.self.source.length
: start + $.suffix.source.length
: Math.min($.self.source.length - 1, $.end);
var res = true;
for (
var i = $.suffix.source.length - 1, len = $.suffix.source.length;
i >= 0 && res;
--i
) {
res = $.self.source[end - len + i] == $.suffix.source[i];
}
return res;
} else if (_b_.isinstance($.suffix, _b_.tuple)) {
for (var i = 0; i < $.suffix.length; ++i) {
if (_b_.isinstance($.suffix[i], bytes)) {
if (bytes.endswith($.self, $.suffix[i], $.start, $.end)) {
return true;
}
} else {
throw _b_.TypeError.$factory(
"endswith first arg must be " +
"bytes or a tuple of bytes, not " +
$B.class_name($.suffix)
);
}
}
return false;
} else {
throw _b_.TypeError.$factory(
"endswith first arg must be bytes " +
"or a tuple of bytes, not " +
$B.class_name($.suffix)
);
}
};
bytes.expandtabs = function () {
var $ = $B.args(
"expandtabs",
2,
{ self: null, tabsize: null },
["self", "tabsize"],
arguments,
{ tabsize: 8 },
null,
null
);
var tab_spaces = [];
for (let i = 0; i < $.tabsize; ++i) {
tab_spaces.push(32);
}
var buffer = $.self.source.slice();
for (let i = 0; i < buffer.length; ++i) {
if (buffer[i] === 9) {
buffer.splice.apply(buffer, [i, 1].concat(tab_spaces));
}
}
return _b_.bytes.$factory(buffer);
};
bytes.find = function (self, sub) {
if (arguments.length != 2) {
var $ = $B.args(
"find",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: -1 },
null,
null
),
sub = $.sub,
start = $.start,
end = $.end;
} else {
var start = 0,
end = -1;
}
if (typeof sub == "number") {
if (sub < 0 || sub > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
return self.source
.slice(0, end == -1 ? undefined : end)
.indexOf(sub, start);
} else if (!sub.__class__) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name(sub) +
"'"
);
} else if (!sub.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name(sub) +
"'"
);
}
end = end == -1 ? self.source.length : Math.min(self.source.length, end);
var len = sub.source.length;
for (var i = start; i <= end - len; i++) {
var chunk = self.source.slice(i, i + len),
found = true;
for (var j = 0; j < len; j++) {
if (chunk[j] != sub.source[j]) {
found = false;
break;
}
}
if (found) {
return i;
}
}
return -1;
};
bytes.fromhex = function () {
var $ = $B.args(
"fromhex",
2,
{ cls: null, string: null },
["cls", "string"],
arguments,
{},
null,
null
),
string = $.string.replace(/\s/g, ""),
source = [];
for (var i = 0; i < string.length; i += 2) {
if (i + 2 > string.length) {
throw _b_.ValueError.$factory(
"non-hexadecimal number found " + "in fromhex() arg"
);
}
source.push(_b_.int.$factory(string.substr(i, 2), 16));
}
return $.cls.$factory(source);
};
bytes.hex = function () {
var $ = $B.args(
"hex",
3,
{ self: null, sep: null, bytes_per_sep: null },
["self", "sep", "bytes_per_sep"],
arguments,
{ sep: "", bytes_per_sep: 1 },
null,
null
),
self = $.self,
sep = $.sep,
bytes_per_sep = $.bytes_per_sep,
res = "",
digits = "0123456789abcdef",
bps = bytes_per_sep,
jstart = bps,
len = self.source.length;
if (bytes_per_sep < 0) {
bps = -bytes_per_sep;
jstart = bps;
} else if (bytes_per_sep == 0) {
sep = "";
} else {
jstart = len % bps;
if (jstart == 0) {
jstart = bps;
}
}
for (var i = 0, j = jstart; i < len; i++) {
var c = self.source[i];
if (j == 0) {
res += sep;
j = bps;
}
j--;
res += digits[c >> 4];
res += digits[c & 0x0f];
}
return res;
};
bytes.index = function () {
var $ = $B.args(
"rfind",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: -1 },
null,
null
);
var index = bytes.find($.self, $.sub, $.start, $.end);
if (index == -1) {
throw _b_.ValueError.$factory("subsection not found");
}
return index;
};
bytes.isalnum = function (self) {
var src = self.source,
len = src.length,
res = len > 0;
for (var i = 0; i < len && res; ++i) {
res =
(src[i] > 96 && src[i] < 123) ||
(src[i] > 64 && src[i] < 91) ||
(src[i] > 47 && src[i] < 58);
}
return res;
};
bytes.isalpha = function (self) {
var src = self.source,
len = src.length,
res = len > 0;
for (var i = 0; i < len && res; ++i) {
res = (src[i] > 96 && src[i] < 123) || (src[i] > 64 && src[i] < 91);
}
return res;
};
bytes.isdigit = function (self) {
var src = self.source,
len = src.length,
res = len > 0;
for (let i = 0; i < len && res; ++i) {
res = src[i] > 47 && src[i] < 58;
}
return res;
};
bytes.islower = function (self) {
var src = self.source,
len = src.length,
res = false;
for (let i = 0; i < len; ++i) {
res = res || (src[i] > 96 && src[i] < 123);
if (src[i] > 64 && src[i] < 91) {
return false;
}
}
return res;
};
bytes.isspace = function (self) {
var src = self.source,
len = src.length;
for (let i = 0; i < len; ++i) {
switch (src[i]) {
case 9:
case 10:
case 11:
case 12:
case 13:
case 32:
break;
default:
return false;
}
}
return true;
};
bytes.isupper = function (self) {
var src = self.source,
len = src.length,
res = false;
for (let i = 0; i < len; ++i) {
res = res || (src[i] > 64 && src[i] < 91);
if (src[i] > 96 && src[i] < 123) {
return false;
}
}
return res;
};
bytes.istitle = function (self) {
var src = self.source,
len = src.length,
current_char_is_letter = false,
prev_char_was_letter = false,
is_uppercase = false,
is_lowercase = false;
for (var i = 0; i < len; ++i) {
is_lowercase = src[i] > 96 && src[i] < 123;
is_uppercase = src[i] > 64 && src[i] < 91;
current_char_is_letter = is_lowercase || is_uppercase;
if (
(current_char_is_letter && prev_char_was_letter && is_uppercase) ||
(!prev_char_was_letter && is_lowercase)
) {
return false;
}
prev_char_was_letter = current_char_is_letter;
}
return true;
};
bytes.join = function () {
var $ns = $B.args(
"join",
2,
{ self: null, iterable: null },
["self", "iterable"],
arguments,
{}
),
self = $ns["self"],
iterable = $ns["iterable"];
var next_func = $B.$getattr(_b_.iter(iterable), "__next__"),
res = self.__class__.$factory(),
empty = true;
while (true) {
try {
var item = next_func();
if (empty) {
empty = false;
} else {
res = bytes.__add__(res, self);
}
res = bytes.__add__(res, item);
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
return res;
};
var _lower = function (char_code) {
if (char_code >= 65 && char_code <= 90) {
return char_code + 32;
} else {
return char_code;
}
};
bytes.lower = function (self) {
var _res = [],
pos = 0;
for (var i = 0, len = self.source.length; i < len; i++) {
if (self.source[i]) {
_res[pos++] = _lower(self.source[i]);
}
}
return bytes.$factory(_res);
};
bytes.ljust = function () {
var $ = $B.args(
"ljust",
3,
{ self: null, width: null, fillbyte: null },
["self", "width", "fillbyte"],
arguments,
{ fillbyte: bytes.$factory([32]) },
null,
null
);
if (!$.fillbyte.__class__) {
throw _b_.TypeError.$factory(
"argument 2 must be a byte string of length 1, " +
"not '" +
$B.class_name($.fillbyte) +
"'"
);
} else if (!$.fillbyte.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"argument 2 must be a byte string of length 1, " +
"not '" +
$B.class_name($.fillbyte) +
"'"
);
}
var padding = [],
count = $.width - $.self.source.length;
for (var i = 0; i < count; ++i) {
padding.push($.fillbyte.source[0]);
}
return bytes.$factory($.self.source.concat(padding));
};
bytes.lstrip = function (self, cars) {
return _strip(self, cars, "l");
};
bytes.maketrans = function (from, to) {
var _t = [],
to = $B.to_bytes(to);
for (var i = 0; i < 256; i++) {
_t[i] = i;
}
for (var i = 0, len = from.source.length; i < len; i++) {
var _ndx = from.source[i];
_t[_ndx] = to[i];
}
return bytes.$factory(_t);
};
bytes.partition = function () {
var $ = $B.args(
"partition",
2,
{ self: null, sep: null },
["self", "sep"],
arguments,
{},
null,
null
);
if (!$.sep.__class__) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
} else if (!$.sep.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
}
var len = $.sep.source.length,
src = $.self.source,
i = bytes.find($.self, $.sep);
return _b_.tuple.$factory([
bytes.$factory(src.slice(0, i)),
bytes.$factory(src.slice(i, i + len)),
bytes.$factory(src.slice(i + len)),
]);
};
bytes.removeprefix = function () {
var $ = $B.args(
"removeprefix",
2,
{ self: null, prefix: null },
["self", "prefix"],
arguments,
{},
null,
null
);
if (!_b_.isinstance($.prefix, [bytes, bytearray])) {
throw _b_.ValueError.$factory(
"prefix should be bytes, not " + `'${$B.class_name($.prefix)}'`
);
}
if (bytes.startswith($.self, $.prefix)) {
return bytes.__getitem__(
$.self,
_b_.slice.$factory($.prefix.source.length, _b_.None)
);
}
return bytes.__getitem__($.self, _b_.slice.$factory(0, _b_.None));
};
bytes.removesuffix = function () {
var $ = $B.args(
"removesuffix",
2,
{ self: null, prefix: null },
["self", "suffix"],
arguments,
{},
null,
null
);
if (!_b_.isinstance($.suffix, [bytes, bytearray])) {
throw _b_.ValueError.$factory(
"suffix should be bytes, not " + `'${$B.class_name($.suffix)}'`
);
}
if (bytes.endswith($.self, $.suffix)) {
return bytes.__getitem__(
$.self,
_b_.slice.$factory(0, $.suffix.source.length + 1)
);
}
return bytes.__getitem__($.self, _b_.slice.$factory(0, _b_.None));
};
bytes.replace = function () {
var $ = $B.args(
"replace",
4,
{ self: null, old: null, new: null, count: null },
["self", "old", "new", "count"],
arguments,
{ count: -1 },
null,
null
),
res = [];
var self = $.self,
src = self.source,
len = src.length,
old = $.old,
$new = $.new;
var count = $.count >= 0 ? $.count : src.length;
if (!$.old.__class__) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name($.old) +
"'"
);
} else if (!$.old.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name($.sep) +
"'"
);
}
if (!$.new.__class__) {
throw _b_.TypeError.$factory(
"second argument must be a bytes-like " +
"object, not '" +
$B.class_name($.old) +
"'"
);
} else if (!$.new.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"second argument must be a bytes-like " +
"object, not '" +
$B.class_name($.sep) +
"'"
);
}
for (var i = 0; i < len; i++) {
if (bytes.startswith(self, old, i) && count) {
for (var j = 0; j < $new.source.length; j++) {
res.push($new.source[j]);
}
i += old.source.length - 1;
count--;
} else {
res.push(src[i]);
}
}
return bytes.$factory(res);
};
bytes.rfind = function (self, subbytes) {
if (arguments.length == 2 && subbytes.__class__ === bytes) {
var sub = subbytes,
start = 0,
end = -1;
} else {
var $ = $B.args(
"rfind",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: -1 },
null,
null
),
self = $.self,
sub = $.sub,
start = $.start,
end = $.end;
}
if (typeof sub == "number") {
if (sub < 0 || sub > 255) {
throw _b_.ValueError.$factory("byte must be in range(0, 256)");
}
return (
$.self.source
.slice(start, $.end == -1 ? undefined : $.end)
.lastIndexOf(sub) + start
);
} else if (!sub.__class__) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name($.sub) +
"'"
);
} else if (!sub.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"first argument must be a bytes-like " +
"object, not '" +
$B.class_name(sub) +
"'"
);
}
end = end == -1 ? self.source.length : Math.min(self.source.length, end);
var len = sub.source.length;
for (var i = end - len; i >= start; --i) {
var chunk = self.source.slice(i, i + len),
found = true;
for (var j = 0; j < len; j++) {
if (chunk[j] != sub.source[j]) {
found = false;
break;
}
}
if (found) {
return i;
}
}
return -1;
};
bytes.rindex = function () {
var $ = $B.args(
"rfind",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: -1 },
null,
null
);
var index = bytes.rfind($.self, $.sub, $.start, $.end);
if (index == -1) {
throw _b_.ValueError.$factory("subsection not found");
}
return index;
};
bytes.rjust = function () {
var $ = $B.args(
"rjust",
3,
{ self: null, width: null, fillbyte: null },
["self", "width", "fillbyte"],
arguments,
{ fillbyte: bytes.$factory([32]) },
null,
null
);
if (!$.fillbyte.__class__) {
throw _b_.TypeError.$factory(
"argument 2 must be a byte string of length 1, " +
"not '" +
$B.class_name($.fillbyte) +
"'"
);
} else if (!$.fillbyte.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"argument 2 must be a byte string of length 1, " +
"not '" +
$B.class_name($.fillbyte) +
"'"
);
}
var padding = [],
count = $.width - $.self.source.length;
for (var i = 0; i < count; ++i) {
padding.push($.fillbyte.source[0]);
}
return bytes.$factory(padding.concat($.self.source));
};
bytes.rpartition = function () {
var $ = $B.args(
"rpartition",
2,
{ self: null, sep: null },
["self", "sep"],
arguments,
{},
null,
null
);
if (!$.sep.__class__) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
} else if (!$.sep.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
}
var len = $.sep.source.length,
src = $.self.source,
i = bytes.rfind($.self, $.sep);
return _b_.tuple.$factory([
bytes.$factory(src.slice(0, i)),
bytes.$factory(src.slice(i, i + len)),
bytes.$factory(src.slice(i + len)),
]);
};
bytes.rstrip = function (self, cars) {
return _strip(self, cars, "r");
};
bytes.split = function () {
var $ = $B.args(
"split",
2,
{ self: null, sep: null },
["self", "sep"],
arguments,
{ sep: bytes.$factory([32]) },
null,
null
),
res = [],
start = 0,
stop = 0;
if (!$.sep.__class__) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
} else if (!$.sep.__class__.$buffer_protocol) {
throw _b_.TypeError.$factory(
"a bytes-like object is required, " +
"not '" +
$B.class_name($.sep) +
"'"
);
}
var seps = $.sep.source,
len = seps.length,
src = $.self.source,
blen = src.length;
while (stop < blen) {
var match = true;
for (var i = 0; i < len && match; i++) {
if (src[stop + i] != seps[i]) {
match = false;
}
}
if (match) {
res.push(bytes.$factory(src.slice(start, stop)));
start = stop + len;
stop = start;
} else {
stop++;
}
}
if (match || stop > start) {
res.push(bytes.$factory(src.slice(start, stop)));
}
return res;
};
bytes.splitlines = function (self) {
var $ = $B.args(
"splitlines",
2,
{ self: null, keepends: null },
["self", "keepends"],
arguments,
{ keepends: false },
null,
null
);
if (!_b_.isinstance($.keepends, [_b_.bool, _b_.int])) {
throw _b_.TypeError(
"integer argument expected, got " + $B.get_class($.keepends).__name
);
}
var keepends = _b_.int.$factory($.keepends),
res = [],
source = $.self.source,
start = 0,
pos = 0;
if (!source.length) {
return res;
}
while (pos < source.length) {
if (
pos < source.length - 1 &&
source[pos] == 0x0d &&
source[pos + 1] == 0x0a
) {
res.push(bytes.$factory(source.slice(start, keepends ? pos + 2 : pos)));
start = pos = pos + 2;
} else if (source[pos] == 0x0d || source[pos] == 0x0a) {
res.push(bytes.$factory(source.slice(start, keepends ? pos + 1 : pos)));
start = pos = pos + 1;
} else {
pos++;
}
}
if (start < source.length) {
res.push(bytes.$factory(source.slice(start)));
}
return res;
};
bytes.startswith = function () {
var $ = $B.args(
"startswith",
3,
{ self: null, prefix: null, start: null },
["self", "prefix", "start"],
arguments,
{ start: 0 },
null,
null
),
start = $.start;
if (_b_.isinstance($.prefix, bytes)) {
var res = true;
for (var i = 0; i < $.prefix.source.length && res; i++) {
res = $.self.source[start + i] == $.prefix.source[i];
}
return res;
} else if (_b_.isinstance($.prefix, _b_.tuple)) {
var items = [];
for (var i = 0; i < $.prefix.length; i++) {
if (_b_.isinstance($.prefix[i], bytes)) {
items = items.concat($.prefix[i].source);
} else {
throw _b_.TypeError.$factory(
"startswith first arg must be " +
"bytes or a tuple of bytes, not " +
$B.class_name($.prefix)
);
}
}
var prefix = bytes.$factory(items);
return bytes.startswith($.self, prefix, start);
} else {
throw _b_.TypeError.$factory(
"startswith first arg must be bytes " +
"or a tuple of bytes, not " +
$B.class_name($.prefix)
);
}
};
bytes.strip = function (self, cars) {
var res = bytes.lstrip(self, cars);
return bytes.rstrip(res, cars);
};
bytes.swapcase = function (self) {
var src = self.source,
len = src.length,
buffer = src.slice();
for (var i = 0; i < len; ++i) {
if (buffer[i] > 96 && buffer[i] < 123) {
buffer[i] -= 32;
} else if (buffer[i] > 64 && buffer[i] < 91) {
buffer[i] += 32;
}
}
return bytes.$factory(buffer);
};
bytes.title = function (self) {
var src = self.source,
len = src.length;
(buffer = src.slice()),
(current_char_is_letter = false),
(prev_char_was_letter = false),
(is_uppercase = false),
(is_lowercase = false);
for (var i = 0; i < len; ++i) {
is_lowercase = buffer[i] > 96 && buffer[i] < 123;
is_uppercase = buffer[i] > 64 && buffer[i] < 91;
current_char_is_letter = is_lowercase || is_uppercase;
if (current_char_is_letter) {
if (prev_char_was_letter && is_uppercase) {
buffer[i] += 32;
} else if (!prev_char_was_letter && is_lowercase) {
buffer[i] -= 32;
}
}
prev_char_was_letter = current_char_is_letter;
}
return bytes.$factory(buffer);
};
bytes.translate = function (self, table, _delete) {
if (_delete === undefined) {
_delete = [];
} else if (_b_.isinstance(_delete, bytes)) {
_delete = _delete.source;
} else {
throw _b_.TypeError.$factory(
"Type " +
$B.get_class(_delete).__name +
" doesn't support the buffer API"
);
}
var res = [],
pos = 0;
if (_b_.isinstance(table, bytes) && table.source.length == 256) {
for (var i = 0, len = self.source.length; i < len; i++) {
if (_delete.indexOf(self.source[i]) > -1) {
continue;
}
res[pos++] = table.source[self.source[i]];
}
}
return bytes.$factory(res);
};
var _upper = function (char_code) {
if (char_code >= 97 && char_code <= 122) {
return char_code - 32;
} else {
return char_code;
}
};
bytes.upper = function (self) {
var _res = [],
pos = 0;
for (var i = 0, len = self.source.length; i < len; i++) {
if (self.source[i]) {
_res[pos++] = _upper(self.source[i]);
}
}
return bytes.$factory(_res);
};
bytes.zfill = function (self, width) {
var buffer = self.source.slice(),
prefix_offset = buffer[0] == 43 || buffer[0] == 45 ? 1 : 0;
var count = width - self.source.length;
var padding = [];
for (var i = 0; i < count; ++i) {
padding.push(48);
}
buffer.splice.apply(buffer, [prefix_offset, 0].concat(padding));
return bytes.$factory(buffer);
};
function $UnicodeEncodeError(encoding, code_point, position) {
throw _b_.UnicodeEncodeError.$factory(
"'" +
encoding +
"' codec can't encode character " +
_b_.hex(code_point) +
" in position " +
position
);
}
function $UnicodeDecodeError(encoding, position) {
throw _b_.UnicodeDecodeError.$factory(
"'" + encoding + "' codec can't decode bytes in position " + position
);
}
function _hex(_int) {
return _int.toString(16);
}
function _int(hex) {
return parseInt(hex, 16);
}
function normalise(encoding) {
var enc = encoding.toLowerCase();
if (enc.substr(0, 7) == "windows") {
enc = "cp" + enc.substr(7);
}
if (enc.startsWith("cp-") || enc.startsWith("iso-")) {
enc = enc.replace("-", "");
}
enc = enc.replace(/-/g, "_");
return enc;
}
function load_decoder(enc) {
if (to_unicode[enc] === undefined) {
var mod = _b_.__import__("encodings." + enc);
if (mod[enc].getregentry) {
to_unicode[enc] = $B.$getattr(mod[enc].getregentry(), "decode");
}
}
}
function load_encoder(enc) {
if (from_unicode[enc] === undefined) {
var mod = _b_.__import__("encodings." + enc);
if (mod[enc].getregentry) {
from_unicode[enc] = $B.$getattr(mod[enc].getregentry(), "encode");
}
}
}
var decode = ($B.decode = function (obj, encoding, errors) {
var s = "",
b = obj.source,
enc = normalise(encoding);
switch (enc) {
case "utf_8":
case "utf-8":
case "utf8":
case "U8":
case "UTF":
var pos = 0,
s = "",
err_info;
while (pos < b.length) {
var byte = b[pos];
err_info = null;
if (!(byte & 0x80)) {
s += String.fromCodePoint(byte);
pos++;
} else if (byte >> 5 == 6) {
if (b[pos + 1] === undefined) {
err_info = [byte, pos, "end"];
} else if ((b[pos + 1] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation"];
}
if (err_info !== null) {
if (errors == "ignore") {
pos++;
} else {
throw _b_.UnicodeDecodeError.$factory(
"'utf-8' codec can't decode byte 0x" +
err_info[0].toString(16) +
" in position " +
err_info[1] +
(err_info[2] == "end"
? ": unexpected end of data"
: ": invalid continuation byte")
);
}
} else {
var cp = byte & 0x1f;
cp <<= 6;
cp += b[pos + 1] & 0x3f;
s += String.fromCodePoint(cp);
pos += 2;
}
} else if (byte >> 4 == 14) {
if (b[pos + 1] === undefined) {
err_info = [byte, pos, "end", pos + 1];
} else if ((b[pos + 1] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation", pos + 2];
} else if (b[pos + 2] === undefined) {
err_info = [byte, pos + "-" + (pos + 1), "end", pos + 2];
} else if ((b[pos + 2] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation", pos + 3];
}
if (err_info !== null) {
if (errors == "ignore") {
pos = err_info[3];
} else if (errors == "surrogateescape") {
for (var i = pos; i < err_info[3]; i++) {
s += String.fromCodePoint(0xdc80 + b[i] - 0x80);
}
pos = err_info[3];
} else {
throw _b_.UnicodeDecodeError.$factory(
"'utf-8' codec can't decode byte 0x" +
err_info[0].toString(16) +
" in position " +
err_info[1] +
(err_info[2] == "end"
? ": unexpected end of data"
: ": invalid continuation byte")
);
}
} else {
var cp = byte & 0xf;
cp = cp << 12;
cp += (b[pos + 1] & 0x3f) << 6;
cp += b[pos + 2] & 0x3f;
s += String.fromCodePoint(cp);
pos += 3;
}
} else if (byte >> 3 == 30) {
if (b[pos + 1] === undefined) {
err_info = [byte, pos, "end", pos + 1];
} else if ((b[pos + 1] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation", pos + 2];
} else if (b[pos + 2] === undefined) {
err_info = [byte, pos + "-" + (pos + 1), "end", pos + 2];
} else if ((b[pos + 2] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation", pos + 3];
} else if (b[pos + 3] === undefined) {
err_info = [
byte,
pos + "-" + (pos + 1) + "-" + (pos + 2),
"end",
pos + 3,
];
} else if ((b[pos + 2] & 0xc0) != 0x80) {
err_info = [byte, pos, "continuation", pos + 3];
}
if (err_info !== null) {
if (errors == "ignore") {
pos = err_info[3];
} else if (errors == "surrogateescape") {
for (var i = pos; i < err_info[3]; i++) {
s += String.fromCodePoint(0xdc80 + b[i] - 0x80);
}
pos = err_info[3];
} else {
throw _b_.UnicodeDecodeError.$factory(
"'utf-8' codec can't decode byte 0x" +
err_info[0].toString(16) +
" in position " +
err_info[1] +
(err_info[2] == "end"
? ": unexpected end of data"
: ": invalid continuation byte")
);
}
} else {
var cp = byte & 0xf;
cp = cp << 18;
cp += (b[pos + 1] & 0x3f) << 12;
cp += (b[pos + 2] & 0x3f) << 6;
cp += b[pos + 3] & 0x3f;
s += String.fromCodePoint(cp);
pos += 4;
}
} else {
if (errors == "ignore") {
pos++;
} else if (errors == "surrogateescape") {
s += String.fromCodePoint(0xdc80 + b[pos] - 0x80);
pos++;
} else {
throw _b_.UnicodeDecodeError.$factory(
"'utf-8' codec can't decode byte 0x" +
byte.toString(16) +
" in position " +
pos +
": invalid start byte"
);
}
}
}
return s;
case "latin_1":
case "windows1252":
case "iso-8859-1":
case "iso8859-1":
case "8859":
case "cp819":
case "latin":
case "latin1":
case "L1":
b.forEach(function (item) {
s += String.fromCharCode(item);
});
break;
case "unicode_escape":
if (obj.__class__ === bytes || obj.__class__ === bytearray) {
obj = decode(obj, "latin-1", "strict");
}
return obj
.replace(/\\n/g, "\n")
.replace(/\\a/g, "\u0007")
.replace(/\\b/g, "\b")
.replace(/\\f/g, "\f")
.replace(/\\t/g, "\t")
.replace(/\\'/g, "'")
.replace(/\\"/g, '"');
case "raw_unicode_escape":
if (obj.__class__ === bytes || obj.__class__ === bytearray) {
obj = decode(obj, "latin-1", "strict");
}
return obj.replace(/\\u([a-fA-F0-9]{4})/g, function (mo) {
var cp = parseInt(mo.substr(2), 16);
return String.fromCharCode(cp);
});
case "ascii":
for (var i = 0, len = b.length; i < len; i++) {
var cp = b[i];
if (cp <= 127) {
s += String.fromCharCode(cp);
} else {
if (errors == "ignore") {
} else {
var msg =
"'ascii' codec can't decode byte 0x" +
cp.toString(16) +
" in position " +
i +
": ordinal not in range(128)";
throw _b_.UnicodeDecodeError.$factory(msg);
}
}
}
break;
default:
try {
load_decoder(enc);
} catch (err) {
console.log(b, encoding, "error load_decoder", err);
throw _b_.LookupError.$factory("unknown encoding: " + enc);
}
return to_unicode[enc](obj)[0];
}
return s;
});
var encode = ($B.encode = function () {
var $ = $B.args(
"encode",
3,
{ s: null, encoding: null, errors: null },
["s", "encoding", "errors"],
arguments,
{ encoding: "utf-8", errors: "strict" },
null,
null
),
s = $.s,
encoding = $.encoding,
errors = $.errors;
var t = [],
pos = 0,
enc = normalise(encoding);
switch (enc) {
case "utf-8":
case "utf_8":
case "utf8":
var res = [];
for (var i = 0, len = s.length; i < len; i++) {
var cp = s.charCodeAt(i);
if (cp < 0x7f) {
res.push(cp);
} else if (cp < 0x7ff) {
res.push(0xc0 + (cp >> 6), 0x80 + (cp & 0x3f));
} else if (cp < 0xffff) {
res.push(
0xe0 + (cp >> 12),
0x80 + ((cp & 0xfff) >> 6),
0x80 + (cp & 0x3f)
);
} else {
console.log("4 bytes");
}
}
return res;
case "latin":
case "latin1":
case "latin-1":
case "latin_1":
case "L1":
case "iso8859_1":
case "iso_8859_1":
case "8859":
case "cp819":
case "windows1252":
for (var i = 0, len = s.length; i < len; i++) {
var cp = s.charCodeAt(i);
if (cp <= 255) {
t[pos++] = cp;
} else if (errors != "ignore") {
$UnicodeEncodeError(encoding, i);
}
}
break;
case "ascii":
for (var i = 0, len = s.length; i < len; i++) {
var cp = s.charCodeAt(i);
if (cp <= 127) {
t[pos++] = cp;
} else if (errors != "ignore") {
$UnicodeEncodeError(encoding, i);
}
}
break;
case "raw_unicode_escape":
for (var i = 0, len = s.length; i < len; i++) {
var cp = s.charCodeAt(i);
if (cp < 256) {
t[pos++] = cp;
} else {
var us = cp.toString(16);
if (us.length % 2) {
us = "0" + us;
}
us = "\\u" + us;
for (var j = 0; j < us.length; j++) {
t[pos++] = us.charCodeAt(j);
}
}
}
break;
default:
try {
load_encoder(enc);
} catch (err) {
throw _b_.LookupError.$factory("unknown encoding: " + encoding);
}
t = from_unicode[enc](s)[0].source;
}
return t;
});
bytes.$factory = function (source, encoding, errors) {
var $ = $B.args(
"bytes",
3,
{ source: null, encoding: null, errors: null },
["source", "encoding", "errors"],
arguments,
{ source: [], encoding: "utf-8", errors: "strict" },
null,
null
);
return bytes.$new(bytes, $.source, $.encoding, $.errors);
};
bytes.__class__ = _b_.type;
bytes.$is_class = true;
for (var attr in bytes) {
if (bytearray[attr] === undefined && typeof bytes[attr] == "function") {
bytearray[attr] = (function (_attr) {
return function () {
return bytes[_attr].apply(null, arguments);
};
})(attr);
}
}
$B.set_func_names(bytes, "builtins");
bytes.fromhex = _b_.classmethod.$factory(bytes.fromhex);
$B.set_func_names(bytearray, "builtins");
bytearray.fromhex = _b_.classmethod.$factory(bytearray.fromhex);
_b_.bytes = bytes;
_b_.bytearray = bytearray;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins,
object = _b_.object,
$N = _b_.None;
function create_type(obj) {
return $B.get_class(obj).$factory();
}
function clone(obj) {
var res = create_type(obj);
res.$items = obj.$items.slice();
for (key in obj.$hashes) {
res.$hashes[key] = obj.$hashes[key];
}
return res;
}
var set = {
__class__: _b_.type,
$infos: { __module__: "builtins", __name__: "set" },
$is_class: true,
$native: true,
};
set.__and__ = function (self, other, accept_iter) {
try {
$test(accept_iter, other);
} catch (err) {
return _b_.NotImplemented;
}
var res = create_type(self);
for (var i = 0, len = self.$items.length; i < len; i++) {
if (_b_.getattr(other, "__contains__")(self.$items[i])) {
set.add(res, self.$items[i]);
}
}
return res;
};
set.__class_getitem__ = function (cls, item) {
if (!Array.isArray(item)) {
item = [item];
}
return $B.GenericAlias.$factory(cls, item);
};
set.__contains__ = function (self, item) {
if (typeof item == "number" || item instanceof Number) {
if (isNaN(item)) {
for (var i = self.$items.length - 1; i >= 0; i--) {
if (isNaN(self.$items[i])) {
return true;
}
}
return false;
} else if (item instanceof Number) {
return self.$numbers.indexOf(item.valueOf()) > -1;
} else {
return self.$items.indexOf(item) > -1;
}
} else if (typeof item == "string") {
return self.$items.indexOf(item) > -1;
}
var hash = _b_.hash(item),
item_class = item.__class__ || $B.get_class(item);
if (self.$hashes[hash]) {
for (var i = 0, len = self.$hashes[hash].length; i < len; i++) {
if (self.$hashes[hash][i] === item) {
return true;
}
}
for (var i = 0, len = self.$hashes[hash].length; i < len; i++) {
if ($B.rich_comp("__eq__", self.$hashes[hash][i], item)) {
return true;
}
}
}
return false;
};
set.__eq__ = function (self, other) {
if (other === undefined) {
return self === set;
}
if (_b_.isinstance(other, [_b_.set, _b_.frozenset])) {
if (other.$items.length == self.$items.length) {
for (var i = 0, len = self.$items.length; i < len; i++) {
if (set.__contains__(self, other.$items[i]) === false) {
return false;
}
}
return true;
}
return false;
}
return _b_.NotImplemented;
};
set.__format__ = function (self, format_string) {
return set.__str__(self);
};
set.__ge__ = function (self, other) {
if (_b_.isinstance(other, [set, frozenset])) {
return set.__le__(other, self);
}
return _b_.NotImplemented;
};
set.__gt__ = function (self, other) {
if (_b_.isinstance(other, [set, frozenset])) {
return set.__lt__(other, self);
}
return _b_.NotImplemented;
};
set.__hash__ = _b_.None;
set.__init__ = function (self, iterable, second) {
if (second === undefined) {
if (Array.isArray(iterable)) {
for (var i = 0, len = iterable.length; i < len; i++) {
$add(self, iterable[i]);
}
return $N;
}
}
var $ = $B.args(
"__init__",
2,
{ self: null, iterable: null },
["self", "iterable"],
arguments,
{ iterable: [] },
null,
null
),
self = $.self,
iterable = $.iterable;
if (_b_.isinstance(iterable, [set, frozenset])) {
self.$items = iterable.$items.slice();
self.$hashes = {};
for (var key in iterable.$hashes) {
self.$hashes[key] = iterable.$hashes[key];
}
return $N;
}
var it = $B.$iter(iterable);
while (1) {
try {
var item = _b_.next(it);
$add(self, item);
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
return $N;
};
var set_iterator = $B.make_iterator_class("set iterator");
set.__iter__ = function (self) {
self.$items.sort(function (x, y) {
var hx = _b_.hash(x),
hy = _b_.hash(y);
return hx == hy ? 0 : hx < hy ? -1 : 1;
});
return set_iterator.$factory(self.$items);
};
set.__le__ = function (self, other) {
if (_b_.isinstance(other, [set, frozenset])) {
var cfunc = _b_.getattr(other, "__contains__");
for (var i = 0, len = self.$items.length; i < len; i++) {
if (!cfunc(self.$items[i])) {
return false;
}
}
return true;
} else {
return _b_.NotImplemented;
}
};
set.__len__ = function (self) {
return self.$items.length;
};
set.__lt__ = function (self, other) {
if (_b_.isinstance(other, [set, frozenset])) {
return (
set.__le__(self, other) &&
set.__len__(self) < _b_.getattr(other, "__len__")()
);
} else {
return _b_.NotImplemented;
}
};
set.__mro__ = [_b_.object];
set.__new__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory("set.__new__(): not enough arguments");
}
return {
__class__: cls,
$items: [],
$numbers: [],
$hashes: {},
};
};
set.__or__ = function (self, other, accept_iter) {
var res = clone(self),
func = _b_.getattr($B.$iter(other), "__next__");
while (1) {
try {
set.add(res, func());
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
res.__class__ = self.__class__;
return res;
};
set.__rand__ = function (self, other) {
return set.__and__(self, other);
};
set.__reduce__ = function (self) {
return _b_.tuple.$factory([
self.__class__,
_b_.tuple.$factory([self.$items]),
$N,
]);
};
set.__reduce_ex__ = function (self, protocol) {
return set.__reduce__(self);
};
set.__repr__ = function (self) {
$B.builtins_repr_check(set, arguments);
return set_repr(self);
};
function set_repr(self) {
klass_name = $B.class_name(self);
if (self.$items.length === 0) {
return klass_name + "()";
}
var head = klass_name + "({",
tail = "})";
if (head == "set({") {
head = "{";
tail = "}";
}
var res = [];
if ($B.repr.enter(self)) {
return klass_name + "(...)";
}
try {
self.$items.sort(function (x, y) {
var hx = _b_.hash(x),
hy = _b_.hash(y);
return hx > hy ? 1 : hx == hy ? 0 : -1;
});
} catch (err) {
console.log("erreur", err.message);
}
for (var i = 0, len = self.$items.length; i < len; i++) {
var r = _b_.repr(self.$items[i]);
if (r === self || r === self.$items[i]) {
res.push("{...}");
} else {
res.push(r);
}
}
res = res.join(", ");
$B.repr.leave(self);
return head + res + tail;
}
set.__rsub__ = function (self, other) {
return set.__sub__(other, self);
};
set.__rxor__ = function (self, other) {
return set.__xor__(self, other);
};
set.__sub__ = function (self, other, accept_iter) {
try {
$test(accept_iter, other, "-");
} catch (err) {
return _b_.NotImplemented;
}
var res = create_type(self),
cfunc = _b_.getattr(other, "__contains__"),
items = [];
for (var i = 0, len = self.$items.length; i < len; i++) {
if (!cfunc(self.$items[i])) {
items.push(self.$items[i]);
}
}
set.__init__.call(null, res, items);
return res;
};
set.__xor__ = function (self, other, accept_iter) {
try {
$test(accept_iter, other, "^");
} catch (err) {
return _b_.NotImplemented;
}
var res = create_type(self),
cfunc = _b_.getattr(other, "__contains__");
for (var i = 0, len = self.$items.length; i < len; i++) {
if (!cfunc(self.$items[i])) {
set.add(res, self.$items[i]);
}
}
for (var i = 0, len = other.$items.length; i < len; i++) {
if (!set.__contains__(self, other.$items[i])) {
set.add(res, other.$items[i]);
}
}
return res;
};
function $test(accept_iter, other, op) {
if (accept_iter === undefined && !_b_.isinstance(other, [set, frozenset])) {
throw _b_.TypeError.$factory(
"unsupported operand type(s) for " +
op +
": 'set' and '" +
$B.class_name(other) +
"'"
);
}
}
$B.make_rmethods(set);
function $add(self, item) {
var $simple = false;
if (
typeof item === "string" ||
typeof item === "number" ||
item instanceof Number
) {
$simple = true;
}
if ($simple) {
var ix = self.$items.indexOf(item);
if (ix == -1) {
if (
item instanceof Number &&
self.$numbers.indexOf(item.valueOf()) > -1
) {
} else if (
typeof item == "number" &&
self.$numbers.indexOf(item) > -1
) {
} else {
self.$items.push(item);
var value = item.valueOf();
if (typeof value == "number") {
self.$numbers.push(value);
}
}
} else {
if (item !== self.$items[ix]) {
self.$items.push(item);
}
}
} else {
var hashvalue = _b_.hash(item);
var items = self.$hashes[hashvalue];
if (items === undefined) {
self.$hashes[hashvalue] = [item];
self.$items.push(item);
} else {
var items = self.$hashes[hashvalue],
cfunc = function (other) {
return $B.rich_comp("__eq__", item, other);
};
for (var i = 0, len = items.length; i < len; i++) {
if (cfunc(items[i])) {
return $N;
}
}
self.$hashes[hashvalue].push(item);
self.$items.push(item);
}
}
return $N;
}
set.add = function () {
var $ = $B.args(
"add",
2,
{ self: null, item: null },
["self", "item"],
arguments,
{},
null,
null
),
self = $.self,
item = $.item;
return $add(self, item);
};
set.clear = function () {
var $ = $B.args(
"clear",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
$.self.$items = [];
$.self.$numbers = [];
$.self.$hashes = {};
return $N;
};
set.copy = function () {
var $ = $B.args(
"copy",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
if (_b_.isinstance($.self, frozenset)) {
return $.self;
}
var res = set.$factory();
$.self.$items.forEach(function (item) {
res.$items.push(item);
});
$.self.$numbers.forEach(function (item) {
res.$numbers.push(item);
});
for (key in self.$hashes) {
res.$hashes[key] = self.$hashes[key];
}
return res;
};
set.difference_update = function (self) {
var $ = $B.args(
"difference_update",
1,
{ self: null },
["self"],
arguments,
{},
"args",
null
);
for (var i = 0; i < $.args.length; i++) {
var s = set.$factory($.args[i]),
_next = _b_.getattr($B.$iter(s), "__next__"),
item;
while (true) {
try {
item = _next();
var _type = typeof item;
if (_type == "string" || _type == "number") {
var _index = self.$items.indexOf(item);
if (_index > -1) {
self.$items.splice(_index, 1);
}
} else {
for (var j = 0; j < self.$items.length; j++) {
if ($B.rich_comp("__eq__", self.$items[j], item)) {
self.$items.splice(j, 1);
var hash = _b_.hash(item);
if (self.$hashes[hash]) {
for (var k = 0; k < self.$hashes[hash].length; k++) {
if ($B.rich_comp("__eq__", self.$hashes[hash][k], item)) {
self.$hashes[hash].splice(k, 1);
break;
}
}
}
}
}
}
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
}
return $N;
};
set.discard = function () {
var $ = $B.args(
"discard",
2,
{ self: null, item: null },
["self", "item"],
arguments,
{},
null,
null
);
try {
set.remove($.self, $.item);
} catch (err) {
if (!_b_.isinstance(err, [_b_.KeyError, _b_.LookupError])) {
throw err;
}
}
return $N;
};
set.intersection_update = function () {
var $ = $B.args(
"intersection_update",
1,
{ self: null },
["self"],
arguments,
{},
"args",
null
),
self = $.self;
for (var i = 0; i < $.args.length; i++) {
var remove = [],
s = set.$factory($.args[i]);
for (var j = 0; j < self.$items.length; j++) {
var _item = self.$items[j],
_type = typeof _item;
if (_type == "string" || _type == "number") {
if (s.$items.indexOf(_item) == -1) {
remove.push(j);
}
} else {
var found = false,
hash = _b_.hash(_item);
if (s.$hashes[hash]) {
var hashes = s.$hashes[hash];
for (var k = 0; !found && k < hashes.length; k++) {
if ($B.rich_comp("__eq__", hashes[k], _item)) {
found = true;
}
}
if (!found) {
remove.push(j);
hashes = self.$hashes[hash];
for (var k = 0; !found && k < hashes.length; k++) {
if ($B.rich_comp("__eq__", hashes[k], _item)) {
self.$hashes.splice(k, 1);
}
}
}
}
}
}
remove
.sort(function (x, y) {
return x - y;
})
.reverse();
for (var j = 0; j < remove.length; j++) {
self.$items.splice(remove[j], 1);
}
}
return $N;
};
set.isdisjoint = function () {
var $ = $B.args(
"is_disjoint",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
);
for (var i = 0, len = $.self.$items.length; i < len; i++) {
if (_b_.getattr($.other, "__contains__")($.self.$items[i])) {
return false;
}
}
return true;
};
set.pop = function (self) {
if (self.$items.length === 0) {
throw _b_.KeyError.$factory("pop from an empty set");
}
var item = self.$items.pop();
if (typeof item != "string" && typeof item != "number") {
var hash = _b_.hash(item),
items = self.$hashes[hash];
for (var k = 0; k < items.length; k++) {
if ($B.rich_comp("__eq__", items[k], item)) {
self.$hashes[hash].splice(k, 1);
break;
}
}
}
return item;
};
set.remove = function (self, item) {
var $ = $B.args(
"remove",
2,
{ self: null, item: null },
["self", "item"],
arguments,
{},
null,
null
),
self = $.self,
item = $.item;
if (!_b_.isinstance(item, set)) {
_b_.hash(item);
}
if (typeof item == "string" || typeof item == "number") {
var _i = self.$items.indexOf(item);
if (_i == -1) {
throw _b_.KeyError.$factory(item);
}
self.$items.splice(_i, 1);
if (typeof item == "number") {
self.$numbers.splice(self.$numbers.indexOf(item), 1);
}
return $N;
}
var hash = _b_.hash(item);
if (self.$hashes[hash]) {
for (var i = 0, len = self.$items.length; i < len; i++) {
if ($B.rich_comp("__eq__", self.$items[i], item)) {
self.$items.splice(i, 1);
if (item instanceof Number) {
self.$numbers.splice(self.$numbers.indexOf(item.valueOf()), 1);
}
break;
}
}
for (var i = 0, len = self.$hashes[hash].length; i < len; i++) {
if ($B.rich_comp("__eq__", self.$hashes[hash][i], item)) {
self.$hashes[hash].splice(i, 1);
break;
}
}
return $N;
}
throw _b_.KeyError.$factory(item);
};
set.symmetric_difference_update = function (self, s) {
var $ = $B.args(
"symmetric_difference_update",
2,
{ self: null, s: null },
["self", "s"],
arguments,
{},
null,
null
),
self = $.self,
s = $.s;
var _next = _b_.getattr($B.$iter(s), "__next__"),
item,
remove = [],
add = [];
while (true) {
try {
item = _next();
var _type = typeof item;
if (_type == "string" || _type == "number") {
var _index = self.$items.indexOf(item);
if (_index > -1) {
remove.push(_index);
} else {
add.push(item);
}
} else {
var found = false;
for (var j = 0; !found && j < self.$items.length; j++) {
if ($B.rich_comp("__eq__", self.$items[j], item)) {
remove.push(j);
found = true;
}
}
if (!found) {
add.push(item);
}
}
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
remove
.sort(function (x, y) {
return x - y;
})
.reverse();
for (var i = 0; i < remove.length; i++) {
if (remove[i] != remove[i - 1]) {
self.$items.splice(remove[i], 1);
}
}
for (var i = 0; i < add.length; i++) {
set.add(self, add[i]);
}
return $N;
};
set.update = function (self) {
var $ = $B.args(
"update",
1,
{ self: null },
["self"],
arguments,
{},
"args",
null
);
for (var i = 0; i < $.args.length; i++) {
var other = set.$factory($.args[i]);
for (var j = 0, _len = other.$items.length; j < _len; j++) {
$add(self, other.$items[j]);
}
}
return $N;
};
set.difference = function () {
var $ = $B.args(
"difference",
1,
{ self: null },
["self"],
arguments,
{},
"args",
null
);
if ($.args.length == 0) {
return set.copy($.self);
}
var res = clone($.self);
for (var i = 0; i < $.args.length; i++) {
res = set.__sub__(res, set.$factory($.args[i]), true);
}
return res;
};
var fc = set.difference + "";
eval(
"set.intersection = " +
fc.replace(/difference/g, "intersection").replace("__sub__", "__and__")
);
eval(
"set.symmetric_difference = " +
fc
.replace(/difference/g, "symmetric_difference")
.replace("__sub__", "__xor__")
);
eval(
"set.union = " +
fc.replace(/difference/g, "union").replace("__sub__", "__or__")
);
set.issubset = function () {
var $ = $B.args(
"issubset",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
"args",
null
),
func = _b_.getattr($.other, "__contains__");
for (var i = 0, len = $.self.$items.length; i < len; i++) {
if (!func($.self.$items[i])) {
return false;
}
}
return true;
};
set.issuperset = function () {
var $ = $B.args(
"issuperset",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
"args",
null
);
var func = _b_.getattr($.self, "__contains__"),
it = $B.$iter($.other);
while (true) {
try {
var item = _b_.next(it);
if (!func(item)) {
return false;
}
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
return true;
}
throw err;
}
}
return true;
};
function $accept_only_set(f, op) {
return function (self, other, accept_iter) {
$test(accept_iter, other, op);
f(self, other);
return self;
};
}
set.__iand__ = $accept_only_set(set.intersection_update, "&=");
set.__isub__ = $accept_only_set(set.difference_update, "-=");
set.__ixor__ = $accept_only_set(set.symmetric_difference_update, "^=");
set.__ior__ = $accept_only_set(set.update, "|=");
set.$factory = function () {
var res = {
__class__: set,
$simple: true,
$items: [],
$numbers: [],
$hashes: {},
};
var args = [res].concat(Array.prototype.slice.call(arguments));
set.__init__.apply(null, args);
return res;
};
$B.set_func_names(set, "builtins");
set.__class_getitem__ = _b_.classmethod.$factory(set.__class_getitem__);
var frozenset = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "builtins", __name__: "frozenset" },
$is_class: true,
$native: true,
};
for (var attr in set) {
switch (attr) {
case "add":
case "clear":
case "discard":
case "pop":
case "remove":
case "update":
break;
default:
if (frozenset[attr] == undefined) {
if (typeof set[attr] == "function") {
frozenset[attr] = (function (x) {
return function () {
return set[x].apply(null, arguments);
};
})(attr);
} else {
frozenset[attr] = set[attr];
}
}
}
}
frozenset.__hash__ = function (self) {
if (self === undefined) {
return frozenset.__hashvalue__ || $B.$py_next_hash--;
}
if (self.__hashvalue__ !== undefined) {
return self.__hashvalue__;
}
var _hash = 1927868237;
_hash *= self.$items.length;
for (var i = 0, len = self.$items.length; i < len; i++) {
var _h = _b_.hash(self.$items[i]);
_hash ^= (_h ^ 89869747 ^ (_h << 16)) * 3644798167;
}
_hash = _hash * 69069 + 907133923;
if (_hash == -1) {
_hash = 590923713;
}
return (self.__hashvalue__ = _hash);
};
frozenset.__new__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory("frozenset.__new__(): not enough arguments");
}
return {
__class__: cls,
$simple: true,
$items: [],
$numbers: [],
$hashes: {},
};
};
frozenset.__repr__ = function (self) {
$B.builtins_repr_check(frozenset, arguments);
return set_repr(self);
};
var singleton_id = Math.floor(Math.random() * Math.pow(2, 40));
function empty_frozenset() {
var res = frozenset.__new__(frozenset);
res.$id = singleton_id;
return res;
}
frozenset.$factory = function () {
var $ = $B.args(
"frozenset",
1,
{ iterable: null },
["iterable"],
arguments,
{ iterable: null },
null,
null
);
if ($.iterable === null) {
return empty_frozenset();
} else if ($.iterable.__class__ == frozenset) {
return $.iterable;
}
var res = set.$factory($.iterable);
if (res.$items.length == 0) {
return empty_frozenset();
}
res.__class__ = frozenset;
return res;
};
$B.set_func_names(frozenset, "builtins");
_b_.set = set;
_b_.frozenset = frozenset;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var object = _b_.object;
var _window = self;
function to_simple(value) {
switch (typeof value) {
case "string":
case "number":
return value;
case "boolean":
return value ? "true" : "false";
case "object":
if (value === _b_.None) {
return "null";
} else if (value instanceof Number) {
return value.valueOf();
} else if (value instanceof String) {
return value.valueOf();
}
default:
console.log("erreur", value);
throw _b_.TypeError.$factory(
"keys must be str, int, " +
"float, bool or None, not " +
$B.class_name(value)
);
}
}
$B.pyobj2structuredclone = function (obj, strict) {
strict = strict === undefined ? true : strict;
if (
typeof obj == "boolean" ||
typeof obj == "number" ||
typeof obj == "string" ||
obj instanceof String
) {
return obj;
} else if (obj instanceof Number) {
return obj.valueOf();
} else if (obj === _b_.None) {
return null;
} else if (
Array.isArray(obj) ||
obj.__class__ === _b_.list ||
obj.__class__ === _b_.tuple
) {
var res = [];
for (var i = 0, len = obj.length; i < len; i++) {
res.push($B.pyobj2structuredclone(obj[i]));
}
return res;
} else if (_b_.isinstance(obj, _b_.dict)) {
if (strict) {
if (
Object.keys(obj.$numeric_dict).length > 0 ||
Object.keys(obj.$object_dict).length > 0
) {
throw _b_.TypeError.$factory(
"a dictionary with non-string " +
"keys does not support structured clone"
);
}
}
var items = $B.dict_to_list(obj),
res = {};
for (var i = 0, len = items.length; i < len; i++) {
res[to_simple(items[i][0])] = $B.pyobj2structuredclone(items[i][1]);
}
return res;
} else {
return obj;
}
};
$B.structuredclone2pyobj = function (obj) {
if (obj === null) {
return _b_.None;
} else if (obj === undefined) {
return $B.Undefined;
} else if (
typeof obj == "boolean" ||
typeof obj == "number" ||
typeof obj == "string"
) {
return obj;
} else if (obj instanceof Number || obj instanceof String) {
return obj.valueOf();
} else if (
Array.isArray(obj) ||
obj.__class__ === _b_.list ||
obj.__class__ === _b_.tuple
) {
var res = _b_.list.$factory();
for (var i = 0, len = obj.length; i < len; i++) {
res.push($B.structuredclone2pyobj(obj[i]));
}
return res;
} else if (typeof obj == "object") {
var res = $B.empty_dict();
for (var key in obj) {
_b_.dict.$setitem(res, key, $B.structuredclone2pyobj(obj[key]));
}
return res;
} else {
console.log(
obj,
Array.isArray(obj),
obj.__class__,
_b_.list,
obj.__class__ === _b_.list
);
throw _b_.TypeError.$factory(
_b_.str.$factory(obj) +
" does not support the structured clone algorithm"
);
}
};
var JSConstructor = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "<javascript>", __name__: "JSConstructor" },
$is_class: true,
};
JSConstructor.__call__ = function (self) {
return function () {
var args = [null];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(pyobj2jsobj(arguments[i]));
}
var factory = self.func.bind.apply(self.func, args);
var res = new factory();
return $B.$JS2Py(res);
};
};
JSConstructor.__getattribute__ = function (self, attr) {
if (attr == "__call__") {
return function () {
var args = [null];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(pyobj2jsobj(arguments[i]));
}
var factory = self.func.bind.apply(self.func, args);
var res = new factory();
return $B.$JS2Py(res);
};
}
return JSObject.__getattribute__(self, attr);
};
JSConstructor.$factory = function (obj) {
return {
__class__: JSConstructor,
js: obj,
func: obj.js_func,
};
};
var jsobj2pyobj = ($B.jsobj2pyobj = function (jsobj) {
switch (jsobj) {
case true:
case false:
return jsobj;
}
if (jsobj === undefined) {
return $B.Undefined;
} else if (jsobj === null) {
return _b_.None;
}
if (Array.isArray(jsobj)) {
return _b_.list.$factory(jsobj.map(jsobj2pyobj));
} else if (typeof jsobj === "number") {
if (jsobj.toString().indexOf(".") == -1) {
return _b_.int.$factory(jsobj);
}
return _b_.float.$factory(jsobj);
} else if (typeof jsobj == "string") {
return $B.String(jsobj);
} else if (typeof jsobj == "function") {
return function () {
var args = [];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(pyobj2jsobj(arguments[i]));
}
return jsobj2pyobj(jsobj.apply(null, args));
};
}
if (jsobj.$nat === "kw") {
return jsobj;
}
if ($B.$isNode(jsobj)) {
return $B.DOMNode.$factory(jsobj);
}
return $B.JSObj.$factory(jsobj);
});
var pyobj2jsobj = ($B.pyobj2jsobj = function (pyobj) {
if (pyobj === true || pyobj === false) {
return pyobj;
}
if (pyobj === _b_.None) {
return null;
}
if (pyobj === $B.Undefined) {
return undefined;
}
var klass = $B.get_class(pyobj);
if (klass === undefined) {
return pyobj;
}
if (klass === JSConstructor) {
if (pyobj.js_func !== undefined) {
return pyobj.js_func;
}
return pyobj.js;
} else if (klass === $B.DOMNode || klass.__mro__.indexOf($B.DOMNode) > -1) {
return pyobj;
} else if ([_b_.list, _b_.tuple].indexOf(klass) > -1) {
var res = [];
pyobj.forEach(function (item) {
res.push(pyobj2jsobj(item));
});
return res;
} else if (klass === _b_.dict || _b_.issubclass(klass, _b_.dict)) {
var jsobj = {};
var items = _b_.list.$factory(_b_.dict.items(pyobj));
items.forEach(function (item) {
if (typeof item[1] == "function") {
item[1].bind(jsobj);
}
jsobj[item[0]] = pyobj2jsobj(item[1]);
});
return jsobj;
} else if (klass === _b_.float || klass === _b_.str) {
return pyobj.valueOf();
} else if (klass === $B.Function || klass === $B.method) {
if (
pyobj.prototype &&
pyobj.prototype.constructor === pyobj &&
!pyobj.$is_func
) {
return pyobj;
}
return function () {
try {
var args = [];
for (var i = 0; i < arguments.length; i++) {
if (arguments[i] === undefined) {
args.push(_b_.None);
} else {
args.push(jsobj2pyobj(arguments[i]));
}
}
if (pyobj.prototype.constructor === pyobj && !pyobj.$is_func) {
var res = new pyobj(...args);
} else {
var res = pyobj.apply(this, args);
}
return pyobj2jsobj(res);
} catch (err) {
console.log(err);
console.log($B.$getattr(err, "info"));
console.log(
$B.class_name(err) + ":",
err.args.length > 0 ? err.args[0] : ""
);
throw err;
}
};
} else {
return pyobj;
}
});
$B.JSConstructor = JSConstructor;
function pyargs2jsargs(pyargs) {
var args = [];
for (var i = 0, len = pyargs.length; i < len; i++) {
var arg = pyargs[i];
if (arg !== undefined && arg !== null && arg.$nat !== undefined) {
var kw = arg.kw;
if (Array.isArray(kw)) {
kw = $B.extend(js_attr.name, ...kw);
}
if (Object.keys(kw).length > 0) {
throw _b_.TypeError.$factory(
"A Javascript function can't take " + "keyword arguments"
);
}
} else {
args.push($B.pyobj2jsobj(arg));
}
}
return args;
}
$B.JSObj = $B.make_class("JSObj", function (jsobj) {
if (Array.isArray(jsobj)) {
} else if (typeof jsobj == "function") {
jsobj.$is_js_func = true;
jsobj.__new__ = function () {
return new jsobj.$js_func(...arguments);
};
} else if (typeof jsobj == "number" && !Number.isInteger(jsobj)) {
return new Number(jsobj);
}
return jsobj;
});
$B.JSObj.__sub__ = function (self, other) {
if (typeof self == "bigint" && typeof other == "bigint") {
return self - other;
}
throw _b_.TypeError.$factory(
"unsupported operand type(s) for - : '" +
$B.class_name(self) +
"' and '" +
$B.class_name(other) +
"'"
);
};
var ops = { "+": "__add__", "*": "__mul__", "**": "__pow__", "%": "__mod__" };
for (var op in ops) {
eval(
"$B.JSObj." + ops[op] + " = " + ($B.JSObj.__sub__ + "").replace(/-/g, op)
);
}
$B.JSObj.__eq__ = function (self, other) {
switch (typeof self) {
case "object":
if (self.__eq__ !== undefined) {
return self.__eq__(other);
}
if (Object.keys(self).length !== Object.keys(other).length) {
return false;
}
if (self === other) {
return true;
}
for (var key in self) {
if (!$B.JSObj.__eq__(self[key], other[key])) {
return false;
}
}
default:
return self === other;
}
};
$B.JSObj.__ne__ = function (self, other) {
return !$B.JSObj.__eq__(self, other);
};
$B.JSObj.__getattribute__ = function (self, attr) {
var test = false;
if (test) {
console.log("__ga__", self, attr);
}
if (attr == "new" && typeof self == "function") {
if (self.$js_func) {
return function () {
var args = pyargs2jsargs(arguments);
return $B.JSObj.$factory(new self.$js_func(...args));
};
} else {
return function () {
var args = pyargs2jsargs(arguments);
return $B.JSObj.$factory(new self(...args));
};
}
}
var js_attr = self[attr];
if (js_attr == undefined && typeof self == "function" && self.$js_func) {
js_attr = self.$js_func[attr];
}
if (js_attr === undefined) {
if (typeof self.getNamedItem == "function") {
var res = self.getNamedItem(attr);
if (res !== undefined) {
return $B.JSObj.$factory(res);
}
}
var klass = $B.get_class(self);
if (klass && klass[attr]) {
var class_attr = klass[attr];
if (typeof class_attr == "function") {
return function () {
var args = [self];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(arguments[i]);
}
return $B.JSObj.$factory(class_attr.apply(null, args));
};
} else {
return class_attr;
}
}
if (attr == "bind" && typeof self.addEventListener == "function") {
return function (event, callback) {
return self.addEventListener(event, callback);
};
}
throw $B.attr_error(attr, self);
}
if (typeof js_attr === "function") {
var res = function () {
var args = pyargs2jsargs(arguments),
target = self.$js_func || self;
try {
var result = js_attr.apply(target, args);
} catch (err) {
console.log("error", err);
console.log(
"attribute",
attr,
"of self",
self,
js_attr,
args,
arguments
);
throw err;
}
if (result === undefined) {
return $B.Undefined;
} else if (result === null) {
return _b_.None;
}
return $B.JSObj.$factory(result);
};
res.prototype = js_attr.prototype;
res.$js_func = js_attr;
res.__mro__ = [_b_.object];
res.$infos = { __name__: js_attr.name, __qualname__: js_attr.name };
if ($B.frames_stack.length > 0) {
res.$infos.__module__ = $B.last($B.frames_stack)[3].__name__;
}
return $B.JSObj.$factory(res);
} else {
return $B.JSObj.$factory(js_attr);
}
};
$B.JSObj.__setattr__ = function (self, attr, value) {
self[attr] = $B.pyobj2structuredclone(value);
return _b_.None;
};
$B.JSObj.__getitem__ = function (self, key) {
if (typeof key == "string") {
return $B.JSObj.__getattribute__(self, key);
} else if (typeof key == "number") {
if (self[key] !== undefined) {
return $B.JSObj.$factory(self[key]);
}
if (typeof self.length == "number") {
if (
(typeof key == "number" || typeof key == "boolean") &&
typeof self.item == "function"
) {
var rank = _b_.int.$factory(key);
if (rank < 0) {
rank += self.length;
}
var res = self.item(rank);
if (res === null) {
throw _b_.IndexError.$factory(rank);
}
return $B.JSObj.$factory(res);
}
}
} else if (key.__class__ === _b_.slice && typeof self.item == "function") {
var _slice = _b_.slice.$conv_for_seq(key, self.length);
var res = [];
for (var i = _slice.start; i < _slice.stop; i += _slice.step) {
res.push(self.item(i));
}
return res;
}
throw _b_.KeyError.$factory(rank);
};
$B.JSObj.__setitem__ = $B.JSObj.__setattr__;
var JSObj_iterator = $B.make_iterator_class("JS object iterator");
$B.JSObj.__iter__ = function (self) {
var items = [];
if (_window.Symbol && self[Symbol.iterator] !== undefined) {
var items = [];
if (self.next !== undefined) {
while (true) {
var nxt = self.next();
if (nxt.done) {
break;
}
items.push($B.JSObj.$factory(nxt.value));
}
} else if (self.length !== undefined && self.item !== undefined) {
for (var i = 0; i < self.length; i++) {
items.push($B.JSObj.$factory(self.item(i)));
}
}
return JSObj_iterator.$factory(items);
} else if (self.length !== undefined && self.item !== undefined) {
for (var i = 0; i < self.length; i++) {
items.push($B.JSObj.$factory(self.js.item(i)));
}
return JSObj_iterator.$factory(items);
}
return JSObj_iterator.$factory(Object.keys(self));
};
$B.JSObj.__len__ = function (self) {
if (typeof self.length == "number") {
return self.length;
}
throw $B.attr_error("__len__", self);
};
$B.JSObj.__repr__ = $B.JSObj.__str__ = function (self) {
return (
"<Javascript " +
self.constructor.name +
" object: " +
self.toString() +
">"
);
};
$B.JSObj.bind = function (self, evt, func) {
var js_func = function (ev) {
return func(jsobj2pyobj(ev));
};
self.addEventListener(evt, js_func);
return _b_.None;
};
$B.JSObj.to_dict = function (self) {
return $B.structuredclone2pyobj(self);
};
$B.set_func_names($B.JSObj, "builtins");
$B.JSMeta = $B.make_class("JSMeta");
$B.JSMeta.__call__ = function (cls) {
var extra_args = [],
klass = arguments[0];
for (var i = 1, len = arguments.length; i < len; i++) {
extra_args.push(arguments[i]);
}
var new_func = _b_.type.__getattribute__(klass, "__new__");
var instance = new_func.apply(null, arguments);
if (instance instanceof cls.__mro__[0].$js_func) {
var init_func = _b_.type.__getattribute__(klass, "__init__");
if (init_func !== _b_.object.__init__) {
var args = [instance].concat(extra_args);
init_func.apply(null, args);
}
}
return instance;
};
$B.JSMeta.__mro__ = [_b_.type, _b_.object];
$B.JSMeta.__getattribute__ = function (cls, attr) {
if (cls[attr] !== undefined) {
return cls[attr];
} else if ($B.JSMeta[attr] !== undefined) {
return $B.JSMeta[attr];
} else {
return _b_.type.__getattribute__(cls, attr);
}
};
$B.JSMeta.__init_subclass__ = function () {};
$B.JSMeta.__new__ = function (metaclass, class_name, bases, cl_dict) {
eval(
"var " +
class_name +
` = function(){
if(cl_dict.$string_dict.__init__){
var args = [this]
for(var i = 0, len = arguments.length; i < len; i++){
args.push(arguments[i])
}
cl_dict.$string_dict.__init__[0].apply(this, args)
}else{
return new bases[0].$js_func(...arguments)
}
}`
);
var new_js_class = eval(class_name);
new_js_class.prototype = Object.create(bases[0].$js_func.prototype);
new_js_class.prototype.constructor = new_js_class;
new_js_class.__mro__ = [bases[0], _b_.type];
new_js_class.$is_js_class = true;
return new_js_class;
};
$B.set_func_names($B.JSMeta, "builtins");
})(__BRYTHON__);
__BRYTHON__.stdlib = {};
(function ($B) {
var _b_ = $B.builtins,
_window = self;
var Module = ($B.module = $B.make_class(
"module",
function (name, doc, $package) {
var obj = Object.create(null);
obj.__class__ = Module;
obj.__name__ = name;
obj.__doc__ = doc || _b_.None;
obj.__package__ = $package || _b_.None;
return obj;
}
));
Module.__new__ = function (cls, name, doc, $package) {
return {
__class__: cls,
__name__: name,
__doc__: doc || _b_.None,
__package__: $package || _b_.None,
};
};
Module.__repr__ = Module.__str__ = function (self) {
var res = "<module " + self.__name__;
if (self.__file__ === undefined) {
res += " (built-in)";
}
return res + ">";
};
Module.__setattr__ = function (self, attr, value) {
if (self.__name__ == "__builtins__") {
$B.builtins[attr] = value;
} else {
self[attr] = value;
}
};
$B.set_func_names(Module, "builtins");
function $download_module(mod, url, $package) {
var xhr = new XMLHttpRequest(),
fake_qs = "?v=" + new Date().getTime(),
res = null,
mod_name = mod.__name__;
var timer = _window.setTimeout(function () {
xhr.abort();
}, 5000);
if ($B.$options.cache) {
xhr.open("GET", url, false);
} else {
xhr.open("GET", url + fake_qs, false);
}
xhr.send();
if ($B.$CORS) {
if (xhr.status == 200 || xhr.status == 0) {
res = xhr.responseText;
} else {
res = _b_.ModuleNotFoundError.$factory(
"No module named '" + mod_name + "'"
);
}
} else {
if (xhr.readyState == 4) {
if (xhr.status == 200) {
res = xhr.responseText;
mod.$last_modified = xhr.getResponseHeader("Last-Modified");
} else {
console.info(
"Error " +
xhr.status +
" means that Python module " +
mod_name +
" was not found at url " +
url
);
res = _b_.ModuleNotFoundError.$factory(
"No module named '" + mod_name + "'"
);
}
}
}
_window.clearTimeout(timer);
if (res == null) {
throw _b_.ModuleNotFoundError.$factory(
"No module named '" + mod_name + "' (res is null)"
);
}
if (res.constructor === Error) {
throw res;
}
return res;
}
$B.$download_module = $download_module;
function import_js(mod, path) {
try {
var module_contents = $download_module(mod, path, undefined);
} catch (err) {
return null;
}
run_js(module_contents, path, mod);
return true;
}
function run_js(module_contents, path, _module) {
var module_id = "$locals_" + _module.__name__.replace(/\./g, "_");
try {
var $module = new Function(
module_id,
module_contents + ";\nreturn $module"
)(_module);
if ($B.$options.store) {
_module.$js = module_contents;
}
} catch (err) {
console.log(err);
console.log(path, _module);
throw err;
}
try {
$module;
} catch (err) {
console.log("no $module");
throw _b_.ImportError.$factory("name '$module' not defined in module");
}
$module.__name__ = _module.__name__;
for (var attr in $module) {
if (typeof $module[attr] == "function") {
$module[attr].$infos = {
__module__: _module.__name__,
__name__: attr,
__qualname__: attr,
};
$module[attr].$in_js_module = true;
}
}
if (_module !== undefined) {
for (var attr in $module) {
_module[attr] = $module[attr];
}
$module = _module;
$module.__class__ = Module;
} else {
$module.__class__ = Module;
$module.__name__ = _module.__name__;
$module.__repr__ = $module.__str__ = function () {
if ($B.builtin_module_names.indexOf(_module.name) > -1) {
return "<module '" + _module.__name__ + "' (built-in)>";
}
return "<module '" + _module.__name__ + "' from " + path + " >";
};
if (_module.name != "builtins") {
$module.__file__ = path;
}
}
$B.imported[_module.__name__] = $module;
return true;
}
function show_ns() {
var kk = Object.keys(_window);
for (var i = 0, len = kk.length; i < len; i++) {
console.log(kk[i]);
if (kk[i].charAt(0) == "$") {
console.log(eval(kk[i]));
}
}
console.log("---");
}
function run_py(module_contents, path, module, compiled) {
$B.file_cache[path] = module_contents;
var root,
js,
mod_name = module.__name__;
if (!compiled) {
var $Node = $B.$Node,
$NodeJSCtx = $B.$NodeJSCtx;
var src = {
src: module_contents,
has_annotations: false,
filename: path,
};
root = $B.py2js(src, module, module.__name__, $B.builtins_scope);
if (module.__package__ !== undefined) {
root.binding["__package__"] = true;
}
}
try {
js = compiled ? module_contents : root.to_js();
if ($B.$options.debug == 10) {
console.log("code for module " + module.__name__);
console.log(js);
}
var src = js;
js = "var $module = (function(){\n" + js;
var prefix = $B.js_from_ast ? "locals_" : "$locals_";
js += "return " + prefix;
js +=
module.__name__.replace(/\./g, "_") +
"})(__BRYTHON__)\n" +
"return $module";
var module_id = prefix + module.__name__.replace(/\./g, "_");
var $module = new Function(module_id, js)(module);
} catch (err) {
if ($B.debug > 1) {
console.log(err + " for module " + module.__name__);
console.log("module", module);
console.log(root);
if ($B.debug > 1) {
console.log(js);
}
for (var attr in err) {
console.log(attr, err[attr]);
}
console.log("info", $B.$getattr(err, "info", "[no info]"));
console.log("message: " + err.$message);
console.log("filename: " + err.fileName);
console.log("linenum: " + err.lineNumber);
}
if ($B.debug > 0) {
console.log("line info " + $B.line_info);
}
throw err;
} finally {
$B.clear_ns(module.__name__);
}
try {
var mod = eval("$module");
for (var attr in mod) {
module[attr] = mod[attr];
}
module.__initializing__ = false;
$B.imported[module.__name__] = module;
return {
content: src,
name: mod_name,
imports: Object.keys(root.imports).join(","),
};
} catch (err) {
console.log("" + err + " " + " for module " + module.__name__);
for (var attr in err) {
console.log(attr + " " + err[attr]);
}
if ($B.debug > 0) {
console.log("line info " + __BRYTHON__.line_info);
}
throw err;
}
}
$B.run_py = run_py;
$B.run_js = run_js;
var ModuleSpec = $B.make_class("ModuleSpec", function (fields) {
fields.__class__ = ModuleSpec;
return fields;
});
ModuleSpec.__str__ = ModuleSpec.__repr__ = function (self) {
var res =
`ModuleSpec(name='${self.name}', ` +
`loader=${_b_.str.$factory(self.loader)}, ` +
`origin='${self.origin}'`;
if (self.submodule_search_locations !== _b_.None) {
res +=
`, submodule_search_locations=` +
`${_b_.str.$factory(self.submodule_search_locations)}`;
}
return res + ")";
};
$B.set_func_names(ModuleSpec, "builtins");
function parent_package(mod_name) {
var parts = mod_name.split(".");
parts.pop();
return parts.join(".");
}
var VFSFinder = $B.make_class("VFSFinder", function () {
return {
__class__: VFSFinder,
};
});
VFSFinder.find_spec = function (cls, fullname, path) {
var stored, is_package, timestamp;
if (!$B.use_VFS) {
return _b_.None;
}
stored = $B.VFS[fullname];
if (stored === undefined) {
return _b_.None;
}
is_package = stored[3] || false;
timestamp = stored.timestamp;
if (stored) {
var is_builtin = $B.builtin_module_names.indexOf(fullname) > -1;
return ModuleSpec.$factory({
name: fullname,
loader: VFSLoader.$factory(),
origin: is_builtin ? "built-in" : "brython_stdlib",
submodule_search_locations: is_package ? [] : _b_.None,
loader_state: { stored: stored, timestamp: timestamp },
cached: _b_.None,
parent: is_package ? fullname : parent_package(fullname),
has_location: _b_.False,
});
}
};
$B.set_func_names(VFSFinder, "<import>");
for (var method in VFSFinder) {
if (typeof VFSFinder[method] == "function") {
VFSFinder[method] = _b_.classmethod.$factory(VFSFinder[method]);
}
}
VFSLoader = $B.make_class("VFSLoader", function () {
return {
__class__: VFSLoader,
};
});
VFSLoader.create_module = function (self, spec) {
return _b_.None;
};
VFSLoader.exec_module = function (self, modobj) {
var stored = modobj.__spec__.loader_state.stored,
timestamp = modobj.__spec__.loader_state.timestamp;
delete modobj.__spec__["loader_state"];
var ext = stored[0],
module_contents = stored[1],
imports = stored[2];
modobj.$is_package = stored[3] || false;
var path = "VFS." + modobj.__name__;
path += modobj.$is_package ? "/__init__.py" : ext;
modobj.__file__ = path;
$B.file_cache[modobj.__file__] = $B.VFS[modobj.__name__][1];
if (ext == ".js") {
run_js(module_contents, modobj.__path__, modobj);
} else if ($B.precompiled.hasOwnProperty(modobj.__name__)) {
if ($B.debug > 1) {
console.info("load", modobj.__name__, "from precompiled");
}
var parts = modobj.__name__.split(".");
for (var i = 0; i < parts.length; i++) {
var parent = parts.slice(0, i + 1).join(".");
if (
$B.imported.hasOwnProperty(parent) &&
$B.imported[parent].__initialized__
) {
continue;
}
var mod_js = $B.precompiled[parent],
is_package = modobj.$is_package;
if (mod_js === undefined) {
continue;
}
if (Array.isArray(mod_js)) {
mod_js = mod_js[0];
}
var mod = ($B.imported[parent] = Module.$factory(
parent,
undefined,
is_package
));
mod.__initialized__ = true;
if (is_package) {
mod.__path__ = "<stdlib>";
mod.__package__ = parent;
} else {
var elts = parent.split(".");
elts.pop();
mod.__package__ = elts.join(".");
}
mod.__file__ = path;
try {
var parent_id = parent.replace(/\./g, "_"),
prefix = $B.js_from_ast ? "locals_" : "$locals_";
mod_js += "return " + prefix + parent_id;
var $module = new Function(prefix + parent_id, mod_js)(mod);
} catch (err) {
if ($B.debug > 1) {
console.log("error in module", mod);
console.log(err);
for (var k in err) {
console.log(k, err[k]);
}
console.log(Object.keys($B.imported));
if ($B.debug > 2) {
console.log(modobj, "mod_js", mod_js);
}
}
throw err;
}
for (var attr in $module) {
mod[attr] = $module[attr];
}
$module.__file__ = path;
if (i > 0) {
$B.builtins.setattr(
$B.imported[parts.slice(0, i).join(".")],
parts[i],
$module
);
}
}
return $module;
} else {
var mod_name = modobj.__name__;
if ($B.debug > 1) {
console.log("run Python code from VFS", mod_name);
}
var record = run_py(module_contents, modobj.__path__, modobj);
record.imports = imports.join(",");
record.is_package = modobj.$is_package;
record.timestamp = $B.timestamp;
record.source_ts = timestamp;
$B.precompiled[mod_name] = record.is_package
? [record.content]
: record.content;
var elts = mod_name.split(".");
if (elts.length > 1) {
elts.pop();
}
if ($B.$options.indexedDB && $B.indexedDB && $B.idb_name) {
var idb_cx = indexedDB.open($B.idb_name);
idb_cx.onsuccess = function (evt) {
var db = evt.target.result,
tx = db.transaction("modules", "readwrite"),
store = tx.objectStore("modules"),
cursor = store.openCursor(),
request = store.put(record);
request.onsuccess = function () {
if ($B.debug > 1) {
console.info(modobj.__name__, "stored in db");
}
};
request.onerror = function () {
console.info("could not store " + modobj.__name__);
};
};
}
}
};
$B.set_func_names(VFSLoader, "builtins");
var finder_cpython = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "CPythonFinder" },
create_module: function (cls, spec) {
return _b_.None;
},
exec_module: function (cls, modobj) {
console.log("exec PYthon module", modobj);
var loader_state = modobj.__spec__.loader_state;
var content = loader_state.content;
delete modobj.__spec__["loader_state"];
modobj.$is_package = loader_state.is_package;
modobj.__file__ = loader_state.__file__;
$B.file_cache[modobj.__file__] = content;
var mod_name = modobj.__name__;
if ($B.debug > 1) {
console.log("run Python code from CPython", mod_name);
}
run_py(content, modobj.__path__, modobj);
},
find_module: function (cls, name, path) {
return {
__class__: Loader,
load_module: function (name, path) {
var spec = cls.find_spec(cls, name, path);
var mod = Module.$factory(name);
$B.imported[name] = mod;
mod.__spec__ = spec;
cls.exec_module(cls, mod);
},
};
},
find_spec: function (cls, fullname, path) {
console.log("finder cpython", fullname);
var xhr = new XMLHttpRequest(),
url = "/cpython_import?module=" + fullname,
result;
xhr.open("GET", url, false);
xhr.onreadystatechange = function () {
if (this.readyState == 4 && this.status == 200) {
var data = JSON.parse(this.responseText);
result = ModuleSpec.$factory({
name: fullname,
loader: cls,
origin: "CPython",
submodule_search_locations: data.is_package ? [] : _b_.None,
loader_state: { content: data.content },
cached: _b_.None,
parent: data.is_package ? fullname : parent_package(fullname),
has_location: _b_.False,
});
}
};
xhr.send();
return result;
},
};
$B.set_func_names(finder_cpython, "<import>");
for (var method in finder_cpython) {
if (typeof finder_cpython[method] == "function") {
finder_cpython[method] = _b_.classmethod.$factory(finder_cpython[method]);
}
}
finder_cpython.$factory = function () {
return { __class__: finder_cpython };
};
var StdlibStaticFinder = $B.make_class("StdlibStaticFinder", function () {
return {
__class__: StdlibStaticFinder,
};
});
StdlibStaticFinder.find_spec = function (self, fullname, path) {
if ($B.stdlib && $B.$options.static_stdlib_import) {
var address = $B.stdlib[fullname];
if (address === undefined) {
var elts = fullname.split(".");
if (elts.length > 1) {
elts.pop();
var $package = $B.stdlib[elts.join(".")];
if ($package && $package[1]) {
address = ["py"];
}
}
}
if (address !== undefined) {
var ext = address[0],
is_pkg = address[1] !== undefined,
path =
$B.brython_path +
(ext == "py" ? "Lib/" : "libs/") +
fullname.replace(/\./g, "/"),
metadata = {
ext: ext,
is_package: is_pkg,
path:
path + (is_pkg ? "/__init__.py" : ext == "py" ? ".py" : ".js"),
address: address,
},
_module = Module.$factory(fullname);
metadata.code = $download_module(_module, metadata.path);
var res = ModuleSpec.$factory({
name: fullname,
loader: PathLoader.$factory(),
origin: metadata.path,
submodule_search_locations: is_pkg ? [path] : _b_.None,
loader_state: metadata,
cached: _b_.None,
parent: is_pkg ? fullname : parent_package(fullname),
has_location: _b_.True,
});
return res;
}
}
return _b_.None;
};
$B.set_func_names(StdlibStaticFinder, "<import>");
for (var method in StdlibStaticFinder) {
if (typeof StdlibStaticFinder[method] == "function") {
StdlibStaticFinder[method] = _b_.classmethod.$factory(
StdlibStaticFinder[method]
);
}
}
StdlibStaticFinder.$factory = function () {
return { __class__: StdlibStaticFinder };
};
var PathFinder = $B.make_class("PathFinder", function () {
return {
__class__: PathFinder,
};
});
PathFinder.find_spec = function (cls, fullname, path) {
if ($B.VFS && $B.VFS[fullname]) {
return _b_.None;
}
if ($B.is_none(path)) {
path = $B.path;
}
for (var i = 0, li = path.length; i < li; ++i) {
var path_entry = path[i];
if (path_entry[path_entry.length - 1] != "/") {
path_entry += "/";
}
var finder = $B.path_importer_cache[path_entry];
if (finder === undefined) {
for (var j = 0, lj = $B.path_hooks.length; j < lj; ++j) {
var hook = $B.path_hooks[j];
try {
finder = $B.$call(hook)(path_entry);
$B.path_importer_cache[path_entry] = finder;
break;
} catch (e) {
if (e.__class__ !== _b_.ImportError) {
throw e;
}
}
}
}
if ($B.is_none(finder)) {
continue;
}
var find_spec = $B.$getattr(finder, "find_spec"),
spec = $B.$call(find_spec)(fullname);
if (!$B.is_none(spec)) {
return spec;
}
}
return _b_.None;
};
$B.set_func_names(PathFinder, "<import>");
for (var method in PathFinder) {
if (typeof PathFinder[method] == "function") {
PathFinder[method] = _b_.classmethod.$factory(PathFinder[method]);
}
}
var PathEntryFinder = $B.make_class(
"PathEntryFinder",
function (path_entry, hint) {
return {
__class__: PathEntryFinder,
path_entry: path_entry,
hint: hint,
};
}
);
PathEntryFinder.find_spec = function (self, fullname) {
var loader_data = {},
notfound = true,
hint = self.hint,
base_path = self.path_entry + fullname.match(/[^.]+$/g)[0],
modpaths = [],
py_ext = $B.$options.python_extension;
var tryall = hint === undefined;
if (tryall || hint == "py") {
modpaths = modpaths.concat([
[base_path + py_ext, "py", false],
[base_path + "/__init__" + py_ext, "py", true],
]);
}
for (var j = 0; notfound && j < modpaths.length; ++j) {
try {
var file_info = modpaths[j],
module = { __name__: fullname, $is_package: false };
loader_data.code = $download_module(module, file_info[0], undefined);
notfound = false;
loader_data.ext = file_info[1];
loader_data.is_package = file_info[2];
if (hint === undefined) {
self.hint = file_info[1];
$B.path_importer_cache[self.path_entry] = self;
}
if (loader_data.is_package) {
$B.path_importer_cache[base_path + "/"] = $B.$call(url_hook)(
base_path + "/",
self.hint
);
}
loader_data.path = file_info[0];
} catch (err) {
if (err.__class__ !== _b_.ModuleNotFoundError) {
throw err;
}
}
}
if (!notfound) {
return ModuleSpec.$factory({
name: fullname,
loader: PathLoader.$factory(),
origin: loader_data.path,
submodule_search_locations: loader_data.is_package
? [base_path]
: _b_.None,
loader_state: loader_data,
cached: _b_.None,
parent: loader_data.is_package ? fullname : parent_package(fullname),
has_location: _b_.True,
});
}
return _b_.None;
};
$B.set_func_names(PathEntryFinder, "builtins");
var PathLoader = $B.make_class("PathLoader", function () {
return {
__class__: PathLoader,
};
});
PathLoader.create_module = function (self, spec) {
return _b_.None;
};
PathLoader.exec_module = function (self, module) {
var metadata = module.__spec__.loader_state;
module.$is_package = metadata.is_package;
if (metadata.ext == "py") {
run_py(metadata.code, metadata.path, module);
} else {
run_js(metadata.code, metadata.path, module);
}
};
var url_hook = ($B.url_hook = function (path_entry) {
path_entry = path_entry.endsWith("/") ? path_entry : path_entry + "/";
return PathEntryFinder.$factory(path_entry);
});
function import_engine(mod_name, _path, from_stdlib) {
var meta_path = $B.meta_path.slice(),
_sys_modules = $B.imported,
_loader,
spec;
if (from_stdlib) {
var path_ix = meta_path.indexOf($B.finders["path"]);
if (path_ix > -1) {
meta_path.splice(path_ix, 1);
}
}
for (var i = 0, len = meta_path.length; i < len; i++) {
var _finder = meta_path[i],
find_spec = $B.$getattr(_finder, "find_spec", _b_.None);
if (find_spec == _b_.None) {
var find_module = $B.$getattr(_finder, "find_module", _b_.None);
if (find_module !== _b_.None) {
_loader = find_module(mod_name, _path);
if (_loader !== _b_.None) {
var load_module = $B.$getattr(_loader, "load_module"),
module = $B.$call(load_module)(mod_name);
_sys_modules[mod_name] = module;
return module;
}
}
} else {
spec = find_spec(mod_name, _path);
if (!$B.is_none(spec)) {
module = $B.imported[spec.name];
if (module !== undefined) {
return (_sys_modules[spec.name] = module);
}
_loader = $B.$getattr(spec, "loader", _b_.None);
break;
}
}
}
if (_loader === undefined) {
message = mod_name;
if ($B.protocol == "file") {
message += " (warning: cannot import local files with protocol 'file')";
}
var exc = _b_.ModuleNotFoundError.$factory(message);
exc.name = mod_name;
throw exc;
}
if ($B.is_none(module)) {
if (spec === _b_.None) {
throw _b_.ModuleNotFoundError.$factory(mod_name);
}
var _spec_name = $B.$getattr(spec, "name");
if (!$B.is_none(_loader)) {
var create_module = $B.$getattr(_loader, "create_module", _b_.None);
if (!$B.is_none(create_module)) {
module = $B.$call(create_module)(spec);
}
}
if (module === undefined) {
throw _b_.ImportError.$factory(mod_name);
}
if ($B.is_none(module)) {
module = $B.module.$factory(mod_name);
var mod_desc = $B.$getattr(spec, "origin");
if ($B.$getattr(spec, "has_location")) {
mod_desc = "from '" + mod_desc + "'";
} else {
mod_desc = "(" + mod_desc + ")";
}
}
}
module.__name__ = _spec_name;
module.__loader__ = _loader;
module.__package__ = $B.$getattr(spec, "parent", "");
module.__spec__ = spec;
var locs = $B.$getattr(spec, "submodule_search_locations");
if ((module.$is_package = !$B.is_none(locs))) {
module.__path__ = locs;
}
if ($B.$getattr(spec, "has_location")) {
module.__file__ = $B.$getattr(spec, "origin");
}
var cached = $B.$getattr(spec, "cached");
if (!$B.is_none(cached)) {
module.__cached__ = cached;
}
if ($B.is_none(_loader)) {
if (!$B.is_none(locs)) {
_sys_modules[_spec_name] = module;
} else {
throw _b_.ImportError.$factory(mod_name);
}
} else {
var exec_module = $B.$getattr(_loader, "exec_module", _b_.None);
if ($B.is_none(exec_module)) {
module = $B.$getattr(_loader, "load_module")(_spec_name);
} else {
_sys_modules[_spec_name] = module;
try {
exec_module(module);
} catch (e) {
delete _sys_modules[_spec_name];
throw e;
}
}
}
return _sys_modules[_spec_name];
}
$B.path_importer_cache = {};
function import_error(mod_name) {
var exc = _b_.ImportError.$factory(mod_name);
exc.name = mod_name;
throw exc;
}
$B.$__import__ = function (mod_name, globals, locals, fromlist, level) {
var $test = false;
if ($test) {
console.log("__import__", mod_name);
}
var from_stdlib = false;
if (globals.$jsobj && globals.$jsobj.__file__) {
var file = globals.$jsobj.__file__;
if (
(file.startsWith($B.brython_path + "Lib/") &&
!file.startsWith($B.brython_path + "Lib/site-packages/")) ||
file.startsWith($B.brython_path + "libs/") ||
file.startsWith("VFS.")
) {
from_stdlib = true;
}
}
var modobj = $B.imported[mod_name],
parsed_name = mod_name.split("."),
has_from = fromlist.length > 0;
if (modobj == _b_.None) {
import_error(mod_name);
}
if (modobj === undefined) {
if ($B.is_none(fromlist)) {
fromlist = [];
}
for (
var i = 0,
modsep = "",
_mod_name = "",
len = parsed_name.length - 1,
__path__ = _b_.None;
i <= len;
++i
) {
var _parent_name = _mod_name;
_mod_name += modsep + parsed_name[i];
modsep = ".";
var modobj = $B.imported[_mod_name];
if ($test) {
console.log(
"iter",
i,
_mod_name,
"modobj",
modobj,
"__path__",
__path__,
Array.isArray(__path__)
);
alert();
}
if (modobj == _b_.None) {
import_error(_mod_name);
} else if (modobj === undefined) {
try {
import_engine(_mod_name, __path__, from_stdlib);
} catch (err) {
delete $B.imported[_mod_name];
throw err;
}
if ($B.is_none($B.imported[_mod_name])) {
import_error(_mod_name);
} else {
if (_parent_name) {
_b_.setattr(
$B.imported[_parent_name],
parsed_name[i],
$B.imported[_mod_name]
);
}
}
} else if (
$B.imported[_parent_name] &&
$B.imported[_parent_name][parsed_name[i]] === undefined
) {
_b_.setattr(
$B.imported[_parent_name],
parsed_name[i],
$B.imported[_mod_name]
);
}
if (i < len) {
try {
__path__ = $B.$getattr($B.imported[_mod_name], "__path__");
} catch (e) {
if (
i == len - 1 &&
$B.imported[_mod_name][parsed_name[len]] &&
$B.imported[_mod_name][parsed_name[len]].__class__ === $B.module
) {
return $B.imported[_mod_name][parsed_name[len]];
}
if (has_from) {
import_error(mod_name);
} else {
var exc = _b_.ModuleNotFoundError.$factory();
exc.msg =
"No module named '" +
mod_name +
"'; '" +
_mod_name +
"' is not a package";
exc.args = $B.fast_tuple([exc.msg]);
exc.name = mod_name;
exc.path = _b_.None;
throw exc;
}
}
}
}
} else {
if ($B.imported[parsed_name[0]] && parsed_name.length == 2) {
try {
if ($B.imported[parsed_name[0]][parsed_name[1]] === undefined) {
$B.$setattr($B.imported[parsed_name[0]], parsed_name[1], modobj);
}
} catch (err) {
console.log("error", parsed_name, modobj);
throw err;
}
}
}
if (fromlist.length > 0) {
return $B.imported[mod_name];
} else {
return $B.imported[parsed_name[0]];
}
};
$B.$import = function (mod_name, fromlist, aliases, locals) {
var level = 0,
frame = $B.last($B.frames_stack),
current_module = frame[2],
parts = current_module.split(".");
while (mod_name.length > 0 && mod_name.startsWith(".")) {
level++;
mod_name = mod_name.substr(1);
if (parts.length == 0) {
throw _b_.ImportError.$factory(
"Parent module '' not loaded, " + "cannot perform relative import"
);
}
current_module = parts.join(".");
parts.pop();
}
if (level > 0) {
mod_name = current_module + (mod_name.length > 0 ? "." + mod_name : "");
}
var parts = mod_name.split(".");
if (mod_name[mod_name.length - 1] == ".") {
parts.pop();
}
var norm_parts = [],
prefix = true;
for (var i = 0, len = parts.length; i < len; i++) {
var p = parts[i];
if (prefix && p == "") {
elt = norm_parts.pop();
if (elt === undefined) {
throw _b_.ImportError.$factory(
"Parent module '' not loaded, " + "cannot perform relative import"
);
}
} else {
prefix = false;
norm_parts.push(p);
}
}
var mod_name = norm_parts.join(".");
fromlist = fromlist === undefined ? [] : fromlist;
aliases = aliases === undefined ? {} : aliases;
locals = locals === undefined ? {} : locals;
if ($B.$options.debug == 10) {
console.log("$import " + mod_name);
console.log("use VFS ? " + $B.use_VFS);
console.log("use static stdlib paths ? " + $B.static_stdlib_import);
}
var current_frame = $B.frames_stack[$B.frames_stack.length - 1],
_globals = current_frame[3],
__import__ = _globals["__import__"],
globals = $B.obj_dict(_globals);
if (__import__ === undefined) {
__import__ = $B.$__import__;
}
var importer =
typeof __import__ == "function"
? __import__
: $B.$getattr(__import__, "__call__"),
modobj = importer(mod_name, globals, undefined, fromlist, 0);
if (!fromlist || fromlist.length == 0) {
var alias = aliases[mod_name];
if (alias) {
locals[alias] = $B.imported[mod_name];
} else {
locals[norm_parts[0]] = modobj;
}
} else {
var __all__ = fromlist,
thunk = {};
if (fromlist && fromlist[0] == "*") {
__all__ = $B.$getattr(modobj, "__all__", thunk);
if (__all__ !== thunk) {
aliases = {};
}
}
if (__all__ === thunk) {
for (var attr in modobj) {
if (attr[0] !== "_") {
locals[attr] = modobj[attr];
}
}
} else {
for (var i = 0, l = __all__.length; i < l; ++i) {
var name = __all__[i];
var alias = aliases[name] || name;
try {
locals[alias] = $B.$getattr(modobj, name);
} catch ($err1) {
try {
$B.$getattr(__import__, "__call__")(
mod_name + "." + name,
globals,
undefined,
[],
0
);
locals[alias] = $B.$getattr(modobj, name);
} catch ($err3) {
if (mod_name === "__future__") {
var frame = $B.last($B.frames_stack),
line_info =
frame[3].$line_info || frame[1].$lineinfo + "," + frame[2],
line_elts = line_info.split(","),
line_num = parseInt(line_elts[0]);
$B.$SyntaxError(
frame[2],
"future feature " + name + " is not defined",
current_frame[3].src,
undefined,
line_num,
{ filename: mod_name }
);
}
if ($err3.$py_error) {
throw $err3;
}
if ($B.debug > 1) {
console.log($err3);
console.log($B.last($B.frames_stack));
}
throw _b_.ImportError.$factory(
"cannot import name '" + name + "'"
);
}
}
}
}
return locals;
}
};
$B.import_all = function (locals, module) {
for (var attr in module) {
if ("_$".indexOf(attr.charAt(0)) == -1) {
locals[attr] = module[attr];
}
}
};
$B.$path_hooks = [url_hook];
$B.$meta_path = [VFSFinder, StdlibStaticFinder, PathFinder];
$B.finders = {
VFS: VFSFinder,
stdlib_static: StdlibStaticFinder,
path: PathFinder,
CPython: finder_cpython,
};
function optimize_import_for_path(path, filetype) {
if (path.slice(-1) != "/") {
path = path + "/";
}
var value = filetype == "none" ? _b_.None : url_hook(path, filetype);
$B.path_importer_cache[path] = value;
}
var Loader = {
__class__: $B.$type,
__mro__: [_b_.object],
__name__: "Loader",
};
var _importlib_module = {
__class__: Module,
__name__: "_importlib",
Loader: Loader,
VFSFinder: VFSFinder,
StdlibStatic: StdlibStaticFinder,
ImporterPath: PathFinder,
UrlPathFinder: url_hook,
optimize_import_for_path: optimize_import_for_path,
};
_importlib_module.__repr__ = _importlib_module.__str__ = function () {
return "<module '_importlib' (built-in)>";
};
$B.imported["_importlib"] = _importlib_module;
})(__BRYTHON__);
var $B = __BRYTHON__;
$B.unicode = {
Cc: [
[0, 32],
[127, 33],
],
Zs: [32, 160, 5760, [8192, 11], 8239, 8287, 12288],
Po: [
[33, 3],
[37, 3],
[42, 3, 2],
47,
58,
59,
63,
64,
92,
161,
167,
182,
183,
191,
894,
903,
[1370, 6],
1417,
[1472, 3, 3],
1523,
1524,
1545,
1546,
1548,
1549,
1563,
1566,
1567,
[1642, 4],
1748,
[1792, 14],
[2039, 3],
[2096, 15],
2142,
2404,
2405,
2416,
2557,
2678,
2800,
3191,
3204,
3572,
3663,
3674,
3675,
[3844, 15],
3860,
3973,
[4048, 5],
4057,
4058,
[4170, 6],
4347,
[4960, 9],
5742,
[5867, 3],
5941,
5942,
[6100, 3],
[6104, 3],
[6144, 6],
[6151, 4],
6468,
6469,
6686,
6687,
[6816, 7],
[6824, 6],
[7002, 7],
[7164, 4],
[7227, 5],
7294,
7295,
[7360, 8],
7379,
8214,
8215,
[8224, 8],
[8240, 9],
[8251, 4],
[8257, 3],
[8263, 11],
8275,
[8277, 10],
[11513, 4],
11518,
11519,
11632,
11776,
11777,
[11782, 3],
11787,
[11790, 9],
11800,
11801,
11803,
11806,
11807,
[11818, 5],
[11824, 10],
[11836, 4],
11841,
[11843, 13],
11858,
[12289, 3],
12349,
12539,
42238,
42239,
[42509, 3],
42611,
42622,
[42738, 6],
[43124, 4],
43214,
43215,
[43256, 3],
43260,
43310,
43311,
43359,
[43457, 13],
43486,
43487,
[43612, 4],
43742,
43743,
43760,
43761,
44011,
[65040, 7],
65049,
65072,
65093,
65094,
[65097, 4],
[65104, 3],
[65108, 4],
[65119, 3],
65128,
65130,
65131,
[65281, 3],
[65285, 3],
[65290, 3, 2],
65295,
65306,
65307,
65311,
65312,
65340,
65377,
65380,
65381,
[65792, 3],
66463,
66512,
66927,
67671,
67871,
67903,
[68176, 9],
68223,
[68336, 7],
[68409, 7],
[68505, 4],
[69461, 5],
[69703, 7],
69819,
69820,
[69822, 4],
[69952, 4],
70004,
70005,
[70085, 4],
70093,
70107,
[70109, 3],
[70200, 6],
70313,
[70731, 5],
70746,
70747,
70749,
70854,
[71105, 23],
[71233, 3],
[71264, 13],
[71484, 3],
71739,
[72004, 3],
72162,
[72255, 8],
[72346, 3],
[72350, 5],
[72769, 5],
72816,
72817,
73463,
73464,
73727,
[74864, 5],
92782,
92783,
92917,
[92983, 5],
92996,
[93847, 4],
94178,
113823,
[121479, 5],
125278,
125279,
],
Sc: [
36,
[162, 4],
1423,
1547,
2046,
2047,
2546,
2547,
2555,
2801,
3065,
3647,
6107,
[8352, 32],
43064,
65020,
65129,
65284,
65504,
65505,
65509,
65510,
[73693, 4],
123647,
126128,
],
Ps: [
40,
91,
123,
3898,
3900,
5787,
8218,
8222,
8261,
8317,
8333,
8968,
8970,
9001,
[10088, 7, 2],
10181,
[10214, 5, 2],
[10627, 11, 2],
10712,
10714,
10748,
[11810, 4, 2],
11842,
[12296, 5, 2],
[12308, 4, 2],
12317,
64831,
65047,
[65077, 8, 2],
65095,
[65113, 3, 2],
65288,
65339,
65371,
65375,
65378,
],
Pe: [
41,
93,
125,
3899,
3901,
5788,
8262,
8318,
8334,
8969,
8971,
9002,
[10089, 7, 2],
10182,
[10215, 5, 2],
[10628, 11, 2],
10713,
10715,
10749,
[11811, 4, 2],
[12297, 5, 2],
[12309, 4, 2],
12318,
12319,
64830,
65048,
[65078, 8, 2],
65096,
[65114, 3, 2],
65289,
65341,
[65373, 3, 3],
],
Sm: [
43,
[60, 3],
124,
126,
172,
177,
215,
247,
1014,
[1542, 3],
8260,
8274,
[8314, 3],
[8330, 3],
8472,
[8512, 5],
8523,
[8592, 5],
8602,
8603,
[8608, 3, 3],
8622,
8654,
8655,
8658,
8660,
[8692, 268],
8992,
8993,
9084,
[9115, 25],
[9180, 6],
9655,
9665,
[9720, 8],
9839,
[10176, 5],
[10183, 31],
[10224, 16],
[10496, 131],
[10649, 63],
[10716, 32],
[10750, 258],
[11056, 21],
[11079, 6],
64297,
65122,
[65124, 3],
65291,
[65308, 3],
65372,
65374,
65506,
[65513, 4],
120513,
120539,
120571,
120597,
120629,
120655,
120687,
120713,
120745,
120771,
126704,
126705,
],
Pd: [
45,
1418,
1470,
5120,
6150,
[8208, 6],
11799,
11802,
11834,
11835,
11840,
12316,
12336,
12448,
65073,
65074,
65112,
65123,
65293,
69293,
],
Nd: [
[48, 10],
[1632, 10],
[1776, 10],
[1984, 10],
[2406, 10],
[2534, 10],
[2662, 10],
[2790, 10],
[2918, 10],
[3046, 10],
[3174, 10],
[3302, 10],
[3430, 10],
[3558, 10],
[3664, 10],
[3792, 10],
[3872, 10],
[4160, 10],
[4240, 10],
[6112, 10],
[6160, 10],
[6470, 10],
[6608, 10],
[6784, 10],
[6800, 10],
[6992, 10],
[7088, 10],
[7232, 10],
[7248, 10],
[42528, 10],
[43216, 10],
[43264, 10],
[43472, 10],
[43504, 10],
[43600, 10],
[44016, 10],
[65296, 10],
[66720, 10],
[68912, 10],
[69734, 10],
[69872, 10],
[69942, 10],
[70096, 10],
[70384, 10],
[70736, 10],
[70864, 10],
[71248, 10],
[71360, 10],
[71472, 10],
[71904, 10],
[72016, 10],
[72784, 10],
[73040, 10],
[73120, 10],
[92768, 10],
[93008, 10],
[120782, 50],
[123200, 10],
[123632, 10],
[125264, 10],
[130032, 10],
],
Lu: [
[65, 26],
[192, 23],
[216, 7],
[256, 28, 2],
[313, 8, 2],
[330, 24, 2],
[377, 3, 2],
385,
[386, 3, 2],
391,
[393, 3],
[398, 4],
403,
404,
[406, 3],
412,
413,
415,
[416, 4, 2],
423,
425,
428,
430,
431,
[433, 3],
437,
439,
440,
444,
[452, 4, 3],
[463, 7, 2],
[478, 9, 2],
497,
500,
[502, 3],
[506, 29, 2],
570,
571,
573,
574,
577,
[579, 4],
[584, 4, 2],
880,
882,
886,
895,
902,
[904, 3],
908,
910,
911,
[913, 17],
[931, 9],
975,
[978, 3],
[984, 12, 2],
1012,
1015,
1017,
1018,
[1021, 51],
[1120, 17, 2],
[1162, 28, 2],
[1217, 7, 2],
[1232, 48, 2],
[1329, 38],
[4256, 38],
4295,
4301,
[5024, 86],
[7312, 43],
[7357, 3],
[7680, 75, 2],
[7838, 49, 2],
[7944, 8],
[7960, 6],
[7976, 8],
[7992, 8],
[8008, 6],
[8025, 4, 2],
[8040, 8],
[8120, 4],
[8136, 4],
[8152, 4],
[8168, 5],
[8184, 4],
8450,
8455,
[8459, 3],
[8464, 3],
8469,
[8473, 5],
[8484, 4, 2],
[8491, 3],
[8496, 4],
8510,
8511,
8517,
8579,
[11264, 47],
11360,
[11362, 3],
[11367, 4, 2],
[11374, 3],
11378,
11381,
[11390, 3],
[11394, 49, 2],
11499,
11501,
11506,
[42560, 23, 2],
[42624, 14, 2],
[42786, 7, 2],
[42802, 31, 2],
[42873, 3, 2],
[42878, 5, 2],
42891,
42893,
42896,
42898,
[42902, 11, 2],
[42923, 4],
[42928, 5],
[42934, 5, 2],
42946,
[42948, 4],
42953,
42997,
[65313, 26],
[66560, 40],
[66736, 36],
[68736, 51],
[71840, 32],
[93760, 32],
[119808, 26],
[119860, 26],
[119912, 26],
119964,
119966,
[119967, 3, 3],
119974,
[119977, 4],
[119982, 8],
[120016, 26],
120068,
120069,
[120071, 4],
[120077, 8],
[120086, 7],
120120,
120121,
[120123, 4],
[120128, 5],
120134,
[120138, 7],
[120172, 26],
[120224, 26],
[120276, 26],
[120328, 26],
[120380, 26],
[120432, 26],
[120488, 25],
[120546, 25],
[120604, 25],
[120662, 25],
[120720, 25],
120778,
[125184, 34],
],
Sk: [
94,
96,
168,
175,
180,
184,
[706, 4],
[722, 14],
[741, 7],
749,
[751, 17],
885,
900,
901,
8125,
[8127, 3],
[8141, 3],
[8157, 3],
[8173, 3],
8189,
8190,
12443,
12444,
[42752, 23],
42784,
42785,
42889,
42890,
43867,
43882,
43883,
[64434, 16],
65342,
65344,
65507,
[127995, 5],
],
Pc: [95, 8255, 8256, 8276, 65075, 65076, [65101, 3], 65343],
Ll: [
[97, 26],
181,
[223, 24],
[248, 8],
[257, 28, 2],
[312, 9, 2],
[329, 24, 2],
[378, 3, 2],
383,
384,
387,
389,
392,
396,
397,
402,
405,
[409, 3],
414,
[417, 3, 2],
424,
426,
427,
429,
432,
436,
438,
441,
442,
[445, 3],
[454, 3, 3],
[462, 8, 2],
[477, 10, 2],
496,
499,
501,
[505, 30, 2],
[564, 6],
572,
575,
576,
578,
[583, 5, 2],
[592, 68],
[661, 27],
881,
[883, 3, 4],
892,
893,
912,
[940, 35],
976,
977,
[981, 3],
[985, 12, 2],
[1008, 4],
[1013, 3, 3],
1020,
[1072, 48],
[1121, 17, 2],
[1163, 27, 2],
[1218, 7, 2],
[1231, 49, 2],
[1376, 41],
[4304, 43],
[4349, 3],
[5112, 6],
[7296, 9],
[7424, 44],
[7531, 13],
[7545, 34],
[7681, 75, 2],
[7830, 8],
[7839, 49, 2],
[7936, 8],
[7952, 6],
[7968, 8],
[7984, 8],
[8000, 6],
[8016, 8],
[8032, 8],
[8048, 14],
[8064, 8],
[8080, 8],
[8096, 8],
[8112, 5],
8118,
8119,
8126,
[8130, 3],
8134,
8135,
[8144, 4],
8150,
8151,
[8160, 8],
[8178, 3],
8182,
8183,
8458,
8462,
8463,
8467,
[8495, 3, 5],
8508,
8509,
[8518, 4],
8526,
8580,
[11312, 47],
11361,
11365,
[11366, 4, 2],
11377,
11379,
11380,
[11382, 6],
[11393, 50, 2],
11492,
11500,
11502,
11507,
[11520, 38],
11559,
11565,
[42561, 23, 2],
[42625, 14, 2],
[42787, 7, 2],
42800,
[42801, 33, 2],
[42866, 7],
42874,
42876,
[42879, 5, 2],
42892,
42894,
42897,
[42899, 3],
[42903, 10, 2],
42927,
[42933, 6, 2],
42947,
42952,
42954,
42998,
43002,
[43824, 43],
[43872, 9],
[43888, 80],
[64256, 7],
[64275, 5],
[65345, 26],
[66600, 40],
[66776, 36],
[68800, 51],
[71872, 32],
[93792, 32],
[119834, 26],
[119886, 7],
[119894, 18],
[119938, 26],
[119990, 4],
119995,
[119997, 7],
[120005, 11],
[120042, 26],
[120094, 26],
[120146, 26],
[120198, 26],
[120250, 26],
[120302, 26],
[120354, 26],
[120406, 26],
[120458, 28],
[120514, 25],
[120540, 6],
[120572, 25],
[120598, 6],
[120630, 25],
[120656, 6],
[120688, 25],
[120714, 6],
[120746, 25],
[120772, 6],
120779,
[125218, 34],
],
So: [
166,
169,
174,
176,
1154,
1421,
1422,
1550,
1551,
1758,
1769,
1789,
1790,
2038,
2554,
2928,
[3059, 6],
3066,
3199,
3407,
3449,
[3841, 3],
3859,
[3861, 3],
[3866, 6],
[3892, 3, 2],
[4030, 8],
[4039, 6],
4046,
4047,
[4053, 4],
4254,
4255,
[5008, 10],
5741,
6464,
[6622, 34],
[7009, 10],
[7028, 9],
8448,
8449,
[8451, 4],
8456,
8457,
8468,
8470,
8471,
[8478, 6],
[8485, 3, 2],
8494,
8506,
8507,
8522,
8524,
8525,
8527,
8586,
8587,
[8597, 5],
[8604, 4],
8609,
8610,
8612,
8613,
[8615, 7],
[8623, 31],
8656,
[8657, 3, 2],
[8662, 30],
[8960, 8],
[8972, 20],
[8994, 7],
[9003, 81],
[9085, 30],
[9140, 40],
[9186, 69],
[9280, 11],
[9372, 78],
[9472, 183],
[9656, 9],
[9666, 54],
[9728, 111],
[9840, 248],
[10132, 44],
[10240, 256],
[11008, 48],
11077,
11078,
[11085, 39],
[11126, 32],
[11159, 105],
[11493, 6],
11856,
11857,
[11904, 26],
[11931, 89],
[12032, 214],
[12272, 12],
12292,
12306,
12307,
12320,
12342,
12343,
12350,
12351,
12688,
12689,
[12694, 10],
[12736, 36],
[12800, 31],
[12842, 30],
12880,
[12896, 32],
[12938, 39],
[12992, 320],
[19904, 64],
[42128, 55],
[43048, 4],
43062,
43063,
43065,
[43639, 3],
65021,
65508,
65512,
65517,
65518,
65532,
65533,
[65847, 9],
[65913, 17],
[65932, 3],
[65936, 13],
65952,
[66000, 45],
67703,
67704,
68296,
71487,
[73685, 8],
[73697, 17],
[92988, 4],
92997,
113820,
[118784, 246],
[119040, 39],
[119081, 60],
[119146, 3],
119171,
119172,
[119180, 30],
[119214, 59],
[119296, 66],
119365,
[119552, 87],
[120832, 512],
[121399, 4],
[121453, 8],
[121462, 14],
121477,
121478,
123215,
126124,
126254,
[126976, 44],
[127024, 100],
[127136, 15],
[127153, 15],
[127169, 15],
[127185, 37],
[127245, 161],
[127462, 29],
[127504, 44],
[127552, 9],
127568,
127569,
[127584, 6],
[127744, 251],
[128000, 728],
[128736, 13],
[128752, 13],
[128768, 116],
[128896, 89],
[128992, 12],
[129024, 12],
[129040, 56],
[129104, 10],
[129120, 40],
[129168, 30],
129200,
129201,
[129280, 121],
[129402, 82],
[129485, 135],
[129632, 14],
[129648, 5],
[129656, 3],
[129664, 7],
[129680, 25],
[129712, 7],
[129728, 3],
[129744, 7],
[129792, 147],
[129940, 55],
],
Lo: [
170,
186,
443,
[448, 4],
660,
[1488, 27],
[1519, 4],
[1568, 32],
[1601, 10],
1646,
1647,
[1649, 99],
1749,
1774,
1775,
[1786, 3],
1791,
1808,
[1810, 30],
[1869, 89],
1969,
[1994, 33],
[2048, 22],
[2112, 25],
[2144, 11],
[2208, 21],
[2230, 18],
[2308, 54],
2365,
2384,
[2392, 10],
[2418, 15],
[2437, 8],
2447,
2448,
[2451, 22],
[2474, 7],
2482,
[2486, 4],
2493,
2510,
2524,
2525,
[2527, 3],
2544,
2545,
2556,
[2565, 6],
2575,
2576,
[2579, 22],
[2602, 7],
2610,
2611,
2613,
2614,
2616,
2617,
[2649, 4],
2654,
[2674, 3],
[2693, 9],
[2703, 3],
[2707, 22],
[2730, 7],
2738,
2739,
[2741, 5],
2749,
2768,
2784,
2785,
2809,
[2821, 8],
2831,
2832,
[2835, 22],
[2858, 7],
2866,
2867,
[2869, 5],
2877,
2908,
2909,
[2911, 3],
2929,
2947,
[2949, 6],
[2958, 3],
[2962, 4],
2969,
[2970, 3, 2],
2975,
2979,
2980,
[2984, 3],
[2990, 12],
3024,
[3077, 8],
[3086, 3],
[3090, 23],
[3114, 16],
3133,
[3160, 3],
3168,
3169,
3200,
[3205, 8],
[3214, 3],
[3218, 23],
[3242, 10],
[3253, 5],
3261,
3294,
3296,
3297,
3313,
3314,
[3332, 9],
[3342, 3],
[3346, 41],
3389,
3406,
[3412, 3],
[3423, 3],
[3450, 6],
[3461, 18],
[3482, 24],
[3507, 9],
3517,
[3520, 7],
[3585, 48],
3634,
3635,
[3648, 6],
3713,
[3714, 3, 2],
[3719, 4],
[3724, 24],
3749,
[3751, 10],
3762,
3763,
3773,
[3776, 5],
[3804, 4],
3840,
[3904, 8],
[3913, 36],
[3976, 5],
[4096, 43],
4159,
[4176, 6],
[4186, 4],
4193,
4197,
4198,
[4206, 3],
[4213, 13],
4238,
[4352, 329],
[4682, 4],
[4688, 7],
4696,
[4698, 4],
[4704, 41],
[4746, 4],
[4752, 33],
[4786, 4],
[4792, 7],
4800,
[4802, 4],
[4808, 15],
[4824, 57],
[4882, 4],
[4888, 67],
[4992, 16],
[5121, 620],
[5743, 17],
[5761, 26],
[5792, 75],
[5873, 8],
[5888, 13],
[5902, 4],
[5920, 18],
[5952, 18],
[5984, 13],
[5998, 3],
[6016, 52],
6108,
[6176, 35],
[6212, 53],
[6272, 5],
[6279, 34],
6314,
[6320, 70],
[6400, 31],
[6480, 30],
[6512, 5],
[6528, 44],
[6576, 26],
[6656, 23],
[6688, 53],
[6917, 47],
[6981, 7],
[7043, 30],
7086,
7087,
[7098, 44],
[7168, 36],
[7245, 3],
[7258, 30],
[7401, 4],
[7406, 6],
7413,
7414,
7418,
[8501, 4],
[11568, 56],
[11648, 23],
[11680, 7],
[11688, 7],
[11696, 7],
[11704, 7],
[11712, 7],
[11720, 7],
[11728, 7],
[11736, 7],
12294,
12348,
[12353, 86],
12447,
[12449, 90],
12543,
[12549, 43],
[12593, 94],
[12704, 32],
[12784, 16],
13312,
19903,
19968,
40956,
[40960, 21],
[40982, 1143],
[42192, 40],
[42240, 268],
[42512, 16],
42538,
42539,
42606,
[42656, 70],
42895,
42999,
[43003, 7],
[43011, 3],
[43015, 4],
[43020, 23],
[43072, 52],
[43138, 50],
[43250, 6],
43259,
43261,
43262,
[43274, 28],
[43312, 23],
[43360, 29],
[43396, 47],
[43488, 5],
[43495, 9],
[43514, 5],
[43520, 41],
[43584, 3],
[43588, 8],
[43616, 16],
[43633, 6],
43642,
[43646, 50],
43697,
43701,
43702,
[43705, 5],
43712,
43714,
43739,
43740,
[43744, 11],
43762,
[43777, 6],
[43785, 6],
[43793, 6],
[43808, 7],
[43816, 7],
[43968, 35],
44032,
55203,
[55216, 23],
[55243, 49],
[63744, 366],
[64112, 106],
64285,
[64287, 10],
[64298, 13],
[64312, 5],
64318,
64320,
64321,
64323,
64324,
[64326, 108],
[64467, 363],
[64848, 64],
[64914, 54],
[65008, 12],
[65136, 5],
[65142, 135],
[65382, 10],
[65393, 45],
[65440, 31],
[65474, 6],
[65482, 6],
[65490, 6],
[65498, 3],
[65536, 12],
[65549, 26],
[65576, 19],
65596,
65597,
[65599, 15],
[65616, 14],
[65664, 123],
[66176, 29],
[66208, 49],
[66304, 32],
[66349, 20],
[66370, 8],
[66384, 38],
[66432, 30],
[66464, 36],
[66504, 8],
[66640, 78],
[66816, 40],
[66864, 52],
[67072, 311],
[67392, 22],
[67424, 8],
[67584, 6],
67592,
[67594, 44],
67639,
67640,
67644,
[67647, 23],
[67680, 23],
[67712, 31],
[67808, 19],
67828,
67829,
[67840, 22],
[67872, 26],
[67968, 56],
68030,
68031,
68096,
[68112, 4],
[68117, 3],
[68121, 29],
[68192, 29],
[68224, 29],
[68288, 8],
[68297, 28],
[68352, 54],
[68416, 22],
[68448, 19],
[68480, 18],
[68608, 73],
[68864, 36],
[69248, 42],
69296,
69297,
[69376, 29],
69415,
[69424, 22],
[69552, 21],
[69600, 23],
[69635, 53],
[69763, 45],
[69840, 25],
[69891, 36],
69956,
69959,
[69968, 35],
70006,
[70019, 48],
[70081, 4],
70106,
70108,
[70144, 18],
[70163, 25],
[70272, 7],
70280,
[70282, 4],
[70287, 15],
[70303, 10],
[70320, 47],
[70405, 8],
70415,
70416,
[70419, 22],
[70442, 7],
70450,
70451,
[70453, 5],
70461,
70480,
[70493, 5],
[70656, 53],
[70727, 4],
[70751, 3],
[70784, 48],
70852,
70853,
70855,
[71040, 47],
[71128, 4],
[71168, 48],
71236,
[71296, 43],
71352,
[71424, 27],
[71680, 44],
[71935, 8],
71945,
[71948, 8],
71957,
71958,
[71960, 24],
71999,
72001,
[72096, 8],
[72106, 39],
72161,
72163,
72192,
[72203, 40],
72250,
72272,
[72284, 46],
72349,
[72384, 57],
[72704, 9],
[72714, 37],
72768,
[72818, 30],
[72960, 7],
72968,
72969,
[72971, 38],
73030,
[73056, 6],
73063,
73064,
[73066, 32],
73112,
[73440, 19],
73648,
[73728, 922],
[74880, 196],
[77824, 1071],
[82944, 583],
[92160, 569],
[92736, 31],
[92880, 30],
[92928, 48],
[93027, 21],
[93053, 19],
[93952, 75],
94032,
94208,
100343,
[100352, 1238],
101632,
101640,
[110592, 287],
[110928, 3],
[110948, 4],
[110960, 396],
[113664, 107],
[113776, 13],
[113792, 9],
[113808, 10],
[123136, 45],
123214,
[123584, 44],
[124928, 197],
[126464, 4],
[126469, 27],
126497,
126498,
126500,
126503,
[126505, 10],
[126516, 4],
126521,
126523,
126530,
[126535, 4, 2],
126542,
126543,
126545,
126546,
126548,
[126551, 6, 2],
126562,
126564,
[126567, 4],
[126572, 7],
[126580, 4],
[126585, 4],
126590,
[126592, 10],
[126603, 17],
[126625, 3],
[126629, 5],
[126635, 17],
131072,
173789,
173824,
177972,
177984,
178205,
178208,
183969,
183984,
191456,
[194560, 542],
196608,
201546,
],
Pi: [
171, 8216, 8219, 8220, 8223, 8249, 11778, 11780, 11785, 11788, 11804, 11808,
],
Cf: [
173,
[1536, 6],
1564,
1757,
1807,
2274,
6158,
[8203, 5],
[8234, 5],
[8288, 5],
[8294, 10],
65279,
[65529, 3],
69821,
69837,
[78896, 9],
[113824, 4],
[119155, 8],
917505,
[917536, 96],
],
No: [
178,
179,
185,
[188, 3],
[2548, 6],
[2930, 6],
[3056, 3],
[3192, 7],
[3416, 7],
[3440, 9],
[3882, 10],
[4969, 20],
[6128, 10],
6618,
8304,
[8308, 6],
[8320, 10],
[8528, 16],
8585,
[9312, 60],
[9450, 22],
[10102, 30],
11517,
[12690, 4],
[12832, 10],
[12872, 8],
[12881, 15],
[12928, 10],
[12977, 15],
[43056, 6],
[65799, 45],
[65909, 4],
65930,
65931,
[66273, 27],
[66336, 4],
[67672, 8],
[67705, 7],
[67751, 9],
[67835, 5],
[67862, 6],
68028,
68029,
[68032, 16],
[68050, 46],
[68160, 9],
68221,
68222,
[68253, 3],
[68331, 5],
[68440, 8],
[68472, 8],
[68521, 7],
[68858, 6],
[69216, 31],
[69405, 10],
[69457, 4],
[69573, 7],
[69714, 20],
[70113, 20],
71482,
71483,
[71914, 9],
[72794, 19],
[73664, 21],
[93019, 7],
[93824, 23],
[119520, 20],
[119648, 25],
[125127, 9],
[126065, 59],
[126125, 3],
[126129, 4],
[126209, 45],
[126255, 15],
[127232, 13],
],
Pf: [187, 8217, 8221, 8250, 11779, 11781, 11786, 11789, 11805, 11809],
Lt: [[453, 3, 3], 498, [8072, 8], [8088, 8], [8104, 8], 8124, 8140, 8188],
Lm: [
[688, 18],
[710, 12],
[736, 5],
748,
750,
884,
890,
1369,
1600,
1765,
1766,
2036,
2037,
2042,
2074,
2084,
2088,
2417,
3654,
3782,
4348,
6103,
6211,
6823,
[7288, 6],
[7468, 63],
7544,
[7579, 37],
8305,
8319,
[8336, 13],
11388,
11389,
11631,
11823,
12293,
[12337, 5],
12347,
12445,
12446,
[12540, 3],
40981,
[42232, 6],
42508,
42623,
42652,
42653,
[42775, 9],
42864,
42888,
43000,
43001,
43471,
43494,
43632,
43741,
43763,
43764,
[43868, 4],
43881,
65392,
65438,
65439,
[92992, 4],
[94099, 13],
94176,
94177,
94179,
[123191, 7],
125259,
],
Mn: [
[768, 112],
[1155, 5],
[1425, 45],
1471,
1473,
1474,
1476,
1477,
1479,
[1552, 11],
[1611, 21],
1648,
[1750, 7],
[1759, 6],
1767,
1768,
[1770, 4],
1809,
[1840, 27],
[1958, 11],
[2027, 9],
2045,
[2070, 4],
[2075, 9],
[2085, 3],
[2089, 5],
[2137, 3],
[2259, 15],
[2275, 32],
2362,
2364,
[2369, 8],
2381,
[2385, 7],
2402,
2403,
2433,
2492,
[2497, 4],
2509,
2530,
2531,
2558,
2561,
2562,
2620,
2625,
2626,
2631,
2632,
[2635, 3],
2641,
2672,
2673,
2677,
2689,
2690,
2748,
[2753, 5],
2759,
2760,
2765,
2786,
2787,
[2810, 6],
2817,
2876,
2879,
[2881, 4],
2893,
2901,
2902,
2914,
2915,
2946,
3008,
3021,
3072,
3076,
[3134, 3],
[3142, 3],
[3146, 4],
3157,
3158,
3170,
3171,
3201,
3260,
3263,
3270,
3276,
3277,
3298,
3299,
3328,
3329,
3387,
3388,
[3393, 4],
3405,
3426,
3427,
3457,
3530,
[3538, 3],
3542,
3633,
[3636, 7],
[3655, 8],
3761,
[3764, 9],
[3784, 6],
3864,
3865,
[3893, 3, 2],
[3953, 14],
[3968, 5],
3974,
3975,
[3981, 11],
[3993, 36],
4038,
[4141, 4],
[4146, 6],
4153,
4154,
4157,
4158,
4184,
4185,
[4190, 3],
[4209, 4],
4226,
4229,
4230,
4237,
4253,
[4957, 3],
[5906, 3],
[5938, 3],
5970,
5971,
6002,
6003,
6068,
6069,
[6071, 7],
6086,
[6089, 11],
6109,
[6155, 3],
6277,
6278,
6313,
[6432, 3],
6439,
6440,
6450,
[6457, 3],
6679,
6680,
6683,
6742,
[6744, 7],
6752,
6754,
[6757, 8],
[6771, 10],
6783,
[6832, 14],
6847,
6848,
[6912, 4],
6964,
[6966, 5],
6972,
6978,
[7019, 9],
7040,
7041,
[7074, 4],
7080,
7081,
[7083, 3],
7142,
7144,
7145,
7149,
[7151, 3],
[7212, 8],
7222,
7223,
[7376, 3],
[7380, 13],
[7394, 7],
7405,
7412,
7416,
7417,
[7616, 58],
[7675, 5],
[8400, 13],
8417,
[8421, 12],
[11503, 3],
11647,
[11744, 32],
[12330, 4],
12441,
12442,
42607,
[42612, 10],
42654,
42655,
42736,
42737,
43010,
43014,
43019,
43045,
43046,
43052,
43204,
43205,
[43232, 18],
43263,
[43302, 8],
[43335, 11],
[43392, 3],
43443,
[43446, 4],
43452,
43453,
43493,
[43561, 6],
43569,
43570,
43573,
43574,
43587,
43596,
43644,
43696,
[43698, 3],
43703,
43704,
43710,
43711,
43713,
43756,
43757,
43766,
44005,
44008,
44013,
64286,
[65024, 16],
[65056, 16],
66045,
66272,
[66422, 5],
[68097, 3],
68101,
68102,
[68108, 4],
[68152, 3],
68159,
68325,
68326,
[68900, 4],
69291,
69292,
[69446, 11],
69633,
[69688, 15],
[69759, 3],
[69811, 4],
69817,
69818,
[69888, 3],
[69927, 5],
[69933, 8],
70003,
70016,
70017,
[70070, 9],
[70089, 4],
70095,
[70191, 3],
70196,
70198,
70199,
70206,
70367,
[70371, 8],
70400,
70401,
70459,
70460,
70464,
[70502, 7],
[70512, 5],
[70712, 8],
[70722, 3],
70726,
70750,
[70835, 6],
70842,
70847,
70848,
70850,
70851,
[71090, 4],
71100,
71101,
71103,
71104,
71132,
71133,
[71219, 8],
71229,
71231,
71232,
71339,
71341,
[71344, 6],
71351,
[71453, 3],
[71458, 4],
[71463, 5],
[71727, 9],
71737,
71738,
71995,
71996,
71998,
72003,
[72148, 4],
72154,
72155,
72160,
[72193, 10],
[72243, 6],
[72251, 4],
72263,
[72273, 6],
[72281, 3],
[72330, 13],
72344,
72345,
[72752, 7],
[72760, 6],
72767,
[72850, 22],
[72874, 7],
72882,
72883,
72885,
72886,
[73009, 6],
73018,
73020,
73021,
[73023, 7],
73031,
73104,
73105,
73109,
73111,
73459,
73460,
[92912, 5],
[92976, 7],
94031,
[94095, 4],
94180,
113821,
113822,
[119143, 3],
[119163, 8],
[119173, 7],
[119210, 4],
[119362, 3],
[121344, 55],
[121403, 50],
121461,
121476,
[121499, 5],
[121505, 15],
[122880, 7],
[122888, 17],
[122907, 7],
122915,
122916,
[122918, 5],
[123184, 7],
[123628, 4],
[125136, 7],
[125252, 7],
[917760, 240],
],
Me: [1160, 1161, 6846, [8413, 4], [8418, 3], [42608, 3]],
Mc: [
2307,
2363,
[2366, 3],
[2377, 4],
2382,
2383,
2434,
2435,
[2494, 3],
2503,
2504,
2507,
2508,
2519,
2563,
[2622, 3],
2691,
[2750, 3],
2761,
2763,
2764,
2818,
2819,
2878,
2880,
2887,
2888,
2891,
2892,
2903,
3006,
3007,
3009,
3010,
[3014, 3],
[3018, 3],
3031,
[3073, 3],
[3137, 4],
3202,
3203,
3262,
[3264, 5],
3271,
3272,
3274,
3275,
3285,
3286,
3330,
3331,
[3390, 3],
[3398, 3],
[3402, 3],
3415,
3458,
3459,
[3535, 3],
[3544, 8],
3570,
3571,
3902,
3903,
3967,
4139,
4140,
4145,
4152,
4155,
4156,
4182,
4183,
[4194, 3],
[4199, 7],
4227,
4228,
[4231, 6],
4239,
[4250, 3],
6070,
[6078, 8],
6087,
6088,
[6435, 4],
[6441, 3],
6448,
6449,
[6451, 6],
6681,
6682,
6741,
6743,
6753,
6755,
6756,
[6765, 6],
6916,
6965,
6971,
[6973, 5],
6979,
6980,
7042,
7073,
7078,
7079,
7082,
7143,
[7146, 3],
7150,
7154,
7155,
[7204, 8],
7220,
7221,
7393,
7415,
12334,
12335,
43043,
43044,
43047,
43136,
43137,
[43188, 16],
43346,
43347,
43395,
43444,
43445,
43450,
43451,
[43454, 3],
43567,
43568,
43571,
43572,
43597,
43643,
43645,
43755,
43758,
43759,
43765,
44003,
44004,
44006,
44007,
44009,
44010,
44012,
69632,
69634,
69762,
[69808, 3],
69815,
69816,
69932,
69957,
69958,
70018,
[70067, 3],
70079,
70080,
70094,
[70188, 3],
70194,
70195,
70197,
[70368, 3],
70402,
70403,
70462,
70463,
[70465, 4],
70471,
70472,
[70475, 3],
70487,
70498,
70499,
[70709, 3],
70720,
70721,
70725,
[70832, 3],
70841,
[70843, 4],
70849,
[71087, 3],
[71096, 4],
71102,
[71216, 3],
71227,
71228,
71230,
71340,
71342,
71343,
71350,
71456,
71457,
71462,
[71724, 3],
71736,
[71984, 6],
71991,
71992,
71997,
72000,
72002,
[72145, 3],
[72156, 4],
72164,
72249,
72279,
72280,
72343,
72751,
72766,
72873,
72881,
72884,
[73098, 5],
73107,
73108,
73110,
73461,
73462,
[94033, 55],
94192,
94193,
119141,
119142,
[119149, 6],
],
Nl: [
[5870, 3],
[8544, 35],
[8581, 4],
12295,
[12321, 9],
[12344, 3],
[42726, 10],
[65856, 53],
66369,
66378,
[66513, 5],
[74752, 111],
],
Zl: [8232],
Zp: [8233],
Cs: [55296, 56191, 56192, 56319, 56320, 57343],
Co: [57344, 63743, 983040, 1048573, 1048576, 1114109],
digits: [
[48, 10],
178,
179,
185,
[1632, 10],
[1776, 10],
[1984, 10],
[2406, 10],
[2534, 10],
[2662, 10],
[2790, 10],
[2918, 10],
[3046, 10],
[3174, 10],
[3302, 10],
[3430, 10],
[3558, 10],
[3664, 10],
[3792, 10],
[3872, 10],
[4160, 10],
[4240, 10],
[4969, 9],
[6112, 10],
[6160, 10],
[6470, 10],
[6608, 11],
[6784, 10],
[6800, 10],
[6992, 10],
[7088, 10],
[7232, 10],
[7248, 10],
8304,
[8308, 6],
[8320, 10],
[9312, 9],
[9332, 9],
[9352, 9],
9450,
[9461, 9],
9471,
[10102, 9],
[10112, 9],
[10122, 9],
[42528, 10],
[43216, 10],
[43264, 10],
[43472, 10],
[43504, 10],
[43600, 10],
[44016, 10],
[65296, 10],
[66720, 10],
[68160, 4],
[68912, 10],
[69216, 9],
[69714, 9],
[69734, 10],
[69872, 10],
[69942, 10],
[70096, 10],
[70384, 10],
[70736, 10],
[70864, 10],
[71248, 10],
[71360, 10],
[71472, 10],
[71904, 10],
[72016, 10],
[72784, 10],
[73040, 10],
[73120, 10],
[92768, 10],
[93008, 10],
[120782, 50],
[123200, 10],
[123632, 10],
[125264, 10],
[127232, 11],
[130032, 10],
],
numeric: [
[48, 10],
178,
179,
185,
[188, 3],
[1632, 10],
[1776, 10],
[1984, 10],
[2406, 10],
[2534, 10],
[2548, 6],
[2662, 10],
[2790, 10],
[2918, 10],
[2930, 6],
[3046, 13],
[3174, 10],
[3192, 7],
[3302, 10],
[3416, 7],
[3430, 19],
[3558, 10],
[3664, 10],
[3792, 10],
[3872, 20],
[4160, 10],
[4240, 10],
[4969, 20],
[5870, 3],
[6112, 10],
[6128, 10],
[6160, 10],
[6470, 10],
[6608, 11],
[6784, 10],
[6800, 10],
[6992, 10],
[7088, 10],
[7232, 10],
[7248, 10],
8304,
[8308, 6],
[8320, 10],
[8528, 51],
[8581, 5],
[9312, 60],
[9450, 22],
[10102, 30],
11517,
12295,
[12321, 9],
[12344, 3],
[12690, 4],
[12832, 10],
[12872, 8],
[12881, 15],
[12928, 10],
[12977, 15],
13317,
13443,
14378,
15181,
19968,
19971,
19975,
19977,
20061,
20108,
20116,
20118,
20159,
20160,
20191,
20200,
20237,
20336,
20740,
20806,
[20841, 3, 2],
21313,
[21315, 3],
21324,
[21441, 4],
22235,
22769,
22777,
24186,
24318,
24319,
[24332, 3],
24336,
25342,
25420,
26578,
28422,
29590,
30334,
32902,
33836,
36014,
36019,
36144,
38433,
38470,
38476,
38520,
38646,
[42528, 10],
[42726, 10],
[43056, 6],
[43216, 10],
[43264, 10],
[43472, 10],
[43504, 10],
[43600, 10],
[44016, 10],
63851,
63859,
63864,
63922,
63953,
63955,
63997,
[65296, 10],
[65799, 45],
[65856, 57],
65930,
65931,
[66273, 27],
[66336, 4],
66369,
66378,
[66513, 5],
[66720, 10],
[67672, 8],
[67705, 7],
[67751, 9],
[67835, 5],
[67862, 6],
68028,
68029,
[68032, 16],
[68050, 46],
[68160, 9],
68221,
68222,
[68253, 3],
[68331, 5],
[68440, 8],
[68472, 8],
[68521, 7],
[68858, 6],
[68912, 10],
[69216, 31],
[69405, 10],
[69457, 4],
[69573, 7],
[69714, 30],
[69872, 10],
[69942, 10],
[70096, 10],
[70113, 20],
[70384, 10],
[70736, 10],
[70864, 10],
[71248, 10],
[71360, 10],
[71472, 12],
[71904, 19],
[72016, 10],
[72784, 29],
[73040, 10],
[73120, 10],
[73664, 21],
[74752, 111],
[92768, 10],
[93008, 10],
[93019, 7],
[93824, 23],
[119520, 20],
[119648, 25],
[120782, 50],
[123200, 10],
[123632, 10],
[125127, 9],
[125264, 10],
[126065, 59],
[126125, 3],
[126129, 4],
[126209, 45],
[126255, 15],
[127232, 13],
[130032, 10],
131073,
131172,
131298,
131361,
133418,
133507,
133516,
133532,
133866,
133885,
133913,
140176,
141720,
146203,
156269,
194704,
],
Cn: [
[888, 2],
[896, 4],
[907, 1],
[909, 1],
[930, 1],
[1328, 1],
[1367, 2],
[1419, 2],
[1424, 1],
[1480, 8],
[1515, 4],
[1525, 11],
[1565, 1],
[1806, 1],
[1867, 2],
[1970, 14],
[2043, 2],
[2094, 2],
[2111, 1],
[2140, 2],
[2143, 1],
[2155, 53],
[2229, 1],
[2248, 11],
[2436, 1],
[2445, 2],
[2449, 2],
[2473, 1],
[2481, 1],
[2483, 3],
[2490, 2],
[2501, 2],
[2505, 2],
[2511, 8],
[2520, 4],
[2526, 1],
[2532, 2],
[2559, 2],
[2564, 1],
[2571, 4],
[2577, 2],
[2601, 1],
[2609, 1],
[2612, 1],
[2615, 1],
[2618, 2],
[2621, 1],
[2627, 4],
[2633, 2],
[2638, 3],
[2642, 7],
[2653, 1],
[2655, 7],
[2679, 10],
[2692, 1],
[2702, 1],
[2706, 1],
[2729, 1],
[2737, 1],
[2740, 1],
[2746, 2],
[2758, 1],
[2762, 1],
[2766, 2],
[2769, 15],
[2788, 2],
[2802, 7],
[2816, 1],
[2820, 1],
[2829, 2],
[2833, 2],
[2857, 1],
[2865, 1],
[2868, 1],
[2874, 2],
[2885, 2],
[2889, 2],
[2894, 7],
[2904, 4],
[2910, 1],
[2916, 2],
[2936, 10],
[2948, 1],
[2955, 3],
[2961, 1],
[2966, 3],
[2971, 1],
[2973, 1],
[2976, 3],
[2981, 3],
[2987, 3],
[3002, 4],
[3011, 3],
[3017, 1],
[3022, 2],
[3025, 6],
[3032, 14],
[3067, 5],
[3085, 1],
[3089, 1],
[3113, 1],
[3130, 3],
[3141, 1],
[3145, 1],
[3150, 7],
[3159, 1],
[3163, 5],
[3172, 2],
[3184, 7],
[3213, 1],
[3217, 1],
[3241, 1],
[3252, 1],
[3258, 2],
[3269, 1],
[3273, 1],
[3278, 7],
[3287, 7],
[3295, 1],
[3300, 2],
[3312, 1],
[3315, 13],
[3341, 1],
[3345, 1],
[3397, 1],
[3401, 1],
[3408, 4],
[3428, 2],
[3456, 1],
[3460, 1],
[3479, 3],
[3506, 1],
[3516, 1],
[3518, 2],
[3527, 3],
[3531, 4],
[3541, 1],
[3543, 1],
[3552, 6],
[3568, 2],
[3573, 12],
[3643, 4],
[3676, 37],
[3715, 1],
[3717, 1],
[3723, 1],
[3748, 1],
[3750, 1],
[3774, 2],
[3781, 1],
[3783, 1],
[3790, 2],
[3802, 2],
[3808, 32],
[3912, 1],
[3949, 4],
[3992, 1],
[4029, 1],
[4045, 1],
[4059, 37],
[4294, 1],
[4296, 5],
[4302, 2],
[4681, 1],
[4686, 2],
[4695, 1],
[4697, 1],
[4702, 2],
[4745, 1],
[4750, 2],
[4785, 1],
[4790, 2],
[4799, 1],
[4801, 1],
[4806, 2],
[4823, 1],
[4881, 1],
[4886, 2],
[4955, 2],
[4989, 3],
[5018, 6],
[5110, 2],
[5118, 2],
[5789, 3],
[5881, 7],
[5901, 1],
[5909, 11],
[5943, 9],
[5972, 12],
[5997, 1],
[6001, 1],
[6004, 12],
[6110, 2],
[6122, 6],
[6138, 6],
[6159, 1],
[6170, 6],
[6265, 7],
[6315, 5],
[6390, 10],
[6431, 1],
[6444, 4],
[6460, 4],
[6465, 3],
[6510, 2],
[6517, 11],
[6572, 4],
[6602, 6],
[6619, 3],
[6684, 2],
[6751, 1],
[6781, 2],
[6794, 6],
[6810, 6],
[6830, 2],
[6849, 63],
[6988, 4],
[7037, 3],
[7156, 8],
[7224, 3],
[7242, 3],
[7305, 7],
[7355, 2],
[7368, 8],
[7419, 5],
[7674, 1],
[7958, 2],
[7966, 2],
[8006, 2],
[8014, 2],
[8024, 1],
[8026, 1],
[8028, 1],
[8030, 1],
[8062, 2],
[8117, 1],
[8133, 1],
[8148, 2],
[8156, 1],
[8176, 2],
[8181, 1],
[8191, 1],
[8293, 1],
[8306, 2],
[8335, 1],
[8349, 3],
[8384, 16],
[8433, 15],
[8588, 4],
[9255, 25],
[9291, 21],
[11124, 2],
[11158, 1],
[11311, 1],
[11359, 1],
[11508, 5],
[11558, 1],
[11560, 5],
[11566, 2],
[11624, 7],
[11633, 14],
[11671, 9],
[11687, 1],
[11695, 1],
[11703, 1],
[11711, 1],
[11719, 1],
[11727, 1],
[11735, 1],
[11743, 1],
[11859, 45],
[11930, 1],
[12020, 12],
[12246, 26],
[12284, 4],
[12352, 1],
[12439, 2],
[12544, 5],
[12592, 1],
[12687, 1],
[12772, 12],
[12831, 1],
[40957, 3],
[42125, 3],
[42183, 9],
[42540, 20],
[42744, 8],
[42944, 2],
[42955, 42],
[43053, 3],
[43066, 6],
[43128, 8],
[43206, 8],
[43226, 6],
[43348, 11],
[43389, 3],
[43470, 1],
[43482, 4],
[43519, 1],
[43575, 9],
[43598, 2],
[43610, 2],
[43715, 24],
[43767, 10],
[43783, 2],
[43791, 2],
[43799, 9],
[43815, 1],
[43823, 1],
[43884, 4],
[44014, 2],
[44026, 6],
[55204, 12],
[55239, 4],
[55292, 4],
[64110, 2],
[64218, 38],
[64263, 12],
[64280, 5],
[64311, 1],
[64317, 1],
[64319, 1],
[64322, 1],
[64325, 1],
[64450, 17],
[64832, 16],
[64912, 2],
[64968, 40],
[65022, 2],
[65050, 6],
[65107, 1],
[65127, 1],
[65132, 4],
[65141, 1],
[65277, 2],
[65280, 1],
[65471, 3],
[65480, 2],
[65488, 2],
[65496, 2],
[65501, 3],
[65511, 1],
[65519, 10],
[65534, 2],
[65548, 1],
[65575, 1],
[65595, 1],
[65598, 1],
[65614, 2],
[65630, 34],
[65787, 5],
[65795, 4],
[65844, 3],
[65935, 1],
[65949, 3],
[65953, 47],
[66046, 130],
[66205, 3],
[66257, 15],
[66300, 4],
[66340, 9],
[66379, 5],
[66427, 5],
[66462, 1],
[66500, 4],
[66518, 42],
[66718, 2],
[66730, 6],
[66772, 4],
[66812, 4],
[66856, 8],
[66916, 11],
[66928, 144],
[67383, 9],
[67414, 10],
[67432, 152],
[67590, 2],
[67593, 1],
[67638, 1],
[67641, 3],
[67645, 2],
[67670, 1],
[67743, 8],
[67760, 48],
[67827, 1],
[67830, 5],
[67868, 3],
[67898, 5],
[67904, 64],
[68024, 4],
[68048, 2],
[68100, 1],
[68103, 5],
[68116, 1],
[68120, 1],
[68150, 2],
[68155, 4],
[68169, 7],
[68185, 7],
[68256, 32],
[68327, 4],
[68343, 9],
[68406, 3],
[68438, 2],
[68467, 5],
[68498, 7],
[68509, 12],
[68528, 80],
[68681, 55],
[68787, 13],
[68851, 7],
[68904, 8],
[68922, 294],
[69247, 1],
[69290, 1],
[69294, 2],
[69298, 78],
[69416, 8],
[69466, 86],
[69580, 20],
[69623, 9],
[69710, 4],
[69744, 15],
[69826, 11],
[69838, 2],
[69865, 7],
[69882, 6],
[69941, 1],
[69960, 8],
[70007, 9],
[70112, 1],
[70133, 11],
[70162, 1],
[70207, 65],
[70279, 1],
[70281, 1],
[70286, 1],
[70302, 1],
[70314, 6],
[70379, 5],
[70394, 6],
[70404, 1],
[70413, 2],
[70417, 2],
[70441, 1],
[70449, 1],
[70452, 1],
[70458, 1],
[70469, 2],
[70473, 2],
[70478, 2],
[70481, 6],
[70488, 5],
[70500, 2],
[70509, 3],
[70517, 139],
[70748, 1],
[70754, 30],
[70856, 8],
[70874, 166],
[71094, 2],
[71134, 34],
[71237, 11],
[71258, 6],
[71277, 19],
[71353, 7],
[71370, 54],
[71451, 2],
[71468, 4],
[71488, 192],
[71740, 100],
[71923, 12],
[71943, 2],
[71946, 2],
[71956, 1],
[71959, 1],
[71990, 1],
[71993, 2],
[72007, 9],
[72026, 70],
[72104, 2],
[72152, 2],
[72165, 27],
[72264, 8],
[72355, 29],
[72441, 263],
[72713, 1],
[72759, 1],
[72774, 10],
[72813, 3],
[72848, 2],
[72872, 1],
[72887, 73],
[72967, 1],
[72970, 1],
[73015, 3],
[73019, 1],
[73022, 1],
[73032, 8],
[73050, 6],
[73062, 1],
[73065, 1],
[73103, 1],
[73106, 1],
[73113, 7],
[73130, 310],
[73465, 183],
[73649, 15],
[73714, 13],
[74650, 102],
[74863, 1],
[74869, 11],
[75076, 2748],
[78895, 1],
[78905, 4039],
[83527, 8633],
[92729, 7],
[92767, 1],
[92778, 4],
[92784, 96],
[92910, 2],
[92918, 10],
[92998, 10],
[93018, 1],
[93026, 1],
[93048, 5],
[93072, 688],
[93851, 101],
[94027, 4],
[94088, 7],
[94112, 64],
[94181, 11],
[94194, 14],
[100344, 8],
[101590, 42],
[101641, 8951],
[110879, 49],
[110931, 17],
[110952, 8],
[111356, 2308],
[113771, 5],
[113789, 3],
[113801, 7],
[113818, 2],
[113828, 4956],
[119030, 10],
[119079, 2],
[119273, 23],
[119366, 154],
[119540, 12],
[119639, 9],
[119673, 135],
[119893, 1],
[119965, 1],
[119968, 2],
[119971, 2],
[119975, 2],
[119981, 1],
[119994, 1],
[119996, 1],
[120004, 1],
[120070, 1],
[120075, 2],
[120085, 1],
[120093, 1],
[120122, 1],
[120127, 1],
[120133, 1],
[120135, 3],
[120145, 1],
[120486, 2],
[120780, 2],
[121484, 15],
[121504, 1],
[121520, 1360],
[122887, 1],
[122905, 2],
[122914, 1],
[122917, 1],
[122923, 213],
[123181, 3],
[123198, 2],
[123210, 4],
[123216, 368],
[123642, 5],
[123648, 1280],
[125125, 2],
[125143, 41],
[125260, 4],
[125274, 4],
[125280, 785],
[126133, 76],
[126270, 194],
[126468, 1],
[126496, 1],
[126499, 1],
[126501, 2],
[126504, 1],
[126515, 1],
[126520, 1],
[126522, 1],
[126524, 6],
[126531, 4],
[126536, 1],
[126538, 1],
[126540, 1],
[126544, 1],
[126547, 1],
[126549, 2],
[126552, 1],
[126554, 1],
[126556, 1],
[126558, 1],
[126560, 1],
[126563, 1],
[126565, 2],
[126571, 1],
[126579, 1],
[126584, 1],
[126589, 1],
[126591, 1],
[126602, 1],
[126620, 5],
[126628, 1],
[126634, 1],
[126652, 52],
[126706, 270],
[127020, 4],
[127124, 12],
[127151, 2],
[127168, 1],
[127184, 1],
[127222, 10],
[127406, 56],
[127491, 13],
[127548, 4],
[127561, 7],
[127570, 14],
[127590, 154],
[128728, 8],
[128749, 3],
[128765, 3],
[128884, 12],
[128985, 7],
[129004, 20],
[129036, 4],
[129096, 8],
[129114, 6],
[129160, 8],
[129198, 2],
[129202, 78],
[129401, 1],
[129484, 1],
[129620, 12],
[129646, 2],
[129653, 3],
[129659, 5],
[129671, 9],
[129705, 7],
[129719, 9],
[129731, 13],
[129751, 41],
[129939, 1],
[129995, 37],
[130042, 1030],
[173790, 34],
[177973, 11],
[178206, 2],
[183970, 14],
[191457, 3103],
[195102, 1506],
[201547, 715958],
[917506, 30],
[917632, 128],
[918000, 65040],
[1048574, 2],
],
};
$B.unicode_casefold = {
223: [115, 115],
304: [105, 775],
329: [700, 110],
496: [106, 780],
912: [953, 776, 769],
944: [965, 776, 769],
1415: [1381, 1410],
7830: [104, 817],
7831: [116, 776],
7832: [119, 778],
7833: [121, 778],
7834: [97, 702],
7838: [223],
8016: [965, 787],
8018: [965, 787, 768],
8020: [965, 787, 769],
8022: [965, 787, 834],
8064: [7936, 953],
8065: [7937, 953],
8066: [7938, 953],
8067: [7939, 953],
8068: [7940, 953],
8069: [7941, 953],
8070: [7942, 953],
8071: [7943, 953],
8072: [8064],
8073: [8065],
8074: [8066],
8075: [8067],
8076: [8068],
8077: [8069],
8078: [8070],
8079: [8071],
8080: [7968, 953],
8081: [7969, 953],
8082: [7970, 953],
8083: [7971, 953],
8084: [7972, 953],
8085: [7973, 953],
8086: [7974, 953],
8087: [7975, 953],
8088: [8080],
8089: [8081],
8090: [8082],
8091: [8083],
8092: [8084],
8093: [8085],
8094: [8086],
8095: [8087],
8096: [8032, 953],
8097: [8033, 953],
8098: [8034, 953],
8099: [8035, 953],
8100: [8036, 953],
8101: [8037, 953],
8102: [8038, 953],
8103: [8039, 953],
8104: [8096],
8105: [8097],
8106: [8098],
8107: [8099],
8108: [8100],
8109: [8101],
8110: [8102],
8111: [8103],
8114: [8048, 953],
8115: [945, 953],
8116: [940, 953],
8118: [945, 834],
8119: [945, 834, 953],
8124: [8115],
8130: [8052, 953],
8131: [951, 953],
8132: [942, 953],
8134: [951, 834],
8135: [951, 834, 953],
8140: [8131],
8146: [953, 776, 768],
8147: [953, 776, 769],
8150: [953, 834],
8151: [953, 776, 834],
8162: [965, 776, 768],
8163: [965, 776, 769],
8164: [961, 787],
8166: [965, 834],
8167: [965, 776, 834],
8178: [8060, 953],
8179: [969, 953],
8180: [974, 953],
8182: [969, 834],
8183: [969, 834, 953],
8188: [8179],
64256: [102, 102],
64257: [102, 105],
64258: [102, 108],
64259: [102, 102, 105],
64260: [102, 102, 108],
64261: [115, 116],
64262: [115, 116],
64275: [1396, 1398],
64276: [1396, 1381],
64277: [1396, 1387],
64278: [1406, 1398],
64279: [1396, 1389],
};
$B.unicode_bidi_whitespace = [
9, 10, 11, 12, 13, 28, 29, 30, 31, 32, 133, 5760, 8192, 8193, 8194, 8195,
8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232, 8233, 8287, 12288,
];
$B.unicode_identifiers = {
XID_Start: [
95,
[65, 26],
[97, 26],
170,
181,
186,
[192, 23],
[216, 31],
[248, 458],
[710, 12],
[736, 5],
748,
750,
[880, 5],
[886, 2],
[891, 3],
895,
902,
[904, 3],
908,
[910, 20],
[931, 83],
[1015, 139],
[1162, 166],
[1329, 38],
1369,
[1376, 41],
[1488, 27],
[1519, 4],
[1568, 43],
[1646, 2],
[1649, 99],
1749,
[1765, 2],
[1774, 2],
[1786, 3],
1791,
1808,
[1810, 30],
[1869, 89],
1969,
[1994, 33],
[2036, 2],
2042,
[2048, 22],
2074,
2084,
2088,
[2112, 25],
[2144, 11],
[2208, 21],
[2230, 18],
[2308, 54],
2365,
2384,
[2392, 10],
2417,
[2418, 15],
[2437, 8],
[2447, 2],
[2451, 22],
[2474, 7],
2482,
[2486, 4],
2493,
2510,
[2524, 2],
[2527, 3],
[2544, 2],
2556,
[2565, 6],
[2575, 2],
[2579, 22],
[2602, 7],
[2610, 2],
[2613, 2],
[2616, 2],
[2649, 4],
2654,
[2674, 3],
[2693, 9],
[2703, 3],
[2707, 22],
[2730, 7],
[2738, 2],
[2741, 5],
2749,
2768,
[2784, 2],
2809,
[2821, 8],
[2831, 2],
[2835, 22],
[2858, 7],
[2866, 2],
[2869, 5],
2877,
[2908, 2],
[2911, 3],
2929,
2947,
[2949, 6],
[2958, 3],
[2962, 4],
[2969, 2],
2972,
[2974, 2],
[2979, 2],
[2984, 3],
[2990, 12],
3024,
[3077, 8],
[3086, 3],
[3090, 23],
[3114, 16],
3133,
[3160, 3],
[3168, 2],
3200,
[3205, 8],
[3214, 3],
[3218, 23],
[3242, 10],
[3253, 5],
3261,
3294,
[3296, 2],
[3313, 2],
[3332, 9],
[3342, 3],
[3346, 41],
3389,
3406,
[3412, 3],
[3423, 3],
[3450, 6],
[3461, 18],
[3482, 24],
[3507, 9],
3517,
[3520, 7],
[3585, 48],
3634,
[3648, 7],
[3713, 2],
3716,
[3718, 5],
[3724, 24],
3749,
[3751, 10],
3762,
3773,
[3776, 5],
3782,
[3804, 4],
3840,
[3904, 8],
[3913, 36],
[3976, 5],
[4096, 43],
4159,
[4176, 6],
[4186, 4],
4193,
[4197, 2],
[4206, 3],
[4213, 13],
4238,
[4256, 38],
4295,
4301,
[4304, 43],
4348,
[4349, 332],
[4682, 4],
[4688, 7],
4696,
[4698, 4],
[4704, 41],
[4746, 4],
[4752, 33],
[4786, 4],
[4792, 7],
4800,
[4802, 4],
[4808, 15],
[4824, 57],
[4882, 4],
[4888, 67],
[4992, 16],
[5024, 86],
[5112, 6],
[5121, 620],
[5743, 17],
[5761, 26],
[5792, 75],
[5870, 11],
[5888, 13],
[5902, 4],
[5920, 18],
[5952, 18],
[5984, 13],
[5998, 3],
[6016, 52],
6103,
6108,
[6176, 89],
[6272, 41],
6314,
[6320, 70],
[6400, 31],
[6480, 30],
[6512, 5],
[6528, 44],
[6576, 26],
[6656, 23],
[6688, 53],
6823,
[6917, 47],
[6981, 7],
[7043, 30],
[7086, 2],
[7098, 44],
[7168, 36],
[7245, 3],
[7258, 36],
[7296, 9],
[7312, 43],
[7357, 3],
[7401, 4],
[7406, 6],
[7413, 2],
7418,
[7424, 192],
[7680, 278],
[7960, 6],
[7968, 38],
[8008, 6],
[8016, 8],
8025,
8027,
8029,
[8031, 31],
[8064, 53],
[8118, 7],
8126,
[8130, 3],
[8134, 7],
[8144, 4],
[8150, 6],
[8160, 13],
[8178, 3],
[8182, 7],
8305,
8319,
[8336, 13],
8450,
8455,
[8458, 10],
8469,
8472,
[8473, 5],
8484,
8486,
8488,
[8490, 16],
[8508, 4],
[8517, 5],
8526,
[8544, 41],
[11264, 47],
[11312, 47],
[11360, 133],
[11499, 4],
[11506, 2],
[11520, 38],
11559,
11565,
[11568, 56],
11631,
[11648, 23],
[11680, 7],
[11688, 7],
[11696, 7],
[11704, 7],
[11712, 7],
[11720, 7],
[11728, 7],
[11736, 7],
12293,
12294,
12295,
[12321, 9],
[12337, 5],
[12344, 5],
[12353, 86],
[12445, 3],
[12449, 90],
[12540, 4],
[12549, 43],
[12593, 94],
[12704, 32],
[12784, 16],
[13312, 6592],
[19968, 20989],
[40960, 1165],
[42192, 46],
[42240, 269],
[42512, 16],
[42538, 2],
[42560, 47],
42623,
[42624, 30],
[42656, 80],
[42775, 9],
[42786, 103],
[42891, 53],
[42946, 9],
[42997, 13],
[43011, 3],
[43015, 4],
[43020, 23],
[43072, 52],
[43138, 50],
[43250, 6],
43259,
[43261, 2],
[43274, 28],
[43312, 23],
[43360, 29],
[43396, 47],
43471,
[43488, 5],
43494,
[43495, 9],
[43514, 5],
[43520, 41],
[43584, 3],
[43588, 8],
[43616, 23],
43642,
[43646, 50],
43697,
[43701, 2],
[43705, 5],
43712,
43714,
[43739, 3],
[43744, 11],
43762,
[43763, 2],
[43777, 6],
[43785, 6],
[43793, 6],
[43808, 7],
[43816, 7],
[43824, 43],
[43868, 14],
[43888, 115],
[44032, 11172],
[55216, 23],
[55243, 49],
[63744, 366],
[64112, 106],
[64256, 7],
[64275, 5],
64285,
[64287, 10],
[64298, 13],
[64312, 5],
64318,
[64320, 2],
[64323, 2],
[64326, 108],
[64467, 139],
[64612, 218],
[64848, 64],
[64914, 54],
[65008, 10],
65137,
65139,
65143,
65145,
65147,
65149,
[65151, 126],
[65313, 26],
[65345, 26],
[65382, 56],
[65440, 31],
[65474, 6],
[65482, 6],
[65490, 6],
[65498, 3],
[65536, 12],
[65549, 26],
[65576, 19],
[65596, 2],
[65599, 15],
[65616, 14],
[65664, 123],
[65856, 53],
[66176, 29],
[66208, 49],
[66304, 32],
[66349, 30],
[66384, 38],
[66432, 30],
[66464, 36],
[66504, 8],
[66513, 5],
[66560, 158],
[66736, 36],
[66776, 36],
[66816, 40],
[66864, 52],
[67072, 311],
[67392, 22],
[67424, 8],
[67584, 6],
67592,
[67594, 44],
[67639, 2],
67644,
[67647, 23],
[67680, 23],
[67712, 31],
[67808, 19],
[67828, 2],
[67840, 22],
[67872, 26],
[67968, 56],
[68030, 2],
68096,
[68112, 4],
[68117, 3],
[68121, 29],
[68192, 29],
[68224, 29],
[68288, 8],
[68297, 28],
[68352, 54],
[68416, 22],
[68448, 19],
[68480, 18],
[68608, 73],
[68736, 51],
[68800, 51],
[68864, 36],
[69248, 42],
[69296, 2],
[69376, 29],
69415,
[69424, 22],
[69552, 21],
[69600, 23],
[69635, 53],
[69763, 45],
[69840, 25],
[69891, 36],
69956,
69959,
[69968, 35],
70006,
[70019, 48],
[70081, 4],
70106,
70108,
[70144, 18],
[70163, 25],
[70272, 7],
70280,
[70282, 4],
[70287, 15],
[70303, 10],
[70320, 47],
[70405, 8],
[70415, 2],
[70419, 22],
[70442, 7],
[70450, 2],
[70453, 5],
70461,
70480,
[70493, 5],
[70656, 53],
[70727, 4],
[70751, 3],
[70784, 48],
[70852, 2],
70855,
[71040, 47],
[71128, 4],
[71168, 48],
71236,
[71296, 43],
71352,
[71424, 27],
[71680, 44],
[71840, 64],
[71935, 8],
71945,
[71948, 8],
[71957, 2],
[71960, 24],
71999,
72001,
[72096, 8],
[72106, 39],
72161,
72163,
72192,
[72203, 40],
72250,
72272,
[72284, 46],
72349,
[72384, 57],
[72704, 9],
[72714, 37],
72768,
[72818, 30],
[72960, 7],
[72968, 2],
[72971, 38],
73030,
[73056, 6],
[73063, 2],
[73066, 32],
73112,
[73440, 19],
73648,
[73728, 922],
[74752, 111],
[74880, 196],
[77824, 1071],
[82944, 583],
[92160, 569],
[92736, 31],
[92880, 30],
[92928, 48],
[92992, 4],
[93027, 21],
[93053, 19],
[93760, 64],
[93952, 75],
94032,
[94099, 13],
[94176, 2],
94179,
[94208, 6136],
[100352, 1238],
[101632, 9],
[110592, 287],
[110928, 3],
[110948, 4],
[110960, 396],
[113664, 107],
[113776, 13],
[113792, 9],
[113808, 10],
[119808, 85],
[119894, 71],
[119966, 2],
119970,
[119973, 2],
[119977, 4],
[119982, 12],
119995,
[119997, 7],
[120005, 65],
[120071, 4],
[120077, 8],
[120086, 7],
[120094, 28],
[120123, 4],
[120128, 5],
120134,
[120138, 7],
[120146, 340],
[120488, 25],
[120514, 25],
[120540, 31],
[120572, 25],
[120598, 31],
[120630, 25],
[120656, 31],
[120688, 25],
[120714, 31],
[120746, 25],
[120772, 8],
[123136, 45],
[123191, 7],
123214,
[123584, 44],
[124928, 197],
[125184, 68],
125259,
[126464, 4],
[126469, 27],
[126497, 2],
126500,
126503,
[126505, 10],
[126516, 4],
126521,
126523,
126530,
126535,
126537,
126539,
[126541, 3],
[126545, 2],
126548,
126551,
126553,
126555,
126557,
126559,
[126561, 2],
126564,
[126567, 4],
[126572, 7],
[126580, 4],
[126585, 4],
126590,
[126592, 10],
[126603, 17],
[126625, 3],
[126629, 5],
[126635, 17],
[131072, 42718],
[173824, 4149],
[177984, 222],
[178208, 5762],
[183984, 7473],
[194560, 542],
[196608, 4939],
],
XID_Continue: [
[48, 10],
[65, 26],
95,
[97, 26],
170,
181,
183,
186,
[192, 23],
[216, 31],
[248, 458],
[710, 12],
[736, 5],
748,
750,
[768, 117],
[886, 2],
[891, 3],
895,
902,
903,
[904, 3],
908,
[910, 20],
[931, 83],
[1015, 139],
[1155, 5],
[1162, 166],
[1329, 38],
1369,
[1376, 41],
[1425, 45],
1471,
[1473, 2],
[1476, 2],
1479,
[1488, 27],
[1519, 4],
[1552, 11],
[1568, 74],
[1646, 102],
1749,
[1750, 7],
[1759, 10],
[1770, 19],
1791,
1808,
1809,
[1810, 57],
[1869, 101],
[1984, 54],
2042,
2045,
[2048, 46],
[2112, 28],
[2144, 11],
[2208, 21],
[2230, 18],
[2259, 15],
[2275, 129],
[2406, 10],
2417,
[2418, 18],
[2437, 8],
[2447, 2],
[2451, 22],
[2474, 7],
2482,
[2486, 4],
2492,
2493,
[2494, 7],
[2503, 2],
[2507, 4],
2519,
[2524, 2],
[2527, 5],
[2534, 12],
2556,
2558,
[2561, 3],
[2565, 6],
[2575, 2],
[2579, 22],
[2602, 7],
[2610, 2],
[2613, 2],
[2616, 2],
2620,
[2622, 5],
[2631, 2],
[2635, 3],
2641,
[2649, 4],
2654,
[2662, 16],
[2689, 3],
[2693, 9],
[2703, 3],
[2707, 22],
[2730, 7],
[2738, 2],
[2741, 5],
2748,
2749,
[2750, 8],
[2759, 3],
[2763, 3],
2768,
[2784, 4],
[2790, 10],
2809,
[2810, 6],
2817,
[2818, 2],
[2821, 8],
[2831, 2],
[2835, 22],
[2858, 7],
[2866, 2],
[2869, 5],
2876,
2877,
2878,
2879,
2880,
[2881, 4],
[2887, 2],
[2891, 3],
[2901, 3],
[2908, 2],
[2911, 5],
[2918, 10],
2929,
2946,
2947,
[2949, 6],
[2958, 3],
[2962, 4],
[2969, 2],
2972,
[2974, 2],
[2979, 2],
[2984, 3],
[2990, 12],
[3006, 5],
[3014, 3],
[3018, 4],
3024,
3031,
[3046, 10],
3072,
[3073, 12],
[3086, 3],
[3090, 23],
[3114, 16],
3133,
[3134, 7],
[3142, 3],
[3146, 4],
[3157, 2],
[3160, 3],
[3168, 4],
[3174, 10],
3200,
3201,
[3202, 2],
[3205, 8],
[3214, 3],
[3218, 23],
[3242, 10],
[3253, 5],
3260,
3261,
3262,
3263,
[3264, 5],
3270,
[3271, 2],
[3274, 4],
[3285, 2],
3294,
[3296, 4],
[3302, 10],
[3313, 2],
[3328, 13],
[3342, 3],
[3346, 51],
[3398, 3],
[3402, 5],
[3412, 4],
[3423, 5],
[3430, 10],
[3450, 6],
3457,
[3458, 2],
[3461, 18],
[3482, 24],
[3507, 9],
3517,
[3520, 7],
3530,
[3535, 6],
3542,
[3544, 8],
[3558, 10],
[3570, 2],
[3585, 58],
[3648, 15],
[3664, 10],
[3713, 2],
3716,
[3718, 5],
[3724, 24],
3749,
[3751, 23],
[3776, 5],
3782,
[3784, 6],
[3792, 10],
[3804, 4],
3840,
[3864, 2],
[3872, 10],
3893,
3895,
3897,
[3902, 10],
[3913, 36],
[3953, 20],
[3974, 18],
[3993, 36],
4038,
[4096, 74],
[4176, 78],
[4256, 38],
4295,
4301,
[4304, 43],
4348,
[4349, 332],
[4682, 4],
[4688, 7],
4696,
[4698, 4],
[4704, 41],
[4746, 4],
[4752, 33],
[4786, 4],
[4792, 7],
4800,
[4802, 4],
[4808, 15],
[4824, 57],
[4882, 4],
[4888, 67],
[4957, 3],
[4969, 9],
[4992, 16],
[5024, 86],
[5112, 6],
[5121, 620],
[5743, 17],
[5761, 26],
[5792, 75],
[5870, 11],
[5888, 13],
[5902, 7],
[5920, 21],
[5952, 20],
[5984, 13],
[5998, 3],
[6002, 2],
[6016, 84],
6103,
6108,
6109,
[6112, 10],
[6155, 3],
[6160, 10],
[6176, 89],
[6272, 43],
[6320, 70],
[6400, 31],
[6432, 12],
[6448, 12],
[6470, 40],
[6512, 5],
[6528, 44],
[6576, 26],
[6608, 11],
[6656, 28],
[6688, 63],
6752,
6753,
6754,
[6755, 26],
6783,
[6784, 10],
[6800, 10],
6823,
[6832, 14],
[6847, 2],
[6912, 76],
[6992, 10],
[7019, 9],
[7040, 116],
[7168, 56],
[7232, 10],
[7245, 49],
[7296, 9],
[7312, 43],
[7357, 3],
[7376, 3],
[7380, 39],
[7424, 250],
[7675, 283],
[7960, 6],
[7968, 38],
[8008, 6],
[8016, 8],
8025,
8027,
8029,
[8031, 31],
[8064, 53],
[8118, 7],
8126,
[8130, 3],
[8134, 7],
[8144, 4],
[8150, 6],
[8160, 13],
[8178, 3],
[8182, 7],
[8255, 2],
8276,
8305,
8319,
[8336, 13],
[8400, 13],
8417,
[8421, 12],
8450,
8455,
[8458, 10],
8469,
8472,
[8473, 5],
8484,
8486,
8488,
[8490, 16],
[8508, 4],
[8517, 5],
8526,
[8544, 41],
[11264, 47],
[11312, 47],
[11360, 133],
[11499, 9],
[11520, 38],
11559,
11565,
[11568, 56],
11631,
11647,
[11648, 23],
[11680, 7],
[11688, 7],
[11696, 7],
[11704, 7],
[11712, 7],
[11720, 7],
[11728, 7],
[11736, 7],
[11744, 32],
12293,
12294,
12295,
[12321, 15],
[12337, 5],
[12344, 5],
[12353, 86],
[12441, 2],
[12445, 3],
[12449, 90],
[12540, 4],
[12549, 43],
[12593, 94],
[12704, 32],
[12784, 16],
[13312, 6592],
[19968, 20989],
[40960, 1165],
[42192, 46],
[42240, 269],
[42512, 28],
[42560, 48],
[42612, 10],
42623,
[42624, 114],
[42775, 9],
[42786, 103],
[42891, 53],
[42946, 9],
[42997, 51],
43052,
[43072, 52],
[43136, 70],
[43216, 10],
[43232, 24],
43259,
[43261, 49],
[43312, 36],
[43360, 29],
[43392, 65],
43471,
[43472, 10],
[43488, 31],
[43520, 55],
[43584, 14],
[43600, 10],
[43616, 23],
43642,
43643,
43644,
43645,
[43646, 69],
[43739, 3],
[43744, 16],
43762,
[43763, 4],
[43777, 6],
[43785, 6],
[43793, 6],
[43808, 7],
[43816, 7],
[43824, 43],
[43868, 14],
[43888, 123],
44012,
44013,
[44016, 10],
[44032, 11172],
[55216, 23],
[55243, 49],
[63744, 366],
[64112, 106],
[64256, 7],
[64275, 5],
64285,
64286,
[64287, 10],
[64298, 13],
[64312, 5],
64318,
[64320, 2],
[64323, 2],
[64326, 108],
[64467, 139],
[64612, 218],
[64848, 64],
[64914, 54],
[65008, 10],
[65024, 16],
[65056, 16],
[65075, 2],
[65101, 3],
65137,
65139,
65143,
65145,
65147,
65149,
[65151, 126],
[65296, 10],
[65313, 26],
65343,
[65345, 26],
[65382, 89],
[65474, 6],
[65482, 6],
[65490, 6],
[65498, 3],
[65536, 12],
[65549, 26],
[65576, 19],
[65596, 2],
[65599, 15],
[65616, 14],
[65664, 123],
[65856, 53],
66045,
[66176, 29],
[66208, 49],
66272,
[66304, 32],
[66349, 30],
[66384, 43],
[66432, 30],
[66464, 36],
[66504, 8],
[66513, 5],
[66560, 158],
[66720, 10],
[66736, 36],
[66776, 36],
[66816, 40],
[66864, 52],
[67072, 311],
[67392, 22],
[67424, 8],
[67584, 6],
67592,
[67594, 44],
[67639, 2],
67644,
[67647, 23],
[67680, 23],
[67712, 31],
[67808, 19],
[67828, 2],
[67840, 22],
[67872, 26],
[67968, 56],
[68030, 2],
68096,
[68097, 3],
[68101, 2],
[68108, 8],
[68117, 3],
[68121, 29],
[68152, 3],
68159,
[68192, 29],
[68224, 29],
[68288, 8],
[68297, 30],
[68352, 54],
[68416, 22],
[68448, 19],
[68480, 18],
[68608, 73],
[68736, 51],
[68800, 51],
[68864, 40],
[68912, 10],
[69248, 42],
[69291, 2],
[69296, 2],
[69376, 29],
69415,
[69424, 33],
[69552, 21],
[69600, 23],
69632,
69633,
69634,
[69635, 68],
[69734, 10],
[69759, 60],
[69840, 25],
[69872, 10],
[69888, 53],
[69942, 10],
69956,
[69957, 3],
[69968, 36],
70006,
[70016, 69],
[70089, 4],
70094,
70095,
[70096, 11],
70108,
[70144, 18],
[70163, 37],
70206,
[70272, 7],
70280,
[70282, 4],
[70287, 15],
[70303, 10],
[70320, 59],
[70384, 10],
[70400, 4],
[70405, 8],
[70415, 2],
[70419, 22],
[70442, 7],
[70450, 2],
[70453, 5],
[70459, 10],
[70471, 2],
[70475, 3],
70480,
70487,
[70493, 7],
[70502, 7],
[70512, 5],
[70656, 75],
[70736, 10],
70750,
[70751, 3],
[70784, 70],
70855,
[70864, 10],
[71040, 54],
[71096, 9],
[71128, 6],
[71168, 65],
71236,
[71248, 10],
[71296, 57],
[71360, 10],
[71424, 27],
[71453, 15],
[71472, 10],
[71680, 59],
[71840, 74],
[71935, 8],
71945,
[71948, 8],
[71957, 2],
[71960, 30],
[71991, 2],
[71995, 9],
[72016, 10],
[72096, 8],
[72106, 46],
[72154, 8],
72163,
72164,
72192,
[72193, 62],
72263,
72272,
[72273, 73],
72349,
[72384, 57],
[72704, 9],
[72714, 45],
[72760, 9],
[72784, 10],
[72818, 30],
[72850, 22],
72873,
[72874, 13],
[72960, 7],
[72968, 2],
[72971, 44],
73018,
[73020, 2],
[73023, 9],
[73040, 10],
[73056, 6],
[73063, 2],
[73066, 37],
[73104, 2],
[73107, 6],
[73120, 10],
[73440, 23],
73648,
[73728, 922],
[74752, 111],
[74880, 196],
[77824, 1071],
[82944, 583],
[92160, 569],
[92736, 31],
[92768, 10],
[92880, 30],
[92912, 5],
[92928, 55],
[92992, 4],
[93008, 10],
[93027, 21],
[93053, 19],
[93760, 64],
[93952, 75],
94031,
94032,
[94033, 55],
[94095, 17],
[94176, 2],
94179,
94180,
[94192, 2],
[94208, 6136],
[100352, 1238],
[101632, 9],
[110592, 287],
[110928, 3],
[110948, 4],
[110960, 396],
[113664, 107],
[113776, 13],
[113792, 9],
[113808, 10],
[113821, 2],
[119141, 5],
[119149, 6],
[119163, 8],
[119173, 7],
[119210, 4],
[119362, 3],
[119808, 85],
[119894, 71],
[119966, 2],
119970,
[119973, 2],
[119977, 4],
[119982, 12],
119995,
[119997, 7],
[120005, 65],
[120071, 4],
[120077, 8],
[120086, 7],
[120094, 28],
[120123, 4],
[120128, 5],
120134,
[120138, 7],
[120146, 340],
[120488, 25],
[120514, 25],
[120540, 31],
[120572, 25],
[120598, 31],
[120630, 25],
[120656, 31],
[120688, 25],
[120714, 31],
[120746, 25],
[120772, 8],
[120782, 50],
[121344, 55],
[121403, 50],
121461,
121476,
[121499, 5],
[121505, 15],
[122880, 7],
[122888, 17],
[122907, 7],
[122915, 2],
[122918, 5],
[123136, 45],
[123184, 14],
[123200, 10],
123214,
[123584, 58],
[124928, 197],
[125136, 7],
[125184, 76],
[125264, 10],
[126464, 4],
[126469, 27],
[126497, 2],
126500,
126503,
[126505, 10],
[126516, 4],
126521,
126523,
126530,
126535,
126537,
126539,
[126541, 3],
[126545, 2],
126548,
126551,
126553,
126555,
126557,
126559,
[126561, 2],
126564,
[126567, 4],
[126572, 7],
[126580, 4],
[126585, 4],
126590,
[126592, 10],
[126603, 17],
[126625, 3],
[126629, 5],
[126635, 17],
[130032, 10],
[131072, 42718],
[173824, 4149],
[177984, 222],
[178208, 5762],
[183984, 7473],
[194560, 542],
[196608, 4939],
[917760, 240],
],
};
$B.unicode_tables = {};
for (var gc in $B.unicode) {
$B.unicode_tables[gc] = {};
$B.unicode[gc].forEach(function (item) {
if (Array.isArray(item)) {
var step = item[2] || 1;
for (var i = 0, nb = item[1]; i < nb; i += 1) {
$B.unicode_tables[gc][item[0] + i * step] = true;
}
} else {
$B.unicode_tables[gc][item] = true;
}
});
}
for (var key in $B.unicode_identifiers) {
$B.unicode_tables[key] = {};
for (const item of $B.unicode_identifiers[key]) {
if (Array.isArray(item)) {
for (var i = 0; i < item[1]; i++) {
$B.unicode_tables[key][item[0] + i] = true;
}
} else {
$B.unicode_tables[key][item] = true;
}
}
}
$B.is_unicode_cn = function (i) {
var cn = $B.unicode.Cn;
for (var j = 0, len = cn.length; j < len; j++) {
if (i >= cn[j][0]) {
if (i < cn[j][0] + cn[j][1]) {
return true;
}
}
return false;
}
return false;
};
(function ($B) {
var _b_ = $B.builtins;
var unicode_tables = $B.unicode_tables;
$B.has_surrogate = function (s) {
for (var i = 0; i < s.length; i++) {
code = s.charCodeAt(i);
if (code >= 0xd800 && code <= 0xdbff) {
return true;
}
}
return false;
};
$B.String = function (s) {
var codepoints = [],
surrogates = [],
j = 0;
for (var i = 0, len = s.length; i < len; i++) {
var cp = s.codePointAt(i);
if (cp >= 0x10000) {
surrogates.push(j);
i++;
}
j++;
}
if (surrogates.length == 0) {
return s;
}
var res = new String(s);
res.__class__ = str;
res.surrogates = surrogates;
return res;
};
function pypos2jspos(s, pypos) {
if (s.surrogates === undefined) {
return pypos;
}
var nb = 0;
while (s.surrogates[nb] < pypos) {
nb++;
}
return pypos + nb;
}
function jspos2pypos(s, jspos) {
if (s.surrogates === undefined) {
return jspos;
}
var nb = 0;
while (s.surrogates[nb] + nb < jspos) {
nb++;
}
return jspos - nb;
}
var str = {
__class__: _b_.type,
__dir__: _b_.object.__dir__,
$infos: { __module__: "builtins", __name__: "str" },
$is_class: true,
$native: true,
};
function normalize_start_end($) {
var len;
if (typeof $.self == "string") {
len = $.self.length;
} else {
len = str.__len__($.self);
}
if ($.start === null || $.start === _b_.None) {
$.start = 0;
} else if ($.start < 0) {
$.start += len;
$.start = Math.max(0, $.start);
}
if ($.end === null || $.end === _b_.None) {
$.end = len;
} else if ($.end < 0) {
$.end += len;
$.end = Math.max(0, $.end);
}
if (!_b_.isinstance($.start, _b_.int) || !_b_.isinstance($.end, _b_.int)) {
throw _b_.TypeError.$factory(
"slice indices must be integers " +
"or None or have an __index__ method"
);
}
if ($.self.surrogates) {
$.js_start = pypos2jspos($.self, $.start);
$.js_end = pypos2jspos($.self, $.end);
}
}
function reverse(s) {
return s.split("").reverse().join("");
}
function check_str(obj, prefix) {
if (obj instanceof String || typeof obj == "string") {
return;
}
if (!_b_.isinstance(obj, str)) {
throw _b_.TypeError.$factory(
(prefix || "") + "must be str, not " + $B.class_name(obj)
);
}
}
function to_chars(s) {
var chars = [];
for (var i = 0, len = s.length; i < len; i++) {
var code = s.charCodeAt(i);
if (code >= 0xd800 && code <= 0xdbff) {
chars.push(s.substr(i, 2));
i++;
} else {
chars.push(s.charAt(i));
}
}
return chars;
}
function to_codepoints(s) {
if (s.codepoints) {
return s.codepoints;
}
var cps = [];
for (var i = 0, len = s.length; i < len; i++) {
var code = s.charCodeAt(i);
if (code >= 0xd800 && code <= 0xdbff) {
var v = 0x10000;
v += (code & 0x03ff) << 10;
v += s.charCodeAt(i + 1) & 0x03ff;
cps.push(v);
i++;
} else {
cps.push(code);
}
}
return (s.codepoints = cps);
}
str.__add__ = function (self, other) {
if (!_b_.isinstance(other, str)) {
try {
return $B.$getattr(other, "__radd__")(self);
} catch (err) {
throw _b_.TypeError.$factory(
"Can't convert " + $B.class_name(other) + " to str implicitly"
);
}
}
return $B.String(self + other);
};
str.__contains__ = function (self, item) {
if (!_b_.isinstance(item, str)) {
throw _b_.TypeError.$factory(
"'in <string>' requires " +
"string as left operand, not " +
$B.class_name(item)
);
}
if (item.__class__ === str || _b_.isinstance(item, str)) {
var nbcar = item.length;
} else {
var nbcar = _b_.len(item);
}
if (nbcar == 0) {
return true;
}
var len = self.length;
if (len == 0) {
return nbcar == 0;
}
for (var i = 0, len = self.length; i < len; i++) {
if (self.substr(i, nbcar) == item) {
return true;
}
}
return false;
};
str.__delitem__ = function () {
throw _b_.TypeError.$factory("'str' object doesn't support item deletion");
};
str.__dir__ = _b_.object.__dir__;
str.__eq__ = function (self, other) {
if (_b_.isinstance(other, _b_.str)) {
return other.valueOf() == self.valueOf();
}
return _b_.NotImplemented;
};
function preformat(self, fmt) {
if (fmt.empty) {
return _b_.str.$factory(self);
}
if (fmt.type && fmt.type != "s") {
throw _b_.ValueError.$factory(
"Unknown format code '" + fmt.type + "' for object of type 'str'"
);
}
return self;
}
str.__format__ = function (self, format_spec) {
var fmt = new $B.parse_format_spec(format_spec);
if (fmt.sign !== undefined) {
throw _b_.ValueError.$factory(
"Sign not allowed in string format specifier"
);
}
if (fmt.precision) {
self = self.substr(0, fmt.precision);
}
fmt.align = fmt.align || "<";
return $B.format_width(preformat(self, fmt), fmt);
};
str.__getitem__ = function (self, arg) {
var len = str.__len__(self);
if (_b_.isinstance(arg, _b_.int)) {
var pos = arg;
if (arg < 0) {
pos += len;
}
if (pos >= 0 && pos < len) {
var jspos = pypos2jspos(self, pos);
if (self.codePointAt(jspos) >= 0x10000) {
return $B.String(self.substr(jspos, 2));
} else {
return self[jspos];
}
}
throw _b_.IndexError.$factory("string index out of range");
}
if (_b_.isinstance(arg, _b_.slice)) {
var s = _b_.slice.$conv_for_seq(arg, len),
start = pypos2jspos(self, s.start),
stop = pypos2jspos(self, s.stop),
step = s.step;
var res = "",
i = null;
if (step > 0) {
if (stop <= start) {
return "";
}
for (var i = start; i < stop; i += step) {
res += self[i];
}
} else {
if (stop >= start) {
return "";
}
for (var i = start; i > stop; i += step) {
res += self[i];
}
}
return $B.String(res);
}
if (_b_.isinstance(arg, _b_.bool)) {
return self.__getitem__(_b_.int.$factory(arg));
}
throw _b_.TypeError.$factory("string indices must be integers");
};
var prefix = 2,
suffix = 3,
mask = 2 ** 32 - 1,
str_hash_cache = {};
str.$nb_str_hash_cache = 0;
function fnv(p) {
if (p.length == 0) {
return 0;
}
var x = prefix;
x = (x ^ (p[0] << 7)) & mask;
for (var i = 0, len = p.length; i < len; i++) {
x = ((1000003 * x) ^ p[i]) & mask;
}
x = (x ^ p.length) & mask;
x = (x ^ suffix) & mask;
if (x == -1) {
x = -2;
}
return x;
}
str.__hash__ = function (self) {
if (str_hash_cache[self] !== undefined) {
return str_hash_cache[self];
}
str.$nb_str_hash_cache++;
if (str.$nb_str_hash_cache > 100000) {
str.$nb_str_hash_cache = 0;
str_hash_cache = {};
}
try {
return (str_hash_cache[self] = fnv(to_codepoints(self)));
} catch (err) {
console.log("error hash, cps", self, to_codepoints(self));
throw err;
}
};
str.__init__ = function (self, arg) {
self.valueOf = function () {
return arg;
};
self.toString = function () {
return arg;
};
return _b_.None;
};
var str_iterator = $B.make_iterator_class("str_iterator");
str.__iter__ = function (self) {
return str_iterator.$factory(to_chars(self));
};
str.__len__ = function (self) {
if (self.surrogates === undefined) {
return self.length;
}
if (self.len !== undefined) {
return self.len;
}
var len = (self.len = self.valueOf().length - self.surrogates.length);
return len;
};
var kwarg_key = new RegExp("([^\\)]*)\\)");
var NotANumber = function () {
this.name = "NotANumber";
};
var number_check = function (s) {
if (!_b_.isinstance(s, [_b_.int, _b_.float])) {
throw new NotANumber();
}
};
var get_char_array = function (size, char) {
if (size <= 0) {
return "";
}
return new Array(size + 1).join(char);
};
var format_padding = function (s, flags, minus_one) {
var padding = flags.padding;
if (!padding) {
return s;
}
s = s.toString();
padding = parseInt(padding, 10);
if (minus_one) {
padding -= 1;
}
if (!flags.left) {
return get_char_array(padding - s.length, flags.pad_char) + s;
} else {
return s + get_char_array(padding - s.length, flags.pad_char);
}
};
var format_int_precision = function (val, flags) {
var precision = flags.precision;
if (!precision) {
return val.toString();
}
precision = parseInt(precision, 10);
var s;
if (val.__class__ === $B.long_int) {
s = $B.long_int.to_base(val, 10);
} else {
s = val.toString();
}
if (s[0] === "-") {
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1);
}
return get_char_array(precision - s.length, "0") + s;
};
var format_float_precision = function (val, upper, flags, modifier) {
var precision = flags.precision;
if (isFinite(val)) {
return modifier(val, precision, flags, upper);
}
if (val === Infinity) {
val = "inf";
} else if (val === -Infinity) {
val = "-inf";
} else {
val = "nan";
}
if (upper) {
return val.toUpperCase();
}
return val;
};
var format_sign = function (val, flags) {
if (flags.sign) {
if (val >= 0) {
return "+";
}
} else if (flags.space) {
if (val >= 0) {
return " ";
}
}
return "";
};
var str_format = function (val, flags) {
flags.pad_char = " ";
return format_padding(str.$factory(val), flags);
};
var num_format = function (val, flags) {
number_check(val);
if (val.__class__ === $B.long_int) {
val = $B.long_int.to_base(val, 10);
} else {
val = parseInt(val);
}
var s = format_int_precision(val, flags);
if (flags.pad_char === "0") {
if (val < 0) {
s = s.substring(1);
return "-" + format_padding(s, flags, true);
}
var sign = format_sign(val, flags);
if (sign !== "") {
return sign + format_padding(s, flags, true);
}
}
return format_padding(format_sign(val, flags) + s, flags);
};
var repr_format = function (val, flags) {
flags.pad_char = " ";
return format_padding(_b_.repr(val), flags);
};
var ascii_format = function (val, flags) {
flags.pad_char = " ";
return format_padding(_b_.ascii(val), flags);
};
var _float_helper = function (val, flags) {
number_check(val);
if (!flags.precision) {
if (!flags.decimal_point) {
flags.precision = 6;
} else {
flags.precision = 0;
}
} else {
flags.precision = parseInt(flags.precision, 10);
validate_precision(flags.precision);
}
return parseFloat(val);
};
var trailing_zeros = /(.*?)(0+)([eE].*)/,
leading_zeros = /\.(0*)/,
trailing_dot = /\.$/;
var validate_precision = function (precision) {
if (precision > 20) {
precision = 20;
}
};
var floating_point_format = function (val, upper, flags) {
(val = _float_helper(val, flags)),
(v = val.toString()),
(v_len = v.length),
(dot_idx = v.indexOf("."));
if (dot_idx < 0) {
dot_idx = v_len;
}
if (val < 1 && val > -1) {
var zeros = leading_zeros.exec(v),
numzeros;
if (zeros) {
numzeros = zeros[1].length;
} else {
numzeros = 0;
}
if (numzeros >= 4) {
val =
format_sign(val, flags) +
format_float_precision(val, upper, flags, _floating_g_exp_helper);
if (!flags.alternate) {
var trl = trailing_zeros.exec(val);
if (trl) {
val = trl[1].replace(trailing_dot, "") + trl[3];
}
} else {
if (flags.precision <= 1) {
val = val[0] + "." + val.substring(1);
}
}
return format_padding(val, flags);
}
flags.precision = (flags.precision || 0) + numzeros;
return format_padding(
format_sign(val, flags) +
format_float_precision(val, upper, flags, function (val, precision) {
return val.toFixed(_b_.min(precision, v_len - dot_idx) + numzeros);
}),
flags
);
}
if (dot_idx > flags.precision) {
val =
format_sign(val, flags) +
format_float_precision(val, upper, flags, _floating_g_exp_helper);
if (!flags.alternate) {
var trl = trailing_zeros.exec(val);
if (trl) {
val = trl[1].replace(trailing_dot, "") + trl[3];
}
} else {
if (flags.precision <= 1) {
val = val[0] + "." + val.substring(1);
}
}
return format_padding(val, flags);
}
return format_padding(
format_sign(val, flags) +
format_float_precision(val, upper, flags, function (val, precision) {
if (!flags.decimal_point) {
precision = _b_.min(v_len - 1, 6);
} else if (precision > v_len) {
if (!flags.alternate) {
precision = v_len;
}
}
if (precision < dot_idx) {
precision = dot_idx;
}
return val.toFixed(precision - dot_idx);
}),
flags
);
};
var _floating_g_exp_helper = function (val, precision, flags, upper) {
if (precision) {
--precision;
}
val = val.toExponential(precision);
var e_idx = val.lastIndexOf("e");
if (e_idx > val.length - 4) {
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2);
}
if (upper) {
return val.toUpperCase();
}
return val;
};
var floating_point_decimal_format = function (val, upper, flags) {
val = _float_helper(val, flags);
return format_padding(
format_sign(val, flags) +
format_float_precision(
val,
upper,
flags,
function (val, precision, flags) {
val = val.toFixed(precision);
if (precision === 0 && flags.alternate) {
val += ".";
}
return val;
}
),
flags
);
};
var _floating_exp_helper = function (val, precision, flags, upper) {
val = val.toExponential(precision);
var e_idx = val.lastIndexOf("e");
if (e_idx > val.length - 4) {
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2);
}
if (upper) {
return val.toUpperCase();
}
return val;
};
var floating_point_exponential_format = function (val, upper, flags) {
val = _float_helper(val, flags);
return format_padding(
format_sign(val, flags) +
format_float_precision(val, upper, flags, _floating_exp_helper),
flags
);
};
var signed_hex_format = function (val, upper, flags) {
var ret;
number_check(val);
if (val.__class__ === $B.long_int) {
ret = $B.long_int.to_base(val, 16);
} else {
ret = parseInt(val);
ret = ret.toString(16);
}
ret = format_int_precision(ret, flags);
if (upper) {
ret = ret.toUpperCase();
}
if (flags.pad_char === "0") {
if (val < 0) {
ret = ret.substring(1);
ret = "-" + format_padding(ret, flags, true);
}
var sign = format_sign(val, flags);
if (sign !== "") {
ret = sign + format_padding(ret, flags, true);
}
}
if (flags.alternate) {
if (ret.charAt(0) === "-") {
if (upper) {
ret = "-0X" + ret.slice(1);
} else {
ret = "-0x" + ret.slice(1);
}
} else {
if (upper) {
ret = "0X" + ret;
} else {
ret = "0x" + ret;
}
}
}
return format_padding(format_sign(val, flags) + ret, flags);
};
var octal_format = function (val, flags) {
number_check(val);
var ret;
if (val.__class__ === $B.long_int) {
ret = $B.long_int.to_base(8);
} else {
ret = parseInt(val);
ret = ret.toString(8);
}
ret = format_int_precision(ret, flags);
if (flags.pad_char === "0") {
if (val < 0) {
ret = ret.substring(1);
ret = "-" + format_padding(ret, flags, true);
}
var sign = format_sign(val, flags);
if (sign !== "") {
ret = sign + format_padding(ret, flags, true);
}
}
if (flags.alternate) {
if (ret.charAt(0) === "-") {
ret = "-0o" + ret.slice(1);
} else {
ret = "0o" + ret;
}
}
return format_padding(ret, flags);
};
function series_of_bytes(val, flags) {
if (val.__class__ && val.__class__.$buffer_protocol) {
var it = _b_.iter(val),
ints = [];
while (true) {
try {
ints.push(_b_.next(it));
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
var b = _b_.bytes.$factory(ints);
return format_padding(_b_.bytes.decode(b, "ascii"), flags);
}
throw err;
}
}
} else {
try {
bytes_obj = $B.$getattr(val, "__bytes__");
return format_padding(_b_.bytes.decode(bytes_obj), flags);
} catch (err) {
if (err.__class__ === _b_.AttributeError) {
throw _b_.TypeError.$factory(
"%b does not accept '" + $B.class_name(val) + "'"
);
}
throw err;
}
}
}
var single_char_format = function (val, flags) {
if (_b_.isinstance(val, str) && val.length == 1) {
return val;
} else if (_b_.isinstance(val, _b_.bytes) && val.source.length == 1) {
val = val.source[0];
} else {
try {
val = _b_.int.$factory(val);
} catch (err) {
throw _b_.TypeError.$factory("%c requires int or char");
}
}
return format_padding(_b_.chr(val), flags);
};
var num_flag = function (c, flags) {
if (c === "0" && !flags.padding && !flags.decimal_point && !flags.left) {
flags.pad_char = "0";
return;
}
if (!flags.decimal_point) {
flags.padding = (flags.padding || "") + c;
} else {
flags.precision = (flags.precision || "") + c;
}
};
var decimal_point_flag = function (val, flags) {
if (flags.decimal_point) {
throw new UnsupportedChar();
}
flags.decimal_point = true;
};
var neg_flag = function (val, flags) {
flags.pad_char = " ";
flags.left = true;
};
var space_flag = function (val, flags) {
flags.space = true;
};
var sign_flag = function (val, flags) {
flags.sign = true;
};
var alternate_flag = function (val, flags) {
flags.alternate = true;
};
var char_mapping = {
b: series_of_bytes,
s: str_format,
d: num_format,
i: num_format,
u: num_format,
o: octal_format,
r: repr_format,
a: ascii_format,
g: function (val, flags) {
return floating_point_format(val, false, flags);
},
G: function (val, flags) {
return floating_point_format(val, true, flags);
},
f: function (val, flags) {
return floating_point_decimal_format(val, false, flags);
},
F: function (val, flags) {
return floating_point_decimal_format(val, true, flags);
},
e: function (val, flags) {
return floating_point_exponential_format(val, false, flags);
},
E: function (val, flags) {
return floating_point_exponential_format(val, true, flags);
},
x: function (val, flags) {
return signed_hex_format(val, false, flags);
},
X: function (val, flags) {
return signed_hex_format(val, true, flags);
},
c: single_char_format,
0: function (val, flags) {
return num_flag("0", flags);
},
1: function (val, flags) {
return num_flag("1", flags);
},
2: function (val, flags) {
return num_flag("2", flags);
},
3: function (val, flags) {
return num_flag("3", flags);
},
4: function (val, flags) {
return num_flag("4", flags);
},
5: function (val, flags) {
return num_flag("5", flags);
},
6: function (val, flags) {
return num_flag("6", flags);
},
7: function (val, flags) {
return num_flag("7", flags);
},
8: function (val, flags) {
return num_flag("8", flags);
},
9: function (val, flags) {
return num_flag("9", flags);
},
"-": neg_flag,
" ": space_flag,
"+": sign_flag,
".": decimal_point_flag,
"#": alternate_flag,
};
var UnsupportedChar = function () {
this.name = "UnsupportedChar";
};
str.__mod__ = function (self, args) {
var length = self.length,
pos = 0 | 0,
argpos = null,
getitem;
if (_b_.isinstance(args, _b_.tuple)) {
argpos = 0 | 0;
} else {
getitem = $B.$getattr(args, "__getitem__", _b_.None);
}
var ret = "";
var $get_kwarg_string = function (s) {
++pos;
var rslt = kwarg_key.exec(s.substring(newpos));
if (!rslt) {
throw _b_.ValueError.$factory("incomplete format key");
}
var key = rslt[1];
newpos += rslt[0].length;
try {
var self = getitem(key);
} catch (err) {
if (err.__class__ === _b_.KeyError) {
throw err;
}
throw _b_.TypeError.$factory("format requires a mapping");
}
return get_string_value(s, self);
};
var $get_arg_string = function (s) {
var self;
if (argpos === null) {
self = args;
} else {
self = args[argpos++];
if (self === undefined) {
throw _b_.TypeError.$factory(
"not enough arguments for format string"
);
}
}
return get_string_value(s, self);
};
var get_string_value = function (s, self) {
var flags = { pad_char: " " };
do {
var func = char_mapping[s[newpos]];
try {
if (func === undefined) {
throw new UnsupportedChar();
} else {
var ret = func(self, flags);
if (ret !== undefined) {
return ret;
}
++newpos;
}
} catch (err) {
if (err.name == "UnsupportedChar") {
invalid_char = s[newpos];
if (invalid_char === undefined) {
throw _b_.ValueError.$factory("incomplete format");
}
throw _b_.ValueError.$factory(
"unsupported format character '" +
invalid_char +
"' (0x" +
invalid_char.charCodeAt(0).toString(16) +
") at index " +
newpos
);
} else if (err.name === "NotANumber") {
var try_char = s[newpos],
cls = self.__class__;
if (!cls) {
if (typeof self === "string") {
cls = "str";
} else {
cls = typeof self;
}
} else {
cls = cls.$infos.__name__;
}
throw _b_.TypeError.$factory(
"%" + try_char + " format: a number is required, not " + cls
);
} else {
throw err;
}
}
} while (true);
};
var nbph = 0;
do {
var newpos = self.indexOf("%", pos);
if (newpos < 0) {
ret += self.substring(pos);
break;
}
ret += self.substring(pos, newpos);
++newpos;
if (newpos < length) {
if (self[newpos] === "%") {
ret += "%";
} else {
nbph++;
if (self[newpos] === "(") {
++newpos;
ret += $get_kwarg_string(self);
} else {
ret += $get_arg_string(self);
}
}
} else {
throw _b_.ValueError.$factory("incomplete format");
}
pos = newpos + 1;
} while (pos < length);
if (argpos !== null) {
if (args.length > argpos) {
throw _b_.TypeError.$factory("not enough arguments for format string");
} else if (args.length < argpos) {
throw _b_.TypeError.$factory(
"not all arguments converted during string formatting"
);
}
} else if (nbph == 0) {
throw _b_.TypeError.$factory(
"not all arguments converted during string formatting"
);
}
return ret;
};
str.__mro__ = [_b_.object];
str.__mul__ = function () {
var $ = $B.args(
"__mul__",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
);
if (!_b_.isinstance($.other, _b_.int)) {
throw _b_.TypeError.$factory(
"Can't multiply sequence by non-int of type '" +
$B.class_name($.other) +
"'"
);
}
return $.self.valueOf().repeat($.other < 0 ? 0 : $.other);
};
str.__ne__ = function (self, other) {
return other.valueOf() !== self.valueOf();
};
function __newobj__() {
var $ = $B.args("__newobj__", 0, {}, [], arguments, {}, "args", null),
args = $.args;
var res = args[1];
res.__class__ = args[0];
return res;
}
str.__reduce_ex__ = function (self) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__ || _b_.str, self]),
_b_.None,
_b_.None,
]);
};
str.__repr__ = function (self) {
var t = $B.special_string_repr,
repl = "",
chars = to_chars(self);
for (var i = 0; i < chars.length; i++) {
var cp = _b_.ord(chars[i]);
if (t[cp] !== undefined) {
repl += t[cp];
} else if ($B.is_unicode_cn(cp)) {
var s = cp.toString(16);
while (s.length < 4) {
s = "0" + s;
}
repl += "\\u" + s;
} else if (cp < 0x20 || (cp >= 0x7f && cp < 0xa0)) {
cp = cp.toString(16);
if (cp.length < 2) {
cp = "0" + cp;
}
repl += "\\x" + cp;
} else if (cp >= 0x300 && cp <= 0x36f) {
repl += "\u200B" + chars[i] + " ";
} else if (cp.toString(16) == "feff") {
repl += "\\ufeff";
} else {
repl += chars[i];
}
}
var res = repl;
if (res.search('"') == -1 && res.search("'") == -1) {
return "'" + res + "'";
} else if (self.search('"') == -1) {
return '"' + res + '"';
}
var qesc = new RegExp("'", "g");
res = "'" + res.replace(qesc, "\\'") + "'";
return res;
};
str.__rmod__ = function () {
var $ = $B.args(
"__rmod__",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
);
return str.__mod__($.other, $.self);
};
str.__rmul__ = function (self, other) {
if (_b_.isinstance(other, _b_.int)) {
other = _b_.int.numerator(other);
var res = "";
while (other > 0) {
res += self;
other--;
}
return res;
}
return _b_.NotImplemented;
};
str.__setattr__ = function (self, attr, value) {
if (typeof self === "string") {
if (str.hasOwnProperty(attr)) {
throw _b_.AttributeError.$factory(
"'str' object attribute '" + attr + "' is read-only"
);
} else {
throw _b_.AttributeError.$factory(
"'str' object has no attribute '" + attr + "'"
);
}
}
_b_.dict.$setitem(self.__dict__, attr, value);
return $N;
};
str.__setitem__ = function (self, attr, value) {
throw _b_.TypeError.$factory(
"'str' object does not support item assignment"
);
};
var combining = [];
for (var cp = 0x300; cp <= 0x36f; cp++) {
combining.push(String.fromCharCode(cp));
}
var combining_re = new RegExp("(" + combining.join("|") + ")", "g");
str.__str__ = function (self) {
var repl = "",
chars = to_chars(self);
if (chars.length == self.length) {
return self.replace(combining_re, "\u200B$1");
}
for (var i = 0; i < chars.length; i++) {
var cp = _b_.ord(chars[i]);
if (cp >= 0x300 && cp <= 0x36f) {
repl += "\u200B" + chars[i];
} else {
repl += chars[i];
}
}
return repl;
};
str.toString = function () {
return "string!";
};
var $comp_func = function (self, other) {
if (typeof other !== "string") {
return _b_.NotImplemented;
}
return self > other;
};
$comp_func += "";
var $comps = { ">": "gt", ">=": "ge", "<": "lt", "<=": "le" };
for (var $op in $comps) {
eval("str.__" + $comps[$op] + "__ = " + $comp_func.replace(/>/gm, $op));
}
var $notimplemented = function (self, other) {
throw _b_.NotImplementedError.$factory(
"OPERATOR not implemented for class str"
);
};
str.capitalize = function (self) {
var $ = $B.args(
"capitalize",
1,
{ self },
["self"],
arguments,
{},
null,
null
);
if (self.length == 0) {
return "";
}
return self.charAt(0).toUpperCase() + self.substr(1);
};
str.casefold = function (self) {
var $ = $B.args(
"casefold",
1,
{ self },
["self"],
arguments,
{},
null,
null
),
res = "",
char,
cf,
chars = to_chars($.self);
for (var i = 0, len = chars.length; i < len; i++) {
char = chars[i];
cf = $B.unicode_casefold[char];
if (cf) {
cf.forEach(function (cp) {
res += String.fromCharCode(cp);
});
} else {
res += char.toLowerCase();
}
}
return res;
};
str.center = function () {
var $ = $B.args(
"center",
3,
{ self: null, width: null, fillchar: null },
["self", "width", "fillchar"],
arguments,
{ fillchar: " " },
null,
null
),
self = $.self;
if ($.width <= self.length) {
return self;
}
var pad = parseInt(($.width - self.length) / 2),
res = $.fillchar.repeat(pad);
res += self + res;
if (res.length < $.width) {
res += $.fillchar;
}
return res;
};
str.count = function () {
var $ = $B.args(
"count",
4,
{ self: null, sub: null, start: null, stop: null },
["self", "sub", "start", "stop"],
arguments,
{ start: null, stop: null },
null,
null
);
if (!(typeof $.sub.valueOf() == "string")) {
throw _b_.TypeError.$factory(
"Can't convert '" + $B.class_name($.sub) + "' object to str implicitly"
);
}
var substr = $.self;
if ($.start !== null) {
var _slice;
if ($.stop !== null) {
_slice = _b_.slice.$factory($.start, $.stop);
} else {
_slice = _b_.slice.$factory($.start, $.self.length);
}
substr = str.__getitem__.apply(null, [$.self].concat(_slice));
} else {
if ($.self.length + $.sub.length == 0) {
return 1;
}
}
if ($.sub.length == 0) {
if ($.start == $.self.length) {
return 1;
} else if (substr.length == 0) {
return 0;
}
return substr.length + 1;
}
var n = 0,
pos = 0;
while (pos < substr.length) {
pos = substr.indexOf($.sub, pos);
if (pos >= 0) {
n++;
pos += $.sub.length;
} else {
break;
}
}
return n;
};
str.encode = function () {
var $ = $B.args(
"encode",
3,
{ self: null, encoding: null, errors: null },
["self", "encoding", "errors"],
arguments,
{ encoding: "utf-8", errors: "strict" },
null,
null
);
if ($.encoding == "rot13" || $.encoding == "rot_13") {
var res = "";
for (var i = 0, len = $.self.length; i < len; i++) {
var char = $.self.charAt(i);
if (("a" <= char && char <= "m") || ("A" <= char && char <= "M")) {
res += String.fromCharCode(String.charCodeAt(char) + 13);
} else if (("m" < char && char <= "z") || ("M" < char && char <= "Z")) {
res += String.fromCharCode(String.charCodeAt(char) - 13);
} else {
res += char;
}
}
return res;
}
return _b_.bytes.__new__(_b_.bytes, $.self, $.encoding, $.errors);
};
str.endswith = function () {
var $ = $B.args(
"endswith",
4,
{ self: null, suffix: null, start: null, end: null },
["self", "suffix", "start", "end"],
arguments,
{ start: 0, end: null },
null,
null
);
normalize_start_end($);
var suffixes = $.suffix;
if (!_b_.isinstance(suffixes, _b_.tuple)) {
suffixes = [suffixes];
}
var chars = to_chars($.self),
s = chars.slice($.start, $.end);
for (var i = 0, len = suffixes.length; i < len; i++) {
var suffix = suffixes[i];
if (!_b_.isinstance(suffix, str)) {
throw _b_.TypeError.$factory(
"endswith first arg must be str or a tuple of str, not int"
);
}
if (
suffix.length <= s.length &&
s.slice(s.length - suffix.length).join("") == suffix
) {
return true;
}
}
return false;
};
str.expandtabs = function (self, tabsize) {
var $ = $B.args(
"expandtabs",
2,
{ self: null, tabsize: null },
["self", "tabsize"],
arguments,
{ tabsize: 8 },
null,
null
);
var s = $B.$GetInt($.tabsize),
col = 0,
pos = 0,
res = "",
chars = to_chars(self);
if (s == 1) {
return self.replace(/\t/g, " ");
}
while (pos < chars.length) {
var car = chars[pos];
switch (car) {
case "\t":
while (col % s > 0) {
res += " ";
col++;
}
break;
case "\r":
case "\n":
res += car;
col = 0;
break;
default:
res += car;
col++;
break;
}
pos++;
}
return res;
};
str.find = function () {
var $ = $B.args(
"str.find",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: null },
null,
null
);
check_str($.sub);
normalize_start_end($);
var len = str.__len__($.self),
sub_len = str.__len__($.sub);
if (sub_len == 0 && $.start == len) {
return len;
}
if (len + sub_len == 0) {
return -1;
}
var js_start = pypos2jspos($.self, $.start),
js_end = pypos2jspos($.self, $.end),
ix = $.self.substring(js_start, js_end).indexOf($.sub);
if (ix == -1) {
return -1;
}
return jspos2pypos($.self, js_start + ix);
};
$B.parse_format = function (fmt_string) {
var elts = fmt_string.split(":"),
name,
conv,
spec,
name_ext = [];
if (elts.length == 1) {
name = fmt_string;
} else {
name = elts[0];
spec = elts.splice(1).join(":");
}
var elts = name.split("!");
if (elts.length > 1) {
name = elts[0];
conv = elts[1];
}
if (name !== undefined) {
function name_repl(match) {
name_ext.push(match);
return "";
}
var name_ext_re =
/\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g;
name = name.replace(name_ext_re, name_repl);
}
return {
name: name,
name_ext: name_ext,
conv: conv,
spec: spec || "",
string: fmt_string,
};
};
$B.split_format = function (self) {
var pos = 0,
_len = self.length,
car,
text = "",
parts = [],
rank = 0;
while (pos < _len) {
car = self.charAt(pos);
if (car == "{" && self.charAt(pos + 1) == "{") {
text += "{";
pos += 2;
} else if (car == "}" && self.charAt(pos + 1) == "}") {
text += "}";
pos += 2;
} else if (car == "{") {
parts.push(text);
var end = pos + 1,
nb = 1;
while (end < _len) {
if (self.charAt(end) == "{") {
nb++;
end++;
} else if (self.charAt(end) == "}") {
nb--;
end++;
if (nb == 0) {
var fmt_string = self.substring(pos + 1, end - 1);
var fmt_obj = $B.parse_format(fmt_string);
fmt_obj.raw_name = fmt_obj.name;
fmt_obj.raw_spec = fmt_obj.spec;
if (!fmt_obj.name) {
fmt_obj.name = rank + "";
rank++;
}
if (fmt_obj.spec !== undefined) {
function replace_nested(name, key) {
if (key == "") {
return "{" + rank++ + "}";
}
return "{" + key + "}";
}
fmt_obj.spec = fmt_obj.spec.replace(
/\{(.*?)\}/g,
replace_nested
);
}
parts.push(fmt_obj);
text = "";
break;
}
} else {
end++;
}
}
if (nb > 0) {
throw _b_.ValueError.$factory("wrong format " + self);
}
pos = end;
} else {
text += car;
pos++;
}
}
if (text) {
parts.push(text);
}
return parts;
};
str.format = function (self) {
var last_arg = $B.last(arguments);
if (last_arg.$nat == "mapping") {
var mapping = last_arg.mapping,
getitem = $B.$getattr(mapping, "__getitem__");
var args = [];
for (var i = 0, len = arguments.length - 1; i < len; i++) {
args.push(arguments[i]);
}
var $ = $B.args(
"format",
1,
{ self: null },
["self"],
args,
{},
"$args",
null
);
} else {
var $ = $B.args(
"format",
1,
{ self: null },
["self"],
arguments,
{},
"$args",
"$kw"
),
mapping = $.$kw,
getitem = function (key) {
return _b_.dict.$getitem(mapping, key);
};
}
var parts = $B.split_format($.self);
var res = "",
fmt;
for (var i = 0; i < parts.length; i++) {
if (typeof parts[i] == "string") {
res += parts[i];
continue;
}
fmt = parts[i];
if (fmt.spec !== undefined) {
function replace_nested(name, key) {
if (/\d+/.exec(key)) {
return _b_.tuple.__getitem__($.$args, parseInt(key));
} else {
return _b_.dict.__getitem__($.$kw, key);
}
}
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g, replace_nested);
}
if (fmt.name.charAt(0).search(/\d/) > -1) {
var pos = parseInt(fmt.name),
value = _b_.tuple.__getitem__($.$args, pos);
} else {
var value = getitem(fmt.name);
}
for (var j = 0; j < fmt.name_ext.length; j++) {
var ext = fmt.name_ext[j];
if (ext.charAt(0) == ".") {
value = $B.$getattr(value, ext.substr(1));
} else {
var key = ext.substr(1, ext.length - 2);
if (key.charAt(0).search(/\d/) > -1) {
key = parseInt(key);
}
value = $B.$getattr(value, "__getitem__")(key);
}
}
if (fmt.conv == "a") {
value = _b_.ascii(value);
} else if (fmt.conv == "r") {
value = _b_.repr(value);
} else if (fmt.conv == "s") {
value = _b_.str.$factory(value);
}
if (value.$is_class || value.$factory) {
res += value.__class__.__format__(value, fmt.spec);
} else {
res += $B.$getattr(value, "__format__")(fmt.spec);
}
}
return res;
};
str.format_map = function (self, mapping) {
var $ = $B.args(
"format_map",
2,
{ self: null, mapping: null },
["self", "mapping"],
arguments,
{},
null,
null
);
return str.format(self, { $nat: "mapping", mapping });
};
str.index = function (self) {
var res = str.find.apply(null, arguments);
if (res === -1) {
throw _b_.ValueError.$factory("substring not found");
}
return res;
};
str.isascii = function (self) {
for (var i = 0, len = self.length; i < len; i++) {
if (self.charCodeAt(i) > 127) {
return false;
}
}
return true;
};
str.isalnum = function (self) {
var $ = $B.args(
"isalnum",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (
unicode_tables.Ll[cp] ||
unicode_tables.Lu[cp] ||
unicode_tables.Lm[cp] ||
unicode_tables.Lt[cp] ||
unicode_tables.Lo[cp] ||
unicode_tables.Nd[cp] ||
unicode_tables.digits[cp] ||
unicode_tables.numeric[cp]
) {
continue;
}
return false;
}
return true;
};
str.isalpha = function (self) {
var $ = $B.args(
"isalpha",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (
unicode_tables.Ll[cp] ||
unicode_tables.Lu[cp] ||
unicode_tables.Lm[cp] ||
unicode_tables.Lt[cp] ||
unicode_tables.Lo[cp]
) {
continue;
}
return false;
}
return true;
};
str.isdecimal = function (self) {
var $ = $B.args(
"isdecimal",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (!unicode_tables.Nd[cp]) {
return false;
}
}
return self.length > 0;
};
str.isdigit = function (self) {
var $ = $B.args(
"isdigit",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (!unicode_tables.digits[cp]) {
return false;
}
}
return self.length > 0;
};
str.isidentifier = function (self) {
var $ = $B.args(
"isidentifier",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
if (self.length == 0) {
return false;
}
var chars = to_chars(self);
if (unicode_tables.XID_Start[_b_.ord(chars[0])] === undefined) {
return false;
} else {
for (var char of chars) {
var cp = _b_.ord(char);
if (unicode_tables.XID_Continue[cp] === undefined) {
return false;
}
}
}
return true;
};
str.islower = function (self) {
var $ = $B.args(
"islower",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
has_cased = false,
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (unicode_tables.Ll[cp]) {
has_cased = true;
continue;
} else if (unicode_tables.Lu[cp] || unicode_tables.Lt[cp]) {
return false;
}
}
return has_cased;
};
str.isnumeric = function (self) {
var $ = $B.args(
"isnumeric",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
for (var char of to_chars(self)) {
if (!unicode_tables.numeric[_b_.ord(char)]) {
return false;
}
}
return self.length > 0;
};
var unprintable = {},
unprintable_gc = ["Cc", "Cf", "Co", "Cs", "Zl", "Zp", "Zs"];
str.isprintable = function (self) {
if (Object.keys(unprintable).length == 0) {
for (var i = 0; i < unprintable_gc.length; i++) {
var table = unicode_tables[unprintable_gc[i]];
for (var cp in table) {
unprintable[cp] = true;
}
}
unprintable[32] = true;
}
var $ = $B.args(
"isprintable",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
for (var char of to_chars(self)) {
if (unprintable[_b_.ord(char)]) {
return false;
}
}
return true;
};
str.isspace = function (self) {
var $ = $B.args(
"isspace",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (
!unicode_tables.Zs[cp] &&
$B.unicode_bidi_whitespace.indexOf(cp) == -1
) {
return false;
}
}
return self.length > 0;
};
str.istitle = function (self) {
var $ = $B.args(
"istitle",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
return self.length > 0 && str.title(self) == self;
};
str.isupper = function (self) {
var $ = $B.args(
"islower",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
is_upper = false,
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (unicode_tables.Lu[cp]) {
is_upper = true;
continue;
} else if (unicode_tables.Ll[cp] || unicode_tables.Lt[cp]) {
return false;
}
}
return is_upper;
};
str.join = function () {
var $ = $B.args(
"join",
2,
{ self: null, iterable: null },
["self", "iterable"],
arguments,
{},
null,
null
);
var iterable = _b_.iter($.iterable),
res = [],
count = 0;
while (1) {
try {
var obj2 = _b_.next(iterable);
if (!_b_.isinstance(obj2, str)) {
throw _b_.TypeError.$factory(
"sequence item " +
count +
": expected str instance, " +
$B.class_name(obj2) +
" found"
);
}
res.push(obj2);
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
} else {
throw err;
}
}
}
return res.join($.self);
};
str.ljust = function (self) {
var $ = $B.args(
"ljust",
3,
{ self: null, width: null, fillchar: null },
["self", "width", "fillchar"],
arguments,
{ fillchar: " " },
null,
null
),
len = str.__len__(self);
if ($.width <= len) {
return self;
}
return self + $.fillchar.repeat($.width - len);
};
str.lower = function (self) {
var $ = $B.args(
"lower",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
return self.toLowerCase();
};
str.lstrip = function (self, x) {
var $ = $B.args(
"lstrip",
2,
{ self: null, chars: null },
["self", "chars"],
arguments,
{ chars: _b_.None },
null,
null
),
self = $.self,
chars = $.chars;
if (chars === _b_.None) {
return self.trimStart();
}
while (self.length > 0) {
var flag = false;
for (var char of chars) {
if (self.startsWith(char)) {
self = self.substr(char.length);
flag = true;
break;
}
}
if (!flag) {
return $.self.surrogates ? $B.String(self) : self;
}
}
return "";
};
str.maketrans = function () {
var $ = $B.args(
"maketrans",
3,
{ x: null, y: null, z: null },
["x", "y", "z"],
arguments,
{ y: null, z: null },
null,
null
);
var _t = $B.empty_dict();
if ($.y === null && $.z === null) {
if (!_b_.isinstance($.x, _b_.dict)) {
throw _b_.TypeError.$factory("maketrans only argument must be a dict");
}
var items = _b_.list.$factory(_b_.dict.items($.x));
for (var i = 0, len = items.length; i < len; i++) {
var k = items[i][0],
v = items[i][1];
if (!_b_.isinstance(k, _b_.int)) {
if (_b_.isinstance(k, _b_.str) && k.length == 1) {
k = _b_.ord(k);
} else {
throw _b_.TypeError.$factory(
"dictionary key " + k + " is not int or 1-char string"
);
}
}
if (v !== _b_.None && !_b_.isinstance(v, [_b_.int, _b_.str])) {
throw _b_.TypeError.$factory(
"dictionary value " + v + " is not None, integer or string"
);
}
_b_.dict.$setitem(_t, k, v);
}
return _t;
} else {
if (!(_b_.isinstance($.x, _b_.str) && _b_.isinstance($.y, _b_.str))) {
throw _b_.TypeError.$factory("maketrans arguments must be strings");
} else if ($.x.length !== $.y.length) {
throw _b_.TypeError.$factory(
"maketrans arguments must be strings or same length"
);
} else {
var toNone = {};
if ($.z !== null) {
if (!_b_.isinstance($.z, _b_.str)) {
throw _b_.TypeError.$factory(
"maketrans third argument must be a string"
);
}
for (var i = 0, len = $.z.length; i < len; i++) {
toNone[_b_.ord($.z.charAt(i))] = true;
}
}
for (var i = 0, len = $.x.length; i < len; i++) {
var key = _b_.ord($.x.charAt(i)),
value = $.y.charCodeAt(i);
_b_.dict.$setitem(_t, key, value);
}
for (var k in toNone) {
_b_.dict.$setitem(_t, parseInt(k), _b_.None);
}
return _t;
}
}
};
str.maketrans.$type = "staticmethod";
str.partition = function () {
var $ = $B.args(
"partition",
2,
{ self: null, sep: null },
["self", "sep"],
arguments,
{},
null,
null
);
if ($.sep == "") {
throw _b_.ValueError.$factory("empty separator");
}
check_str($.sep);
var chars = to_chars($.self),
i = $.self.indexOf($.sep);
if (i == -1) {
return _b_.tuple.$factory([$.self, "", ""]);
}
return _b_.tuple.$factory([
chars.slice(0, i).join(""),
$.sep,
chars.slice(i + $.sep.length).join(""),
]);
};
str.removeprefix = function () {
var $ = $B.args(
"removeprefix",
2,
{ self: null, prefix: null },
["self", "prefix"],
arguments,
{},
null,
null
);
if (!_b_.isinstance($.prefix, str)) {
throw _b_.ValueError.$factory(
"prefix should be str, not " + `'${$B.class_name($.prefix)}'`
);
}
if (str.startswith($.self, $.prefix)) {
return $.self.substr($.prefix.length);
}
return $.self.substr(0);
};
str.removesuffix = function () {
var $ = $B.args(
"removesuffix",
2,
{ self: null, prefix: null },
["self", "suffix"],
arguments,
{},
null,
null
);
if (!_b_.isinstance($.suffix, str)) {
throw _b_.ValueError.$factory(
"suffix should be str, not " + `'${$B.class_name($.prefix)}'`
);
}
if ($.suffix.length > 0 && str.endswith($.self, $.suffix)) {
return $.self.substr(0, $.self.length - $.suffix.length);
}
return $.self.substr(0);
};
function $re_escape(str) {
var specials = "[.*+?|()$^";
for (var i = 0, len = specials.length; i < len; i++) {
var re = new RegExp("\\" + specials.charAt(i), "g");
str = str.replace(re, "\\" + specials.charAt(i));
}
return str;
}
str.replace = function (self, old, _new, count) {
var $ = $B.args(
"replace",
4,
{ self: null, old: null, new: null, count: null },
["self", "old", "new", "count"],
arguments,
{ count: -1 },
null,
null
),
count = $.count,
self = $.self,
old = $.old,
_new = $.new;
check_str(old, "replace() argument 1 ");
check_str(_new, "replace() argument 2 ");
if (!_b_.isinstance(count, [_b_.int, _b_.float])) {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(count) +
"' object cannot be interpreted as an integer"
);
} else if (_b_.isinstance(count, _b_.float)) {
throw _b_.TypeError.$factory("integer argument expected, got float");
}
if (count == 0) {
return self;
}
if (count.__class__ == $B.long_int) {
count = parseInt(count.value);
}
if (old == "") {
if (_new == "") {
return self;
}
if (self == "") {
return _new;
}
var elts = self.split("");
if (count > -1 && elts.length >= count) {
var rest = elts.slice(count).join("");
return _new + elts.slice(0, count).join(_new) + rest;
} else {
return _new + elts.join(_new) + _new;
}
} else {
var elts = str.split(self, old, count);
}
var res = self,
pos = -1;
if (old.length == 0) {
var res = _new;
for (var i = 0; i < elts.length; i++) {
res += elts[i] + _new;
}
return res + rest;
}
if (count < 0) {
count = res.length;
}
while (count > 0) {
pos = res.indexOf(old, pos);
if (pos < 0) {
break;
}
res = res.substr(0, pos) + _new + res.substr(pos + old.length);
pos = pos + _new.length;
count--;
}
return res;
};
str.rfind = function (self, substr) {
var $ = $B.args(
"rfind",
4,
{ self: null, sub: null, start: null, end: null },
["self", "sub", "start", "end"],
arguments,
{ start: 0, end: null },
null,
null
);
normalize_start_end($);
check_str($.sub);
var len = str.__len__($.self),
sub_len = str.__len__($.sub);
if (sub_len == 0) {
if ($.js_start > len) {
return -1;
} else {
return str.__len__($.self);
}
}
var js_start = pypos2jspos($.self, $.start),
js_end = pypos2jspos($.self, $.end),
ix = $.self.substring(js_start, js_end).lastIndexOf($.sub);
if (ix == -1) {
return -1;
}
return jspos2pypos($.self, js_start + ix) - $.start;
};
str.rindex = function () {
var res = str.rfind.apply(null, arguments);
if (res == -1) {
throw _b_.ValueError.$factory("substring not found");
}
return res;
};
str.rjust = function (self) {
var $ = $B.args(
"rjust",
3,
{ self: null, width: null, fillchar: null },
["self", "width", "fillchar"],
arguments,
{ fillchar: " " },
null,
null
);
var len = str.__len__(self);
if ($.width <= len) {
return self;
}
return $B.String($.fillchar.repeat($.width - len) + self);
};
str.rpartition = function (self, sep) {
var $ = $B.args(
"rpartition",
2,
{ self: null, sep: null },
["self", "sep"],
arguments,
{},
null,
null
);
check_str($.sep);
var self = reverse($.self),
sep = reverse($.sep);
var items = str.partition(self, sep).reverse();
for (var i = 0; i < items.length; i++) {
items[i] = items[i].split("").reverse().join("");
}
return items;
};
str.rsplit = function (self) {
var $ = $B.args(
"rsplit",
3,
{ self: null, sep: null, maxsplit: null },
["self", "sep", "maxsplit"],
arguments,
{ sep: _b_.None, maxsplit: -1 },
null,
null
),
sep = $.sep;
var rev_str = reverse($.self),
rev_sep = sep === _b_.None ? sep : reverse($.sep),
rev_res = str.split(rev_str, rev_sep, $.maxsplit);
rev_res.reverse();
for (var i = 0; i < rev_res.length; i++) {
rev_res[i] = reverse(rev_res[i]);
}
return rev_res;
};
str.rstrip = function (self, x) {
var $ = $B.args(
"rstrip",
2,
{ self: null, chars: null },
["self", "chars"],
arguments,
{ chars: _b_.None },
null,
null
),
self = $.self,
chars = $.chars;
if (chars === _b_.None) {
return self.trimEnd();
}
while (self.length > 0) {
var flag = false;
for (var char of chars) {
if (self.endsWith(char)) {
self = self.substr(0, self.length - char.length);
flag = true;
break;
}
}
if (!flag) {
return $.self.surrogates ? $B.String(self) : self;
}
}
return "";
};
str.split = function () {
var $ = $B.args(
"split",
3,
{ self: null, sep: null, maxsplit: null },
["self", "sep", "maxsplit"],
arguments,
{ sep: _b_.None, maxsplit: -1 },
null,
null
),
sep = $.sep,
maxsplit = $.maxsplit,
self = $.self,
pos = 0;
if (maxsplit.__class__ === $B.long_int) {
maxsplit = parseInt(maxsplit.value);
}
if (sep == "") {
throw _b_.ValueError.$factory("empty separator");
}
if (sep === _b_.None) {
var res = [];
while (pos < self.length && self.charAt(pos).search(/\s/) > -1) {
pos++;
}
if (pos === self.length - 1) {
return [self];
}
var name = "";
while (1) {
if (self.charAt(pos).search(/\s/) == -1) {
if (name == "") {
name = self.charAt(pos);
} else {
name += self.charAt(pos);
}
} else {
if (name !== "") {
res.push(name);
if (maxsplit !== -1 && res.length == maxsplit + 1) {
res.pop();
res.push(name + self.substr(pos));
return res;
}
name = "";
}
}
pos++;
if (pos > self.length - 1) {
if (name) {
res.push(name);
}
break;
}
}
return res.map($B.String);
} else {
var res = [],
s = "",
seplen = sep.length;
if (maxsplit == 0) {
return [self];
}
while (pos < self.length) {
if (self.substr(pos, seplen) == sep) {
res.push(s);
pos += seplen;
if (maxsplit > -1 && res.length >= maxsplit) {
res.push(self.substr(pos));
return res.map($B.String);
}
s = "";
} else {
s += self.charAt(pos);
pos++;
}
}
res.push(s);
return res.map($B.String);
}
};
str.splitlines = function (self) {
var $ = $B.args(
"splitlines",
2,
{ self: null, keepends: null },
["self", "keepends"],
arguments,
{ keepends: false },
null,
null
);
if (!_b_.isinstance($.keepends, [_b_.bool, _b_.int])) {
throw _b_.TypeError(
"integer argument expected, got " + $B.get_class($.keepends).__name
);
}
var keepends = _b_.int.$factory($.keepends),
res = [],
self = $.self,
start = 0,
pos = 0;
if (!self.length) {
return res;
}
while (pos < self.length) {
if (self.substr(pos, 2) == "\r\n") {
res.push(self.slice(start, keepends ? pos + 2 : pos));
start = pos = pos + 2;
} else if (self[pos] == "\r" || self[pos] == "\n") {
res.push(self.slice(start, keepends ? pos + 1 : pos));
start = pos = pos + 1;
} else {
pos++;
}
}
if (start < self.length) {
res.push(self.slice(start));
}
return res.map($B.String);
};
str.startswith = function () {
var $ = $B.args(
"startswith",
4,
{ self: null, prefix: null, start: null, end: null },
["self", "prefix", "start", "end"],
arguments,
{ start: 0, end: null },
null,
null
);
normalize_start_end($);
var prefixes = $.prefix;
if (!_b_.isinstance(prefixes, _b_.tuple)) {
prefixes = [prefixes];
}
var s = $.self.substring($.start, $.end);
for (var prefix of prefixes) {
if (!_b_.isinstance(prefix, str)) {
throw _b_.TypeError.$factory(
"endswith first arg must be str " + "or a tuple of str, not int"
);
}
if (s.substr(0, prefix.length) == prefix) {
return true;
}
}
return false;
};
str.strip = function () {
var $ = $B.args(
"strip",
2,
{ self: null, chars: null },
["self", "chars"],
arguments,
{ chars: _b_.None },
null,
null
);
if ($.chars === _b_.None) {
return $.self.trim();
}
return str.rstrip(str.lstrip($.self, $.chars), $.chars);
};
str.swapcase = function (self) {
var $ = $B.args(
"swapcase",
1,
{ self },
["self"],
arguments,
{},
null,
null
),
res = "",
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (unicode_tables.Ll[cp]) {
res += char.toUpperCase();
} else if (unicode_tables.Lu[cp]) {
res += char.toLowerCase();
} else {
res += char;
}
}
return res;
};
str.title = function (self) {
var $ = $B.args("title", 1, { self }, ["self"], arguments, {}, null, null),
state,
cp,
res = "";
for (var char of to_chars(self)) {
cp = _b_.ord(char);
if (unicode_tables.Ll[cp]) {
if (!state) {
res += char.toUpperCase();
state = "word";
} else {
res += char;
}
} else if (unicode_tables.Lu[cp] || unicode_tables.Lt[cp]) {
res += state ? char.toLowerCase() : char;
state = "word";
} else {
state = null;
res += char;
}
}
return res;
};
str.translate = function (self, table) {
var res = [],
getitem = $B.$getattr(table, "__getitem__"),
cp;
for (var char of to_chars(self)) {
cp = _b_.ord(char);
try {
var repl = getitem(cp);
if (repl !== _b_.None) {
if (typeof repl == "string") {
res.push(repl);
} else if (typeof repl == "number") {
res.push(String.fromCharCode(repl));
}
}
} catch (err) {
res.push(char);
}
}
return res.join("");
};
str.upper = function (self) {
var $ = $B.args(
"upper",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
return self.toUpperCase();
};
str.zfill = function (self, width) {
var $ = $B.args(
"zfill",
2,
{ self: null, width: null },
["self", "width"],
arguments,
{},
null,
null
),
len = str.__len__(self);
if ($.width <= len) {
return self;
}
switch (self.charAt(0)) {
case "+":
case "-":
return self.charAt(0) + "0".repeat($.width - len) + self.substr(1);
default:
return "0".repeat($.width - len) + self;
}
};
str.$factory = function (arg, encoding, errors) {
if (arguments.length == 0) {
return "";
}
if (arg === undefined) {
return $B.UndefinedClass.__str__();
} else if (arg === null) {
return "<Javascript null>";
}
if (encoding !== undefined) {
var $ = $B.args(
"str",
3,
{ arg: null, encoding: null, errors: null },
["arg", "encoding", "errors"],
arguments,
{ encoding: "utf-8", errors: "strict" },
null,
null
),
encoding = $.encoding,
errors = $.errors;
}
if (
typeof arg == "string" ||
arg instanceof String ||
typeof arg == "number"
) {
if (isFinite(arg)) {
return arg.toString();
}
}
try {
if (arg.$is_class || arg.$factory) {
var func = $B.$getattr(arg.__class__, "__str__");
return func(arg);
}
if (
arg.__class__ &&
arg.__class__ === _b_.bytes &&
encoding !== undefined
) {
return _b_.bytes.decode(arg, $.encoding, $.errors);
}
var klass = arg.__class__ || $B.get_class(arg);
if (klass === undefined) {
return $B.JSObj.__str__($B.JSObj.$factory(arg));
}
var method = $B.$getattr(klass, "__str__", null);
if (
method === null ||
(arg.__class__ &&
arg.__class__ !== _b_.object &&
method === _b_.object.__str__)
) {
var method = $B.$getattr(klass, "__repr__");
}
} catch (err) {
console.log("no __str__ for", arg);
console.log("err ", err);
if ($B.debug > 1) {
console.log(err);
}
console.log(
"Warning - no method __str__ or __repr__, " + "default to toString",
arg
);
throw err;
}
return $B.$call(method)(arg);
};
str.__new__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory("str.__new__(): not enough arguments");
}
return { __class__: cls };
};
$B.set_func_names(str, "builtins");
var StringSubclass = ($B.StringSubclass = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "str" },
$is_class: true,
});
for (var $attr in str) {
if (typeof str[$attr] == "function") {
StringSubclass[$attr] = (function (attr) {
return function () {
var args = [],
pos = 0;
if (arguments.length > 0) {
var args = [arguments[0].valueOf()],
pos = 1;
for (var i = 1, len = arguments.length; i < len; i++) {
args[pos++] = arguments[i];
}
}
return str[attr].apply(null, args);
};
})($attr);
}
}
StringSubclass.__new__ = function (cls) {
return { __class__: cls };
};
$B.set_func_names(StringSubclass, "builtins");
_b_.str = str;
$B.parse_format_spec = function (spec) {
if (spec == "") {
this.empty = true;
} else {
var pos = 0,
aligns = "<>=^",
digits = "0123456789",
types = "bcdeEfFgGnosxX%",
align_pos = aligns.indexOf(spec.charAt(0));
if (align_pos != -1) {
if (spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1) {
this.fill = spec.charAt(0);
this.align = spec.charAt(1);
pos = 2;
} else {
this.align = aligns[align_pos];
this.fill = " ";
pos++;
}
} else {
align_pos = aligns.indexOf(spec.charAt(1));
if (spec.charAt(1) && align_pos != -1) {
this.align = aligns[align_pos];
this.fill = spec.charAt(0);
pos = 2;
}
}
var car = spec.charAt(pos);
if (car == "+" || car == "-" || car == " ") {
this.sign = car;
pos++;
car = spec.charAt(pos);
}
if (car == "#") {
this.alternate = true;
pos++;
car = spec.charAt(pos);
}
if (car == "0") {
this.fill = "0";
if (align_pos == -1) {
this.align = "=";
}
pos++;
car = spec.charAt(pos);
}
while (car && digits.indexOf(car) > -1) {
if (this.width === undefined) {
this.width = car;
} else {
this.width += car;
}
pos++;
car = spec.charAt(pos);
}
if (this.width !== undefined) {
this.width = parseInt(this.width);
}
if (this.width === undefined && car == "{") {
var end_param_pos = spec.substr(pos).search("}");
this.width = spec.substring(pos, end_param_pos);
console.log("width", "[" + this.width + "]");
pos += end_param_pos + 1;
}
if (car == ",") {
this.comma = true;
pos++;
car = spec.charAt(pos);
}
if (car == ".") {
if (digits.indexOf(spec.charAt(pos + 1)) == -1) {
throw _b_.ValueError.$factory("Missing precision in format spec");
}
this.precision = spec.charAt(pos + 1);
pos += 2;
car = spec.charAt(pos);
while (car && digits.indexOf(car) > -1) {
this.precision += car;
pos++;
car = spec.charAt(pos);
}
this.precision = parseInt(this.precision);
}
if (car && types.indexOf(car) > -1) {
this.type = car;
pos++;
car = spec.charAt(pos);
}
if (pos !== spec.length) {
throw _b_.ValueError.$factory("Invalid format specifier: " + spec);
}
}
this.toString = function () {
return (
(this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
(this.align || "") +
(this.sign || "") +
(this.alternate ? "#" : "") +
(this.sign_aware ? "0" : "") +
(this.width || "") +
(this.comma ? "," : "") +
(this.precision ? "." + this.precision : "") +
(this.type || "")
);
};
};
$B.format_width = function (s, fmt) {
if (fmt.width && s.length < fmt.width) {
var fill = fmt.fill || " ",
align = fmt.align || "<",
missing = fmt.width - s.length;
switch (align) {
case "<":
return s + fill.repeat(missing);
case ">":
return fill.repeat(missing) + s;
case "=":
if ("+-".indexOf(s.charAt(0)) > -1) {
return s.charAt(0) + fill.repeat(missing) + s.substr(1);
} else {
return fill.repeat(missing) + s;
}
case "^":
var left = parseInt(missing / 2);
return fill.repeat(left) + s + fill.repeat(missing - left);
}
}
return s;
};
function fstring_expression(start) {
this.type = "expression";
this.start = start;
this.expression = "";
this.conversion = null;
this.fmt = null;
}
function fstring_error(msg, pos) {
error = Error(msg);
error.position = pos;
throw error;
}
$B.parse_fstring = function (string) {
var elts = [],
pos = 0,
current = "",
ctype = null,
nb_braces = 0,
expr_start,
car;
while (pos < string.length) {
if (ctype === null) {
car = string.charAt(pos);
if (car == "{") {
if (string.charAt(pos + 1) == "{") {
ctype = "string";
current = "{";
pos += 2;
} else {
ctype = "expression";
expr_start = pos + 1;
nb_braces = 1;
pos++;
}
} else if (car == "}") {
if (string.charAt(pos + 1) == car) {
ctype = "string";
current = "}";
pos += 2;
} else {
fstring_error(" f-string: single '}' is not allowed", pos);
}
} else {
ctype = "string";
current = car;
pos++;
}
} else if (ctype == "string") {
var i = pos;
while (i < string.length) {
car = string.charAt(i);
if (car == "{") {
if (string.charAt(i + 1) == "{") {
current += "{";
i += 2;
} else {
elts.push(current);
ctype = "expression";
expr_start = i + 1;
pos = i + 1;
break;
}
} else if (car == "}") {
if (string.charAt(i + 1) == car) {
current += car;
i += 2;
} else {
fstring_error(" f-string: single '}' is not allowed", pos);
}
} else {
current += car;
i++;
}
}
pos = i + 1;
} else if (ctype == "debug") {
while (string.charAt(i) == " ") {
i++;
}
if (string.charAt(i) == "}") {
elts.push(current);
ctype = null;
current = "";
pos = i + 1;
}
} else {
var i = pos,
nb_braces = 1,
nb_paren = 0,
current = new fstring_expression(expr_start);
while (i < string.length) {
car = string.charAt(i);
if (car == "{" && nb_paren == 0) {
nb_braces++;
current.expression += car;
i++;
} else if (car == "}" && nb_paren == 0) {
nb_braces -= 1;
if (nb_braces == 0) {
if (current.expression == "") {
fstring_error("f-string: empty expression not allowed", pos);
}
elts.push(current);
ctype = null;
current = "";
pos = i + 1;
break;
}
current.expression += car;
i++;
} else if (car == "\\") {
throw Error(
"f-string expression part cannot include a" + " backslash"
);
} else if (
nb_paren == 0 &&
car == "!" &&
current.fmt === null &&
":}".indexOf(string.charAt(i + 2)) > -1
) {
if (current.expression.length == 0) {
throw Error("f-string: empty expression not allowed");
}
if ("ars".indexOf(string.charAt(i + 1)) == -1) {
throw Error(
"f-string: invalid conversion character:" +
" expected 's', 'r', or 'a'"
);
} else {
current.conversion = string.charAt(i + 1);
i += 2;
}
} else if (car == "(" || car == "[") {
nb_paren++;
current.expression += car;
i++;
} else if (car == ")" || car == "]") {
nb_paren--;
current.expression += car;
i++;
} else if (car == '"') {
if (string.substr(i, 3) == '"""') {
var end = string.indexOf('"""', i + 3);
if (end == -1) {
fstring_error("f-string: unterminated string", pos);
} else {
var trs = string.substring(i, end + 3);
trs = trs.replace("\n", "\\n\\");
current.expression += trs;
i = end + 3;
}
} else {
var end = string.indexOf('"', i + 1);
if (end == -1) {
fstring_error("f-string: unterminated string", pos);
} else {
current.expression += string.substring(i, end + 1);
i = end + 1;
}
}
} else if (nb_paren == 0 && car == ":") {
current.fmt = true;
var cb = 0,
fmt_complete = false;
for (var j = i + 1; j < string.length; j++) {
if (string[j] == "{") {
if (string[j + 1] == "{") {
j += 2;
} else {
cb++;
}
} else if (string[j] == "}") {
if (string[j + 1] == "}") {
j += 2;
} else if (cb == 0) {
fmt_complete = true;
var fmt = string.substring(i + 1, j);
current.format = $B.parse_fstring(fmt);
i = j;
break;
} else {
cb--;
}
}
}
if (!fmt_complete) {
fstring_error("invalid format", pos);
}
} else if (car == "=") {
var ce = current.expression,
last_char = ce.charAt(ce.length - 1),
last_char_re =
("()".indexOf(last_char) > -1 ? "\\" : "") + last_char;
if (
ce.length == 0 ||
nb_paren > 0 ||
string.charAt(i + 1) == "=" ||
"=!<>:".search(last_char_re) > -1
) {
current.expression += car;
i += 1;
} else {
tail = car;
while (string.charAt(i + 1).match(/\s/)) {
tail += string.charAt(i + 1);
i++;
}
elts.push(current.expression + tail);
while (ce.match(/\s$/)) {
ce = ce.substr(0, ce.length - 1);
}
current.expression = ce;
ctype = "debug";
i++;
}
} else {
current.expression += car;
i++;
}
}
if (nb_braces > 0) {
fstring_error("f-string: expected '}'", pos);
}
}
}
if (current.length > 0) {
elts.push(current);
}
for (var elt of elts) {
if (typeof elt == "object") {
if (
elt.fmt_pos !== undefined &&
elt.expression.charAt(elt.fmt_pos) != ":"
) {
console.log("mauvais format", string, elts);
throw Error();
}
}
}
return elts;
};
var _chr = ($B.codepoint2jsstring = function (i) {
if (i >= 0x10000 && i <= 0x10ffff) {
var code = i - 0x10000;
return (
String.fromCodePoint(0xd800 | (code >> 10)) +
String.fromCodePoint(0xdc00 | (code & 0x3ff))
);
} else {
return String.fromCodePoint(i);
}
});
var _ord = ($B.jsstring2codepoint = function (c) {
if (c.length == 1) {
return c.charCodeAt(0);
}
var code = 0x10000;
code += (c.charCodeAt(0) & 0x03ff) << 10;
code += c.charCodeAt(1) & 0x03ff;
return code;
});
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
function $err(op, other) {
var msg =
"unsupported operand type(s) for " +
op +
" : 'int' and '" +
$B.class_name(other) +
"'";
throw _b_.TypeError.$factory(msg);
}
function int_value(obj) {
if (typeof obj == "boolean") {
return obj ? 1 : 0;
}
return obj.$brython_value !== undefined ? obj.$brython_value : obj;
}
var int = {
__class__: _b_.type,
__dir__: _b_.object.__dir__,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "int" },
$is_class: true,
$native: true,
$descriptors: {
numerator: true,
denominator: true,
imag: true,
real: true,
},
};
int.as_integer_ratio = function () {
var $ = $B.args(
"as_integer_ratio",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
return $B.$list([$.self, 1]);
};
int.from_bytes = function () {
var $ = $B.args(
"from_bytes",
3,
{ bytes: null, byteorder: null, signed: null },
["bytes", "byteorder", "signed"],
arguments,
{ signed: false },
null,
null
);
var x = $.bytes,
byteorder = $.byteorder,
signed = $.signed,
_bytes,
_len;
if (_b_.isinstance(x, [_b_.bytes, _b_.bytearray])) {
_bytes = x.source;
_len = x.source.length;
} else {
_bytes = _b_.list.$factory(x);
_len = _bytes.length;
for (var i = 0; i < _len; i++) {
_b_.bytes.$factory([_bytes[i]]);
}
}
if (byteorder == "big") {
_bytes.reverse();
} else if (byteorder != "little") {
throw _b_.ValueError.$factory(
"byteorder must be either 'little' or 'big'"
);
}
var num = _bytes[0];
if (signed && num >= 128) {
num = num - 256;
}
var _mult = 256;
for (var i = 1; i < _len; i++) {
num = $B.add($B.mul(_mult, _bytes[i]), num);
_mult = $B.mul(_mult, 256);
}
if (!signed) {
return num;
}
if (_bytes[_len - 1] < 128) {
return num;
}
return $B.sub(num, _mult);
};
int.to_bytes = function () {
var $ = $B.args(
"to_bytes",
3,
{ self: null, len: null, byteorder: null, signed: null },
["self", "len", "byteorder", "*", "signed"],
arguments,
{ signed: false },
null,
null
),
self = $.self,
len = $.len,
byteorder = $.byteorder,
signed = $.signed;
if (!_b_.isinstance(len, _b_.int)) {
throw _b_.TypeError.$factory(
"integer argument expected, got " + $B.class_name(len)
);
}
if (["little", "big"].indexOf(byteorder) == -1) {
throw _b_.ValueError.$factory(
"byteorder must be either 'little' or 'big'"
);
}
if (_b_.isinstance(self, $B.long_int)) {
return $B.long_int.to_bytes(self, len, byteorder, signed);
}
if (self < 0) {
if (!signed) {
throw _b_.OverflowError.$factory(
"can't convert negative int to unsigned"
);
}
self = Math.pow(256, len) + self;
}
var res = [],
value = self;
while (value > 0) {
var quotient = Math.floor(value / 256),
rest = value - 256 * quotient;
res.push(rest);
if (res.length > len) {
throw _b_.OverflowError.$factory("int too big to convert");
}
value = quotient;
}
while (res.length < len) {
res.push(0);
}
if (byteorder == "big") {
res.reverse();
}
return {
__class__: _b_.bytes,
source: res,
};
};
int.__abs__ = function (self) {
return _b_.abs(self);
};
int.__add__ = function (self, other) {
self = int_value(self);
if (_b_.isinstance(other, int)) {
if (other.__class__ == $B.long_int) {
return $B.long_int.__add__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
other = int_value(other);
var res = self + other;
if (res > $B.min_int && res < $B.max_int) {
return res;
} else {
return $B.long_int.__add__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
}
return _b_.NotImplemented;
};
int.__bool__ = function (self) {
return int_value(self).valueOf() == 0 ? false : true;
};
int.__ceil__ = function (self) {
return Math.ceil(int_value(self));
};
int.__divmod__ = function (self, other) {
if (!_b_.isinstance(other, int)) {
return _b_.NotImplemented;
}
return $B.fast_tuple([
int.__floordiv__(self, other),
int.__mod__(self, other),
]);
};
int.__eq__ = function (self, other) {
if (_b_.isinstance(other, int)) {
return self.valueOf() == int_value(other).valueOf();
}
if (_b_.isinstance(other, _b_.float)) {
return self.valueOf() == other.valueOf();
}
if (_b_.isinstance(other, _b_.complex)) {
if (other.$imag != 0) {
return _b_.False;
}
return self.valueOf() == other.$real;
}
return _b_.NotImplemented;
};
int.__float__ = function (self) {
return new Number(self);
};
function preformat(self, fmt) {
if (fmt.empty) {
return _b_.str.$factory(self);
}
if (fmt.type && "bcdoxXn".indexOf(fmt.type) == -1) {
throw _b_.ValueError.$factory(
"Unknown format code '" + fmt.type + "' for object of type 'int'"
);
}
var res;
switch (fmt.type) {
case undefined:
case "d":
res = self.toString();
break;
case "b":
res = (fmt.alternate ? "0b" : "") + self.toString(2);
break;
case "c":
res = _b_.chr(self);
break;
case "o":
res = (fmt.alternate ? "0o" : "") + self.toString(8);
break;
case "x":
res = (fmt.alternate ? "0x" : "") + self.toString(16);
break;
case "X":
res = (fmt.alternate ? "0X" : "") + self.toString(16).toUpperCase();
break;
case "n":
return self;
}
if (fmt.sign !== undefined) {
if ((fmt.sign == " " || fmt.sign == "+") && self >= 0) {
res = fmt.sign + res;
}
}
return res;
}
int.__format__ = function (self, format_spec) {
var fmt = new $B.parse_format_spec(format_spec);
if (fmt.type && "eEfFgG%".indexOf(fmt.type) != -1) {
return _b_.float.__format__(self, format_spec);
}
fmt.align = fmt.align || ">";
var res = preformat(self, fmt);
if (fmt.comma) {
var sign = res[0] == "-" ? "-" : "",
rest = res.substr(sign.length),
len = rest.length,
nb = Math.ceil(rest.length / 3),
chunks = [];
for (var i = 0; i < nb; i++) {
chunks.push(rest.substring(len - 3 * i - 3, len - 3 * i));
}
chunks.reverse();
res = sign + chunks.join(",");
}
return $B.format_width(res, fmt);
};
int.__floordiv__ = function (self, other) {
if (other.__class__ === $B.long_int) {
return $B.long_int.__floordiv__($B.long_int.$factory(self), other);
}
if (_b_.isinstance(other, int)) {
other = int_value(other);
if (other == 0) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
return Math.floor(self / other);
}
return _b_.NotImplemented;
};
int.__hash__ = function (self) {
if (self.$brython_value) {
var hash_method = $B.$getattr(self.__class__, "__hash__");
if (hash_method === int.__hash__) {
if (typeof self.$brython_value == "number") {
return self.$brython_value;
} else {
return $B.long_int.__hash__(self.$brython_value);
}
} else {
return hash_method(self);
}
}
return self.valueOf();
};
int.__index__ = function (self) {
return int_value(self);
};
int.__init__ = function (self, value) {
if (value === undefined) {
value = 0;
}
self.toString = function () {
return value;
};
return _b_.None;
};
int.__int__ = function (self) {
return self;
};
int.__invert__ = function (self) {
return ~self;
};
int.__lshift__ = function (self, other) {
self = int_value(self);
if (_b_.isinstance(other, int)) {
other = int_value(other);
try {
return int.$factory(
$B.long_int.__lshift__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
)
);
} catch (err) {
console.log("err in lshift", self, other);
throw err;
}
}
return _b_.NotImplemented;
};
int.__mod__ = function (self, other) {
if (_b_.isinstance(other, _b_.tuple) && other.length == 1) {
other = other[0];
}
if (other.__class__ === $B.long_int) {
return $B.long_int.__mod__($B.long_int.$factory(self), other);
}
if (_b_.isinstance(other, int)) {
other = int_value(other);
if (other === false) {
other = 0;
} else if (other === true) {
other = 1;
}
if (other == 0) {
throw _b_.ZeroDivisionError.$factory(
"integer division or modulo by zero"
);
}
return ((self % other) + other) % other;
}
return _b_.NotImplemented;
};
int.__mul__ = function (self, other) {
self = int_value(self);
if (_b_.isinstance(other, int)) {
if (other.__class__ == $B.long_int) {
return $B.long_int.__mul__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
other = int_value(other);
var res = self * other;
if (res > $B.min_int && res < $B.max_int) {
return res;
} else {
return int.$factory(
$B.long_int.__mul__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
)
);
}
}
return _b_.NotImplemented;
};
int.__ne__ = function (self, other) {
var res = int.__eq__(self, other);
return res === _b_.NotImplemented ? res : !res;
};
int.__neg__ = function (self) {
return -self;
};
int.__new__ = function (cls, value) {
if (cls === undefined) {
throw _b_.TypeError.$factory("int.__new__(): not enough arguments");
} else if (!_b_.isinstance(cls, _b_.type)) {
throw _b_.TypeError.$factory("int.__new__(X): X is not a type object");
}
if (cls === int) {
return int.$factory(value);
}
return {
__class__: cls,
__dict__: $B.empty_dict(),
$brython_value: value || 0,
};
};
int.__pos__ = function (self) {
return self;
};
function extended_euclidean(a, b) {
var d, u, v;
if (b == 0) {
return [a, 1, 0];
} else {
[d, u, v] = extended_euclidean(b, a % b);
return [d, v, u - Math.floor(a / b) * v];
}
}
int.__pow__ = function (self, other, z) {
if (!_b_.isinstance(other, int)) {
return _b_.NotImplemented;
}
if (typeof other == "number" || _b_.isinstance(other, int)) {
other = int_value(other);
switch (other.valueOf()) {
case 0:
return int.$factory(1);
case 1:
return int.$factory(self.valueOf());
}
if (z !== undefined && z !== _b_.None) {
if (z == 1) {
return 0;
}
var result = 1,
base = self % z,
exponent = other,
long_int = $B.long_int;
if (exponent < 0) {
var gcd, inv, _;
[gcd, inv, _] = extended_euclidean(self, z);
if (gcd !== 1) {
throw _b_.ValueError.$factory(
"not relative primes: " + self + " and " + z
);
}
return int.__pow__(inv, -exponent, z);
}
while (exponent > 0) {
if (exponent % 2 == 1) {
if (result * base > $B.max_int) {
result = long_int.__mul__(
long_int.$factory(result),
long_int.$factory(base)
);
result = long_int.__mod__(result, z);
} else {
result = (result * base) % z;
}
}
exponent = exponent >> 1;
if (base * base > $B.max_int) {
base = long_int.__mul__(
long_int.$factory(base),
long_int.$factory(base)
);
base = long_int.__mod__(base, z);
} else {
base = (base * base) % z;
}
}
return result;
}
var res = Math.pow(self.valueOf(), other.valueOf());
if (res > $B.min_int && res < $B.max_int) {
return other > 0 ? res : new Number(res);
} else if (res !== Infinity && !isFinite(res)) {
return res;
} else {
if ($B.BigInt) {
return {
__class__: $B.long_int,
value: ($B.BigInt(self) ** $B.BigInt(other)).toString(),
pos: true,
};
}
return $B.long_int.__pow__(
$B.long_int.$from_int(self),
$B.long_int.$from_int(other)
);
}
}
if (_b_.isinstance(other, _b_.float)) {
other = _b_.float.numerator(other);
if (self >= 0) {
return new Number(Math.pow(self, other));
} else {
return _b_.complex.__pow__($B.make_complex(self, 0), other);
}
} else if (_b_.isinstance(other, _b_.complex)) {
var preal = Math.pow(self, other.$real),
ln = Math.log(self);
return $B.make_complex(preal * Math.cos(ln), preal * Math.sin(ln));
}
var rpow = $B.$getattr(other, "__rpow__", _b_.None);
if (rpow !== _b_.None) {
return rpow(self);
}
$err("**", other);
};
function __newobj__() {
var $ = $B.args("__newobj__", 0, {}, [], arguments, {}, "args", null),
args = $.args;
var res = args.slice(1);
res.__class__ = args[0];
return res;
}
int.__reduce_ex__ = function (self) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__ || int, int_value(self)]),
_b_.None,
_b_.None,
_b_.None,
]);
};
int.__repr__ = function (self) {
$B.builtins_repr_check(int, arguments);
return int_value(self).toString();
};
int.__rshift__ = function (self, other) {
self = int_value(self);
if (typeof other == "number" || _b_.isinstance(other, int)) {
other = int_value(other);
return int.$factory(
$B.long_int.__rshift__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
)
);
}
return _b_.NotImplemented;
};
int.__setattr__ = function (self, attr, value) {
if (typeof self == "number" || typeof self == "boolean") {
var cl_name = $B.class_name(self);
if (_b_.dir(self).indexOf(attr) > -1) {
throw _b_.AttributeError.$factory(
"attribute '" + attr + `' of '${cl_name}' objects is not writable`
);
} else {
throw _b_.AttributeError.$factory(
`'${cl_name}' object` + ` has no attribute '${attr}'`
);
}
throw _b_.AttributeError.$factory(msg);
}
_b_.dict.$setitem(self.__dict__, attr, value);
return _b_.None;
};
int.__sub__ = function (self, other) {
self = int_value(self);
if (_b_.isinstance(other, int)) {
if (other.__class__ == $B.long_int) {
return $B.long_int.__sub__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
other = int_value(other);
var res = self - other;
if (res > $B.min_int && res < $B.max_int) {
return res;
} else {
return $B.long_int.__sub__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
}
return _b_.NotImplemented;
};
int.__truediv__ = function (self, other) {
if (_b_.isinstance(other, int)) {
other = int_value(other);
if (other == 0) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
if (other.__class__ === $B.long_int) {
return new Number(self / parseInt(other.value));
}
return new Number(self / other);
}
return _b_.NotImplemented;
};
int.bit_length = function (self) {
s = _b_.bin(self);
s = $B.$getattr(s, "lstrip")("-0b");
return s.length;
};
int.numerator = function (self) {
return int_value(self);
};
int.denominator = function (self) {
return int.$factory(1);
};
int.imag = function (self) {
return int.$factory(0);
};
int.real = function (self) {
return self;
};
for (var attr of ["numerator", "denominator", "imag", "real"]) {
int[attr].setter = (function (x) {
return function (self, value) {
throw _b_.AttributeError.$factory(
`attribute '${x}' of ` +
`'${$B.class_name(self)}' objects is not writable`
);
};
})(attr);
}
$B.max_int32 = (1 << 30) * 2 - 1;
$B.min_int32 = -$B.max_int32;
var $op_func = function (self, other) {
self = int_value(self);
if (typeof other == "number" || _b_.isinstance(other, int)) {
if (other.__class__ === $B.long_int) {
return $B.long_int.__sub__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
other = int_value(other);
if (
self > $B.max_int32 ||
self < $B.min_int32 ||
other > $B.max_int32 ||
other < $B.min_int32
) {
return $B.long_int.__sub__(
$B.long_int.$factory(self),
$B.long_int.$factory(other)
);
}
return self - other;
}
return _b_.NotImplemented;
};
$op_func += "";
var $ops = { "&": "and", "|": "or", "^": "xor" };
for (var $op in $ops) {
var opf = $op_func.replace(/-/gm, $op);
opf = opf.replace(new RegExp("sub", "gm"), $ops[$op]);
eval("int.__" + $ops[$op] + "__ = " + opf);
}
var $comp_func = function (self, other) {
if (other.__class__ === $B.long_int) {
return $B.long_int.__lt__(other, $B.long_int.$factory(self));
}
if (_b_.isinstance(other, int)) {
other = int_value(other);
return self.valueOf() > other.valueOf();
} else if (_b_.isinstance(other, _b_.float)) {
return self.valueOf() > _b_.float.numerator(other);
} else if (_b_.isinstance(other, _b_.bool)) {
return self.valueOf() > _b_.bool.__hash__(other);
}
if (_b_.hasattr(other, "__int__") || _b_.hasattr(other, "__index__")) {
return int.__gt__(self, $B.$GetInt(other));
}
return _b_.NotImplemented;
};
$comp_func += "";
for (var $op in $B.$comps) {
eval(
"int.__" +
$B.$comps[$op] +
"__ = " +
$comp_func
.replace(/>/gm, $op)
.replace(/__gt__/gm, "__" + $B.$comps[$op] + "__")
.replace(/__lt__/, "__" + $B.$inv_comps[$op] + "__")
);
}
var r_opnames = [
"add",
"sub",
"mul",
"truediv",
"floordiv",
"mod",
"pow",
"lshift",
"rshift",
"and",
"xor",
"or",
"divmod",
];
for (var r_opname of r_opnames) {
if (
int["__r" + r_opname + "__"] === undefined &&
int["__" + r_opname + "__"]
) {
int["__r" + r_opname + "__"] = (function (name) {
return function (self, other) {
if (_b_.isinstance(other, int)) {
other = int_value(other);
return int["__" + name + "__"](other, self);
}
return _b_.NotImplemented;
};
})(r_opname);
}
}
var $valid_digits = function (base) {
var digits = "";
if (base === 0) {
return "0";
}
if (base < 10) {
for (var i = 0; i < base; i++) {
digits += String.fromCharCode(i + 48);
}
return digits;
}
var digits = "0123456789";
for (var i = 10; i < base; i++) {
digits += String.fromCharCode(i + 55);
}
return digits;
};
int.$factory = function (value, base) {
if (value === undefined) {
return 0;
}
if (typeof value == "number" && (base === undefined || base == 10)) {
return parseInt(value);
}
if (_b_.isinstance(value, _b_.complex)) {
throw _b_.TypeError.$factory("can't convert complex to int");
}
var $ns = $B.args(
"int",
2,
{ x: null, base: null },
["x", "base"],
arguments,
{ base: 10 },
null,
null
),
value = $ns["x"],
base = $ns["base"];
if (_b_.isinstance(value, _b_.float) && base == 10) {
value = _b_.float.numerator(value);
if (value < $B.min_int || value > $B.max_int) {
return $B.long_int.$from_float(value);
} else {
return value > 0 ? Math.floor(value) : Math.ceil(value);
}
}
if (!(base >= 2 && base <= 36)) {
if (base != 0) {
throw _b_.ValueError.$factory("invalid base");
}
}
if (typeof value == "number") {
if (base == 10) {
if (value < $B.min_int || value > $B.max_int) {
return $B.long_int.$factory(value);
}
return value;
} else if (value.toString().search("e") > -1) {
throw _b_.OverflowError.$factory("can't convert to base " + base);
} else {
var res = parseInt(value, base);
if (value < $B.min_int || value > $B.max_int) {
return $B.long_int.$factory(value, base);
}
return res;
}
}
if (value === true) {
return Number(1);
}
if (value === false) {
return Number(0);
}
if (value.__class__ === $B.long_int) {
var z = parseInt(value.value);
if (z > $B.min_int && z < $B.max_int) {
return z;
} else {
return value;
}
}
base = $B.$GetInt(base);
function invalid(value, base) {
throw _b_.ValueError.$factory(
"invalid literal for int() with base " +
base +
": '" +
_b_.str.$factory(value) +
"'"
);
}
if (_b_.isinstance(value, _b_.str)) {
value = value.valueOf();
}
if (typeof value == "string") {
var _value = value.trim();
if (
_value.length == 2 &&
base == 0 &&
(_value == "0b" || _value == "0o" || _value == "0x")
) {
throw _b_.ValueError.$factory("invalid value");
}
if (_value.length > 2) {
var _pre = _value.substr(0, 2).toUpperCase();
if (base == 0) {
if (_pre == "0B") {
base = 2;
}
if (_pre == "0O") {
base = 8;
}
if (_pre == "0X") {
base = 16;
}
} else if (_pre == "0X" && base != 16) {
invalid(_value, base);
} else if (_pre == "0O" && base != 8) {
invalid(_value, base);
}
if ((_pre == "0B" && base == 2) || _pre == "0O" || _pre == "0X") {
_value = _value.substr(2);
while (_value.startsWith("_")) {
_value = _value.substr(1);
}
}
} else if (base == 0) {
base = 10;
}
var _digits = $valid_digits(base),
_re = new RegExp(
"^[+-]?[" + _digits + "]" + "[" + _digits + "_]*$",
"i"
),
match = _re.exec(_value);
if (match === null) {
invalid(value, base);
} else {
value = _value.replace(/_/g, "");
}
if (base <= 10 && !isFinite(value)) {
invalid(_value, base);
}
var res = parseInt(value, base);
if (res < $B.min_int || res > $B.max_int) {
return $B.long_int.$factory(value, base);
}
return res;
}
if (_b_.isinstance(value, [_b_.bytes, _b_.bytearray])) {
return int.$factory($B.$getattr(value, "decode")("latin-1"), base);
}
for (var special_method of ["__int__", "__index__", "__trunc__"]) {
var num_value = $B.$getattr(
value.__class__ || $B.get_class(value),
special_method,
_b_.None
);
if (num_value !== _b_.None) {
return $B.$call(num_value)(value);
}
}
throw _b_.TypeError.$factory(
"int() argument must be a string, a bytes-like " +
"object or a number, not '" +
$B.class_name(value) +
"'"
);
};
$B.set_func_names(int, "builtins");
_b_.int = int;
$B.$bool = function (obj) {
if (obj === null || obj === undefined) {
return false;
}
switch (typeof obj) {
case "boolean":
return obj;
case "number":
case "string":
if (obj) {
return true;
}
return false;
default:
if (obj.$is_class) {
return true;
}
var klass = obj.__class__ || $B.get_class(obj),
missing = {},
bool_method = $B.$getattr(klass, "__bool__", missing);
if (bool_method === missing) {
try {
return _b_.len(obj) > 0;
} catch (err) {
return true;
}
} else {
var res = $B.$call(bool_method)(obj);
if (res !== true && res !== false) {
throw _b_.TypeError.$factory(
"__bool__ should return " + "bool, returned " + $B.class_name(res)
);
}
return res;
}
}
};
var bool = {
__bases__: [int],
__class__: _b_.type,
__mro__: [int, _b_.object],
$infos: { __name__: "bool", __module__: "builtins" },
$is_class: true,
$native: true,
$descriptors: {
numerator: true,
denominator: true,
imag: true,
real: true,
},
};
bool.__and__ = function (self, other) {
if (_b_.isinstance(other, bool)) {
return self && other;
} else if (_b_.isinstance(other, int)) {
return int.__and__(bool.__index__(self), int.__index__(other));
}
return _b_.NotImplemented;
};
bool.__float__ = function (self) {
return self ? new Number(1) : new Number(0);
};
bool.__hash__ =
bool.__index__ =
bool.__int__ =
function (self) {
if (self.valueOf()) return 1;
return 0;
};
bool.__neg__ = function (self) {
return -$B.int_or_bool(self);
};
bool.__or__ = function (self, other) {
if (_b_.isinstance(other, bool)) {
return self || other;
} else if (_b_.isinstance(other, int)) {
return int.__or__(bool.__index__(self), int.__index__(other));
}
return _b_.NotImplemented;
};
bool.__pos__ = $B.int_or_bool;
bool.__repr__ = function (self) {
$B.builtins_repr_check(bool, arguments);
return self ? "True" : "False";
};
bool.__xor__ = function (self, other) {
if (_b_.isinstance(other, bool)) {
return self ^ other ? true : false;
} else if (_b_.isinstance(other, int)) {
return int.__xor__(bool.__index__(self), int.__index__(other));
}
return _b_.NotImplemented;
};
bool.$factory = function () {
var $ = $B.args(
"bool",
1,
{ x: null },
["x"],
arguments,
{ x: false },
null,
null
);
return $B.$bool($.x);
};
bool.numerator = int.numerator;
bool.denominator = int.denominator;
bool.real = int.real;
bool.imag = int.imag;
_b_.bool = bool;
$B.set_func_names(bool, "builtins");
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
try {
eval("window");
} catch (err) {
window = self;
}
var long_int = {
__class__: _b_.type,
__mro__: [_b_.int, _b_.object],
$infos: { __module__: "builtins", __name__: "int" },
$is_class: true,
$native: true,
$descriptors: {
numerator: true,
denominator: true,
imag: true,
real: true,
},
};
var max_safe_divider = $B.max_int / 9;
function add_pos(v1, v2) {
return {
__class__: long_int,
value: (BigInt(v1) + BigInt(v2)).toString(),
pos: true,
};
}
var len = (Math.pow(2, 53) - 1 + "").length - 1;
function binary_pos(t) {
var nb_chunks = Math.ceil(t.length / len),
chunks = [],
pos,
start,
nb,
bin = [];
for (var i = 0; i < nb_chunks; i++) {
pos = t.length - (i + 1) * len;
start = Math.max(0, pos);
nb = pos - start;
chunks.push(t.substr(start, len + nb));
}
chunks = chunks.reverse();
chunks.forEach(function (chunk, i) {
chunks[i] = parseInt(chunk);
});
var rest;
var carry = Math.pow(10, 15);
while (chunks[chunks.length - 1] > 0) {
chunks.forEach(function (chunk, i) {
rest = chunk % 2;
chunks[i] = Math.floor(chunk / 2);
if (rest && i < chunks.length - 1) {
chunks[i + 1] += carry;
}
});
bin.push(rest);
if (chunks[0] == 0) {
chunks.shift();
}
}
bin = bin.reverse().join("");
return bin;
}
function binary(obj) {
var bpos = binary_pos(obj.value);
if (obj.pos) {
return bpos;
}
var res = "";
for (var i = 0, len = bpos.length; i < len; i++) {
res += bpos.charAt(i) == "0" ? "1" : "0";
}
var add1 = add_pos(res, "1").value;
add1 = res.substr(0, res.length - add1.length) + add1;
return add1;
}
function comp_pos(v1, v2) {
if (v1.length > v2.length) {
return 1;
} else if (v1.length < v2.length) {
return -1;
} else {
if (v1 > v2) {
return 1;
} else if (v1 < v2) {
return -1;
}
}
return 0;
}
function divmod_by_safe_int(t, n) {
if (n == 1) {
return [t, 0];
}
var quotient = BigInt(t) / BigInt(n),
rest = BigInt(t) - quotient * BigInt(n);
console.log("divmod by safe int");
return [from_BigInt(quotient), from_BigInt(rest)];
}
function divmod_pos(v1, v2) {
var a = {
__class__: long_int,
value: (BigInt(v1) / BigInt(v2)).toString(),
pos: true,
},
b = {
__class__: long_int,
value: (BigInt(v1) % BigInt(v2)).toString(),
pos: true,
};
return [a, b];
}
function split_chunks(s, size) {
var nb = Math.ceil(s.length / size),
chunks = [],
len = s.length;
for (var i = 0; i < nb; i++) {
var pos = len - size * (i + 1);
if (pos < 0) {
size += pos;
pos = 0;
}
chunks.push(parseInt(s.substr(pos, size)));
}
return chunks;
}
function mul_pos(x, y) {
return long_int.$factory(from_BigInt(BigInt(x) * BigInt(y)));
}
function sub_pos(v1, v2) {
return {
__class__: long_int,
value: (BigInt(v1) - BigInt(v2)).toString(),
pos: true,
};
}
function to_BigInt(x) {
var res = $B.BigInt(x.value);
if (x.pos) {
return res;
}
return -res;
}
function to_int(long_int) {
return long_int.pos ? parseInt(long_int.value) : -parseInt(long_int.value);
}
function from_BigInt(y) {
var pos = y >= 0;
y = y.toString();
y = y.endsWith("n") ? y.substr(0, y.length - 1) : y;
y = y.startsWith("-") ? y.substr(1) : y;
return intOrLong({ __class__: long_int, value: y, pos: pos });
}
long_int.$from_float = function (value) {
var s = Math.abs(value).toString(),
v = s;
if (s.search("e") > -1) {
var t = /-?(\d)(\.\d+)?e([+-])(\d*)/.exec(s),
n1 = t[1],
n2 = t[2],
pos = t[3],
exp = t[4];
if (pos == "+") {
if (n2 === undefined) {
v = n1 + "0".repeat(exp - 1);
} else {
v = n1 + n2 + "0".repeat(exp - 1 - n2.length);
}
}
}
return { __class__: long_int, value: v, pos: value >= 0 };
};
function preformat(self, fmt) {
if (fmt.empty) {
return _b_.str.$factory(self);
}
if (fmt.type && "bcdoxXn".indexOf(fmt.type) == -1) {
throw _b_.ValueError.$factory(
"Unknown format code '" + fmt.type + "' for object of type 'int'"
);
}
var res;
switch (fmt.type) {
case undefined:
case "d":
res = self.toString();
break;
case "b":
res = (fmt.alternate ? "0b" : "") + BigInt(self.value).toString(2);
break;
case "c":
res = _b_.chr(self);
break;
case "o":
res = (fmt.alternate ? "0o" : "") + BigInt(self.value).toString(8);
break;
case "x":
res = (fmt.alternate ? "0x" : "") + BigInt(self.value).toString(16);
break;
case "X":
res =
(fmt.alternate ? "0X" : "") +
BigInt(self.value).toString(16).toUpperCase();
break;
case "n":
return self;
}
if (fmt.sign !== undefined) {
if ((fmt.sign == " " || fmt.sign == "+") && self >= 0) {
res = fmt.sign + res;
}
}
return res;
}
long_int.__format__ = function (self, format_spec) {
var fmt = new $B.parse_format_spec(format_spec);
if (fmt.type && "eEfFgG%".indexOf(fmt.type) != -1) {
return _b_.float.__format__(self, format_spec);
}
fmt.align = fmt.align || ">";
var res = preformat(self, fmt);
if (fmt.comma) {
var sign = res[0] == "-" ? "-" : "",
rest = res.substr(sign.length),
len = rest.length,
nb = Math.ceil(rest.length / 3),
chunks = [];
for (var i = 0; i < nb; i++) {
chunks.push(rest.substring(len - 3 * i - 3, len - 3 * i));
}
chunks.reverse();
res = sign + chunks.join(",");
}
return $B.format_width(res, fmt);
};
long_int.__abs__ = function (self) {
return { __class__: long_int, value: self.value, pos: true };
};
long_int.__add__ = function (self, other) {
if (_b_.isinstance(other, _b_.float)) {
return _b_.float.$factory(to_int(self) + other);
}
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
} else if (other.__class__ !== long_int) {
if (_b_.isinstance(other, _b_.bool)) {
other = long_int.$factory(other ? 1 : 0);
} else if (_b_.isinstance(other, _b_.int)) {
other = long_int.$factory(_b_.str.$factory(_b_.int.__index__(other)));
} else {
return _b_.NotImplemented;
}
}
return from_BigInt(to_BigInt(self) + to_BigInt(other));
};
long_int.__and__ = function (self, other) {
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
return from_BigInt(to_BigInt(self) & to_BigInt(other));
};
long_int.__divmod__ = function (self, other) {
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
var a = to_BigInt(self),
b = to_BigInt(other),
quotient;
if ((a >= 0 && b > 0) || (a <= 0 && b < 0)) {
quotient = a / b;
} else {
quotient = a / b - BigInt(1);
}
var rest = a - quotient * b;
return $B.fast_tuple([from_BigInt(quotient), from_BigInt(rest)]);
};
long_int.__eq__ = function (self, other) {
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
return self.value == other.value && self.pos == other.pos;
};
long_int.__float__ = function (self) {
if (!isFinite(parseFloat(self.value))) {
throw _b_.OverflowError.$factory("int too big to convert to float");
}
return new Number((self.pos ? 1 : -1) * parseFloat(self.value));
};
long_int.__floordiv__ = function (self, other) {
if (_b_.isinstance(other, _b_.float)) {
return _b_.float.$factory(to_int(self) / other);
}
if (typeof other == "number" && Math.abs(other) < $B.max_safe_divider) {
var t = self.value,
res = divmod_by_safe_int(t, other),
pos = other > 0 ? self.pos : !self.pos;
return { __class__: long_int, value: res[0], pos: pos };
}
var res = intOrLong(long_int.__divmod__(self, other)[0]);
return res;
};
long_int.__ge__ = function (self, other) {
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
if (self.pos != other.pos) {
return !other.pos;
}
if (self.value.length > other.value.length) {
return self.pos;
} else if (self.value.length < other.value.length) {
return !self.pos;
} else {
return self.pos ? self.value >= other.value : self.value <= other.value;
}
};
long_int.__gt__ = function (self, other) {
return !long_int.__le__(self, other);
};
long_int.__hash__ = function (self) {
var modulus = $B.fast_long_int("2305843009213693951", true),
self_pos = $B.fast_long_int(self.value, true);
var _hash = $B.long_int.__mod__(self_pos, modulus);
if (typeof _hash == "number") {
_hash = self.pos ? _hash : -_hash;
} else {
_hash.pos = self.pos;
}
return (self.__hashvalue__ = _hash);
};
long_int.__index__ = function (self) {
var res = "",
temp = self.value,
d;
while (true) {
d = divmod_pos(temp, "2");
res = d[1].value + res;
temp = d[0].value;
if (temp == "0") {
break;
}
}
if (!self.pos) {
var nres = "",
flag = false;
for (var len = res.length - 1, i = len; i >= 0; i--) {
var bit = res.charAt(i);
if (bit == "0") {
if (flag) {
nres = "1" + nres;
} else {
nres = "0" + nres;
}
} else {
if (flag) {
nres = "0" + nres;
} else {
flag = true;
nres = "1" + nres;
}
}
}
nres = "1" + nres;
res = nres;
} else {
res = "0" + res;
}
return intOrLong(res);
};
long_int.__invert__ = function (self) {
return long_int.__sub__(long_int.$factory("-1"), self);
};
long_int.__le__ = function (self, other) {
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
if (self.pos !== other.pos) {
return !self.pos;
}
if (self.value.length > other.value.length) {
return !self.pos;
} else if (self.value.length < other.value.length) {
return self.pos;
} else {
return self.pos ? self.value <= other.value : self.value >= other.value;
}
};
long_int.__lt__ = function (self, other) {
return !long_int.__ge__(self, other);
};
long_int.__lshift__ = function (self, shift) {
if (shift.__class__ == long_int) {
shift = shift.value;
}
return intOrLong({
__class__: long_int,
value: (BigInt(self.value) << BigInt(shift)).toString(),
pos: self.pos,
});
};
long_int.__mod__ = function (self, other) {
return intOrLong(long_int.__divmod__(self, other)[1]);
};
long_int.__mro__ = [_b_.int, _b_.object];
long_int.__mul__ = function (self, other) {
switch (self) {
case Number.NEGATIVE_INFINITY:
case Number.POSITIVE_INFINITY:
if ($B.rich_comp("__eq__", other, 0)) {
return NaN;
} else if (_b_.getattr(other, "__gt__")(0)) {
return self;
} else {
return -self;
}
}
if (_b_.isinstance(other, _b_.float)) {
return _b_.float.$factory(to_int(self) * other);
}
if (typeof other == "number") {
other = long_int.$factory(other);
}
other_value = other.value;
other_pos = other.pos;
if (other.__class__ !== long_int && _b_.isinstance(other, _b_.int)) {
var value = _b_.int.__index__(other);
other_value = _b_.str.$factory(value);
other_pos = value > 0;
}
return from_BigInt(to_BigInt(self) * to_BigInt(other));
};
long_int.__ne__ = function (self, other) {
var res = long_int.__eq__(self, other);
return res === _b_.NotImplemented ? res : !res;
};
long_int.__neg__ = function (obj) {
return { __class__: long_int, value: obj.value, pos: !obj.pos };
};
long_int.__or__ = function (self, other) {
other = long_int.$factory(other);
var v1 = long_int.__index__(self);
var v2 = long_int.__index__(other);
if (v1.length < v2.length) {
var temp = v2;
v2 = v1;
v1 = temp;
}
var start = v1.length - v2.length;
var res = v1.substr(0, start);
for (var i = 0; i < v2.length; i++) {
if (v1.charAt(start + i) == "1" || v2.charAt(i) == "1") {
res += "1";
} else {
res += "0";
}
}
return intOrLong(long_int.$factory(res, 2));
};
long_int.__pos__ = function (self) {
return self;
};
long_int.__pow__ = function (self, power, z) {
if (typeof power == "number") {
power = long_int.$from_int(power);
} else if (_b_.isinstance(power, _b_.int)) {
power = long_int.$factory(_b_.str.$factory(_b_.int.__index__(power)));
} else if (!_b_.isinstance(power, long_int)) {
var msg = "power must be an integer, not '";
throw _b_.TypeError.$factory(msg + $B.class_name(power) + "'");
}
if (!power.pos) {
if (self.value == "1") {
return self;
}
return long_int.$factory("0");
} else if (power.value == "0") {
return long_int.$factory("1");
}
var s = $B.BigInt(self.value),
b = $B.BigInt(1),
x = $B.BigInt(power.value),
z =
z === undefined
? z
: typeof z == "number"
? $B.BigInt(z)
: $B.BigInt(z.value);
if (z === undefined) {
return {
__class__: long_int,
value: (s ** x).toString(),
pos: true,
};
}
while (x > 0) {
if (x % $B.BigInt(2) == 1) {
b = b * s;
}
x = x / $B.BigInt(2);
if (x > 0) {
s = s * s;
}
if (z !== undefined) {
b = b % z;
}
}
return { __class__: long_int, value: b.toString(), pos: true };
};
long_int.__rshift__ = function (self, shift) {
if (shift.__class__ === long_int) {
shift = shift.value;
}
return intOrLong({
__class__: long_int,
value: (BigInt(self.value) >> BigInt(shift)).toString(),
pos: self.pos,
});
};
long_int.__str__ = long_int.__repr__ = function (self) {
var res = "";
if (!self.pos) {
res += "-";
}
return res + self.value;
};
long_int.__sub__ = function (self, other) {
if (_b_.isinstance(other, _b_.float)) {
other = other instanceof Number ? other : other.$brython_value;
return _b_.float.$factory(to_int(self) - other);
}
if (typeof other == "number") {
other = long_int.$factory(_b_.str.$factory(other));
}
if ($B.BigInt) {
}
var res;
if (self.pos && other.pos) {
switch (comp_pos(self.value, other.value)) {
case 1:
res = sub_pos(self.value, other.value);
break;
case 0:
res = { __class__: long_int, value: "0", pos: true };
break;
case -1:
res = sub_pos(other.value, self.value);
res.pos = false;
break;
}
return intOrLong(res);
} else if (!self.pos && !other.pos) {
switch (comp_pos(self.value, other.value)) {
case 1:
res = sub_pos(self.value, other.value);
res.pos = false;
break;
case 0:
res = { __class__: long_int, value: "0", pos: true };
break;
case -1:
res = sub_pos(other.value, self.value);
break;
}
return intOrLong(res);
} else if (self.pos && !other.pos) {
return intOrLong(add_pos(self.value, other.value));
} else {
res = add_pos(self.value, other.value);
res.pos = false;
return intOrLong(res);
}
};
long_int.__truediv__ = function (self, other) {
if (_b_.isinstance(other, long_int)) {
return _b_.float.$factory(to_int(self) / to_int(other));
} else if (_b_.isinstance(other, _b_.int)) {
return _b_.float.$factory(to_int(self) / other);
} else if (_b_.isinstance(other, _b_.float)) {
return _b_.float.$factory(to_int(self) / other);
} else {
throw _b_.TypeError.$factory(
"unsupported operand type(s) for /: 'int' and '" +
$B.class_name(other) +
"'"
);
}
};
long_int.__xor__ = function (self, other) {
other = long_int.$factory(other);
var v1 = long_int.__index__(self),
v2 = long_int.__index__(other);
if (v1.length < v2.length) {
var temp = v2;
v2 = v1;
v1 = temp;
}
var start = v1.length - v2.length;
var res = v1.substr(0, start);
for (var i = 0; i < v2.length; i++) {
if (v1.charAt(start + i) == "1" && v2.charAt(i) == "0") {
res += "1";
} else if (v1.charAt(start + i) == "0" && v2.charAt(i) == "1") {
res += "1";
} else {
res += "0";
}
}
return intOrLong(long_int.$factory(res, 2));
};
long_int.bit_length = function (self) {
return binary(self).length;
};
function _infos(self) {
var nbits = $B.long_int.bit_length(self),
pow2 = 2n ** BigInt(nbits - 1),
rest = BigInt(self.value) - pow2,
relative_rest = new Number(rest) / new Number(pow2);
return { nbits, pow2, rest, relative_rest };
}
long_int.$log2 = function (x) {
if (!x.pos) {
throw _b_.ValueError.$factory("math domain error");
}
var infos = _infos(x);
return _b_.float.$factory(
infos.nbits - 1 + Math.log(1 + infos.relative_rest / Math.LN2)
);
};
long_int.$log10 = function (x) {
if (!x.pos) {
throw _b_.ValueError.$factory("math domain error");
}
var exp = x.value.length - 1,
mant = eval(x.value[0] + "." + x.value.substr(1));
return _b_.float.$factory(exp + Math.log10(mant));
};
long_int.numerator = function (self) {
return self;
};
long_int.denominator = function (self) {
return _b_.int.$factory(1);
};
long_int.imag = function (self) {
return _b_.int.$factory(0);
};
long_int.real = function (self) {
return self;
};
long_int.to_base = function (self, base) {
if (base == 2) {
return binary_pos(self.value);
}
var res = "",
v = self.value;
while (v > 0) {
var dm = divmod_pos(v, base.toString());
res = parseInt(dm[1].value).toString(base) + res;
v = dm[0].value;
if (v == 0) {
break;
}
}
return res;
};
long_int.to_bytes = function (self, len, byteorder, signed) {
var res = [],
v = self.value;
if (!$B.$bool(signed) && !self.pos) {
throw _b_.OverflowError.$factory(
"can't convert negative int to unsigned"
);
}
while (v > 0) {
var dm = divmod_pos(v, 256);
v = parseInt(dm[0].value);
res.push(parseInt(dm[1].value));
if (res.length > len) {
throw _b_.OverflowError.$factory("int too big to convert");
}
}
while (res.length < len) {
res.push(0);
}
if (byteorder == "big") {
res.reverse();
}
return _b_.bytes.$factory(res);
};
function digits(base) {
var is_digits = {};
for (var i = 0; i < base; i++) {
if (i == 10) {
break;
}
is_digits[i] = true;
}
if (base > 10) {
for (var i = 0; i < base - 10; i++) {
is_digits[String.fromCharCode(65 + i)] = true;
is_digits[String.fromCharCode(97 + i)] = true;
}
}
return is_digits;
}
var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
var MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER;
function isSafeInteger(n) {
return (
typeof n === "number" &&
Math.round(n) === n &&
MIN_SAFE_INTEGER <= n &&
n <= MAX_SAFE_INTEGER
);
}
function intOrLong(long) {
var v = parseInt(long.value) * (long.pos ? 1 : -1);
if (v > MIN_SAFE_INTEGER && v < MAX_SAFE_INTEGER) {
return v;
}
return long;
}
long_int.$from_int = function (value) {
return { __class__: long_int, value: value.toString(), pos: value > 0 };
};
long_int.$factory = function (value, base) {
if (arguments.length > 2) {
throw _b_.TypeError.$factory(
"long_int takes at most 2 arguments (" + arguments.length + " given)"
);
}
if (base === undefined) {
base = 10;
} else if (!_b_.isinstance(base, _b_.int)) {
throw _b_.TypeError.$factory(
"'" +
$B.class_name(base) +
"' object cannot be interpreted as an integer"
);
}
if (base < 0 || base == 1 || base > 36) {
throw _b_.ValueError.$factory(
"long_int.$factory() base must be >= 2 and <= 36"
);
}
if (typeof value == "number") {
var pos = value >= 0,
value = Math.abs(value),
res;
if (isSafeInteger(value)) {
res = long_int.$from_int(value);
} else if (value.constructor == Number) {
var s = value.toString(),
pos_exp = s.search("e");
if (pos_exp > -1) {
var mant = s.substr(0, pos_exp),
exp = parseInt(s.substr(pos_exp + 1)),
point = mant.search(/\./);
if (point > -1) {
var nb_dec = mant.substr(point + 1).length;
if (nb_dec > exp) {
var res =
mant.substr(0, point) + mant.substr(point + 1).substr(0, exp);
res = long_int.$from_int(res);
} else {
var res =
mant.substr(0, point) +
mant.substr(point + 1) +
"0".repeat(exp - nb_dec);
res = long_int.$from_int(res);
}
} else {
res = long_int.$from_int(mant + "0".repeat(exp));
}
} else {
var point = s.search(/\./);
if (point > -1) {
res = long_int.$from_int(s.substr(0, point));
} else {
res = long_int.$from_int(s);
}
}
} else {
throw _b_.ValueError.$factory(
"argument of long_int is not a safe integer"
);
}
res.pos = pos;
return res;
} else if (_b_.isinstance(value, _b_.float)) {
if (
value === Number.POSITIVE_INFINITY ||
value === Number.NEGATIVE_INFINITY
) {
return value;
}
if (value >= 0) {
value = new Number(Math.round(value.value));
} else {
value = new Number(Math.ceil(value.value));
}
} else if (_b_.isinstance(value, _b_.bool)) {
if (value.valueOf()) {
return _b_.int.$factory(1);
}
return _b_.int.$factory(0);
} else if (value.__class__ === long_int) {
return value;
} else if (_b_.isinstance(value, _b_.int)) {
value = value.$brython_value + "";
} else if (_b_.isinstance(value, _b_.bool)) {
value = _b_.bool.__int__(value) + "";
} else if (typeof value != "string") {
throw _b_.ValueError.$factory(
"argument of long_int must be a string, not " + $B.class_name(value)
);
}
var has_prefix = false,
pos = true,
start = 0;
while (value.charAt(0) == " " && value.length) {
value = value.substr(1);
}
while (value.charAt(value.length - 1) == " " && value.length) {
value = value.substr(0, value.length - 1);
}
if (value.charAt(0) == "+") {
has_prefix = true;
} else if (value.charAt(0) == "-") {
has_prefix = true;
pos = false;
}
if (has_prefix) {
if (value.length == 1) {
throw _b_.ValueError.$factory(
'long_int argument is not a valid number: "' + value + '"'
);
} else {
value = value.substr(1);
}
}
while (start < value.length - 1 && value.charAt(start) == "0") {
start++;
}
value = value.substr(start);
var is_digits = digits(base),
point = -1;
for (var i = 0; i < value.length; i++) {
if (value.charAt(i) == "." && point == -1) {
point = i;
} else if (false) {
var mant = value.substr(0, i);
if (/^[+-]?\d+$/.exec(value.substr(i + 1))) {
exp = parseInt(value.substr(i + 1));
} else {
throw Error("wrong exp " + value.substr(i + 1));
}
if (point != -1) {
mant = mant.substr(0, point) + mant.substr(point + 1);
exp = exp + point - 1;
}
point = -1;
value = mant + "0".repeat(exp - mant.length);
break;
} else if (!is_digits[value.charAt(i)]) {
throw _b_.ValueError.$factory(
'long_int argument is not a valid number: "' + value + '"'
);
}
}
if (point != -1) {
value = value.substr(0, point);
}
if (base != 10) {
var coef = "1",
v10 = long_int.$factory(0),
ix = value.length;
while (ix--) {
var digit_base10 = parseInt(value.charAt(ix), base).toString(),
digit_by_coef = mul_pos(coef, digit_base10).value;
v10 = add_pos(v10.value, digit_by_coef);
coef = mul_pos(coef, base.toString()).value;
}
return v10;
}
return { __class__: long_int, value: value, pos: pos };
};
function extended_euclidean_algorithm(a, b) {
var s = 0,
old_s = 1,
t = 1,
old_t = 0,
r = b,
old_r = a,
quotient,
tmp;
while ($B.rich_comp("__ne__", r, 0)) {
quotient = $B.rich_op("__floordiv__", old_r, r);
tmp = $B.rich_op("__sub__", old_r, $B.rich_op("__mul__", quotient, r));
old_r = r;
r = tmp;
tmp = $B.rich_op("__sub__", old_s, $B.rich_op("__mul__", quotient, s));
old_s = s;
s = tmp;
tmp = $B.rich_op("__sub__", old_t, $B.rich_op("__mul__", quotient, t));
old_t = t;
t = tmp;
}
return [old_r, old_s, old_t];
}
function inverse_of(n, p) {
var gcd, x, y;
[gcd, x, y] = extended_euclidean_algorithm(n, p);
if ($B.rich_comp("__ne__", gcd, 1)) {
throw Error(
`${n} has no multiplicative inverse '
'modulo ${p}`
);
} else {
return $B.rich_op("__mod__", x, p);
}
}
$B.inverse_of = inverse_of;
$B.set_func_names(long_int, "builtins");
$B.long_int = long_int;
$B.fast_long_int = function (value, pos) {
return { __class__: $B.long_int, value: value, pos: pos };
};
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var object = _b_.object;
function $err(op, other) {
var msg =
"unsupported operand type(s) for " +
op +
": 'float' and '" +
$B.class_name(other) +
"'";
throw _b_.TypeError.$factory(msg);
}
function float_value(obj) {
return obj.$brython_value !== undefined ? obj.$brython_value : obj;
}
var float = {
__class__: _b_.type,
__dir__: object.__dir__,
$infos: { __module__: "builtins", __name__: "float" },
$is_class: true,
$native: true,
$descriptors: {
numerator: true,
denominator: true,
imag: true,
real: true,
},
};
float.numerator = function (self) {
return float_value(self);
};
float.denominator = function (self) {
return _b_.int.$factory(1);
};
float.imag = function (self) {
return _b_.int.$factory(0);
};
float.real = function (self) {
return float_value(self);
};
float.__float__ = function (self) {
return float_value(self);
};
$B.shift1_cache = {};
float.as_integer_ratio = function (self) {
self = float_value(self);
if (
self.valueOf() == Number.POSITIVE_INFINITY ||
self.valueOf() == Number.NEGATIVE_INFINITY
) {
throw _b_.OverflowError.$factory(
"Cannot pass infinity to " + "float.as_integer_ratio."
);
}
if (!Number.isFinite(self.valueOf())) {
throw _b_.ValueError.$factory(
"Cannot pass NaN to " + "float.as_integer_ratio."
);
}
var tmp = frexp(self.valueOf()),
fp = tmp[0],
exponent = tmp[1];
for (var i = 0; i < 300; i++) {
if (fp == Math.floor(fp)) {
break;
} else {
fp *= 2;
exponent--;
}
}
numerator = _b_.int.$factory(fp);
py_exponent = _b_.abs(exponent);
denominator = 1;
var x;
if ($B.shift1_cache[py_exponent] !== undefined) {
x = $B.shift1_cache[py_exponent];
} else {
x = $B.$getattr(1, "__lshift__")(py_exponent);
$B.shift1_cache[py_exponent] = x;
}
py_exponent = x;
if (exponent > 0) {
numerator = $B.rich_op("__mul__", numerator, py_exponent);
} else {
denominator = py_exponent;
}
return $B.fast_tuple([
_b_.int.$factory(numerator),
_b_.int.$factory(denominator),
]);
};
float.__abs__ = function (self) {
return new Number(Math.abs(float_value(self)));
};
float.__bool__ = function (self) {
self = float_value(self);
return _b_.bool.$factory(self.valueOf());
};
float.__divmod__ = function (self, other) {
if (!_b_.isinstance(other, [_b_.int, float])) {
return _b_.NotImplemented;
}
return $B.fast_tuple([
float.__floordiv__(self, other),
float.__mod__(self, other),
]);
};
float.__eq__ = function (self, other) {
self = float_value(self);
other = float_value(other);
if (isNaN(self) && isNaN(other)) {
return false;
}
if (_b_.isinstance(other, _b_.int)) {
return self == other;
}
if (_b_.isinstance(other, float)) {
return self.valueOf() == other.valueOf();
}
if (_b_.isinstance(other, _b_.complex)) {
if (other.$imag != 0) {
return false;
}
return self == other.$real;
}
return _b_.NotImplemented;
};
float.__floordiv__ = function (self, other) {
self = float_value(self);
other = float_value(other);
if (_b_.isinstance(other, [_b_.int, float])) {
if (other.valueOf() == 0) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
return float.$factory(Math.floor(self / other));
}
return _b_.NotImplemented;
};
float.fromhex = function (arg) {
if (!_b_.isinstance(arg, _b_.str)) {
throw _b_.ValueError.$factory("argument must be a string");
}
var value = arg.trim();
switch (value.toLowerCase()) {
case "+inf":
case "inf":
case "+infinity":
case "infinity":
return $FloatClass(Infinity);
case "-inf":
case "-infinity":
return $FloatClass(-Infinity);
case "+nan":
case "nan":
return $FloatClass(Number.NaN);
case "-nan":
return $FloatClass(-Number.NaN);
case "":
throw _b_.ValueError.$factory("could not convert string to float");
}
var mo = /^(\d*)(\.?)(\d*)$/.exec(value);
if (mo !== null) {
var res = parseFloat(mo[1]),
coef = 16;
if (mo[2]) {
for (var digit of mo[3]) {
res += parseInt(digit, 16) / coef;
coef *= 16;
}
}
return $FloatClass(res);
}
var _m = /^(\+|-)?(0x)?([0-9A-F]+\.?)?(\.[0-9A-F]+)?(p(\+|-)?\d+)?$/i.exec(
value
);
if (_m == null) {
throw _b_.ValueError.$factory(
"invalid hexadecimal floating-point string"
);
}
var _sign = _m[1],
_int = parseInt(_m[3] || "0", 16),
_fraction = _m[4] || ".0",
_exponent = _m[5] || "p0";
if (_sign == "-") {
_sign = -1;
} else {
_sign = 1;
}
var _sum = _int;
for (var i = 1, len = _fraction.length; i < len; i++) {
_sum += parseInt(_fraction.charAt(i), 16) / Math.pow(16, i);
}
return new Number(
_sign * _sum * Math.pow(2, parseInt(_exponent.substring(1)))
);
};
float.__getformat__ = function (arg) {
if (arg == "double" || arg == "float") {
return "IEEE, little-endian";
}
throw _b_.ValueError.$factory(
"__getformat__() argument 1 must be " + "'double' or 'float'"
);
};
function preformat(self, fmt) {
if (fmt.empty) {
return _b_.str.$factory(self);
}
if (fmt.type && "eEfFgGn%".indexOf(fmt.type) == -1) {
throw _b_.ValueError.$factory(
"Unknown format code '" + fmt.type + "' for object of type 'float'"
);
}
if (isNaN(self)) {
if (fmt.type == "f" || fmt.type == "g") {
return "nan";
} else {
return "NAN";
}
}
if (self == Number.POSITIVE_INFINITY) {
if (fmt.type == "f" || fmt.type == "g") {
return "inf";
} else {
return "INF";
}
}
if (fmt.precision === undefined && fmt.type !== undefined) {
fmt.precision = 6;
}
if (fmt.type == "%") {
self *= 100;
}
if (fmt.type == "e") {
var res = self.toExponential(fmt.precision),
exp = parseInt(res.substr(res.search("e") + 1));
if (Math.abs(exp) < 10) {
res = res.substr(0, res.length - 1) + "0" + res.charAt(res.length - 1);
}
return res;
}
if (fmt.precision !== undefined) {
var prec = fmt.precision;
if (prec == 0) {
return Math.round(self) + "";
}
var res = self.toFixed(prec),
pt_pos = res.indexOf(".");
if (
fmt.type !== undefined &&
(fmt.type == "%" || fmt.type.toLowerCase() == "f")
) {
if (pt_pos == -1) {
res += "." + "0".repeat(fmt.precision);
} else {
var missing = fmt.precision - res.length + pt_pos + 1;
if (missing > 0) {
res += "0".repeat(missing);
}
}
} else if (fmt.type && fmt.type.toLowerCase() == "g") {
var exp_fmt = preformat(self, { type: "e" }).split("e"),
exp = parseInt(exp_fmt[1]);
if (-4 <= exp && exp < fmt.precision) {
res = preformat(self, {
type: "f",
precision: fmt.precision - 1 - exp,
});
} else {
res = preformat(self, { type: "e", precision: fmt.precision - 1 });
}
var parts = res.split("e");
if (fmt.alternate) {
if (parts[0].search(/\./) == -1) {
parts[0] += ".";
}
} else {
if (parts[1]) {
var signif = parts[0];
while (signif.endsWith("0")) {
signif = signif.substr(0, signif.length - 1);
}
if (signif.endsWith(".")) {
signif = signif.substr(0, signif.length - 1);
}
parts[0] = signif;
}
}
res = parts.join("e");
if (fmt.type == "G") {
res = res.toUpperCase();
}
return res;
} else if (fmt.type === undefined) {
fmt.type = "g";
res = preformat(self, fmt);
fmt.type = undefined;
} else {
var res1 = self.toExponential(fmt.precision - 1),
exp = parseInt(res1.substr(res1.search("e") + 1));
if (exp < -4 || exp >= fmt.precision - 1) {
var elts = res1.split("e");
while (elts[0].endsWith("0")) {
elts[0] = elts[0].substr(0, elts[0].length - 1);
}
res = elts.join("e");
}
}
} else {
var res = _b_.str.$factory(self);
}
if (fmt.type === undefined || "gGn".indexOf(fmt.type) != -1) {
if (res.search("e") == -1) {
while (res.charAt(res.length - 1) == "0") {
res = res.substr(0, res.length - 1);
}
}
if (res.charAt(res.length - 1) == ".") {
if (fmt.type === undefined) {
res += "0";
} else {
res = res.substr(0, res.length - 1);
}
}
}
if (fmt.sign !== undefined) {
if ((fmt.sign == " " || fmt.sign == "+") && self > 0) {
res = fmt.sign + res;
}
}
if (fmt.type == "%") {
res += "%";
}
return res;
}
float.__format__ = function (self, format_spec) {
self = float_value(self);
var fmt = new $B.parse_format_spec(format_spec);
fmt.align = fmt.align || ">";
var raw = preformat(self, fmt).split("."),
_int = raw[0];
if (fmt.comma) {
var len = _int.length,
nb = Math.ceil(_int.length / 3),
chunks = [];
for (var i = 0; i < nb; i++) {
chunks.push(_int.substring(len - 3 * i - 3, len - 3 * i));
}
chunks.reverse();
raw[0] = chunks.join(",");
}
return $B.format_width(raw.join("."), fmt);
};
float.__hash__ = function (self) {
if (self === undefined) {
return float.__hashvalue__ || $B.$py_next_hash--;
}
var _v = self.valueOf();
if (_v === Infinity) {
return 314159;
}
if (_v === -Infinity) {
return -271828;
}
if (isNaN(_v)) {
return 0;
}
if (_v == Math.round(_v)) {
return Math.round(_v);
}
var r = frexp(_v);
r[0] *= Math.pow(2, 31);
var hipart = _b_.int.$factory(r[0]);
r[0] = (r[0] - hipart) * Math.pow(2, 31);
var x = hipart + _b_.int.$factory(r[0]) + (r[1] << 15);
return x & 0xffffffff;
};
function isninf(x) {
var x1 = x;
if (_b_.isinstance(x, float)) {
x1 = float.numerator(x);
}
return x1 == -Infinity || x1 == Number.NEGATIVE_INFINITY;
}
function isinf(x) {
var x1 = x;
if (!x instanceof Number && _b_.isinstance(x, float)) {
x1 = float.numerator(x);
}
return (
x1 == Infinity ||
x1 == -Infinity ||
x1 == Number.POSITIVE_INFINITY ||
x1 == Number.NEGATIVE_INFINITY
);
}
function isnan(x) {
var x1 = x;
if (_b_.isinstance(x, float)) {
x1 = float.numerator(x);
}
return isNaN(x1);
}
function fabs(x) {
if (x == 0) {
return new Number(0);
}
return x > 0 ? float.$factory(x) : float.$factory(-x);
}
function frexp(x) {
var x1 = x;
if (_b_.isinstance(x, float)) {
x1 = x.valueOf();
}
if (isNaN(x1) || isinf(x1)) {
return [x1, -1];
} else if (x1 == 0) {
return [0, 0];
}
var sign = 1,
ex = 0,
man = x1;
if (man < 0) {
sign = -sign;
man = -man;
}
while (man < 0.5) {
man *= 2.0;
ex--;
}
while (man >= 1.0) {
man *= 0.5;
ex++;
}
man *= sign;
return [man, ex];
}
function ldexp(x, i) {
if (isninf(x)) {
return float.$factory("-inf");
}
if (isinf(x)) {
return float.$factory("inf");
}
var y = x;
if (_b_.isinstance(x, float)) {
y = x.valueOf();
}
if (y == 0) {
return y;
}
var j = i;
if (_b_.isinstance(i, float)) {
j = i.valueOf();
}
return y * Math.pow(2, j);
}
float.$funcs = { isinf, isninf, isnan, fabs, frexp, ldexp };
float.hex = function (self) {
self = float_value(self);
var DBL_MANT_DIG = 53,
TOHEX_NBITS = DBL_MANT_DIG + 3 - ((DBL_MANT_DIG + 2) % 4);
switch (self.valueOf()) {
case Infinity:
case -Infinity:
case Number.NaN:
case -Number.NaN:
return self;
case -0:
return "-0x0.0p0";
case 0:
return "0x0.0p0";
}
var _a = frexp(fabs(self.valueOf())),
_m = _a[0],
_e = _a[1],
_shift = 1 - Math.max(-1021 - _e, 0);
_m = ldexp(_m, _shift);
_e -= _shift;
var _int2hex = "0123456789ABCDEF".split(""),
_s = _int2hex[Math.floor(_m)];
_s += ".";
_m -= Math.floor(_m);
for (var i = 0; i < (TOHEX_NBITS - 1) / 4; i++) {
_m *= 16.0;
_s += _int2hex[Math.floor(_m)];
_m -= Math.floor(_m);
}
var _esign = "+";
if (_e < 0) {
_esign = "-";
_e = -_e;
}
if (self.value < 0) {
return "-0x" + _s + "p" + _esign + _e;
}
return "0x" + _s + "p" + _esign + _e;
};
float.__init__ = function (self, value) {
return _b_.None;
};
float.__int__ = function (self) {
return parseInt(self);
};
float.is_integer = function (self) {
return _b_.int.$factory(self) == self;
};
float.__mod__ = function (self, other) {
self = float_value(self);
other = float_value(other);
if (other == 0) {
throw _b_.ZeroDivisionError.$factory("float modulo");
}
if (_b_.isinstance(other, _b_.int)) {
other = _b_.int.numerator(other);
return new Number(((self % other) + other) % other);
}
if (_b_.isinstance(other, float)) {
var q = Math.floor(self / other),
r = self - other * q;
return new Number(r);
}
return _b_.NotImplemented;
};
float.__mro__ = [object];
float.__mul__ = function (self, other) {
self = float_value(self);
other = float_value(other);
if (_b_.isinstance(other, _b_.int)) {
if (other.__class__ == $B.long_int) {
return new Number(self * parseFloat(other.value));
}
other = _b_.int.numerator(other);
return new Number(self * other);
}
if (_b_.isinstance(other, float)) {
return new Number(self * float_value(other));
}
return _b_.NotImplemented;
};
float.__ne__ = function (self, other) {
var res = float.__eq__(self, other);
return res === _b_.NotImplemented ? res : !res;
};
float.__neg__ = function (self) {
return new Number(-float_value(self));
};
float.__new__ = function (cls, value) {
if (cls === undefined) {
throw _b_.TypeError.$factory("float.__new__(): not enough arguments");
} else if (!_b_.isinstance(cls, _b_.type)) {
throw _b_.TypeError.$factory("float.__new__(X): X is not a type object");
}
if (cls === float) {
return float.$factory(value);
}
return {
__class__: cls,
__dict__: $B.empty_dict(),
$brython_value: value || 0,
};
};
float.__pos__ = function (self) {
return float_value(self);
};
float.__pow__ = function (self, other) {
self = float_value(self);
other = float_value(other);
var other_int = _b_.isinstance(other, _b_.int);
if (other_int || _b_.isinstance(other, float)) {
if (self == 1) {
return new Number(1);
}
if (other == 0) {
return new Number(1);
}
if (
self == -1 &&
(!isFinite(other) ||
other.__class__ === $B.long_int ||
!$B.is_safe_int(other)) &&
!isNaN(other)
) {
return new Number(1);
} else if (self == 0 && isFinite(other) && other < 0) {
throw _b_.ZeroDivisionError.$factory(
"0.0 cannot be raised " + "to a negative power"
);
} else if (self == Number.NEGATIVE_INFINITY && !isNaN(other)) {
if (other < 0 && other % 2 == 1) {
return new Number(-0.0);
} else if (other < 0) {
return new Number(0);
} else if (other > 0 && other % 2 == 1) {
return Number.NEGATIVE_INFINITY;
} else {
return Number.POSITIVE_INFINITY;
}
} else if (self == Number.POSITIVE_INFINITY && !isNaN(other)) {
return other > 0 ? self : new Number(0);
}
if (other == Number.NEGATIVE_INFINITY && !isNaN(self)) {
return Math.abs(self) < 1 ? Number.POSITIVE_INFINITY : new Number(0);
} else if (other == Number.POSITIVE_INFINITY && !isNaN(self)) {
return Math.abs(self) < 1 ? new Number(0) : Number.POSITIVE_INFINITY;
}
if (self < 0 && !$B.$getattr(other, "__eq__")(_b_.int.$factory(other))) {
return _b_.complex.__pow__($B.make_complex(self, 0), other);
}
return float.$factory(Math.pow(self, other));
}
return _b_.NotImplemented;
};
function __newobj__() {
var $ = $B.args("__newobj__", 0, {}, [], arguments, {}, "args", null),
args = $.args;
var res = args.slice(1);
res.__class__ = args[0];
return res;
}
float.__reduce_ex__ = function (self) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__ || _b_.int, float_value(self)]),
_b_.None,
_b_.None,
_b_.None,
]);
};
float.__repr__ = function (self) {
$B.builtins_repr_check(float, arguments);
self = float_value(self).valueOf();
if (self == Infinity) {
return "inf";
} else if (self == -Infinity) {
return "-inf";
} else if (isNaN(self)) {
return "nan";
} else if (self === 0) {
if (1 / self === -Infinity) {
return "-0.0";
}
return "0.0";
}
var res = self + "";
if (res.search(/[.eE]/) == -1) {
res += ".0";
}
var split_e = res.split(/e/i);
if (split_e.length == 2) {
var mant = split_e[0],
exp = split_e[1];
if (exp.startsWith("-")) {
exp_str = parseInt(exp.substr(1)) + "";
if (exp_str.length < 2) {
exp_str = "0" + exp_str;
}
return mant + "e-" + exp_str;
}
}
var x, y;
[x, y] = res.split(".");
var sign = "";
if (x[0] == "-") {
x = x.substr(1);
sign = "-";
}
if (x.length > 16) {
var exp = x.length - 1,
int_part = x[0],
dec_part = x.substr(1) + y;
while (dec_part.endsWith("0")) {
dec_part = dec_part.substr(0, dec_part.length - 1);
}
var mant = int_part;
if (dec_part.length > 0) {
mant += "." + dec_part;
}
return sign + mant + "e+" + exp;
} else if (x == "0") {
var exp = 0;
while (exp < y.length && y.charAt(exp) == "0") {
exp++;
}
if (exp > 3) {
var rest = y.substr(exp),
exp = (exp + 1).toString();
while (rest.endsWith("0")) {
rest = rest.substr(0, res.length - 1);
}
var mant = rest[0];
if (rest.length > 1) {
mant += "." + rest.substr(1);
}
if (exp.length == 1) {
exp = "0" + exp;
}
return sign + mant + "e-" + exp;
}
}
return _b_.str.$factory(res);
};
float.__setattr__ = function (self, attr, value) {
if (self.constructor === Number) {
if (float[attr] === undefined) {
throw _b_.AttributeError.$factory(
"'float' object has no attribute '" + attr + "'"
);
} else {
throw _b_.AttributeError.$factory(
"'float' object attribute '" + attr + "' is read-only"
);
}
}
self[attr] = value;
return _b_.None;
};
float.__truediv__ = function (self, other) {
self = float_value(self);
other = float_value(other);
if (_b_.isinstance(other, [_b_.int, float])) {
if (other.valueOf() == 0) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
return float.$factory(self / other);
}
return _b_.NotImplemented;
};
var $op_func = function (self, other) {
self = float_value(self);
other = float_value(other);
if (_b_.isinstance(other, _b_.int)) {
if (typeof other == "boolean") {
return other ? self - 1 : self;
} else if (other.__class__ === $B.long_int) {
return float.$factory(self - parseInt(other.value));
} else {
return float.$factory(self - other);
}
}
if (_b_.isinstance(other, float)) {
return float.$factory(self - other);
}
return _b_.NotImplemented;
};
$op_func += "";
var $ops = { "+": "add", "-": "sub" };
for (var $op in $ops) {
var $opf = $op_func.replace(/-/gm, $op);
$opf = $opf.replace(/__rsub__/gm, "__r" + $ops[$op] + "__");
eval("float.__" + $ops[$op] + "__ = " + $opf);
}
var $comp_func = function (self, other) {
self = float_value(self);
other = float_value(other);
if (_b_.isinstance(other, _b_.int)) {
if (other.__class__ === $B.long_int) {
return self > parseInt(other.value);
}
return self > other.valueOf();
}
if (_b_.isinstance(other, float)) {
return self > other;
}
if (_b_.isinstance(other, _b_.bool)) {
return self.valueOf() > _b_.bool.__hash__(other);
}
if (_b_.hasattr(other, "__int__") || _b_.hasattr(other, "__index__")) {
return _b_.int.__gt__(self, $B.$GetInt(other));
}
var inv_op = $B.$getattr(other, "__le__", _b_.None);
if (inv_op !== _b_.None) {
return inv_op(self);
}
throw _b_.TypeError.$factory(
"unorderable types: float() > " + $B.class_name(other) + "()"
);
};
$comp_func += "";
for (var $op in $B.$comps) {
eval(
"float.__" +
$B.$comps[$op] +
"__ = " +
$comp_func
.replace(/>/gm, $op)
.replace(/__gt__/gm, "__" + $B.$comps[$op] + "__")
.replace(/__le__/, "__" + $B.$inv_comps[$op] + "__")
);
}
var r_opnames = [
"add",
"sub",
"mul",
"truediv",
"floordiv",
"mod",
"pow",
"lshift",
"rshift",
"and",
"xor",
"or",
"divmod",
];
for (var r_opname of r_opnames) {
if (
float["__r" + r_opname + "__"] === undefined &&
float["__" + r_opname + "__"]
) {
float["__r" + r_opname + "__"] = (function (name) {
return function (self, other) {
if (_b_.isinstance(other, _b_.int)) {
other = float_value(_b_.int.numerator(other));
return float["__" + name + "__"](other, self);
} else if (_b_.isinstance(other, float)) {
other = float_value(other);
return float["__" + name + "__"](other, self);
}
return _b_.NotImplemented;
};
})(r_opname);
}
}
function $FloatClass(value) {
return new Number(value);
}
function to_digits(s) {
var arabic_digits =
"\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669",
res = "";
for (var i = 0; i < s.length; i++) {
var x = arabic_digits.indexOf(s[i]);
if (x > -1) {
res += x;
} else {
res += s[i];
}
}
return res;
}
float.$factory = function (value) {
switch (value) {
case undefined:
return $FloatClass(0.0);
case Number.MAX_VALUE:
return $FloatClass(Infinity);
case -Number.MAX_VALUE:
return $FloatClass(-Infinity);
case true:
return new Number(1);
case false:
return new Number(0);
}
if (typeof value == "number") {
return new Number(value);
}
if (_b_.isinstance(value, float)) {
return float_value(value);
}
if (_b_.isinstance(value, _b_.bytes)) {
var s = $B.$getattr(value, "decode")("latin-1");
return float.$factory($B.$getattr(value, "decode")("latin-1"));
}
if (typeof value == "string") {
value = value.trim();
switch (value.toLowerCase()) {
case "+inf":
case "inf":
case "+infinity":
case "infinity":
return Number.POSITIVE_INFINITY;
case "-inf":
case "-infinity":
return Number.NEGATIVE_INFINITY;
case "+nan":
case "nan":
return Number.NaN;
case "-nan":
return -Number.NaN;
case "":
throw _b_.ValueError.$factory("count not convert string to float");
default:
value = value.charAt(0) + value.substr(1).replace(/_/g, "");
value = to_digits(value);
if (isFinite(value)) return $FloatClass(eval(value));
else {
_b_.str.encode(value, "latin-1");
throw _b_.ValueError.$factory(
"Could not convert to float(): '" + _b_.str.$factory(value) + "'"
);
}
}
}
var klass = value.__class__ || $B.get_class(value),
num_value = $B.to_num(value, ["__float__", "__index__"]);
if (value !== Number.POSITIVE_INFINITY && !isFinite(num_value)) {
throw _b_.OverflowError.$factory("int too large to convert to float");
}
if (num_value !== null) {
return num_value;
}
throw _b_.TypeError.$factory(
"float() argument must be a string or a " +
"number, not '" +
$B.class_name(value) +
"'"
);
};
$B.$FloatClass = $FloatClass;
$B.set_func_names(float, "builtins");
var FloatSubclass = ($B.FloatSubclass = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "builtins", __name__: "float" },
$is_class: true,
});
for (var $attr in float) {
if (typeof float[$attr] == "function") {
FloatSubclass[$attr] = (function (attr) {
return function () {
var args = [],
pos = 0;
if (arguments.length > 0) {
var args = [arguments[0].valueOf()],
pos = 1;
for (var i = 1, len = arguments.length; i < len; i++) {
args[pos++] = arguments[i];
}
}
return float[attr].apply(null, args);
};
})($attr);
}
}
$B.set_func_names(FloatSubclass, "builtins");
_b_.float = float;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
function $UnsupportedOpType(op, class1, class2) {
throw _b_.TypeError.$factory(
"unsupported operand type(s) for " +
op +
": '" +
class1 +
"' and '" +
class2 +
"'"
);
}
var complex = {
__class__: _b_.type,
__dir__: _b_.object.__dir__,
$infos: { __module__: "builtins", __name__: "complex" },
$is_class: true,
$native: true,
$descriptors: { real: true, imag: true },
};
complex.__abs__ = function (self) {
var _rf = isFinite(self.$real),
_if = isFinite(self.$imag);
if (
(_rf && isNaN(self.$imag)) ||
(_if && isNaN(self.$real)) ||
(isNaN(self.$imag) && isNaN(self.$real))
) {
return NaN;
}
if (!_rf || !_if) {
return Infinity;
}
var mag = Math.sqrt(Math.pow(self.$real, 2) + Math.pow(self.$imag, 2));
if (!isFinite(mag) && _rf && _if) {
throw _b_.OverflowError.$factory("absolute value too large");
}
return mag;
};
complex.__add__ = function (self, other) {
if (_b_.isinstance(other, complex)) {
return make_complex(self.$real + other.$real, self.$imag + other.$imag);
}
if (_b_.isinstance(other, _b_.int)) {
other = _b_.int.numerator(other);
return make_complex($B.add(self.$real, other.valueOf()), self.$imag);
}
if (_b_.isinstance(other, _b_.float)) {
return make_complex(self.$real + other.valueOf(), self.$imag);
}
return _b_.NotImplemented;
};
complex.__bool__ = function (self) {
return self.$real != 0 || self.$imag != 0;
};
complex.__complex__ = function (self) {
return self;
};
complex.__eq__ = function (self, other) {
if (_b_.isinstance(other, complex)) {
return (
self.$real.valueOf() == other.$real.valueOf() &&
self.$imag.valueOf() == other.$imag.valueOf()
);
}
if (_b_.isinstance(other, _b_.int)) {
if (self.$imag != 0) {
return false;
}
return self.$real == other.valueOf();
}
if (_b_.isinstance(other, _b_.float)) {
if (self.$imag != 0) {
return false;
}
return self.$real == other.valueOf();
}
return _b_.NotImplemented;
};
complex.__hash__ = function (self) {
return self.$imag * 1000003 + self.$real;
};
complex.__init__ = function () {
return _b_.None;
};
complex.__invert__ = function (self) {
return ~self;
};
complex.__mro__ = [_b_.object];
complex.__mul__ = function (self, other) {
if (_b_.isinstance(other, complex)) {
return make_complex(
self.$real * other.$real - self.$imag * other.$imag,
self.$imag * other.$real + self.$real * other.$imag
);
} else if (_b_.isinstance(other, _b_.int)) {
return make_complex(
self.$real * other.valueOf(),
self.$imag * other.valueOf()
);
} else if (_b_.isinstance(other, _b_.float)) {
return make_complex(self.$real * other, self.$imag * other);
} else if (_b_.isinstance(other, _b_.bool)) {
if (other.valueOf()) {
return self;
}
return make_complex(0, 0);
}
$UnsupportedOpType("*", complex, other);
};
complex.__ne__ = function (self, other) {
var res = complex.__eq__(self, other);
return res === _b_.NotImplemented ? res : !res;
};
complex.__neg__ = function (self) {
return make_complex(-self.$real, -self.$imag);
};
complex.__new__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory("complex.__new__(): not enough arguments");
}
var res,
missing = {},
args = $B.args(
"complex",
3,
{ cls: null, real: null, imag: null },
["cls", "real", "imag"],
arguments,
{ real: 0, imag: missing },
null,
null
),
$real = args.real,
$imag = args.imag;
if (typeof $real == "string") {
if ($imag !== missing) {
throw _b_.TypeError.$factory(
"complex() can't take second arg " + "if first is a string"
);
} else {
var arg = $real;
$real = $real.trim();
if ($real.startsWith("(") && $real.endsWith(")")) {
$real = $real.substr(1);
$real = $real.substr(0, $real.length - 1);
}
var complex_re =
/^\s*([\+\-]*[0-9_]*\.?[0-9_]*(e[\+\-]*[0-9_]*)?)([\+\-]?)([0-9_]*\.?[0-9_]*(e[\+\-]*[0-9_]*)?)(j?)\s*$/i;
var parts = complex_re.exec($real);
function to_num(s) {
var res = parseFloat(s.charAt(0) + s.substr(1).replace(/_/g, ""));
if (isNaN(res)) {
throw _b_.ValueError.$factory(
"could not convert string " + "to complex: '" + arg + "'"
);
}
return res;
}
if (parts === null) {
throw _b_.ValueError.$factory("complex() arg is a malformed string");
} else if (
parts[_real] == "." ||
parts[_imag] == "." ||
parts[_real] == ".e" ||
parts[_imag] == ".e" ||
parts[_real] == "e" ||
parts[_imag] == "e"
) {
throw _b_.ValueError.$factory("complex() arg is a malformed string");
} else if (parts[_j] != "") {
if (parts[_sign] == "") {
$real = 0;
if (parts[_real] == "+" || parts[_real] == "") {
$imag = 1;
} else if (parts[_real] == "-") {
$imag = -1;
} else {
$imag = to_num(parts[_real]);
}
} else {
$real = to_num(parts[_real]);
$imag = parts[_imag] == "" ? 1 : to_num(parts[_imag]);
$imag = parts[_sign] == "-" ? -$imag : $imag;
}
} else {
$real = to_num(parts[_real]);
$imag = 0;
}
res = { __class__: complex, $real: $real || 0, $imag: $imag || 0 };
return res;
}
}
$imag = $imag === missing ? 0 : $imag;
if (arguments.length == 2 && $real.__class__ === complex && $imag == 0) {
return $real;
}
if (
_b_.isinstance($real, [_b_.float, _b_.int]) &&
_b_.isinstance($imag, [_b_.float, _b_.int])
) {
res = { __class__: complex, $real: $real, $imag: $imag };
return res;
}
var real_to_num = $B.to_num($real, [
"__complex__",
"__float__",
"__index__",
]);
if (real_to_num === null) {
throw _b_.TypeError.$factory(
"complex() first argument must be a " +
" string or a number, not '" +
$B.class_name($real) +
"'"
);
}
$real = real_to_num;
$imag = _convert($imag);
if (
!_b_.isinstance($real, _b_.float) &&
!_b_.isinstance($real, _b_.int) &&
!_b_.isinstance($real, _b_.complex)
) {
throw _b_.TypeError.$factory(
"complex() argument must be a string " + "or a number"
);
}
if (typeof $imag == "string") {
throw _b_.TypeError.$factory("complex() second arg can't be a string");
}
if (
!_b_.isinstance($imag, _b_.float) &&
!_b_.isinstance($imag, _b_.int) &&
!_b_.isinstance($imag, _b_.complex) &&
$imag !== missing
) {
throw _b_.TypeError.$factory(
"complex() argument must be a string " + "or a number"
);
}
$imag = complex.__mul__(complex.$factory("1j"), $imag);
return complex.__add__($imag, $real);
};
complex.__pos__ = function (self) {
return self;
};
function complex2expo(cx) {
var norm = Math.sqrt(cx.$real * cx.$real + cx.$imag * cx.$imag),
sin = cx.$imag / norm,
cos = cx.$real / norm,
angle;
if (cos == 0) {
angle = sin == 1 ? Math.PI / 2 : (3 * Math.PI) / 2;
} else if (sin == 0) {
angle = cos == 1 ? 0 : Math.PI;
} else {
angle = Math.atan(sin / cos);
}
return { norm: norm, angle: angle };
}
complex.__pow__ = function (self, other) {
if (other == 1) {
return self;
}
var exp = complex2expo(self),
angle = exp.angle,
res = Math.pow(exp.norm, other);
if (_b_.isinstance(other, [_b_.int, _b_.float])) {
return make_complex(
res * Math.cos(angle * other),
res * Math.sin(angle * other)
);
} else if (_b_.isinstance(other, complex)) {
var x = other.$real,
y = other.$imag;
var pw = Math.pow(exp.norm, x) * Math.pow(Math.E, -y * angle),
theta = y * Math.log(exp.norm) - x * angle;
return make_complex(pw * Math.cos(theta), pw * Math.sin(theta));
} else {
throw _b_.TypeError.$factory(
"unsupported operand type(s) " +
"for ** or pow(): 'complex' and '" +
$B.class_name(other) +
"'"
);
}
};
complex.__radd__ = function (self, other) {
if (_b_.isinstance(other, _b_.bool)) {
other = other ? 1 : 0;
}
if (_b_.isinstance(other, [_b_.int, _b_.float])) {
return make_complex(other + self.$real, self.$imag);
}
return _b_.NotImplemented;
};
complex.__repr__ = function (self) {
$B.builtins_repr_check(complex, arguments);
var real = _b_.str.$factory(self.$real),
imag = _b_.str.$factory(self.$imag);
if (imag.endsWith(".0")) {
imag = imag.substr(0, imag.length - 2);
}
if (self.$imag instanceof Number && self.$imag == parseInt(self.$imag)) {
if (self.$imag == 0 && 1 / self.$imag === -Infinity) {
imag = "-0";
}
}
if (self.$real == 0) {
if (1 / self.$real < 0) {
if (imag.startsWith("-")) {
return "-0" + imag + "j";
}
return "-0+" + imag + "j";
} else {
return imag + "j";
}
}
if (self.$imag > 0 || isNaN(self.$imag)) {
return "(" + real + "+" + imag + "j)";
}
if (self.$imag == 0) {
if (1 / self.$imag < 0) {
return "(" + real + "-0j)";
}
return "(" + real + "+0j)";
}
return "(" + real + "-" + _b_.str.$factory(-self.$imag) + "j)";
};
complex.__rmul__ = function (self, other) {
if (_b_.isinstance(other, _b_.bool)) {
other = other ? 1 : 0;
}
if (_b_.isinstance(other, [_b_.int, _b_.float])) {
return make_complex(other * self.$real, other * self.$imag);
}
return _b_.NotImplemented;
};
complex.__sqrt__ = function (self) {
if (self.$imag == 0) {
return complex(Math.sqrt(self.$real));
}
var r = self.$real,
i = self.$imag,
_a = Math.sqrt((r + sqrt) / 2),
_b = Number.sign(i) * Math.sqrt((-r + sqrt) / 2);
return make_complex(_a, _b);
};
complex.__sub__ = function (self, other) {
if (_b_.isinstance(other, complex)) {
return make_complex(self.$real - other.$real, self.$imag - other.$imag);
}
if (_b_.isinstance(other, _b_.int)) {
other = _b_.int.numerator(other);
return make_complex($B.sub(self.$real, other.valueOf()), self.$imag);
}
if (_b_.isinstance(other, _b_.float)) {
return make_complex(self.$real - other.valueOf(), self.$imag);
}
return _b_.NotImplemented;
};
complex.__truediv__ = function (self, other) {
if (_b_.isinstance(other, complex)) {
if (other.$real == 0 && other.$imag == 0) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
var _num = self.$real * other.$real + self.$imag * other.$imag,
_div = other.$real * other.$real + other.$imag * other.$imag;
var _num2 = self.$imag * other.$real - self.$real * other.$imag;
return make_complex(_num / _div, _num2 / _div);
}
if (_b_.isinstance(other, _b_.int)) {
if (!other.valueOf()) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
return complex.__truediv__(self, complex.$factory(other.valueOf()));
}
if (_b_.isinstance(other, _b_.float)) {
if (!other.valueOf()) {
throw _b_.ZeroDivisionError.$factory("division by zero");
}
return complex.__truediv__(self, complex.$factory(other.valueOf()));
}
$UnsupportedOpType("//", "complex", other.__class__);
};
complex.conjugate = function (self) {
return make_complex(self.$real, -self.$imag);
};
complex.__ior__ = complex.__or__;
var r_opnames = [
"add",
"sub",
"mul",
"truediv",
"floordiv",
"mod",
"pow",
"lshift",
"rshift",
"and",
"xor",
"or",
];
for (var r_opname of r_opnames) {
if (
complex["__r" + r_opname + "__"] === undefined &&
complex["__" + r_opname + "__"]
) {
complex["__r" + r_opname + "__"] = (function (name) {
return function (self, other) {
if (_b_.isinstance(other, [_b_.int, _b_.float])) {
other = make_complex(other, 0);
return complex["__" + name + "__"](other, self);
} else if (_b_.isinstance(other, complex)) {
return complex["__" + name + "__"](other, self);
}
return _b_.NotImplemented;
};
})(r_opname);
}
}
var $comp_func = function (self, other) {
if (other === undefined || other == _b_.None) {
return _b_.NotImplemented;
}
throw _b_.TypeError.$factory(
"no ordering relation " + "is defined for complex numbers"
);
};
$comp_func += "";
for (var $op in $B.$comps) {
eval(
"complex.__" + $B.$comps[$op] + "__ = " + $comp_func.replace(/>/gm, $op)
);
}
complex.real = function (self) {
return new Number(self.$real);
};
complex.real.setter = function () {
throw _b_.AttributeError.$factory("readonly attribute");
};
complex.imag = function (self) {
return new Number(self.$imag);
};
complex.imag.setter = function () {
throw _b_.AttributeError.$factory("readonly attribute");
};
var _real = 1,
_real_mantissa = 2,
_sign = 3,
_imag = 4,
_imag_mantissa = 5,
_j = 6;
var type_conversions = ["__complex__", "__float__", "__index__"];
var _convert = function (num) {
var klass = num.__class__ || $B.get_class(num);
for (var i = 0; i < type_conversions.length; i++) {
var missing = {},
method = $B.$getattr(klass, type_conversions[i], missing);
if (method !== missing) {
return method(num);
}
}
return null;
};
var make_complex = ($B.make_complex = function (real, imag) {
return {
__class__: complex,
$real: real,
$imag: imag,
};
});
complex.$factory = function () {
return complex.__new__(complex, ...arguments);
};
$B.set_func_names(complex, "builtins");
_b_.complex = complex;
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var str_hash = _b_.str.__hash__,
$N = _b_.None;
var set_ops = [
"eq",
"le",
"lt",
"ge",
"gt",
"sub",
"rsub",
"and",
"or",
"xor",
];
function is_sublist(t1, t2) {
for (var i = 0, ilen = t1.length; i < ilen; i++) {
var x = t1[i],
flag = false;
for (var j = 0, jlen = t2.length; j < jlen; j++) {
if ($B.rich_comp("__eq__", x, t2[j])) {
t2.splice(j, 1);
flag = true;
break;
}
}
if (!flag) {
return false;
}
}
return true;
}
dict_view_op = {
__eq__: function (t1, t2) {
return t1.length == t2.length && is_sublist(t1, t2);
},
__ne__: function (t1, t2) {
return !dict_view_op.__eq__(t1, t2);
},
__lt__: function (t1, t2) {
return t1.length < t2.length && is_sublist(t1, t2);
},
__gt__: function (t1, t2) {
return dict_view_op.__lt__(t2, t1);
},
__le__: function (t1, t2) {
return t1.length <= t2.length && is_sublist(t1, t2);
},
__ge__: function (t1, t2) {
return dict_view_op.__le__(t2, t1);
},
__and__: function (t1, t2) {
var items = [];
for (var i = 0, ilen = t1.length; i < ilen; i++) {
var x = t1[i];
flag = false;
for (var j = 0, jlen = t2.length; j < jlen; j++) {
if ($B.rich_comp("__eq__", x, t2[j])) {
t2.splice(j, 1);
items.push(x);
break;
}
}
}
return items;
},
__or__: function (t1, t2) {
var items = t1;
for (var j = 0, jlen = t2.length; j < jlen; j++) {
var y = t2[j],
flag = false;
for (var i = 0, ilen = t1.length; i < ilen; i++) {
if ($B.rich_comp("__eq__", y, t1[i])) {
t2.splice(j, 1);
flag = true;
break;
}
}
if (!flag) {
items.push(y);
}
}
return items;
},
};
$B.make_view = function (name) {
var klass = $B.make_class(name, function (d, items, set_like) {
return {
__class__: klass,
__dict__: $B.empty_dict(),
counter: -1,
dict: d,
items: items,
len: items.length,
set_like: set_like,
};
});
for (var i = 0, len = set_ops.length; i < len; i++) {
var op = "__" + set_ops[i] + "__";
klass[op] = (function (op) {
return function (self, other) {
if (self.set_like) {
return _b_.set[op](_b_.set.$factory(self), _b_.set.$factory(other));
} else {
if (other.__class__ !== klass) {
return false;
}
var other_items = _b_.list.$factory(other);
return dict_view_op[op](self.items, other_items);
}
};
})(op);
}
klass.__iter__ = function (self) {
var it = klass.$iterator.$factory(self.items);
it.test_change = function () {
return self.dict.$version != self.dict_version;
};
return it;
};
klass.__len__ = function (self) {
return self.len;
};
klass.__repr__ = function (self) {
return klass.$infos.__name__ + "(" + _b_.repr(self.items) + ")";
};
$B.set_func_names(klass, "builtins");
return klass;
};
var dict = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __module__: "builtins", __name__: "dict" },
$is_class: true,
$native: true,
$match_mapping_pattern: true,
};
dict.$to_obj = function (d) {
var res = {};
for (var key in d.$string_dict) {
res[key] = d.$string_dict[key][0];
}
return res;
};
function to_list(d, ix) {
var items = [],
item;
if (d.$jsobj) {
items = [];
for (var attr in d.$jsobj) {
if (!attr.startsWith("$") && (!d.$exclude || !d.$exclude(attr))) {
var val = d.$jsobj[attr];
if (val === undefined) {
val = _b_.NotImplemented;
} else if (val === null) {
val = $N;
}
items.push([attr, val]);
}
}
} else if (_b_.isinstance(d, _b_.dict)) {
for (var k in d.$numeric_dict) {
items.push([parseFloat(k), d.$numeric_dict[k]]);
}
for (var k in d.$string_dict) {
items.push([k, d.$string_dict[k]]);
}
for (var k in d.$object_dict) {
d.$object_dict[k].forEach(function (item) {
items.push(item);
});
}
items.sort(function (a, b) {
return a[1][1] - b[1][1];
});
items = items.map(function (item) {
return [item[0], item[1][0]];
});
}
if (ix !== undefined) {
res = items.map(function (item) {
return item[ix];
});
return res;
} else {
items.__class__ = _b_.tuple;
return items.map(function (item) {
item.__class__ = _b_.tuple;
return item;
});
}
}
$B.dict_to_list = to_list;
var $copy_dict = function (left, right) {
var _l = to_list(right),
si = dict.$setitem;
right.$version = right.$version || 0;
var right_version = right.$version || 0;
for (var i = 0, len = _l.length; i < len; i++) {
si(left, _l[i][0], _l[i][1]);
if (right.$version != right_version) {
throw _b_.RuntimeError.$factory("dict mutated during update");
}
}
};
function rank(self, hash, key) {
var pairs = self.$object_dict[hash];
if (pairs !== undefined) {
for (var i = 0, len = pairs.length; i < len; i++) {
if ($B.rich_comp("__eq__", key, pairs[i][0])) {
return i;
}
}
}
return -1;
}
dict.__bool__ = function () {
var $ = $B.args(
"__bool__",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
return dict.__len__($.self) > 0;
};
dict.__class_getitem__ = function (cls, item) {
if (!Array.isArray(item)) {
item = [item];
}
return $B.GenericAlias.$factory(cls, item);
};
dict.__contains__ = function () {
var $ = $B.args(
"__contains__",
2,
{ self: null, key: null },
["self", "key"],
arguments,
{},
null,
null
),
self = $.self,
key = $.key;
if (self.$jsobj) {
return self.$jsobj[key] !== undefined;
}
switch (typeof key) {
case "string":
return self.$string_dict.hasOwnProperty(key);
case "number":
return self.$numeric_dict[key] !== undefined;
}
var hash = _b_.hash(key);
if (
self.$str_hash[hash] !== undefined &&
$B.rich_comp("__eq__", key, self.$str_hash[hash])
) {
return true;
}
if (
self.$numeric_dict[hash] !== undefined &&
$B.rich_comp("__eq__", key, hash)
) {
return true;
}
return rank(self, hash, key) > -1;
};
dict.__delitem__ = function () {
var $ = $B.args(
"__eq__",
2,
{ self: null, arg: null },
["self", "arg"],
arguments,
{},
null,
null
),
self = $.self,
arg = $.arg;
if (self.$jsobj) {
if (self.$jsobj[arg] === undefined) {
throw _b_.KeyError.$factory(arg);
}
delete self.$jsobj[arg];
return $N;
}
switch (typeof arg) {
case "string":
if (self.$string_dict[arg] === undefined) {
throw _b_.KeyError.$factory(_b_.str.$factory(arg));
}
delete self.$string_dict[arg];
delete self.$str_hash[str_hash(arg)];
self.$version++;
return $N;
case "number":
if (self.$numeric_dict[arg] === undefined) {
throw _b_.KeyError.$factory(_b_.str.$factory(arg));
}
delete self.$numeric_dict[arg];
self.$version++;
return $N;
}
var hash = _b_.hash(arg),
ix;
if ((ix = rank(self, hash, arg)) > -1) {
self.$object_dict[hash].splice(ix, 1);
} else {
throw _b_.KeyError.$factory(_b_.str.$factory(arg));
}
self.$version++;
return $N;
};
dict.__eq__ = function () {
var $ = $B.args(
"__eq__",
2,
{ self: null, other: null },
["self", "other"],
arguments,
{},
null,
null
),
self = $.self,
other = $.other;
if (!_b_.isinstance(other, dict)) {
return false;
}
if (self.$jsobj) {
self = jsobj2dict(self.$jsobj);
}
if (other.$jsobj) {
other = jsobj2dict(other.$jsobj);
}
if (dict.__len__(self) != dict.__len__(other)) {
return false;
}
if (self.$string_dict.length != other.$string_dict.length) {
return false;
}
for (var k in self.$numeric_dict) {
if (other.$numeric_dict.hasOwnProperty(k)) {
if (
!$B.rich_comp(
"__eq__",
other.$numeric_dict[k][0],
self.$numeric_dict[k][0]
)
) {
return false;
}
} else if (other.$object_dict.hasOwnProperty(k)) {
var pairs = other.$object_dict[k],
flag = false;
for (var i = 0, len = pairs.length; i < len; i++) {
if (
$B.rich_comp("__eq__", k, pairs[i][0]) &&
$B.rich_comp("__eq__", self.$numeric_dict[k], pairs[i][1])
) {
flag = true;
break;
}
}
if (!flag) {
return false;
}
} else {
return false;
}
}
for (var k in self.$string_dict) {
if (
!other.$string_dict.hasOwnProperty(k) ||
!$B.rich_comp(
"__eq__",
other.$string_dict[k][0],
self.$string_dict[k][0]
)
) {
return false;
}
}
for (var hash in self.$object_dict) {
var pairs = self.$object_dict[hash];
var other_pairs = [];
if (other.$numeric_dict[hash] !== undefined) {
other_pairs.push([hash, other.$numeric_dict[hash]]);
}
if (other.$object_dict[hash] !== undefined) {
other_pairs = other_pairs.concat(other.$object_dict[hash]);
}
if (other_pairs.length == 0) {
return false;
}
for (var i = 0, len_i = pairs.length; i < len_i; i++) {
var flag = false;
var key = pairs[i][0],
value = pairs[i][1][0];
for (var j = 0, len_j = other_pairs.length; j < len_j; j++) {
if (
$B.rich_comp("__eq__", key, other_pairs[j][0]) &&
$B.rich_comp("__eq__", value, other_pairs[j][1][0])
) {
flag = true;
break;
}
}
if (!flag) {
return false;
}
}
}
return true;
};
dict.__getitem__ = function () {
var $ = $B.args(
"__getitem__",
2,
{ self: null, arg: null },
["self", "arg"],
arguments,
{},
null,
null
),
self = $.self,
arg = $.arg;
return dict.$getitem(self, arg);
};
dict.$getitem = function (self, arg, ignore_missing) {
if (self.$jsobj) {
if (self.$exclude && self.$exclude(arg)) {
throw _b_.KeyError.$factory(arg);
}
if (self.$jsobj[arg] === undefined) {
if (self.$jsobj.hasOwnProperty && self.$jsobj.hasOwnProperty(arg)) {
return $B.Undefined;
}
throw _b_.KeyError.$factory(arg);
}
return self.$jsobj[arg];
}
switch (typeof arg) {
case "string":
if (self.$string_dict.hasOwnProperty(arg)) {
return self.$string_dict[arg][0];
}
break;
case "number":
if (self.$numeric_dict[arg] !== undefined) {
return self.$numeric_dict[arg][0];
}
break;
}
var hash = _b_.hash(arg),
_eq = function (other) {
return $B.rich_comp("__eq__", arg, other);
};
if (typeof arg == "object") {
arg.$hash = hash;
}
var sk = self.$str_hash[hash];
if (sk !== undefined && _eq(sk)) {
return self.$string_dict[sk][0];
}
if (self.$numeric_dict[hash] !== undefined && _eq(hash)) {
return self.$numeric_dict[hash][0];
}
if (_b_.isinstance(arg, _b_.str)) {
if (self.$string_dict.hasOwnProperty(arg.valueOf())) {
return self.$string_dict[arg.valueOf()][0];
}
}
var ix = rank(self, hash, arg);
if (ix > -1) {
return self.$object_dict[hash][ix][1][0];
}
if (!ignore_missing) {
if (self.__class__ !== dict && !ignore_missing) {
try {
var missing_method = $B.$getattr(
self.__class__,
"__missing__",
_b_.None
);
} catch (err) {
console.log(err);
}
if (missing_method !== _b_.None) {
return missing_method(self, arg);
}
}
}
throw _b_.KeyError.$factory(arg);
};
dict.__hash__ = _b_.None;
function init_from_list(self, args) {
var i = -1,
stop = args.length - 1,
si = dict.__setitem__;
while (i++ < stop) {
var item = args[i];
if (item.length != 2) {
throw _b_.ValueError.$factory(
"dictionary " +
`update sequence element #${i} has length 1; 2 is required`
);
}
switch (typeof item[0]) {
case "string":
self.$string_dict[item[0]] = [item[1], self.$order++];
self.$str_hash[str_hash(item[0])] = item[0];
self.$version++;
break;
case "number":
if (item[0] != 0 && item[0] != 1) {
self.$numeric_dict[item[0]] = [item[1], self.$order++];
self.$version++;
break;
}
default:
si(self, item[0], item[1]);
break;
}
}
}
dict.__init__ = function (self, first, second) {
if (first === undefined) {
return $N;
}
if (second === undefined) {
if (first.$nat != "kw" && $B.get_class(first) === $B.JSObj) {
for (var key in first) {
self.$string_dict[key] = [first[key], self.$order++];
}
return _b_.None;
} else if (first.$jsobj) {
self.$jsobj = {};
for (var attr in first.$jsobj) {
self.$jsobj[attr] = first.$jsobj[attr];
}
return $N;
} else if (Array.isArray(first)) {
init_from_list(self, first);
return $N;
}
}
var $ = $B.args(
"dict",
1,
{ self: null },
["self"],
arguments,
{},
"first",
"second"
);
var args = $.first;
if (args.length > 1) {
throw _b_.TypeError.$factory(
"dict expected at most 1 argument" + ", got 2"
);
} else if (args.length == 1) {
args = args[0];
if (args.__class__ === dict) {
["$string_dict", "$str_hash", "$numeric_dict", "$object_dict"].forEach(
function (d) {
for (key in args[d]) {
self[d][key] = args[d][key];
}
}
);
} else if (_b_.isinstance(args, dict)) {
$copy_dict(self, args);
} else {
var keys = $B.$getattr(args, "keys", null);
if (keys !== null) {
var gi = $B.$getattr(args, "__getitem__", null);
if (gi !== null) {
gi = $B.$call(gi);
var kiter = _b_.iter($B.$call(keys)());
while (true) {
try {
var key = _b_.next(kiter),
value = gi(key);
dict.__setitem__(self, key, value);
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
break;
}
throw err;
}
}
return $N;
}
}
if (!Array.isArray(args)) {
args = _b_.list.$factory(args);
}
init_from_list(self, args);
}
}
var kw = $.second.$string_dict;
for (var attr in kw) {
switch (typeof attr) {
case "string":
self.$string_dict[attr] = [kw[attr][0], self.$order++];
self.$str_hash[str_hash(attr)] = attr;
break;
case "number":
self.$numeric_dict[attr] = [kw[attr][0], self.$order++];
break;
default:
si(self, attr, kw[attr][0]);
break;
}
}
return $N;
};
dict.__iter__ = function (self) {
return _b_.iter(dict.keys(self));
};
dict.__ior__ = function (self, other) {
dict.update(self, other);
return self;
};
dict.__len__ = function (self) {
var _count = 0;
if (self.$jsobj) {
for (var attr in self.$jsobj) {
if (attr.charAt(0) != "$" && (!self.$exclude || !self.$exclude(attr))) {
_count++;
}
}
return _count;
}
for (var k in self.$numeric_dict) {
_count++;
}
for (var k in self.$string_dict) {
_count++;
}
for (var hash in self.$object_dict) {
_count += self.$object_dict[hash].length;
}
return _count;
};
dict.__ne__ = function (self, other) {
return !dict.__eq__(self, other);
};
dict.__new__ = function (cls) {
if (cls === undefined) {
throw _b_.TypeError.$factory("int.__new__(): not enough arguments");
}
var instance = {
__class__: cls,
$numeric_dict: {},
$object_dict: {},
$string_dict: {},
$str_hash: {},
$version: 0,
$order: 0,
};
if (cls !== dict) {
instance.__dict__ = $B.empty_dict();
}
return instance;
};
dict.__or__ = function (self, other) {
if (!_b_.isinstance(other, dict)) {
return _b_.NotImplemented;
}
var res = dict.copy(self);
dict.update(res, other);
return res;
};
function __newobj__() {
var $ = $B.args("__newobj__", 0, {}, [], arguments, {}, "args", null),
args = $.args;
var res = $B.empty_dict();
res.__class__ = args[0];
return res;
}
dict.__reduce_ex__ = function (self, protocol) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__]),
_b_.None,
_b_.None,
dict.items(self),
]);
};
dict.__repr__ = function (self) {
$B.builtins_repr_check(dict, arguments);
if (self.$jsobj) {
return dict.__repr__(jsobj2dict(self.$jsobj, self.$exclude));
}
if ($B.repr.enter(self)) {
return "{...}";
}
var res = [],
items = to_list(self);
items.forEach(function (item) {
try {
res.push(_b_.repr(item[0]) + ": " + _b_.repr(item[1]));
} catch (err) {
throw err;
}
});
$B.repr.leave(self);
return "{" + res.join(", ") + "}";
};
dict.__ror__ = function (self, other) {
if (!_b_.isinstance(other, dict)) {
return _b_.NotImplemented;
}
var res = dict.copy(other);
dict.update(res, self);
return res;
};
dict.__setitem__ = function (self, key, value) {
var $ = $B.args(
"__setitem__",
3,
{ self: null, key: null, value: null },
["self", "key", "value"],
arguments,
{},
null,
null
);
return dict.$setitem($.self, $.key, $.value);
};
dict.$setitem = function (self, key, value, $hash) {
if (self.$jsobj) {
if (self.$from_js) {
value = $B.pyobj2jsobj(value);
}
if (self.$jsobj.__class__ === _b_.type) {
self.$jsobj[key] = value;
if (key == "__init__" || key == "__new__") {
self.$jsobj.$factory = $B.$instance_creator(self.$jsobj);
}
} else {
self.$jsobj[key] = value;
}
return $N;
}
if (key instanceof String) {
key = key.valueOf();
}
switch (typeof key) {
case "string":
if (self.$string_dict === undefined) {
console.log("pas de string dict", self, key, value);
}
if (self.$string_dict.hasOwnProperty(key)) {
self.$string_dict[key][0] = value;
} else {
self.$string_dict[key] = [value, self.$order++];
self.$str_hash[str_hash(key)] = key;
self.$version++;
}
return $N;
case "number":
if (self.$numeric_dict[key] !== undefined) {
self.$numeric_dict[key][0] = value;
} else {
var done = false;
if ((key == 0 || key == 1) && self.$object_dict[key] !== undefined) {
for (const item of self.$object_dict[key]) {
if (
(key == 0 && item[0] === false) ||
(key == 1 && item[0] === true)
) {
item[1][0] = value;
done = true;
}
}
}
if (!done) {
self.$numeric_dict[key] = [value, self.$order++];
}
self.$version++;
}
return $N;
case "boolean":
var num = key ? 1 : 0;
if (self.$numeric_dict[num] !== undefined) {
var order = self.$numeric_dict[num][1];
self.$numeric_dict[num] = [value, order];
return;
}
if (self.$object_dict[num] !== undefined) {
self.$object_dict[num].push([key, [value, self.$order++]]);
} else {
self.$object_dict[num] = [[key, [value, self.$order++]]];
}
}
var hash = $hash === undefined ? _b_.hash(key) : $hash,
_eq = function (other) {
return $B.rich_comp("__eq__", key, other);
};
if (self.$numeric_dict[hash] !== undefined && _eq(hash)) {
self.$numeric_dict[hash] = [value, self.$numeric_dict[hash][1]];
self.$version++;
return $N;
}
var sk = self.$str_hash[hash];
if (sk !== undefined && _eq(sk)) {
self.$string_dict[sk] = [value, self.$string_dict[sk][1]];
self.$version++;
return $N;
}
if ($hash) {
if (self.$object_dict[$hash] !== undefined) {
self.$object_dict[$hash].push([key, [value, self.$order++]]);
} else {
self.$object_dict[$hash] = [[key, [value, self.$order++]]];
}
self.$version++;
return $N;
}
var ix = rank(self, hash, key);
if (ix > -1) {
self.$object_dict[hash][ix][1] = [
value,
self.$object_dict[hash][ix][1][1],
];
return $N;
} else if (self.$object_dict.hasOwnProperty(hash)) {
self.$object_dict[hash].push([key, [value, self.$order++]]);
} else {
self.$object_dict[hash] = [[key, [value, self.$order++]]];
}
self.$version++;
return $N;
};
$B.make_rmethods(dict);
dict.clear = function () {
var $ = $B.args(
"clear",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
self = $.self;
self.$numeric_dict = {};
self.$string_dict = {};
self.$str_hash = {};
self.$object_dict = {};
if (self.$jsobj) {
for (var attr in self.$jsobj) {
if (attr.charAt(0) !== "$" && attr !== "__class__") {
delete self.$jsobj[attr];
}
}
}
self.$version++;
self.$order = 0;
return $N;
};
dict.copy = function (self) {
var $ = $B.args(
"copy",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
self = $.self,
res = $B.empty_dict();
$copy_dict(res, self);
return res;
};
dict.fromkeys = function () {
var $ = $B.args(
"fromkeys",
3,
{ cls: null, keys: null, value: null },
["cls", "keys", "value"],
arguments,
{ value: _b_.None },
null,
null
),
keys = $.keys,
value = $.value;
var klass = $.cls,
res = $B.$call(klass)(),
keys_iter = $B.$iter(keys);
while (1) {
try {
var key = _b_.next(keys_iter);
if (klass === dict) {
dict.$setitem(res, key, value);
} else {
$B.$getattr(res, "__setitem__")(key, value);
}
} catch (err) {
if ($B.is_exc(err, [_b_.StopIteration])) {
return res;
}
throw err;
}
}
};
dict.get = function () {
var $ = $B.args(
"get",
3,
{ self: null, key: null, _default: null },
["self", "key", "_default"],
arguments,
{ _default: $N },
null,
null
);
try {
return dict.$getitem($.self, $.key, true);
} catch (err) {
if (_b_.isinstance(err, _b_.KeyError)) {
return $._default;
} else {
throw err;
}
}
};
var dict_items = $B.make_view("dict_items", true);
dict_items.$iterator = $B.make_iterator_class("dict_itemiterator");
dict.items = function (self) {
var $ = $B.args(
"items",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
var items = to_list(self),
set_like = true;
for (var i = 0, len = items.length; i < len; i++) {
try {
_b_.hash(items[i][1]);
} catch (err) {
set_like = false;
break;
}
}
var values = to_list(self);
var it = dict_items.$factory(self, values, set_like);
it.dict_version = self.$version;
return it;
};
var dict_keys = $B.make_view("dict_keys");
dict_keys.$iterator = $B.make_iterator_class("dict_keyiterator");
dict.keys = function (self) {
var $ = $B.args(
"keys",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
var it = dict_keys.$factory(self, to_list(self, 0), true);
it.dict_version = self.$version;
return it;
};
dict.pop = function () {
var missing = {},
$ = $B.args(
"pop",
3,
{ self: null, key: null, _default: null },
["self", "key", "_default"],
arguments,
{ _default: missing },
null,
null
),
self = $.self,
key = $.key,
_default = $._default;
try {
var res = dict.__getitem__(self, key);
dict.__delitem__(self, key);
return res;
} catch (err) {
if (err.__class__ === _b_.KeyError) {
if (_default !== missing) {
return _default;
}
throw err;
}
throw err;
}
};
dict.popitem = function (self) {
try {
var itm = _b_.next(_b_.iter(dict.items(self)));
dict.__delitem__(self, itm[0]);
return _b_.tuple.$factory(itm);
} catch (err) {
if (err.__class__ == _b_.StopIteration) {
throw _b_.KeyError.$factory("'popitem(): dictionary is empty'");
}
}
};
dict.setdefault = function () {
var $ = $B.args(
"setdefault",
3,
{ self: null, key: null, _default: null },
["self", "key", "_default"],
arguments,
{ _default: $N },
null,
null
),
self = $.self,
key = $.key,
_default = $._default;
try {
return dict.$getitem(self, key, true);
} catch (err) {
if (err.__class__ !== _b_.KeyError) {
throw err;
}
if (_default === undefined) {
_default = $N;
}
var hash = key.$hash;
key.$hash = undefined;
dict.$setitem(self, key, _default, hash);
return _default;
}
};
dict.update = function (self) {
var $ = $B.args(
"update",
1,
{ self: null },
["self"],
arguments,
{},
"args",
"kw"
),
self = $.self,
args = $.args,
kw = $.kw;
if (args.length > 0) {
var o = args[0];
if (_b_.isinstance(o, dict)) {
if (o.$jsobj) {
o = jsobj2dict(o.$jsobj);
}
$copy_dict(self, o);
} else if (_b_.hasattr(o, "keys")) {
var _keys = _b_.list.$factory($B.$call($B.$getattr(o, "keys"))());
for (var i = 0, len = _keys.length; i < len; i++) {
var _value = $B.$getattr(o, "__getitem__")(_keys[i]);
dict.$setitem(self, _keys[i], _value);
}
} else {
var it = _b_.iter(o),
i = 0;
while (true) {
try {
var item = _b_.next(it);
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
break;
}
throw err;
}
try {
key_value = _b_.list.$factory(item);
} catch (err) {
throw _b_.TypeError.$factory(
"cannot convert dictionary" +
" update sequence element #" +
i +
" to a sequence"
);
}
if (key_value.length !== 2) {
throw _b_.ValueError.$factory(
"dictionary update " +
"sequence element #" +
i +
" has length " +
key_value.length +
"; 2 is required"
);
}
dict.$setitem(self, key_value[0], key_value[1]);
i++;
}
}
}
$copy_dict(self, kw);
self.$version++;
return $N;
};
var dict_values = $B.make_view("dict_values");
dict_values.$iterator = $B.make_iterator_class("dict_valueiterator");
dict.values = function (self) {
var $ = $B.args(
"values",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
var values = to_list(self, 1);
var it = dict_values.$factory(self, values, false);
it.dict_version = self.$version;
return it;
};
dict.$factory = function () {
var res = dict.__new__(dict);
var args = [res];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(arguments[i]);
}
dict.__init__.apply(null, args);
return res;
};
_b_.dict = dict;
$B.set_func_names(dict, "builtins");
dict.__class_getitem__ = _b_.classmethod.$factory(dict.__class_getitem__);
$B.empty_dict = function () {
return {
__class__: dict,
$numeric_dict: {},
$object_dict: {},
$string_dict: {},
$str_hash: {},
$version: 0,
$order: 0,
};
};
dict.fromkeys = _b_.classmethod.$factory(dict.fromkeys);
$B.getset_descriptor = $B.make_class(
"getset_descriptor",
function (klass, attr) {
return {
__class__: $B.getset_descriptor,
__doc__: _b_.None,
cls: klass,
attr: attr,
};
}
);
$B.getset_descriptor.__repr__ = $B.getset_descriptor.__str__ = function (
self
) {
return `<attribute '${self.attr}' of '${self.cls.$infos.__name__}' objects>`;
};
$B.set_func_names($B.getset_descriptor, "builtins");
var mappingproxy = ($B.mappingproxy = $B.make_class(
"mappingproxy",
function (obj) {
if (_b_.isinstance(obj, dict)) {
var res = $B.obj_dict(dict.$to_obj(obj));
} else {
var res = $B.obj_dict(obj);
}
res.__class__ = mappingproxy;
return res;
}
));
mappingproxy.$match_mapping_pattern = true;
mappingproxy.__repr__ = function () {
return "<mappingproxy object>";
};
mappingproxy.__setitem__ = function () {
throw _b_.TypeError.$factory(
"'mappingproxy' object does not support " + "item assignment"
);
};
for (var attr in dict) {
if (
mappingproxy[attr] !== undefined ||
[
"__class__",
"__mro__",
"__new__",
"__init__",
"__delitem__",
"clear",
"fromkeys",
"pop",
"popitem",
"setdefault",
"update",
].indexOf(attr) > -1
) {
continue;
}
if (typeof dict[attr] == "function") {
mappingproxy[attr] = (function (key) {
return function () {
return dict[key].apply(null, arguments);
};
})(attr);
} else {
mappingproxy[attr] = dict[attr];
}
}
$B.set_func_names(mappingproxy, "builtins");
function jsobj2dict(x, exclude) {
exclude =
exclude ||
function () {
return false;
};
var d = $B.empty_dict();
for (var attr in x) {
if (attr.charAt(0) != "$" && !exclude(attr)) {
if (x[attr] === null) {
d.$string_dict[attr] = [_b_.None, d.$order++];
} else if (x[attr] === undefined) {
continue;
} else if (x[attr].$jsobj === x) {
d.$string_dict[attr] = [d, d.$order++];
} else {
d.$string_dict[attr] = [$B.$JS2Py(x[attr]), d.$order++];
}
}
}
return d;
}
$B.obj_dict = function (obj, exclude) {
var klass = obj.__class__ || $B.get_class(obj);
if (klass !== undefined && klass.$native) {
throw $B.attr_error("__dict__", obj);
}
var res = $B.empty_dict();
res.$jsobj = obj;
res.$exclude =
exclude ||
function () {
return false;
};
return res;
};
var jsobj_as_pydict = ($B.jsobj_as_pydict = $B.make_class(
"jsobj_as_pydict",
function (jsobj, exclude) {
return {
__class__: jsobj_as_pydict,
obj: jsobj,
exclude: exclude
? exclude
: function () {
return false;
},
new_keys: [],
};
}
));
jsobj_as_pydict.__contains__ = function (self, key) {
if (self.new_keys.indexOf(key) > -1) {
return true;
}
return !(self.exclude(key) || self.obj[key] === undefined);
};
jsobj_as_pydict.__delitem__ = function (self, key) {
jsobj_as_pydict.__getitem__(self, key);
delete self.obj[key];
var ix = self.new_keys.indexOf(key);
if (ix > -1) {
self.new_keys.splice(ix, 1);
}
};
jsobj_as_pydict.__eq__ = function (self, other) {
if (other.__class__ !== jsobj_as_pydict) {
return _b_.NotImplemented;
}
var self1 = $B.empty_dict();
other1 = $B.empty_dict();
dict.__init__(self1, jsobj_as_pydict.items(self));
dict.__init__(other1, jsobj_as_pydict.items(other));
return dict.__eq__(self1, other1);
};
jsobj_as_pydict.__getitem__ = function (self, key) {
if (jsobj_as_pydict.__contains__(self, key)) {
return self.obj[key];
}
throw _b_.KeyError.$factory(key);
};
jsobj_as_pydict.__iter__ = function (self) {
return _b_.iter(jsobj_as_pydict.keys(self));
};
jsobj_as_pydict.__len__ = function (self) {
var len = 0;
for (var key in self.obj) {
if (!self.exclude(key)) {
len++;
}
}
return len + self.new_keys.length;
};
jsobj_as_pydict.__repr__ = function (self) {
if ($B.repr.enter(self)) {
return "{...}";
}
var res = [],
items = _b_.list.$factory(jsobj_as_pydict.items(self));
for (var item of items) {
res.push(_b_.repr(item[0]) + ": " + _b_.repr(item[1]));
}
$B.repr.leave(self);
return "{" + res.join(", ") + "}";
};
jsobj_as_pydict.__setitem__ = function (self, key, value) {
if (self.exclude(key) && self.new_keys.indexOf(key) == -1) {
self.new_keys.push(key);
}
self.obj[key] = value;
};
jsobj_as_pydict.get = function (self, key, _default) {
_default = _default === undefined ? _b_.None : _default;
if (self.exclude(key) || self.obj[key] === undefined) {
return _default;
}
return self.obj[key];
};
jsobj_as_pydict.items = function (self) {
var items = [];
for (var key in self.obj) {
if (self.exclude(key) && self.new_keys.indexOf(key) == -1) {
continue;
}
items.push($B.fast_tuple([key, self.obj[key]]));
}
var set_like = true;
for (var item of items) {
try {
_b_.hash(item[1]);
} catch (err) {
set_like = false;
break;
}
}
var it = dict_items.$factory(self, items, set_like);
it.dict_version = self.$version;
return it;
};
jsobj_as_pydict.keys = function (self) {
var lst = [];
for (var key in self.obj) {
if (self.exclude(key) && self.new_keys.indexOf(key) == -1) {
continue;
}
lst.push(key);
}
var it = dict_keys.$factory(self, lst, true);
it.dict_version = self.$version;
return it;
};
jsobj_as_pydict.values = function (self) {
var values = [];
for (var key in self.obj) {
if (self.exclude(key) && self.new_keys.indexOf(key) == -1) {
continue;
}
values.push(self.obj[key]);
}
var it = dict_values.$factory(self, values, false);
it.dict_version = self.$version;
return it;
};
$B.set_func_names(jsobj_as_pydict, "builtins");
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins,
object = _b_.object,
getattr = $B.$getattr,
isinstance = _b_.isinstance,
$N = _b_.None;
function check_not_tuple(self, attr) {
if (self.__class__ === tuple) {
throw $B.attr_error(attr, self);
}
}
function $list() {
return list.$factory.apply(null, arguments);
}
var list = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "builtins", __name__: "list" },
$is_class: true,
$native: true,
$match_sequence_pattern: true,
__dir__: object.__dir__,
};
list.__add__ = function (self, other) {
if ($B.get_class(self) !== $B.get_class(other)) {
var this_name = $B.class_name(self);
var radd = $B.$getattr(other, "__radd__", null);
if (radd === null) {
throw _b_.TypeError.$factory(
"can only concatenate " +
this_name +
' (not "' +
$B.class_name(other) +
'") to ' +
this_name
);
}
return _b_.NotImplemented;
}
var res = self.slice(),
is_js = other.$brython_class == "js";
for (const item of other) {
res.push(is_js ? $B.$JS2Py(item) : item);
}
res.__brython__ = true;
if (isinstance(self, tuple)) {
res = tuple.$factory(res);
}
return res;
};
list.__class_getitem__ = function (cls, item) {
if (!Array.isArray(item)) {
item = [item];
}
return $B.GenericAlias.$factory(cls, item);
};
list.__contains__ = function (self, item) {
var $ = $B.args(
"__contains__",
2,
{ self: null, item: null },
["self", "item"],
arguments,
{},
null,
null
),
self = $.self,
item = $.item;
var _eq = function (other) {
return $B.rich_comp("__eq__", item, other);
};
var i = 0;
while (i < self.length) {
if (_eq(self[i])) {
return true;
}
i++;
}
return false;
};
list.__delitem__ = function (self, arg) {
if (isinstance(arg, _b_.int)) {
var pos = arg;
if (arg < 0) {
pos = self.length + pos;
}
if (pos >= 0 && pos < self.length) {
self.splice(pos, 1);
return $N;
}
throw _b_.IndexError.$factory(
$B.class_name(self) + " index out of range"
);
}
if (isinstance(arg, _b_.slice)) {
var step = arg.step;
if (step === $N) {
step = 1;
}
var start = arg.start;
if (start === $N) {
start = step > 0 ? 0 : self.length;
}
var stop = arg.stop;
if (stop === $N) {
stop = step > 0 ? self.length : 0;
}
if (start < 0) {
start = self.length + start;
}
if (stop < 0) {
stop = self.length + stop;
}
var res = [],
i = null,
pos = 0;
if (step > 0) {
if (stop > start) {
for (var i = start; i < stop; i += step) {
if (self[i] !== undefined) {
res[pos++] = i;
}
}
}
} else {
if (stop < start) {
for (var i = start; i > stop; i += step) {
if (self[i] !== undefined) {
res[pos++] = i;
}
}
res.reverse();
}
}
var i = res.length;
while (i--) {
self.splice(res[i], 1);
}
return $N;
}
if (_b_.hasattr(arg, "__int__") || _b_.hasattr(arg, "__index__")) {
list.__delitem__(self, _b_.int.$factory(arg));
return $N;
}
throw _b_.TypeError.$factory(
$B.class_name(self) +
" indices must be integer, not " +
$B.class_name(arg)
);
};
list.__eq__ = function (self, other) {
var klass = isinstance(self, list) ? list : tuple;
if (isinstance(other, klass)) {
if (other.length == self.length) {
var i = self.length;
while (i--) {
if (!$B.rich_comp("__eq__", self[i], other[i])) {
return false;
}
}
return true;
}
return false;
}
return _b_.NotImplemented;
};
list.__getitem__ = function (self, key) {
$B.check_no_kw("__getitem__", self, key);
$B.check_nb_args("__getitem__", 2, arguments);
return list.$getitem(self, key);
};
list.$getitem = function (self, key) {
var klass = self.__class__ || $B.get_class(self);
var factory = function (list_res) {
list_res.__class__ = klass;
return list_res;
};
var int_key;
try {
int_key = $B.PyNumber_Index(key);
} catch (err) {}
if (int_key !== undefined) {
var items = self.valueOf(),
pos = int_key;
if (int_key < 0) {
pos = items.length + pos;
}
if (pos >= 0 && pos < items.length) {
return items[pos];
}
throw _b_.IndexError.$factory(
$B.class_name(self) + " index out of range"
);
}
if (key.__class__ === _b_.slice || isinstance(key, _b_.slice)) {
if (
key.start === _b_.None &&
key.stop === _b_.None &&
key.step === _b_.None
) {
return self.slice();
}
var s = _b_.slice.$conv_for_seq(key, self.length);
var res = [],
i = null,
items = self.valueOf(),
pos = 0,
start = s.start,
stop = s.stop,
step = s.step;
if (step > 0) {
if (stop <= start) {
return factory(res);
}
for (var i = start; i < stop; i += step) {
res[pos++] = items[i];
}
return factory(res);
} else {
if (stop > start) {
return factory(res);
}
for (var i = start; i > stop; i += step) {
res[pos++] = items[i];
}
return factory(res);
}
}
throw _b_.TypeError.$factory(
$B.class_name(self) +
" indices must be integer, not " +
$B.class_name(key)
);
};
list.__ge__ = function (self, other) {
if (!isinstance(other, [list, _b_.tuple])) {
return _b_.NotImplemented;
}
var i = 0;
while (i < self.length) {
if (i >= other.length) {
return true;
}
if ($B.rich_comp("__eq__", self[i], other[i])) {
i++;
} else {
res = $B.$getattr(self[i], "__ge__")(other[i]);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(self[i]) +
"() >= " +
$B.class_name(other[i]) +
"()"
);
} else {
return res;
}
}
}
return other.length == self.length;
};
list.__gt__ = function (self, other) {
if (!isinstance(other, [list, _b_.tuple])) {
return _b_.NotImplemented;
}
var i = 0;
while (i < self.length) {
if (i >= other.length) {
return true;
}
if ($B.rich_comp("__eq__", self[i], other[i])) {
i++;
} else {
res = $B.$getattr(self[i], "__gt__")(other[i]);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(self[i]) +
"() > " +
$B.class_name(other[i]) +
"()"
);
} else return res;
}
}
return false;
};
list.__hash__ = $N;
list.__iadd__ = function () {
var $ = $B.args(
"__iadd__",
2,
{ self: null, x: null },
["self", "x"],
arguments,
{},
null,
null
);
var x = list.$factory($B.$iter($.x));
for (var i = 0; i < x.length; i++) {
$.self.push(x[i]);
}
return $.self;
};
list.__imul__ = function () {
var $ = $B.args(
"__imul__",
2,
{ self: null, x: null },
["self", "x"],
arguments,
{},
null,
null
),
x = $B.$GetInt($.x),
len = $.self.length,
pos = len;
if (x == 0) {
list.clear($.self);
return $.self;
}
for (var i = 1; i < x; i++) {
for (j = 0; j < len; j++) {
$.self[pos++] = $.self[j];
}
}
return $.self;
};
list.__init__ = function (self, arg) {
var $ = $B.args(
"__init__",
1,
{ self: null },
["self"],
arguments,
{},
"args",
null
),
self = $.self,
args = $.args;
if (args.length > 1) {
throw _b_.TypeError.$factory(
"expected at most 1 argument, got " + args.length
);
}
var arg = args[0];
var len_func = $B.$call($B.$getattr(self, "__len__")),
pop_func = $B.$getattr(self, "pop", $N);
if (pop_func !== $N) {
pop_func = $B.$call(pop_func);
while (len_func()) {
pop_func();
}
}
if (arg === undefined) {
return $N;
}
var arg = $B.$iter(arg),
next_func = $B.$call($B.$getattr(arg, "__next__")),
pos = len_func();
while (1) {
try {
var res = next_func();
self[pos++] = res;
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
break;
} else {
throw err;
}
}
}
return $N;
};
var list_iterator = $B.make_iterator_class("list_iterator");
list_iterator.__reduce__ = list_iterator.__reduce_ex__ = function (self) {
return $B.fast_tuple([_b_.iter, $B.fast_tuple([list.$factory(self)]), 0]);
};
list.__iter__ = function (self) {
return list_iterator.$factory(self);
};
list.__le__ = function (self, other) {
var res = list.__ge__(self, other);
if (res === _b_.NotImplemented) {
return res;
}
return !res;
};
list.__len__ = function (self) {
return self.length;
};
list.__lt__ = function (self, other) {
if (!isinstance(other, [list, _b_.tuple])) {
return _b_.NotImplemented;
}
var i = 0;
while (i < self.length) {
if (i >= other.length) {
return false;
}
if ($B.rich_comp("__eq__", self[i], other[i])) {
i++;
} else {
res = $B.$getattr(self[i], "__lt__")(other[i]);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(self[i]) +
"() >= " +
$B.class_name(other[i]) +
"()"
);
} else {
return res;
}
}
}
return other.length > self.length;
};
list.__mul__ = function (self, other) {
if (isinstance(other, _b_.int)) {
other = _b_.int.numerator(other);
var res = [],
$temp = self.slice(),
len = $temp.length;
for (var i = 0; i < other; i++) {
for (var j = 0; j < len; j++) {
res.push($temp[j]);
}
}
res.__class__ = self.__class__;
return res;
}
if (_b_.hasattr(other, "__int__") || _b_.hasattr(other, "__index__")) {
return list.__mul__(self, _b_.int.$factory(other));
}
var rmul = $B.$getattr(other, "__rmul__", null);
if (rmul === null) {
throw _b_.TypeError.$factory(
`can't multiply sequence by non-int ` +
`of type '${$B.class_name(other)}'`
);
}
return _b_.NotImplemented;
};
list.__new__ = function (cls, ...args) {
if (cls === undefined) {
throw _b_.TypeError.$factory("list.__new__(): not enough arguments");
}
var res = [];
res.__class__ = cls;
res.__brython__ = true;
res.__dict__ = $B.empty_dict();
return res;
};
function __newobj__() {
var $ = $B.args("__newobj__", 0, {}, [], arguments, {}, "args", null),
args = $.args;
var res = args.slice(1);
res.__class__ = args[0];
return res;
}
list.__reduce_ex__ = function (self) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__]),
_b_.None,
_b_.iter(self),
]);
};
list.__repr__ = function (self) {
$B.builtins_repr_check(list, arguments);
return list_repr(self);
};
function list_repr(self) {
if ($B.repr.enter(self)) {
return "[...]";
}
var _r = [],
res;
for (var i = 0; i < self.length; i++) {
_r.push(_b_.repr(self[i]));
}
if (_b_.isinstance(self, tuple)) {
if (self.length == 1) {
res = "(" + _r[0] + ",)";
} else {
res = "(" + _r.join(", ") + ")";
}
} else {
res = "[" + _r.join(", ") + "]";
}
$B.repr.leave(self);
return res;
}
list.__rmul__ = function (self, other) {
return list.__mul__(self, other);
};
list.__setattr__ = function (self, attr, value) {
if (self.__class__ === list || self.__class__ === tuple) {
var cl_name = $B.class_name(self);
if (list.hasOwnProperty(attr)) {
throw _b_.AttributeError.$factory(
"'" + cl_name + "' object attribute '" + attr + "' is read-only"
);
} else {
throw _b_.AttributeError.$factory(
"'" + cl_name + " object has no attribute '" + attr + "'"
);
}
}
_b_.dict.$setitem(self.__dict__, attr, value);
return $N;
};
list.__setitem__ = function () {
var $ = $B.args(
"__setitem__",
3,
{ self: null, key: null, value: null },
["self", "key", "value"],
arguments,
{},
null,
null
),
self = $.self,
arg = $.key,
value = $.value;
list.$setitem(self, arg, value);
};
list.$setitem = function (self, arg, value) {
if (typeof arg == "number" || isinstance(arg, _b_.int)) {
var pos = arg;
if (arg < 0) {
pos = self.length + pos;
}
if (pos >= 0 && pos < self.length) {
self[pos] = value;
} else {
throw _b_.IndexError.$factory("list index out of range");
}
return $N;
}
if (isinstance(arg, _b_.slice)) {
var s = _b_.slice.$conv_for_seq(arg, self.length);
if (arg.step === null) {
$B.set_list_slice(self, s.start, s.stop, value);
} else {
$B.set_list_slice_step(self, s.start, s.stop, s.step, value);
}
return $N;
}
if (_b_.hasattr(arg, "__int__") || _b_.hasattr(arg, "__index__")) {
list.__setitem__(self, _b_.int.$factory(arg), value);
return $N;
}
throw _b_.TypeError.$factory(
"list indices must be integer, not " + $B.class_name(arg)
);
};
list.append = function (self, x) {
$B.check_no_kw("append", self, x);
$B.check_nb_args("append", 2, arguments);
self.push(x);
return $N;
};
list.clear = function () {
var $ = $B.args(
"clear",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
while ($.self.length) {
$.self.pop();
}
return $N;
};
list.copy = function () {
var $ = $B.args(
"copy",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
var res = $.self.slice();
res.__class__ = self.__class__;
res.__brython__ = true;
return res;
};
list.count = function () {
var $ = $B.args(
"count",
2,
{ self: null, x: null },
["self", "x"],
arguments,
{},
null,
null
);
var res = 0,
_eq = function (other) {
return $B.rich_comp("__eq__", $.x, other);
},
i = $.self.length;
while (i--) {
if (_eq($.self[i])) {
res++;
}
}
return res;
};
list.extend = function () {
var $ = $B.args(
"extend",
2,
{ self: null, t: null },
["self", "t"],
arguments,
{},
null,
null
);
var other = list.$factory($B.$iter($.t));
for (var i = 0; i < other.length; i++) {
$.self.push(other[i]);
}
return $N;
};
list.index = function () {
var missing = {},
$ = $B.args(
"index",
4,
{ self: null, x: null, start: null, stop: null },
["self", "x", "start", "stop"],
arguments,
{ start: 0, stop: missing },
null,
null
),
self = $.self,
start = $.start,
stop = $.stop;
var _eq = function (other) {
return $B.rich_comp("__eq__", $.x, other);
};
if (start.__class__ === $B.long_int) {
start = parseInt(start.value) * (start.pos ? 1 : -1);
}
if (start < 0) {
start = Math.max(0, start + self.length);
}
if (stop === missing) {
stop = self.length;
} else {
if (stop.__class__ === $B.long_int) {
stop = parseInt(stop.value) * (stop.pos ? 1 : -1);
}
if (stop < 0) {
stop = Math.min(self.length, stop + self.length);
}
stop = Math.min(stop, self.length);
}
for (var i = start; i < stop; i++) {
if (_eq(self[i])) {
return i;
}
}
throw _b_.ValueError.$factory(
_b_.repr($.x) + " is not in " + $B.class_name(self)
);
};
list.insert = function () {
var $ = $B.args(
"insert",
3,
{ self: null, i: null, item: null },
["self", "i", "item"],
arguments,
{},
null,
null
);
$.self.splice($.i, 0, $.item);
return $N;
};
list.pop = function () {
var missing = {};
var $ = $B.args(
"pop",
2,
{ self: null, pos: null },
["self", "pos"],
arguments,
{ pos: missing },
null,
null
),
self = $.self,
pos = $.pos;
check_not_tuple(self, "pop");
if (pos === missing) {
pos = self.length - 1;
}
pos = $B.$GetInt(pos);
if (pos < 0) {
pos += self.length;
}
var res = self[pos];
if (res === undefined) {
throw _b_.IndexError.$factory("pop index out of range");
}
self.splice(pos, 1);
return res;
};
list.remove = function () {
var $ = $B.args(
"remove",
2,
{ self: null, x: null },
["self", "x"],
arguments,
{},
null,
null
);
for (var i = 0, len = $.self.length; i < len; i++) {
if ($B.rich_comp("__eq__", $.self[i], $.x)) {
$.self.splice(i, 1);
return $N;
}
}
throw _b_.ValueError.$factory(_b_.str.$factory($.x) + " is not in list");
};
list.reverse = function (self) {
var $ = $B.args(
"reverse",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
_len = $.self.length - 1,
i = parseInt($.self.length / 2);
while (i--) {
var buf = $.self[i];
$.self[i] = $.self[_len - i];
$.self[_len - i] = buf;
}
return $N;
};
function $partition(arg, array, begin, end, pivot) {
var piv = array[pivot];
array = swap(array, pivot, end - 1);
var store = begin;
if (arg === null) {
if (array.$cl !== false) {
var le_func = _b_.getattr(array.$cl, "__le__");
for (var ix = begin; ix < end - 1; ++ix) {
if (le_func(array[ix], piv)) {
array = swap(array, store, ix);
++store;
}
}
} else {
for (var ix = begin; ix < end - 1; ++ix) {
if ($B.$getattr(array[ix], "__le__")(piv)) {
array = swap(array, store, ix);
++store;
}
}
}
} else {
var len = array.length;
for (var ix = begin; ix < end - 1; ++ix) {
var x = arg(array[ix]);
if (array.length !== len) {
throw _b_.ValueError.$factory("list modified during sort");
}
if ($B.$getattr(x, "__le__")(arg(piv))) {
array = swap(array, store, ix);
++store;
}
}
}
array = swap(array, end - 1, store);
return store;
}
function swap(_array, a, b) {
var tmp = _array[a];
_array[a] = _array[b];
_array[b] = tmp;
return _array;
}
function $qsort(arg, array, begin, end) {
if (end - 1 > begin) {
var pivot = begin + Math.floor(Math.random() * (end - begin));
pivot = $partition(arg, array, begin, end, pivot);
$qsort(arg, array, begin, pivot);
$qsort(arg, array, pivot + 1, end);
}
}
function $elts_class(self) {
if (self.length == 0) {
return null;
}
var cl = $B.get_class(self[0]),
i = self.length;
while (i--) {
if ($B.get_class(self[i]) !== cl) {
return false;
}
}
return cl;
}
list.sort = function (self) {
var $ = $B.args(
"sort",
1,
{ self: null },
["self"],
arguments,
{},
null,
"kw"
);
check_not_tuple(self, "sort");
var func = $N,
reverse = false,
kw_args = $.kw,
keys = _b_.list.$factory(_b_.dict.keys(kw_args));
for (var i = 0; i < keys.length; i++) {
if (keys[i] == "key") {
func = kw_args.$string_dict[keys[i]][0];
} else if (keys[i] == "reverse") {
reverse = kw_args.$string_dict[keys[i]][0];
} else {
throw _b_.TypeError.$factory(
"'" + keys[i] + "' is an invalid keyword argument for this function"
);
}
}
if (self.length == 0) {
return;
}
if (func !== $N) {
func = $B.$call(func);
}
self.$cl = $elts_class(self);
var cmp = null;
if (func === $N && self.$cl === _b_.str) {
if (reverse) {
cmp = function (b, a) {
return $B.$AlphabeticalCompare(a, b);
};
} else {
cmp = function (a, b) {
return $B.$AlphabeticalCompare(a, b);
};
}
} else if (func === $N && self.$cl === _b_.int) {
if (reverse) {
cmp = function (b, a) {
return a - b;
};
} else {
cmp = function (a, b) {
return a - b;
};
}
} else {
if (func === $N) {
if (reverse) {
cmp = function (b, a) {
res = $B.$getattr(a, "__lt__")(b);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(b) +
"() < " +
$B.class_name(a) +
"()"
);
}
if (res) {
if (a == b) {
return 0;
}
return -1;
}
return 1;
};
} else {
cmp = function (a, b) {
res = $B.$getattr(a, "__lt__")(b);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(a) +
"() < " +
$B.class_name(b) +
"()"
);
}
if (res) {
if (a == b) {
return 0;
}
return -1;
}
return 1;
};
}
} else {
if (reverse) {
cmp = function (b, a) {
var _a = func(a),
_b = func(b);
res = $B.$getattr(_a, "__lt__")(_b);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(b) +
"() < " +
$B.class_name(a) +
"()"
);
}
if (res) {
if (_a == _b) {
return 0;
}
return -1;
}
return 1;
};
} else {
cmp = function (a, b) {
var _a = func(a),
_b = func(b);
res = $B.$getattr(_a, "__lt__")(_b);
if (res === _b_.NotImplemented) {
throw _b_.TypeError.$factory(
"unorderable types: " +
$B.class_name(a) +
"() < " +
$B.class_name(b) +
"()"
);
}
if (res) {
if (_a == _b) {
return 0;
}
return -1;
}
return 1;
};
}
}
}
$B.$TimSort(self, cmp);
return self.__brython__ ? $N : self;
};
$B.$list = function (t) {
t.__brython__ = true;
t.__class__ = _b_.list;
return t;
};
list.$factory = function () {
if (arguments.length == 0) {
return [];
}
var $ = $B.args(
"list",
1,
{ obj: null },
["obj"],
arguments,
{},
null,
null
),
obj = $.obj;
if (Array.isArray(obj)) {
obj = obj.slice();
obj.__brython__ = true;
if (obj.__class__ == tuple) {
var res = obj.slice();
res.__class__ = list;
return res;
}
return obj;
}
var res = [],
pos = 0,
arg = $B.$iter(obj),
next_func = $B.$call($B.$getattr(arg, "__next__"));
while (1) {
try {
res[pos++] = next_func();
} catch (err) {
if (!isinstance(err, _b_.StopIteration)) {
throw err;
}
break;
}
}
res.__brython__ = true;
return res;
};
$B.set_func_names(list, "builtins");
list.__class_getitem__ = _b_.classmethod.$factory(list.__class_getitem__);
var JSArray = ($B.JSArray = $B.make_class("JSArray", function (array) {
return {
__class__: JSArray,
js: array,
};
}));
JSArray.__repr__ = JSArray.__str__ = function () {
return "<JSArray object>";
};
function make_args(args) {
var res = [args[0].js];
for (var i = 1, len = args.length; i < len; i++) {
res.push(args[i]);
}
return res;
}
for (var attr in list) {
if ($B.JSArray[attr] !== undefined) {
continue;
}
if (typeof list[attr] == "function") {
$B.JSArray[attr] = (function (fname) {
return function () {
return $B.$JS2Py(list[fname].apply(null, make_args(arguments)));
};
})(attr);
}
}
$B.set_func_names($B.JSArray, "builtins");
function $tuple(arg) {
return arg;
}
var tuple = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "builtins", __name__: "tuple" },
$is_class: true,
$native: true,
$match_sequence_pattern: true,
};
var tuple_iterator = $B.make_iterator_class("tuple_iterator");
tuple.__iter__ = function (self) {
return tuple_iterator.$factory(self);
};
tuple.$factory = function () {
var obj = list.$factory(...arguments);
obj.__class__ = tuple;
return obj;
};
$B.fast_tuple = function (array) {
array.__class__ = tuple;
array.__brython__ = true;
array.__dict__ = $B.empty_dict();
return array;
};
for (var attr in list) {
switch (attr) {
case "__delitem__":
case "__iadd__":
case "__imul__":
case "__setitem__":
case "append":
case "extend":
case "insert":
case "remove":
case "reverse":
break;
default:
if (tuple[attr] === undefined) {
if (typeof list[attr] == "function") {
tuple[attr] = (function (x) {
return function () {
return list[x].apply(null, arguments);
};
})(attr);
}
}
}
}
tuple.__eq__ = function (self, other) {
if (other === undefined) {
return self === tuple;
}
return list.__eq__(self, other);
};
function c_mul(a, b) {
s = ((parseInt(a) * b) & 0xffffffff).toString(16);
return parseInt(s.substr(0, s.length - 1), 16);
}
tuple.__hash__ = function (self) {
var x = 0x3456789;
for (var i = 0, len = self.length; i < len; i++) {
var y = _b_.hash(self[i]);
x = c_mul(1000003, x) ^ (y & 0xffffffff);
}
return x;
};
tuple.__init__ = function () {
return $N;
};
tuple.__new__ = function (cls, ...args) {
if (cls === undefined) {
throw _b_.TypeError.$factory("list.__new__(): not enough arguments");
}
var self = [];
self.__class__ = cls;
self.__brython__ = true;
self.__dict__ = $B.empty_dict();
var arg = $B.$iter(args[0]),
next_func = $B.$call($B.$getattr(arg, "__next__"));
while (1) {
try {
var item = next_func();
self.push(item);
} catch (err) {
if (err.__class__ === _b_.StopIteration) {
break;
} else {
throw err;
}
}
}
return self;
};
tuple.__reduce_ex__ = function (self) {
return $B.fast_tuple([
__newobj__,
$B.fast_tuple([self.__class__].concat(self.slice())),
_b_.None,
_b_.None,
]);
};
tuple.__repr__ = function (self) {
$B.builtins_repr_check(tuple, arguments);
return list_repr(self);
};
$B.set_func_names(tuple, "builtins");
_b_.list = list;
_b_.tuple = tuple;
_b_.object.__bases__ = tuple.$factory();
_b_.type.__bases__ = $B.fast_tuple([_b_.object]);
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var $GeneratorReturn = {};
$B.generator_return = function (value) {
return { __class__: $GeneratorReturn, value: value };
};
$B.generator = $B.make_class("generator", function (func, name) {
var res = function () {
var gen = func.apply(null, arguments);
gen.$name = name || "generator";
gen.$func = func;
gen.$has_run = false;
return {
__class__: $B.generator,
js_gen: gen,
};
};
res.$infos = func.$infos;
res.$is_genfunc = true;
res.$name = name;
return res;
});
$B.generator.__iter__ = function (self) {
return self;
};
$B.generator.__next__ = function (self) {
return $B.generator.send(self, _b_.None);
};
$B.generator.__str__ = function (self) {
var name = self.js_gen.$name || "generator";
if (self.js_gen.$func && self.js_gen.$func.$infos) {
name = self.js_gen.$func.$infos.__qualname__;
}
return `<generator object ${name}>`;
};
$B.generator.close = function (self) {
if ($B.js_from_ast) {
return $B.generator.close1(self);
}
try {
$B.generator.throw(self, _b_.GeneratorExit.$factory());
} catch (err) {
if (!$B.is_exc(err, [_b_.GeneratorExit, _b_.StopIteration])) {
throw _b_.RuntimeError.$factory("generator ignored GeneratorExit");
}
}
};
$B.generator.close1 = function (self) {
var save_stack = $B.frames_stack.slice();
if (self.$frame) {
$B.frames_stack.push(self.$frame);
}
try {
$B.generator.throw(self, _b_.GeneratorExit.$factory());
} catch (err) {
if (!$B.is_exc(err, [_b_.GeneratorExit, _b_.StopIteration])) {
$B.frames_stack = save_stack;
throw _b_.RuntimeError.$factory("generator ignored GeneratorExit");
}
}
$B.frames_stack = save_stack;
};
$B.generator.send = function (self, value) {
if ($B.js_from_ast) {
return $B.generator.send1(self, value);
}
var gen = self.js_gen;
gen.$has_run = true;
if (gen.$finished) {
throw _b_.StopIteration.$factory(value);
}
if (gen.gi_running === true) {
throw _b_.ValueError.$factory("generator already executing");
}
gen.gi_running = true;
try {
var res = gen.next(value);
} catch (err) {
gen.$finished = true;
throw err;
}
if (res.value && res.value.__class__ === $GeneratorReturn) {
gen.$finished = true;
throw _b_.StopIteration.$factory(res.value.value);
}
gen.gi_running = false;
if (res.done) {
throw _b_.StopIteration.$factory(res.value);
}
return res.value;
};
function trace() {
return $B.frames_stack.slice();
}
$B.generator.send1 = function (self, value) {
var gen = self.js_gen;
gen.$has_run = true;
if (gen.$finished) {
throw _b_.StopIteration.$factory(value);
}
if (gen.gi_running === true) {
throw _b_.ValueError.$factory("generator already executing");
}
gen.gi_running = true;
var save_stack = $B.frames_stack.slice();
if (self.$frame) {
$B.frames_stack.push(self.$frame);
}
try {
var res = gen.next(value);
} catch (err) {
gen.$finished = true;
$B.frames_stack = save_stack;
throw err;
}
if ($B.last($B.frames_stack) === self.$frame) {
$B.leave_frame();
}
$B.frames_stack = save_stack;
if (res.value && res.value.__class__ === $GeneratorReturn) {
gen.$finished = true;
throw _b_.StopIteration.$factory(res.value.value);
}
gen.gi_running = false;
if (res.done) {
throw _b_.StopIteration.$factory(res.value);
}
return res.value;
};
$B.generator.throw = function (self, type, value, traceback) {
if ($B.js_from_ast) {
return $B.generator.throw1(self, type, value, traceback);
}
var gen = self.js_gen,
exc = type;
if (exc.$is_class) {
if (!_b_.issubclass(type, _b_.BaseException)) {
throw _b_.TypeError.$factory(
"exception value must be an " + "instance of BaseException"
);
} else if (value === undefined) {
exc = $B.$call(exc)();
} else if (_b_.isinstance(value, type)) {
exc = value;
}
} else {
if (value === undefined) {
value = exc;
} else {
exc = $B.$call(exc)(value);
}
}
if (traceback !== undefined) {
exc.$traceback = traceback;
}
var res = gen.throw(exc);
if (res.done) {
throw _b_.StopIteration.$factory("StopIteration");
}
return res.value;
};
$B.generator.throw1 = function (self, type, value, traceback) {
var gen = self.js_gen,
exc = type;
if (exc.$is_class) {
if (!_b_.issubclass(type, _b_.BaseException)) {
throw _b_.TypeError.$factory(
"exception value must be an " + "instance of BaseException"
);
} else if (value === undefined) {
exc = $B.$call(exc)();
} else if (_b_.isinstance(value, type)) {
exc = value;
}
} else {
if (value === undefined) {
value = exc;
} else {
exc = $B.$call(exc)(value);
}
}
if (traceback !== undefined) {
exc.$traceback = traceback;
}
var save_stack = $B.frames_stack.slice();
if (self.$frame) {
$B.frames_stack.push(self.$frame);
}
var res = gen.throw(exc);
$B.frames_stack = save_stack;
if (res.done) {
throw _b_.StopIteration.$factory("StopIteration");
}
return res.value;
};
$B.set_func_names($B.generator, "builtins");
$B.async_generator = $B.make_class("async_generator", function (func) {
var f = function () {
var gen = func.apply(null, arguments);
var res = Object.create(null);
res.__class__ = $B.async_generator;
res.js_gen = gen;
return res;
};
return f;
});
var ag_closed = {};
$B.async_generator.__aiter__ = function (self) {
return self;
};
$B.async_generator.__anext__ = function (self) {
return $B.async_generator.asend(self, _b_.None);
};
$B.async_generator.aclose = function (self) {
self.js_gen.$finished = true;
return _b_.None;
};
$B.async_generator.asend1 = async function (self, value) {
var gen = self.js_gen;
if (gen.$finished) {
throw _b_.StopAsyncIteration.$factory(value);
}
if (gen.ag_running === true) {
throw _b_.ValueError.$factory("generator already executing");
}
gen.ag_running = true;
var save_stack = $B.frames_stack.slice();
if (self.$frame) {
$B.frames_stack.push(self.$frame);
}
try {
var res = await gen.next(value);
} catch (err) {
gen.$finished = true;
$B.frames_stack = save_stack;
throw err;
}
if ($B.last($B.frames_stack) === self.$frame) {
$B.leave_frame();
}
$B.frames_stack = save_stack;
if (res.done) {
throw _b_.StopAsyncIteration.$factory(value);
}
if (res.value.__class__ === $GeneratorReturn) {
gen.$finished = true;
throw _b_.StopAsyncIteration.$factory(res.value.value);
}
gen.ag_running = false;
return res.value;
};
$B.async_generator.asend = async function (self, value) {
if ($B.js_from_ast) {
return $B.async_generator.asend1(self, value);
}
var gen = self.js_gen;
if (gen.$finished) {
throw _b_.StopAsyncIteration.$factory(value);
}
if (gen.ag_running === true) {
throw _b_.ValueError.$factory("generator already executing");
}
gen.ag_running = true;
try {
var res = await gen.next(value);
} catch (err) {
gen.$finished = true;
throw err;
}
if (res.done) {
throw _b_.StopAsyncIteration.$factory(value);
}
if (res.value.__class__ === $GeneratorReturn) {
gen.$finished = true;
throw _b_.StopAsyncIteration.$factory(res.value.value);
}
gen.ag_running = false;
return res.value;
};
$B.async_generator.athrow = async function (self, type, value, traceback) {
if ($B.js_from_ast) {
return $B.async_generator.athrow1(self, type, value, traceback);
}
var gen = self.js_gen,
exc = type;
if (exc.$is_class) {
if (!_b_.issubclass(type, _b_.BaseException)) {
throw _b_.TypeError.$factory(
"exception value must be an " + "instance of BaseException"
);
} else if (value === undefined) {
value = $B.$call(exc)();
}
} else {
if (value === undefined) {
value = exc;
} else {
exc = $B.$call(exc)(value);
}
}
if (traceback !== undefined) {
exc.$traceback = traceback;
}
await gen.throw(value);
};
$B.async_generator.athrow1 = async function (self, type, value, traceback) {
var gen = self.js_gen,
exc = type;
if (exc.$is_class) {
if (!_b_.issubclass(type, _b_.BaseException)) {
throw _b_.TypeError.$factory(
"exception value must be an " + "instance of BaseException"
);
} else if (value === undefined) {
value = $B.$call(exc)();
}
} else {
if (value === undefined) {
value = exc;
} else {
exc = $B.$call(exc)(value);
}
}
if (traceback !== undefined) {
exc.$traceback = traceback;
}
var save_stack = $B.frames_stack.slice();
if (self.$frame) {
$B.frames_stack.push(self.$frame);
}
await gen.throw(value);
$B.frames_stack = save_stack;
};
$B.set_func_names($B.async_generator, "builtins");
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins,
object = _b_.object,
_window = self;
function $getMouseOffset(target, ev) {
ev = ev || _window.event;
var docPos = $getPosition(target);
var mousePos = $mouseCoords(ev);
return { x: mousePos.x - docPos.x, y: mousePos.y - docPos.y };
}
function $getPosition(e) {
var left = 0,
top = 0,
width = e.width || e.offsetWidth,
height = e.height || e.offsetHeight,
scroll = document.scrollingElement.scrollTop;
while (e.offsetParent) {
left += e.offsetLeft;
top += e.offsetTop;
e = e.offsetParent;
}
left += e.offsetLeft || 0;
top += e.offsetTop || 0;
if (e.parentElement) {
var parent_pos = $getPosition(e.parentElement);
left += parent_pos.left;
top += parent_pos.top;
}
return { left: left, top: top, width: width, height: height };
}
function trace(msg) {
var elt = document.getElementById("trace");
if (elt) {
elt.innerText += msg;
}
}
function $mouseCoords(ev) {
if (ev.type.startsWith("touch")) {
var res = {};
res.x = _b_.int.$factory(ev.touches[0].screenX);
res.y = _b_.int.$factory(ev.touches[0].screenY);
res.__getattr__ = function (attr) {
return this[attr];
};
res.__class__ = "MouseCoords";
return res;
}
var posx = 0,
posy = 0;
if (!ev) {
var ev = _window.event;
}
if (ev.pageX || ev.pageY) {
posx = ev.pageX;
posy = ev.pageY;
} else if (ev.clientX || ev.clientY) {
posx =
ev.clientX +
document.body.scrollLeft +
document.documentElement.scrollLeft;
posy =
ev.clientY +
document.body.scrollTop +
document.documentElement.scrollTop;
}
var res = {};
res.x = _b_.int.$factory(posx);
res.y = _b_.int.$factory(posy);
res.__getattr__ = function (attr) {
return this[attr];
};
res.__class__ = "MouseCoords";
return res;
}
var $DOMNodeAttrs = [
"nodeName",
"nodeValue",
"nodeType",
"parentNode",
"childNodes",
"firstChild",
"lastChild",
"previousSibling",
"nextSibling",
"attributes",
"ownerDocument",
];
$B.$isNode = function (o) {
return typeof Node === "object"
? o instanceof Node
: o &&
typeof o === "object" &&
typeof o.nodeType === "number" &&
typeof o.nodeName === "string";
};
$B.$isNodeList = function (nodes) {
try {
var result = Object.prototype.toString.call(nodes);
var re = new RegExp("^\\[object (HTMLCollection|NodeList)\\]$");
return (
typeof nodes === "object" &&
re.exec(result) !== null &&
nodes.length !== undefined &&
(nodes.length == 0 ||
(typeof nodes[0] === "object" && nodes[0].nodeType > 0))
);
} catch (err) {
return false;
}
};
var $DOMEventAttrs_W3C = [
"NONE",
"CAPTURING_PHASE",
"AT_TARGET",
"BUBBLING_PHASE",
"type",
"target",
"currentTarget",
"eventPhase",
"bubbles",
"cancelable",
"timeStamp",
"stopPropagation",
"preventDefault",
"initEvent",
];
var $DOMEventAttrs_IE = [
"altKey",
"altLeft",
"button",
"cancelBubble",
"clientX",
"clientY",
"contentOverflow",
"ctrlKey",
"ctrlLeft",
"data",
"dataFld",
"dataTransfer",
"fromElement",
"keyCode",
"nextPage",
"offsetX",
"offsetY",
"origin",
"propertyName",
"reason",
"recordset",
"repeat",
"screenX",
"screenY",
"shiftKey",
"shiftLeft",
"source",
"srcElement",
"srcFilter",
"srcUrn",
"toElement",
"type",
"url",
"wheelDelta",
"x",
"y",
];
$B.$isEvent = function (obj) {
var flag = true;
for (var i = 0; i < $DOMEventAttrs_W3C.length; i++) {
if (obj[$DOMEventAttrs_W3C[i]] === undefined) {
flag = false;
break;
}
}
if (flag) {
return true;
}
for (var i = 0; i < $DOMEventAttrs_IE.length; i++) {
if (obj[$DOMEventAttrs_IE[i]] === undefined) {
return false;
}
}
return true;
};
var $NodeTypes = {
1: "ELEMENT",
2: "ATTRIBUTE",
3: "TEXT",
4: "CDATA_SECTION",
5: "ENTITY_REFERENCE",
6: "ENTITY",
7: "PROCESSING_INSTRUCTION",
8: "COMMENT",
9: "DOCUMENT",
10: "DOCUMENT_TYPE",
11: "DOCUMENT_FRAGMENT",
12: "NOTATION",
};
var Attributes = $B.make_class("Attributes", function (elt) {
return { __class__: Attributes, elt: elt };
});
Attributes.__contains__ = function () {
var $ = $B.args(
"__getitem__",
2,
{ self: null, key: null },
["self", "key"],
arguments,
{},
null,
null
);
if ($.self.elt instanceof SVGElement) {
return $.self.elt.hasAttributeNS(null, $.key);
} else if (typeof $.self.elt.hasAttribute == "function") {
return $.self.elt.hasAttribute($.key);
}
return false;
};
Attributes.__delitem__ = function () {
var $ = $B.args(
"__getitem__",
2,
{ self: null, key: null },
["self", "key"],
arguments,
{},
null,
null
);
if (!Attributes.__contains__($.self, $.key)) {
throw _b_.KeyError.$factory($.key);
}
if ($.self.elt instanceof SVGElement) {
$.self.elt.removeAttributeNS(null, $.key);
return _b_.None;
} else if (typeof $.self.elt.hasAttribute == "function") {
$.self.elt.removeAttribute($.key);
return _b_.None;
}
};
Attributes.__getitem__ = function () {
var $ = $B.args(
"__getitem__",
2,
{ self: null, key: null },
["self", "key"],
arguments,
{},
null,
null
);
if (
$.self.elt instanceof SVGElement &&
$.self.elt.hasAttributeNS(null, $.key)
) {
return $.self.elt.getAttributeNS(null, $.key);
} else if (
typeof $.self.elt.hasAttribute == "function" &&
$.self.elt.hasAttribute($.key)
) {
return $.self.elt.getAttribute($.key);
}
throw _b_.KeyError.$factory($.key);
};
Attributes.__iter__ = function (self) {
self.$counter = 0;
var attrs = self.elt.attributes,
items = [];
for (var i = 0; i < attrs.length; i++) {
items.push(attrs[i].name);
}
self.$items = items;
return self;
};
Attributes.__next__ = function () {
var $ = $B.args(
"__next__",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
if ($.self.$counter < $.self.$items.length) {
var res = $.self.$items[$.self.$counter];
$.self.$counter++;
return res;
} else {
throw _b_.StopIteration.$factory("");
}
};
Attributes.__setitem__ = function () {
var $ = $B.args(
"__setitem__",
3,
{ self: null, key: null, value: null },
["self", "key", "value"],
arguments,
{},
null,
null
);
if (
$.self.elt instanceof SVGElement &&
typeof $.self.elt.setAttributeNS == "function"
) {
$.self.elt.setAttributeNS(null, $.key, $.value);
return _b_.None;
} else if (typeof $.self.elt.setAttribute == "function") {
$.self.elt.setAttribute($.key, $.value);
return _b_.None;
}
throw _b_.TypeError.$factory("Can't set attributes on element");
};
Attributes.__repr__ = Attributes.__str__ = function (self) {
var attrs = self.elt.attributes,
items = [];
for (var i = 0; i < attrs.length; i++) {
items.push(
attrs[i].name +
': "' +
self.elt.getAttributeNS(null, attrs[i].name) +
'"'
);
}
return "{" + items.join(", ") + "}";
};
Attributes.get = function () {
var $ = $B.args(
"get",
3,
{ self: null, key: null, deflt: null },
["self", "key", "deflt"],
arguments,
{ deflt: _b_.None },
null,
null
);
try {
return Attributes.__getitem__($.self, $.key);
} catch (err) {
if (err.__class__ === _b_.KeyError) {
return $.deflt;
} else {
throw err;
}
}
};
Attributes.keys = function () {
return Attributes.__iter__.apply(null, arguments);
};
Attributes.items = function () {
var $ = $B.args(
"values",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
attrs = $.self.elt.attributes,
values = [];
for (var i = 0; i < attrs.length; i++) {
values.push([attrs[i].name, attrs[i].value]);
}
return _b_.list.__iter__(values);
};
Attributes.values = function () {
var $ = $B.args(
"values",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
),
attrs = $.self.elt.attributes,
values = [];
for (var i = 0; i < attrs.length; i++) {
values.push(attrs[i].value);
}
return _b_.list.__iter__(values);
};
$B.set_func_names(Attributes, "<dom>");
var DOMEvent = ($B.DOMEvent = {
__class__: _b_.type,
__mro__: [object],
$infos: { __name__: "DOMEvent" },
});
DOMEvent.__new__ = function (cls, evt_name) {
var ev = new Event(evt_name);
ev.__class__ = DOMEvent;
if (ev.preventDefault === undefined) {
ev.preventDefault = function () {
ev.returnValue = false;
};
}
if (ev.stopPropagation === undefined) {
ev.stopPropagation = function () {
ev.cancelBubble = true;
};
}
return ev;
};
function dom2svg(svg_elt, coords) {
var pt = svg_elt.createSVGPoint();
pt.x = coords.x;
pt.y = coords.y;
return pt.matrixTransform(svg_elt.getScreenCTM().inverse());
}
DOMEvent.__getattribute__ = function (self, attr) {
switch (attr) {
case "__repr__":
case "__str__":
return function () {
return "<DOMEvent object>";
};
case "x":
return $mouseCoords(self).x;
case "y":
return $mouseCoords(self).y;
case "data":
if (self.dataTransfer !== null) {
return Clipboard.$factory(self.dataTransfer);
}
return $B.$JS2Py(self["data"]);
case "target":
if (self.target !== undefined) {
return DOMNode.$factory(self.target);
}
case "char":
return String.fromCharCode(self.which);
case "svgX":
if (self.target instanceof SVGSVGElement) {
return Math.floor(dom2svg(self.target, $mouseCoords(self)).x);
}
throw _b_.AttributeError.$factory(
"event target is not an SVG " + "element"
);
case "svgY":
if (self.target instanceof SVGSVGElement) {
return Math.floor(dom2svg(self.target, $mouseCoords(self)).y);
}
throw _b_.AttributeError.$factory(
"event target is not an SVG " + "element"
);
}
var res = self[attr];
if (res !== undefined) {
if (typeof res == "function") {
var func = function () {
var args = [];
for (var i = 0; i < arguments.length; i++) {
args.push($B.pyobj2jsobj(arguments[i]));
}
return res.apply(self, arguments);
};
func.$infos = { __name__: res.name, __qualname__: res.name };
return func;
}
return $B.$JS2Py(res);
}
throw $B.attr_error(attr, self);
};
DOMEvent.$factory = function (evt_name) {
return DOMEvent.__new__(DOMEvent, evt_name);
};
var $DOMEvent = ($B.$DOMEvent = function (ev) {
ev.__class__ = DOMEvent;
ev.$no_dict = true;
if (ev.preventDefault === undefined) {
ev.preventDefault = function () {
ev.returnValue = false;
};
}
if (ev.stopPropagation === undefined) {
ev.stopPropagation = function () {
ev.cancelBubble = true;
};
}
return ev;
});
$B.set_func_names(DOMEvent, "browser");
var Clipboard = {
__class__: _b_.type,
$infos: { __module__: "browser", __name__: "Clipboard" },
};
Clipboard.__getitem__ = function (self, name) {
return self.data.getData(name);
};
Clipboard.__mro__ = [object];
Clipboard.__setitem__ = function (self, name, value) {
self.data.setData(name, value);
};
Clipboard.$factory = function (data) {
return {
__class__: Clipboard,
__dict__: $B.empty_dict(),
data: data,
};
};
$B.set_func_names(Clipboard, "<dom>");
function $EventsList(elt, evt, arg) {
this.elt = elt;
this.evt = evt;
if (_b_.isinstance(arg, _b_.list)) {
this.callbacks = arg;
} else {
this.callbacks = [arg];
}
this.remove = function (callback) {
var found = false;
for (var i = 0; i < this.callbacks.length; i++) {
if (this.callbacks[i] === callback) {
found = true;
this.callback.splice(i, 1);
this.elt.removeEventListener(this.evt, callback, false);
break;
}
}
if (!found) {
throw _b_.KeyError.$factory("not found");
}
};
}
var OpenFile = ($B.OpenFile = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "<pydom>", __name__: "OpenFile" },
});
OpenFile.$factory = function (file, mode, encoding) {
var res = {
__class__: $OpenFileDict,
file: file,
reader: new FileReader(),
};
if (mode === "r") {
res.reader.readAsText(file, encoding);
} else if (mode === "rb") {
res.reader.readAsBinaryString(file);
}
return res;
};
OpenFile.__getattr__ = function (self, attr) {
if (self["get_" + attr] !== undefined) {
return self["get_" + attr];
}
return self.reader[attr];
};
OpenFile.__setattr__ = function (self, attr, value) {
var obj = self.reader;
if (attr.substr(0, 2) == "on") {
var callback = function (ev) {
return value($DOMEvent(ev));
};
obj.addEventListener(attr.substr(2), callback);
} else if ("set_" + attr in obj) {
return obj["set_" + attr](value);
} else if (attr in obj) {
obj[attr] = value;
} else {
_b_.setattr(obj, attr, value);
}
};
$B.set_func_names(OpenFile, "<dom>");
var dom = { File: function () {}, FileReader: function () {} };
dom.File.__class__ = _b_.type;
dom.File.__str__ = function () {
return "<class 'File'>";
};
dom.FileReader.__class__ = _b_.type;
dom.FileReader.__str__ = function () {
return "<class 'FileReader'>";
};
var DOMNode = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "browser", __name__: "DOMNode" },
};
DOMNode.$factory = function (elt) {
return elt;
};
DOMNode.__add__ = function (self, other) {
var res = TagSum.$factory();
(res.children = [self]), (pos = 1);
if (_b_.isinstance(other, TagSum)) {
res.children = res.children.concat(other.children);
} else if (
_b_.isinstance(other, [
_b_.str,
_b_.int,
_b_.float,
_b_.list,
_b_.dict,
_b_.set,
_b_.tuple,
])
) {
res.children[pos++] = DOMNode.$factory(
document.createTextNode(_b_.str.$factory(other))
);
} else if (_b_.isinstance(other, DOMNode)) {
res.children[pos++] = other;
} else {
try {
res.children = res.children.concat(_b_.list.$factory(other));
} catch (err) {
throw _b_.TypeError.$factory(
"can't add '" + $B.class_name(other) + "' object to DOMNode instance"
);
}
}
return res;
};
DOMNode.__bool__ = function (self) {
return true;
};
DOMNode.__contains__ = function (self, key) {
if (self.nodeType == 9 && typeof key == "string") {
return document.getElementById(key) !== null;
}
if (self.length !== undefined && typeof self.item == "function") {
for (var i = 0, len = self.length; i < len; i++) {
if (self.item(i) === key) {
return true;
}
}
}
return false;
};
DOMNode.__del__ = function (self) {
if (!self.parentNode) {
throw _b_.ValueError.$factory("can't delete " + _b_.str.$factory(self));
}
self.parentNode.removeChild(self);
};
DOMNode.__delattr__ = function (self, attr) {
if (self[attr] === undefined) {
throw _b_.AttributeError.$factory(
`cannot delete DOMNode attribute '${attr}'`
);
}
delete self[attr];
return _b_.None;
};
DOMNode.__delitem__ = function (self, key) {
if (self.nodeType == 9) {
var res = self.getElementById(key);
if (res) {
res.parentNode.removeChild(res);
} else {
throw _b_.KeyError.$factory(key);
}
} else {
self.parentNode.removeChild(self);
}
};
DOMNode.__dir__ = function (self) {
var res = [];
for (var attr in self) {
if (attr.charAt(0) != "$") {
res.push(attr);
}
}
res.sort();
return res;
};
DOMNode.__eq__ = function (self, other) {
return self == other;
};
DOMNode.__getattribute__ = function (self, attr) {
switch (attr) {
case "attrs":
return Attributes.$factory(self);
case "children":
case "child_nodes":
case "class_name":
case "html":
case "parent":
case "text":
return DOMNode[attr](self);
case "height":
case "left":
case "top":
case "width":
if (self.tagName == "CANVAS" && self[attr]) {
return self[attr];
}
if (self instanceof SVGElement) {
return self[attr].baseVal.value;
}
var computed = window.getComputedStyle(self).getPropertyValue(attr);
if (computed !== undefined) {
var prop = Math.floor(parseFloat(computed) + 0.5);
return isNaN(prop) ? computed : prop;
} else if (self.style[attr]) {
return parseInt(self.style[attr]);
} else {
throw _b_.AttributeError.$factory(
"style." + attr + " is not set for " + _b_.str.$factory(self)
);
}
case "x":
case "y":
if (!(self instanceof SVGElement)) {
var pos = $getPosition(self);
return attr == "x" ? pos.left : pos.top;
}
case "clear":
case "closest":
return function () {
return DOMNode[attr].call(null, self, ...arguments);
};
case "headers":
if (self.nodeType == 9) {
var req = new XMLHttpRequest();
req.open("GET", document.location, false);
req.send(null);
var headers = req.getAllResponseHeaders();
headers = headers.split("\r\n");
var res = $B.empty_dict();
for (var i = 0; i < headers.length; i++) {
var header = headers[i];
if (header.strip().length == 0) {
continue;
}
var pos = header.search(":");
res.__setitem__(
header.substr(0, pos),
header.substr(pos + 1).lstrip()
);
}
return res;
}
break;
case "location":
attr = "location";
break;
}
if (
attr == "select" &&
self.nodeType == 1 &&
["INPUT", "TEXTAREA"].indexOf(self.tagName.toUpperCase()) > -1
) {
return function (selector) {
if (selector === undefined) {
self.select();
return _b_.None;
}
return DOMNode.select(self, selector);
};
}
if (attr == "query" && self.nodeType == 9) {
var res = { __class__: Query, _keys: [], _values: {} };
var qs = location.search.substr(1).split("&");
if (location.search != "") {
for (var i = 0; i < qs.length; i++) {
var pos = qs[i].search("="),
elts = [qs[i].substr(0, pos), qs[i].substr(pos + 1)],
key = decodeURIComponent(elts[0]),
value = decodeURIComponent(elts[1]);
if (res._keys.indexOf(key) > -1) {
res._values[key].push(value);
} else {
res._keys.push(key);
res._values[key] = [value];
}
}
}
return res;
}
var property = self[attr];
if (
property !== undefined &&
self.__class__ &&
self.__class__.__module__ != "browser.html" &&
self.__class__.__module__ != "browser.svg"
) {
var bases = self.__class__.__bases__;
var show_message = true;
for (var base of bases) {
if (base.__module__ == "browser.html") {
show_message = false;
break;
}
}
if (show_message) {
var from_class = $B.$getattr(self.__class__, attr, _b_.None);
if (from_class !== _b_.None) {
var frame = $B.last($B.frames_stack),
line_info = frame[1].$line_info,
line = line_info.split(",")[0];
console.info(
"Warning: line " +
line +
", " +
self.tagName +
" element has instance attribute '" +
attr +
"' set." +
" Attribute of class " +
$B.class_name(self) +
" is ignored."
);
}
}
}
if (property === undefined) {
if (self.tagName) {
var ce = customElements.get(self.tagName.toLowerCase());
if (ce !== undefined && ce.$cls !== undefined) {
var save_class = self.__class__;
self.__class__ = ce.$cls;
try {
var res = _b_.object.__getattribute__(self, attr);
self.__class__ = save_class;
return res;
} catch (err) {
self.__class__ = save_class;
if (!$B.is_exc(err, [_b_.AttributeError])) {
throw err;
}
}
}
}
return object.__getattribute__(self, attr);
}
var res = property;
if (res !== undefined) {
if (res === null) {
return _b_.None;
}
if (typeof res === "function") {
if (res.$is_func) {
return res;
}
var func = (function (f, elt) {
return function () {
var args = [],
pos = 0;
for (var i = 0; i < arguments.length; i++) {
var arg = arguments[i];
if (typeof arg == "function") {
if (arg.$cache) {
var f1 = arg.$cache;
} else {
var f1 = (function (dest_fn) {
return function () {
try {
return dest_fn.apply(null, arguments);
} catch (err) {
$B.handle_error(err);
}
};
})(arg);
arg.$cache = f1;
}
args[pos++] = f1;
} else if (_b_.isinstance(arg, DOMNode)) {
args[pos++] = arg;
} else if (arg === _b_.None) {
args[pos++] = null;
} else if (arg.__class__ == _b_.dict) {
args[pos++] = _b_.dict.$to_obj(arg);
} else {
args[pos++] = arg;
}
}
var result = f.apply(elt, args);
return $B.$JS2Py(result);
};
})(res, self);
func.$infos = { __name__: attr, __qualname__: attr };
func.$is_func = true;
func.$python_function = res;
return func;
}
if (attr == "style") {
return $B.JSObj.$factory(self[attr]);
}
if (Array.isArray(res)) {
return res;
}
return $B.$JS2Py(res);
}
return object.__getattribute__(self, attr);
};
DOMNode.__getitem__ = function (self, key) {
if (self.nodeType == 9) {
if (typeof key.valueOf() == "string") {
var res = self.getElementById(key);
if (res) {
return DOMNode.$factory(res);
}
throw _b_.KeyError.$factory(key);
} else {
try {
var elts = self.getElementsByTagName(key.$infos.__name__),
res = [];
for (var i = 0; i < elts.length; i++) {
res.push(DOMNode.$factory(elts[i]));
}
return res;
} catch (err) {
throw _b_.KeyError.$factory(_b_.str.$factory(key));
}
}
} else {
if (
(typeof key == "number" || typeof key == "boolean") &&
typeof self.item == "function"
) {
var key_to_int = _b_.int.$factory(key);
if (key_to_int < 0) {
key_to_int += self.length;
}
var res = DOMNode.$factory(self.item(key_to_int));
if (res === undefined) {
throw _b_.KeyError.$factory(key);
}
return res;
} else if (
typeof key == "string" &&
self.attributes &&
typeof self.attributes.getNamedItem == "function"
) {
var attr = self.attributes.getNamedItem(key);
if (!!attr) {
return attr.value;
}
throw _b_.KeyError.$factory(key);
}
}
};
DOMNode.__hash__ = function (self) {
return self.__hashvalue__ === undefined
? (self.__hashvalue__ = $B.$py_next_hash--)
: self.__hashvalue__;
};
DOMNode.__iter__ = function (self) {
if (self.length !== undefined && typeof self.item == "function") {
var items = [];
for (var i = 0, len = self.length; i < len; i++) {
items.push(DOMNode.$factory(self.item(i)));
}
} else if (self.childNodes !== undefined) {
var items = [];
for (var i = 0, len = self.childNodes.length; i < len; i++) {
items.push(DOMNode.$factory(self.childNodes[i]));
}
}
return $B.$iter(items);
};
DOMNode.__le__ = function (self, other) {
if (self.nodeType == 9) {
self = self.body;
}
if (_b_.isinstance(other, TagSum)) {
for (var i = 0; i < other.children.length; i++) {
self.appendChild(other.children[i]);
}
} else if (typeof other == "string" || typeof other == "number") {
var txt = document.createTextNode(other.toString());
self.appendChild(txt);
} else if (other instanceof Node) {
self.appendChild(other);
} else {
try {
var items = _b_.list.$factory(other);
items.forEach(function (item) {
DOMNode.__le__(self, item);
});
} catch (err) {
throw _b_.TypeError.$factory(
"can't add '" + $B.class_name(other) + "' object to DOMNode instance"
);
}
}
return self;
};
DOMNode.__len__ = function (self) {
return self.length;
};
DOMNode.__mul__ = function (self, other) {
if (_b_.isinstance(other, _b_.int) && other.valueOf() > 0) {
var res = TagSum.$factory();
var pos = res.children.length;
for (var i = 0; i < other.valueOf(); i++) {
res.children[pos++] = DOMNode.clone(self)();
}
return res;
}
throw _b_.ValueError.$factory(
"can't multiply " + self.__class__ + "by " + other
);
};
DOMNode.__ne__ = function (self, other) {
return !DOMNode.__eq__(self, other);
};
DOMNode.__next__ = function (self) {
self.$counter++;
if (self.$counter < self.childNodes.length) {
return DOMNode.$factory(self.childNodes[self.$counter]);
}
throw _b_.StopIteration.$factory("StopIteration");
};
DOMNode.__radd__ = function (self, other) {
var res = TagSum.$factory();
var txt = DOMNode.$factory(document.createTextNode(other));
res.children = [txt, self];
return res;
};
DOMNode.__str__ = DOMNode.__repr__ = function (self) {
var attrs = self.attributes,
attrs_str = "",
items = [];
if (attrs !== undefined) {
var items = [];
for (var i = 0; i < attrs.length; i++) {
items.push(
attrs[i].name + '="' + self.getAttributeNS(null, attrs[i].name) + '"'
);
}
}
var proto = Object.getPrototypeOf(self);
if (proto) {
var name = proto.constructor.name;
if (name === undefined) {
var proto_str = proto.constructor.toString();
name = proto_str.substring(8, proto_str.length - 1);
}
items.splice(0, 0, name);
return "<" + items.join(" ") + ">";
}
var res = "<DOMNode object type '";
return (
res +
$NodeTypes[self.nodeType] +
"' name '" +
self.nodeName +
"'" +
attrs_str +
">"
);
};
DOMNode.__setattr__ = function (self, attr, value) {
if (attr.substr(0, 2) == "on" && attr.length > 2) {
if (!$B.$bool(value)) {
DOMNode.unbind(self, attr.substr(2));
} else {
DOMNode.bind(self, attr.substr(2), value);
}
} else {
switch (attr) {
case "left":
case "top":
case "width":
case "height":
if (_b_.isinstance(value, _b_.int) && self.nodeType == 1) {
self.style[attr] = value + "px";
return _b_.None;
} else {
throw _b_.ValueError.$factory(
attr +
" value should be" +
" an integer, not " +
$B.class_name(value)
);
}
break;
}
if (DOMNode["set_" + attr] !== undefined) {
return DOMNode["set_" + attr](self, value);
}
function warn(msg) {
console.log(msg);
var frame = $B.last($B.frames_stack);
if ($B.debug > 0) {
var info = frame[1].$line_info.split(",");
console.log("module", info[1], "line", info[0]);
if ($B.$py_src.hasOwnProperty(info[1])) {
var src = $B.$py_src[info[1]];
console.log(src.split("\n")[parseInt(info[0]) - 1]);
}
} else {
console.log("module", frame[2]);
}
}
var proto = Object.getPrototypeOf(self),
nb = 0;
while (!!proto && proto !== Object.prototype && nb++ < 10) {
var descriptors = Object.getOwnPropertyDescriptors(proto);
if (!!descriptors && typeof descriptors.hasOwnProperty == "function") {
if (descriptors.hasOwnProperty(attr)) {
if (
!descriptors[attr].writable &&
descriptors[attr].set === undefined
) {
warn(
"Warning: property '" +
attr +
"' is not writable. Use element.attrs['" +
attr +
"'] instead."
);
}
break;
}
} else {
break;
}
proto = Object.getPrototypeOf(proto);
}
if (self.style && self.style[attr] !== undefined) {
warn("Warning: '" + attr + "' is a property of element.style");
}
self[attr] = value;
return _b_.None;
}
};
DOMNode.__setitem__ = function (self, key, value) {
if (typeof key == "number") {
self.childNodes[key] = value;
} else if (typeof key == "string") {
if (self.attributes) {
if (self instanceof SVGElement) {
self.setAttributeNS(null, key, value);
} else if (typeof self.setAttribute == "function") {
self.setAttribute(key, value);
}
}
}
};
DOMNode.abs_left = {
__get__: function (self) {
return $getPosition(self).left;
},
__set__: function () {
throw _b_.AttributeError.$factory(
"'DOMNode' objectattribute " + "'abs_left' is read-only"
);
},
};
DOMNode.abs_top = {
__get__: function (self) {
return $getPosition(self).top;
},
__set__: function () {
throw _b_.AttributeError.$factory(
"'DOMNode' objectattribute " + "'abs_top' is read-only"
);
},
};
DOMNode.attach = DOMNode.__le__;
DOMNode.bind = function (self, event) {
var $ = $B.args(
"bind",
4,
{ self: null, event: null, func: null, options: null },
["self", "event", "func", "options"],
arguments,
{ func: _b_.None, options: _b_.None },
null,
null
),
self = $.self,
event = $.event,
func = $.func,
options = $.options;
if (func === _b_.None) {
return function (f) {
return DOMNode.bind(self, event, f);
};
}
var callback = (function (f) {
return function (ev) {
try {
return f($DOMEvent(ev));
} catch (err) {
if (err.__class__ !== undefined) {
$B.handle_error(err);
} else {
try {
$B.$getattr($B.stderr, "write")(err);
} catch (err1) {
console.log(err);
}
}
}
};
})(func);
callback.$infos = func.$infos;
callback.$attrs = func.$attrs || {};
callback.$func = func;
if (typeof options == "boolean") {
self.addEventListener(event, callback, options);
} else if (options.__class__ === _b_.dict) {
self.addEventListener(event, callback, _b_.dict.$to_obj(options));
} else if (options === _b_.None) {
self.addEventListener(event, callback, false);
}
self.$events = self.$events || {};
self.$events[event] = self.$events[event] || [];
self.$events[event].push([func, callback]);
return self;
};
DOMNode.children = function (self) {
var res = [];
if (self.nodeType == 9) {
self = self.body;
}
for (var child of self.children) {
res.push(DOMNode.$factory(child));
}
return res;
};
DOMNode.child_nodes = function (self) {
var res = [];
if (self.nodeType == 9) {
self = self.body;
}
for (child of self.childNodes) {
res.push(DOMNode.$factory(child));
}
return res;
};
DOMNode.clear = function (self) {
var $ = $B.args(
"clear",
1,
{ self: null },
["self"],
arguments,
{},
null,
null
);
if (self.nodeType == 9) {
self = self.body;
}
while (self.firstChild) {
self.removeChild(self.firstChild);
}
};
DOMNode.Class = function (self) {
if (self.className !== undefined) {
return self.className;
}
return _b_.None;
};
DOMNode.class_name = function (self) {
return DOMNode.Class(self);
};
DOMNode.clone = function (self) {
var res = DOMNode.$factory(self.cloneNode(true));
var events = self.$events || {};
for (var event in events) {
var evt_list = events[event];
evt_list.forEach(function (evt) {
var func = evt[0];
DOMNode.bind(res, event, func);
});
}
return res;
};
DOMNode.closest = function (self, selector) {
var $ = $B.args(
"closest",
2,
{ self: null, selector: null },
["self", "selector"],
arguments,
{},
null,
null
);
var res = self.closest(selector);
if (res === null) {
throw _b_.KeyError.$factory("no parent with selector " + selector);
}
return DOMNode.$factory(res);
};
DOMNode.bindings = function (self) {
var res = $B.empty_dict();
for (var key in self.$events) {
_b_.dict.$setitem(
res,
key,
self.$events[key].map((x) => x[1])
);
}
return res;
};
DOMNode.events = function (self, event) {
self.$events = self.$events || {};
var evt_list = (self.$events[event] = self.$events[event] || []),
callbacks = [];
evt_list.forEach(function (evt) {
callbacks.push(evt[1]);
});
return callbacks;
};
function make_list(node_list) {
var res = [];
for (var i = 0; i < node_list.length; i++) {
res.push(DOMNode.$factory(node_list[i]));
}
return res;
}
DOMNode.get = function (self) {
var args = [];
for (var i = 1; i < arguments.length; i++) {
args.push(arguments[i]);
}
var $ns = $B.args("get", 0, {}, [], args, {}, null, "kw"),
$dict = {},
items = _b_.list.$factory(_b_.dict.items($ns["kw"]));
items.forEach(function (item) {
$dict[item[0]] = item[1];
});
if ($dict["name"] !== undefined) {
if (self.getElementsByName === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by name"
);
}
return make_list(self.getElementsByName($dict["name"]));
}
if ($dict["tag"] !== undefined) {
if (self.getElementsByTagName === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by tag name"
);
}
return make_list(self.getElementsByTagName($dict["tag"]));
}
if ($dict["classname"] !== undefined) {
if (self.getElementsByClassName === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by class name"
);
}
return make_list(self.getElementsByClassName($dict["classname"]));
}
if ($dict["id"] !== undefined) {
if (self.getElementById === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by id"
);
}
var id_res = document.getElementById($dict["id"]);
if (!id_res) {
return [];
}
return [DOMNode.$factory(id_res)];
}
if ($dict["selector"] !== undefined) {
if (self.querySelectorAll === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by selector"
);
}
return make_list(self.querySelectorAll($dict["selector"]));
}
return res;
};
DOMNode.getContext = function (self) {
if (!("getContext" in self)) {
throw _b_.AttributeError.$factory("object has no attribute 'getContext'");
}
return function (ctx) {
return $B.JSObj.$factory(self.getContext(ctx));
};
};
DOMNode.getSelectionRange = function (self) {
if (self["getSelectionRange"] !== undefined) {
return self.getSelectionRange.apply(null, arguments);
}
};
DOMNode.html = function (self) {
var res = self.innerHTML;
if (res === undefined) {
if (self.nodeType == 9 && self.body) {
res = self.body.innerHTML;
} else {
res = _b_.None;
}
}
return res;
};
DOMNode.index = function (self, selector) {
var items;
if (selector === undefined) {
items = self.parentElement.childNodes;
} else {
items = self.parentElement.querySelectorAll(selector);
}
var rank = -1;
for (var i = 0; i < items.length; i++) {
if (items[i] === self) {
rank = i;
break;
}
}
return rank;
};
DOMNode.inside = function (self, other) {
var elt = self;
while (true) {
if (other === elt) {
return true;
}
elt = elt.parentNode;
if (!elt) {
return false;
}
}
};
DOMNode.options = function (self) {
return new $OptionsClass(self);
};
DOMNode.parent = function (self) {
if (self.parentElement) {
return DOMNode.$factory(self.parentElement);
}
return _b_.None;
};
DOMNode.reset = function (self) {
return function () {
self.reset();
};
};
DOMNode.scrolled_left = {
__get__: function (self) {
return $getPosition(self).left - document.scrollingElement.scrollLeft;
},
__set__: function () {
throw _b_.AttributeError.$factory(
"'DOMNode' objectattribute " + "'scrolled_left' is read-only"
);
},
};
DOMNode.scrolled_top = {
__get__: function (self) {
return $getPosition(self).top - document.scrollingElement.scrollTop;
},
__set__: function () {
throw _b_.AttributeError.$factory(
"'DOMNode' objectattribute " + "'scrolled_top' is read-only"
);
},
};
DOMNode.select = function (self, selector) {
if (self.querySelectorAll === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by selector"
);
}
return make_list(self.querySelectorAll(selector));
};
DOMNode.select_one = function (self, selector) {
if (self.querySelector === undefined) {
throw _b_.TypeError.$factory(
"DOMNode object doesn't support " + "selection by selector"
);
}
var res = self.querySelector(selector);
if (res === null) {
return _b_.None;
}
return DOMNode.$factory(res);
};
DOMNode.setSelectionRange = function (self) {
if (this["setSelectionRange"] !== undefined) {
return (function (obj) {
return function () {
return obj.setSelectionRange.apply(obj, arguments);
};
})(this);
} else if (this["createTextRange"] !== undefined) {
return (function (obj) {
return function (start_pos, end_pos) {
if (end_pos == undefined) {
end_pos = start_pos;
}
var range = obj.createTextRange();
range.collapse(true);
range.moveEnd("character", start_pos);
range.moveStart("character", end_pos);
range.select();
};
})(this);
}
};
DOMNode.set_class_name = function (self, arg) {
self.setAttribute("class", arg);
};
DOMNode.set_html = function (self, value) {
if (self.nodeType == 9) {
self = self.body;
}
self.innerHTML = _b_.str.$factory(value);
};
DOMNode.set_style = function (self, style) {
if (typeof style === "string") {
self.style = style;
} else if (!_b_.isinstance(style, _b_.dict)) {
throw _b_.TypeError.$factory(
"style must be str or dict, not " + $B.class_name(style)
);
}
var items = _b_.list.$factory(_b_.dict.items(style));
for (var i = 0; i < items.length; i++) {
var key = items[i][0],
value = items[i][1];
if (key.toLowerCase() == "float") {
self.style.cssFloat = value;
self.style.styleFloat = value;
} else {
switch (key) {
case "top":
case "left":
case "width":
case "height":
case "borderWidth":
if (_b_.isinstance(value, _b_.int)) {
value = value + "px";
}
}
self.style[key] = value;
}
}
};
DOMNode.set_text = function (self, value) {
if (self.nodeType == 9) {
self = self.body;
}
self.innerText = _b_.str.$factory(value);
self.textContent = _b_.str.$factory(value);
};
DOMNode.set_value = function (self, value) {
self.value = _b_.str.$factory(value);
};
DOMNode.submit = function (self) {
return function () {
self.submit();
};
};
DOMNode.text = function (self) {
if (self.nodeType == 9) {
self = self.body;
}
var res = self.innerText || self.textContent;
if (res === null) {
res = _b_.None;
}
return res;
};
DOMNode.toString = function (self) {
if (self === undefined) {
return "DOMNode";
}
return self.nodeName;
};
DOMNode.trigger = function (self, etype) {
if (self.fireEvent) {
self.fireEvent("on" + etype);
} else {
var evObj = document.createEvent("Events");
evObj.initEvent(etype, true, false);
self.dispatchEvent(evObj);
}
};
DOMNode.unbind = function (self, event) {
self.$events = self.$events || {};
if (self.$events === {}) {
return _b_.None;
}
if (event === undefined) {
for (var event in self.$events) {
DOMNode.unbind(self, event);
}
return _b_.None;
}
if (self.$events[event] === undefined || self.$events[event].length == 0) {
return _b_.None;
}
var events = self.$events[event];
if (arguments.length == 2) {
for (var i = 0; i < events.length; i++) {
var callback = events[i][1];
self.removeEventListener(event, callback, false);
}
self.$events[event] = [];
return _b_.None;
}
for (var i = 2; i < arguments.length; i++) {
var callback = arguments[i],
flag = false,
func = callback.$func;
if (func === undefined) {
var found = false;
for (var j = 0; j < events.length; j++) {
if (events[j][0] === callback) {
var func = callback,
found = true;
break;
}
}
if (!found) {
throw _b_.TypeError.$factory("function is not an event callback");
}
}
for (var j = 0; j < events.length; j++) {
if ($B.$getattr(func, "__eq__")(events[j][0])) {
var callback = events[j][1];
self.removeEventListener(event, callback, false);
events.splice(j, 1);
flag = true;
break;
}
}
if (!flag) {
throw _b_.KeyError.$factory("missing callback for event " + event);
}
}
};
$B.set_func_names(DOMNode, "browser");
var Query = {
__class__: _b_.type,
__mro__: [_b_.object],
$infos: { __name__: "query" },
};
Query.__contains__ = function (self, key) {
return self._keys.indexOf(key) > -1;
};
Query.__getitem__ = function (self, key) {
var result = self._values[key];
if (result === undefined) {
throw _b_.KeyError.$factory(key);
} else if (result.length == 1) {
return result[0];
}
return result;
};
var Query_iterator = $B.make_iterator_class("query string iterator");
Query.__iter__ = function (self) {
return Query_iterator.$factory(self._keys);
};
Query.__setitem__ = function (self, key, value) {
self._values[key] = [value];
return _b_.None;
};
Query.__str__ = Query.__repr__ = function (self) {
var elts = [];
for (var key in self._values) {
for (const val of self._values[key]) {
elts.push(encodeURIComponent(key) + "=" + encodeURIComponent(val));
}
}
if (elts.length == 0) {
return "";
} else {
return "?" + elts.join("&");
}
};
Query.getfirst = function (self, key, _default) {
var result = self._values[key];
if (result === undefined) {
if (_default === undefined) {
return _b_.None;
}
return _default;
}
return result[0];
};
Query.getlist = function (self, key) {
var result = self._values[key];
if (result === undefined) {
return [];
}
return result;
};
Query.getvalue = function (self, key, _default) {
try {
return Query.__getitem__(self, key);
} catch (err) {
if (_default === undefined) {
return _b_.None;
}
return _default;
}
};
Query.keys = function (self) {
return self._keys;
};
$B.set_func_names(Query, "<dom>");
var TagSum = {
__class__: _b_.type,
__mro__: [object],
$infos: { __module__: "<pydom>", __name__: "TagSum" },
};
TagSum.appendChild = function (self, child) {
self.children.push(child);
};
TagSum.__add__ = function (self, other) {
if ($B.get_class(other) === TagSum) {
self.children = self.children.concat(other.children);
} else if (
_b_.isinstance(other, [
_b_.str,
_b_.int,
_b_.float,
_b_.dict,
_b_.set,
_b_.list,
])
) {
self.children = self.children.concat(
DOMNode.$factory(document.createTextNode(other))
);
} else {
self.children.push(other);
}
return self;
};
TagSum.__radd__ = function (self, other) {
var res = TagSum.$factory();
res.children = self.children.concat(
DOMNode.$factory(document.createTextNode(other))
);
return res;
};
TagSum.__repr__ = function (self) {
var res = "<object TagSum> ";
for (var i = 0; i < self.children.length; i++) {
res += self.children[i];
if (self.children[i].toString() == "[object Text]") {
res += " [" + self.children[i].textContent + "]\n";
}
}
return res;
};
TagSum.__str__ = TagSum.toString = TagSum.__repr__;
TagSum.clone = function (self) {
var res = TagSum.$factory();
for (var i = 0; i < self.children.length; i++) {
res.children.push(self.children[i].cloneNode(true));
}
return res;
};
TagSum.$factory = function () {
return {
__class__: TagSum,
children: [],
toString: function () {
return "(TagSum)";
},
};
};
$B.set_func_names(TagSum, "<dom>");
$B.TagSum = TagSum;
var win = $B.JSObj.$factory(_window);
win.get_postMessage = function (msg, targetOrigin) {
if (_b_.isinstance(msg, dict)) {
var temp = { __class__: "dict" },
items = _b_.list.$factory(_b_.dict.items(msg));
items.forEach(function (item) {
temp[item[0]] = item[1];
});
msg = temp;
}
return _window.postMessage(msg, targetOrigin);
};
$B.DOMNode = DOMNode;
$B.win = win;
})(__BRYTHON__);
$B.pattern_match = function (subject, pattern) {
var _b_ = $B.builtins,
frame = $B.last($B.frames_stack),
locals = frame[1];
function bind(pattern, subject) {
if (pattern.alias) {
locals[pattern.alias] = subject;
}
}
if (pattern.sequence) {
if (_b_.isinstance(subject, [_b_.str, _b_.bytes, _b_.bytearray])) {
return false;
}
var Sequence;
if ($B.imported["collections.abc"]) {
Sequence = $B.imported["collections.abc"].Sequence;
}
var deque;
if ($B.imported["collections"]) {
deque = $B.imported["collections"].deque;
}
var supported = false;
var klass = subject.__class__ || $B.get_class(subject);
for (var base of [klass].concat(klass.__bases__ || [])) {
if (base.$match_sequence_pattern) {
supported = true;
break;
} else if (base === Sequence || base == deque) {
supported = true;
break;
}
}
if (!supported && Sequence) {
supported = _b_.issubclass(klass, Sequence);
}
if (!supported) {
return false;
}
if (
pattern.sequence.length == 1 &&
pattern.sequence[0].capture_starred == "_"
) {
return true;
}
var subject_length = _b_.len(subject);
var nb_fixed_length = 0;
for (var item of pattern.sequence) {
if (!item.capture_starred) {
nb_fixed_length++;
}
}
if (subject_length < nb_fixed_length) {
return false;
} else if (subject_length == 0 && pattern.sequence.length == 0) {
return true;
}
var it = _b_.iter(subject),
nxt = $B.$getattr(it, "__next__"),
store_starred = [],
nb_matched_in_subject = 0;
for (var i = 0, len = pattern.sequence.length; i < len; i++) {
if (pattern.sequence[i].capture_starred) {
if (pattern.sequence[i].capture_starred == "_" && i == len - 1) {
bind(pattern, subject);
return true;
}
var starred_match_length =
subject_length - nb_matched_in_subject - len + i + 1;
for (var j = 0; j < starred_match_length; j++) {
store_starred.push(nxt());
}
locals[pattern.sequence[i].capture_starred] = store_starred;
nb_matched_in_subject += starred_match_length;
} else {
var subject_item = nxt();
var m = $B.pattern_match(subject_item, pattern.sequence[i]);
if (!m) {
return false;
}
nb_matched_in_subject++;
}
}
if (nb_matched_in_subject != subject_length) {
return false;
}
bind(pattern, subject);
return true;
}
if (pattern.group) {
if (pattern.group.length == 1) {
if ($B.pattern_match(subject, pattern.group[0])) {
bind(pattern, subject);
return true;
}
} else {
pattern.sequence = pattern.group;
return $B.pattern_match(subject, pattern);
}
}
if (pattern.or) {
for (var item of pattern.or) {
if ($B.pattern_match(subject, item)) {
bind(pattern, subject);
return true;
}
}
return false;
}
if (pattern.mapping) {
var supported = false;
var Mapping;
if ($B.imported["collections.abc"]) {
Mapping = $B.imported["collections.abc"].Mapping;
}
var klass = subject.__class__ || $B.get_class(subject);
for (var base of [klass].concat(klass.__bases__ || [])) {
if (base.$match_mapping_pattern || base === Mapping) {
supported = true;
break;
}
}
if (!supported && Mapping) {
supported = _b_.issubclass(klass, Mapping);
}
if (!supported) {
return false;
}
var matched = [],
keys = [];
for (var item of pattern.mapping) {
var key_pattern = item[0],
value_pattern = item[1];
if (key_pattern.hasOwnProperty("literal")) {
var key = key_pattern.literal;
} else if (key_pattern.hasOwnProperty("value")) {
var key = key_pattern.value;
}
if (_b_.list.__contains__(keys, key)) {
throw _b_.ValueError.$factory(
"mapping pattern checks " +
"duplicate key (" +
_b_.str.$factory(key) +
")"
);
}
keys.push(key);
var missing = $B.make_class("missing", function () {
return {
__class__: missing,
};
});
try {
var v = $B.$call($B.$getattr(subject, "get"))(key, missing);
if (v === missing) {
return false;
}
if (!$B.pattern_match(v, value_pattern)) {
return false;
}
matched.push(key);
} catch (err) {
if ($B.is_exc(err, [_b_.KeyError])) {
return false;
}
throw err;
}
}
if (pattern.rest) {
var rest = $B.empty_dict(),
it = _b_.iter(subject);
while (true) {
try {
var next_key = _b_.next(it);
} catch (err) {
if ($B.is_exc(err, [_b_.StopIteration])) {
locals[pattern.rest] = rest;
return true;
}
throw err;
}
if (!_b_.list.__contains__(matched, next_key)) {
_b_.dict.__setitem__(rest, next_key, $B.$getitem(subject, next_key));
}
}
}
return true;
}
if (pattern.class) {
var klass = pattern.class;
if (!_b_.isinstance(klass, _b_.type)) {
throw _b_.TypeError.$factory("called match pattern must be a type");
}
if (!_b_.isinstance(subject, klass)) {
return false;
}
if (pattern.args.length > 0) {
if (
[
_b_.bool,
_b_.bytearray,
_b_.bytes,
_b_.dict,
_b_.float,
_b_.frozenset,
_b_.int,
_b_.list,
_b_.set,
_b_.str,
_b_.tuple,
].indexOf(klass) > -1
) {
if (pattern.args.length > 1) {
throw _b_.TypeError.$factory(
"for builtin type " +
$B.class_name(subject) +
", a single positional " +
"subpattern is accepted"
);
}
return $B.pattern_match(subject, pattern.args[0]);
} else {
var match_args = $B.$getattr(
klass,
"__match_args__",
$B.fast_tuple([])
);
if (!_b_.isinstance(match_args, _b_.tuple)) {
throw _b_.TypeError.$factory(
"__match_args__() did not return a tuple"
);
}
if (pattern.args.length > match_args.length) {
throw _b_.TypeError.$factory(
"__match_args__() returns " +
match_args.length +
" names but " +
pattern.args.length +
" positional " +
"arguments were passed"
);
}
for (var i = 0, len = pattern.args.length; i < len; i++) {
var pattern_arg = pattern.args[i],
klass_arg = match_args[i];
if (typeof klass_arg !== "string") {
throw _b_.TypeError.$factory(
"item in __match_args__ " + "is not a string: " + klass_arg
);
}
if (pattern.keywords.hasOwnProperty(klass_arg)) {
throw _b_.TypeError.$factory(
"__match_arg__ item " +
klass_arg +
" was passed as keyword pattern"
);
}
pattern.keywords[klass_arg] = pattern_arg;
}
}
}
for (var key in pattern.keywords) {
var v = $B.$getattr(subject, key, null);
if (v === null) {
return false;
} else if (!$B.pattern_match(v, pattern.keywords[key])) {
return false;
}
}
bind(pattern, subject);
return true;
}
if (pattern.capture) {
if (pattern.capture != "_") {
locals[pattern.capture] = subject;
}
bind(pattern, subject);
return true;
} else if (pattern.capture_starred) {
locals[pattern.capture_starred] = $B.$list(subject);
return true;
} else if (pattern.hasOwnProperty("literal")) {
var literal = pattern.literal;
if (literal === _b_.None || literal === _b_.True || literal === _b_.False) {
return $B.$is(subject, literal);
}
if ($B.rich_comp("__eq__", subject, literal)) {
bind(pattern, subject);
return true;
}
return false;
} else if (pattern.hasOwnProperty("value")) {
if ($B.rich_comp("__eq__", subject, pattern.value)) {
bind(pattern, subject);
return true;
}
} else if (subject == pattern) {
return true;
}
return false;
};
(function ($B) {
var _b_ = $B.builtins;
var update = ($B.update_obj = function (mod, data) {
for (attr in data) {
mod[attr] = data[attr];
}
});
var _window = self;
var modules = {};
var browser = {
$package: true,
$is_package: true,
__initialized__: true,
__package__: "browser",
__file__: $B.brython_path.replace(/\/*$/g, "") + "/Lib/browser/__init__.py",
bind: function () {
var $ = $B.args(
"bind",
3,
{ elt: null, evt: null, options: null },
["elt", "evt", "options"],
arguments,
{ options: _b_.None },
null,
null
);
var options = $.options;
if (typeof options == "boolean") {
} else if (options.__class__ === _b_.dict) {
options = options.$string_dict;
} else {
options == false;
}
return function (callback) {
if ($B.get_class($.elt) === $B.JSObj) {
function f(ev) {
try {
return callback($B.JSObj.$factory(ev));
} catch (err) {
$B.handle_error(err);
}
}
$.elt.addEventListener($.evt, f, options);
return callback;
} else if (_b_.isinstance($.elt, $B.DOMNode)) {
$B.DOMNode.bind($.elt, $.evt, callback, options);
return callback;
} else if (_b_.isinstance($.elt, _b_.str)) {
var items = document.querySelectorAll($.elt);
for (var i = 0; i < items.length; i++) {
$B.DOMNode.bind(
$B.DOMNode.$factory(items[i]),
$.evt,
callback,
options
);
}
return callback;
}
try {
var it = $B.$iter($.elt);
while (true) {
try {
var elt = _b_.next(it);
$B.DOMNode.bind(elt, $.evt, callback);
} catch (err) {
if (_b_.isinstance(err, _b_.StopIteration)) {
break;
}
throw err;
}
}
} catch (err) {
if (_b_.isinstance(err, _b_.AttributeError)) {
$B.DOMNode.bind($.elt, $.evt, callback);
}
throw err;
}
return callback;
};
},
console: self.console && $B.JSObj.$factory(self.console),
self: $B.win,
win: $B.win,
window: $B.win,
};
browser.__path__ = browser.__file__;
if ($B.isNode) {
delete browser.window;
delete browser.win;
} else if ($B.isWebWorker) {
browser.is_webworker = true;
delete browser.window;
delete browser.win;
browser.self.send = self.postMessage;
} else {
browser.is_webworker = false;
update(browser, {
alert: function (message) {
window.alert($B.builtins.str.$factory(message || ""));
},
confirm: $B.JSObj.$factory(window.confirm),
document: $B.DOMNode.$factory(document),
doc: $B.DOMNode.$factory(document),
DOMEvent: $B.DOMEvent,
DOMNode: $B.DOMNode,
load: function (script_url) {
var file_obj = $B.builtins.open(script_url);
var content = $B.$getattr(file_obj, "read")();
eval(content);
},
mouseCoords: function (ev) {
return $B.JSObj.$factory($mouseCoords(ev));
},
prompt: function (message, default_value) {
return $B.JSObj.$factory(window.prompt(message, default_value || ""));
},
reload: function () {
var scripts = document.getElementsByTagName("script"),
js_scripts = [];
scripts.forEach(function (script) {
if (script.type === undefined || script.type == "text/javascript") {
js_scripts.push(script);
if (script.src) {
console.log(script.src);
}
}
});
console.log(js_scripts);
for (var mod in $B.imported) {
if ($B.imported[mod].$last_modified) {
console.log(
"check",
mod,
$B.imported[mod].__file__,
$B.imported[mod].$last_modified
);
} else {
console.log("no date for mod", mod);
}
}
},
run_script: function () {
var $ = $B.args(
"run_script",
2,
{ src: null, name: null },
["src", "name"],
arguments,
{ name: "script_" + $B.UUID() },
null,
null
);
$B.run_script($.src, $.name, $B.script_path, true);
},
URLParameter: function (name) {
name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
var regex = new RegExp("[\\?&]" + name + "=([^&#]*)"),
results = regex.exec(location.search);
results =
results === null
? ""
: decodeURIComponent(results[1].replace(/\+/g, " "));
return $B.builtins.str.$factory(results);
},
});
modules["browser.html"] = (function ($B) {
var _b_ = $B.builtins;
var TagSum = $B.TagSum;
function makeTagDict(tagName) {
var dict = {
__class__: _b_.type,
$infos: {
__name__: tagName,
__module__: "browser.html",
__qualname__: tagName,
},
};
dict.__init__ = function () {
var $ns = $B.args(
"pow",
1,
{ self: null },
["self"],
arguments,
{},
"args",
"kw"
),
self = $ns["self"],
args = $ns["args"];
if (args.length == 1) {
var first = args[0];
if (_b_.isinstance(first, [_b_.str, _b_.int, _b_.float])) {
self.innerHTML = _b_.str.$factory(first);
} else if (first.__class__ === TagSum) {
for (var i = 0, len = first.children.length; i < len; i++) {
self.appendChild(first.children[i]);
}
} else {
if (_b_.isinstance(first, $B.DOMNode)) {
self.appendChild(first);
} else {
try {
var items = _b_.list.$factory(first);
items.forEach(function (item) {
$B.DOMNode.__le__(self, item);
});
} catch (err) {
if ($B.debug > 1) {
console.log(err, err.__class__, err.args);
console.log("first", first);
console.log(arguments);
}
throw err;
}
}
}
}
var items = _b_.list.$factory(_b_.dict.items($ns["kw"]));
for (var i = 0, len = items.length; i < len; i++) {
var arg = items[i][0],
value = items[i][1];
if (arg.toLowerCase().substr(0, 2) == "on") {
var js = '$B.DOMNode.bind(self,"' + arg.toLowerCase().substr(2);
eval(js + '",function(){' + value + "})");
} else if (arg.toLowerCase() == "style") {
$B.DOMNode.set_style(self, value);
} else {
if (value !== false) {
try {
arg = $B.imported["browser.html"].attribute_mapper(arg);
self.setAttribute(arg, value);
} catch (err) {
throw _b_.ValueError.$factory("can't set attribute " + arg);
}
}
}
}
};
dict.__mro__ = [$B.DOMNode, $B.builtins.object];
dict.__new__ = function (cls) {
var res = document.createElement(tagName);
if (cls !== html[tagName]) {
res.__class__ = cls;
}
return res;
};
$B.set_func_names(dict, "browser.html");
return dict;
}
function makeFactory(klass) {
var factory = function () {
if (klass.$infos.__name__ == "SVG") {
var res = $B.DOMNode.$factory(
document.createElementNS("http://www.w3.org/2000/svg", "svg"),
true
);
} else {
var res = document.createElement(klass.$infos.__name__);
}
var init = $B.$getattr(klass, "__init__", null);
if (init !== null) {
init(res, ...arguments);
}
return res;
};
return factory;
}
var tags = [
"A",
"ABBR",
"ACRONYM",
"ADDRESS",
"APPLET",
"AREA",
"B",
"BASE",
"BASEFONT",
"BDO",
"BIG",
"BLOCKQUOTE",
"BODY",
"BR",
"BUTTON",
"CAPTION",
"CENTER",
"CITE",
"CODE",
"COL",
"COLGROUP",
"DD",
"DEL",
"DFN",
"DIR",
"DIV",
"DL",
"DT",
"EM",
"FIELDSET",
"FONT",
"FORM",
"FRAME",
"FRAMESET",
"H1",
"H2",
"H3",
"H4",
"H5",
"H6",
"HEAD",
"HR",
"HTML",
"I",
"IFRAME",
"IMG",
"INPUT",
"INS",
"ISINDEX",
"KBD",
"LABEL",
"LEGEND",
"LI",
"LINK",
"MAP",
"MENU",
"META",
"NOFRAMES",
"NOSCRIPT",
"OBJECT",
"OL",
"OPTGROUP",
"OPTION",
"P",
"PARAM",
"PRE",
"Q",
"S",
"SAMP",
"SCRIPT",
"SELECT",
"SMALL",
"SPAN",
"STRIKE",
"STRONG",
"STYLE",
"SUB",
"SUP",
"SVG",
"TABLE",
"TBODY",
"TD",
"TEXTAREA",
"TFOOT",
"TH",
"THEAD",
"TITLE",
"TR",
"TT",
"U",
"UL",
"VAR",
"ARTICLE",
"ASIDE",
"AUDIO",
"BDI",
"CANVAS",
"COMMAND",
"DATA",
"DATALIST",
"EMBED",
"FIGCAPTION",
"FIGURE",
"FOOTER",
"HEADER",
"KEYGEN",
"MAIN",
"MARK",
"MATH",
"METER",
"NAV",
"OUTPUT",
"PROGRESS",
"RB",
"RP",
"RT",
"RTC",
"RUBY",
"SECTION",
"SOURCE",
"TEMPLATE",
"TIME",
"TRACK",
"VIDEO",
"WBR",
"DETAILS",
"DIALOG",
"MENUITEM",
"PICTURE",
"SUMMARY",
];
var html = {};
html.tags = $B.jsobj_as_pydict.$factory(html, function (attr) {
return tags.indexOf(attr) == -1;
});
function maketag(tagName) {
if (!(typeof tagName == "string")) {
throw _b_.TypeError.$factory(
"html.maketag expects a string as argument"
);
}
if (html[tagName] !== undefined) {
throw _b_.ValueError.$factory("cannot reset class for " + tagName);
}
var klass = makeTagDict(tagName);
klass.$factory = makeFactory(klass);
html[tagName] = klass;
return klass;
}
for (var tagName of tags) {
maketag(tagName);
}
html.maketag = maketag;
html.attribute_mapper = function (attr) {
return attr.replace(/_/g, "-");
};
return html;
})(__BRYTHON__);
}
modules["browser"] = browser;
$B.UndefinedClass = $B.make_class("Undefined", function () {
return $B.Undefined;
});
$B.UndefinedClass.__mro__ = [_b_.object];
$B.UndefinedClass.__bool__ = function (self) {
return false;
};
$B.UndefinedClass.__repr__ = $B.UndefinedClass.__str__ = function (self) {
return "<Javascript undefined>";
};
$B.Undefined = { __class__: $B.UndefinedClass };
$B.set_func_names($B.UndefinedClass, "javascript");
var super_class = $B.make_class("JavascriptSuper", function () {
var b_super = _b_.super.$factory(),
b_self = b_super.__self_class__,
proto = Object.getPrototypeOf(b_self),
parent = proto.constructor.$parent;
var factory = function () {
var p = parent.bind(b_self),
res;
if (parent.toString().startsWith("class")) {
res = new p(...arguments);
} else {
res = p(...arguments);
}
for (key in res) {
b_self[key] = res[key];
}
return res;
};
return {
__class__: super_class,
__init__: factory,
__self_class__: b_self,
};
});
super_class.__getattribute__ = function (self, attr) {
if (attr == "__init__" || attr == "__call__") {
return self.__init__;
}
return $B.$getattr(self.__self_class__, attr);
};
$B.set_func_names(super_class, "javascript");
modules["javascript"] = {
this: function () {
if ($B.js_this === undefined) {
return $B.builtins.None;
}
return $B.JSObj.$factory($B.js_this);
},
Date: self.Date && $B.JSObj.$factory(self.Date),
extends: function (js_constr) {
return function (obj) {
if (obj.$is_class) {
var factory = function () {
var init = $B.$getattr(obj, "__init__", _b_.None);
if (init !== _b_.None) {
init.bind(this, this).apply(this, arguments);
}
return this;
};
factory.prototype = Object.create(js_constr.prototype);
factory.prototype.constructor = factory;
factory.$parent = js_constr.$js_func;
factory.$is_class = true;
factory.$infos = obj.$infos;
for (var key in obj) {
if (typeof obj[key] == "function") {
factory.prototype[key] = (function (x) {
return function () {
return obj[x].bind(this, this).apply(this, arguments);
};
})(key);
}
}
return factory;
}
};
},
JSON: {
__class__: $B.make_class("JSON"),
parse: function () {
return $B.structuredclone2pyobj(JSON.parse.apply(this, arguments));
},
stringify: function (obj, replacer, space) {
return JSON.stringify(
$B.pyobj2structuredclone(obj, false),
$B.JSObj.$factory(replacer),
space
);
},
},
jsobj2pyobj: function (obj) {
return $B.jsobj2pyobj(obj);
},
load: function (script_url) {
console.log(
'"javascript.load" is deprecrated. ' + "Use browser.load instead."
);
var file_obj = $B.builtins.open(script_url);
var content = $B.$getattr(file_obj, "read")();
eval(content);
},
Math: self.Math && $B.JSObj.$factory(self.Math),
NULL: null,
Number: self.Number && $B.JSObj.$factory(self.Number),
py2js: function (src, module_name) {
if (module_name === undefined) {
module_name = "__main__" + $B.UUID();
}
var js = $B
.py2js(src, module_name, module_name, $B.builtins_scope)
.to_js();
return $B.format_indent(js, 0);
},
pyobj2jsobj: function (obj) {
return $B.pyobj2jsobj(obj);
},
RegExp: self.RegExp && $B.JSObj.$factory(self.RegExp),
String: self.String && $B.JSObj.$factory(self.String),
super: super_class,
UNDEFINED: $B.Undefined,
UndefinedType: $B.UndefinedClass,
};
var arraybuffers = [
"Int8Array",
"Uint8Array",
"Uint8ClampedArray",
"Int16Array",
"Uint16Array",
"Int32Array",
"Uint32Array",
"Float32Array",
"Float64Array",
"BigInt64Array",
"BigUint64Array",
];
arraybuffers.forEach(function (ab) {
if (self[ab] !== undefined) {
modules["javascript"][ab] = $B.JSObj.$factory(self[ab]);
}
});
var _b_ = $B.builtins;
modules["_sys"] = {
Getframe: function () {
var $ = $B.args(
"_getframe",
1,
{ depth: null },
["depth"],
arguments,
{ depth: 0 },
null,
null
),
depth = $.depth;
return $B._frame.$factory(
$B.frames_stack,
$B.frames_stack.length - depth - 1
);
},
breakpointhook: function () {
var hookname = $B.$options.breakpoint,
modname,
dot,
funcname,
hook;
if (hookname === undefined) {
hookname = "pdb.set_trace";
}
[modname, dot, funcname] = _b_.str.rpartition(hookname, ".");
if (dot == "") {
modname = "builtins";
}
try {
$B.$import(modname);
hook = $B.$getattr($B.imported[modname], funcname);
} catch (err) {
console.warn("cannot import breakpoint", hookname);
return _b_.None;
}
return $B.$call(hook).apply(null, arguments);
},
exc_info: function () {
for (var i = $B.frames_stack.length - 1; i >= 0; i--) {
var frame = $B.frames_stack[i],
exc = frame[1].$current_exception;
if (exc) {
return _b_.tuple.$factory([
exc.__class__,
exc,
$B.$getattr(exc, "__traceback__"),
]);
}
}
return _b_.tuple.$factory([_b_.None, _b_.None, _b_.None]);
},
excepthook: function (exc_class, exc_value, traceback) {
$B.handle_error(exc_value);
},
gettrace: function () {
return $B.tracefunc || _b_.None;
},
max_string_length: $B.max_string_length,
modules: _b_.property.$factory(
function () {
return $B.obj_dict($B.imported);
},
function (self, value) {
throw _b_.TypeError.$factory("Read only property 'sys.modules'");
}
),
path: _b_.property.$factory(
function () {
return $B.path;
},
function (self, value) {
$B.path = value;
}
),
meta_path: _b_.property.$factory(
function () {
return $B.meta_path;
},
function (self, value) {
$B.meta_path = value;
}
),
path_hooks: _b_.property.$factory(
function () {
return $B.path_hooks;
},
function (self, value) {
$B.path_hooks = value;
}
),
path_importer_cache: _b_.property.$factory(
function () {
return _b_.dict.$factory($B.JSObj.$factory($B.path_importer_cache));
},
function (self, value) {
throw _b_.TypeError.$factory(
"Read only property" + " 'sys.path_importer_cache'"
);
}
),
settrace: function () {
var $ = $B.args(
"settrace",
1,
{ tracefunc: null },
["tracefunc"],
arguments,
{},
null,
null
);
$B.tracefunc = $.tracefunc;
$B.last($B.frames_stack)[1].$f_trace = $B.tracefunc;
$B.tracefunc.$current_frame_id = $B.last($B.frames_stack)[0];
return _b_.None;
},
stderr: _b_.property.$factory(
function () {
return $B.stderr;
},
function (self, value) {
$B.stderr = value;
}
),
stdout: _b_.property.$factory(
function () {
return $B.stdout;
},
function (self, value) {
$B.stdout = value;
}
),
stdin: _b_.property.$factory(
function () {
return $B.stdin;
},
function (self, value) {
$B.stdin = value;
}
),
vfs: _b_.property.$factory(
function () {
if ($B.hasOwnProperty("VFS")) {
return $B.obj_dict($B.VFS);
} else {
return _b_.None;
}
},
function () {
throw _b_.TypeError.$factory("Read only property 'sys.vfs'");
}
),
};
modules._sys.__breakpointhook__ = modules._sys.breakpointhook;
var WarningMessage = $B.make_class("WarningMessage", function () {
var $ = $B.make_args(
"WarningMessage",
8,
{
message: null,
category: null,
filename: null,
lineno: null,
file: null,
line: null,
source: null,
},
["message", "category", "filename", "lineno", "file", "line", "source"],
arguments,
{ file: _b_.None, line: _b_.None, source: _b_.None },
null,
null
);
return {
__class__: WarningMessage,
message: $.message,
category: $.category,
filename: $.filename,
lineno: $.lineno,
file: $.file,
line: $.line,
source: $.source,
_category_name: _b_.bool.$factory($.category)
? $B.$getattr($.category, "__name__")
: _b_.None,
};
});
modules._warnings = {
_defaultaction: "default",
_filters_mutated: function () {},
_onceregistry: $B.empty_dict(),
filters: [
$B.fast_tuple([
"default",
_b_.None,
_b_.DeprecationWarning,
"__main__",
0,
]),
$B.fast_tuple(["ignore", _b_.None, _b_.DeprecationWarning, _b_.None, 0]),
$B.fast_tuple([
"ignore",
_b_.None,
_b_.PendingDeprecationWarning,
_b_.None,
0,
]),
$B.fast_tuple(["ignore", _b_.None, _b_.ImportWarning, _b_.None, 0]),
$B.fast_tuple(["ignore", _b_.None, _b_.ResourceWarning, _b_.None, 0]),
],
warn: function (message) {
var filters;
if ($B.imported.warnings) {
filters = $B.imported.warnings.filters;
} else {
filters = modules._warnings.filters;
}
if (filters[0][0] == "error") {
var syntax_error = _b_.SyntaxError.$factory(message.args[0]);
syntax_error.args[1] = [
message.filename,
message.lineno,
message.offset,
message.line,
];
syntax_error.filename = message.filename;
syntax_error.lineno = message.lineno;
syntax_error.offset = message.offset;
syntax_error.line = message.line;
throw syntax_error;
}
var frame = $B.imported._sys.Getframe(),
category = message.__class__ || $B.get_class(message),
warning_message = {
__class__: WarningMessage,
message: message,
category,
filename: message.filename || frame.f_code.co_filename,
lineno: message.lineno || frame.f_lineno,
file: _b_.None,
line: _b_.None,
source: _b_.None,
_category_name: category.__name__,
};
if ($B.imported.warnings) {
$B.imported.warnings._showwarnmsg_impl(warning_message);
} else {
var trace = $B.class_name(message) + ": " + message.args[0];
$B.$getattr($B.stderr, "write")(trace + "\n");
var flush = $B.$getattr($B.stderr, "flush", _b_.None);
if (flush !== _b_.None) {
flush();
}
}
},
warn_explicit: function () {
console.log("warn_explicit", arguments);
},
};
function load(name, module_obj) {
module_obj.__class__ = $B.module;
module_obj.__name__ = name;
$B.imported[name] = module_obj;
for (var attr in module_obj) {
if (typeof module_obj[attr] == "function") {
module_obj[attr].$infos = {
__module__: name,
__name__: attr,
__qualname__: name + "." + attr,
};
}
}
}
for (var attr in modules) {
load(attr, modules[attr]);
}
if (!($B.isWebWorker || $B.isNode)) {
modules["browser"].html = modules["browser.html"];
}
var _b_ = $B.builtins;
_b_.__builtins__ = $B.module.$factory("__builtins__", "Python builtins");
for (var attr in _b_) {
_b_.__builtins__[attr] = _b_[attr];
$B.builtins_scope.binding[attr] = true;
if (_b_[attr].$is_class) {
if (_b_[attr].__bases__) {
_b_[attr].__bases__.__class__ = _b_.tuple;
} else {
_b_[attr].__bases__ = $B.fast_tuple([_b_.object]);
}
}
}
_b_.__builtins__.__setattr__ = function (attr, value) {
_b_[attr] = value;
};
$B.method_descriptor.__getattribute__ = $B.Function.__getattribute__;
$B.wrapper_descriptor.__getattribute__ = $B.Function.__getattribute__;
for (var name in _b_) {
if (_b_[name].__class__ === _b_.type) {
$B.builtin_classes.push(_b_[name]);
for (var key in _b_[name]) {
var value = _b_[name][key];
if (value === undefined) {
continue;
} else if (value.__class__) {
continue;
} else if (typeof value != "function") {
continue;
} else if (key == "__new__") {
value.__class__ = $B.builtin_function;
} else if (key.startsWith("__")) {
value.__class__ = $B.wrapper_descriptor;
} else {
value.__class__ = $B.method_descriptor;
}
value.__objclass__ = _b_[name];
}
}
}
for (var attr in $B) {
if (Array.isArray($B[attr])) {
$B[attr].__class__ = _b_.list;
}
}
$B.cell = $B.make_class("cell", function (value) {
return {
__class__: $B.cell,
$cell_contents: value,
};
});
$B.cell.cell_contents = $B.$call(_b_.property)(
function (self) {
if (self.$cell_contents === null) {
throw _b_.ValueError.$factory("empty cell");
}
return self.$cell_contents;
},
function (self, value) {
self.$cell_contents = value;
}
);
var $comps = Object.values($B.$comps).concat(["eq", "ne"]);
$comps.forEach(function (comp) {
var op = "__" + comp + "__";
$B.cell[op] = (function (op) {
return function (self, other) {
if (!_b_.isinstance(other, $B.cell)) {
return _b_.NotImplemented;
}
if (self.$cell_contents === null) {
if (other.$cell_contents === null) {
return op == "__eq__";
} else {
return ["__ne__", "__lt__", "__le__"].indexOf(op) > -1;
}
} else if (other.$cell_contents === null) {
return ["__ne__", "__gt__", "__ge__"].indexOf(op) > -1;
}
return $B.rich_comp(op, self.$cell_contents, other.$cell_contents);
};
})(op);
});
$B.set_func_names($B.cell, "builtins");
$B.AST = {
__class__: _b_.type,
__getattr__: function (self, attr) {
var res = self.js_node[attr];
if (res === undefined) {
throw $B.attr_error(attr, self);
}
return $B.AST.$convert(res);
},
__mro__: [_b_.object],
$infos: { __qualname__: "AST", __name__: "AST" },
$is_class: true,
$convert: function (js_node) {
if (js_node === undefined) {
return _b_.None;
}
var constr = js_node.constructor;
if (constr && constr.$name) {
return $B.python_ast_classes[constr.$name].$factory(js_node);
} else if (Array.isArray(js_node)) {
return js_node.map($B.AST.$convert);
} else if (js_node.type) {
switch (js_node.type) {
case "int":
var res = parseInt(js_node.value[1], js_node.value[0]);
if (res < $B.min_int || res > $B.max_int) {
var res = $B.long_int.$factory(
js_node.value[1],
js_node.value[0]
);
if (js_node.sign == "-") {
res.pos = false;
}
return res;
}
return js_node.sign == "-" ? -res : res;
case "float":
return new Number(js_node.value);
case "imaginary":
return $B.make_complex(0, $B.AST.$convert(js_node.value));
case "ellipsis":
return _b_.Ellipsis;
case "str":
if (js_node.is_bytes) {
return _b_.bytes.$factory(js_node.value, "latin-1");
}
return js_node.value;
case "id":
if (["False", "None", "True"].indexOf(js_node.value) > -1) {
return _b_[js_node.value];
}
break;
}
} else if (["string", "number"].indexOf(typeof js_node) > -1) {
return js_node;
} else if (js_node.$name) {
return js_node.$name + "()";
} else if ([_b_.None, _b_.True, _b_.False].indexOf(js_node) > -1) {
return js_node;
} else if (js_node.__class__) {
return js_node;
} else {
console.log("cannot handle", js_node);
return js_node;
}
},
};
})(__BRYTHON__);
(function ($B) {
var _b_ = $B.builtins;
var coroutine = ($B.coroutine = $B.make_class("coroutine"));
coroutine.close = function (self) {};
coroutine.send = function (self) {
return self.$func.apply(null, self.$args);
};
coroutine.__repr__ = coroutine.__str__ = function (self) {
if (self.$func.$infos) {
return "<coroutine " + self.$func.$infos.__name__ + ">";
} else {
return "<coroutine object>";
}
};
$B.set_func_names(coroutine, "builtins");
$B.make_async = (func) => {
if (func.$is_genfunc) {
return func;
}
var f = function () {
var args = arguments,
stack = $B.deep_copy($B.frames_stack);
return {
__class__: coroutine,
$args: args,
$func: func,
$stack: stack,
};
};
f.$infos = func.$infos;
return f;
};
$B.promise = function (obj) {
if (obj.__class__ === coroutine) {
return coroutine.send(obj);
}
if (typeof obj == "function") {
return obj();
}
return obj;
};
})(__BRYTHON__);
Reference in New Issue View Git Blame Copy Permalink