flexx_tutorial_app.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial for flexx.app - connecting to the browser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[I 22:27:08 flexx.app] Asset store collected 2 new modules.\n"
     ]
    }
   ],
   "source": [
    "from flexx import flx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In normal operation, one uses `flx.launch()` to fire up a browser (or desktop app) to run the JavaScript in. This is followed by `flx.run()` (or `flx.start()` for servers) to enter Flexx' main loop.\n",
    "\n",
    "In the notebook, however, there already is a browser. To tell Flexx that we're in the notebook, use `flx.init_notebook()` at the start of your notebook. Since Flexx's event system is based on asyncio, we need to \"activate\" asyncio as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script id='flexx-core.js'>\n",
       "/* Bundle contents:\n",
       "- asset flexx-loader.js\n",
       "- asset bsdf.js\n",
       "- asset bb64.js\n",
       "- asset pscript-std.js\n",
       "- asset flexx.event.js\n",
       "- module flexx.app._clientcore\n",
       "- module flexx.app._component2\n",
       "*/\n",
       "\n",
       "\n",
       "/* ========================== flexx-loader.js ===========================*/\n",
       "\n",
       "/*Flexx module loader. Licensed by BSD-2-clause.*/\n",
       "\n",
       "(function(){\n",
       "\n",
       "if (typeof window === 'undefined' && typeof module == 'object') {\n",
       "    throw Error('flexx.app does not run on NodeJS!');\n",
       "}\n",
       "if (typeof flexx == 'undefined') {\n",
       "    window.flexx = {};\n",
       "}\n",
       "\n",
       "var modules = {};\n",
       "function define (name, deps, factory) {\n",
       "    if (arguments.length == 1) {\n",
       "        factory = name;\n",
       "        deps = [];\n",
       "        name = null;\n",
       "    }\n",
       "    if (arguments.length == 2) {\n",
       "        factory = deps;\n",
       "        deps = name;\n",
       "        name = null;\n",
       "    }\n",
       "    // Get dependencies - in current implementation, these must be loaded\n",
       "    var dep_vals = [];\n",
       "    for (var i=0; i<deps.length; i++) {\n",
       "        if (modules[deps[i]] === undefined) {\n",
       "            throw Error('Unknown dependency: ' + deps[i]);\n",
       "        }\n",
       "        dep_vals.push(modules[deps[i]]);\n",
       "    }\n",
       "    // Load the module and store it if is not anonymous\n",
       "    var mod = factory.apply(null, dep_vals);\n",
       "    if (name) {\n",
       "        modules[name] = mod;\n",
       "    }\n",
       "}\n",
       "define.amd = true;\n",
       "define.flexx = true;\n",
       "\n",
       "function require (name) {\n",
       "    if (name.startsWith('phosphor/')) {\n",
       "        if (window.jupyter && window.jupyter.lab && window.jupyter.lab.loader) {\n",
       "            var path = 'phosphor@*/' + name.slice(9);\n",
       "            if (!path.endsWith('.js')) { path = path + '.js'; }\n",
       "            return window.jupyter.lab.loader.require(path);\n",
       "        } else {\n",
       "            return window.require_phosphor(name);  // provided by our Phosphor-all\n",
       "        }\n",
       "    }\n",
       "    if (modules[name] === undefined) {\n",
       "        throw Error('Unknown module: ' + name);\n",
       "    }\n",
       "    return modules[name];\n",
       "}\n",
       "\n",
       "// Expose this\n",
       "window.flexx.define = define;\n",
       "window.flexx.require = require;\n",
       "window.flexx._modules = modules;\n",
       "\n",
       "})();\n",
       "\n",
       "\n",
       "/* ============================== bsdf.js ===============================*/\n",
       "\n",
       "flexx.define(\"bsdf\", [], (function () {\n",
       "\"use strict\";\n",
       "\n",
       "var VERSION;\n",
       "VERSION = [2, 1, 0];\n",
       "\n",
       "// http://github.com/msgpack/msgpack-javascript/blob/master/msgpack.js#L181-L192\n",
       "function utf8encode(mix) {\n",
       "    // Mix is assumed to be a string. returns an Array of ints.\n",
       "    var iz = mix.length;\n",
       "    var rv = [];\n",
       "    for (var i = 0; i < iz; ++i) {\n",
       "        var c = mix.charCodeAt(i);\n",
       "        if (c < 0x80) { // ASCII(0x00 ~ 0x7f)\n",
       "            rv.push(c & 0x7f);\n",
       "        } else if (c < 0x0800) {\n",
       "            rv.push(((c >>>  6) & 0x1f) | 0xc0, (c & 0x3f) | 0x80);\n",
       "        } else if (c < 0x10000) {\n",
       "            rv.push(((c >>> 12) & 0x0f) | 0xe0,\n",
       "                    ((c >>>  6) & 0x3f) | 0x80, (c & 0x3f) | 0x80);\n",
       "        }\n",
       "    }\n",
       "    return rv;\n",
       "}\n",
       "\n",
       "// http://github.com/msgpack/msgpack-javascript/blob/master/msgpack.js#L365-L375\n",
       "function utf8decode(buf) {\n",
       "    // The buf is assumed to be an Array or Uint8Array. Returns a string.\n",
       "    var iz = buf.length - 1;\n",
       "    var ary = [];\n",
       "    for (var i = -1; i < iz; ) {\n",
       "        var c = buf[++i]; // lead byte\n",
       "        ary.push(c < 0x80 ? c : // ASCII(0x00 ~ 0x7f)\n",
       "                 c < 0xe0 ? ((c & 0x1f) <<  6 | (buf[++i] & 0x3f)) :\n",
       "                            ((c & 0x0f) << 12 | (buf[++i] & 0x3f) << 6\n",
       "                                              | (buf[++i] & 0x3f)));\n",
       "    }\n",
       "    return String.fromCharCode.apply(null, ary);\n",
       "}\n",
       "\n",
       "\n",
       "// ================== API\n",
       "\n",
       "function bsdf_encode(d, extensions) {\n",
       "    var s = new BsdfSerializer(extensions);\n",
       "    return s.encode(d);\n",
       "}\n",
       "\n",
       "function bsdf_decode(buf, extensions) {\n",
       "    var s = new BsdfSerializer(extensions);\n",
       "    return s.decode(buf);\n",
       "}\n",
       "\n",
       "function BsdfSerializer(extensions) {\n",
       "    /* A placeholder for a BSDF serializer with associated extensions.\n",
       "     * Other formats also use it to associate options, but we don't have any.\n",
       "     */\n",
       "    this.extensions = [];\n",
       "    if (extensions === undefined) { extensions = standard_extensions; }\n",
       "    if (!Array.isArray(extensions)) { throw \"Extensions must be an array.\"; }\n",
       "    for (var i=0; i<extensions.length; i++) {\n",
       "        this.add_extension(extensions[i]);\n",
       "    }\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.add_extension = function (e) {\n",
       "    // We use an array also as a dict for quick lookup\n",
       "    if (this.extensions[e.name] !== undefined) {\n",
       "        // Overwrite existing\n",
       "        for (var i=0; i<this.extensions.length; i++) {\n",
       "            if (this.extensions[i].name == e.name) { this.extensions[i] = e; break; }\n",
       "        }\n",
       "    } else {\n",
       "        // Append\n",
       "        this.extensions.push(e);\n",
       "        this.extensions[e.name] = e;\n",
       "    }\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.remove_extension = function (e) {\n",
       "    delete this.extensions[e.name];\n",
       "    for (var i=0; i<this.extensions.length; i++) {\n",
       "        if (this.extensions[i].name == name) { this.extensions.splice(i, 1); break; }\n",
       "    }\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.encode = function (d) {\n",
       "    // Write head and version\n",
       "    var f = ByteBuilder();\n",
       "    f.push_char('B'); f.push_char('S'); f.push_char('D'); f.push_char('F');\n",
       "    f.push_uint8(VERSION[0]); f.push_uint8(VERSION[1]);\n",
       "    // Encode and return result\n",
       "    this.encode_object(f, d);\n",
       "    return f.get_result();\n",
       "};\n",
       "\n",
       "BsdfSerializer.prototype.decode = function (buf, extensions) {\n",
       "    // Read and check head\n",
       "    var f = BytesReader(buf);\n",
       "    var head = f.get_char() + f.get_char() + f.get_char() + f.get_char();\n",
       "    if (head != 'BSDF') {\n",
       "        throw \"This does not look like BSDF encoded data: \" + head;\n",
       "    }\n",
       "    // Read and check version\n",
       "    var major_version = f.get_uint8();\n",
       "    var minor_version = f.get_uint8();\n",
       "    if (major_version != VERSION[0]) {\n",
       "        throw ('Reading file with different major version ' + major_version + ' from the implementation ' + VERSION[0]);\n",
       "    } else if (minor_version > VERSION[1]){\n",
       "        console.warn('BSDF warning: reading file with higher minor version ' + minor_version + ' than the implementation ' + VERSION[1]);\n",
       "    }\n",
       "    // Decode\n",
       "    return this.decode_object(f);\n",
       "};\n",
       "\n",
       "\n",
       "//---- encoder\n",
       "\n",
       "function ByteBuilder() {\n",
       "    // We use an arraybuffer for efficiency, but we don't know its final size.\n",
       "    // Therefore we create a new one with increasing size when needed.\n",
       "    var buffers = [];\n",
       "    var min_buf_size = 1024;\n",
       "\n",
       "    var buf8 = new Uint8Array(min_buf_size);\n",
       "    var bufdv = new DataView(buf8.buffer);\n",
       "\n",
       "    var pos = 0;\n",
       "    var pos_offset = 0;\n",
       "    var pos_max = buf8.byteLength;  // max valid value of pos\n",
       "\n",
       "    // Create text encoder / decoder\n",
       "    var text_encode, text_decode;\n",
       "    if (typeof TextEncoder !== 'undefined') {\n",
       "        var x = new TextEncoder('utf-8');\n",
       "        text_encode = x.encode.bind(x);\n",
       "    } else {\n",
       "        // test this\n",
       "        text_encode = utf8encode;\n",
       "    }\n",
       "\n",
       "    function get_result() {\n",
       "        // Combine all sub buffers into one contiguous buffer\n",
       "        var total = new Uint8Array(pos_offset + pos);\n",
       "        var i = 0, j;\n",
       "        for (var index=0; index<buffers.length; index+=2) {\n",
       "            var sub = buffers[index];\n",
       "            var n = buffers[index + 1];\n",
       "            var offset = i;\n",
       "            for(j=0; j<n; j++, i++){ total[i] = sub[j]; }\n",
       "        }\n",
       "        for(j=0; j<pos; j++, i++){ total[i] = buf8[j]; }  // also current buffer\n",
       "        return total.buffer; // total is an exact fit on its buffer\n",
       "    }\n",
       "    function new_buffer(n) {\n",
       "        // Establish size\n",
       "        var new_size = Math.max(n + 64 , min_buf_size);\n",
       "        // Store current buffer\n",
       "        buffers.push(buf8);\n",
       "        buffers.push(pos);\n",
       "        // Create new\n",
       "        buf8 = new Uint8Array(new_size);\n",
       "        bufdv = new DataView(buf8.buffer);\n",
       "        // Set positions\n",
       "        pos_offset += pos;\n",
       "        pos_max = buf8.byteLength;\n",
       "        pos = 0;\n",
       "    }\n",
       "    function tell() {\n",
       "        return pos_offset + pos;\n",
       "    }\n",
       "    function push_bytes(s) {  // we use Uint8Array internally for this\n",
       "        var n = s.byteLength;\n",
       "        if (pos + n > pos_max) { new_buffer(n); }\n",
       "        for (var i=0; i<n; i++) { buf8[pos+i] = s[i]; }\n",
       "        pos += n;\n",
       "    }\n",
       "    function push_char(s) {\n",
       "        if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "        buf8[pos] = s.charCodeAt();\n",
       "        pos += 1;\n",
       "    }\n",
       "    function push_str(s) {\n",
       "        var bb = text_encode(s);\n",
       "        push_size(bb.length);\n",
       "        if (pos + bb.length > pos_max) { new_buffer(bb.length); }\n",
       "        for (var i=0; i<bb.length; i++) { buf8[pos + i] = bb[i]; }\n",
       "        pos += bb.length;\n",
       "    }\n",
       "    function push_size(s, big) {\n",
       "        if (s <= 250 && typeof big == 'undefined') {\n",
       "            if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "            buf8[pos] = s;\n",
       "            pos += 1;\n",
       "        } else {\n",
       "            if (pos + 9 > pos_max) { new_buffer(9); }\n",
       "            buf8[pos] = 253;\n",
       "            bufdv.setUint32(pos+1, (s % 4294967296), true); // uint64\n",
       "            bufdv.setUint32(pos+5, (s / 4294967296) & 4294967295, true);\n",
       "            pos += 9;\n",
       "        }\n",
       "    }\n",
       "    function push_uint8(s) {\n",
       "        if (pos + 1 > pos_max) { new_buffer(1); }\n",
       "        buf8[pos] = s;\n",
       "        pos += 1;\n",
       "    }\n",
       "    function push_int16(s) {\n",
       "        if (pos + 2 > pos_max) { new_buffer(2); }\n",
       "        bufdv.setInt16(pos, s, true);\n",
       "        pos += 2;\n",
       "    }\n",
       "    function push_int64(s) {\n",
       "        if (pos + 8 > pos_max) { new_buffer(8); }\n",
       "        var j, a;\n",
       "        if (s < 0) { // perform two's complement encoding\n",
       "            for (j=0, a=s+1; j<8; j++, a/=256) { buf8[pos+j] = ((-(a % 256 )) & 255) ^ 255; }\n",
       "        } else {\n",
       "            for (j=0, a=s; j<8; j++, a/=256) { buf8[pos+j] = ((a % 256 ) & 255); }\n",
       "        }\n",
       "        pos += 8;\n",
       "    }\n",
       "    function push_float64(s) {\n",
       "        // todo: we could push 32bit floats via \"f\"\n",
       "        if (pos + 8 > pos_max) { new_buffer(8); }\n",
       "        bufdv.setFloat64(pos, s, true);\n",
       "        pos += 8;\n",
       "    }\n",
       "    return {get_result: get_result, tell: tell, push_bytes: push_bytes,\n",
       "            push_char: push_char, push_str: push_str, push_size: push_size,\n",
       "            push_uint8: push_uint8, push_int16: push_int16, push_int64: push_int64,\n",
       "            push_float64: push_float64};\n",
       "}\n",
       "\n",
       "function encode_type_id(f, c, extension_id) {\n",
       "    if (typeof extension_id == 'undefined') {\n",
       "        f.push_char(c);\n",
       "    } else {\n",
       "        f.push_char(c.toUpperCase());\n",
       "        f.push_str(extension_id);\n",
       "    }\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.encode_object = function (f, value, extension_id) {\n",
       "    var iext, ext;\n",
       "\n",
       "    if (value === null) { encode_type_id(f, 'v', extension_id); }\n",
       "    //else if (typeof value == 'undefined') { encode_type_id(f, 'v', extension_id); }\n",
       "    else if (value === false) { encode_type_id(f, 'n', extension_id); }\n",
       "    else if (value === true) { encode_type_id(f, 'y', extension_id); }\n",
       "    else if (typeof value == 'number') {\n",
       "        if (Number.isInteger(value)) {\n",
       "            if (value >= -32768 && value <= 32767) {\n",
       "                encode_type_id(f, 'h', extension_id);\n",
       "                f.push_int16(value);\n",
       "            } else {\n",
       "                encode_type_id(f, 'i', extension_id);\n",
       "                f.push_int64(value);\n",
       "            }\n",
       "        } else {\n",
       "            encode_type_id(f, 'd', extension_id);\n",
       "            f.push_float64(value);\n",
       "        }\n",
       "    } else if (typeof value == 'string') {\n",
       "        encode_type_id(f, 's', extension_id);\n",
       "        f.push_str(value);\n",
       "    } else if (typeof value == 'object') {\n",
       "        if (Array.isArray(value)) {  // heterogeneous list\n",
       "            encode_type_id(f, 'l', extension_id);\n",
       "            var n = value.length;\n",
       "            f.push_size(n);\n",
       "            for (var i=0; i<n; i++) {\n",
       "                this.encode_object(f, value[i]);\n",
       "            }\n",
       "        } else if (value.constructor === Object) {  // mapping / dict\n",
       "            encode_type_id(f, 'm', extension_id);\n",
       "            var nm = Object.keys(value).length;\n",
       "            f.push_size(nm);\n",
       "            for (var key in value) {\n",
       "                f.push_str(key);\n",
       "                this.encode_object(f, value[key]);\n",
       "            }\n",
       "        } else if (value instanceof ArrayBuffer || value instanceof DataView) {  // bytes\n",
       "            if (value instanceof ArrayBuffer) { value = new DataView(value); }\n",
       "            encode_type_id(f, 'b', extension_id);\n",
       "            var compression = 0;\n",
       "            var compressed = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);  // map to uint8\n",
       "            var data_size = value.byteLength;\n",
       "            var used_size = data_size;\n",
       "            var extra_size = 0;\n",
       "            var allocated_size = used_size + extra_size;\n",
       "            // Write sizes - write at least in a size that allows resizing\n",
       "            if (allocated_size > 250) {  // && compression == 0\n",
       "                f.push_size(allocated_size, true);\n",
       "                f.push_size(used_size, true);\n",
       "                f.push_size(data_size, true);\n",
       "            } else {\n",
       "                f.push_size(allocated_size);\n",
       "                f.push_size(used_size);\n",
       "                f.push_size(data_size);\n",
       "            }\n",
       "            // Compression and checksum\n",
       "            f.push_uint8(0);\n",
       "            f.push_uint8(0);  // no checksum\n",
       "            // Byte alignment\n",
       "            if (compression == 0) {\n",
       "                var alignment = 8 - (f.tell() + 1) % 8;  // +1 for the byte to write\n",
       "                f.push_uint8(alignment);\n",
       "                for (var j=0; j<alignment; j++) { f.push_uint8(0); }\n",
       "            } else {\n",
       "                f.push_uint8(0);  // zero alignment\n",
       "            }\n",
       "            // The actual data and extra space\n",
       "            f.push_bytes(compressed);\n",
       "            f.push_bytes(new Uint8Array(allocated_size - used_size));\n",
       "        } else {\n",
       "            // Try extensions (for objects)\n",
       "            for (iext=0; iext<this.extensions.length; iext++) {\n",
       "                ext = this.extensions[iext];\n",
       "                if (ext.match(this, value)) {\n",
       "                    this.encode_object(f, ext.encode(this, value), ext.name);\n",
       "                    return;\n",
       "                }\n",
       "            }\n",
       "            var cls = Object.getPrototypeOf(value);\n",
       "            var cname = cls.__name__ || cls.constructor.name;  // __name__ is a PyScript thing\n",
       "            throw \"cannot encode object of type \" + cname;\n",
       "        }\n",
       "    } else {\n",
       "        if (typeof extension_id != 'undefined') {\n",
       "            throw ('Extension ' + extension_id + ' wronfully encodes object to another ' +\n",
       "                   'extension object (though it may encode to a list/dict ' +\n",
       "                   'that contains other extension objects).');\n",
       "        }\n",
       "        // Try extensions (for other types)\n",
       "        for (iext=0; iext<this.extensions.length; iext++) {\n",
       "            ext = this.extensions[iext];\n",
       "            if (ext.match(this, value)) {\n",
       "                this.encode_object(f, ext.encode(this, value), ext.name);\n",
       "                return;\n",
       "            }\n",
       "        }\n",
       "        throw \"cannot encode type \" + typeof(value);\n",
       "    }\n",
       "};\n",
       "\n",
       "//---- decoder\n",
       "\n",
       "function BytesReader(buf) {\n",
       "\n",
       "    // Buffer can be ArrayBuffer, DataView or Uint8Array, or Nodejs Buffer, we map to DataView\n",
       "    var bufdv;\n",
       "\n",
       "    if (typeof buf.byteLength == 'undefined') {\n",
       "        throw \"BSDF decorer needs something that looks like bytes\";\n",
       "    }\n",
       "    if (typeof buf.byteOffset == 'undefined') {\n",
       "        bufdv = new DataView(buf);  // buf was probably an ArrayBuffer\n",
       "    } else {\n",
       "        bufdv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);  // remap to something we know\n",
       "    }\n",
       "\n",
       "    var startpos = bufdv.byteOffset;\n",
       "    var pos = 0;\n",
       "    var buf8 = new Uint8Array(bufdv.buffer, bufdv.byteOffset, bufdv.byteLength);\n",
       "\n",
       "    // Create text encoder / decoder\n",
       "    var text_encode, text_decode;\n",
       "    if (typeof TextDecoder !== 'undefined') {\n",
       "        var x = new TextDecoder('utf-8');\n",
       "        text_decode = x.decode.bind(x);\n",
       "    } else {\n",
       "        // test this\n",
       "        text_decode = utf8decode;\n",
       "    }\n",
       "\n",
       "    function tell() {\n",
       "        return pos;\n",
       "    }\n",
       "    function get_char() {\n",
       "        return String.fromCharCode(buf8[pos++]);\n",
       "    }\n",
       "    function get_size() {\n",
       "        var s = buf8[pos++];\n",
       "        if (s >= 253) {\n",
       "            if (s == 253) {\n",
       "                s = bufdv.getUint32(pos, true) + bufdv.getUint32(pos+4, true) * 4294967296;\n",
       "            } else if (s == 254) { // closed stream\n",
       "                s = bufdv.getUint32(pos, true) + bufdv.getUint32(pos+4, true) * 4294967296;\n",
       "            } else if (s == 255) {  // unclosed stream\n",
       "                s = -1;\n",
       "            } else {\n",
       "                throw \"Invalid size\";\n",
       "            }\n",
       "            pos += 8;\n",
       "        }\n",
       "        return s;\n",
       "    }\n",
       "    function get_bytes(n) {  // we use Uint8Array internally for this\n",
       "        var s = new Uint8Array(buf8.buffer, buf8.byteOffset + pos, n);\n",
       "        pos += n;\n",
       "        return s;\n",
       "    }\n",
       "    function get_str() {\n",
       "        var n = get_size();\n",
       "        var bb = new Uint8Array(buf8.buffer, buf8.byteOffset + pos, n);\n",
       "        pos += n;\n",
       "        return text_decode(bb);\n",
       "    }\n",
       "    function get_uint8() {\n",
       "        return buf8[pos++];\n",
       "    }\n",
       "    function get_int16() {\n",
       "        var s = bufdv.getInt16(pos, true);\n",
       "        pos += 2;\n",
       "        return s;\n",
       "    }\n",
       "    function get_int64() {\n",
       "        var isneg = (buf8[pos+7] & 0x80) > 0;\n",
       "        var s, j, m;\n",
       "        if (isneg) {\n",
       "            s = -1;\n",
       "            for (j=0, m=1; j<8; j++, m*=256) { s -= (buf8[pos+j] ^ 0xff) * m; }\n",
       "        } else {\n",
       "            s = 0;\n",
       "            for (j=0, m=1; j<8; j++, m*=256) { s += buf8[pos+j] * m; }\n",
       "        }\n",
       "        pos += 8;\n",
       "        return s;\n",
       "    }\n",
       "    function get_float32() {\n",
       "        var s = bufdv.getFloat32(pos, true);\n",
       "        pos += 4;\n",
       "        return s;\n",
       "    } function get_float64() {\n",
       "        var s = bufdv.getFloat64(pos, true);\n",
       "        pos += 8;\n",
       "        return s;\n",
       "    }\n",
       "\n",
       "    return {tell: tell, get_size:get_size, get_bytes: get_bytes,\n",
       "            get_uint8: get_uint8, get_int16: get_int16, get_int64: get_int64,\n",
       "            get_float32: get_float32, get_float64: get_float64, get_char: get_char, get_str: get_str};\n",
       "\n",
       "}\n",
       "\n",
       "BsdfSerializer.prototype.decode_object = function (f) {\n",
       "\n",
       "    var char = f.get_char();\n",
       "    var c = char.toLowerCase();\n",
       "    var value;\n",
       "    var extension_id = null;\n",
       "\n",
       "    if (char == '\\x00') {  // because String.fromCharCode(undefined) produces ASCII 0.\n",
       "        throw new EOFError('End of BSDF data reached.');\n",
       "    }\n",
       "\n",
       "    // Conversion (uppercase value identifiers signify converted values)\n",
       "    if (char != c) {\n",
       "        extension_id = f.get_str();\n",
       "    }\n",
       "\n",
       "    if (c == 'v') {\n",
       "        value = null;\n",
       "    } else if (c == 'n') {\n",
       "        value = false;\n",
       "    } else if (c == 'y') {\n",
       "        value = true;\n",
       "    } else if (c == 'h') {\n",
       "        value = f.get_int16();\n",
       "    } else if (c == 'i') {\n",
       "        value = f.get_int64();\n",
       "    } else if (c == 'f') {\n",
       "        value = f.get_float32();\n",
       "    } else if (c == 'd') {\n",
       "        value = f.get_float64();\n",
       "    } else if (c == 's') {\n",
       "        value = f.get_str();\n",
       "    } else if (c == 'l') {\n",
       "        var n = f.get_size();\n",
       "        if (n < 0) {\n",
       "            // Streaming\n",
       "            value = [];\n",
       "            try {\n",
       "                while (true) { value.push(this.decode_object(f)); }\n",
       "            } catch(err) {\n",
       "                if (err instanceof EOFError) { /* ok */ } else { throw err; }\n",
       "            }\n",
       "        } else {\n",
       "            // Normal\n",
       "            value = new Array(n);\n",
       "            for (var i=0; i<n; i++) {\n",
       "                value[i] = this.decode_object(f);\n",
       "            }\n",
       "        }\n",
       "    } else if (c == 'm') {\n",
       "        var nm = f.get_size();\n",
       "        value = {};\n",
       "        for (var j=0; j<nm; j++) {\n",
       "            var key = f.get_str();\n",
       "            value[key] = this.decode_object(f);\n",
       "        }\n",
       "    } else if (c == 'b') {\n",
       "        // Get sizes\n",
       "        var allocated_size = f.get_size();\n",
       "        var used_size = f.get_size();\n",
       "        var data_size = f.get_size();\n",
       "        // Compression and checksum\n",
       "        var compression = f.get_uint8();\n",
       "        var has_checksum = f.get_uint8();\n",
       "        if (has_checksum) {\n",
       "            var checksum = f.get_bytes(16);\n",
       "        }\n",
       "        // Skip alignment\n",
       "        var alignment = f.get_uint8();\n",
       "        f.get_bytes(alignment);\n",
       "        // Get data (as ArrayBuffer)\n",
       "        var compressed = f.get_bytes(used_size);  // uint8\n",
       "        f.get_bytes(allocated_size - used_size);  // skip extra space\n",
       "        if (compression == 0) {\n",
       "            value = new DataView(compressed.buffer, compressed.byteOffset, compressed.byteLength);\n",
       "        } else {\n",
       "            throw \"JS implementation of BSDF does not support compression (\" + compression + ')';\n",
       "        }\n",
       "    } else {\n",
       "        throw \"Invalid value specifier at pos \" + f.tell() + \": \" + JSON.stringify(char);\n",
       "    }\n",
       "\n",
       "    // Convert using an extension?\n",
       "    if (extension_id !== null) {\n",
       "        var ext = this.extensions[extension_id];\n",
       "        if (ext) {\n",
       "            value = ext.decode(this, value);\n",
       "        } else {\n",
       "            console.warn('BSDF warning: no known extension for \"' + extension_id + '\", value passes in raw form.');\n",
       "        }\n",
       "    }\n",
       "    return value;\n",
       "};\n",
       "\n",
       "\n",
       "// To be able to support complex numbers\n",
       "function Complex(real, imag) {\n",
       "    this.real = real;\n",
       "    this.imag = imag;\n",
       "}\n",
       "\n",
       "function EOFError(msg) {\n",
       "    this.msg = msg;\n",
       "}\n",
       "\n",
       "\n",
       "// ================== Standard extensions\n",
       "\n",
       "var rootns;\n",
       "if (typeof window == 'undefined') { rootns = global; } else { rootns = window; }\n",
       "\n",
       "var complex_extension = {\n",
       "    name: 'c',\n",
       "    match: function(s, v) { return v instanceof Complex; },\n",
       "    encode: function(s, v) { return [v.real, v.imag]; },\n",
       "    decode: function(s, v) { return new Complex(v[0], v[1]); }\n",
       "};\n",
       "\n",
       "var ndarray_extension = {\n",
       "    name: 'ndarray',\n",
       "    match: function(s, v) {\n",
       "        return v.BYTES_PER_ELEMENT !== undefined && v.constructor.name.endsWith('Array');\n",
       "    },\n",
       "    encode: function(s, v) {\n",
       "        return {shape: v.shape || [v.length],\n",
       "                dtype: v.constructor.name.slice(0, -5).toLowerCase(),\n",
       "                data: new DataView(v.buffer, v.byteOffset, v.byteLength)};\n",
       "    },\n",
       "    decode: function(s, v) {\n",
       "        var cls = rootns[v.dtype[0].toUpperCase() + v.dtype.slice(1) + 'Array'];\n",
       "        var value = new cls(v.data.buffer, v.data.byteOffset, v.data.byteLength / cls.BYTES_PER_ELEMENT);\n",
       "        value.shape = v.shape;\n",
       "        return value;\n",
       "    }\n",
       "};\n",
       "\n",
       "var standard_extensions = [complex_extension, ndarray_extension];\n",
       "\n",
       "// ================== the UMD module suffix\n",
       "return {encode: bsdf_encode, decode: bsdf_decode, BsdfSerializer: BsdfSerializer, standard_extensions: standard_extensions};\n",
       "}));\n",
       "\n",
       "\n",
       "/* ============================== bb64.js ===============================*/\n",
       "\n",
       "flexx.define(\"bb64\", [], (function () {\n",
       "\"use strict\";\n",
       "\n",
       "function base64encode(b, last_two) {\n",
       "    \"use strict\";\n",
       "    console.assert(b.BYTES_PER_ELEMENT == 1);\n",
       "    // Most Base64 encoders use +/ for the last two characters, but not all\n",
       "    if (last_two === undefined) last_two = '+/';\n",
       "    // Init charcodes array\n",
       "    var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\" + last_two;\n",
       "    var charcodes = new Uint8Array(64);\n",
       "    for (var k=0; k<64; k++) charcodes[k] = chars.charCodeAt(k);\n",
       "    // Init result string, as a typed array of ASCII values\n",
       "    var s = new Uint8Array(Math.ceil(b.length / 3) * 4);\n",
       "    // Init\n",
       "    var b1, b2, b3;\n",
       "    var i = 0;  // The byte index\n",
       "    var j = 0;  // The string index\n",
       "    // Iterate over bytes\n",
       "    while (i < b.length) {\n",
       "        // Sample bytes, out of bounds are mapped to zero\n",
       "        b1 = b[i+0] || 0; b2 = b[i+1] || 0; b3 = b[i+2] || 0;\n",
       "        i += 3;\n",
       "        // Encode and assign\n",
       "        s[j+0] = charcodes[( b1 >> 2 ) & 0x3F];\n",
       "        s[j+1] = charcodes[( ( b1 & 0x3 ) << 4 ) | ( ( b2 >> 4 ) & 0xF )];\n",
       "        s[j+2] = charcodes[( ( b2 & 0xF ) << 2 ) | ( ( b3 >> 6 ) & 0x3 )];\n",
       "        s[j+3] = charcodes[b3 & 0x3F];\n",
       "        j += 4;\n",
       "    }\n",
       "    // Replace stub bytes with the padding char\n",
       "    for (var k=0; k<(i-b.length); k++) s[s.length-k-1] = '61';\n",
       "    // Convert to string\n",
       "    return String.fromCharCode.apply(null, s);\n",
       "}\n",
       "\n",
       "function base64decode(s, last_two) {\n",
       "    \"use strict\";\n",
       "    // Most Base64 encoders use +/ for the last two characters, but not all\n",
       "    if (last_two === undefined) last_two = '+/';\n",
       "    var charcode62 = last_two.charCodeAt(0), charcode63 = last_two.charCodeAt(1);\n",
       "    // Allocate byte array, with a length as large as it can possibly become\n",
       "    var b = new Uint8Array(Math.floor((s.length / 4) * 3));\n",
       "    // Init\n",
       "    var i = 0; // The number of bytes (and byte index)\n",
       "    var j = 0; // The index into the string\n",
       "    var c, cc = new Array(4);  // to store character codes (ints)\n",
       "    // Iterate while there are chars left\n",
       "    while (j < s.length) {\n",
       "        // Collect 4 (or less) characters\n",
       "        var charcount = 0;\n",
       "        while (charcount < 4 && j < s.length) {\n",
       "            c = s.charCodeAt(j++);\n",
       "            if (c >= 65 && c <=90) c -= 65;  // A-Z: 0-25\n",
       "            else if (c >=97 && c<=122) c -= 71;  // a-z: 26-51\n",
       "            else if (c >=48 && c<=57) c += 4;  // 0-9: 52-61\n",
       "            else if (c == charcode62) c = 62;\n",
       "            else if (c == charcode63) c = 63;\n",
       "            else continue;  // skip other chars, like newline, padding, or other\n",
       "            cc[charcount] = c;\n",
       "            charcount += 1;\n",
       "        }\n",
       "        // At the end, we may not have enough chars, zero these values\n",
       "        if (charcount != 4) for (var k=charcount; k<4; k++) cc[k] = 0;\n",
       "        // Calculate the 3 byte values\n",
       "        b[i+0] = (cc[0] << 2) | (cc[1] >> 4);\n",
       "        b[i+1] = ((cc[1] & 15) << 4) | (cc[2] >> 2);\n",
       "        b[i+2] = ((cc[2] & 3) << 6) | cc[3];\n",
       "        // Next i (4 chars -> 3 bytes, 3 chars -> 2 bytes, 2 chars -> 1 byte)\n",
       "        i += charcount - 1;\n",
       "    }\n",
       "    // Return view that has the correct length, but on same data buffer.\n",
       "    // The unused memory should be marginal, so making a copy not worth it.\n",
       "    return new Uint8Array(b.buffer, 0, i);\n",
       "}\n",
       "\n",
       "return {encode: base64encode, decode: base64decode};\n",
       "}));\n",
       "\n",
       "\n",
       "/* =========================== pscript-std.js ===========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "flexx.define(\"pscript-std.js\", [], function () {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_abs = Math.abs;\n",
       "var _pyfunc_all = function (x) { // nargs: 1\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        if (!_pyfunc_truthy(x[i])){return false;}\n",
       "    } return true;\n",
       "};\n",
       "var _pyfunc_any = function (x) { // nargs: 1\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        if (_pyfunc_truthy(x[i])){return true;}\n",
       "    } return false;\n",
       "};\n",
       "var _pyfunc_bool = function (x) { // nargs: 1\n",
       "    return Boolean(_pyfunc_truthy(x));\n",
       "};\n",
       "var _pyfunc_delattr = function (ob, name) {  // nargs: 2\n",
       "    delete ob[name];\n",
       "};\n",
       "var _pyfunc_dict = function (x) {\n",
       "    var t, i, keys, r={};\n",
       "    if (Array.isArray(x)) {\n",
       "        for (i=0; i<x.length; i++) {\n",
       "            t=x[i]; r[t[0]] = t[1];\n",
       "        }\n",
       "    } else {\n",
       "        keys = Object.keys(x);\n",
       "        for (i=0; i<keys.length; i++) {\n",
       "            t=keys[i]; r[t] = x[t];\n",
       "        }\n",
       "    }\n",
       "    return r;\n",
       "};\n",
       "var _pyfunc_divmod = function (x, y) { // nargs: 2\n",
       "    var m = x % y; return [(x-m)/y, m];\n",
       "};\n",
       "var _pyfunc_enumerate = function (iter) { // nargs: 1\n",
       "    var i, res=[];\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    for (i=0; i<iter.length; i++) {res.push([i, iter[i]]);}\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_filter = function (func, iter) { // nargs: 2\n",
       "    if (typeof func === \"undefined\" || func === null) {func = function(x) {return x;}}\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.filter(func);\n",
       "};\n",
       "var _pyfunc_float = Number;\n",
       "var _pyfunc_getattr = function (ob, name, deflt) { // nargs: 2 3\n",
       "    var has_attr = ob !== undefined && ob !== null && ob[name] !== undefined;\n",
       "    if (has_attr) {return ob[name];}\n",
       "    else if (arguments.length == 3) {return deflt;}\n",
       "    else {var e = Error(name); e.name='AttributeError'; throw e;}\n",
       "};\n",
       "var _pyfunc_hasattr = function (ob, name) { // nargs: 2\n",
       "    return (ob !== undefined) && (ob !== null) && (ob[name] !== undefined);\n",
       "};\n",
       "var _pyfunc_int = function (x) { // nargs: 1\n",
       "    return x<0 ? Math.ceil(x): Math.floor(x);\n",
       "};\n",
       "var _pyfunc_list = function (x) {\n",
       "    var r=[];\n",
       "    if (typeof x===\"object\" && !Array.isArray(x)) {x = Object.keys(x)}\n",
       "    for (var i=0; i<x.length; i++) {\n",
       "        r.push(x[i]);\n",
       "    }\n",
       "    return r;\n",
       "};\n",
       "var _pyfunc_map = function (func, iter) { // nargs: 2\n",
       "    if (typeof func === \"undefined\" || func === null) {func = function(x) {return x;}}\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.map(func);\n",
       "};\n",
       "var _pyfunc_merge_dicts = function () {\n",
       "    var res = {};\n",
       "    for (var i=0; i<arguments.length; i++) {\n",
       "        var d = arguments[i];\n",
       "        var key, keys = Object.keys(d);\n",
       "        for (var j=0; j<keys.length; j++) { key = keys[j]; res[key] = d[key]; }\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_op_add = function (a, b) { // nargs: 2\n",
       "    if (Array.isArray(a) && Array.isArray(b)) {\n",
       "        return a.concat(b);\n",
       "    } return a + b;\n",
       "};\n",
       "var _pyfunc_op_contains = function op_contains (a, b) { // nargs: 2\n",
       "    if (b == null) {\n",
       "    } else if (Array.isArray(b)) {\n",
       "        for (var i=0; i<b.length; i++) {if (_pyfunc_op_equals(a, b[i]))\n",
       "                                           return true;}\n",
       "        return false;\n",
       "    } else if (b.constructor === Object) {\n",
       "        for (var k in b) {if (a == k) return true;}\n",
       "        return false;\n",
       "    } else if (b.constructor == String) {\n",
       "        return b.indexOf(a) >= 0;\n",
       "    } var e = Error('Not a container: ' + b); e.name='TypeError'; throw e;\n",
       "};\n",
       "var _pyfunc_op_equals = function op_equals (a, b) { // nargs: 2\n",
       "    if (a == null || b == null) {\n",
       "    } else if (Array.isArray(a) && Array.isArray(b)) {\n",
       "        var i = 0, iseq = a.length == b.length;\n",
       "        while (iseq && i < a.length) {iseq = op_equals(a[i], b[i]); i+=1;}\n",
       "        return iseq;\n",
       "    } else if (a.constructor === Object && b.constructor === Object) {\n",
       "        var akeys = Object.keys(a), bkeys = Object.keys(b);\n",
       "        akeys.sort(); bkeys.sort();\n",
       "        var i=0, k, iseq = op_equals(akeys, bkeys);\n",
       "        while (iseq && i < akeys.length)\n",
       "            {k=akeys[i]; iseq = op_equals(a[k], b[k]); i+=1;}\n",
       "        return iseq;\n",
       "    } return a == b;\n",
       "};\n",
       "var _pyfunc_op_error = function (etype, msg) { // nargs: 2\n",
       "    var e = new Error(etype + ': ' + msg);\n",
       "    e.name = etype\n",
       "    return e;\n",
       "};\n",
       "var _pyfunc_op_instantiate = function (ob, args) { // nargs: 2\n",
       "    if ((typeof ob === \"undefined\") ||\n",
       "            (typeof window !== \"undefined\" && window === ob) ||\n",
       "            (typeof global !== \"undefined\" && global === ob))\n",
       "            {throw \"Class constructor is called as a function.\";}\n",
       "    for (var name in ob) {\n",
       "        if (Object[name] === undefined &&\n",
       "            typeof ob[name] === 'function' && !ob[name].nobind) {\n",
       "            ob[name] = ob[name].bind(ob);\n",
       "            ob[name].__name__ = name;\n",
       "        }\n",
       "    }\n",
       "    if (ob.__init__) {\n",
       "        ob.__init__.apply(ob, args);\n",
       "    }\n",
       "};\n",
       "var _pyfunc_op_mult = function (a, b) { // nargs: 2\n",
       "    if ((typeof a === 'number') + (typeof b === 'number') === 1) {\n",
       "        if (a.constructor === String) return _pymeth_repeat.call(a, b);\n",
       "        if (b.constructor === String) return _pymeth_repeat.call(b, a);\n",
       "        if (Array.isArray(b)) {var t=a; a=b; b=t;}\n",
       "        if (Array.isArray(a)) {\n",
       "            var res = []; for (var i=0; i<b; i++) res = res.concat(a);\n",
       "            return res;\n",
       "        }\n",
       "    } return a * b;\n",
       "};\n",
       "var _pyfunc_op_parse_kwargs = function (arg_names, arg_values, kwargs, strict) { // nargs: 3\n",
       "    for (var i=0; i<arg_values.length; i++) {\n",
       "        var name = arg_names[i];\n",
       "        if (kwargs[name] !== undefined) {\n",
       "            arg_values[i] = kwargs[name];\n",
       "            delete kwargs[name];\n",
       "        }\n",
       "    }\n",
       "    if (strict && Object.keys(kwargs).length > 0) {\n",
       "        throw _pyfunc_op_error('TypeError',\n",
       "            'Function ' + strict + ' does not accept **kwargs.');\n",
       "    }\n",
       "    return kwargs;\n",
       "};\n",
       "var _pyfunc_perf_counter = function() { // nargs: 0\n",
       "    if (typeof(process) === \"undefined\"){return performance.now()*1e-3;}\n",
       "    else {var t = process.hrtime(); return t[0] + t[1]*1e-9;}\n",
       "};\n",
       "var _pyfunc_pow = Math.pow;\n",
       "var _pyfunc_range = function (start, end, step) {\n",
       "var i, res = [];\n",
       "    var val = start;\n",
       "    var n = (end - start) / step;\n",
       "    for (i=0; i<n; i++) {\n",
       "        res.push(val);\n",
       "        val += step;\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_repr = function (x) { // nargs: 1\n",
       "    var res; try { res = JSON.stringify(x); } catch (e) { res = undefined; }\n",
       "    if (typeof res === 'undefined') { res = x._IS_COMPONENT ? x.id : String(x); }\n",
       "    return res;\n",
       "};\n",
       "var _pyfunc_reversed = function (iter) { // nargs: 1\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    return iter.slice().reverse();\n",
       "};\n",
       "var _pyfunc_round = Math.round;\n",
       "var _pyfunc_setattr = function (ob, name, value) {  // nargs: 3\n",
       "    ob[name] = value;\n",
       "};\n",
       "var _pyfunc_sorted = function (iter, key, reverse) { // nargs: 1 2 3\n",
       "    if ((typeof iter===\"object\") && (!Array.isArray(iter))) {iter = Object.keys(iter);}\n",
       "    var comp = function (a, b) {a = key(a); b = key(b);\n",
       "        if (a<b) {return -1;} if (a>b) {return 1;} return 0;};\n",
       "    comp = Boolean(key) ? comp : undefined; \n",
       "    iter = iter.slice().sort(comp);\n",
       "    if (reverse) iter.reverse();\n",
       "    return iter;\n",
       "};\n",
       "var _pyfunc_str = String;\n",
       "var _pyfunc_sum = function (x) {  // nargs: 1\n",
       "    return x.reduce(function(a, b) {return a + b;});\n",
       "};\n",
       "var _pyfunc_time = function () {return Date.now() / 1000;};\n",
       "var _pyfunc_truthy = function (v) {\n",
       "    if (v === null || typeof v !== \"object\") {return v;}\n",
       "    else if (v.length !== undefined) {return v.length ? v : false;}\n",
       "    else if (v.byteLength !== undefined) {return v.byteLength ? v : false;}\n",
       "    else if (v.constructor !== Object) {return true;}\n",
       "    else {return Object.getOwnPropertyNames(v).length ? v : false;}\n",
       "};\n",
       "var _pyfunc_zip = function () { // nargs: 2 3 4 5 6 7 8 9\n",
       "    var i, j, tup, arg, args = [], res = [], len = 1e20;\n",
       "    for (i=0; i<arguments.length; i++) {\n",
       "        arg = arguments[i];\n",
       "        if ((typeof arg===\"object\") && (!Array.isArray(arg))) {arg = Object.keys(arg);}\n",
       "        args.push(arg);\n",
       "        len = Math.min(len, arg.length);\n",
       "    }\n",
       "    for (j=0; j<len; j++) {\n",
       "        tup = []\n",
       "        for (i=0; i<args.length; i++) {tup.push(args[i][j]);}\n",
       "        res.push(tup);\n",
       "    }\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_append = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.append.apply(this, arguments);\n",
       "    this.push(x);\n",
       "};\n",
       "var _pymeth_capitalize = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.capitalize.apply(this, arguments);\n",
       "    return this.slice(0, 1).toUpperCase() + this.slice(1).toLowerCase();\n",
       "};\n",
       "var _pymeth_casefold = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.casefold.apply(this, arguments);\n",
       "    return this.toLowerCase();\n",
       "};\n",
       "var _pymeth_center = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.center.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    var left = Math.ceil(tofill / 2);\n",
       "    var right = tofill - left;\n",
       "    return _pymeth_repeat.call(fill, left) + this + _pymeth_repeat.call(fill, right);\n",
       "};\n",
       "var _pymeth_clear = function () { // nargs: 0\n",
       "    if (Array.isArray(this)) {\n",
       "        this.splice(0, this.length);\n",
       "    } else if (this.constructor === Object) {\n",
       "        var keys = Object.keys(this);\n",
       "        for (var i=0; i<keys.length; i++) delete this[keys[i]];\n",
       "    } else return this.clear.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_copy = function () { // nargs: 0\n",
       "    if (Array.isArray(this)) {\n",
       "        return this.slice(0);\n",
       "    } else if (this.constructor === Object) {\n",
       "        var key, keys = Object.keys(this), res = {};\n",
       "        for (var i=0; i<keys.length; i++) {key = keys[i]; res[key] = this[key];}\n",
       "        return res;\n",
       "    } else return this.copy.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_count = function (x, start, stop) { // nargs: 1 2 3\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    if (Array.isArray(this)) {\n",
       "        var count = 0;\n",
       "        for (var i=0; i<this.length; i++) { \n",
       "            if (_pyfunc_op_equals(this[i], x)) {count+=1;}\n",
       "        } return count;\n",
       "    } else if (this.constructor == String) {\n",
       "        var count = 0, i = start;\n",
       "        while (i >= 0 && i < stop) {\n",
       "            i = this.indexOf(x, i);\n",
       "            if (i < 0) break; \n",
       "            count += 1;\n",
       "            i += Math.max(1, x.length);\n",
       "        } return count;\n",
       "    } else return this.count.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_endswith = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.endswith.apply(this, arguments);\n",
       "    return this.lastIndexOf(x) == this.length - x.length;\n",
       "};\n",
       "var _pymeth_expandtabs = function (tabsize) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.expandtabs.apply(this, arguments);\n",
       "    tabsize = (tabsize === undefined) ? 8 : tabsize;\n",
       "    return this.replace(/\\t/g, _pymeth_repeat.call(' ', tabsize));\n",
       "};\n",
       "var _pymeth_extend = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.extend.apply(this, arguments);\n",
       "    this.push.apply(this, x);   \n",
       "};\n",
       "var _pymeth_find = function (x, start, stop) { // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.find.apply(this, arguments);\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    var i = this.slice(start, stop).indexOf(x);\n",
       "    if (i >= 0) return i + start;\n",
       "    return -1;\n",
       "};\n",
       "var _pymeth_get = function (key, d) { // nargs: 1 2\n",
       "    if (this.constructor !== Object) return this.get.apply(this, arguments);\n",
       "    if (this[key] !== undefined) {return this[key];}\n",
       "    else if (d !== undefined) {return d;}\n",
       "    else {return null;}\n",
       "};\n",
       "var _pymeth_index = function (x, start, stop) { // nargs: 1 2 3\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    if (Array.isArray(this)) {\n",
       "        for (var i=start; i<stop; i++) {\n",
       "            if (_pyfunc_op_equals(this[i], x)) {return i;} // indexOf cant\n",
       "        }\n",
       "    } else if (this.constructor === String) {\n",
       "        var i = this.slice(start, stop).indexOf(x);\n",
       "        if (i >= 0) return i + start;\n",
       "    } else return this.index.apply(this, arguments);\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_insert = function (i, x) { // nargs: 2\n",
       "    if (!Array.isArray(this)) return this.insert.apply(this, arguments);\n",
       "    i = (i < 0) ? this.length + i : i;\n",
       "    this.splice(i, 0, x);\n",
       "};\n",
       "var _pymeth_isalnum = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isalnum.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z0-9]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isalpha = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isalpha.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isidentifier = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isidentifier.apply(this, arguments);\n",
       "    return Boolean(/^[A-Za-z_][A-Za-z0-9_]*$/.test(this));\n",
       "};\n",
       "var _pymeth_islower = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.islower.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), high = this.toUpperCase();\n",
       "    return low != high && low == this;\n",
       "};\n",
       "var _pymeth_isnumeric = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isnumeric.apply(this, arguments);\n",
       "    return Boolean(/^[0-9]+$/.test(this));\n",
       "};\n",
       "var _pymeth_isspace = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isspace.apply(this, arguments);\n",
       "    return Boolean(/^\\s+$/.test(this));\n",
       "};\n",
       "var _pymeth_istitle = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.istitle.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), title = _pymeth_title.call(this);\n",
       "    return low != title && title == this;\n",
       "};\n",
       "var _pymeth_isupper = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.isupper.apply(this, arguments);\n",
       "    var low = this.toLowerCase(), high = this.toUpperCase();\n",
       "    return low != high && high == this;\n",
       "};\n",
       "var _pymeth_items = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.items.apply(this, arguments);\n",
       "    var key, keys = Object.keys(this), res = []\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; res.push([key, this[key]]);}\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_join = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.join.apply(this, arguments);\n",
       "    return x.join(this);  // call join on the list instead of the string.   \n",
       "};\n",
       "var _pymeth_keys = function () { // nargs: 0\n",
       "    if (typeof this['keys'] === 'function') return this.keys.apply(this, arguments);\n",
       "    return Object.keys(this);\n",
       "};\n",
       "var _pymeth_ljust = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.ljust.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    return this + _pymeth_repeat.call(fill, tofill);\n",
       "};\n",
       "var _pymeth_lower = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.lower.apply(this, arguments);\n",
       "    return this.toLowerCase();\n",
       "};\n",
       "var _pymeth_lstrip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.lstrip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        if (chars.indexOf(this[i]) < 0) return this.slice(i);\n",
       "    } return '';\n",
       "};\n",
       "var _pymeth_partition = function (sep) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.partition.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    var i1 = this.indexOf(sep);\n",
       "    if (i1 < 0) return [this.slice(0), '', '']\n",
       "    var i2 = i1 + sep.length;\n",
       "    return [this.slice(0, i1), this.slice(i1, i2), this.slice(i2)]; \n",
       "};\n",
       "var _pymeth_pop = function (i, d) { // nargs: 1 2\n",
       "    if (Array.isArray(this)) {\n",
       "        i = (i === undefined) ? -1 : i;\n",
       "        i = (i < 0) ? (this.length + i) : i;\n",
       "        var popped = this.splice(i, 1);\n",
       "        if (popped.length)  return popped[0];\n",
       "        var e = Error(i); e.name='IndexError'; throw e;\n",
       "    } else if (this.constructor === Object) {\n",
       "        var res = this[i]\n",
       "        if (res !== undefined) {delete this[i]; return res;}\n",
       "        else if (d !== undefined) return d;\n",
       "        var e = Error(i); e.name='KeyError'; throw e;\n",
       "    } else return this.pop.apply(this, arguments);\n",
       "};\n",
       "var _pymeth_popitem = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.popitem.apply(this, arguments);\n",
       "    var keys, key, val;\n",
       "    keys = Object.keys(this);\n",
       "    if (keys.length == 0) {var e = Error(); e.name='KeyError'; throw e;}\n",
       "    key = keys[0]; val = this[key]; delete this[key];\n",
       "    return [key, val];\n",
       "};\n",
       "var _pymeth_remove = function (x) { // nargs: 1\n",
       "    if (!Array.isArray(this)) return this.remove.apply(this, arguments);\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        if (_pyfunc_op_equals(this[i], x)) {this.splice(i, 1); return;}\n",
       "    }\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_repeat = function(count) { // nargs: 0\n",
       "    if (this.repeat) return this.repeat(count);\n",
       "    if (count < 1) return '';\n",
       "    var result = '', pattern = this.valueOf();\n",
       "    while (count > 1) {\n",
       "        if (count & 1) result += pattern;\n",
       "        count >>= 1, pattern += pattern;\n",
       "    }\n",
       "    return result + pattern;\n",
       "};\n",
       "var _pymeth_replace = function (s1, s2, count) {  // nargs: 2 3\n",
       "    if (this.constructor !== String) return this.replace.apply(this, arguments);\n",
       "    var i = 0, i2, parts = [];\n",
       "    count = (count === undefined) ? 1e20 : count;\n",
       "    while (count > 0) {\n",
       "        i2 = this.indexOf(s1, i);\n",
       "        if (i2 >= 0) {\n",
       "            parts.push(this.slice(i, i2));\n",
       "            parts.push(s2);\n",
       "            i = i2 + s1.length;\n",
       "            count -= 1;\n",
       "        } else break;\n",
       "    }\n",
       "    parts.push(this.slice(i));\n",
       "    return parts.join('');\n",
       "};\n",
       "var _pymeth_reverse = function () { // nargs: 0\n",
       "    this.reverse();\n",
       "};\n",
       "var _pymeth_rfind = function (x, start, stop) { // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.rfind.apply(this, arguments);\n",
       "    start = (start === undefined) ? 0 : start;\n",
       "    stop = (stop === undefined) ? this.length : stop;\n",
       "    start = Math.max(0, ((start < 0) ? this.length + start : start));\n",
       "    stop = Math.min(this.length, ((stop < 0) ? this.length + stop : stop));\n",
       "    var i = this.slice(start, stop).lastIndexOf(x);\n",
       "    if (i >= 0) return i + start;\n",
       "    return -1;\n",
       "};\n",
       "var _pymeth_rindex = function (x, start, stop) {  // nargs: 1 2 3\n",
       "    if (this.constructor !== String) return this.rindex.apply(this, arguments);\n",
       "    var i = _pymeth_rfind.call(this, x, start, stop);\n",
       "    if (i >= 0) return i;\n",
       "    var e = Error(x); e.name='ValueError'; throw e;\n",
       "};\n",
       "var _pymeth_rjust = function (w, fill) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.rjust.apply(this, arguments);\n",
       "    fill = (fill === undefined) ? ' ' : fill;\n",
       "    var tofill = Math.max(0, w - this.length);\n",
       "    return _pymeth_repeat.call(fill, tofill) + this;\n",
       "};\n",
       "var _pymeth_rpartition = function (sep) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.rpartition.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    var i1 = this.lastIndexOf(sep);\n",
       "    if (i1 < 0) return ['', '', this.slice(0)]\n",
       "    var i2 = i1 + sep.length;\n",
       "    return [this.slice(0, i1), this.slice(i1, i2), this.slice(i2)]; \n",
       "};\n",
       "var _pymeth_rsplit = function (sep, count) { // nargs: 1 2\n",
       "    if (this.constructor !== String) return this.rsplit.apply(this, arguments);\n",
       "    sep = (sep === undefined) ? /\\s/ : sep;\n",
       "    count = Math.max(0, (count === undefined) ? 1e20 : count);\n",
       "    var parts = this.split(sep);\n",
       "    var limit = Math.max(0, parts.length-count);\n",
       "    var res = parts.slice(limit);\n",
       "    if (count < parts.length) res.splice(0, 0, parts.slice(0, limit).join(sep));\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_rstrip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.rstrip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    for (var i=this.length-1; i>=0; i--) {\n",
       "        if (chars.indexOf(this[i]) < 0) return this.slice(0, i+1);\n",
       "    } return '';\n",
       "};\n",
       "var _pymeth_setdefault = function (key, d) { // nargs: 1 2\n",
       "    if (this.constructor !== Object) return this.setdefault.apply(this, arguments);\n",
       "    if (this[key] !== undefined) {return this[key];}\n",
       "    else if (d !== undefined) { this[key] = d; return d;}\n",
       "    else {return null;}\n",
       "};\n",
       "var _pymeth_sort = function (key, reverse) { // nargs: 0 1 2\n",
       "    if (!Array.isArray(this)) return this.sort.apply(this, arguments);\n",
       "    var comp = function (a, b) {a = key(a); b = key(b);\n",
       "        if (a<b) {return -1;} if (a>b) {return 1;} return 0;};\n",
       "    comp = Boolean(key) ? comp : undefined; \n",
       "    this.sort(comp);\n",
       "    if (reverse) this.reverse();\n",
       "};\n",
       "var _pymeth_split = function (sep, count) { // nargs: 0, 1 2\n",
       "    if (this.constructor !== String) return this.split.apply(this, arguments);\n",
       "    if (sep === '') {var e = Error('empty sep'); e.name='ValueError'; throw e;}\n",
       "    sep = (sep === undefined) ? /\\s/ : sep;\n",
       "    if (count === undefined) { return this.split(sep); }\n",
       "    var res = [], i = 0, index1 = 0, index2 = 0;\n",
       "    while (i < count && index1 < this.length) {\n",
       "        index2 = this.indexOf(sep, index1);\n",
       "        if (index2 < 0) { break; }\n",
       "        res.push(this.slice(index1, index2));\n",
       "        index1 = index2 + sep.length || 1;\n",
       "        i += 1;\n",
       "    }\n",
       "    res.push(this.slice(index1));\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_splitlines = function (keepends) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.splitlines.apply(this, arguments);\n",
       "    keepends = keepends ? 1 : 0\n",
       "    var finder = /\\r\\n|\\r|\\n/g;\n",
       "    var i = 0, i2, isrn, parts = [];\n",
       "    while (finder.exec(this) !== null) {\n",
       "        i2 = finder.lastIndex -1;\n",
       "        isrn = i2 > 0 && this[i2-1] == '\\r' && this[i2] == '\\n';\n",
       "        if (keepends) parts.push(this.slice(i, finder.lastIndex));\n",
       "        else parts.push(this.slice(i, i2 - isrn));\n",
       "        i = finder.lastIndex;\n",
       "    }\n",
       "    if (i < this.length) parts.push(this.slice(i));\n",
       "    else if (!parts.length) parts.push('');\n",
       "    return parts;\n",
       "};\n",
       "var _pymeth_startswith = function (x) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.startswith.apply(this, arguments);\n",
       "    return this.indexOf(x) == 0;\n",
       "};\n",
       "var _pymeth_strip = function (chars) { // nargs: 0 1\n",
       "    if (this.constructor !== String) return this.strip.apply(this, arguments);\n",
       "    chars = (chars === undefined) ? ' \\t\\r\\n' : chars;\n",
       "    var i, s1 = this, s2 = '', s3 = '';\n",
       "    for (i=0; i<s1.length; i++) {\n",
       "        if (chars.indexOf(s1[i]) < 0) {s2 = s1.slice(i); break;}\n",
       "    } for (i=s2.length-1; i>=0; i--) {\n",
       "        if (chars.indexOf(s2[i]) < 0) {s3 = s2.slice(0, i+1); break;}\n",
       "    } return s3;\n",
       "};\n",
       "var _pymeth_swapcase = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.swapcase.apply(this, arguments);\n",
       "    var c, res = [];\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        c = this[i];\n",
       "        if (c.toUpperCase() == c) res.push(c.toLowerCase());\n",
       "        else res.push(c.toUpperCase());\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_title = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.title.apply(this, arguments);\n",
       "    var i0, res = [], tester = /^[^A-Za-z]?[A-Za-z]$/;\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        i0 = Math.max(0, i-1);\n",
       "        if (tester.test(this.slice(i0, i+1))) res.push(this[i].toUpperCase());\n",
       "        else res.push(this[i].toLowerCase());\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_translate = function (table) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.translate.apply(this, arguments);\n",
       "    var c, res = [];\n",
       "    for (var i=0; i<this.length; i++) {\n",
       "        c = table[this[i]];\n",
       "        if (c === undefined) res.push(this[i]);\n",
       "        else if (c !== null) res.push(c);\n",
       "    } return res.join('');\n",
       "};\n",
       "var _pymeth_update = function (other) { // nargs: 1\n",
       "    if (this.constructor !== Object) return this.update.apply(this, arguments);\n",
       "    var key, keys = Object.keys(other);\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; this[key] = other[key];}\n",
       "    return null;\n",
       "};\n",
       "var _pymeth_upper = function () { // nargs: 0\n",
       "    if (this.constructor !== String) return this.upper.apply(this, arguments);\n",
       "    return this.toUpperCase();\n",
       "};\n",
       "var _pymeth_values = function () { // nargs: 0\n",
       "    if (this.constructor !== Object) return this.values.apply(this, arguments);\n",
       "    var key, keys = Object.keys(this), res = [];\n",
       "    for (var i=0; i<keys.length; i++) {key = keys[i]; res.push(this[key]);}\n",
       "    return res;\n",
       "};\n",
       "var _pymeth_zfill = function (width) { // nargs: 1\n",
       "    if (this.constructor !== String) return this.zfill.apply(this, arguments);\n",
       "    return _pymeth_rjust.call(this, width, '0');\n",
       "};\n",
       "\n",
       "return {_pyfunc_perf_counter: _pyfunc_perf_counter, _pyfunc_time: _pyfunc_time, _pyfunc_op_instantiate: _pyfunc_op_instantiate, _pyfunc_merge_dicts: _pyfunc_merge_dicts, _pyfunc_op_parse_kwargs: _pyfunc_op_parse_kwargs, _pyfunc_op_error: _pyfunc_op_error, _pyfunc_hasattr: _pyfunc_hasattr, _pyfunc_getattr: _pyfunc_getattr, _pyfunc_setattr: _pyfunc_setattr, _pyfunc_delattr: _pyfunc_delattr, _pyfunc_dict: _pyfunc_dict, _pyfunc_list: _pyfunc_list, _pyfunc_range: _pyfunc_range, _pyfunc_pow: _pyfunc_pow, _pyfunc_sum: _pyfunc_sum, _pyfunc_round: _pyfunc_round, _pyfunc_int: _pyfunc_int, _pyfunc_float: _pyfunc_float, _pyfunc_str: _pyfunc_str, _pyfunc_repr: _pyfunc_repr, _pyfunc_bool: _pyfunc_bool, _pyfunc_abs: _pyfunc_abs, _pyfunc_divmod: _pyfunc_divmod, _pyfunc_all: _pyfunc_all, _pyfunc_any: _pyfunc_any, _pyfunc_enumerate: _pyfunc_enumerate, _pyfunc_zip: _pyfunc_zip, _pyfunc_reversed: _pyfunc_reversed, _pyfunc_sorted: _pyfunc_sorted, _pyfunc_filter: _pyfunc_filter, _pyfunc_map: _pyfunc_map, _pyfunc_truthy: _pyfunc_truthy, _pyfunc_op_equals: _pyfunc_op_equals, _pyfunc_op_contains: _pyfunc_op_contains, _pyfunc_op_add: _pyfunc_op_add, _pyfunc_op_mult: _pyfunc_op_mult, _pymeth_append: _pymeth_append, _pymeth_extend: _pymeth_extend, _pymeth_insert: _pymeth_insert, _pymeth_remove: _pymeth_remove, _pymeth_reverse: _pymeth_reverse, _pymeth_sort: _pymeth_sort, _pymeth_clear: _pymeth_clear, _pymeth_copy: _pymeth_copy, _pymeth_pop: _pymeth_pop, _pymeth_count: _pymeth_count, _pymeth_index: _pymeth_index, _pymeth_get: _pymeth_get, _pymeth_items: _pymeth_items, _pymeth_keys: _pymeth_keys, _pymeth_popitem: _pymeth_popitem, _pymeth_setdefault: _pymeth_setdefault, _pymeth_update: _pymeth_update, _pymeth_values: _pymeth_values, _pymeth_repeat: _pymeth_repeat, _pymeth_capitalize: _pymeth_capitalize, _pymeth_casefold: _pymeth_casefold, _pymeth_center: _pymeth_center, _pymeth_endswith: _pymeth_endswith, _pymeth_expandtabs: _pymeth_expandtabs, _pymeth_find: _pymeth_find, _pymeth_isalnum: _pymeth_isalnum, _pymeth_isalpha: _pymeth_isalpha, _pymeth_isidentifier: _pymeth_isidentifier, _pymeth_islower: _pymeth_islower, _pymeth_isnumeric: _pymeth_isnumeric, _pymeth_isspace: _pymeth_isspace, _pymeth_istitle: _pymeth_istitle, _pymeth_isupper: _pymeth_isupper, _pymeth_join: _pymeth_join, _pymeth_ljust: _pymeth_ljust, _pymeth_lower: _pymeth_lower, _pymeth_lstrip: _pymeth_lstrip, _pymeth_partition: _pymeth_partition, _pymeth_replace: _pymeth_replace, _pymeth_rfind: _pymeth_rfind, _pymeth_rindex: _pymeth_rindex, _pymeth_rjust: _pymeth_rjust, _pymeth_rpartition: _pymeth_rpartition, _pymeth_rsplit: _pymeth_rsplit, _pymeth_rstrip: _pymeth_rstrip, _pymeth_split: _pymeth_split, _pymeth_splitlines: _pymeth_splitlines, _pymeth_startswith: _pymeth_startswith, _pymeth_strip: _pymeth_strip, _pymeth_swapcase: _pymeth_swapcase, _pymeth_title: _pymeth_title, _pymeth_translate: _pymeth_translate, _pymeth_upper: _pymeth_upper, _pymeth_zfill: _pymeth_zfill};\n",
       "});\n",
       "\n",
       "\n",
       "/* =========================== flexx.event.js ===========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "flexx.define(\"flexx.event.js\", [\"pscript-std.js\"], function (_py) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_getattr = _py._pyfunc_getattr, _pyfunc_all = _py._pyfunc_all, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_op_parse_kwargs = _py._pyfunc_op_parse_kwargs, _pyfunc_dict = _py._pyfunc_dict, _pyfunc_bool = _py._pyfunc_bool, _pyfunc_op_mult = _py._pyfunc_op_mult, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_truthy = _py._pyfunc_truthy, _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_str = _py._pyfunc_str, _pyfunc_float = _py._pyfunc_float, _pyfunc_hasattr = _py._pyfunc_hasattr, _pyfunc_range = _py._pyfunc_range, _pyfunc_repr = _py._pyfunc_repr, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_int = _py._pyfunc_int, _pyfunc_setattr = _py._pyfunc_setattr, _pyfunc_list = _py._pyfunc_list;\n",
       "var _pymeth_join = _py._pymeth_join, _pymeth_sort = _py._pymeth_sort, _pymeth_split = _py._pymeth_split, _pymeth_lstrip = _py._pymeth_lstrip, _pymeth_rstrip = _py._pymeth_rstrip, _pymeth_clear = _py._pymeth_clear, _pymeth_endswith = _py._pymeth_endswith, _pymeth_pop = _py._pymeth_pop, _pymeth_startswith = _py._pymeth_startswith, _pymeth_partition = _py._pymeth_partition, _pymeth_repeat = _py._pymeth_repeat, _pymeth_copy = _py._pymeth_copy, _pymeth_upper = _py._pymeth_upper, _pymeth_get = _py._pymeth_get, _pymeth_append = _py._pymeth_append, _pymeth_lower = _py._pymeth_lower, _pymeth_insert = _py._pymeth_insert, _pymeth_strip = _py._pymeth_strip, _pymeth_replace = _py._pymeth_replace;\n",
       "var _mutate_array_js;\n",
       "_mutate_array_js = function flx__mutate_array_js (array, ev) {\n",
       "\tvar err_3, index, is_nd, mutation, objects;\n",
       "\tis_nd = _pyfunc_hasattr(array, \"shape\") && _pyfunc_hasattr(array, \"dtype\");\n",
       "\tmutation = ev.mutation;\n",
       "\tindex = ev.index;\n",
       "\tobjects = ev.objects;\n",
       "\tif ((is_nd === true)) {\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot set nd array in-place\");\n",
       "\t\t} else if (_pyfunc_op_contains(mutation, [\"extend\", \"insert\", \"remove\"])) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot resize nd arrays\");\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"replace\")) {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', \"Cannot replace items in nd array\");\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\t\tif (!(Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'number')) { throw _pyfunc_op_error('AssertionError', \"Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'number'\");}\n",
       "\t\t} else if ((!Array.isArray(objects))) {\n",
       "\t\t\tthrow _pyfunc_op_error('TypeError', \"Inplace list/array mutating requires a list of objects.\");\n",
       "\t\t}\n",
       "\t\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([0, array.length], objects));\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"insert\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([index, 0], objects));\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\t\tarray.splice(index, objects);\n",
       "\t\t} else if (_pyfunc_op_equals(mutation, \"replace\")) {\n",
       "\t\t\tarray.splice.apply(array, [].concat([index, objects.length], objects));\n",
       "\t\t} else {\n",
       "\t\t\tthrow _pyfunc_op_error('NotImplementedError', mutation);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var mutate_array = _mutate_array_js;\n",
       "var mutate_dict;\n",
       "mutate_dict = function flx_mutate_dict (d, ev) {\n",
       "\tvar err_2, key, mutation, objects, stub1_seq, stub2_seq, stub3_itr, val;\n",
       "\tmutation = ev[\"mutation\"];\n",
       "\tobjects = ev[\"objects\"];\n",
       "\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\t_pymeth_clear.call(d);\n",
       "\t} else if (_pyfunc_op_contains(mutation, [\"set\", \"insert\", \"replace\"])) {\n",
       "\t\tif (!(Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'object')) { throw _pyfunc_op_error('AssertionError', \"Object.prototype.toString.call(objects).slice(8,-1).toLowerCase() === 'object'\");}\n",
       "\t\tstub1_seq = objects;\n",
       "\t\tfor (key in stub1_seq) {\n",
       "\t\t\tif (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "\t\t\tval = stub1_seq[key];\n",
       "\t\t\td[key] = val;\n",
       "\t\t}\n",
       "\t} else if (_pyfunc_op_equals(mutation, \"remove\")) {\n",
       "\t\tif (!(Array.isArray(objects))) { throw _pyfunc_op_error('AssertionError', \"Array.isArray(objects)\");}\n",
       "\t\tstub2_seq = objects;\n",
       "\t\tif ((typeof stub2_seq === \"object\") && (!Array.isArray(stub2_seq))) { stub2_seq = Object.keys(stub2_seq);}\n",
       "\t\tfor (stub3_itr = 0; stub3_itr < stub2_seq.length; stub3_itr += 1) {\n",
       "\t\t\tkey = stub2_seq[stub3_itr];\n",
       "\t\t\t_pymeth_pop.call(d, key);\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('NotImplementedError', mutation);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var Logger = function () {\n",
       "\tthis.level = 25;\n",
       "}\n",
       "var $Logger = Logger.prototype;\n",
       "$Logger.debug = function (msg) {\n",
       "\tif (this.level <= 10) { console.info(msg); }\n",
       "};\n",
       "$Logger.info = function (msg) {\n",
       "\tif (this.level <= 20) { console.info(msg); }\n",
       "};\n",
       "$Logger.warn = function (msg) {\n",
       "\tif (this.level <= 30) { console.warn(msg); }\n",
       "};\n",
       "$Logger.exception = function (msg) {\n",
       "\tconsole.error(msg);\n",
       "};\n",
       "$Logger.error = function (msg) {\n",
       "\tconsole.error(msg);\n",
       "};\n",
       "var logger = new Logger();\n",
       "var Loop;\n",
       "Loop = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "var $Loop = Loop.prototype;\n",
       "$Loop.__init__ = function () {\n",
       "\tthis._active_components = [];\n",
       "\tthis.reset();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._call_soon_func = function (func) {\n",
       "\tsetTimeout(func, 0);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._iter_callback = function () {\n",
       "\tthis._scheduled_call_to_iter = false;\n",
       "\treturn this.iter();\n",
       "};\n",
       "\n",
       "\n",
       "$Loop.__enter__ = function () {\n",
       "\treturn this;\n",
       "};\n",
       "\n",
       "$Loop.__exit__ = function (type, value, traceback) {\n",
       "\tthis.iter();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._activate_component = function (component) {\n",
       "\t_pymeth_append.call(this._active_components, component);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._deactivate_component = function (component) {\n",
       "\tvar err_2, top;\n",
       "\ttop = _pymeth_pop.call(this._active_components, (-1));\n",
       "\tif ((top !== component)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', (\"loop._deactivate_component: \" + component.id + \" is not \" + (_pyfunc_truthy(top) && _pyfunc_truthy(top.id)) + \"\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_actions = function (n) {\n",
       "\tvar action, args, err, i, pending_actions, stub1_err, stub2_;\n",
       "\tn = (n === undefined) ? null: n;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tif ((n === null)) {\n",
       "\t\t\tpending_actions = this._pending_actions;\n",
       "\t\t\tthis._pending_actions = [];\n",
       "\t\t} else {\n",
       "\t\t\tpending_actions = this._pending_actions.slice(0,n);\n",
       "\t\t\tthis._pending_actions = this._pending_actions.slice(n);\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < pending_actions.length; i += 1) {\n",
       "\t\tstub2_ = pending_actions[i];\n",
       "\t\taction = stub2_[0];args = stub2_[1];\n",
       "\t\tthis._processing_action = action;\n",
       "\t\ttry {\n",
       "\t\t\taction.apply(null, args);\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t} finally {\n",
       "\t\t\tthis._processing_action = null;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_calls = function () {\n",
       "\tvar args, err, func, i, pending_calls, stub1_err, stub2_;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tpending_calls = this._pending_calls;\n",
       "\t\tthis._pending_calls = [];\n",
       "\t}\n",
       "\tfor (i = 0; i < pending_calls.length; i += 1) {\n",
       "\t\tstub2_ = pending_calls[i];\n",
       "\t\tfunc = stub2_[0];args = stub2_[1];\n",
       "\t\ttry {\n",
       "\t\t\tfunc.apply(null, args);\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._process_reactions = function () {\n",
       "\tvar _, component, component_names, connections, err, events, ir, name, pending_reactions, reaction, stub1_err, stub2_, stub3_seq, stub4_seq;\n",
       "\t{/* with lock */\n",
       "\t\t\t\tpending_reactions = this._pending_reactions;\n",
       "\t\tthis._pending_reactions = [];\n",
       "\t\tthis._pending_reaction_ids = ({});\n",
       "\t}\n",
       "\tfor (ir = 0; ir < pending_reactions.length; ir += 1) {\n",
       "\t\tstub2_ = pending_reactions[ir];\n",
       "\t\treaction = stub2_[0];_ = stub2_[1];events = stub2_[2];\n",
       "\t\tif (((events.length > 0) || (_pyfunc_op_equals(reaction.get_mode(), \"auto\")))) {\n",
       "\t\t\tthis._prop_access = ({});\n",
       "\t\t\tthis._processing_reaction = reaction;\n",
       "\t\t\ttry {\n",
       "\t\t\t\treaction.apply(null, events);\n",
       "\t\t\t} catch(err_4) {\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\terr = err_4;\n",
       "\t\t\t\t\tlogger.exception(err);\n",
       "\t\t\t\t}\n",
       "\t\t\t} finally {\n",
       "\t\t\t\tthis._processing_reaction = null;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\ttry {\n",
       "\t\t\tif ((_pyfunc_op_equals(reaction.get_mode(), \"auto\"))) {\n",
       "\t\t\t\tconnections = [];\n",
       "\t\t\t\tstub4_seq = this._prop_access;\n",
       "\t\t\t\tfor (component_names in stub4_seq) {\n",
       "\t\t\t\t\tif (!stub4_seq.hasOwnProperty(component_names)){ continue; }\n",
       "\t\t\t\t\tcomponent_names = stub4_seq[component_names];\n",
       "\t\t\t\t\tcomponent = component_names[0];\n",
       "\t\t\t\t\tstub3_seq = component_names[1];\n",
       "\t\t\t\t\tfor (name in stub3_seq) {\n",
       "\t\t\t\t\t\tif (!stub3_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\t\t\t\t\t_pymeth_append.call(connections, [component, name]);\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t}\n",
       "\t\t\t\treaction._update_implicit_connections(connections);\n",
       "\t\t\t}\n",
       "\t\t} catch(err_3) {\n",
       "\t\t\t{\n",
       "\t\t\t\terr = err_3;\n",
       "\t\t\t\tlogger.exception(err);\n",
       "\t\t\t}\n",
       "\t\t} finally {\n",
       "\t\t\tthis._prop_access = ({});\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop._schedule_iter = function () {\n",
       "\tif ((this._scheduled_call_to_iter === false)) {\n",
       "\t\tthis._scheduled_call_to_iter = true;\n",
       "\t\tthis._call_soon_func(this._iter_callback);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.add_action_invokation = function (action, args) {\n",
       "\tvar stub1_err;\n",
       "\t{/* with lock */\n",
       "\t\t_pymeth_append.call(this._pending_actions, [action, args]);\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.add_reaction_event = function (reaction, ev) {\n",
       "\tvar ev2, i, mode, new_item, pending_reactions, stub1_err;\n",
       "\tpending_reactions = this._pending_reactions;\n",
       "\tmode = reaction.get_mode();\n",
       "\t{/* with lock */\n",
       "\t\t\t\tif (_pyfunc_op_equals(mode, \"normal\")) {\n",
       "\t\t\ti = pending_reactions.length;\n",
       "\t\t\twhile (i > 0) {\n",
       "\t\t\t\ti -= 1;\n",
       "\t\t\t\tev2 = pending_reactions[i][1];\n",
       "\t\t\t\tif (((pending_reactions[i][0]) === reaction)) {\n",
       "\t\t\t\t\t_pymeth_append.call((pending_reactions[i][2]), ev);\n",
       "\t\t\t\t\tif ((!((ev2[\"source\"] === ev[\"source\"]) && _pyfunc_op_equals(ev2[\"type\"], ev[\"type\"])))) {\n",
       "\t\t\t\t\t\tpending_reactions[i][1] = ({source: null});\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t\treturn null;\n",
       "\t\t\t\t}\n",
       "\t\t\t\tif ((!((ev2 === null) || ((ev2[\"source\"] === ev[\"source\"]) && _pyfunc_op_equals(ev2.type, ev.type))))) {\n",
       "\t\t\t\t\tbreak;\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t} else if (_pyfunc_op_contains(reaction._id, this._pending_reaction_ids)) {\n",
       "\t\t\tif ((reaction._connections.length > 0)) {\n",
       "\t\t\t\t_pymeth_append.call((this._pending_reaction_ids[reaction._id][2]), ev);\n",
       "\t\t\t}\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((reaction._connections.length > 0)) {\n",
       "\t\t\tnew_item = [reaction, ev, [ev]];\n",
       "\t\t} else {\n",
       "\t\t\tnew_item = [reaction, null, []];\n",
       "\t\t}\n",
       "\t\t_pymeth_append.call(pending_reactions, new_item);\n",
       "\t\tthis._pending_reaction_ids[reaction._id] = new_item;\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.call_soon = function (func) {\n",
       "\tvar args, stub1_err;\n",
       "\targs = Array.prototype.slice.call(arguments, 1);\n",
       "\t{/* with lock */\n",
       "\t\t_pymeth_append.call(this._pending_calls, [func, args]);\n",
       "\t\tthis._schedule_iter();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.can_mutate = function (component) {\n",
       "\tvar active;\n",
       "\tcomponent = (component === undefined) ? null: component;\n",
       "\tactive = this.get_active_component();\n",
       "\tif ((active !== null)) {\n",
       "\t\treturn active === component;\n",
       "\t} else {\n",
       "\t\treturn this._processing_action !== null;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.get_active_component = function () {\n",
       "\tif ((this._active_components.length > 0)) {\n",
       "\t\treturn this._active_components[this._active_components.length -1];\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.get_active_components = function () {\n",
       "\treturn _pyfunc_list(this._active_components);\n",
       "};\n",
       "\n",
       "$Loop.has_pending = function () {\n",
       "\treturn (this._pending_reactions.length > 0) || (this._pending_actions.length > 0) || (this._pending_calls.length > 0);\n",
       "};\n",
       "\n",
       "$Loop.iter = function () {\n",
       "\tvar err_2, stub1_err;\n",
       "\t{/* with lock */\n",
       "\t\t\t}\n",
       "\tif ((this._in_iter === true)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"Cannot call flexx.event.loop.iter() while it is processing.\");\n",
       "\t}\n",
       "\tthis._in_iter = true;\n",
       "\ttry {\n",
       "\t\tthis._process_calls();\n",
       "\t\tthis._process_actions();\n",
       "\t\tthis._process_reactions();\n",
       "\t} finally {\n",
       "\t\tthis._in_iter = false;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.register_prop_access = function (component, prop_name) {\n",
       "\tvar d;\n",
       "\tif ((this._processing_reaction !== null)) {\n",
       "\t\tif ((_pyfunc_op_equals(this._processing_reaction.get_mode(), \"auto\"))) {\n",
       "\t\t\t {\n",
       "\t\t\t\tif ((!_pyfunc_op_contains(component._id, this._prop_access))) {\n",
       "\t\t\t\t\td = ({});\n",
       "\t\t\t\t\tthis._prop_access[component._id] = [component, d];\n",
       "\t\t\t\t} else {\n",
       "\t\t\t\t\td = this._prop_access[component._id][1];\n",
       "\t\t\t\t}\n",
       "\t\t\t\td[prop_name] = true;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Loop.reset = function () {\n",
       "\tthis._in_iter = false;\n",
       "\tthis._scheduled_call_to_iter = false;\n",
       "\tthis._processing_action = null;\n",
       "\tthis._processing_reaction = null;\n",
       "\tthis._prop_access = ({});\n",
       "\tthis._pending_calls = [];\n",
       "\tthis._pending_actions = [];\n",
       "\tthis._pending_reactions = [];\n",
       "\tthis._pending_reaction_ids = ({});\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "var loop = new Loop();\n",
       "var Component;\n",
       "Component = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "var $Component = Component.prototype;\n",
       "$Component._base_class = Object;\n",
       "$Component.__name__ = \"Component\";\n",
       "\n",
       "$Component._IS_COMPONENT = true;\n",
       "$Component._COUNT = 0;\n",
       "$Component._REACTION_COUNT = 0;\n",
       "$Component.__init__ = function () {\n",
       "\tvar i, init_args, name, property_values, stub1_err;\n",
       "\tproperty_values = {};\n",
       "\tif (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "\t\tproperty_values = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "\t\tinit_args = arguments[0].flx_args;\n",
       "\t} else {init_args = Array.prototype.slice.call(arguments);}\n",
       "\t$Component._COUNT += 1;\n",
       "\tthis._id = this.__name__ + $Component._COUNT;\n",
       "\tthis._disposed = false;\n",
       "\tthis._Component__handlers = ({});\n",
       "\tthis._Component__pending_events = [];\n",
       "\tthis._Component__anonymous_reactions = [];\n",
       "\tthis._Component__initial_mutation = false;\n",
       "\tfor (i = 0; i < this.__actions__.length; i += 1) {\n",
       "\t\tname = this.__actions__[i];\n",
       "\t\tthis._Component__create_action(this[name], name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__emitters__.length; i += 1) {\n",
       "\t\tname = this.__emitters__[i];\n",
       "\t\tthis._Component__handlers[name] = [];\n",
       "\t\tthis._Component__create_emitter(this[name], name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__properties__.length; i += 1) {\n",
       "\t\tname = this.__properties__[i];\n",
       "\t\tthis._Component__handlers[name] = [];\n",
       "\t\tthis._Component__create_property(name);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__attributes__.length; i += 1) {\n",
       "\t\tname = this.__attributes__[i];\n",
       "\t\tthis._Component__create_attribute(name);\n",
       "\t}\n",
       "\tthis.__enter__();\n",
       "\ttry {\n",
       "\t\tthis._comp_init_property_values(property_values);\n",
       "\t\tthis.init.apply(this, init_args);\n",
       "\t} catch(err_1)  { stub1_err=err_1; }\n",
       "\tif (stub1_err) { if (!this.__exit__(stub1_err.name || \"error\", stub1_err, null)) { throw stub1_err; }\n",
       "\t} else { this.__exit__(null, null, null); }\n",
       "\tthis._comp_init_reactions();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_init_property_values = function (property_values) {\n",
       "\tvar err_4, i, name, stub2_seq, value, values;\n",
       "\tvalues = [];\n",
       "\tfor (i = 0; i < this.__properties__.length; i += 1) {\n",
       "\t\tname = this.__properties__[i];\n",
       "\t\tif ((!_pyfunc_op_contains(name, property_values))) {\n",
       "\t\t\t_pymeth_append.call(values, ([name, this[(\"_\" + name) + \"_value\"]]));\n",
       "\t\t}\n",
       "\t}\n",
       "\tstub2_seq = property_values;\n",
       "\tfor (name in stub2_seq) {\n",
       "\t\tif (!stub2_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\tvalue = stub2_seq[name];\n",
       "\t\tif ((!_pyfunc_op_contains(name, this.__properties__))) {\n",
       "\t\t\tif (_pyfunc_op_contains(name, this.__attributes__)) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + this._id + \".\" + name + \" is an attribute, not a property\"));\n",
       "\t\t\t} else {\n",
       "\t\t\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + this._id + \" does not have property \" + name + \".\"));\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tif ((typeof value === \"function\")) {\n",
       "\t\t\tthis._comp_make_implicit_setter(name, value);\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\t_pymeth_append.call(values, [name, value]);\n",
       "\t}\n",
       "\tthis._comp_apply_property_values(values);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_make_implicit_setter = function (prop_name, func) {\n",
       "\tvar err_2, reaction, setter_func, setter_reaction, t;\n",
       "\tsetter_func = _pyfunc_getattr(this, (\"set_\" + prop_name), null);\n",
       "\tif ((setter_func === null)) {\n",
       "\t\tt = \"%s does not have a set_%s() action for property %s.\";\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (t % [this._id, prop_name, prop_name]));\n",
       "\t}\n",
       "\tsetter_reaction = (function () {return setter_func(func());}).bind(this);\n",
       "\treaction = this._Component__create_reaction(setter_reaction, \"auto-\" + prop_name, \"auto\", []);\n",
       "\t_pymeth_append.call(this._Component__anonymous_reactions, reaction);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_init_reactions = function () {\n",
       "\tvar ev, func, i, name, r;\n",
       "\tif ((this._Component__pending_events !== null)) {\n",
       "\t\t_pymeth_append.call(this._Component__pending_events, null);\n",
       "\t\tloop.call_soon(this._comp_stop_capturing_events);\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__reactions__.length; i += 1) {\n",
       "\t\tname = this.__reactions__[i];\n",
       "\t\tfunc = this[name];\n",
       "\t\tr = this._Component__create_reaction(func, name, func._mode, _pyfunc_truthy(func._connection_strings) || []);\n",
       "\t\tif ((_pyfunc_op_equals(r.get_mode(), \"auto\"))) {\n",
       "\t\t\tev = {source:this, type:\"\", label:\"\"};\n",
       "\t\t\tloop.add_reaction_event(r, ev);\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < this._Component__anonymous_reactions.length; i += 1) {\n",
       "\t\tr = this._Component__anonymous_reactions[i];\n",
       "\t\tif ((_pyfunc_op_equals(r.get_mode(), \"auto\"))) {\n",
       "\t\t\tev = {source:this, type:\"\", label:\"\"};\n",
       "\t\t\tloop.add_reaction_event(r, ev);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.reaction = function () {\n",
       "\tvar connection_strings, err_2, err_3, func, i, mode, name, nameparts, s;\n",
       "\tconnection_strings = Array.prototype.slice.call(arguments);\n",
       "\tif ((connection_strings.length < 2)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"Component.reaction() (js) needs a function and one or more connection strings.\");\n",
       "\t}\n",
       "\tif ((typeof connection_strings[0] === \"function\")) {\n",
       "\t\tfunc = connection_strings[0];\n",
       "\t\tconnection_strings = connection_strings.slice(1);\n",
       "\t} else if ((typeof connection_strings[connection_strings.length -1] === \"function\")) {\n",
       "\t\tfunc = connection_strings[connection_strings.length -1];\n",
       "\t\tconnection_strings = connection_strings.slice(0,-1);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"Component.reaction() requires a callable.\");\n",
       "\t}\n",
       "\tfor (i = 0; i < connection_strings.length; i += 1) {\n",
       "\t\ts = connection_strings[i];\n",
       "\t\tif ((!(((Object.prototype.toString.call(s).slice(8,-1).toLowerCase() === 'string')) && s.length))) {\n",
       "\t\t\tthrow _pyfunc_op_error('ValueError', \"Connection string must be nonempty strings.\");\n",
       "\t\t}\n",
       "\t}\n",
       "\tname = func.__name__ || func.name || 'anonymous';\n",
       "\tnameparts = name.split(' ');\n",
       "\tnameparts = nameparts[nameparts.length-1].split('flx_');\n",
       "\tname = nameparts[nameparts.length -1];\n",
       "\tmode = \"normal\";\n",
       "\treturn this._Component__create_reaction_ob(func, name, mode, connection_strings);\n",
       "};\n",
       "\n",
       "$Component._Component__create_action = function (action_func, name) {\n",
       "\tvar action, getter, opts, setter;\n",
       "\taction = (function flx_action () {\n",
       "\t\tvar res;\n",
       "\t\tif ((loop.can_mutate(this) === true)) {\n",
       "\t\t\tres = action_func.apply(this, arguments);\n",
       "\t\t\tif ((res !== null)) {\n",
       "\t\t\t\tlogger.warn(\"Action (\" + name + \") is not supposed to return a value\");\n",
       "\t\t\t}\n",
       "\t\t} else {\n",
       "\t\t\tloop.add_action_invokation(action, arguments);\n",
       "\t\t}\n",
       "\t\treturn this;\n",
       "\t}).bind(this);\n",
       "\n",
       "\taction.is_autogenerated = _pyfunc_op_equals(action_func.name, \"flx_setter\");\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn action;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Action \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_attribute = function (name) {\n",
       "\tvar getter, opts, setter;\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn this[\"_\" + name];\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Cannot set attribute \" + _pyfunc_repr(name) + \"\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: false, configurable: false, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_property = function (name) {\n",
       "\tvar getter, opts, private_name, setter;\n",
       "\tprivate_name = (\"_\" + name) + \"_value\";\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\tloop.register_prop_access(this, name);\n",
       "\t\treturn this[private_name];\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Cannot set property \" + _pyfunc_repr(name) + \"; properties can only be mutated by actions.\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_emitter = function (emitter_func, name) {\n",
       "\tvar func, getter, opts, setter;\n",
       "\tfunc = (function flx_func () {\n",
       "\t\tvar ev;\n",
       "\t\tev = emitter_func.apply(this, arguments);\n",
       "\t\tif ((ev !== null)) {\n",
       "\t\t\tthis.emit(name, ev);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn func;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Emitter \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._Component__create_reaction = function (reaction_func, name, mode, c_strings) {\n",
       "\tvar getter, opts, reaction, setter;\n",
       "\treaction = this._Component__create_reaction_ob(reaction_func, name, mode, c_strings);\n",
       "\tgetter = (function flx_getter () {\n",
       "\t\treturn reaction;\n",
       "\t}).bind(this);\n",
       "\n",
       "\tsetter = (function flx_setter (x) {\n",
       "\t\tvar err_2;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Reaction \" + name + \" is not settable\"));\n",
       "\t\treturn null;\n",
       "\t}).bind(this);\n",
       "\n",
       "\topts = ({enumerable: true, configurable: true, get: getter, set: setter});\n",
       "\tObject.defineProperty(this, name, opts);\n",
       "\treturn reaction;\n",
       "};\n",
       "\n",
       "$Component._Component__create_reaction_ob = function (reaction_func, name, mode, connection_strings) {\n",
       "\tvar reaction, that;\n",
       "\treaction = (function flx_reaction () {\n",
       "\t\treturn reaction_func.apply(this, arguments);\n",
       "\t}).bind(this);\n",
       "\n",
       "\t\n",
       "\treaction._clear_component_refs = function (ob) {\n",
       "\t\tvar connection, i, ic;\n",
       "\t\tfor (i = this._implicit_connections.length - 1; i > -1; i += -1) {\n",
       "\t\t\tif (((this._implicit_connections[i][0]) === ob)) {\n",
       "\t\t\t\t_pymeth_pop.call(this._implicit_connections, i);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tconnection = this._connections[ic];\n",
       "\t\t\tfor (i = connection.objects.length - 1; i > -1; i += -1) {\n",
       "\t\t\t\tif (((connection.objects[i][0]) === ob)) {\n",
       "\t\t\t\t\t_pymeth_pop.call(connection.objects, i);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._connect_and_disconnect = function (old_objects, new_objects, force) {\n",
       "\t\tvar i, i1, i2, i3, ob, stub1_, stub2_, stub3_, type;\n",
       "\t\tforce = (force === undefined) ? false: force;\n",
       "\t\ti1 = 0;\n",
       "\t\twhile ((i1 < new_objects.length) && (i1 < old_objects.length) && (((new_objects[i1][0]) === (old_objects[i1][0]))) && ((_pyfunc_op_equals((new_objects[i1][1]), (old_objects[i1][1]))))) {\n",
       "\t\t\ti1 = _pyfunc_op_add(i1, 1);\n",
       "\t\t}\n",
       "\t\tstub1_ = [new_objects.length - 1, old_objects.length - 1];\n",
       "\t\ti2 = stub1_[0];i3 = stub1_[1];\n",
       "\t\twhile ((i2 >= i1) && (i3 >= i1) && (((new_objects[i2][0]) === (old_objects[i3][0]))) && ((_pyfunc_op_equals((new_objects[i2][1]), (old_objects[i3][1]))))) {\n",
       "\t\t\ti2 -= 1;\n",
       "\t\t\ti3 -= 1;\n",
       "\t\t}\n",
       "\t\tfor (i = i1; i < i3 + 1; i += 1) {\n",
       "\t\t\tstub2_ = old_objects[i];\n",
       "\t\t\tob = stub2_[0];type = stub2_[1];\n",
       "\t\t\tob.disconnect(type, this);\n",
       "\t\t}\n",
       "\t\tfor (i = i1; i < i2 + 1; i += 1) {\n",
       "\t\t\tstub3_ = new_objects[i];\n",
       "\t\t\tob = stub3_[0];type = stub3_[1];\n",
       "\t\t\tob._register_reaction(type, this, force);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._init = function (connection_strings) {\n",
       "\t\tvar _, d, err_5, force, fullname, i, ic, ichars, ipart, is_identifier, label, part, parts, s, s0, stub1_;\n",
       "\t\tichars = \"0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n",
       "\t\tthis._connections = [];\n",
       "\t\tthis._implicit_connections = [];\n",
       "\t\tfor (ic = 0; ic < connection_strings.length; ic += 1) {\n",
       "\t\t\tfullname = connection_strings[ic];\n",
       "\t\t\tforce = _pymeth_startswith.call(fullname, \"!\");\n",
       "\t\t\tstub1_ = _pymeth_partition.call(_pymeth_lstrip.call(fullname, \"!\"), \":\");\n",
       "\t\t\ts = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\t\t\ts0 = s;\n",
       "\t\t\tif ((_pyfunc_op_contains(\".*.\", (s + \".\")))) {\n",
       "\t\t\t\ts = _pymeth_replace.call(s, \".*\", \"*\");\n",
       "\t\t\t\tconsole.warn(\"Connection string syntax \\\"foo.*.bar\\\" is deprecated, use \\\"\" + s + \"\\\" instead of \\\"\" + s0 + \"\\\":.\");\n",
       "\t\t\t}\n",
       "\t\t\tif (_pyfunc_op_contains(\"!\", s)) {\n",
       "\t\t\t\ts = _pymeth_replace.call(s, \"!\", \"\");\n",
       "\t\t\t\tforce = true;\n",
       "\t\t\t\tconsole.warn(\"Exclamation marks in connection strings must come at the very start, use \\\"!\" + s + \"\\\" instead of \\\"\" + s0 + \"\\\".\");\n",
       "\t\t\t}\n",
       "\t\t\tparts = _pymeth_split.call(s, \".\");\n",
       "\t\t\tfor (ipart = 0; ipart < parts.length; ipart += 1) {\n",
       "\t\t\t\tpart = _pymeth_rstrip.call(parts[ipart], \"*\");\n",
       "\t\t\t\tis_identifier = part.length > 0;\n",
       "\t\t\t\tfor (i = 0; i < part.length; i += 1) {\n",
       "\t\t\t\t\tis_identifier = _pyfunc_truthy(is_identifier) && _pyfunc_op_contains(part[i], ichars);\n",
       "\t\t\t\t}\n",
       "\t\t\t\tif ((is_identifier === false)) {\n",
       "\t\t\t\t\tthrow _pyfunc_op_error('ValueError', (\"Connection string \" + _pyfunc_repr(s) + \" contains non-identifier part \" + _pyfunc_repr(part) + \"\"));\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\td = {};\n",
       "\t\t\t_pymeth_append.call(this._connections, d);\n",
       "\t\t\td.fullname = fullname;\n",
       "\t\t\td.parts = parts;\n",
       "\t\t\td.type = _pyfunc_op_add((_pymeth_rstrip.call(parts[parts.length -1], \"*\") + \":\"), (_pyfunc_truthy(label) || this._name));\n",
       "\t\t\td.force = force;\n",
       "\t\t\td.objects = [];\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tthis.reconnect(ic);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._seek_event_object = function (index, path, ob) {\n",
       "\t\tvar connection, err_3, isub, name_label, new_ob, obname, obname_full, selector, stub1_, t;\n",
       "\t\tconnection = this._connections[index];\n",
       "\t\tif (((ob === null) || (path.length == 0))) {\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((path.length == 1)) {\n",
       "\t\t\tif (_pyfunc_hasattr(ob, \"_IS_COMPONENT\")) {\n",
       "\t\t\t\t_pymeth_append.call(connection.objects, [ob, connection.type]);\n",
       "\t\t\t}\n",
       "\t\t\tif ((!_pyfunc_truthy(_pymeth_endswith.call(path[0], \"**\")))) {\n",
       "\t\t\t\treturn null;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tstub1_ = [path[0], path.slice(1)];\n",
       "\t\tobname_full = stub1_[0];path = stub1_[1];\n",
       "\t\tobname = _pymeth_rstrip.call(obname_full, \"*\");\n",
       "\t\tselector = obname_full.slice(obname.length);\n",
       "\t\tif (_pyfunc_op_equals(selector, \"***\")) {\n",
       "\t\t\tthis._seek_event_object(index, path, ob);\n",
       "\t\t}\n",
       "\t\tif ((_pyfunc_hasattr(ob, \"_IS_COMPONENT\") && _pyfunc_op_contains(obname, ob.__properties__))) {\n",
       "\t\t\tname_label = _pyfunc_op_add((obname + \":reconnect_\"), _pyfunc_str(index));\n",
       "\t\t\t_pymeth_append.call(connection.objects, [ob, name_label]);\n",
       "\t\t\tnew_ob = _pyfunc_getattr(ob, obname, null);\n",
       "\t\t} else {\n",
       "\t\t\tnew_ob = _pyfunc_getattr(ob, obname, null);\n",
       "\t\t}\n",
       "\t\tif (_pyfunc_truthy(selector.length && _pyfunc_op_contains(selector, \"***\") && Array.isArray(new_ob))) {\n",
       "\t\t\tif ((selector.length > 1)) {\n",
       "\t\t\t\tpath = _pyfunc_op_add([obname + \"***\"], path);\n",
       "\t\t\t}\n",
       "\t\t\tfor (isub = 0; isub < new_ob.length; isub += 1) {\n",
       "\t\t\t\tthis._seek_event_object(index, path, new_ob[isub]);\n",
       "\t\t\t}\n",
       "\t\t\treturn null;\n",
       "\t\t} else if (_pyfunc_op_equals(selector, \"*\")) {\n",
       "\t\t\tt = \"Invalid connection {name_full} because {name} is not a tuple/list.\";\n",
       "\t\t\tthrow _pyfunc_op_error('RuntimeError', (_pymeth_replace.call(_pymeth_replace.call(t, \"{name_full}\", obname_full), \"{name}\", obname)));\n",
       "\t\t} else {\n",
       "\t\t\treturn this._seek_event_object(index, path, new_ob);\n",
       "\t\t}\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._update_implicit_connections = function (connections) {\n",
       "\t\tvar new_conns, old_conns;\n",
       "\t\told_conns = this._implicit_connections;\n",
       "\t\tnew_conns = connections;\n",
       "\t\tthis._implicit_connections = new_conns;\n",
       "\t\tthis._connect_and_disconnect(old_conns, new_conns);\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction._use_once = function (func) {\n",
       "\t\tthis._func_once = func;\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction.dispose = function () {\n",
       "\t\tvar connection, ic, ob, stub1_, stub2_, type;\n",
       "\t\tif (((this._connections.length == 0) && (this._implicit_connections.length == 0))) {\n",
       "\t\t\treturn null;\n",
       "\t\t}\n",
       "\t\tif ((!\"this_is_js()\")) {\n",
       "\t\t}\n",
       "\t\twhile (this._implicit_connections.length) {\n",
       "\t\t\tstub1_ = _pymeth_pop.call(this._implicit_connections, 0);\n",
       "\t\t\tob = stub1_[0];type = stub1_[1];\n",
       "\t\t\tob.disconnect(type, this);\n",
       "\t\t}\n",
       "\t\tfor (ic = 0; ic < this._connections.length; ic += 1) {\n",
       "\t\t\tconnection = this._connections[ic];\n",
       "\t\t\twhile (connection.objects.length > 0) {\n",
       "\t\t\t\tstub2_ = _pymeth_pop.call(connection.objects, 0);\n",
       "\t\t\t\tob = stub2_[0];type = stub2_[1];\n",
       "\t\t\t\tob.disconnect(type, this);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tthis._connections = [];\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       "\treaction.get_connection_info = function () {\n",
       "\t\treturn (function list_comprehension (iter0) {var res = [];var c, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {c = iter0[i0];{res.push([c.fullname, (function list_comprehension (iter0) {var res = [];var u, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {u = iter0[i0];{res.push(u[1]);}}return res;}).call(this, c.objects)]);}}return res;}).call(this, this._connections);\n",
       "\t};\n",
       "\n",
       "\treaction.get_mode = function () {\n",
       "\t\treturn this._mode;\n",
       "\t};\n",
       "\n",
       "\treaction.get_name = function () {\n",
       "\t\treturn this._name;\n",
       "\t};\n",
       "\n",
       "\treaction.reconnect = function (index) {\n",
       "\t\tvar connection, err_3, new_objects, ob, old_objects;\n",
       "\t\tconnection = this._connections[index];\n",
       "\t\told_objects = connection.objects;\n",
       "\t\tconnection.objects = [];\n",
       "\t\tob = this._ob1();\n",
       "\t\tif ((ob !== null)) {\n",
       "\t\t\tthis._seek_event_object(index, connection.parts, ob);\n",
       "\t\t}\n",
       "\t\tnew_objects = connection.objects;\n",
       "\t\tif ((new_objects.length == 0)) {\n",
       "\t\t\tthrow _pyfunc_op_error('RuntimeError', (\"Could not connect to \" + _pyfunc_repr(connection.fullname) + \"\"));\n",
       "\t\t}\n",
       "\t\tthis._connect_and_disconnect(old_objects, new_objects, connection.force);\n",
       "\t\treturn null;\n",
       "\t};\n",
       "\n",
       ";\n",
       "\tthat = this;\n",
       "\t$Component._REACTION_COUNT += 1;\n",
       "\treaction._id = 'r' + $Component._REACTION_COUNT;\n",
       "\treaction._name = name;\n",
       "\treaction._mode = mode;\n",
       "\treaction._ob1 = (function () {return that;}).bind(this);\n",
       "\treaction._init(connection_strings, this);\n",
       "\treturn reaction;\n",
       "};\n",
       "\n",
       "\n",
       "$Component._Component__check_not_active = function () {\n",
       "\tvar active_components, err_2;\n",
       "\tactive_components = loop.get_active_components();\n",
       "\tif (_pyfunc_op_contains(this, active_components)) {\n",
       "\t\tthrow _pyfunc_op_error('RuntimeError', \"It seems that the event loop is processing events while a Component is active. This has a high risk on race conditions.\");\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.__actions__ = []\n",
       "$Component.__attributes__ = [\"id\"]\n",
       "$Component.__emitters__ = []\n",
       "$Component.__enter__ = function () {\n",
       "\tloop._activate_component(this);\n",
       "\tloop.call_soon(this._Component__check_not_active);\n",
       "\treturn this;\n",
       "};\n",
       "\n",
       "$Component.__exit__ = function (type, value, traceback) {\n",
       "\tloop._deactivate_component(this);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.__properties__ = []\n",
       "$Component.__reactions__ = []\n",
       "$Component._comp_apply_property_values = function (values) {\n",
       "\tvar name, setter, setter_name, stub1_seq, stub2_itr, stub3_tgt, stub4_seq, stub5_itr, stub6_tgt, value;\n",
       "\tthis._Component__initial_mutation = true;\n",
       "\tstub1_seq = values;\n",
       "\tif ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "\tfor (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "\t\tstub3_tgt = stub1_seq[stub2_itr];\n",
       "\t\tname = stub3_tgt[0]; value = stub3_tgt[1];\n",
       "\t\tthis._mutate(name, value);\n",
       "\t}\n",
       "\tstub4_seq = values;\n",
       "\tif ((typeof stub4_seq === \"object\") && (!Array.isArray(stub4_seq))) { stub4_seq = Object.keys(stub4_seq);}\n",
       "\tfor (stub5_itr = 0; stub5_itr < stub4_seq.length; stub5_itr += 1) {\n",
       "\t\tstub6_tgt = stub4_seq[stub5_itr];\n",
       "\t\tname = stub6_tgt[0]; value = stub6_tgt[1];\n",
       "\t\tsetter_name = _pyfunc_op_add(((_pymeth_startswith.call(name, \"_\"))? (\"_set\") : (\"set_\")), name);\n",
       "\t\tsetter = _pyfunc_getattr(this, setter_name, null);\n",
       "\t\tif ((setter !== null)) {\n",
       "\t\t\tif ((_pyfunc_getattr(setter, \"is_autogenerated\", null) === false)) {\n",
       "\t\t\t\tsetter(value);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\tthis._Component__initial_mutation = false;\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._comp_stop_capturing_events = function () {\n",
       "\tvar allow_reconnect, ev, events, stub1_seq, stub2_itr;\n",
       "\tevents = this._Component__pending_events;\n",
       "\tthis._Component__pending_events = null;\n",
       "\tallow_reconnect = false;\n",
       "\tstub1_seq = events;\n",
       "\tif ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "\tfor (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "\t\tev = stub1_seq[stub2_itr];\n",
       "\t\tif ((ev === null)) {\n",
       "\t\t\tallow_reconnect = true;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\tev.allow_reconnect = allow_reconnect;\n",
       "\t\tthis.emit(ev.type, ev);\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._dispose = function () {\n",
       "\tvar i, name, reactions, stub1_seq;\n",
       "\tthis._disposed = true;\n",
       "\tif ((!\"this_is_js()\")) {\n",
       "\t}\n",
       "\tstub1_seq = this._Component__handlers;\n",
       "\tfor (name in stub1_seq) {\n",
       "\t\tif (!stub1_seq.hasOwnProperty(name)){ continue; }\n",
       "\t\treactions = stub1_seq[name];\n",
       "\t\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\t\t((reactions[i][1])._clear_component_refs)(this);\n",
       "\t\t}\n",
       "\t\twhile (reactions.length) {\n",
       "\t\t\treactions.pop();\n",
       "\t\t}\n",
       "\t}\n",
       "\tfor (i = 0; i < this.__reactions__.length; i += 1) {\n",
       "\t\t(_pyfunc_getattr(this, this.__reactions__[i]).dispose)();\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._mutate = function (prop_name, value, mutation, index) {\n",
       "\tvar cname, err_2, err_4, ev, is_equal, old, private_name, validator_name, value2;\n",
       "\tmutation = (mutation === undefined) ? \"set\": mutation;\n",
       "\tindex = (index === undefined) ? -1: index;\n",
       "\tif ((!(Object.prototype.toString.call(prop_name).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"_mutate's first arg must be str, not \" + Object.getPrototypeOf(prop_name) + \"\"));\n",
       "\t}\n",
       "\tif ((!_pyfunc_op_contains(prop_name, this.__properties__))) {\n",
       "\t\tcname = Object.getPrototypeOf(this).__name__;\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"\" + cname + \" object has no property \" + _pyfunc_repr(prop_name) + \"\"));\n",
       "\t}\n",
       "\tif ((loop.can_mutate(this) === false)) {\n",
       "\t\tthrow _pyfunc_op_error('AttributeError', (\"Trying to mutate property \" + prop_name + \" outside of an action or context.\"));\n",
       "\t}\n",
       "\tprivate_name = (\"_\" + prop_name) + \"_value\";\n",
       "\tvalidator_name = (\"_\" + prop_name) + \"_validate\";\n",
       "\told = _pyfunc_getattr(this, private_name);\n",
       "\tif (_pyfunc_op_equals(mutation, \"set\")) {\n",
       "\t\tvalue2 = _pyfunc_getattr(this, validator_name)(value);\n",
       "\t\t_pyfunc_setattr(this, private_name, value2);\n",
       "\t\t{ /* if this_is_js() */\n",
       "\t\tis_equal = _pyfunc_op_equals(old, value2);\n",
       "\t\t}\n",
       "\t\tif ((this._Component__initial_mutation === true)) {\n",
       "\t\t\told = value2;\n",
       "\t\t\tis_equal = false;\n",
       "\t\t}\n",
       "\t\tif ((!_pyfunc_truthy(is_equal))) {\n",
       "\t\t\tthis.emit(prop_name, {new_value:value2, old_value:old, mutation:mutation});\n",
       "\t\t\treturn true;\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\tev = {};\n",
       "\t\tev.objects = value;\n",
       "\t\tev.mutation = mutation;\n",
       "\t\tev.index = index;\n",
       "\t\tif ((Object.prototype.toString.call(old).slice(8,-1).toLowerCase() === 'object')) {\n",
       "\t\t\tif ((!_pyfunc_op_equals(index, (-1)))) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('IndexError', \"For in-place dict mutations, the index is not used, and must be -1.\");\n",
       "\t\t\t}\n",
       "\t\t\tmutate_dict(old, ev);\n",
       "\t\t} else {\n",
       "\t\t\tif ((index < 0)) {\n",
       "\t\t\t\tthrow _pyfunc_op_error('IndexError', \"For insert, remove, and replace mutations, the index must be >= 0.\");\n",
       "\t\t\t}\n",
       "\t\t\tmutate_array(old, ev);\n",
       "\t\t}\n",
       "\t\tthis.emit(prop_name, ev);\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._register_reaction = function (event_type, reaction, force) {\n",
       "\tvar _, comp1, comp2, i, label, msg, reactions, stub1_, stub2_els, type;\n",
       "\tforce = (force === undefined) ? false: force;\n",
       "\tstub1_ = _pymeth_partition.call(event_type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tlabel = _pyfunc_truthy(label) || reaction._name;\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, null);\n",
       "\tif ((reactions === null)) {\n",
       "\t\treactions = [];\n",
       "\t\tthis._Component__handlers[type] = reactions;\n",
       "\t\tif ((!_pyfunc_truthy(force))) {\n",
       "\t\t\tmsg = (\"Event type \\\"{type}\\\" does not exist on component {id}. \") + (\"Use \\\"!{type}\\\" or \\\"!xx.yy.{type}\\\" to suppress this warning.\");\n",
       "\t\t\tmsg = _pymeth_replace.call(_pymeth_replace.call(msg, \"{type}\", type), \"{id}\", this._id);\n",
       "\t\t\tlogger.warn(msg);\n",
       "\t\t}\n",
       "\t}\n",
       "\tcomp1 = _pyfunc_op_add((label + \"-\"), reaction._id);\n",
       "\tstub2_els = true;\n",
       "\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\tcomp2 = _pyfunc_op_add(((reactions[i][0]) + \"-\"), ((reactions[i][1])._id));\n",
       "\t\tif ((comp1 < comp2)) {\n",
       "\t\t\t_pymeth_insert.call(reactions, i, [label, reaction]);\n",
       "\t\t\tstub2_els = false; break;\n",
       "\t\t} else if (_pyfunc_op_equals(comp1, comp2)) {\n",
       "\t\t\tstub2_els = false; break;\n",
       "\t\t}\n",
       "\t} if (stub2_els) {\n",
       "\t\t_pymeth_append.call(reactions, [label, reaction]);\n",
       "\t}\n",
       "\tthis._registered_reactions_hook();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component._registered_reactions_hook = function () {\n",
       "\tvar key, reactions, stub1_seq, used_event_types;\n",
       "\tused_event_types = [];\n",
       "\tstub1_seq = this._Component__handlers;\n",
       "\tfor (key in stub1_seq) {\n",
       "\t\tif (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "\t\treactions = stub1_seq[key];\n",
       "\t\tif ((reactions.length > 0)) {\n",
       "\t\t\t_pymeth_append.call(used_event_types, key);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn used_event_types;\n",
       "};\n",
       "\n",
       "$Component.disconnect = function (type, reaction) {\n",
       "\tvar _, entry, i, label, reactions, stub1_;\n",
       "\treaction = (reaction === undefined) ? null: reaction;\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, []);\n",
       "\tfor (i = reactions.length - 1; i > -1; i += -1) {\n",
       "\t\tentry = reactions[i];\n",
       "\t\tif ((!(((_pyfunc_truthy(label) && ((!_pyfunc_op_equals(label, entry[0]))))) || (_pyfunc_truthy(reaction) && (reaction !== entry[1]))))) {\n",
       "\t\t\t_pymeth_pop.call(reactions, i);\n",
       "\t\t}\n",
       "\t}\n",
       "\tthis._registered_reactions_hook();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.dispose = function () {\n",
       "\tthis._dispose();\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "$Component.emit = function (type, info) {\n",
       "\tvar _, err_2, ev, i, index, label, reaction, reactions, stub1_, stub2_;\n",
       "\tinfo = (info === undefined) ? null: info;\n",
       "\tinfo = ((info === null))? (({})) : (info);\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tif (label.length) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', \"The type given to emit() should not include a label.\");\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(info).slice(8,-1).toLowerCase() === 'object'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Info object (for \" + _pyfunc_repr(type) + \") must be a dict, not \" + _pyfunc_repr(info) + \"\"));\n",
       "\t}\n",
       "\tev = _pyfunc_dict(info);\n",
       "\tev.type = type;\n",
       "\tev.source = this;\n",
       "\tif ((this._Component__pending_events !== null)) {\n",
       "\t\t_pymeth_append.call(this._Component__pending_events, ev);\n",
       "\t} else {\n",
       "\t\treactions = _pymeth_get.call(this._Component__handlers, ev.type, []);\n",
       "\t\tfor (i = 0; i < reactions.length; i += 1) {\n",
       "\t\t\tstub2_ = reactions[i];\n",
       "\t\t\tlabel = stub2_[0];reaction = stub2_[1];\n",
       "\t\t\tif (_pymeth_startswith.call(label, \"reconnect_\")) {\n",
       "\t\t\t\tif ((_pyfunc_getattr(ev, \"allow_reconnect\", true) === true)) {\n",
       "\t\t\t\t\tindex = _pyfunc_int((_pymeth_split.call(label, \"_\")[_pymeth_split.call(label, \"_\").length -1]));\n",
       "\t\t\t\t\treaction.reconnect(index);\n",
       "\t\t\t\t}\n",
       "\t\t\t} else {\n",
       "\t\t\t\tloop.add_reaction_event(reaction, ev);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn ev;\n",
       "};\n",
       "\n",
       "$Component.get_event_handlers = function (type) {\n",
       "\tvar _, err_2, label, reactions, stub1_;\n",
       "\tif ((!_pyfunc_truthy(type))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"get_event_handlers() missing \\\"type\\\" argument.\"));\n",
       "\t}\n",
       "\tstub1_ = _pymeth_partition.call(type, \":\");\n",
       "\ttype = stub1_[0];_ = stub1_[1];label = stub1_[2];\n",
       "\tif (label.length) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', \"The type given to get_event_handlers() should not include a label.\");\n",
       "\t}\n",
       "\treactions = _pymeth_get.call(this._Component__handlers, type, []);\n",
       "\treturn (function list_comprehension (iter0) {var res = [];var h, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {h = iter0[i0];{res.push(h[1]);}}return res;}).call(this, reactions);\n",
       "};\n",
       "\n",
       "$Component.get_event_types = function () {\n",
       "\tvar types;\n",
       "\ttypes = _pyfunc_list(this._Component__handlers);\n",
       "\t_pymeth_sort.call(types, undefined, false);\n",
       "\treturn types;\n",
       "};\n",
       "\n",
       "$Component.init = function () {\n",
       "\treturn null;\n",
       "};\n",
       "var Property = function () {};\n",
       "Property.prototype._validate = function(value, name, data) {return value;};\n",
       "var AnyProp;\n",
       "AnyProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "AnyProp.prototype = Object.create(Property.prototype);\n",
       "AnyProp.prototype._base_class = Property.prototype;\n",
       "AnyProp.prototype.__name__ = \"AnyProp\";\n",
       "\n",
       "\n",
       "var BoolProp;\n",
       "BoolProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "BoolProp.prototype = Object.create(Property.prototype);\n",
       "BoolProp.prototype._base_class = Property.prototype;\n",
       "BoolProp.prototype.__name__ = \"BoolProp\";\n",
       "\n",
       "BoolProp.prototype._default = false;\n",
       "BoolProp.prototype._validate = function (value, name, data) {\n",
       "\treturn _pyfunc_bool(value);\n",
       "};\n",
       "\n",
       "\n",
       "var ColorProp;\n",
       "ColorProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ColorProp.prototype = Object.create(Property.prototype);\n",
       "ColorProp.prototype._base_class = Property.prototype;\n",
       "ColorProp.prototype.__name__ = \"ColorProp\";\n",
       "\n",
       "ColorProp.prototype._default = \"#000\";\n",
       "ColorProp.prototype._validate = function (value, name, data) {\n",
       "\tvar M, Mi, blackfactor, common_colors, d, err_2, err_3, hex, i, stub10_, stub10_c, stub10_i0, stub10_iter0, stub1_, stub2_, stub3_, stub4_, stub5_, stub5_i, stub5_i0, stub5_iter0, stub6_, stub6_i, stub6_i0, stub6_iter0, stub7_, stub7_i0, stub7_iter0, stub7_x, stub8_, stub8_i0, stub8_iter0, stub8_v, stub9_, stub9_i0, stub9_iter0, stub9_v, val, whitefactor;\n",
       "\tval = value;\n",
       "\tcommon_colors = ({k: \"#000000\", black: \"#000000\", w: \"#ffffff\", white: \"#ffffff\", r: \"#ff0000\", red: \"#ff0000\", g: \"#00ff00\", green: \"#00ff00\", lime: \"#00ff00\", b: \"#0000ff\", blue: \"#0000ff\", y: \"#ffff00\", yellow: \"#ffff00\", m: \"#ff00ff\", magenta: \"#ff00ff\", fuchsia: \"#ff00ff\", c: \"#00ffff\", cyan: \"#00ffff\", aqua: \"#00ffff\", gray: \"#808080\", grey: \"#808080\"});\n",
       "\tcommon_colors[\"\"] = \"#0000\";\n",
       "\tM = ({0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15});\n",
       "\tMi = \"0123456789abcdef\";\n",
       "\tif ((Object.prototype.toString.call(val).slice(8,-1).toLowerCase() === 'string')) {\n",
       "\t\tval = _pymeth_lower.call(val);\n",
       "\t\twhitefactor = 0.0;\n",
       "\t\tblackfactor = 0.0;\n",
       "\t\tif (_pymeth_startswith.call(val, \"darker\")) {\n",
       "\t\t\tstub1_ = [0.66, val.slice(6)];\n",
       "\t\t\tblackfactor = stub1_[0];val = stub1_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"dark\")) {\n",
       "\t\t\tstub2_ = [0.33, val.slice(4)];\n",
       "\t\t\tblackfactor = stub2_[0];val = stub2_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"lighter\")) {\n",
       "\t\t\tstub3_ = [0.66, val.slice(7)];\n",
       "\t\t\twhitefactor = stub3_[0];val = stub3_[1];\n",
       "\t\t} else if (_pymeth_startswith.call(val, \"light\")) {\n",
       "\t\t\tstub4_ = [0.33, val.slice(5)];\n",
       "\t\t\twhitefactor = stub4_[0];val = stub4_[1];\n",
       "\t\t}\n",
       "\t\tval = _pymeth_get.call(common_colors, val, val);\n",
       "\t\tif ((((_pymeth_startswith.call(val, \"#\") && (val.length == 4))) || (val.length == 5))) {\n",
       "\t\t\tstub5_ = [];stub5_iter0 = _pyfunc_range(1, val.length, 1);if ((typeof stub5_iter0 === \"object\") && (!Array.isArray(stub5_iter0))) {stub5_iter0 = Object.keys(stub5_iter0);}for (stub5_i0=0; stub5_i0<stub5_iter0.length; stub5_i0++) {stub5_i = stub5_iter0[stub5_i0];{stub5_.push(_pyfunc_op_mult(_pymeth_get.call(M, val[stub5_i], 0), 17));}}\n",
       "\t\t\tval = stub5_;\n",
       "\t\t} else if ((((_pymeth_startswith.call(val, \"#\") && (val.length == 7))) || (val.length == 9))) {\n",
       "\t\t\tstub6_ = [];stub6_iter0 = _pyfunc_range(1, val.length, 2);if ((typeof stub6_iter0 === \"object\") && (!Array.isArray(stub6_iter0))) {stub6_iter0 = Object.keys(stub6_iter0);}for (stub6_i0=0; stub6_i0<stub6_iter0.length; stub6_i0++) {stub6_i = stub6_iter0[stub6_i0];{stub6_.push(_pyfunc_op_add((_pyfunc_op_mult(_pymeth_get.call(M, val[stub6_i], 0), 16)), _pymeth_get.call(M, val[stub6_i + 1], 0)));}}\n",
       "\t\t\tval = stub6_;\n",
       "\t\t} else if (_pyfunc_truthy(_pymeth_startswith.call(val, \"rgb(\") || _pymeth_startswith.call(val, \"rgba(\"))) {\n",
       "\t\t\tstub7_ = [];stub7_iter0 = _pymeth_split.call(val.slice(4,-1), \",\");if ((typeof stub7_iter0 === \"object\") && (!Array.isArray(stub7_iter0))) {stub7_iter0 = Object.keys(stub7_iter0);}for (stub7_i0=0; stub7_i0<stub7_iter0.length; stub7_i0++) {stub7_x = stub7_iter0[stub7_i0];{stub7_.push(_pyfunc_float((_pymeth_strip.call(stub7_x, \" ,();\"))));}}\n",
       "\t\t\tval = stub7_;\n",
       "\t\t\tif ((val.length == 4)) {\n",
       "\t\t\t\tval[val.length -1] = _pyfunc_op_mult(val[val.length -1], 255);\n",
       "\t\t\t}\n",
       "\t\t} else {\n",
       "\t\t\tthrow _pyfunc_op_error('ValueError', (\"ColorProp \" + _pyfunc_repr(name) + \" got invalid color: \" + _pyfunc_repr(value) + \"\"));\n",
       "\t\t}\n",
       "\t\tstub8_ = [];stub8_iter0 = val;if ((typeof stub8_iter0 === \"object\") && (!Array.isArray(stub8_iter0))) {stub8_iter0 = Object.keys(stub8_iter0);}for (stub8_i0=0; stub8_i0<stub8_iter0.length; stub8_i0++) {stub8_v = stub8_iter0[stub8_i0];{stub8_.push(stub8_v / 255);}}\n",
       "\t\tval = stub8_;\n",
       "\t\tfor (i = 0; i < 3; i += 1) {\n",
       "\t\t\tval[i] = _pyfunc_op_add((_pyfunc_op_mult((1.0 - whitefactor), val[i])), whitefactor);\n",
       "\t\t\tval[i] = (_pyfunc_op_mult((1.0 - blackfactor), val[i])) + 0;\n",
       "\t\t}\n",
       "\t}\n",
       "\tif ((val === null)) {\n",
       "\t\tval = [0, 0, 0, 0];\n",
       "\t} else if ((((Object.prototype.toString.call(val).slice(8,-1).toLowerCase() === 'object')) && _pyfunc_op_contains(\"t\", val))) {\n",
       "\t\tval = val[\"t\"];\n",
       "\t}\n",
       "\tif ((!Array.isArray(val))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"ColorProp \" + _pyfunc_repr(name) + \" value must be str or tuple.\"));\n",
       "\t}\n",
       "\tstub9_ = [];stub9_iter0 = val;if ((typeof stub9_iter0 === \"object\") && (!Array.isArray(stub9_iter0))) {stub9_iter0 = Object.keys(stub9_iter0);}for (stub9_i0=0; stub9_i0<stub9_iter0.length; stub9_i0++) {stub9_v = stub9_iter0[stub9_i0];{stub9_.push(Math.max((Math.min(_pyfunc_float(stub9_v), 1.0)), 0.0));}}\n",
       "\tval = stub9_;\n",
       "\tif ((val.length == 3)) {\n",
       "\t\tval = _pyfunc_op_add(val, [1.0]);\n",
       "\t} else if (_pyfunc_truthy(val.length != 4)) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', (\"ColorProp \" + _pyfunc_repr(name) + \" value must have 3 or 4 elements, not \" + val.length + \"\"));\n",
       "\t}\n",
       "\tval = _pyfunc_list(val);\n",
       "\t{ /* if this_is_js() */\n",
       "\tval.push = undefined;\n",
       "\tval.splice = undefined;\n",
       "\tval.push = undefined;\n",
       "\tval.reverse = undefined;\n",
       "\tval.sort = undefined;\n",
       "\t}\n",
       "\t{ /* if this_is_js() */\n",
       "\td = ({});\n",
       "\t}\n",
       "\td.t = val;\n",
       "\td.alpha = val[3];\n",
       "\tstub10_ = [];stub10_iter0 = val.slice(0,3);if ((typeof stub10_iter0 === \"object\") && (!Array.isArray(stub10_iter0))) {stub10_iter0 = Object.keys(stub10_iter0);}for (stub10_i0=0; stub10_i0<stub10_iter0.length; stub10_i0++) {stub10_c = stub10_iter0[stub10_i0];{stub10_.push(_pyfunc_int(_pyfunc_op_mult(stub10_c, 255)));}}\n",
       "\thex = stub10_;\n",
       "\td.hex = \"#\" + (_pymeth_join.call(\"\", ((function list_comprehension (iter0) {var res = [];var c, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {c = iter0[i0];{res.push(_pyfunc_op_add(Mi[_pyfunc_int((c / 16))], Mi[c % 16]));}}return res;}).call(this, hex))));\n",
       "\td.css = \"rgba(\" + _pyfunc_op_mult(val[0], 255) + \",\" + _pyfunc_op_mult(val[1], 255) + \",\" + _pyfunc_op_mult(val[2], 255) + \",\" + val[3] + \")\";\n",
       "\treturn d;\n",
       "};\n",
       "\n",
       "\n",
       "var ComponentProp;\n",
       "ComponentProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ComponentProp.prototype = Object.create(Property.prototype);\n",
       "ComponentProp.prototype._base_class = Property.prototype;\n",
       "ComponentProp.prototype.__name__ = \"ComponentProp\";\n",
       "\n",
       "ComponentProp.prototype._default = null;\n",
       "ComponentProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!((value === null) || _pyfunc_hasattr(value, \"_IS_COMPONENT\")))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Component property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var DictProp;\n",
       "DictProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "DictProp.prototype = Object.create(Property.prototype);\n",
       "DictProp.prototype._base_class = Property.prototype;\n",
       "DictProp.prototype.__name__ = \"DictProp\";\n",
       "\n",
       "DictProp.prototype._default = ({});\n",
       "DictProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'object'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Dict property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn _pymeth_copy.call(value);\n",
       "};\n",
       "\n",
       "\n",
       "var EnumProp;\n",
       "EnumProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "EnumProp.prototype = Object.create(Property.prototype);\n",
       "EnumProp.prototype._base_class = Property.prototype;\n",
       "EnumProp.prototype.__name__ = \"EnumProp\";\n",
       "\n",
       "EnumProp.prototype._default = \"\";\n",
       "EnumProp.prototype._consume_args = function (options) {\n",
       "\tvar args, err_2;\n",
       "\targs = Array.prototype.slice.call(arguments, 1);\n",
       "\tif ((!Array.isArray(options))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"EnumProp needs list of options\");\n",
       "\t}\n",
       "\tif ((!(_pyfunc_all(((function list_comprehension (iter0) {var res = [];var i, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {i = iter0[i0];{res.push(Object.prototype.toString.call(i).slice(8,-1).toLowerCase() === 'string');}}return res;}).call(this, options)))))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', \"EnumProp options must be str\");\n",
       "\t}\n",
       "\tif ((!_pyfunc_truthy(args))) {\n",
       "\t\targs = [options[0]];\n",
       "\t}\n",
       "\tthis._set_data((function list_comprehension (iter0) {var res = [];var option, i0;if ((typeof iter0 === \"object\") && (!Array.isArray(iter0))) {iter0 = Object.keys(iter0);}for (i0=0; i0<iter0.length; i0++) {option = iter0[i0];{res.push(_pymeth_upper.call(option));}}return res;}).call(this, options));\n",
       "\tEnumProp.prototype._base_class._consume_args.apply(this, args);\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "EnumProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"EnumProp \" + _pyfunc_repr(name) + \" value must be str.\"));\n",
       "\t}\n",
       "\tvalue = _pymeth_upper.call(value);\n",
       "\tif ((!_pyfunc_op_contains(_pymeth_upper.call(value), data))) {\n",
       "\t\tthrow _pyfunc_op_error('ValueError', (\"Invalid value for enum \" + _pyfunc_repr(name) + \": \" + value + \"\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var FloatPairProp;\n",
       "FloatPairProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "FloatPairProp.prototype = Object.create(Property.prototype);\n",
       "FloatPairProp.prototype._base_class = Property.prototype;\n",
       "FloatPairProp.prototype.__name__ = \"FloatPairProp\";\n",
       "\n",
       "FloatPairProp.prototype._default = [0.0, 0.0];\n",
       "FloatPairProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tvalue = [value, value];\n",
       "\t}\n",
       "\tif (_pyfunc_truthy(value.length != 2)) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair property \" + _pyfunc_repr(name) + \" needs a scalar or two values, not \" + value.length + \"\"));\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(value[0]).slice(8,-1).toLowerCase() === 'number'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair \" + _pyfunc_repr(name) + \" 1st value cannot be \" + _pyfunc_repr(value[0]) + \".\"));\n",
       "\t}\n",
       "\tif ((!(Object.prototype.toString.call(value[1]).slice(8,-1).toLowerCase() === 'number'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"FloatPair \" + _pyfunc_repr(name) + \" 2nd value cannot be \" + _pyfunc_repr(value[1]) + \".\"));\n",
       "\t}\n",
       "\tvalue = [_pyfunc_float(value[0]), _pyfunc_float(value[1])];\n",
       "\t{ /* if this_is_js() */\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.splice = undefined;\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.reverse = undefined;\n",
       "\tvalue.sort = undefined;\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var FloatProp;\n",
       "FloatProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "FloatProp.prototype = Object.create(Property.prototype);\n",
       "FloatProp.prototype._base_class = Property.prototype;\n",
       "FloatProp.prototype.__name__ = \"FloatProp\";\n",
       "\n",
       "FloatProp.prototype._default = 0.0;\n",
       "FloatProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'number')) || (Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\treturn _pyfunc_float(value);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Float property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "\n",
       "var IntProp;\n",
       "IntProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "IntProp.prototype = Object.create(Property.prototype);\n",
       "IntProp.prototype._base_class = Property.prototype;\n",
       "IntProp.prototype.__name__ = \"IntProp\";\n",
       "\n",
       "IntProp.prototype._default = 0;\n",
       "IntProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'number')) || ((Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'boolean')) || (Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\treturn _pyfunc_int(value);\n",
       "\t} else {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Int property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn null;\n",
       "};\n",
       "\n",
       "\n",
       "var ListProp;\n",
       "ListProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ListProp.prototype = Object.create(Property.prototype);\n",
       "ListProp.prototype._base_class = Property.prototype;\n",
       "ListProp.prototype.__name__ = \"ListProp\";\n",
       "\n",
       "ListProp.prototype._default = [];\n",
       "ListProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"List property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn _pyfunc_list(value);\n",
       "};\n",
       "\n",
       "\n",
       "var StringProp;\n",
       "StringProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "StringProp.prototype = Object.create(Property.prototype);\n",
       "StringProp.prototype._base_class = Property.prototype;\n",
       "StringProp.prototype.__name__ = \"StringProp\";\n",
       "\n",
       "StringProp.prototype._default = \"\";\n",
       "StringProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!(Object.prototype.toString.call(value).slice(8,-1).toLowerCase() === 'string'))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"String property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var TriStateProp;\n",
       "TriStateProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "TriStateProp.prototype = Object.create(Property.prototype);\n",
       "TriStateProp.prototype._base_class = Property.prototype;\n",
       "TriStateProp.prototype.__name__ = \"TriStateProp\";\n",
       "\n",
       "TriStateProp.prototype._default = null;\n",
       "TriStateProp.prototype._validate = function (value, name, data) {\n",
       "\tif ((value === null)) {\n",
       "\t\treturn null;\n",
       "\t}\n",
       "\treturn _pyfunc_bool(value);\n",
       "};\n",
       "\n",
       "\n",
       "var TupleProp;\n",
       "TupleProp = function () {\n",
       "\t_pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "TupleProp.prototype = Object.create(Property.prototype);\n",
       "TupleProp.prototype._base_class = Property.prototype;\n",
       "TupleProp.prototype.__name__ = \"TupleProp\";\n",
       "\n",
       "TupleProp.prototype._default = [];\n",
       "TupleProp.prototype._validate = function (value, name, data) {\n",
       "\tvar err_2;\n",
       "\tif ((!Array.isArray(value))) {\n",
       "\t\tthrow _pyfunc_op_error('TypeError', (\"Tuple property \" + _pyfunc_repr(name) + \" cannot accept \" + _pyfunc_repr(value) + \".\"));\n",
       "\t}\n",
       "\tvalue = _pyfunc_list(value);\n",
       "\t{ /* if this_is_js() */\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.splice = undefined;\n",
       "\tvalue.push = undefined;\n",
       "\tvalue.reverse = undefined;\n",
       "\tvalue.sort = undefined;\n",
       "\t}\n",
       "\treturn value;\n",
       "};\n",
       "\n",
       "\n",
       "var event = {}; // convenience \"module emulator\"\n",
       "event.Property = Property;\n",
       "event.AnyProp = AnyProp;\n",
       "event.BoolProp = BoolProp;\n",
       "event.ColorProp = ColorProp;\n",
       "event.ComponentProp = ComponentProp;\n",
       "event.DictProp = DictProp;\n",
       "event.EnumProp = EnumProp;\n",
       "event.FloatPairProp = FloatPairProp;\n",
       "event.FloatProp = FloatProp;\n",
       "event.IntProp = IntProp;\n",
       "event.ListProp = ListProp;\n",
       "event.StringProp = StringProp;\n",
       "event.TriStateProp = TriStateProp;\n",
       "event.TupleProp = TupleProp;\n",
       "\n",
       "return {Component: Component, loop: loop, logger: logger, Property: Property, AnyProp: AnyProp, BoolProp: BoolProp, TriStateProp: TriStateProp, IntProp: IntProp, FloatProp: FloatProp, StringProp: StringProp, TupleProp: TupleProp, ListProp: ListProp, DictProp: DictProp, ComponentProp: ComponentProp, FloatPairProp: FloatPairProp, EnumProp: EnumProp, ColorProp: ColorProp};\n",
       "});\n",
       "\n",
       "\n",
       "/* ======================= flexx.app._clientcore ========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "\n",
       "\n",
       "flexx.define(\"flexx.app._clientcore\", [\"pscript-std.js\"], function (_py) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_range = _py._pyfunc_range, _pyfunc_reversed = _py._pyfunc_reversed, _pyfunc_str = _py._pyfunc_str, _pyfunc_time = _py._pyfunc_time, _pyfunc_truthy = _py._pyfunc_truthy;\n",
       "\n",
       "var _pymeth_count = _py._pymeth_count, _pymeth_get = _py._pymeth_get, _pymeth_join = _py._pymeth_join, _pymeth_pop = _py._pymeth_pop, _pymeth_replace = _py._pymeth_replace, _pymeth_split = _py._pymeth_split, _pymeth_splitlines = _py._pymeth_splitlines;\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "var Flexx, JsSession, __pscript__, bsdf, serializer;\n",
       "\"\\nThe client's core Flexx engine, implemented in PScript.\\n\";\n",
       "__pscript__ = true;\n",
       "Flexx = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "Flexx.prototype._base_class = Object;\n",
       "Flexx.prototype.__name__ = \"Flexx\";\n",
       "\n",
       "Flexx.prototype.__init__ = function () {\n",
       "    var err_2, key, stub1_seq;\n",
       "    if (_pyfunc_truthy(window.flexx.init)) {\n",
       "        throw _pyfunc_op_error('RuntimeError', \"Should not create global Flexx object more than once.\");\n",
       "    }\n",
       "    this.is_notebook = false;\n",
       "    this.is_exported = false;\n",
       "    stub1_seq = window.flexx;\n",
       "    for (key in stub1_seq) {\n",
       "        if (!stub1_seq.hasOwnProperty(key)){ continue; }\n",
       "        this[key] = window.flexx[key];\n",
       "    }\n",
       "    this.need_main_widget = true;\n",
       "    this._session_count = 0;\n",
       "    this.sessions = ({});\n",
       "    window.addEventListener(\"load\", this.init, false);\n",
       "    window.addEventListener(\"unload\", this.exit, false);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.init = function () {\n",
       "    this.asset_node = window.document.createElement(\"div\");\n",
       "    this.asset_node.id = \"Flexx asset container\";\n",
       "    window.document.body.appendChild(this.asset_node);\n",
       "    if (_pyfunc_truthy(this.is_exported)) {\n",
       "        if (_pyfunc_truthy(this.is_notebook)) {\n",
       "            console.log(\"Flexx: I am in an exported notebook!\");\n",
       "        } else {\n",
       "            console.log(\"Flexx: I am in an exported app!\");\n",
       "            this.run_exported_app();\n",
       "        }\n",
       "    } else {\n",
       "        console.log(\"Flexx: Initializing\");\n",
       "        if ((!_pyfunc_truthy(this.is_notebook))) {\n",
       "            this._remove_querystring();\n",
       "        }\n",
       "        this.init_logging();\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype._remove_querystring = function () {\n",
       "    try {\n",
       "        window.history.replaceState(window.history.state, \"\", window.location.pathname);\n",
       "    } catch(err_2) {\n",
       "        {\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.exit = function () {\n",
       "    var session, stub2_seq;\n",
       "    stub2_seq = this.sessions;\n",
       "    for (session in stub2_seq) {\n",
       "        if (!stub2_seq.hasOwnProperty(session)){ continue; }\n",
       "        session = stub2_seq[session];\n",
       "        session.exit();\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.spin = function (n) {\n",
       "    n = (n === undefined) ? 1: n;\n",
       "    if (!window.document.body) {return;}\n",
       "    var el = window.document.body.children[0];\n",
       "    if (el && el.classList.contains(\"flx-spinner\")) {\n",
       "        if (n === null) {\n",
       "            el.style.display = 'none';  // Stop the spinner\n",
       "        } else {\n",
       "            el.children[0].innerHTML += '&#9632'.repeat(n);\n",
       "        }\n",
       "    };\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.init_logging = function () {\n",
       "    var error, info, log, on_error, warn;\n",
       "    if (_pyfunc_truthy(window.console.ori_log)) {\n",
       "        return null;\n",
       "    }\n",
       "    window.console.ori_log = window.console.log;\n",
       "    window.console.ori_info = _pyfunc_truthy(window.console.info) || window.console.log;\n",
       "    window.console.ori_warn = _pyfunc_truthy(window.console.warn) || window.console.log;\n",
       "    window.console.ori_error = _pyfunc_truthy(window.console.error) || window.console.log;\n",
       "    log = (function flx_log (msg) {\n",
       "        var session, stub3_seq;\n",
       "        window.console.ori_log(msg);\n",
       "        stub3_seq = this.sessions;\n",
       "        for (session in stub3_seq) {\n",
       "            if (!stub3_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub3_seq[session];\n",
       "            session.send_command(\"PRINT\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    info = (function flx_info (msg) {\n",
       "        var session, stub4_seq;\n",
       "        window.console.ori_info(msg);\n",
       "        stub4_seq = this.sessions;\n",
       "        for (session in stub4_seq) {\n",
       "            if (!stub4_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub4_seq[session];\n",
       "            session.send_command(\"INFO\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    warn = (function flx_warn (msg) {\n",
       "        var session, stub5_seq;\n",
       "        window.console.ori_warn(msg);\n",
       "        stub5_seq = this.sessions;\n",
       "        for (session in stub5_seq) {\n",
       "            if (!stub5_seq.hasOwnProperty(session)){ continue; }\n",
       "            session = stub5_seq[session];\n",
       "            session.send_command(\"WARN\", _pyfunc_str(msg));\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    error = (function flx_error (msg) {\n",
       "        var evt;\n",
       "        evt = {message:_pyfunc_str(msg), error:msg, preventDefault:((function () {return null;}).bind(this))};\n",
       "        on_error(evt);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_error = (function flx_on_error (evt) {\n",
       "        this._handle_error(evt);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_error = on_error.bind(this);\n",
       "    window.console.log = log;\n",
       "    window.console.info = info;\n",
       "    window.console.warn = warn;\n",
       "    window.console.error = error;\n",
       "    window.addEventListener(\"error\", on_error, false);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype.create_session = function (app_name, session_id, ws_url) {\n",
       "    var s;\n",
       "    s = new JsSession(app_name, session_id, ws_url);\n",
       "    this._session_count = _pyfunc_op_add(this._session_count, 1);\n",
       "    this[\"s\" + this._session_count] = s;\n",
       "    this.sessions[session_id] = s;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "Flexx.prototype._handle_error = function (evt) {\n",
       "    var i, msg, session, session_needle, short, stack, stub10_seq, stub11_itr, stub12_seq, stub13_itr, stub14_seq, stub6_seq, stub7_itr, stub8_seq, stub9_itr, x;\n",
       "    msg = short = evt.message;\n",
       "    if ((!_pyfunc_truthy(window.evt))) {\n",
       "        window.evt = evt;\n",
       "    }\n",
       "    if ((_pyfunc_truthy(evt.error) && _pyfunc_truthy(evt.error.stack))) {\n",
       "        stack = _pymeth_splitlines.call(evt.error.stack);\n",
       "        session_needle = \"?session_id=\" + this.id;\n",
       "        for (i = 0; i < stack.length; i += 1) {\n",
       "            stack[i] = _pymeth_replace.call(_pymeth_replace.call(stack[i], \"@\", \" @ \"), session_needle, \"\");\n",
       "        }\n",
       "        stub6_seq = [evt.message, \"_pyfunc_op_error\"];\n",
       "        if ((typeof stub6_seq === \"object\") && (!Array.isArray(stub6_seq))) { stub6_seq = Object.keys(stub6_seq);}\n",
       "        for (stub7_itr = 0; stub7_itr < stub6_seq.length; stub7_itr += 1) {\n",
       "            x = stub6_seq[stub7_itr];\n",
       "            if (_pyfunc_op_contains(x, stack[0])) {\n",
       "                _pymeth_pop.call(stack, 0);\n",
       "            }\n",
       "        }\n",
       "        for (i = 0; i < stack.length; i += 1) {\n",
       "            stub8_seq = [\"_process_actions\", \"_process_reactions\", \"_process_calls\"];\n",
       "            if ((typeof stub8_seq === \"object\") && (!Array.isArray(stub8_seq))) { stub8_seq = Object.keys(stub8_seq);}\n",
       "            for (stub9_itr = 0; stub9_itr < stub8_seq.length; stub9_itr += 1) {\n",
       "                x = stub8_seq[stub9_itr];\n",
       "                if ((_pyfunc_op_contains((\"Loop.\" + x), stack[i]))) {\n",
       "                    stack = stack.slice(0,i);\n",
       "                    break;\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        stub12_seq = _pyfunc_reversed(_pyfunc_range(0, stack.length, 1));\n",
       "        if ((typeof stub12_seq === \"object\") && (!Array.isArray(stub12_seq))) { stub12_seq = Object.keys(stub12_seq);}\n",
       "        for (stub13_itr = 0; stub13_itr < stub12_seq.length; stub13_itr += 1) {\n",
       "            i = stub12_seq[stub13_itr];\n",
       "            stub10_seq = [\"flx_action \"];\n",
       "            if ((typeof stub10_seq === \"object\") && (!Array.isArray(stub10_seq))) { stub10_seq = Object.keys(stub10_seq);}\n",
       "            for (stub11_itr = 0; stub11_itr < stub10_seq.length; stub11_itr += 1) {\n",
       "                x = stub10_seq[stub11_itr];\n",
       "                if ((_pyfunc_truthy(stack[i]) && _pymeth_count.call(stack[i], x))) {\n",
       "                    _pymeth_pop.call(stack, i);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        msg = _pyfunc_op_add(msg, \"\\n\" + _pymeth_join.call(\"\\n\", stack));\n",
       "    } else if ((_pyfunc_truthy(evt.message) && _pyfunc_truthy(evt.lineno))) {\n",
       "        msg = _pyfunc_op_add(msg, \"\\nIn \" + evt.filename + \":\" + evt.lineno + \"\");\n",
       "    }\n",
       "    evt.preventDefault();\n",
       "    window.console.ori_error(msg);\n",
       "    stub14_seq = this.sessions;\n",
       "    for (session in stub14_seq) {\n",
       "        if (!stub14_seq.hasOwnProperty(session)){ continue; }\n",
       "        session = stub14_seq[session];\n",
       "        session.send_command(\"ERROR\", short);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "JsSession = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "JsSession.prototype._base_class = Object;\n",
       "JsSession.prototype.__name__ = \"JsSession\";\n",
       "\n",
       "JsSession.prototype.__init__ = function (app_name, id, ws_url) {\n",
       "    var config, err, jconfig;\n",
       "    ws_url = (ws_url === undefined) ? null: ws_url;\n",
       "    this.app = null;\n",
       "    this.app_name = app_name;\n",
       "    this.id = id;\n",
       "    this.status = 1;\n",
       "    this.ws_url = ws_url;\n",
       "    this._component_counter = 0;\n",
       "    this._disposed_ob = ({_disposed: true});\n",
       "    if ((!_pyfunc_truthy(this.id))) {\n",
       "        jconfig = window.document.getElementById(\"jupyter-config-data\");\n",
       "        if (_pyfunc_truthy(jconfig)) {\n",
       "            try {\n",
       "                config = JSON.parse(jconfig.innerText);\n",
       "                this.id = config.flexx_session_id;\n",
       "                this.app_name = config.flexx_app_name;\n",
       "            } catch(err_4) {\n",
       "                {\n",
       "                    err = err_4;\n",
       "                    console.log(err);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    this._init_time = _pyfunc_time();\n",
       "    this._pending_commands = [];\n",
       "    this._asset_count = 0;\n",
       "    this._ws = null;\n",
       "    this.last_msg = null;\n",
       "    this.instances = ({});\n",
       "    this.instances_to_check_size = ({});\n",
       "    if ((!_pyfunc_truthy(window.flexx.is_exported))) {\n",
       "        this.init_socket();\n",
       "    }\n",
       "    window.addEventListener(\"resize\", this._check_size_of_objects, false);\n",
       "    window.setInterval(this._check_size_of_objects, 1000);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.exit = function () {\n",
       "    if (_pyfunc_truthy(this._ws)) {\n",
       "        this._ws.close();\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.send_command = function () {\n",
       "    var bb, command, err;\n",
       "    command = Array.prototype.slice.call(arguments);\n",
       "    if ((this._ws !== null)) {\n",
       "        try {\n",
       "            bb = serializer.encode(command);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                console.log(\"Command that failed to encode:\");\n",
       "                console.log(command);\n",
       "                throw err;\n",
       "            }\n",
       "        }\n",
       "        this._ws.send(bb);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.instantiate_component = function (module, cname, id, args, kwargs, active_components) {\n",
       "    var Cls, ac, c, m, stub15_seq, stub16_itr, stub17_seq, stub18_itr;\n",
       "    c = _pymeth_get.call(this.instances, id, null);\n",
       "    if (((c !== null) && (c._disposed === false))) {\n",
       "        return c;\n",
       "    }\n",
       "    m = window.flexx.require(module);\n",
       "    Cls = m[cname];\n",
       "    kwargs[\"flx_session\"] = this;\n",
       "    kwargs[\"flx_id\"] = id;\n",
       "    active_components = _pyfunc_truthy(active_components) || [];\n",
       "    stub15_seq = active_components;\n",
       "    if ((typeof stub15_seq === \"object\") && (!Array.isArray(stub15_seq))) { stub15_seq = Object.keys(stub15_seq);}\n",
       "    for (stub16_itr = 0; stub16_itr < stub15_seq.length; stub16_itr += 1) {\n",
       "        ac = stub15_seq[stub16_itr];\n",
       "        ac.__enter__();\n",
       "    }\n",
       "    try {\n",
       "        c = new Cls({flx_args: args, flx_kwargs: kwargs});\n",
       "    } finally {\n",
       "        stub17_seq = _pyfunc_reversed(active_components);\n",
       "        if ((typeof stub17_seq === \"object\") && (!Array.isArray(stub17_seq))) { stub17_seq = Object.keys(stub17_seq);}\n",
       "        for (stub18_itr = 0; stub18_itr < stub17_seq.length; stub18_itr += 1) {\n",
       "            ac = stub17_seq[stub18_itr];\n",
       "            ac.__exit__();\n",
       "        }\n",
       "    }\n",
       "    return c;\n",
       "};\n",
       "\n",
       "JsSession.prototype._register_component = function (c, id) {\n",
       "    id = (id === undefined) ? null: id;\n",
       "    if ((this.app === null)) {\n",
       "        this.app = c;\n",
       "    }\n",
       "    if ((id === null)) {\n",
       "        this._component_counter = _pyfunc_op_add(this._component_counter, 1);\n",
       "        id = (_pyfunc_op_add((c.__name__ + \"_\"), _pyfunc_str(this._component_counter))) + \"js\";\n",
       "    }\n",
       "    c._id = id;\n",
       "    c._uid = _pyfunc_op_add((this.id + \"_\"), id);\n",
       "    this.instances[c._id] = c;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._unregister_component = function (c) {\n",
       "    _pymeth_pop.call(this.instances_to_check_size, c.id, null);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.get_component_instance = function (id) {\n",
       "    if (_pyfunc_op_equals(id, \"body\")) {\n",
       "        return window.document.body;\n",
       "    } else {\n",
       "        return _pymeth_get.call(this.instances, id, null);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.init_socket = function () {\n",
       "    var WebSocket, address, err_2, on_ws_close, on_ws_error, on_ws_message, on_ws_open, proto, ws;\n",
       "    WebSocket = window.WebSocket;\n",
       "    if ((WebSocket === undefined)) {\n",
       "        window.document.body.textContent = \"Browser does not support WebSockets\";\n",
       "        throw \"FAIL: need websocket\";\n",
       "    }\n",
       "    if ((!_pyfunc_truthy(this.ws_url))) {\n",
       "        proto = \"ws\";\n",
       "        if (_pyfunc_op_equals(window.location.protocol, \"https:\")) {\n",
       "            proto = \"wss\";\n",
       "        }\n",
       "        address = window.location.hostname;\n",
       "        if (_pyfunc_truthy(window.location.port)) {\n",
       "            address = _pyfunc_op_add(address, \":\" + window.location.port);\n",
       "        }\n",
       "        this.ws_url = \"\" + proto + \"://\" + address + \"/flexx/ws/\" + this.app_name + \"\";\n",
       "    }\n",
       "    this.ws_url = _pymeth_replace.call(this.ws_url, \"0.0.0.0\", window.location.hostname);\n",
       "    this._ws = ws = new WebSocket(this.ws_url);\n",
       "    ws.binaryType = \"arraybuffer\";\n",
       "    this.status = 2;\n",
       "    on_ws_open = (function flx_on_ws_open (evt) {\n",
       "        window.console.info(\"Socket opened with session id \" + this.id);\n",
       "        this.send_command(\"HI_FLEXX\", this.id);\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_message = (function flx_on_ws_message (evt) {\n",
       "        var msg;\n",
       "        msg = _pyfunc_truthy(evt.data) || evt;\n",
       "        if ((this._pending_commands === null)) {\n",
       "            this._receive_raw_command(msg);\n",
       "        } else {\n",
       "            if ((this._pending_commands.length == 0)) {\n",
       "                window.setTimeout(this._process_commands, 0);\n",
       "            }\n",
       "            this._pending_commands.push(msg);\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_close = (function flx_on_ws_close (evt) {\n",
       "        var msg;\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "        msg = \"Lost connection with server\";\n",
       "        if ((_pyfunc_truthy(evt) && _pyfunc_truthy(evt.reason))) {\n",
       "            msg = _pyfunc_op_add(msg, \": \" + evt.reason + \" (\" + evt.code + \")\");\n",
       "        }\n",
       "        if ((!_pyfunc_truthy(window.flexx.is_notebook))) {\n",
       "            window.document.body.textContent = msg;\n",
       "        } else {\n",
       "            window.console.info(msg);\n",
       "        }\n",
       "        return null;\n",
       "    }).bind(this);\n",
       "\n",
       "    on_ws_error = function (evt) {\n",
       "        this._ws = null;\n",
       "        this.status = 0;\n",
       "        window.console.error(\"Socket error\");\n",
       "        return null;\n",
       "    };\n",
       "\n",
       "    ws.onopen = on_ws_open;\n",
       "    ws.onmessage = on_ws_message;\n",
       "    ws.onclose = on_ws_close;\n",
       "    ws.onerror = on_ws_error;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._process_commands = function () {\n",
       "    var command, err, msg;\n",
       "    while ((this._pending_commands !== null) && (this._pending_commands.length > 0)) {\n",
       "        msg = _pymeth_pop.call(this._pending_commands, 0);\n",
       "        try {\n",
       "            command = this._receive_raw_command(msg);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                window.setTimeout(this._process_commands, 0);\n",
       "                throw err;\n",
       "            }\n",
       "        }\n",
       "        if (_pyfunc_op_equals(command[0], \"DEFINE\")) {\n",
       "            this._asset_count = _pyfunc_op_add(this._asset_count, 1);\n",
       "            if ((_pyfunc_op_equals((this._asset_count % 3), 0))) {\n",
       "                if (this._pending_commands.length) {\n",
       "                    window.setTimeout(this._process_commands, 0);\n",
       "                }\n",
       "                break;\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_raw_command = function (msg) {\n",
       "    return this._receive_command(serializer.decode(msg));\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_command = function (command) {\n",
       "    var address, args, c, cmd, code, el, id, kind, name, ob, stub19_, stub20_, x;\n",
       "    cmd = command[0];\n",
       "    if (_pyfunc_op_equals(cmd, \"PING\")) {\n",
       "        window.setTimeout(this.send_command, 10, \"PONG\", command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INIT_DONE\")) {\n",
       "        window.flexx.spin(null);\n",
       "        while (this._pending_commands.length) {\n",
       "            this._receive_raw_command(_pymeth_pop.call(this._pending_commands, 0));\n",
       "        }\n",
       "        this._pending_commands = null;\n",
       "    } else if (_pyfunc_op_equals(cmd, \"PRINT\")) {\n",
       "        (_pyfunc_truthy(window.console.ori_log) || window.console.log)(command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"EXEC\")) {\n",
       "        eval(command[1]);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"EVAL\")) {\n",
       "        x = null;\n",
       "        if ((command.length == 2)) {\n",
       "            x = eval(command[1]);\n",
       "        } else if ((command.length == 3)) {\n",
       "            x = eval(_pyfunc_op_add(((\"this.instances.\" + command[1]) + \".\"), command[2]));\n",
       "        }\n",
       "        console.log(_pyfunc_str(x));\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INVOKE\")) {\n",
       "        stub19_ = command.slice(1);\n",
       "        id = stub19_[0];name = stub19_[1];args = stub19_[2];\n",
       "        ob = _pymeth_get.call(this.instances, id, null);\n",
       "        if ((ob === null)) {\n",
       "            console.warn(\"Cannot invoke \" + id + \".\" + name + \"; session does not know it (anymore).\");\n",
       "        } else if ((ob._disposed === true)) {\n",
       "        } else {\n",
       "            ob[name].apply(ob, args);\n",
       "        }\n",
       "    } else if (_pyfunc_op_equals(cmd, \"INSTANTIATE\")) {\n",
       "        this.instantiate_component.apply(this, command.slice(1));\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DISPOSE\")) {\n",
       "        id = command[1];\n",
       "        c = _pymeth_get.call(this.instances, id, null);\n",
       "        if (((c !== null) && (c._disposed === false))) {\n",
       "            c._dispose();\n",
       "        }\n",
       "        this.send_command(\"DISPOSE_ACK\", command[1]);\n",
       "        _pymeth_pop.call(this.instances, id, null);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DISPOSE_ACK\")) {\n",
       "        _pymeth_pop.call(this.instances, command[1], null);\n",
       "    } else if (_pyfunc_op_equals(cmd, \"DEFINE\")) {\n",
       "        stub20_ = command.slice(1);\n",
       "        kind = stub20_[0];name = stub20_[1];code = stub20_[2];\n",
       "        window.flexx.spin();\n",
       "        address = _pyfunc_op_add((window.location.protocol + \"//\"), (_pymeth_split.call(this.ws_url, \"/\")[2]));\n",
       "        code = _pyfunc_op_add(code, \"\\n//# sourceURL=\" + address + \"/flexx/assets/shared/\" + name + \"\\n\");\n",
       "        if (_pyfunc_op_equals(kind, \"JS-EVAL\")) {\n",
       "            eval(code);\n",
       "        } else if (_pyfunc_op_equals(kind, \"JS\")) {\n",
       "            el = window.document.createElement(\"script\");\n",
       "            el.id = name;\n",
       "            el.innerHTML = code;\n",
       "            window.flexx.asset_node.appendChild(el);\n",
       "        } else if (_pyfunc_op_equals(kind, \"CSS\")) {\n",
       "            el = window.document.createElement(\"style\");\n",
       "            el.type = \"text/css\";\n",
       "            el.id = name;\n",
       "            el.innerHTML = code;\n",
       "            window.flexx.asset_node.appendChild(el);\n",
       "        } else {\n",
       "            window.console.error((_pyfunc_op_add(((\"Dont know how to DEFINE \" + name) + (\" with \\\"\")), kind)) + (\"\\\".\"));\n",
       "        }\n",
       "    } else if (_pyfunc_op_equals(cmd, \"OPEN\")) {\n",
       "        window.win1 = window.open(command[1], \"new\", \"chrome\");\n",
       "    } else {\n",
       "        window.console.error(((\"Invalid command: \\\"\") + cmd) + (\"\\\"\"));\n",
       "    }\n",
       "    return command;\n",
       "};\n",
       "\n",
       "JsSession.prototype.call_after_roundtrip = function (callback) {\n",
       "    var args, ping_to_schedule_at;\n",
       "    args = Array.prototype.slice.call(arguments, 1);\n",
       "    ping_to_schedule_at = this._ping_counter + 1;\n",
       "    if (((this._ping_calls.length == 0) || ((this._ping_calls[this._ping_calls.length -1][0]) < ping_to_schedule_at))) {\n",
       "        window.setTimeout(this._send_ping, 0);\n",
       "    }\n",
       "    this._ping_calls.push([ping_to_schedule_at, callback, args]);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._send_ping = function () {\n",
       "    this._ping_counter = _pyfunc_op_add(this._ping_counter, 1);\n",
       "    this.send_command(\"PING\", this._ping_counter);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._receive_pong = function (count) {\n",
       "    var _, args, callback, stub21_;\n",
       "    while ((this._ping_calls.length > 0) && (((this._ping_calls[0][0]) <= count))) {\n",
       "        stub21_ = _pymeth_pop.call(this._ping_calls, 0);\n",
       "        _ = stub21_[0];callback = stub21_[1];args = stub21_[2];\n",
       "        window.setTimeout.apply(window, [].concat([callback, 0], args));\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype.keep_checking_size_of = function (ob, check) {\n",
       "    check = (check === undefined) ? true: check;\n",
       "    if (_pyfunc_truthy(check)) {\n",
       "        this.instances_to_check_size[ob.id] = ob;\n",
       "    } else {\n",
       "        _pymeth_pop.call(this.instances_to_check_size, ob.id, null);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "JsSession.prototype._check_size_of_objects = function () {\n",
       "    var ob, stub22_seq;\n",
       "    stub22_seq = this.instances_to_check_size;\n",
       "    for (ob in stub22_seq) {\n",
       "        if (!stub22_seq.hasOwnProperty(ob)){ continue; }\n",
       "        ob = stub22_seq[ob];\n",
       "        if ((ob._disposed === false)) {\n",
       "            ob.check_real_size();\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "{ /* if this_is_js() */\n",
       "window.flexx = new Flexx();\n",
       "bsdf = flexx.require('bsdf');\n",
       "serializer = new bsdf.BsdfSerializer();\n",
       "window.flexx.serializer = serializer;\n",
       "}\n",
       "\n",
       "return {Flexx: Flexx, JsSession: JsSession, bsdf: bsdf, serializer: serializer};\n",
       "});\n",
       "\n",
       "\n",
       "/* ======================= flexx.app._component2 ========================*/\n",
       "\n",
       "/* Autogenerated code from Flexx. Code Subject to the BSD-2-clause license. */\n",
       "\n",
       "\n",
       "\n",
       "flexx.define(\"flexx.app._component2\", [\"pscript-std.js\", \"flexx.event.js\", \"flexx.app._clientcore\"], function (_py, event, flexx$app$_clientcore) {\n",
       "\n",
       "\"use strict\";\n",
       "\n",
       "var _pyfunc_getattr = _py._pyfunc_getattr, _pyfunc_hasattr = _py._pyfunc_hasattr, _pyfunc_op_add = _py._pyfunc_op_add, _pyfunc_op_contains = _py._pyfunc_op_contains, _pyfunc_op_equals = _py._pyfunc_op_equals, _pyfunc_op_error = _py._pyfunc_op_error, _pyfunc_op_instantiate = _py._pyfunc_op_instantiate, _pyfunc_op_parse_kwargs = _py._pyfunc_op_parse_kwargs, _pyfunc_setattr = _py._pyfunc_setattr, _pyfunc_truthy = _py._pyfunc_truthy;\n",
       "\n",
       "var _pymeth_append = _py._pymeth_append, _pymeth_get = _py._pymeth_get, _pymeth_keys = _py._pymeth_keys, _pymeth_pop = _py._pymeth_pop;\n",
       "\n",
       "var serializer = flexx$app$_clientcore.serializer;\n",
       "\n",
       "var serializer = flexx$app$_clientcore.serializer;\n",
       "\n",
       "var logger = event.logger;\n",
       "\n",
       "var loop = event.loop;\n",
       "\n",
       "var Component = event.Component;\n",
       "\n",
       "var LocalProperty = event.LocalProperty;\n",
       "\n",
       "var Property = event.Property;\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "var LocalProperty;\n",
       "LocalProperty = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "LocalProperty.prototype = Object.create(Property.prototype);\n",
       "LocalProperty.prototype._base_class = Property.prototype;\n",
       "LocalProperty.prototype.__name__ = \"LocalProperty\";\n",
       "\n",
       "\n",
       "\n",
       "var BaseAppComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "BaseAppComponent.prototype = Object.create(Component.prototype);\n",
       "BaseAppComponent.prototype._base_class = Component.prototype;\n",
       "BaseAppComponent.prototype.__name__ = \"BaseAppComponent\";\n",
       "var $BaseAppComponent = BaseAppComponent.prototype;\n",
       "\n",
       "$BaseAppComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$BaseAppComponent.__properties__ = []\n",
       "$BaseAppComponent.__actions__ = []\n",
       "$BaseAppComponent.__emitters__ = []\n",
       "$BaseAppComponent.__reactions__ = []\n",
       "\n",
       "$BaseAppComponent._comp_init_app_component = function (property_values) {\n",
       "    var active, custom_id, err_2, session;\n",
       "    _pymeth_pop.call(property_values, \"flx_is_app\", null);\n",
       "    custom_id = _pymeth_pop.call(property_values, \"flx_id\", null);\n",
       "    this._session = null;\n",
       "    session = _pymeth_pop.call(property_values, \"flx_session\", null);\n",
       "    if ((session !== null)) {\n",
       "        this._session = session;\n",
       "    } else {\n",
       "        active = loop.get_active_components();\n",
       "        active = ((active.length > 1))? (active[active.length -2]) : (null);\n",
       "        if ((active !== null)) {\n",
       "            this._session = active._session;\n",
       "        } else if ((!\"this_is_js()\")) {\n",
       "        }\n",
       "    }\n",
       "    if ((this._session === null)) {\n",
       "        throw _pyfunc_op_error('RuntimeError', (\"\" + (_pyfunc_truthy(custom_id) || this._id) + \" needs a session!\"));\n",
       "    }\n",
       "    this._session._register_component(this, custom_id);\n",
       "    this._root = this._session.app;\n",
       "    return custom_id === null;\n",
       "};\n",
       "\n",
       "\n",
       "var LocalComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "LocalComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "LocalComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "LocalComponent.prototype.__name__ = \"LocalComponent\";\n",
       "var $LocalComponent = LocalComponent.prototype;\n",
       "\n",
       "$LocalComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$LocalComponent.__properties__ = []\n",
       "$LocalComponent.__actions__ = []\n",
       "$LocalComponent.__emitters__ = []\n",
       "$LocalComponent.__reactions__ = []\n",
       "$LocalComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$LocalComponent._comp_init_property_values = function (property_values) {\n",
       "    this._LocalComponent__event_types_at_proxy = [];\n",
       "    this._comp_init_app_component(property_values);\n",
       "    this._has_proxy = _pymeth_pop.call(property_values, \"flx_has_proxy\", false);\n",
       "    (BaseAppComponent.prototype._comp_init_property_values).call(this, property_values);\n",
       "    { /* if this_is_js() */\n",
       "    this._event_listeners = [];\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._ensure_proxy_instance = function (include_props) {\n",
       "    var name, props, stub1_seq, stub2_itr;\n",
       "    include_props = (include_props === undefined) ? true: include_props;\n",
       "    if (((this._has_proxy === false) && (this._disposed === false))) {\n",
       "        if ((this._session.status > 0)) {\n",
       "            props = ({});\n",
       "            if (_pyfunc_truthy(include_props)) {\n",
       "                stub1_seq = this.__proxy_properties__;\n",
       "                if ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "                for (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "                    name = stub1_seq[stub2_itr];\n",
       "                    props[name] = _pyfunc_getattr(this, name);\n",
       "                }\n",
       "            }\n",
       "            this._session.send_command(\"INSTANTIATE\", this.__jsmodule__, Object.getPrototypeOf(this).__name__, this._id, [], props);\n",
       "            this._has_proxy = true;\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent.emit = function (type, info) {\n",
       "    var ev, isprop;\n",
       "    info = (info === undefined) ? null: info;\n",
       "    ev = (BaseAppComponent.prototype.emit).call(this, type, info);\n",
       "    isprop = _pyfunc_op_contains(type, this.__proxy_properties__);\n",
       "    if (((this._has_proxy === true) && (this._session.status > 0))) {\n",
       "        if (_pyfunc_truthy(_pyfunc_truthy(isprop) || _pyfunc_op_contains(type, this._LocalComponent__event_types_at_proxy))) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_emit_at_proxy\", [ev]);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._dispose = function () {\n",
       "    var was_disposed;\n",
       "    was_disposed = this._disposed;\n",
       "    (BaseAppComponent.prototype._dispose).call(this);\n",
       "    this._has_proxy = false;\n",
       "    if (((was_disposed === false) && (this._session !== null))) {\n",
       "        this._session._unregister_component(this);\n",
       "        if ((this._session.status > 0)) {\n",
       "            this._session.send_command(\"DISPOSE\", this._id);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._flx_set_has_proxy = function (has_proxy) {\n",
       "    this._has_proxy = has_proxy;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$LocalComponent._flx_set_event_types_at_proxy = function (event_types) {\n",
       "    this._LocalComponent__event_types_at_proxy = event_types;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var ProxyComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "ProxyComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "ProxyComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "ProxyComponent.prototype.__name__ = \"ProxyComponent\";\n",
       "var $ProxyComponent = ProxyComponent.prototype;\n",
       "\n",
       "$ProxyComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$ProxyComponent.__properties__ = []\n",
       "$ProxyComponent.__actions__ = [\"_emit_at_proxy\"]\n",
       "$ProxyComponent.__emitters__ = []\n",
       "$ProxyComponent.__reactions__ = []\n",
       "$ProxyComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$ProxyComponent.__init__ = function () {\n",
       "    var err_2, init_args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        init_args = arguments[0].flx_args;\n",
       "    } else {init_args = Array.prototype.slice.call(arguments);}\n",
       "    { /* if this_is_js() */\n",
       "    if (!(init_args.length == 0)) { throw _pyfunc_op_error('AssertionError', \"init_args.length == 0\");}\n",
       "    if ((!_pyfunc_op_contains(\"flx_id\", kwargs))) {\n",
       "        throw _pyfunc_op_error('RuntimeError', \"Cannot instantiate a PyComponent from JS.\");\n",
       "    }\n",
       "    (BaseAppComponent.prototype.__init__).call(this, {flx_args: [], flx_kwargs: kwargs});\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._comp_init_property_values = function (property_values) {\n",
       "    var local_inst, props2set;\n",
       "    local_inst = this._comp_init_app_component(property_values);\n",
       "    props2set = (_pyfunc_truthy(local_inst))? (({})) : (property_values);\n",
       "    (BaseAppComponent.prototype._comp_init_property_values).call(this, props2set);\n",
       "    { /* if this_is_js() */\n",
       "    if (!(_pyfunc_op_equals((_pymeth_keys.call(property_values).length), 0))) { throw _pyfunc_op_error('AssertionError', \"_pyfunc_op_equals((_pymeth_keys.call(property_values).length), 0)\");}\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._comp_apply_property_values = function (values) {\n",
       "    var name, stub1_seq, stub2_itr, stub3_tgt, value;\n",
       "    stub1_seq = values;\n",
       "    if ((typeof stub1_seq === \"object\") && (!Array.isArray(stub1_seq))) { stub1_seq = Object.keys(stub1_seq);}\n",
       "    for (stub2_itr = 0; stub2_itr < stub1_seq.length; stub2_itr += 1) {\n",
       "        stub3_tgt = stub1_seq[stub2_itr];\n",
       "        name = stub3_tgt[0]; value = stub3_tgt[1];\n",
       "        _pyfunc_setattr(this, ((\"_\" + name) + \"_value\"), value);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._proxy_action = function (name) {\n",
       "    var args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        name = arguments[0].flx_args[0];\n",
       "        args = arguments[0].flx_args.slice(1);\n",
       "    } else {args = Array.prototype.slice.call(arguments, 1);}\n",
       "    if (!(!_pyfunc_truthy(kwargs))) { throw _pyfunc_op_error('AssertionError', \"!_pyfunc_truthy(kwargs)\");}\n",
       "    this._session.send_command(\"INVOKE\", this._id, name, args);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._proxy_emitter = function (name) {\n",
       "    var args, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        name = arguments[0].flx_args[0];\n",
       "        args = arguments[0].flx_args.slice(1);\n",
       "    } else {args = Array.prototype.slice.call(arguments, 1);}\n",
       "    { /* if this_is_js() */\n",
       "    logger.error(\"Cannot use emitters of a PyComponent in JS.\");\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._mutate = function () {\n",
       "    var args, err_1, kwargs;\n",
       "    kwargs = {};\n",
       "    if (arguments.length == 1 && typeof arguments[0] == 'object' && Object.keys(arguments[0]).toString() == 'flx_args,flx_kwargs') {\n",
       "        kwargs = _pyfunc_op_parse_kwargs([], [], arguments[0].flx_kwargs);\n",
       "        args = arguments[0].flx_args;\n",
       "    } else {args = Array.prototype.slice.call(arguments);}\n",
       "    throw _pyfunc_op_error('RuntimeError', \"Cannot mutate properties from a proxy class.\");\n",
       "    serializer;\n",
       "    BsdfComponentExtension;\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._registered_reactions_hook = function () {\n",
       "    var event_types;\n",
       "    event_types = (BaseAppComponent.prototype._registered_reactions_hook).call(this);\n",
       "    try {\n",
       "        if (((this._disposed === false) && (this._session.status > 0))) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_flx_set_event_types_at_proxy\", [event_types]);\n",
       "        }\n",
       "    } finally {\n",
       "        return event_types;\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._emit_at_proxy = function _emit_at_proxy (ev) {\n",
       "    if ((!\"this_is_js()\")) {\n",
       "    }\n",
       "    if ((_pyfunc_op_contains(ev.type, this.__properties__) && _pyfunc_hasattr(ev, \"mutation\"))) {\n",
       "        if (_pyfunc_op_equals(ev.mutation, \"set\")) {\n",
       "            (BaseAppComponent.prototype._mutate).call(this, ev.type, ev.new_value);\n",
       "        } else {\n",
       "            (BaseAppComponent.prototype._mutate).call(this, ev.type, ev.objects, ev.mutation, ev.index);\n",
       "        }\n",
       "    } else {\n",
       "        this.emit(ev.type, ev);\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "$ProxyComponent._emit_at_proxy.nobind = true;\n",
       "\n",
       "$ProxyComponent.dispose = function () {\n",
       "    var err_1;\n",
       "    { /* if this_is_js() */\n",
       "    throw _pyfunc_op_error('RuntimeError', \"Cannot dispose a PyComponent from JS.\");\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$ProxyComponent._dispose = function () {\n",
       "    var was_disposed;\n",
       "    was_disposed = this._disposed;\n",
       "    (BaseAppComponent.prototype._dispose).call(this);\n",
       "    if (((was_disposed === false) && (this._session !== null))) {\n",
       "        this._session._unregister_component(this);\n",
       "        if ((this._session.status > 0)) {\n",
       "            this._session.send_command(\"INVOKE\", this._id, \"_flx_set_has_proxy\", [false]);\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var StubComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "StubComponent.prototype = Object.create(BaseAppComponent.prototype);\n",
       "StubComponent.prototype._base_class = BaseAppComponent.prototype;\n",
       "StubComponent.prototype.__name__ = \"StubComponent\";\n",
       "var $StubComponent = StubComponent.prototype;\n",
       "\n",
       "$StubComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$StubComponent.__properties__ = []\n",
       "$StubComponent.__actions__ = []\n",
       "$StubComponent.__emitters__ = []\n",
       "$StubComponent.__reactions__ = []\n",
       "$StubComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "$StubComponent.__init__ = function (session, id) {\n",
       "    (BaseAppComponent.prototype.__init__).call(this);\n",
       "    this._session = session;\n",
       "    this._id = id;\n",
       "    this._uid = _pyfunc_op_add((session.id + \"_\"), id);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "var JsComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "JsComponent.prototype = Object.create(LocalComponent.prototype);\n",
       "JsComponent.prototype._base_class = LocalComponent.prototype;\n",
       "JsComponent.prototype.__name__ = \"JsComponent\";\n",
       "var $JsComponent = JsComponent.prototype;\n",
       "\n",
       "$JsComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$JsComponent.__properties__ = []\n",
       "$JsComponent.__actions__ = []\n",
       "$JsComponent.__emitters__ = []\n",
       "$JsComponent.__reactions__ = []\n",
       "$JsComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "$JsComponent.__proxy_properties__ = []\n",
       "\n",
       "$JsComponent._addEventListener = function (node, type, callback, capture) {\n",
       "    capture = (capture === undefined) ? false: capture;\n",
       "    node.addEventListener(type, callback, capture);\n",
       "    _pymeth_append.call(this._event_listeners, [node, type, callback, capture]);\n",
       "    return null;\n",
       "};\n",
       "\n",
       "$JsComponent._dispose = function () {\n",
       "    var callback, capture, err, node, stub1_, type;\n",
       "    (LocalComponent.prototype._dispose).call(this);\n",
       "    while (this._event_listeners.length > 0) {\n",
       "        try {\n",
       "            stub1_ = this._event_listeners.pop();\n",
       "            node = stub1_[0];type = stub1_[1];callback = stub1_[2];capture = stub1_[3];\n",
       "            node.removeEventListener(type, callback, capture);\n",
       "        } catch(err_3) {\n",
       "            {\n",
       "                err = err_3;\n",
       "                console.log(err);\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return null;\n",
       "};\n",
       "\n",
       "\n",
       "\n",
       "var PyComponent = function () {\n",
       "    _pyfunc_op_instantiate(this, arguments);\n",
       "}\n",
       "PyComponent.prototype = Object.create(ProxyComponent.prototype);\n",
       "PyComponent.prototype._base_class = ProxyComponent.prototype;\n",
       "PyComponent.prototype.__name__ = \"PyComponent\";\n",
       "var $PyComponent = PyComponent.prototype;\n",
       "\n",
       "$PyComponent.__attributes__ = [\"id\", \"root\", \"session\", \"uid\"]\n",
       "$PyComponent.__properties__ = []\n",
       "$PyComponent.__actions__ = [\"_emit_at_proxy\"]\n",
       "$PyComponent.__emitters__ = []\n",
       "$PyComponent.__reactions__ = []\n",
       "$PyComponent.__jsmodule__ = \"flexx.app._component2\"\n",
       "\n",
       "\n",
       "var BsdfComponentExtension = {name: \"flexx.app.component\",\n",
       "    match: function (s, c) {\n",
       "        return c instanceof BaseAppComponent;\n",
       "    },\n",
       "    encode: function (s, c) {\n",
       "        if (_pyfunc_truthy(c instanceof JsComponent)) {\n",
       "            c._ensure_proxy_instance();\n",
       "        }\n",
       "        return {session_id:c._session.id, id:c._id};\n",
       "    },\n",
       "    decode: function (s, d) {\n",
       "        var c, session;\n",
       "        c = null;\n",
       "        session = _pymeth_get.call(window.flexx.sessions, d[\"session_id\"], null);\n",
       "        if ((session === null)) {\n",
       "            session = {id:d[\"session_id\"]};\n",
       "            c = new StubComponent(session, d[\"id\"]);\n",
       "        } else {\n",
       "            c = session.get_component_instance(d[\"id\"]);\n",
       "            if ((c === null)) {\n",
       "                logger.warn(\"Using stub component for \" + d[\"id\"] + \".\");\n",
       "                c = new StubComponent(session, d[\"id\"]);\n",
       "            }\n",
       "        }\n",
       "        return c;\n",
       "    }};\n",
       "serializer.add_extension(BsdfComponentExtension);\n",
       "\n",
       "\n",
       "return {JsComponent: JsComponent, LocalProperty: LocalProperty, PyComponent: PyComponent};\n",
       "});\n",
       "\n",
       "</script><script>\n",
       "            flexx.is_notebook = true;\n",
       "            flexx.is_exported = !flexx.is_live_notebook;\n",
       "            /* If Phosphor is already loaded, disable our Phosphor CSS. */\n",
       "            if (window.jupyter && window.jupyter.lab) {\n",
       "                document.getElementById('phosphor-all.css').disabled = true;\n",
       "            }\n",
       "            flexx.init();\n",
       "            flexx.create_session(\"__default__\", \"4u4r0ghNtOUZ7xmw91Zvb41d\", \"ws://localhost:49191/flexx/ws/__default__\");\n",
       "            </script><i>Flexx is ready for use</i>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%gui asyncio\n",
    "flx.init_notebook()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyComponent(flx.JsComponent):\n",
    "\n",
    "    foo = flx.StringProp('', settable=True)\n",
    "        \n",
    "    @flx.reaction('foo')\n",
    "    def on_foo(self, *events):\n",
    "        if self.foo:\n",
    "            window.alert('foo is ' + self.foo, + len(events))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "var bb64 =  flexx.require(\"bb64\");\n",
       "function cmd(c) {flexx.s1._receive_command(flexx.serializer.decode(bb64.decode(c)));}\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbAdzC0lOU1RBTlRJQVRFcwhfX21haW5fX3MLTXlDb21wb25lbnRzDU15Q29tcG9uZW50XzJsAG0BDWZseF9oYXNfcHJveHl5bAA=\");"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = MyComponent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JsComponent 'MyComponent_2' at 0x1dd22f0d668>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "var bb64 =  flexx.require(\"bb64\");\n",
       "function cmd(c) {flexx.s1._receive_command(flexx.serializer.decode(bb64.decode(c)));}\n",
       "cmd(\"QlNERgIBbARzBklOVk9LRXMNTXlDb21wb25lbnRfMnMHc2V0X2Zvb2wBcwRoZWxv\");"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "m.set_foo('helo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use an example model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "var bb64 =  flexx.require(\"bb64\");\n",
       "function cmd(c) {flexx.s1._receive_command(flexx.serializer.decode(bb64.decode(c)));}\n",
       "cmd(\"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\");\n",
       "cmd(\"QlNERgIBbAZzC0lOU1RBTlRJQVRFcx5mbGV4eGFtcGxlcy50ZXN0ZXJzLmZpbmRfcHJpbWVzC1ByaW1lRmluZGVycw1QcmltZUZpbmRlcl8zbABtAA==\");\n",
       "cmd(\"QlNERgIBbAdzC0lOU1RBTlRJQVRFcx5mbGV4eGFtcGxlcy50ZXN0ZXJzLmZpbmRfcHJpbWVzDVByaW1lRmluZGVySnNzD1ByaW1lRmluZGVySnNfNGwAbQENZmx4X2hhc19wcm94eXlsAU0TZmxleHguYXBwLmNvbXBvbmVudAIKc2Vzc2lvbl9pZHMYNHU0cjBnaE50T1VaN3htdzkxWnZiNDFkAmlkcw1QcmltZUZpbmRlcl8z\");"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from flexxamples.testers.find_prime import PrimeFinder\n",
    "p = PrimeFinder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<PyComponent 'PrimeFinder_3' at 0x1dd22f02c50>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17389 found in  0.5967290135927767 seconds\n"
     ]
    }
   ],
   "source": [
    "p.find_prime_py(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<PyComponent 'PrimeFinder_3' at 0x1dd22f02c50>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.find_prime_js(2000)  # Result is written to JS console, open F12 to see it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}