From 5d78f96b3d746f06d77ec46cc11aa9896d0257fa Mon Sep 17 00:00:00 2001 From: denim2x Date: Fri, 31 May 2019 09:34:20 +0300 Subject: [PATCH] Initialize repository Signed-off-by: denim2x --- .cfignore | 10 ++ .gitignore | 71 ++++++++++++ LICENSE | 7 ++ Procfile | 1 + README.md | 25 ++++ _bareasgi.py | 10 ++ app.js | 136 ++++++++++++++++++++++ config.py | 227 +++++++++++++++++++++++++++++++++++++ engine.py | 109 ++++++++++++++++++ main.py | 20 ++++ manifest.yml | 7 ++ package.json | 27 +++++ requirements.txt | 7 ++ runtime.txt | 1 + static/app.js | 65 +++++++++++ static/favicon.png | Bin 0 -> 615 bytes static/icon-512.png | Bin 0 -> 2920 bytes static/index.html | 41 +++++++ static/master.css | 216 +++++++++++++++++++++++++++++++++++ util/__init__.py | 251 +++++++++++++++++++++++++++++++++++++++++ util/list.py | 78 +++++++++++++ util/priority_queue.py | 204 +++++++++++++++++++++++++++++++++ util/pyquery.py | 94 +++++++++++++++ util/request.py | 23 ++++ util/set.py | 107 ++++++++++++++++++ util/url.py | 84 ++++++++++++++ watson/__init__.py | 8 ++ watson/assistant.py | 164 +++++++++++++++++++++++++++ 28 files changed, 1993 insertions(+) create mode 100644 .cfignore create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 Procfile create mode 100644 README.md create mode 100644 _bareasgi.py create mode 100644 app.js create mode 100644 config.py create mode 100644 engine.py create mode 100644 main.py create mode 100644 manifest.yml create mode 100644 package.json create mode 100644 requirements.txt create mode 100644 runtime.txt create mode 100644 static/app.js create mode 100644 static/favicon.png create mode 100644 static/icon-512.png create mode 100644 static/index.html create mode 100644 static/master.css create mode 100644 util/__init__.py create mode 100644 util/list.py create mode 100644 util/priority_queue.py create mode 100644 util/pyquery.py create mode 100644 util/request.py create mode 100644 util/set.py create mode 100644 util/url.py create mode 100644 watson/__init__.py create mode 100644 watson/assistant.py diff --git a/.cfignore b/.cfignore new file mode 100644 index 0000000..882ee29 --- /dev/null +++ b/.cfignore @@ -0,0 +1,10 @@ +.gitignore +LICENSE +README.md +vcap-local.json +node_modules +.settings +.git +.project +.pydevproject +*tmp-browserify* \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..04270dd --- /dev/null +++ b/.gitignore @@ -0,0 +1,71 @@ +# Logs +logs +*.log + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +bin/ +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +/lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# python virtual environment/compiled files +venv/ +*.pyc + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Intellij/PyCharm config +.idea/ + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo +*.pot + +# PyBuilder +target/ + +# Mac files +*.DS_Store + +vcap-local.json +node_modules +.settings +.project +.pydevproject +config.yaml +*tmp-browserify* diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8471e1c --- /dev/null +++ b/LICENSE @@ -0,0 +1,7 @@ +Copyright 2019 denim2x (denim2x.ml) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/Procfile b/Procfile new file mode 100644 index 0000000..469ae06 --- /dev/null +++ b/Procfile @@ -0,0 +1 @@ +web: python3 main.py diff --git a/README.md b/README.md new file mode 100644 index 0000000..0088c60 --- /dev/null +++ b/README.md @@ -0,0 +1,25 @@ +# Whizbot +Engage into interesting conversations with this multi-purpose chatbot + +## Description +This project aims to develop an interesting conversational agent with the following capabilities: + - describes itself, its abilities and others; + - answers open-ended questions with information from Wikipedia; + - displays Weather data; + - shows Chuck Norris jokes. + +## Architecture +### Frontend +- HTML5 +- JavaScript (ES6) +- CSS3 +- Rivets.js +- Domtastic + +### Backend +- Web server developed in Python3 with BareASGI, hosted on CloudFoundry service; +- Watson Assistant, for classifying intents and modeling appropriate responses; +- Weather Company Data for IBM Bluemix - for retrieving weather information; +- Wikipedia Search API - for retrieving answers to open-ended questions; +- Chuck Norris jokes API. + diff --git a/_bareasgi.py b/_bareasgi.py new file mode 100644 index 0000000..4c3ffaf --- /dev/null +++ b/_bareasgi.py @@ -0,0 +1,10 @@ +import bareasgi as _bareasgi +from bareasgi import * + +def json_response(data, status=200, headers={}): + headers = [] # FIXME + return _bareasgi.json_response(status, headers, data) + +def text_response(text, status=200, headers={}): + headers = [] + return _bareasgi.text_response(status, headers, text) diff --git a/app.js b/app.js new file mode 100644 index 0000000..108e072 --- /dev/null +++ b/app.js @@ -0,0 +1,136 @@ +'use strict'; +/*jslint node: true */ +/*jslint esversion: 6 */ +/* globals $: true */ +/* eqeqeq: false */ +/* -W041: false */ +const type = require('type-of'); +const request = require('superagent'); +const h = require('hyperscript-string'); +const $ = require('domtastic'); +const rivets = require('rivets'); + +$.fn.clear = function() { + this.forEach((e) => { + e.innerHTML = ''; + }); + return this; +}; + +$.fn.outerHTML = function() { + return this.prop('outerHTML'); +}; + +const state = { + message: '', + knowledge: [], + conversation: [], + error: false +}; + +function _error(method, url, { response: res }) { + res = res ? [res.status, res.text] : []; + console.warn(`[${method} ${url}]`, ...res); +} + +function send_message(text='', cb) { + request.post('/message').send(text).then(({ body }) => { + state.conversation.push({ text: body }); + }, (e) => { + _error('POST', '/message', e); + cb && cb(); + }); +} + +send_message(); + +$('.Conversation-input') + .on('keydown', (e) => { + let message = state.message; + if (e.code == 'Enter' && !e.shiftKey && !e.altKey && !e.ctrlKey) { + if (message == '') + return; + state.message = ''; + state.conversation.push({ text: message.split(/\s*[\n\r]+\s*/g), is_user: true }); + send_message(message, () => { + state.error = true; + }); + return false; + } + }) + .on('paste', (e) => { + e.preventDefault(); + let text = e.clipboardData.getData("text/plain"); + document.execCommand("insertHTML", false, text); + return false; + }); + +function _const(self, key, value) { + Object.defineProperty(self, key, { + value, writable: false, enumerable: true, configurable: true + }); + return self; +} + +const { Binding } = rivets._; +rivets._.Binding = class extends Binding { + parseTarget() { + if (this.binder.parseTarget) { + Object.assign(this, this.binder.parseTarget(this.keypath)); + } + return super.parseTarget(); + } + + publish() { + _const(this, 'state', 'publish'); + let ret = super.publish(); + _const(this, 'state'); + } +}; + +rivets.binders['input'] = { + parseTarget(keypath) { + let empty_class; + [keypath, empty_class] = keypath.trim().split(/\s*\?\s*/); + return { keypath, empty_class }; + }, + + bind: function(el) { + this._empty = true; + $(el).on('input.rv-input', this.publish); + this._watch = () => { + el.innerHTML = ''; + if (el.innerHTML == '') { + clearInterval(this._watcher); + } + }; + }, + + unbind: function(el) { + $(el).off('.rv-input'); + clearInterval(this._watcher); + }, + + routine: function(el, value) { + if (this.state != 'publish') { + clearInterval(this._watcher); + el.innerText = value; + } + state.error = false; + this._empty = value == ''; + if (this._empty) { + this._watcher = setInterval(this._watch, 30); + } + if (this.empty_class) { + $(el).toggleClass(this.empty_class, this._empty); + } + }, + + getValue : function(el) { + return el.innerText.trim(); + } +}; + +global.$state = state; + +rivets.bind(document.body, state); diff --git a/config.py b/config.py new file mode 100644 index 0000000..2c02523 --- /dev/null +++ b/config.py @@ -0,0 +1,227 @@ +import os, re +from itertools import chain, zip_longest +from collections import namedtuple + +from munch import munchify +import yaml + +from util import realpath, Object, Executor, HTMLParser +from util.request import Request + + +with open(realpath('config.yaml')) as f: + data = yaml.load(f, Loader=yaml.SafeLoader) + locals().update(munchify(data)) + +class chuck_norris: + _base = 'https://api.chucknorris.io/jokes' + _categories = Request('GET', f'{_base}/categories') + _random = Request('GET', f'{_base}/random') + + @classmethod + def categories(cls, raw=False): + ret = cls._categories().json() + if raw: + return ret + return ', '.join(ret) + + @classmethod + def random(cls, category=None, count=1, raw=False): + params = None + if category: + params = { 'category': category } + + executor = Executor() + for i in executor(count): + executor[cls._random](params=params) + + ret = [munchify(e.json()) for e in executor.collect()] + if raw: + return ret + return [e.value for e in ret] + +_parser = HTMLParser() +def strip_html(html): + return _parser(html).text + +class Snippet: + def __init__(self, data): + self._data = data + self._text = strip_html(data.snippet).strip() + if not re.match(r'^.*[\.!\?]$', self._text): + self._text = f"{self._text}…" + self._caption = data.title + + def __bool__(self): + return bool(self._text) + + @property + def text(self): + return self._text + + @property + def caption(self): + return self._caption + +class wikipedia: + _base = 'https://en.wikipedia.org/w/api.php' + _search = Request('GET', _base, params={ + 'action': 'query', + 'format': 'json', + 'list': 'search', + 'srsort': 'relevance', + 'srenablerewrites': 'on' + }) + def __new__(cls, query, type=None, count=None): + params = { 'srsearch': query } + if count is not None: + params['srlimit'] = count + if type is not None: + params['srprop'] = type + res = cls._search(params=params) + if not res.ok: + return [] + return munchify(res.json()).query.search + + @classmethod + def snippets(cls, query, count=None): + return [Snippet(e) for e in cls(query, 'snippet', count)] + + @classmethod + def snippet(cls, query): + ret = cls.snippets(query, 1) + return ret[0] if ret else None + +_units = Object(metric='m', imperial='e') +units_ = Object(m='metric', e='imperial') + +Precipitation = namedtuple('Precipitation', 'total hourly snow') + +class Value(dict): + def __init__(self, units, type): + super().__init__() + self._units = units + self._unit = Units[units].get(type, '') + + def _format(self, key): + return f"{self[key]}{self._unit}" + +class Temperature(Value): + def __init__(self, value, feel, min, max, units): + super().__init__(units, 'temperature') + self['value'] = value + self['feel'] = feel + + def __bool__(self): + return bool(self['value']) + + @property + def value(self): + return self._format('value') + + @property + def feel(self): + return self._format('feel') + +class Wind(Value): + def __init__(self, speed, direction, units): + super().__init__(units, 'speed') + self['speed'] = speed + self['direction'] = direction or '' + + def __bool__(self): + return bool(self['speed']) + + @property + def speed(self): + return self._format('speed') + + @property + def direction(self): + return self['direction'] + +Units = Object( + metric = Object( + temperature = '°C', + speed = ' km/h', + ), +) + +class Observation: + def __init__(self, data): + self._meta = data.metadata + self._units = units_[self._meta.units] + data = data.observation + self._data = data + self._precipitation = Precipitation(data.precip_total, data.precip_hrly, data.snow_hrly) + self._temperature = Temperature(data.temp, data.feels_like, data.min_temp, data.max_temp, self._units) + self._wind = Wind(data.wspd, data.wdir_cardinal, self._units) + + @property + def units(self): + return self._units + + @property + def observation(self): + return self._data.wx_phrase + + @property + def temperature(self): + return self._temperature + + @property + def precipitation(self): + return self._precipitation + + @property + def wind(self): + return self._wind + + @property + def pressure(self): + return self._data.pressure + + @property + def visibility(self): + return self._data.vis + +class Weather: + notions = { 'forecast', 'humidity', 'precipitation', 'pressure', 'temperature', 'visibility', 'weather', 'wind speed' } + def __init__(self, host, username, password): + self._host = host + self._auth = (username, password) + self._url = f"https://{host}/api/weather" + self._language = 'en-US' + self._params = dict(language=self._language) + self._location = Request('GET', f"{self._url}/v3/location/search", params=self._params, auth=self._auth) + self._current = None + + def __bool__(self): + return bool(self._current) + + def location(self, query): + res = self._location(params=dict(query=query)) + if not res.ok: + return False + location = res.result().location + latitude = location.latitude[0] + longitude = location.longitude[0] + geocode = f"geocode/{latitude}/{longitude}" + self._current = Request('GET', f"{self._url}/v1/{geocode}/observations.json", params=self._params, auth=self._auth) + return True + + def forecast(self, hours=None, days=None): + pass + + def get_params(self, units): + units = _units.get(units, units) + return dict(units=units, **self._params) + + def current(self, units='m'): + if not self: + return + res = self._current(params=self.get_params(units)) + if res.ok: + return Observation(res.result()) + +__all__ = { 'ibm_cloud', 'chuck_norris', 'wikipedia' } diff --git a/engine.py b/engine.py new file mode 100644 index 0000000..f6deacc --- /dev/null +++ b/engine.py @@ -0,0 +1,109 @@ +import re + +from _bareasgi import text_reader, text_response, json_response +from config import ibm_cloud, chuck_norris, wikipedia, Weather +from watson import Assistant +from util import split + + +def _clean(text): + """Strips any CR/LF/TAB characters from text""" + if text is None: + return None + return re.sub(r"\s+", " ", text) + +weather = Weather(**ibm_cloud.weather) + +assistant = Assistant(**ibm_cloud.chatbot) +wikibot = Assistant.v1(**ibm_cloud.wikibot) +assistant.link(wikibot, 0.9) + +def retry(): + return json_response(assistant(intents=['retry']).text) + +_weather = None + +async def message(scope, info, matches, content): + global _weather + text = _clean((await text_reader(content)).strip().lstrip('.').lstrip()) + if text == '': + return json_response(assistant(intents=['welcome']).text) + + if not _weather: + res = assistant(text) + if res is None: + return json_response(res.data, 404) + + if not res.intent or res.confidence < 0.9: + ret = wikipedia.snippet(text) + if not ret: + return retry() + + wikibot[text, ret.caption] = ret.text + return json_response(split(ret.text)) + else: + res = assistant(text, bypass=True) + if res and res.intent and res.confidence >= 0.9: + _weather = None + return json_response(res.text) + + if _weather or res.intent == 'weather': + if _weather: + notions = _weather + location = text + else: + ret = dict(res.entities['notion']) + notions = set() + for notion in set(ret): + if notion in Weather.notions: + notions.add(notion) + del ret[notion] + + locations = list(ret.values()) + location = locations[0].value if locations else None + if not location and not weather: + _weather = notions + return json_response(res.text) + + if location and not weather.location(location): + return retry() + + _weather = None + obs = weather.current() + if not obs: + return retry() + + answer = [] + if obs.observation: + answer.append(obs.observation) + + if 'weather' in notions: + notions.update({ 'temperature', 'wind speed' }) + + if 'temperature' in notions: + e = obs.temperature + if e: + answer.append(f"temperature: {e.value} (feels like: {e.feel})") + + if 'wind speed' in notions: + e = obs.wind + if e: + answer.append(f"wind: {e.direction} {e.speed}") + + if not answer: + return retry() + + return json_response(answer) + + if res.intent == 'chuck_norris': + category = res.entities['domain'].get('value') + if ('notion', 'categories') in res.entities: + ret = [chuck_norris.categories()] + elif ('notion', 'joke') in res.entities: + ret = chuck_norris.random(category) + else: + ret = chuck_norris.random(category, 3) + return json_response(ret) + + return json_response(res.text) + diff --git a/main.py b/main.py new file mode 100644 index 0000000..d8296d5 --- /dev/null +++ b/main.py @@ -0,0 +1,20 @@ +#!/usr/bin/python3 +# -*- coding: utf-8 -*- + +import os + +import uvicorn +from _bareasgi import Application +from bareasgi_static import add_static_file_provider + +from engine import message + +here = os.path.abspath(os.path.dirname(__file__)) + +app = Application() +app.http_router.add({'POST'}, '/message', message) + +add_static_file_provider(app, os.path.join(here, 'static'), index_filename='index.html') + +port = int(os.getenv('PORT', '80')) +uvicorn.run(app, host='0.0.0.0', port=port) diff --git a/manifest.yml b/manifest.yml new file mode 100644 index 0000000..67c38e0 --- /dev/null +++ b/manifest.yml @@ -0,0 +1,7 @@ +applications: + - name: Whizbot + host: whizbot + command: python3 main.py + buildpack: python_buildpack + domain: apps.internal + diff --git a/package.json b/package.json new file mode 100644 index 0000000..a25ff4c --- /dev/null +++ b/package.json @@ -0,0 +1,27 @@ +{ + "name": "web-knowledge-assistant", + "description": "An engaging virtual assistant capable of answering arbitrary open-ended questions", + "version": "1.0.0", + "author": "denim2x ", + "license": "MIT", + "repository": "github:denim2x/web-knowledge-assistant", + "devDependencies": { + "@vendhq/uglifyify": "^5.1.0", + "browserify": "^16.2.3" + }, + "dependencies": { + "domtastic": "^0.15.12", + "hyperscript-string": "^2.1.0", + "install": "^0.12.2", + "npm": "^6.9.0", + "rivets": "^0.9.6", + "superagent": "4.1.0", + "type-of": "^2.0.1" + }, + "scripts": { + "build": "browserify app.js -d -o static/app.js", + "prestart": "browserify app.js -g uglifyify -d -o static/app.js", + "start": "npm run-script serve", + "serve": "python3 main.py" + } +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..1e47a32 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +ibm-watson +uvicorn==0.7.0 +bareasgi==1.0.3 +bareasgi_static +munch +requests +PyYAML diff --git a/runtime.txt b/runtime.txt new file mode 100644 index 0000000..a486801 --- /dev/null +++ b/runtime.txt @@ -0,0 +1 @@ +python-3.7.x \ No newline at end of file diff --git a/static/app.js b/static/app.js new file mode 100644 index 0000000..dddb741 --- /dev/null +++ b/static/app.js @@ -0,0 +1,65 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i1?t-1:0),i=1;i]*>/,f=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,a=/^[.#]?[\w-]*$/,l=function(e,t){var n;if(void 0===t&&(t=document),e){if(e instanceof y)return e;"string"!=typeof e?n=e.nodeType||e===window?[e]:e:c.test(e)?n=v(e):(t="string"==typeof t?document.querySelector(t):t.length?t[0]:t,n=p(e,t))}else n=document.querySelectorAll(null);return m(n)},d=function(e){var t=[];return r(this,function(n){return r(p(e,n),function(e){-1===t.indexOf(e)&&t.push(e)})}),l(t)},h=(e="undefined"!=typeof Element?Element.prototype:n,t=e.matches||e.matchesSelector||e.mozMatchesSelector||e.msMatchesSelector||e.oMatchesSelector||e.webkitMatchesSelector,function(e,n){return t.call(e,n)}),p=function(e,t){if(a.test(e)){if("#"===e[0]){var n=(t.getElementById?t:document).getElementById(e.slice(1));return n?[n]:[]}return"."===e[0]?t.getElementsByClassName(e.slice(1)):t.getElementsByTagName(e)}return t.querySelectorAll(e)},v=function(e){if(f.test(e))return[document.createElement(RegExp.$1)];var t=[],n=document.createElement("div"),i=n.childNodes;n.innerHTML=e;for(var r=0,o=i.length;r0?this[0].value:void 0:r(this,function(t){return t.value=e})}}),X=Object.freeze({html:function(e){if(void 0===e){var t=this.nodeType?this:this[0];return t?t.innerHTML:void 0}return r(this,function(t){return t.innerHTML=e})}}),Y=function(){var e=function(e,t){var n=[];return r(this,function(i){for(;i&&i!==t;){if(h(i,e)){n.push(i);break}i=i.parentElement}}),l(u(n))};return"undefined"!=typeof Element&&Element.prototype.closest?function(t,n){if(n)return e.call(this,t,n);var i=[];return r(this,function(e){var n=e.closest(t);n&&i.push(n)}),l(u(i))}:e}(),ee=Object.freeze({closest:Y}),te=function(e,t,n,i,o){var u,s,c,f=this;return"function"==typeof t&&(n=t,t=null),e.split(" ").forEach(function(a){u=a.split("."),a=u[0]||null,s=u[1]||null,c=fe(n),r(f,function(r){if(t&&(c=pe.bind(r,t,c)),o){var u=c;c=function(o){ne.call(r,e,t,n,i),u.call(r,o)}}r.addEventListener(a,c,i||!1),se(r).push({eventName:a,handler:n,eventListener:c,selector:t,namespace:s})})},this),this},ne=function(e,t,n,i){var o,u,s,c=this;return void 0===e&&(e=""),"function"==typeof t&&(n=t,t=null),e.split(" ").forEach(function(e){return o=e.split("."),e=o[0]||null,u=o[1]||null,r(c,function(o){s=se(o),r(s.filter(function(i){return!(e&&i.eventName!==e||u&&i.namespace!==u||n&&i.handler!==n||t&&i.selector!==t)}),function(e){o.removeEventListener(e.eventName,e.eventListener,i||!1),s.splice(s.indexOf(e),1)}),e||u||t||n?0===s.length&&ce(o):ce(o)})},this),this},ie="__domtastic_event__",re=1,oe={},ue=[],se=function(e){e[ie]||(e[ie]=0===ue.length?++re:ue.pop());var t=e[ie];return oe[t]||(oe[t]=[])},ce=function(e){var t=e[ie];oe[t]&&(oe[t]=null,e[ie]=null,ue.push(t))},fe=function(e){return function(t){return e.call(this,he(t))}},ae={preventDefault:"isDefaultPrevented",stopImmediatePropagation:"isImmediatePropagationStopped",stopPropagation:"isPropagationStopped"},le=function(){return!0},de=function(){return!1},he=function(e){if(!e.isDefaultPrevented||e.stopImmediatePropagation||e.stopPropagation){for(var t in ae)!function(t,n,i){e[t]=function(){return this[n]=le,i&&i.apply(this,arguments)},e[n]=de}(t,ae[t],e[t]);e._preventDefault&&e.preventDefault()}return e},pe=function(e,t,n){var i=n._target||n.target,r=Y.call([i],e,this)[0];r&&r!==this&&(r!==i&&n.isPropagationStopped&&n.isPropagationStopped()||t.call(r,n))},ve=te,me=ne,ye=Object.freeze({on:te,off:ne,one:function(e,t,n,i){return te.call(this,e,t,n,i,1)},getHandlers:se,clearHandlers:ce,proxyHandler:fe,delegateHandler:pe,bind:ve,unbind:me}),be=/^(mouse(down|up|over|out|enter|leave|move)|contextmenu|(dbl)?click)$/,ge=/^key(down|press|up)$/,Ee=function(e,t,n){var i=void 0===n?{}:n,o=i.bubbles,u=void 0===o||o,s=i.cancelable,c=void 0===s||s,f=i.preventDefault,a=void 0!==f&&f,l=new(Ne(e))(e,{bubbles:u,cancelable:c,preventDefault:a,detail:t});return l._preventDefault=a,r(this,function(n){!u||je||Ce(n)?Te(n,l):Oe(n,e,{bubbles:u,cancelable:c,preventDefault:a,detail:t})})},Ne=function(e){return Ae?be.test(e)?MouseEvent:ge.test(e)?KeyboardEvent:CustomEvent:CustomEvent},Ce=function(e){return e===window||e===document||K(e.ownerDocument.documentElement,e)},Oe=function(e,t,n){void 0===n&&(n={}),n.bubbles=!1;var i=new CustomEvent(t,n);i._target=e;do{Te(e,i)}while(e=e.parentNode)},we=["blur","focus","select","submit"],Te=function(e,t){-1===we.indexOf(t.type)||"function"!=typeof e[t.type]||t._preventDefault||t.cancelable?e.dispatchEvent(t):e[t.type]()};!function(){var e=function(e,t){void 0===t&&(t={bubbles:!1,cancelable:!1,detail:void 0});var n=document.createEvent("CustomEvent");return n.initCustomEvent(e,t.bubbles,t.cancelable,t.detail),n};e.prototype=n.CustomEvent&&n.CustomEvent.prototype,n.CustomEvent=e}();var je=function(){var e=!1,t=n.document;if(t){var i=t.createElement("div"),r=i.cloneNode();i.appendChild(r),i.addEventListener("e",function(){e=!0}),r.dispatchEvent(new CustomEvent("e",{bubbles:!0}))}return e}(),Ae=function(){try{new MouseEvent("click")}catch(e){return!1}return!0}(),Le=Object.freeze({trigger:Ee,triggerHandler:function(e,t){this[0]&&Ee.call(this[0],e,t,{bubbles:!1,preventDefault:!0})}}),De=Object.freeze({ready:function(e){return/complete|loaded|interactive/.test(document.readyState)&&document.body?e():document.addEventListener("DOMContentLoaded",e,!1),this}}),ze=n.$,_e=Object.freeze({noConflict:function(){return n.$=ze,this}}),Me=function(e,t){return l([].slice.apply(this,arguments))},xe=Object.freeze({children:function(e){var t=[];return r(this,function(n){n.children&&r(n.children,function(n){(!e||e&&h(n,e))&&t.push(n)})}),l(t)},concat:function(e){var t=this;return r(l(e),function(e){-1===[].indexOf.call(t,e)&&[].push.call(t,e)}),this},contents:function(){var e=[];return r(this,function(t){return e.push.apply(e,i(t.childNodes))}),l(e)},eq:function(e){return Me.call(this,e,e+1)},first:function(){return Me.call(this,0,1)},get:function(e){return this[e]},parent:function(e){var t=[];return r(this,function(n){(!e||e&&h(n.parentNode,e))&&t.push(n.parentNode)}),l(t)},siblings:function(e){var t=[];return r(this,function(n){return r(n.parentNode.children,function(i){i!==n&&(!e||e&&h(i,e))&&t.push(i)})}),l(t)},slice:Me}),Se=Array.isArray,Pe=Object.freeze({isFunction:function(e){return"function"==typeof e},isArray:Se}),He={},$e={};return void 0!==b&&(($e=l).matches=h,He.find=d),o($e,W,_e,Pe),o(He,M,P,F,q,U,Q,V,X,ye,Le,De,ee,xe),$e.fn=He,$e.version="0.15.12",$e.extend=o,$e.BaseClass=x($e.fn),$e}); + +},{}],5:[function(require,module,exports){ +"use strict";const arrify=require("arrify"),isPlainObject=require("is-plain-object"),classNames=require("classnames"),render=require("./render"),utils=require("./utils"),h=(e,s,r)=>{s&&!isPlainObject(s)?(r=s,s={}):s||(s={}),r=arrify(r);const i=utils.getSelectorParts(e);return i.id&&(s.id=i.id),i.classes.length&&(s.class=classNames(s.class,i.classes)),render(i.tag,s,r)};module.exports=exports=h; + +},{"./render":6,"./utils":7,"arrify":1,"classnames":2,"is-plain-object":8}],6:[function(require,module,exports){ +"use strict";const voidElements=require("void-elements"),arrify=require("arrify");function renderAttributes(e){return(e=Object.keys(e).filter(r=>void 0!==e[r]&&null!==e[r]&&!1!==e[r]).map(r=>!0===e[r]?r:`${r}="${e[r]}"`).join(" "))?` ${e}`:""}function renderChildren(e){return 0===(e=arrify(e)).length?"":1===e.length?e[0]:`\n\t${e.join("\n\t")}\n`}module.exports=exports=function(e,r,t){return"!doctype"===e||voidElements[e]?`<${e}${renderAttributes(r)}>`:`<${e}${renderAttributes(r)}>${renderChildren(t)}`}; + +},{"arrify":1,"void-elements":19}],7:[function(require,module,exports){ +"use strict";const SELECTOR_REGEX=/(^|#|\.)[^#\.]+/g;function getTag(t){return"#"===t[0][0]||"."===t[0][0]?"div":t[0].toLowerCase()}function getClasses(t){return t.filter(isClass).map(slice(1))}function getId(t){return t.filter(isId).map(slice(1))[0]}function slice(t,e){return s=>s.slice(t,e)}function isId(t){return"#"===t[0]}function isClass(t){return"."===t[0]}exports.getSelectorParts=(t=>{const e=t.match(SELECTOR_REGEX);if(!e)throw new Error(`Invalid selector! Should have the format "name.class1.class2#id", but was: "${t}"`);return{tag:getTag(e),id:getId(e),classes:getClasses(e)}}); + +},{}],8:[function(require,module,exports){ +"use strict";var isObject=require("isobject");function isObjectObject(t){return!0===isObject(t)&&"[object Object]"===Object.prototype.toString.call(t)}module.exports=function(t){var e,c;return!1!==isObjectObject(t)&&("function"==typeof(e=t.constructor)&&(!1!==isObjectObject(c=e.prototype)&&!1!==c.hasOwnProperty("isPrototypeOf")))}; + +},{"isobject":9}],9:[function(require,module,exports){ +"use strict";module.exports=function(r){return null!=r&&"object"==typeof r&&!1===Array.isArray(r)}; + +},{}],10:[function(require,module,exports){ +(function(){var t,e,i,n,s,r=function(t,e){return function(){return t.apply(e,arguments)}},o=[].slice,l={}.hasOwnProperty,u=function(t,e){for(var i in e)l.call(e,i)&&(t[i]=e[i]);function n(){this.constructor=t}return n.prototype=e.prototype,t.prototype=new n,t.__super__=e.prototype,t},h=[].indexOf||function(t){for(var e=0,i=this.length;e0&&n=0?this.static[l]=s.value:u.type===t.TypeParser.types.primitive?this.static[l]=u.value:this.observers[l]=s.value)}return u(i,e),i.prototype.sync=function(){},i.prototype.update=function(){},i.prototype.publish=function(){},i.prototype.locals=function(){var t,e,i,n,s,r;for(t in i={},s=this.static)n=s[t],i[t]=n;for(t in r=this.observers)e=r[t],i[t]=e.value();return i},i.prototype.camelCase=function(t){return t.replace(/-([a-z])/g,function(t){return t[1].toUpperCase()})},i.prototype.bind=function(){var e,i,n,s,r,o,l,u,h,a,p,d,c,f,b,v,m,y,g,w;if(!this.bound){for(i in f=this.observers)n=f[i],this.observers[i]=this.observe(this.view.models,n,function(t){return function(e){return function(){return t.componentView.models[e]=t.observers[e].value()}}}(this).call(this,i));this.bound=!0}if(null!=this.componentView)this.componentView.bind();else{for(this.el.innerHTML=this.component.template.call(this),l=this.component.initialize.call(this,this.el,this.locals()),this.el._bound=!0,o={},a=0,d=(b=t.extensions).length;a=0));return a}}else if((null!=e?e.toString():void 0)!==(null!=(u=t.value)?u.toString():void 0))return t.value=null!=e?e:""}},t.public.binders.if={block:!0,priority:4e3,bind:function(t){var e,i;if(null==this.marker)return e=[this.view.prefix,this.type].join("-").replace("--","-"),i=t.getAttribute(e),this.marker=document.createComment(" rivets: "+this.type+" "+i+" "),this.bound=!1,t.removeAttribute(e),t.parentNode.insertBefore(this.marker,t),t.parentNode.removeChild(t)},unbind:function(){if(this.nested)return this.nested.unbind(),this.bound=!1},routine:function(e,i){var n,s,r,o;if(!!i==!this.bound){if(i){for(n in r={},o=this.view.models)s=o[n],r[n]=s;return(this.nested||(this.nested=new t.View(e,r,this.view.options()))).bind(),this.marker.parentNode.insertBefore(e,this.marker.nextSibling),this.bound=!0}return e.parentNode.removeChild(e),this.nested.unbind(),this.bound=!1}},update:function(t){var e;return null!=(e=this.nested)?e.update(t):void 0}},t.public.binders.unless={block:!0,priority:4e3,bind:function(e){return t.public.binders.if.bind.call(this,e)},unbind:function(){return t.public.binders.if.unbind.call(this)},routine:function(e,i){return t.public.binders.if.routine.call(this,e,!i)},update:function(e){return t.public.binders.if.update.call(this,e)}},t.public.binders["on-*"]={function:!0,priority:1e3,unbind:function(e){if(this.handler)return t.Util.unbindEvent(e,this.args[0],this.handler)},routine:function(e,i){return this.handler&&t.Util.unbindEvent(e,this.args[0],this.handler),t.Util.bindEvent(e,this.args[0],this.handler=this.eventHandler(i))}},t.public.binders["each-*"]={block:!0,priority:4e3,bind:function(t){var e,i,n,s;if(null==this.marker)e=[this.view.prefix,this.type].join("-").replace("--","-"),this.marker=document.createComment(" rivets: "+this.type+" "),this.iterated=[],t.removeAttribute(e),t.parentNode.insertBefore(this.marker,t),t.parentNode.removeChild(t);else for(i=0,n=(s=this.iterated).length;ii.length)for(c=0,v=(g=Array(this.iterated.length-i.length)).length;c=0&&r.splice(n,1),r.length||delete s.pointers[e],this.cleanupWeakReference(s,t[this.id])},observe:function(t,e,i){var n,s,r,o;return null==(n=this.weakReference(t).callbacks)[e]&&(n[e]=[],(null!=(s=Object.getOwnPropertyDescriptor(t,e))?s.get:void 0)||(null!=s?s.set:void 0)||(r=t[e],Object.defineProperty(t,e,{enumerable:!0,get:function(){return r},set:(o=this,function(i){var s,l,u,a,p;if(i!==r&&(o.unobserveMutations(r,t[o.id],e),r=i,l=o.weakmap[t[o.id]])){if((n=l.callbacks)[e])for(u=0,a=(p=n[e].slice()).length;u=0&&s();return o.observeMutations(i,t[o.id],e)}})}))),h.call(n[e],i)<0&&n[e].push(i),this.observeMutations(t[e],t[this.id],e)},unobserve:function(t,e,i){var n,s,r;if((r=this.weakmap[t[this.id]])&&(n=r.callbacks[e]))return(s=n.indexOf(i))>=0&&(n.splice(s,1),n.length||(delete r.callbacks[e],this.unobserveMutations(t[e],t[this.id],e))),this.cleanupWeakReference(r,t[this.id])},get:function(t,e){return t[e]},set:function(t,e,i){return t[e]=i}},t.factory=function(e){return t.sightglass=e,t.public._=t,t.public},"object"==typeof("undefined"!=typeof module&&null!==module?module.exports:void 0)?module.exports=t.factory(require("sightglass")):"function"==typeof define&&define.amd?define(["sightglass"],function(e){return this.rivets=t.factory(e)}):this.rivets=t.factory(sightglass)}).call(this); + +},{"sightglass":11}],11:[function(require,module,exports){ +(function(){function t(t,s,i,h){return new e(t,s,i,h)}function e(t,e,i,h){this.options=h||{},this.options.adapters=this.options.adapters||{},this.obj=t,this.keypath=e,this.callback=i,this.objectPath=[],this.update=this.update.bind(this),this.parse(),s(this.target=this.realize())&&this.set(!0,this.key,this.target,this.callback)}function s(t){return"object"==typeof t&&null!==t}function i(t){throw new Error("[sightglass] "+t)}t.adapters={},e.tokenize=function(t,e,s){var i,h,a=[],o={i:s,path:""};for(i=0;i{Agent.prototype[t]=function(...e){return this._defaults.push({fn:t,args:e}),this}}),Agent.prototype._setDefaults=function(t){this._defaults.forEach(e=>{t[e.fn].apply(t,e.args)})},module.exports=Agent; + +},{}],13:[function(require,module,exports){ +let root;"undefined"!=typeof window?root=window:"undefined"!=typeof self?root=self:(console.warn("Using browser-only version of superagent in non-browser environment"),root=this);const Emitter=require("component-emitter"),RequestBase=require("./request-base"),isObject=require("./is-object"),ResponseBase=require("./response-base"),Agent=require("./agent-base");function noop(){}const request=exports=module.exports=function(e,t){return"function"==typeof t?new exports.Request("GET",e).end(t):1==arguments.length?new exports.Request("GET",e):new exports.Request(e,t)};exports.Request=Request,request.getXHR=(()=>{if(!(!root.XMLHttpRequest||root.location&&"file:"==root.location.protocol&&root.ActiveXObject))return new XMLHttpRequest;try{return new ActiveXObject("Microsoft.XMLHTTP")}catch(e){}try{return new ActiveXObject("Msxml2.XMLHTTP.6.0")}catch(e){}try{return new ActiveXObject("Msxml2.XMLHTTP.3.0")}catch(e){}try{return new ActiveXObject("Msxml2.XMLHTTP")}catch(e){}throw Error("Browser-only version of superagent could not find XHR")});const trim="".trim?e=>e.trim():e=>e.replace(/(^\s*|\s*$)/g,"");function serialize(e){if(!isObject(e))return e;const t=[];for(const s in e)pushEncodedKeyValuePair(t,s,e[s]);return t.join("&")}function pushEncodedKeyValuePair(e,t,s){if(null!=s)if(Array.isArray(s))s.forEach(s=>{pushEncodedKeyValuePair(e,t,s)});else if(isObject(s))for(const r in s)pushEncodedKeyValuePair(e,`${t}[${r}]`,s[r]);else e.push(encodeURIComponent(t)+"="+encodeURIComponent(s));else null===s&&e.push(encodeURIComponent(t))}function parseString(e){const t={},s=e.split("&");let r,o;for(let e=0,n=s.length;e{let e,t=null,r=null;try{r=new Response(s)}catch(e){return(t=new Error("Parser is unable to parse the response")).parse=!0,t.original=e,s.xhr?(t.rawResponse=void 0===s.xhr.responseType?s.xhr.responseText:s.xhr.response,t.status=s.xhr.status?s.xhr.status:null,t.statusCode=t.status):(t.rawResponse=null,t.status=null),s.callback(t)}s.emit("response",r);try{s._isResponseOK(r)||(e=new Error(r.statusText||"Unsuccessful HTTP response"))}catch(t){e=t}e?(e.original=t,e.response=r,e.status=r.status,s.callback(e,r)):s.callback(null,r)})}function del(e,t,s){const r=request("DELETE",e);return"function"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}request.serializeObject=serialize,request.parseString=parseString,request.types={html:"text/html",json:"application/json",xml:"text/xml",urlencoded:"application/x-www-form-urlencoded",form:"application/x-www-form-urlencoded","form-data":"application/x-www-form-urlencoded"},request.serialize={"application/x-www-form-urlencoded":serialize,"application/json":JSON.stringify},request.parse={"application/x-www-form-urlencoded":parseString,"application/json":JSON.parse},ResponseBase(Response.prototype),Response.prototype._parseBody=function(e){let t=request.parse[this.type];return this.req._parser?this.req._parser(this,e):(!t&&isJSON(this.type)&&(t=request.parse["application/json"]),t&&e&&(e.length||e instanceof Object)?t(e):null)},Response.prototype.toError=function(){const e=this.req,t=e.method,s=e.url,r=`cannot ${t} ${s} (${this.status})`,o=new Error(r);return o.status=this.status,o.method=t,o.url=s,o},request.Response=Response,Emitter(Request.prototype),RequestBase(Request.prototype),Request.prototype.type=function(e){return this.set("Content-Type",request.types[e]||e),this},Request.prototype.accept=function(e){return this.set("Accept",request.types[e]||e),this},Request.prototype.auth=function(e,t,s){1===arguments.length&&(t=""),"object"==typeof t&&null!==t&&(s=t,t=""),s||(s={type:"function"==typeof btoa?"basic":"auto"});return this._auth(e,t,s,e=>{if("function"==typeof btoa)return btoa(e);throw new Error("Cannot use basic auth, btoa is not a function")})},Request.prototype.query=function(e){return"string"!=typeof e&&(e=serialize(e)),e&&this._query.push(e),this},Request.prototype.attach=function(e,t,s){if(t){if(this._data)throw Error("superagent can't mix .send() and .attach()");this._getFormData().append(e,t,s||t.name)}return this},Request.prototype._getFormData=function(){return this._formData||(this._formData=new root.FormData),this._formData},Request.prototype.callback=function(e,t){if(this._shouldRetry(e,t))return this._retry();const s=this._callback;this.clearTimeout(),e&&(this._maxRetries&&(e.retries=this._retries-1),this.emit("error",e)),s(e,t)},Request.prototype.crossDomainError=function(){const e=new Error("Request has been terminated\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.");e.crossDomain=!0,e.status=this.status,e.method=this.method,e.url=this.url,this.callback(e)},Request.prototype.buffer=Request.prototype.ca=Request.prototype.agent=function(){return console.warn("This is not supported in browser version of superagent"),this},Request.prototype.pipe=Request.prototype.write=(()=>{throw Error("Streaming is not supported in browser version of superagent")}),Request.prototype._isHost=function(e){return e&&"object"==typeof e&&!Array.isArray(e)&&"[object Object]"!==Object.prototype.toString.call(e)},Request.prototype.end=function(e){this._endCalled&&console.warn("Warning: .end() was called twice. This is not supported in superagent"),this._endCalled=!0,this._callback=e||noop,this._finalizeQueryString(),this._end()},Request.prototype._end=function(){if(this._aborted)return this.callback(Error("The request has been aborted even before .end() was called"));const e=this,t=this.xhr=request.getXHR();let s=this._formData||this._data;this._setTimeouts(),t.onreadystatechange=(()=>{const s=t.readyState;if(s>=2&&e._responseTimeoutTimer&&clearTimeout(e._responseTimeoutTimer),4!=s)return;let r;try{r=t.status}catch(e){r=0}if(!r){if(e.timedout||e._aborted)return;return e.crossDomainError()}e.emit("end")});const r=(t,s)=>{s.total>0&&(s.percent=s.loaded/s.total*100),s.direction=t,e.emit("progress",s)};if(this.hasListeners("progress"))try{t.onprogress=r.bind(null,"download"),t.upload&&(t.upload.onprogress=r.bind(null,"upload"))}catch(e){}try{this.username&&this.password?t.open(this.method,this.url,!0,this.username,this.password):t.open(this.method,this.url,!0)}catch(e){return this.callback(e)}if(this._withCredentials&&(t.withCredentials=!0),!this._formData&&"GET"!=this.method&&"HEAD"!=this.method&&"string"!=typeof s&&!this._isHost(s)){const e=this._header["content-type"];let t=this._serializer||request.serialize[e?e.split(";")[0]:""];!t&&isJSON(e)&&(t=request.serialize["application/json"]),t&&(s=t(s))}for(const e in this.header)null!=this.header[e]&&this.header.hasOwnProperty(e)&&t.setRequestHeader(e,this.header[e]);this._responseType&&(t.responseType=this._responseType),this.emit("request",this),t.send(void 0!==s?s:null)},request.agent=(()=>new Agent),["GET","POST","OPTIONS","PATCH","PUT","DELETE"].forEach(e=>{Agent.prototype[e.toLowerCase()]=function(t,s){const r=new request.Request(e,t);return this._setDefaults(r),s&&r.end(s),r}}),Agent.prototype.del=Agent.prototype.delete,request.get=((e,t,s)=>{const r=request("GET",e);return"function"==typeof t&&(s=t,t=null),t&&r.query(t),s&&r.end(s),r}),request.head=((e,t,s)=>{const r=request("HEAD",e);return"function"==typeof t&&(s=t,t=null),t&&r.query(t),s&&r.end(s),r}),request.options=((e,t,s)=>{const r=request("OPTIONS",e);return"function"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.del=del,request.delete=del,request.patch=((e,t,s)=>{const r=request("PATCH",e);return"function"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.post=((e,t,s)=>{const r=request("POST",e);return"function"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.put=((e,t,s)=>{const r=request("PUT",e);return"function"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}); + +},{"./agent-base":12,"./is-object":14,"./request-base":15,"./response-base":16,"component-emitter":3}],14:[function(require,module,exports){ +"use strict";function isObject(t){return null!==t&&"object"==typeof t}module.exports=isObject; + +},{}],15:[function(require,module,exports){ +"use strict";const isObject=require("./is-object");function RequestBase(t){if(t)return mixin(t)}function mixin(t){for(const e in RequestBase.prototype)t[e]=RequestBase.prototype[e];return t}module.exports=RequestBase,RequestBase.prototype.clearTimeout=function(){return clearTimeout(this._timer),clearTimeout(this._responseTimeoutTimer),delete this._timer,delete this._responseTimeoutTimer,this},RequestBase.prototype.parse=function(t){return this._parser=t,this},RequestBase.prototype.responseType=function(t){return this._responseType=t,this},RequestBase.prototype.serialize=function(t){return this._serializer=t,this},RequestBase.prototype.timeout=function(t){if(!t||"object"!=typeof t)return this._timeout=t,this._responseTimeout=0,this;for(const e in t)switch(e){case"deadline":this._timeout=t.deadline;break;case"response":this._responseTimeout=t.response;break;default:console.warn("Unknown timeout option",e)}return this},RequestBase.prototype.retry=function(t,e){return 0!==arguments.length&&!0!==t||(t=1),t<=0&&(t=0),this._maxRetries=t,this._retries=0,this._retryCallback=e,this};const ERROR_CODES=["ECONNRESET","ETIMEDOUT","EADDRINFO","ESOCKETTIMEDOUT"];RequestBase.prototype._shouldRetry=function(t,e){if(!this._maxRetries||this._retries++>=this._maxRetries)return!1;if(this._retryCallback)try{const s=this._retryCallback(t,e);if(!0===s)return!0;if(!1===s)return!1}catch(t){console.error(t)}if(e&&e.status&&e.status>=500&&501!=e.status)return!0;if(t){if(t.code&&~ERROR_CODES.indexOf(t.code))return!0;if(t.timeout&&"ECONNABORTED"==t.code)return!0;if(t.crossDomain)return!0}return!1},RequestBase.prototype._retry=function(){return this.clearTimeout(),this.req&&(this.req=null,this.req=this.request()),this._aborted=!1,this.timedout=!1,this._end()},RequestBase.prototype.then=function(t,e){if(!this._fullfilledPromise){const t=this;this._endCalled&&console.warn("Warning: superagent request was sent twice, because both .end() and .then() were called. Never call .end() if you use promises"),this._fullfilledPromise=new Promise((e,s)=>{t.on("error",s),t.on("abort",()=>{const t=new Error("Aborted");t.code="ABORTED",t.status=this.status,t.method=this.method,t.url=this.url,s(t)}),t.end((t,i)=>{t?s(t):e(i)})})}return this._fullfilledPromise.then(t,e)},RequestBase.prototype.catch=function(t){return this.then(void 0,t)},RequestBase.prototype.use=function(t){return t(this),this},RequestBase.prototype.ok=function(t){if("function"!=typeof t)throw Error("Callback required");return this._okCallback=t,this},RequestBase.prototype._isResponseOK=function(t){return!!t&&(this._okCallback?this._okCallback(t):t.status>=200&&t.status<300)},RequestBase.prototype.get=function(t){return this._header[t.toLowerCase()]},RequestBase.prototype.getHeader=RequestBase.prototype.get,RequestBase.prototype.set=function(t,e){if(isObject(t)){for(const e in t)this.set(e,t[e]);return this}return this._header[t.toLowerCase()]=e,this.header[t]=e,this},RequestBase.prototype.unset=function(t){return delete this._header[t.toLowerCase()],delete this.header[t],this},RequestBase.prototype.field=function(t,e){if(null==t)throw new Error(".field(name, val) name can not be empty");if(this._data)throw new Error(".field() can't be used if .send() is used. Please use only .send() or only .field() & .attach()");if(isObject(t)){for(const e in t)this.field(e,t[e]);return this}if(Array.isArray(e)){for(const s in e)this.field(t,e[s]);return this}if(null==e)throw new Error(".field(name, val) val can not be empty");return"boolean"==typeof e&&(e=""+e),this._getFormData().append(t,e),this},RequestBase.prototype.abort=function(){return this._aborted?this:(this._aborted=!0,this.xhr&&this.xhr.abort(),this.req&&this.req.abort(),this.clearTimeout(),this.emit("abort"),this)},RequestBase.prototype._auth=function(t,e,s,i){switch(s.type){case"basic":this.set("Authorization",`Basic ${i(`${t}:${e}`)}`);break;case"auto":this.username=t,this.password=e;break;case"bearer":this.set("Authorization",`Bearer ${t}`)}return this},RequestBase.prototype.withCredentials=function(t){return null==t&&(t=!0),this._withCredentials=t,this},RequestBase.prototype.redirects=function(t){return this._maxRedirects=t,this},RequestBase.prototype.maxResponseSize=function(t){if("number"!=typeof t)throw TypeError("Invalid argument");return this._maxResponseSize=t,this},RequestBase.prototype.toJSON=function(){return{method:this.method,url:this.url,data:this._data,headers:this._header}},RequestBase.prototype.send=function(t){const e=isObject(t);let s=this._header["content-type"];if(this._formData)throw new Error(".send() can't be used if .attach() or .field() is used. Please use only .send() or only .field() & .attach()");if(e&&!this._data)Array.isArray(t)?this._data=[]:this._isHost(t)||(this._data={});else if(t&&this._data&&this._isHost(this._data))throw Error("Can't merge these send calls");if(e&&isObject(this._data))for(const e in t)this._data[e]=t[e];else"string"==typeof t?(s||this.type("form"),s=this._header["content-type"],this._data="application/x-www-form-urlencoded"==s?this._data?`${this._data}&${t}`:t:(this._data||"")+t):this._data=t;return!e||this._isHost(t)?this:(s||this.type("json"),this)},RequestBase.prototype.sortQuery=function(t){return this._sort=void 0===t||t,this},RequestBase.prototype._finalizeQueryString=function(){const t=this._query.join("&");if(t&&(this.url+=(this.url.indexOf("?")>=0?"&":"?")+t),this._query.length=0,this._sort){const t=this.url.indexOf("?");if(t>=0){const e=this.url.substring(t+1).split("&");"function"==typeof this._sort?e.sort(this._sort):e.sort(),this.url=this.url.substring(0,t)+"?"+e.join("&")}}},RequestBase.prototype._appendQueryString=(()=>{console.trace("Unsupported")}),RequestBase.prototype._timeoutError=function(t,e,s){if(this._aborted)return;const i=new Error(`${t+e}ms exceeded`);i.timeout=e,i.code="ECONNABORTED",i.errno=s,this.timedout=!0,this.abort(),this.callback(i)},RequestBase.prototype._setTimeouts=function(){const t=this;this._timeout&&!this._timer&&(this._timer=setTimeout(()=>{t._timeoutError("Timeout of ",t._timeout,"ETIME")},this._timeout)),this._responseTimeout&&!this._responseTimeoutTimer&&(this._responseTimeoutTimer=setTimeout(()=>{t._timeoutError("Response timeout of ",t._responseTimeout,"ETIMEDOUT")},this._responseTimeout))}; + +},{"./is-object":14}],16:[function(require,module,exports){ +"use strict";const utils=require("./utils");function ResponseBase(t){if(t)return mixin(t)}function mixin(t){for(const s in ResponseBase.prototype)t[s]=ResponseBase.prototype[s];return t}module.exports=ResponseBase,ResponseBase.prototype.get=function(t){return this.header[t.toLowerCase()]},ResponseBase.prototype._setHeaderProperties=function(t){const s=t["content-type"]||"";this.type=utils.type(s);const e=utils.params(s);for(const t in e)this[t]=e[t];this.links={};try{t.link&&(this.links=utils.parseLinks(t.link))}catch(t){}},ResponseBase.prototype._setStatusProperties=function(t){const s=t/100|0;this.status=this.statusCode=t,this.statusType=s,this.info=1==s,this.ok=2==s,this.redirect=3==s,this.clientError=4==s,this.serverError=5==s,this.error=(4==s||5==s)&&this.toError(),this.created=201==t,this.accepted=202==t,this.noContent=204==t,this.badRequest=400==t,this.unauthorized=401==t,this.notAcceptable=406==t,this.forbidden=403==t,this.notFound=404==t,this.unprocessableEntity=422==t}; + +},{"./utils":17}],17:[function(require,module,exports){ +"use strict";exports.type=(e=>e.split(/ *; */).shift()),exports.params=(e=>e.split(/ *; */).reduce((e,t)=>{const s=t.split(/ *= */),i=s.shift(),r=s.shift();return i&&r&&(e[i]=r),e},{})),exports.parseLinks=(e=>e.split(/ *, */).reduce((e,t)=>{const s=t.split(/ *; */),i=s[0].slice(1,-1);return e[s[1].split(/ *= */)[1].slice(1,-1)]=i,e},{})),exports.cleanHeader=((e,t)=>(delete e["content-type"],delete e["content-length"],delete e["transfer-encoding"],delete e.host,t&&(delete e.authorization,delete e.cookie),e)); + +},{}],18:[function(require,module,exports){ +var toString=Object.prototype.toString;module.exports=function(e){switch(toString.call(e)){case"[object Function]":return"function";case"[object Date]":return"date";case"[object RegExp]":return"regexp";case"[object Arguments]":return"arguments";case"[object Array]":return"array";case"[object String]":return"string"}if("object"==typeof e&&e&&"number"==typeof e.length)try{if("function"==typeof e.callee)return"arguments"}catch(e){if(e instanceof TypeError)return"arguments"}return null===e?"null":void 0===e?"undefined":e&&1===e.nodeType?"element":e===Object(e)?"object":typeof e}; + +},{}],19:[function(require,module,exports){ +module.exports={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,menuitem:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0}; + +},{}],20:[function(require,module,exports){ +(function (global){ +"use strict";const type=require("type-of"),request=require("superagent"),h=require("hyperscript-string"),$=require("domtastic"),rivets=require("rivets");$.fn.clear=function(){return this.forEach(e=>{e.innerHTML=""}),this},$.fn.outerHTML=function(){return this.prop("outerHTML")};const state={message:"",knowledge:[],conversation:[],error:!1};function _error(e,t,{response:s}){s=s?[s.status,s.text]:[],console.warn(`[${e} ${t}]`,...s)}function send_message(e="",t){request.post("/message").send(e).then(({body:e})=>{state.conversation.push({text:e})},e=>{_error("POST","/message",e),t&&t()})}function _const(e,t,s){return Object.defineProperty(e,t,{value:s,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),$(".Conversation-input").on("keydown",e=>{let t=state.message;if("Enter"==e.code&&!e.shiftKey&&!e.altKey&&!e.ctrlKey){if(""==t)return;return state.message="",state.conversation.push({text:t.split(/\s*[\n\r]+\s*/g),is_user:!0}),send_message(t,()=>{state.error=!0}),!1}}).on("paste",e=>{e.preventDefault();let t=e.clipboardData.getData("text/plain");return document.execCommand("insertHTML",!1,t),!1});const{Binding:Binding}=rivets._;rivets._.Binding=class extends Binding{parseTarget(){return this.binder.parseTarget&&Object.assign(this,this.binder.parseTarget(this.keypath)),super.parseTarget()}publish(){_const(this,"state","publish");super.publish();_const(this,"state")}},rivets.binders.input={parseTarget(e){let t;return[e,t]=e.trim().split(/\s*\?\s*/),{keypath:e,empty_class:t}},bind:function(e){this._empty=!0,$(e).on("input.rv-input",this.publish),this._watch=(()=>{e.innerHTML="",""==e.innerHTML&&clearInterval(this._watcher)})},unbind:function(e){$(e).off(".rv-input"),clearInterval(this._watcher)},routine:function(e,t){"publish"!=this.state&&(clearInterval(this._watcher),e.innerText=t),state.error=!1,this._empty=""==t,this._empty&&(this._watcher=setInterval(this._watch,30)),this.empty_class&&$(e).toggleClass(this.empty_class,this._empty)},getValue:function(e){return e.innerText.trim()}},global.$state=state,rivets.bind(document.body,state); + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"domtastic":4,"hyperscript-string":5,"rivets":10,"superagent":13,"type-of":18}]},{},[20]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../wikia-is-answered/node_modules/browser-pack/_prelude.js","../wikia-is-answered/node_modules/arrify/index.js","../wikia-is-answered/node_modules/classnames/index.js","../wikia-is-answered/node_modules/component-emitter/index.js","../wikia-is-answered/node_modules/domtastic/dist/domtastic.js","../wikia-is-answered/node_modules/hyperscript-string/src/index.js","../wikia-is-answered/node_modules/hyperscript-string/src/render.js","../wikia-is-answered/node_modules/hyperscript-string/src/utils.js","../wikia-is-answered/node_modules/is-plain-object/index.js","../wikia-is-answered/node_modules/isobject/index.js","../wikia-is-answered/node_modules/rivets/dist/rivets.js","../wikia-is-answered/node_modules/sightglass/index.js","../wikia-is-answered/node_modules/superagent/lib/agent-base.js","../wikia-is-answered/node_modules/superagent/lib/client.js","../wikia-is-answered/node_modules/superagent/lib/is-object.js","../wikia-is-answered/node_modules/superagent/lib/request-base.js","../wikia-is-answered/node_modules/superagent/lib/response-base.js","../wikia-is-answered/node_modules/superagent/lib/utils.js","../wikia-is-answered/node_modules/type-of/index.js","../wikia-is-answered/node_modules/void-elements/index.js","app.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;ACFA;AACA;AACA;;ACFA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","\"use strict\";module.exports=function(r){return null==r?[]:Array.isArray(r)?r:[r]};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJ2YWwiLCJBcnJheSIsImlzQXJyYXkiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0FBLE9BQU9DLFFBQVUsU0FBVUMsR0FDMUIsT0FBSUEsTUFBQUEsRUFDSSxHQUdEQyxNQUFNQyxRQUFRRixHQUFPQSxFQUFNLENBQUNBIiwiZmlsZSI6IkU6XFxXb3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXGFycmlmeVxcaW5kZXguanMifQ==","!function(){\"use strict\";var e={}.hasOwnProperty;function n(){for(var r=[],t=0;t<arguments.length;t++){var f=arguments[t];if(f){var o=typeof f;if(\"string\"===o||\"number\"===o)r.push(f);else if(Array.isArray(f)&&f.length){var i=n.apply(null,f);i&&r.push(i)}else if(\"object\"===o)for(var a in f)e.call(f,a)&&f[a]&&r.push(a)}}return r.join(\" \")}\"undefined\"!=typeof module&&module.exports?(n.default=n,module.exports=n):\"function\"==typeof define&&\"object\"==typeof define.amd&&define.amd?define(\"classnames\",[],function(){return n}):window.classNames=n}();\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImhhc093biIsImhhc093blByb3BlcnR5IiwiY2xhc3NOYW1lcyIsImNsYXNzZXMiLCJpIiwiYXJndW1lbnRzIiwibGVuZ3RoIiwiYXJnIiwiYXJnVHlwZSIsInB1c2giLCJBcnJheSIsImlzQXJyYXkiLCJpbm5lciIsImFwcGx5Iiwia2V5IiwiY2FsbCIsImpvaW4iLCJtb2R1bGUiLCJleHBvcnRzIiwiZGVmYXVsdCIsImRlZmluZSIsImFtZCIsIndpbmRvdyJdLCJtYXBwaW5ncyI6IkNBT0MsV0FDQSxhQUVBLElBQUlBLEVBQVMsR0FBR0MsZUFFaEIsU0FBU0MsSUFHUixJQUZBLElBQUlDLEVBQVUsR0FFTEMsRUFBSSxFQUFHQSxFQUFJQyxVQUFVQyxPQUFRRixJQUFLLENBQzFDLElBQUlHLEVBQU1GLFVBQVVELEdBQ3BCLEdBQUtHLEVBQUwsQ0FFQSxJQUFJQyxTQUFpQkQsRUFFckIsR0FBZ0IsV0FBWkMsR0FBb0MsV0FBWkEsRUFDM0JMLEVBQVFNLEtBQUtGLFFBQ1AsR0FBSUcsTUFBTUMsUUFBUUosSUFBUUEsRUFBSUQsT0FBUSxDQUM1QyxJQUFJTSxFQUFRVixFQUFXVyxNQUFNLEtBQU1OLEdBQy9CSyxHQUNIVCxFQUFRTSxLQUFLRyxRQUVSLEdBQWdCLFdBQVpKLEVBQ1YsSUFBSyxJQUFJTSxLQUFPUCxFQUNYUCxFQUFPZSxLQUFLUixFQUFLTyxJQUFRUCxFQUFJTyxJQUNoQ1gsRUFBUU0sS0FBS0ssSUFNakIsT0FBT1gsRUFBUWEsS0FBSyxLQUdDLG9CQUFYQyxRQUEwQkEsT0FBT0MsU0FDM0NoQixFQUFXaUIsUUFBVWpCLEVBQ3JCZSxPQUFPQyxRQUFVaEIsR0FDVyxtQkFBWGtCLFFBQStDLGlCQUFmQSxPQUFPQyxLQUFvQkQsT0FBT0MsSUFFbkZELE9BQU8sYUFBYyxHQUFJLFdBQ3hCLE9BQU9sQixJQUdSb0IsT0FBT3BCLFdBQWFBLEVBMUN0QiIsImZpbGUiOiJFOlxcV29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxjbGFzc25hbWVzXFxpbmRleC5qcyJ9","function Emitter(t){if(t)return mixin(t)}function mixin(t){for(var e in Emitter.prototype)t[e]=Emitter.prototype[e];return t}\"undefined\"!=typeof module&&(module.exports=Emitter),Emitter.prototype.on=Emitter.prototype.addEventListener=function(t,e){return this._callbacks=this._callbacks||{},(this._callbacks[\"$\"+t]=this._callbacks[\"$\"+t]||[]).push(e),this},Emitter.prototype.once=function(t,e){function i(){this.off(t,i),e.apply(this,arguments)}return i.fn=e,this.on(t,i),this},Emitter.prototype.off=Emitter.prototype.removeListener=Emitter.prototype.removeAllListeners=Emitter.prototype.removeEventListener=function(t,e){if(this._callbacks=this._callbacks||{},0==arguments.length)return this._callbacks={},this;var i,r=this._callbacks[\"$\"+t];if(!r)return this;if(1==arguments.length)return delete this._callbacks[\"$\"+t],this;for(var s=0;s<r.length;s++)if((i=r[s])===e||i.fn===e){r.splice(s,1);break}return this},Emitter.prototype.emit=function(t){this._callbacks=this._callbacks||{};var e=[].slice.call(arguments,1),i=this._callbacks[\"$\"+t];if(i)for(var r=0,s=(i=i.slice(0)).length;r<s;++r)i[r].apply(this,e);return this},Emitter.prototype.listeners=function(t){return this._callbacks=this._callbacks||{},this._callbacks[\"$\"+t]||[]},Emitter.prototype.hasListeners=function(t){return!!this.listeners(t).length};\n\n//# sourceMappingURL=data:application/json;base64,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","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=e||self).$=t()}(this,function(){\"use strict\";var e,t,n=\"undefined\"!=typeof window?window:{},i=function(e){for(var t=e.length,n=new Array(t),i=0;i<t;i++)n[i]=e[i];return n},r=function(e,t,n){var i=e.length;if(void 0!==i&&void 0===e.nodeType)for(var r=0;r<i;r++)t.call(n,e[r],r,e);else t.call(n,e,0,e);return e},o=function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),i=1;i<t;i++)n[i-1]=arguments[i];return n.forEach(function(t){for(var n in t)e[n]=t[n]}),e},u=function(e){return e.filter(function(t,n){return e.indexOf(t)===n})},s=!1,c=/^\\s*<(\\w+|!)[^>]*>/,f=/^<(\\w+)\\s*\\/?>(?:<\\/\\1>|)$/,a=/^[.#]?[\\w-]*$/,l=function(e,t){var n;if(void 0===t&&(t=document),e){if(e instanceof y)return e;\"string\"!=typeof e?n=e.nodeType||e===window?[e]:e:c.test(e)?n=v(e):(t=\"string\"==typeof t?document.querySelector(t):t.length?t[0]:t,n=p(e,t))}else n=document.querySelectorAll(null);return m(n)},d=function(e){var t=[];return r(this,function(n){return r(p(e,n),function(e){-1===t.indexOf(e)&&t.push(e)})}),l(t)},h=(e=\"undefined\"!=typeof Element?Element.prototype:n,t=e.matches||e.matchesSelector||e.mozMatchesSelector||e.msMatchesSelector||e.oMatchesSelector||e.webkitMatchesSelector,function(e,n){return t.call(e,n)}),p=function(e,t){if(a.test(e)){if(\"#\"===e[0]){var n=(t.getElementById?t:document).getElementById(e.slice(1));return n?[n]:[]}return\".\"===e[0]?t.getElementsByClassName(e.slice(1)):t.getElementsByTagName(e)}return t.querySelectorAll(e)},v=function(e){if(f.test(e))return[document.createElement(RegExp.$1)];var t=[],n=document.createElement(\"div\"),i=n.childNodes;n.innerHTML=e;for(var r=0,o=i.length;r<o;r++)t.push(i[r]);return t},m=function(e){return s||(y.prototype=l.fn,y.prototype.constructor=y,s=!0),new y(e)},y=function(e){for(var t=0,n=e.length;t<n;)this[t]=e[t++];this.length=n},b=Object.freeze({$:l,find:d,matches:h,DOMtastic:y}),g=Array.prototype,E=g.every,N=function(e,t){return r(this,e,t)},C=N,O=g.indexOf,w=g.map,T=g.pop,j=g.push,A=g.reduce,L=g.reduceRight,D=g.shift,z=g.some,_=g.unshift,M=Object.freeze({every:E,filter:function(e,t){var n=\"function\"==typeof e?e:function(t){return h(t,e)};return l(g.filter.call(this,n,t))},forEach:N,each:C,indexOf:O,map:w,pop:T,push:j,reduce:A,reduceRight:L,reverse:function(){return l(i(this).reverse())},shift:D,some:z,unshift:_});function x(e){var t=function(){y.call(this,l.apply(void 0,arguments))};return o(t.prototype,e),t}var S=function(e){return e.replace(/-([\\da-z])/gi,function(e,t){return t.toUpperCase()})},P=Object.freeze({css:function(e,t){var n,i,o;if(\"string\"==typeof e){if(e=S(e),void 0===t){var u=this.nodeType?this:this[0];return u?function(e){return!isNaN(parseFloat(e))&&isFinite(e)}(o=u.style[e])?parseFloat(o):o:void 0}(n={})[e]=t}else for(i in n=e)o=n[i],delete n[i],n[S(i)]=o;return r(this,function(e){for(i in n)n[i]||0===n[i]?e.style[i]=n[i]:e.style.removeProperty(i.replace(/([a-z\\d])([A-Z])/g,\"$1-$2\").toLowerCase())}),this}}),H=Array.prototype.forEach,$=function e(t){if(this instanceof Node)if(\"string\"==typeof t)this.insertAdjacentHTML(\"beforeend\",t);else if(t instanceof Node)this.appendChild(t);else{var n=t instanceof NodeList?i(t):t;H.call(n,this.appendChild.bind(this))}else k(this,e,t);return this},I=function e(t){if(this instanceof Node)if(\"string\"==typeof t)this.insertAdjacentHTML(\"beforebegin\",t);else if(t instanceof Node)this.parentNode.insertBefore(t,this);else{var n=t instanceof NodeList?i(t):t;H.call(n,e.bind(this))}else k(this,e,t);return this},B=function(e){return\"string\"==typeof e?e:e instanceof Node?e.cloneNode(!0):\"length\"in e?[].map.call(e,function(e){return e.cloneNode(!0)}):e},k=function(e,t,n){for(var i=e.length;i--;){var r=0===i?n:B(n);t.call(e[i],r)}},q=Object.freeze({append:$,prepend:function e(t){if(this instanceof Node)if(\"string\"==typeof t)this.insertAdjacentHTML(\"afterbegin\",t);else if(t instanceof Node)this.insertBefore(t,this.firstChild);else{var n=t instanceof NodeList?i(t):t;H.call(n.reverse(),e.bind(this))}else k(this,e,t);return this},before:I,after:function e(t){if(this instanceof Node)if(\"string\"==typeof t)this.insertAdjacentHTML(\"afterend\",t);else if(t instanceof Node)this.parentNode.insertBefore(t,this.nextSibling);else{var n=t instanceof NodeList?i(t):t;H.call(n.reverse(),e.bind(this))}else k(this,e,t);return this},clone:function(){return l(B(this))},_clone:B,_each:k}),F=Object.freeze({attr:function(e,t){if(\"string\"==typeof e&&void 0===t){var n=this.nodeType?this:this[0];return n?n.getAttribute(e):void 0}return r(this,function(n){if(\"object\"==typeof e)for(var i in e)n.setAttribute(i,e[i]);else n.setAttribute(e,t)})},removeAttr:function(e){return r(this,function(t){return t.removeAttribute(e)})}}),R=function(e,t){return r(this,function(n){return n.classList[e](t)})},U=Object.freeze({addClass:function(e){return e&&e.length&&r(e.split(\" \"),R.bind(this,\"add\")),this},removeClass:function(e){return e&&e.length&&r(e.split(\" \"),R.bind(this,\"remove\")),this},toggleClass:function(e,t){if(e&&e.length){var n=\"boolean\"==typeof t?t?\"add\":\"remove\":\"toggle\";r(e.split(\" \"),R.bind(this,n))}return this},hasClass:function(e){return(this.nodeType?[this]:this).some(function(t){return t.classList.contains(e)})}}),K=function(e,t){return!(!e||!t||e===t)&&(e.contains?e.contains(t):!!e.compareDocumentPosition&&!(e.compareDocumentPosition(t)&Node.DOCUMENT_POSITION_DISCONNECTED))},W=Object.freeze({contains:K}),Z=\"undefined\"!=typeof document&&\"dataset\"in document.documentElement,G=Z?\"dataset\":\"__DOMTASTIC_DATA__\",J=function(e){return e.replace(/-+(.)?/g,function(e,t){return t?t.toUpperCase():\"\"})},Q=Object.freeze({data:function(e,t){if(\"string\"==typeof e&&void 0===t){var n=this.nodeType?this:this[0];return n&&G in n?n[G][J(e)]:void 0}return r(this,function(n){Z||(n[G]=n[G]||{}),n[G][J(e)]=t})},prop:function(e,t){if(\"string\"==typeof e&&void 0===t){var n=this.nodeType?this:this[0];return n&&n?n[e]:void 0}return r(this,function(n){return n[e]=t})}}),V=Object.freeze({appendTo:function(e){var t=\"string\"==typeof e?l(e):e;return $.call(t,this),this},empty:function(){return r(this,function(e){return e.innerHTML=\"\"})},remove:function(){return r(this,function(e){e.parentNode&&e.parentNode.removeChild(e)})},replaceWith:function(){return I.apply(this,arguments).remove()},text:function(e){return void 0===e?this[0].textContent:r(this,function(t){return t.textContent=\"\"+e})},val:function(e){return void 0===e?this.length>0?this[0].value:void 0:r(this,function(t){return t.value=e})}}),X=Object.freeze({html:function(e){if(void 0===e){var t=this.nodeType?this:this[0];return t?t.innerHTML:void 0}return r(this,function(t){return t.innerHTML=e})}}),Y=function(){var e=function(e,t){var n=[];return r(this,function(i){for(;i&&i!==t;){if(h(i,e)){n.push(i);break}i=i.parentElement}}),l(u(n))};return\"undefined\"!=typeof Element&&Element.prototype.closest?function(t,n){if(n)return e.call(this,t,n);var i=[];return r(this,function(e){var n=e.closest(t);n&&i.push(n)}),l(u(i))}:e}(),ee=Object.freeze({closest:Y}),te=function(e,t,n,i,o){var u,s,c,f=this;return\"function\"==typeof t&&(n=t,t=null),e.split(\" \").forEach(function(a){u=a.split(\".\"),a=u[0]||null,s=u[1]||null,c=fe(n),r(f,function(r){if(t&&(c=pe.bind(r,t,c)),o){var u=c;c=function(o){ne.call(r,e,t,n,i),u.call(r,o)}}r.addEventListener(a,c,i||!1),se(r).push({eventName:a,handler:n,eventListener:c,selector:t,namespace:s})})},this),this},ne=function(e,t,n,i){var o,u,s,c=this;return void 0===e&&(e=\"\"),\"function\"==typeof t&&(n=t,t=null),e.split(\" \").forEach(function(e){return o=e.split(\".\"),e=o[0]||null,u=o[1]||null,r(c,function(o){s=se(o),r(s.filter(function(i){return!(e&&i.eventName!==e||u&&i.namespace!==u||n&&i.handler!==n||t&&i.selector!==t)}),function(e){o.removeEventListener(e.eventName,e.eventListener,i||!1),s.splice(s.indexOf(e),1)}),e||u||t||n?0===s.length&&ce(o):ce(o)})},this),this},ie=\"__domtastic_event__\",re=1,oe={},ue=[],se=function(e){e[ie]||(e[ie]=0===ue.length?++re:ue.pop());var t=e[ie];return oe[t]||(oe[t]=[])},ce=function(e){var t=e[ie];oe[t]&&(oe[t]=null,e[ie]=null,ue.push(t))},fe=function(e){return function(t){return e.call(this,he(t))}},ae={preventDefault:\"isDefaultPrevented\",stopImmediatePropagation:\"isImmediatePropagationStopped\",stopPropagation:\"isPropagationStopped\"},le=function(){return!0},de=function(){return!1},he=function(e){if(!e.isDefaultPrevented||e.stopImmediatePropagation||e.stopPropagation){for(var t in ae)!function(t,n,i){e[t]=function(){return this[n]=le,i&&i.apply(this,arguments)},e[n]=de}(t,ae[t],e[t]);e._preventDefault&&e.preventDefault()}return e},pe=function(e,t,n){var i=n._target||n.target,r=Y.call([i],e,this)[0];r&&r!==this&&(r!==i&&n.isPropagationStopped&&n.isPropagationStopped()||t.call(r,n))},ve=te,me=ne,ye=Object.freeze({on:te,off:ne,one:function(e,t,n,i){return te.call(this,e,t,n,i,1)},getHandlers:se,clearHandlers:ce,proxyHandler:fe,delegateHandler:pe,bind:ve,unbind:me}),be=/^(mouse(down|up|over|out|enter|leave|move)|contextmenu|(dbl)?click)$/,ge=/^key(down|press|up)$/,Ee=function(e,t,n){var i=void 0===n?{}:n,o=i.bubbles,u=void 0===o||o,s=i.cancelable,c=void 0===s||s,f=i.preventDefault,a=void 0!==f&&f,l=new(Ne(e))(e,{bubbles:u,cancelable:c,preventDefault:a,detail:t});return l._preventDefault=a,r(this,function(n){!u||je||Ce(n)?Te(n,l):Oe(n,e,{bubbles:u,cancelable:c,preventDefault:a,detail:t})})},Ne=function(e){return Ae?be.test(e)?MouseEvent:ge.test(e)?KeyboardEvent:CustomEvent:CustomEvent},Ce=function(e){return e===window||e===document||K(e.ownerDocument.documentElement,e)},Oe=function(e,t,n){void 0===n&&(n={}),n.bubbles=!1;var i=new CustomEvent(t,n);i._target=e;do{Te(e,i)}while(e=e.parentNode)},we=[\"blur\",\"focus\",\"select\",\"submit\"],Te=function(e,t){-1===we.indexOf(t.type)||\"function\"!=typeof e[t.type]||t._preventDefault||t.cancelable?e.dispatchEvent(t):e[t.type]()};!function(){var e=function(e,t){void 0===t&&(t={bubbles:!1,cancelable:!1,detail:void 0});var n=document.createEvent(\"CustomEvent\");return n.initCustomEvent(e,t.bubbles,t.cancelable,t.detail),n};e.prototype=n.CustomEvent&&n.CustomEvent.prototype,n.CustomEvent=e}();var je=function(){var e=!1,t=n.document;if(t){var i=t.createElement(\"div\"),r=i.cloneNode();i.appendChild(r),i.addEventListener(\"e\",function(){e=!0}),r.dispatchEvent(new CustomEvent(\"e\",{bubbles:!0}))}return e}(),Ae=function(){try{new MouseEvent(\"click\")}catch(e){return!1}return!0}(),Le=Object.freeze({trigger:Ee,triggerHandler:function(e,t){this[0]&&Ee.call(this[0],e,t,{bubbles:!1,preventDefault:!0})}}),De=Object.freeze({ready:function(e){return/complete|loaded|interactive/.test(document.readyState)&&document.body?e():document.addEventListener(\"DOMContentLoaded\",e,!1),this}}),ze=n.$,_e=Object.freeze({noConflict:function(){return n.$=ze,this}}),Me=function(e,t){return l([].slice.apply(this,arguments))},xe=Object.freeze({children:function(e){var t=[];return r(this,function(n){n.children&&r(n.children,function(n){(!e||e&&h(n,e))&&t.push(n)})}),l(t)},concat:function(e){var t=this;return r(l(e),function(e){-1===[].indexOf.call(t,e)&&[].push.call(t,e)}),this},contents:function(){var e=[];return r(this,function(t){return e.push.apply(e,i(t.childNodes))}),l(e)},eq:function(e){return Me.call(this,e,e+1)},first:function(){return Me.call(this,0,1)},get:function(e){return this[e]},parent:function(e){var t=[];return r(this,function(n){(!e||e&&h(n.parentNode,e))&&t.push(n.parentNode)}),l(t)},siblings:function(e){var t=[];return r(this,function(n){return r(n.parentNode.children,function(i){i!==n&&(!e||e&&h(i,e))&&t.push(i)})}),l(t)},slice:Me}),Se=Array.isArray,Pe=Object.freeze({isFunction:function(e){return\"function\"==typeof e},isArray:Se}),He={},$e={};return void 0!==b&&(($e=l).matches=h,He.find=d),o($e,W,_e,Pe),o(He,M,P,F,q,U,Q,V,X,ye,Le,De,ee,xe),$e.fn=He,$e.version=\"0.15.12\",$e.extend=o,$e.BaseClass=x($e.fn),$e});\n\n//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["domtastic.js"],"names":["global","factory","exports","module","define","amd","self","$","this","context","_matches","win","window","toArray","collection","length","result","Array","i","each","callback","thisArg","undefined","nodeType","call","extend","target","_len","arguments","sources","_key","forEach","src","prop","uniq","filter","item","index","indexOf","isPrototypeSet","reFragment","reSingleTag","reSimpleSelector","selector","document","DOMtastic","test","createFragment","querySelector","querySelectorAll","wrap","find","nodes","node","child","push","matches","Element","prototype","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","element","getElementById","slice","getElementsByClassName","getElementsByTagName","html","createElement","RegExp","$1","elements","container","children","childNodes","innerHTML","l","fn","constructor","Object","freeze","ArrayProto","every","each$1","map","pop","reduce","reduceRight","shift","some","unshift","array","reverse","BaseClass","api","apply","camelize","value","replace","letter","toUpperCase","css$1","css","key","styleProps","val","isNaN","parseFloat","isFinite","isNumeric","style","removeProperty","toLowerCase","forEach$1","append","Node","insertAdjacentHTML","appendChild","NodeList","bind","_each","before","parentNode","insertBefore","_clone","cloneNode","el","elm","dom","prepend","firstChild","after","nextSibling","clone","dom_attr","attr","getAttribute","_attr","setAttribute","removeAttr","removeAttribute","_each$1","fnName","className","classList","dom_class","addClass","split","removeClass","toggleClass","state","action","hasClass","contains","compareDocumentPosition","DOCUMENT_POSITION_DISCONNECTED","dom_contains","isSupportsDataSet","documentElement","DATAKEYPROP","camelize$1","str","match","char","dom_data","data","dom_extra","appendTo","empty","remove","removeChild","replaceWith","text","textContent","dom_html","fragment","closest","parentElement","n","selector_closest","on","eventNames","handler","useCapture","once","parts","namespace","eventListener","_this","eventName","proxyHandler","delegateHandler","listener","event","off","addEventListener","getHandlers","handlers","_this2","removeEventListener","splice","clearHandlers","eventKeyProp","id","unusedKeys","augmentEvent","eventMethods","preventDefault","stopImmediatePropagation","stopPropagation","returnTrue","returnFalse","isDefaultPrevented","methodName","testMethodName","originalMethod","_preventDefault","eventTarget","_target","currentTarget","isPropagationStopped","unbind","one","reMouseEvent","reKeyEvent","trigger","type","_temp","_ref","_ref$bubbles","bubbles","_ref$cancelable","cancelable","_ref$preventDefault","getEventConstructor","detail","isEventBubblingInDetachedTree","isAttachedToDocument","dispatchEvent","triggerForPath","isSupportsOtherEventConstructors","MouseEvent","KeyboardEvent","CustomEvent","ownerDocument","params","directEventMethods","customEvent","createEvent","initCustomEvent","isBubbling","doc","parent","e","event_trigger","triggerHandler","event_ready","ready","readyState","body","previousLib","noconflict","noConflict","start","end","selector_extra","concat","contents","eq","first","get","siblings","sibling","isArray","isFunction","obj","$$1","version"],"mappings":"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","file":"E:\\workspace\\pantomath-chatbot\\node_modules\\domtastic\\dist\\domtastic.js"}","\"use strict\";const arrify=require(\"arrify\"),isPlainObject=require(\"is-plain-object\"),classNames=require(\"classnames\"),render=require(\"./render\"),utils=require(\"./utils\"),h=(e,s,r)=>{s&&!isPlainObject(s)?(r=s,s={}):s||(s={}),r=arrify(r);const i=utils.getSelectorParts(e);return i.id&&(s.id=i.id),i.classes.length&&(s.class=classNames(s.class,i.classes)),render(i.tag,s,r)};module.exports=exports=h;\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImFycmlmeSIsInJlcXVpcmUiLCJpc1BsYWluT2JqZWN0IiwiY2xhc3NOYW1lcyIsInJlbmRlciIsInV0aWxzIiwiaCIsInNlbGVjdG9yIiwiYXR0cnMiLCJjaGlsZHJlbiIsInBhcnRzIiwiZ2V0U2VsZWN0b3JQYXJ0cyIsImlkIiwiY2xhc3NlcyIsImxlbmd0aCIsImNsYXNzIiwidGFnIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6IkFBQUEsYUFDQSxNQUFNQSxPQUFTQyxRQUFRLFVBQ2pCQyxjQUFnQkQsUUFBUSxtQkFDeEJFLFdBQWFGLFFBQVEsY0FDckJHLE9BQVNILFFBQVEsWUFDakJJLE1BQVFKLFFBQVEsV0FFaEJLLEVBQUksQ0FBQ0MsRUFBVUMsRUFBT0MsS0FDdkJELElBQVVOLGNBQWNNLElBQzNCQyxFQUFXRCxFQUNYQSxFQUFRLElBQ0dBLElBQ1hBLEVBQVEsSUFFVEMsRUFBV1QsT0FBT1MsR0FDbEIsTUFBTUMsRUFBUUwsTUFBTU0saUJBQWlCSixHQU9yQyxPQU5JRyxFQUFNRSxLQUNUSixFQUFNSSxHQUFLRixFQUFNRSxJQUVkRixFQUFNRyxRQUFRQyxTQUNqQk4sRUFBTU8sTUFBUVosV0FBV0ssRUFBTU8sTUFBT0wsRUFBTUcsVUFFdENULE9BQU9NLEVBQU1NLElBQUtSLEVBQU9DLElBR2pDUSxPQUFPQyxRQUFVQSxRQUFVWiIsImZpbGUiOiJFOlxcd29ya3NwYWNlXFxwYW50b21hdGgtY2hhdGJvdFxcbm9kZV9tb2R1bGVzXFxoeXBlcnNjcmlwdC1zdHJpbmdcXHNyY1xcaW5kZXguanMifQ==","\"use strict\";const voidElements=require(\"void-elements\"),arrify=require(\"arrify\");function renderAttributes(e){return(e=Object.keys(e).filter(r=>void 0!==e[r]&&null!==e[r]&&!1!==e[r]).map(r=>!0===e[r]?r:`${r}=\"${e[r]}\"`).join(\" \"))?` ${e}`:\"\"}function renderChildren(e){return 0===(e=arrify(e)).length?\"\":1===e.length?e[0]:`\\n\\t${e.join(\"\\n\\t\")}\\n`}module.exports=exports=function(e,r,t){return\"!doctype\"===e||voidElements[e]?`<${e}${renderAttributes(r)}>`:`<${e}${renderAttributes(r)}>${renderChildren(t)}</${e}>`};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlbmRlci5qcyJdLCJuYW1lcyI6WyJ2b2lkRWxlbWVudHMiLCJyZXF1aXJlIiwiYXJyaWZ5IiwicmVuZGVyQXR0cmlidXRlcyIsImF0dHJzIiwiT2JqZWN0Iiwia2V5cyIsImZpbHRlciIsIm5hbWUiLCJ1bmRlZmluZWQiLCJtYXAiLCJqb2luIiwicmVuZGVyQ2hpbGRyZW4iLCJjaGlsZHJlbiIsImxlbmd0aCIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0EsTUFBTUEsYUFBZUMsUUFBUSxpQkFDdkJDLE9BQVNELFFBQVEsVUFTdkIsU0FBU0UsaUJBQWlCQyxHQWF6QixPQVpBQSxFQUFRQyxPQUFPQyxLQUFLRixHQUNsQkcsT0FBT0MsUUFDU0MsSUFBaEJMLEVBQU1JLElBQ1UsT0FBaEJKLEVBQU1JLEtBQ1UsSUFBaEJKLEVBQU1JLElBRU5FLElBQUlGLElBQ1ksSUFBaEJKLEVBQU1JLEdBQ05BLEtBQ0dBLE1BQVNKLEVBQU1JLE9BRWxCRyxLQUFLLFVBRUtQLElBRUwsR0FHUixTQUFTUSxlQUFlQyxHQUV2QixPQUF3QixLQUR4QkEsRUFBV1gsT0FBT1csSUFDTEMsT0FDTCxHQUN1QixJQUFwQkQsRUFBU0MsT0FDWkQsRUFBUyxVQUVIQSxFQUFTRixLQUFLLFlBakM3QkksT0FBT0MsUUFBVUEsUUFBVSxTQUFnQlIsRUFBTUosRUFBT1MsR0FDdkQsTUFBYSxhQUFUTCxHQUF1QlIsYUFBYVEsT0FDNUJBLElBQU9MLGlCQUFpQkMsVUFFekJJLElBQU9MLGlCQUFpQkMsTUFBVVEsZUFBZUMsT0FBY0wiLCJmaWxlIjoiRTpcXFdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaHlwZXJzY3JpcHQtc3RyaW5nXFxzcmNcXHJlbmRlci5qcyJ9","\"use strict\";const SELECTOR_REGEX=/(^|#|\\.)[^#\\.]+/g;function getTag(t){return\"#\"===t[0][0]||\".\"===t[0][0]?\"div\":t[0].toLowerCase()}function getClasses(t){return t.filter(isClass).map(slice(1))}function getId(t){return t.filter(isId).map(slice(1))[0]}function slice(t,e){return s=>s.slice(t,e)}function isId(t){return\"#\"===t[0]}function isClass(t){return\".\"===t[0]}exports.getSelectorParts=(t=>{const e=t.match(SELECTOR_REGEX);if(!e)throw new Error(`Invalid selector! Should have the format \"name.class1.class2#id\", but was: \"${t}\"`);return{tag:getTag(e),id:getId(e),classes:getClasses(e)}});\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInV0aWxzLmpzIl0sIm5hbWVzIjpbIlNFTEVDVE9SX1JFR0VYIiwiZ2V0VGFnIiwibWF0Y2hlcyIsInRvTG93ZXJDYXNlIiwiZ2V0Q2xhc3NlcyIsImZpbHRlciIsImlzQ2xhc3MiLCJtYXAiLCJzbGljZSIsImdldElkIiwiaXNJZCIsImEiLCJiIiwidmFsIiwic3RyIiwiZXhwb3J0cyIsImdldFNlbGVjdG9yUGFydHMiLCJzZWxlY3RvciIsIm1hdGNoIiwiRXJyb3IiLCJ0YWciLCJpZCIsImNsYXNzZXMiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0EsTUFBTUEsZUFBaUIsbUJBY3ZCLFNBQVNDLE9BQU9DLEdBQ2YsTUFBc0IsTUFBbEJBLEVBQVEsR0FBRyxJQUFnQyxNQUFsQkEsRUFBUSxHQUFHLEdBQ2hDLE1BRURBLEVBQVEsR0FBR0MsY0FHbkIsU0FBU0MsV0FBV0YsR0FDbkIsT0FBT0EsRUFBUUcsT0FBT0MsU0FBU0MsSUFBSUMsTUFBTSxJQUcxQyxTQUFTQyxNQUFNUCxHQUNkLE9BQU9BLEVBQVFHLE9BQU9LLE1BQU1ILElBQUlDLE1BQU0sSUFBSSxHQUczQyxTQUFTQSxNQUFNRyxFQUFHQyxHQUNqQixPQUFPQyxHQUFPQSxFQUFJTCxNQUFNRyxFQUFHQyxHQUc1QixTQUFTRixLQUFLSSxHQUNiLE1BQWtCLE1BQVhBLEVBQUksR0FHWixTQUFTUixRQUFRUSxHQUNoQixNQUFrQixNQUFYQSxFQUFJLEdBcENaQyxRQUFRQyxpQkFBbUIsQ0FBQ0MsSUFDM0IsTUFBTWYsRUFBVWUsRUFBU0MsTUFBTWxCLGdCQUMvQixJQUFLRSxFQUNKLE1BQU0sSUFBSWlCLHFGQUFxRkYsTUFFaEcsTUFBTyxDQUNORyxJQUFLbkIsT0FBT0MsR0FDWm1CLEdBQUlaLE1BQU1QLEdBQ1ZvQixRQUFTbEIsV0FBV0YiLCJmaWxlIjoiRTpcXFdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaHlwZXJzY3JpcHQtc3RyaW5nXFxzcmNcXHV0aWxzLmpzIn0=","\"use strict\";var isObject=require(\"isobject\");function isObjectObject(t){return!0===isObject(t)&&\"[object Object]\"===Object.prototype.toString.call(t)}module.exports=function(t){var e,c;return!1!==isObjectObject(t)&&(\"function\"==typeof(e=t.constructor)&&(!1!==isObjectObject(c=e.prototype)&&!1!==c.hasOwnProperty(\"isPrototypeOf\")))};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImlzT2JqZWN0IiwicmVxdWlyZSIsImlzT2JqZWN0T2JqZWN0IiwibyIsIk9iamVjdCIsInByb3RvdHlwZSIsInRvU3RyaW5nIiwiY2FsbCIsIm1vZHVsZSIsImV4cG9ydHMiLCJjdG9yIiwicHJvdCIsImNvbnN0cnVjdG9yIiwiaGFzT3duUHJvcGVydHkiXSwibWFwcGluZ3MiOiJBQU9BLGFBRUEsSUFBSUEsU0FBV0MsUUFBUSxZQUV2QixTQUFTQyxlQUFlQyxHQUN0QixPQUF1QixJQUFoQkgsU0FBU0csSUFDMkIsb0JBQXRDQyxPQUFPQyxVQUFVQyxTQUFTQyxLQUFLSixHQUd0Q0ssT0FBT0MsUUFBVSxTQUF1Qk4sR0FDdEMsSUFBSU8sRUFBS0MsRUFFVCxPQUEwQixJQUF0QlQsZUFBZUMsS0FJQyxtQkFEcEJPLEVBQU9QLEVBQUVTLGdCQUtvQixJQUF6QlYsZUFESlMsRUFBT0QsRUFBS0wsYUFJaUMsSUFBekNNLEVBQUtFLGVBQWUiLCJmaWxlIjoiRTpcXFdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaXMtcGxhaW4tb2JqZWN0XFxpbmRleC5qcyJ9","\"use strict\";module.exports=function(r){return null!=r&&\"object\"==typeof r&&!1===Array.isArray(r)};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJ2YWwiLCJBcnJheSIsImlzQXJyYXkiXSwibWFwcGluZ3MiOiJBQU9BLGFBRUFBLE9BQU9DLFFBQVUsU0FBa0JDLEdBQ2pDLE9BQWMsTUFBUEEsR0FBOEIsaUJBQVJBLElBQTJDLElBQXZCQyxNQUFNQyxRQUFRRiIsImZpbGUiOiJFOlxcV29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxpc29iamVjdFxcaW5kZXguanMifQ==","(function(){var t,e,i,n,s,r=function(t,e){return function(){return t.apply(e,arguments)}},o=[].slice,l={}.hasOwnProperty,u=function(t,e){for(var i in e)l.call(e,i)&&(t[i]=e[i]);function n(){this.constructor=t}return n.prototype=e.prototype,t.prototype=new n,t.__super__=e.prototype,t},h=[].indexOf||function(t){for(var e=0,i=this.length;e<i;e++)if(e in this&&this[e]===t)return e;return-1};t={options:[\"prefix\",\"templateDelimiters\",\"rootInterface\",\"preloadData\",\"handler\",\"executeFunctions\"],extensions:[\"binders\",\"formatters\",\"components\",\"adapters\"],public:{binders:{},components:{},formatters:{},adapters:{},prefix:\"rv\",templateDelimiters:[\"{\",\"}\"],rootInterface:\".\",preloadData:!0,executeFunctions:!1,iterationAlias:function(t){return\"%\"+t+\"%\"},handler:function(t,e,i){return this.call(t,e,i.view.models)},configure:function(e){var i,n,s,r;for(s in null==e&&(e={}),e)if(r=e[s],\"binders\"===s||\"components\"===s||\"formatters\"===s||\"adapters\"===s)for(n in r)i=r[n],t[s][n]=i;else t.public[s]=r},bind:function(e,i,n){var s;return null==i&&(i={}),null==n&&(n={}),(s=new t.View(e,i,n)).bind(),s},init:function(e,i,n){var s,r,o;if(null==n&&(n={}),null==i&&(i=document.createElement(\"div\")),(r=(e=t.public.components[e]).template.call(this,i))instanceof HTMLElement){for(;i.firstChild;)i.removeChild(i.firstChild);i.appendChild(r)}else i.innerHTML=r;return s=e.initialize.call(this,i,n),(o=new t.View(i,s)).bind(),o}}},window.jQuery||window.$?(s=\"on\"in(i=window.jQuery||window.$).prototype?[\"on\",\"off\"]:[\"bind\",\"unbind\"],e=s[0],n=s[1],t.Util={bindEvent:function(t,n,s){return i(t)[e](n,s)},unbindEvent:function(t,e,s){return i(t)[n](e,s)},getInputValue:function(t){var e;return\"checkbox\"===(e=i(t)).attr(\"type\")?e.is(\":checked\"):e.val()}}):t.Util={bindEvent:\"addEventListener\"in window?function(t,e,i){return t.addEventListener(e,i,!1)}:function(t,e,i){return t.attachEvent(\"on\"+e,i)},unbindEvent:\"removeEventListener\"in window?function(t,e,i){return t.removeEventListener(e,i,!1)}:function(t,e,i){return t.detachEvent(\"on\"+e,i)},getInputValue:function(t){var e,i,n,s;if(\"checkbox\"===t.type)return t.checked;if(\"select-multiple\"===t.type){for(s=[],i=0,n=t.length;i<n;i++)(e=t[i]).selected&&s.push(e.value);return s}return t.value}},t.TypeParser=function(){function t(){}return t.types={primitive:0,keypath:1},t.parse=function(t){return/^'.*'$|^\".*\"$/.test(t)?{type:this.types.primitive,value:t.slice(1,-1)}:\"true\"===t?{type:this.types.primitive,value:!0}:\"false\"===t?{type:this.types.primitive,value:!1}:\"null\"===t?{type:this.types.primitive,value:null}:\"undefined\"===t?{type:this.types.primitive,value:void 0}:\"\"===t?{type:this.types.primitive,value:void 0}:!1===isNaN(Number(t))?{type:this.types.primitive,value:Number(t)}:{type:this.types.keypath,value:t}},t}(),t.TextTemplateParser=function(){function t(){}return t.types={text:0,binding:1},t.parse=function(t,e){var i,n,s,r,o,l,u;for(l=[],r=t.length,i=0,n=0;n<r;){if((i=t.indexOf(e[0],n))<0){l.push({type:this.types.text,value:t.slice(n)});break}if(i>0&&n<i&&l.push({type:this.types.text,value:t.slice(n,i)}),n=i+e[0].length,(i=t.indexOf(e[1],n))<0){o=t.slice(n-e[1].length),(null!=(s=l[l.length-1])?s.type:void 0)===this.types.text?s.value+=o:l.push({type:this.types.text,value:o});break}u=t.slice(n,i).trim(),l.push({type:this.types.binding,value:u}),n=i+e[1].length}return l},t}(),t.View=function(){function e(e,i,n){var s,o,l,u,h,a,p,d,c,f,b,v,m;for(this.els=e,this.models=i,null==n&&(n={}),this.update=r(this.update,this),this.publish=r(this.publish,this),this.sync=r(this.sync,this),this.unbind=r(this.unbind,this),this.bind=r(this.bind,this),this.select=r(this.select,this),this.traverse=r(this.traverse,this),this.build=r(this.build,this),this.buildBinding=r(this.buildBinding,this),this.bindingRegExp=r(this.bindingRegExp,this),this.options=r(this.options,this),this.els.jquery||this.els instanceof Array||(this.els=[this.els]),h=0,p=(c=t.extensions).length;h<p;h++){if(this[o=c[h]]={},n[o])for(s in f=n[o])l=f[s],this[o][s]=l;for(s in b=t.public[o])l=b[s],null==(u=this[o])[s]&&(u[s]=l)}for(a=0,d=(v=t.options).length;a<d;a++)this[o=v[a]]=null!=(m=n[o])?m:t.public[o];this.build()}return e.prototype.options=function(){var e,i,n,s,r;for(i={},n=0,s=(r=t.extensions.concat(t.options)).length;n<s;n++)i[e=r[n]]=this[e];return i},e.prototype.bindingRegExp=function(){return new RegExp(\"^\"+this.prefix+\"-\")},e.prototype.buildBinding=function(e,i,n,s){var r,o,l,u,h,a,p;return h={},p=function(){var t,e,i,n;for(n=[],t=0,e=(i=s.match(/((?:'[^']*')*(?:(?:[^\\|']*(?:'[^']*')+[^\\|']*)+|[^\\|]+))|^$/g)).length;t<e;t++)a=i[t],n.push(a.trim());return n}(),u=(r=function(){var t,e,i,n;for(n=[],t=0,e=(i=p.shift().split(\"<\")).length;t<e;t++)o=i[t],n.push(o.trim());return n}()).shift(),h.formatters=p,(l=r.shift())&&(h.dependencies=l.split(/\\s+/)),this.bindings.push(new t[e](this,i,n,u,h))},e.prototype.build=function(){var e,i,n,s,r,o;for(this.bindings=[],o=this,i=function(e){var n,s,r,l,u,h,a,p,d,c,f,b,v;if(3===e.nodeType){if(u=t.TextTemplateParser,(r=o.templateDelimiters)&&(p=u.parse(e.data,r)).length&&(1!==p.length||p[0].type!==u.types.text)){for(d=0,f=p.length;d<f;d++)a=p[d],h=document.createTextNode(a.value),e.parentNode.insertBefore(h,e),1===a.type&&o.buildBinding(\"TextBinding\",h,null,a.value);e.parentNode.removeChild(e)}}else 1===e.nodeType&&(n=o.traverse(e));if(!n)for(v=function(){var t,i,n,s;for(s=[],t=0,i=(n=e.childNodes).length;t<i;t++)l=n[t],s.push(l);return s}(),c=0,b=v.length;c<b;c++)s=v[c],i(s)},n=0,s=(r=this.els).length;n<s;n++)e=r[n],i(e);this.bindings.sort(function(t,e){var i,n;return((null!=(i=e.binder)?i.priority:void 0)||0)-((null!=(n=t.binder)?n.priority:void 0)||0)})},e.prototype.traverse=function(e){var i,n,s,r,o,l,u,h,a,p,d,c,f,b,v;for(r=this.bindingRegExp(),o=\"SCRIPT\"===e.nodeName||\"STYLE\"===e.nodeName,a=0,d=(f=e.attributes).length;a<d;a++)if(i=f[a],r.test(i.name)){if(u=i.name.replace(r,\"\"),!(s=this.binders[u]))for(l in b=this.binders)h=b[l],\"*\"!==l&&-1!==l.indexOf(\"*\")&&new RegExp(\"^\"+l.replace(/\\*/g,\".+\")+\"$\").test(u)&&(s=h);s||(s=this.binders[\"*\"]),s.block&&(o=!0,n=[i])}for(p=0,c=(v=n||e.attributes).length;p<c;p++)i=v[p],r.test(i.name)&&(u=i.name.replace(r,\"\"),this.buildBinding(\"Binding\",e,u,i.value));return o||(u=e.nodeName.toLowerCase(),this.components[u]&&!e._bound&&(this.bindings.push(new t.ComponentBinding(this,e,u)),o=!0)),o},e.prototype.select=function(t){var e,i,n,s,r;for(r=[],i=0,n=(s=this.bindings).length;i<n;i++)t(e=s[i])&&r.push(e);return r},e.prototype.bind=function(){var t,e,i;for(t=0,e=(i=this.bindings).length;t<e;t++)i[t].bind()},e.prototype.unbind=function(){var t,e,i;for(t=0,e=(i=this.bindings).length;t<e;t++)i[t].unbind()},e.prototype.sync=function(){var t,e,i,n;for(e=0,i=(n=this.bindings).length;e<i;e++)\"function\"==typeof(t=n[e]).sync&&t.sync()},e.prototype.publish=function(){var t,e,i;for(t=0,e=(i=this.select(function(t){var e;return null!=(e=t.binder)?e.publishes:void 0})).length;t<e;t++)i[t].publish()},e.prototype.update=function(t){var e,i,n,s,r,o;for(i in null==t&&(t={}),t)n=t[i],this.models[i]=n;for(s=0,r=(o=this.bindings).length;s<r;s++)\"function\"==typeof(e=o[s]).update&&e.update(t)},e}(),t.Binding=function(){function e(t,e,i,n,s){this.view=t,this.el=e,this.type=i,this.keypath=n,this.options=null!=s?s:{},this.getValue=r(this.getValue,this),this.update=r(this.update,this),this.unbind=r(this.unbind,this),this.bind=r(this.bind,this),this.publish=r(this.publish,this),this.sync=r(this.sync,this),this.set=r(this.set,this),this.eventHandler=r(this.eventHandler,this),this.formattedValue=r(this.formattedValue,this),this.parseFormatterArguments=r(this.parseFormatterArguments,this),this.parseTarget=r(this.parseTarget,this),this.observe=r(this.observe,this),this.setBinder=r(this.setBinder,this),this.formatters=this.options.formatters||[],this.dependencies=[],this.formatterObservers={},this.model=void 0,this.setBinder()}return e.prototype.setBinder=function(){var t,e,i;if(!(this.binder=this.view.binders[this.type]))for(t in i=this.view.binders)e=i[t],\"*\"!==t&&-1!==t.indexOf(\"*\")&&new RegExp(\"^\"+t.replace(/\\*/g,\".+\")+\"$\").test(this.type)&&(this.binder=e,this.args=new RegExp(\"^\"+t.replace(/\\*/g,\"(.+)\")+\"$\").exec(this.type),this.args.shift());if(this.binder||(this.binder=this.view.binders[\"*\"]),this.binder instanceof Function)return this.binder={routine:this.binder}},e.prototype.observe=function(e,i,n){return t.sightglass(e,i,n,{root:this.view.rootInterface,adapters:this.view.adapters})},e.prototype.parseTarget=function(){var e;return(e=t.TypeParser.parse(this.keypath)).type===t.TypeParser.types.primitive?this.value=e.value:(this.observer=this.observe(this.view.models,this.keypath,this.sync),this.model=this.observer.target)},e.prototype.parseFormatterArguments=function(e,i){var n,s,r,o,l,u,h;for(e=function(){var i,n,r;for(r=[],i=0,n=e.length;i<n;i++)s=e[i],r.push(t.TypeParser.parse(s));return r}(),o=[],n=u=0,h=e.length;u<h;n=++u)s=e[n],o.push(s.type===t.TypeParser.types.primitive?s.value:((l=this.formatterObservers)[i]||(l[i]={}),(r=this.formatterObservers[i][n])||(r=this.observe(this.view.models,s.value,this.sync),this.formatterObservers[i][n]=r),r.value()));return o},e.prototype.formattedValue=function(t){var e,i,n,s,r,l,u,h,a;for(i=l=0,u=(h=this.formatters).length;l<u;i=++l)s=(e=(n=h[i]).match(/[^\\s']+|'([^']|'[^\\s])*'|\"([^\"]|\"[^\\s])*\"/g)).shift(),n=this.view.formatters[s],r=this.parseFormatterArguments(e,i),(null!=n?n.read:void 0)instanceof Function?t=(a=n.read).call.apply(a,[this.model,t].concat(o.call(r))):n instanceof Function&&(t=n.call.apply(n,[this.model,t].concat(o.call(r))));return t},e.prototype.eventHandler=function(t){var e,i;return i=(e=this).view.handler,function(n){return i.call(t,this,n,e)}},e.prototype.set=function(e){var i;return e=e instanceof Function&&!this.binder.function&&t.public.executeFunctions?this.formattedValue(e.call(this.model)):this.formattedValue(e),null!=(i=this.binder.routine)?i.call(this,this.el,e):void 0},e.prototype.sync=function(){var t,e;return this.set(function(){var i,n,s,r,o,l,u;if(this.observer){if(this.model!==this.observer.target){for(i=0,s=(o=this.dependencies).length;i<s;i++)(e=o[i]).unobserve();if(this.dependencies=[],null!=(this.model=this.observer.target)&&(null!=(l=this.options.dependencies)?l.length:void 0))for(n=0,r=(u=this.options.dependencies).length;n<r;n++)t=u[n],e=this.observe(this.model,t,this.sync),this.dependencies.push(e)}return this.observer.value()}return this.value}.call(this))},e.prototype.publish=function(){var t,e,i,n,s,r,l,u,h,a,p,d;if(this.observer){for(l=this.getValue(this.el),s=this.formatters.length-1,i=u=0,h=(a=this.formatters.slice(0).reverse()).length;u<h;i=++u)e=s-i,n=(t=a[i].split(/\\s+/)).shift(),r=this.parseFormatterArguments(t,e),(null!=(p=this.view.formatters[n])?p.publish:void 0)&&(l=(d=this.view.formatters[n]).publish.apply(d,[l].concat(o.call(r))));return this.observer.setValue(l)}},e.prototype.bind=function(){var t,e,i,n,s,r,o;if(this.parseTarget(),null!=(s=this.binder.bind)&&s.call(this,this.el),null!=this.model&&(null!=(r=this.options.dependencies)?r.length:void 0))for(i=0,n=(o=this.options.dependencies).length;i<n;i++)t=o[i],e=this.observe(this.model,t,this.sync),this.dependencies.push(e);if(this.view.preloadData)return this.sync()},e.prototype.unbind=function(){var t,e,i,n,s,r,o,l,u;for(null!=(r=this.binder.unbind)&&r.call(this,this.el),null!=(o=this.observer)&&o.unobserve(),n=0,s=(l=this.dependencies).length;n<s;n++)l[n].unobserve();for(i in this.dependencies=[],u=this.formatterObservers)for(t in e=u[i])e[t].unobserve();return this.formatterObservers={}},e.prototype.update=function(t){var e,i;return null==t&&(t={}),this.model=null!=(e=this.observer)?e.target:void 0,null!=(i=this.binder.update)?i.call(this,t):void 0},e.prototype.getValue=function(e){return this.binder&&null!=this.binder.getValue?this.binder.getValue.call(this,e):t.Util.getInputValue(e)},e}(),t.ComponentBinding=function(e){function i(e,i,n){var s,o,l,u,a,p,d,c;for(this.view=e,this.el=i,this.type=n,this.unbind=r(this.unbind,this),this.bind=r(this.bind,this),this.locals=r(this.locals,this),this.component=this.view.components[this.type],this.static={},this.observers={},this.upstreamObservers={},o=e.bindingRegExp(),a=0,p=(d=this.el.attributes||[]).length;a<p;a++)s=d[a],o.test(s.name)||(l=this.camelCase(s.name),u=t.TypeParser.parse(s.value),h.call(null!=(c=this.component.static)?c:[],l)>=0?this.static[l]=s.value:u.type===t.TypeParser.types.primitive?this.static[l]=u.value:this.observers[l]=s.value)}return u(i,e),i.prototype.sync=function(){},i.prototype.update=function(){},i.prototype.publish=function(){},i.prototype.locals=function(){var t,e,i,n,s,r;for(t in i={},s=this.static)n=s[t],i[t]=n;for(t in r=this.observers)e=r[t],i[t]=e.value();return i},i.prototype.camelCase=function(t){return t.replace(/-([a-z])/g,function(t){return t[1].toUpperCase()})},i.prototype.bind=function(){var e,i,n,s,r,o,l,u,h,a,p,d,c,f,b,v,m,y,g,w;if(!this.bound){for(i in f=this.observers)n=f[i],this.observers[i]=this.observe(this.view.models,n,function(t){return function(e){return function(){return t.componentView.models[e]=t.observers[e].value()}}}(this).call(this,i));this.bound=!0}if(null!=this.componentView)this.componentView.bind();else{for(this.el.innerHTML=this.component.template.call(this),l=this.component.initialize.call(this,this.el,this.locals()),this.el._bound=!0,o={},a=0,d=(b=t.extensions).length;a<d;a++){if(o[r=b[a]]={},this.component[r])for(e in v=this.component[r])u=v[e],o[r][e]=u;for(e in m=this.view[r])u=m[e],null==(h=o[r])[e]&&(h[e]=u)}for(p=0,c=(y=t.options).length;p<c;p++)o[r=y[p]]=null!=(g=this.component[r])?g:this.view[r];for(i in this.componentView=new t.View(Array.prototype.slice.call(this.el.childNodes),l,o),this.componentView.bind(),w=this.observers)s=w[i],this.upstreamObservers[i]=this.observe(this.componentView.models,i,function(t){return function(e,i){return function(){return i.setValue(t.componentView.models[e])}}}(this).call(this,i,s))}},i.prototype.unbind=function(){var t,e,i,n;for(t in e=this.upstreamObservers)e[t].unobserve();for(t in i=this.observers)i[t].unobserve();return null!=(n=this.componentView)?n.unbind.call(this):void 0},i}(t.Binding),t.TextBinding=function(t){function e(t,e,i,n,s){this.view=t,this.el=e,this.type=i,this.keypath=n,this.options=null!=s?s:{},this.sync=r(this.sync,this),this.formatters=this.options.formatters||[],this.dependencies=[],this.formatterObservers={}}return u(e,t),e.prototype.binder={routine:function(t,e){return t.data=null!=e?e:\"\"}},e.prototype.sync=function(){return e.__super__.sync.apply(this,arguments)},e}(t.Binding),t.public.binders.text=function(t,e){return null!=t.textContent?t.textContent=null!=e?e:\"\":t.innerText=null!=e?e:\"\"},t.public.binders.html=function(t,e){return t.innerHTML=null!=e?e:\"\"},t.public.binders.show=function(t,e){return t.style.display=e?\"\":\"none\"},t.public.binders.hide=function(t,e){return t.style.display=e?\"none\":\"\"},t.public.binders.enabled=function(t,e){return t.disabled=!e},t.public.binders.disabled=function(t,e){return t.disabled=!!e},t.public.binders.checked={publishes:!0,priority:2e3,bind:function(e){return t.Util.bindEvent(e,\"change\",this.publish)},unbind:function(e){return t.Util.unbindEvent(e,\"change\",this.publish)},routine:function(t,e){var i;return\"radio\"===t.type?t.checked=(null!=(i=t.value)?i.toString():void 0)===(null!=e?e.toString():void 0):t.checked=!!e}},t.public.binders.unchecked={publishes:!0,priority:2e3,bind:function(e){return t.Util.bindEvent(e,\"change\",this.publish)},unbind:function(e){return t.Util.unbindEvent(e,\"change\",this.publish)},routine:function(t,e){var i;return\"radio\"===t.type?t.checked=(null!=(i=t.value)?i.toString():void 0)!==(null!=e?e.toString():void 0):t.checked=!e}},t.public.binders.value={publishes:!0,priority:3e3,bind:function(e){if(\"INPUT\"!==e.tagName||\"radio\"!==e.type)return this.event=\"SELECT\"===e.tagName?\"change\":\"input\",t.Util.bindEvent(e,this.event,this.publish)},unbind:function(e){if(\"INPUT\"!==e.tagName||\"radio\"!==e.type)return t.Util.unbindEvent(e,this.event,this.publish)},routine:function(t,e){var n,s,r,o,l,u,a;if(\"INPUT\"===t.tagName&&\"radio\"===t.type)return t.setAttribute(\"value\",e);if(null!=window.jQuery){if(t=i(t),(null!=e?e.toString():void 0)!==(null!=(o=t.val())?o.toString():void 0))return t.val(null!=e?e:\"\")}else if(\"select-multiple\"===t.type){if(null!=e){for(a=[],s=0,r=t.length;s<r;s++)n=t[s],a.push(n.selected=(l=n.value,h.call(e,l)>=0));return a}}else if((null!=e?e.toString():void 0)!==(null!=(u=t.value)?u.toString():void 0))return t.value=null!=e?e:\"\"}},t.public.binders.if={block:!0,priority:4e3,bind:function(t){var e,i;if(null==this.marker)return e=[this.view.prefix,this.type].join(\"-\").replace(\"--\",\"-\"),i=t.getAttribute(e),this.marker=document.createComment(\" rivets: \"+this.type+\" \"+i+\" \"),this.bound=!1,t.removeAttribute(e),t.parentNode.insertBefore(this.marker,t),t.parentNode.removeChild(t)},unbind:function(){if(this.nested)return this.nested.unbind(),this.bound=!1},routine:function(e,i){var n,s,r,o;if(!!i==!this.bound){if(i){for(n in r={},o=this.view.models)s=o[n],r[n]=s;return(this.nested||(this.nested=new t.View(e,r,this.view.options()))).bind(),this.marker.parentNode.insertBefore(e,this.marker.nextSibling),this.bound=!0}return e.parentNode.removeChild(e),this.nested.unbind(),this.bound=!1}},update:function(t){var e;return null!=(e=this.nested)?e.update(t):void 0}},t.public.binders.unless={block:!0,priority:4e3,bind:function(e){return t.public.binders.if.bind.call(this,e)},unbind:function(){return t.public.binders.if.unbind.call(this)},routine:function(e,i){return t.public.binders.if.routine.call(this,e,!i)},update:function(e){return t.public.binders.if.update.call(this,e)}},t.public.binders[\"on-*\"]={function:!0,priority:1e3,unbind:function(e){if(this.handler)return t.Util.unbindEvent(e,this.args[0],this.handler)},routine:function(e,i){return this.handler&&t.Util.unbindEvent(e,this.args[0],this.handler),t.Util.bindEvent(e,this.args[0],this.handler=this.eventHandler(i))}},t.public.binders[\"each-*\"]={block:!0,priority:4e3,bind:function(t){var e,i,n,s;if(null==this.marker)e=[this.view.prefix,this.type].join(\"-\").replace(\"--\",\"-\"),this.marker=document.createComment(\" rivets: \"+this.type+\" \"),this.iterated=[],t.removeAttribute(e),t.parentNode.insertBefore(this.marker,t),t.parentNode.removeChild(t);else for(i=0,n=(s=this.iterated).length;i<n;i++)s[i].bind()},unbind:function(t){var e,i,n;if(null!=this.iterated)for(e=0,i=(n=this.iterated).length;e<i;e++)n[e].unbind()},routine:function(e,i){var n,s,r,o,l,u,h,a,p,d,c,f,b,v,m,y,g,w,k;if(u=this.args[0],i=i||[],this.iterated.length>i.length)for(c=0,v=(g=Array(this.iterated.length-i.length)).length;c<v;c++)g[c],(d=this.iterated.pop()).unbind(),this.marker.parentNode.removeChild(d.els[0]);for(r=f=0,m=i.length;f<m;r=++f)if(l=i[r],(s={index:r})[t.public.iterationAlias(u)]=r,s[u]=l,null==this.iterated[r]){for(o in w=this.view.models)l=w[o],null==s[o]&&(s[o]=l);a=this.iterated.length?this.iterated[this.iterated.length-1].els[0]:this.marker,(h=this.view.options()).preloadData=!0,p=e.cloneNode(!0),(d=new t.View(p,s,h)).bind(),this.iterated.push(d),this.marker.parentNode.insertBefore(p,a.nextSibling)}else this.iterated[r].models[u]!==l&&this.iterated[r].update(s);if(\"OPTION\"===e.nodeName)for(b=0,y=(k=this.view.bindings).length;b<y;b++)(n=k[b]).el===this.marker.parentNode&&\"value\"===n.type&&n.sync()},update:function(t){var e,i,n,s,r,o;for(i in e={},t)n=t[i],i!==this.args[0]&&(e[i]=n);for(s=0,r=(o=this.iterated).length;s<r;s++)o[s].update(e)}},t.public.binders[\"class-*\"]=function(t,e){var i;if(!e==(-1!==(i=\" \"+t.className+\" \").indexOf(\" \"+this.args[0]+\" \")))return t.className=e?t.className+\" \"+this.args[0]:i.replace(\" \"+this.args[0]+\" \",\" \").trim()},t.public.binders[\"*\"]=function(t,e){return null!=e?t.setAttribute(this.type,e):t.removeAttribute(this.type)},t.public.formatters.call=function(){var t,e;return e=arguments[0],t=2<=arguments.length?o.call(arguments,1):[],e.call.apply(e,[this].concat(o.call(t)))},t.public.adapters[\".\"]={id:\"_rv\",counter:0,weakmap:{},weakReference:function(t){var e,i,n;return t.hasOwnProperty(this.id)||(e=this.counter++,Object.defineProperty(t,this.id,{value:e})),(i=this.weakmap)[n=t[this.id]]||(i[n]={callbacks:{}})},cleanupWeakReference:function(t,e){if(!(Object.keys(t.callbacks).length||t.pointers&&Object.keys(t.pointers).length))return delete this.weakmap[e]},stubFunction:function(t,e){var i,n,s;return n=t[e],i=this.weakReference(t),s=this.weakmap,t[e]=function(){var e,r,o,l,u,h,a,p,d;for(r in o=n.apply(t,arguments),h=i.pointers)for(e=h[r],l=0,u=(d=null!=(a=null!=(p=s[r])?p.callbacks[e]:void 0)?a:[]).length;l<u;l++)(0,d[l])();return o}},observeMutations:function(t,e,i){var n,s,r,o,l,u;if(Array.isArray(t)){if(null==(r=this.weakReference(t)).pointers)for(r.pointers={},l=0,u=(s=[\"push\",\"pop\",\"shift\",\"unshift\",\"sort\",\"reverse\",\"splice\"]).length;l<u;l++)n=s[l],this.stubFunction(t,n);if(null==(o=r.pointers)[e]&&(o[e]=[]),h.call(r.pointers[e],i)<0)return r.pointers[e].push(i)}},unobserveMutations:function(t,e,i){var n,s,r;if(Array.isArray(t)&&null!=t[this.id]&&(s=this.weakmap[t[this.id]])&&(r=s.pointers[e]))return(n=r.indexOf(i))>=0&&r.splice(n,1),r.length||delete s.pointers[e],this.cleanupWeakReference(s,t[this.id])},observe:function(t,e,i){var n,s,r,o;return null==(n=this.weakReference(t).callbacks)[e]&&(n[e]=[],(null!=(s=Object.getOwnPropertyDescriptor(t,e))?s.get:void 0)||(null!=s?s.set:void 0)||(r=t[e],Object.defineProperty(t,e,{enumerable:!0,get:function(){return r},set:(o=this,function(i){var s,l,u,a,p;if(i!==r&&(o.unobserveMutations(r,t[o.id],e),r=i,l=o.weakmap[t[o.id]])){if((n=l.callbacks)[e])for(u=0,a=(p=n[e].slice()).length;u<a;u++)s=p[u],h.call(n[e],s)>=0&&s();return o.observeMutations(i,t[o.id],e)}})}))),h.call(n[e],i)<0&&n[e].push(i),this.observeMutations(t[e],t[this.id],e)},unobserve:function(t,e,i){var n,s,r;if((r=this.weakmap[t[this.id]])&&(n=r.callbacks[e]))return(s=n.indexOf(i))>=0&&(n.splice(s,1),n.length||(delete r.callbacks[e],this.unobserveMutations(t[e],t[this.id],e))),this.cleanupWeakReference(r,t[this.id])},get:function(t,e){return t[e]},set:function(t,e,i){return t[e]=i}},t.factory=function(e){return t.sightglass=e,t.public._=t,t.public},\"object\"==typeof(\"undefined\"!=typeof module&&null!==module?module.exports:void 0)?module.exports=t.factory(require(\"sightglass\")):\"function\"==typeof define&&define.amd?define([\"sightglass\"],function(e){return this.rivets=t.factory(e)}):this.rivets=t.factory(sightglass)}).call(this);\n\n//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["rivets.js"],"names":["Rivets","bindMethod","jQuery","unbindMethod","_ref","__bind","fn","me","apply","arguments","__slice","slice","__hasProp","hasOwnProperty","__extends","child","parent","key","call","ctor","this","constructor","prototype","__super__","__indexOf","indexOf","item","i","l","length","options","extensions","public","binders","components","formatters","adapters","prefix","templateDelimiters","rootInterface","preloadData","executeFunctions","iterationAlias","modelName","handler","context","ev","binding","view","models","configure","descriptor","option","value","bind","el","View","init","component","data","scope","template","document","createElement","HTMLElement","firstChild","removeChild","appendChild","innerHTML","initialize","window","Util","bindEvent","event","unbindEvent","getInputValue","$el","attr","is","val","addEventListener","attachEvent","removeEventListener","detachEvent","o","_i","_len","_results","type","checked","selected","push","TypeParser","types","primitive","keypath","parse","string","test","isNaN","Number","TextTemplateParser","text","delimiters","index","lastIndex","lastToken","substring","tokens","trim","els","k","v","_base","_j","_len1","_ref1","_ref2","_ref3","_ref4","_ref5","update","publish","sync","unbind","select","traverse","build","buildBinding","bindingRegExp","jquery","Array","concat","RegExp","node","declaration","ctx","dependencies","pipe","pipes","match","shift","split","bindings","_this","block","childNode","n","parser","token","nodeType","createTextNode","parentNode","insertBefore","_k","childNodes","sort","a","b","binder","priority","attribute","attributes","identifier","nodeName","name","replace","toLowerCase","_bound","ComponentBinding","publishes","model","Binding","getValue","set","eventHandler","formattedValue","parseFormatterArguments","parseTarget","observe","setBinder","formatterObservers","args","exec","Function","routine","obj","callback","sightglass","root","observer","target","formatterIndex","ai","arg","processedArgs","fi","formatter","id","read","dependency","unobserve","fiReversed","lastformatterIndex","reverse","setValue","_super","propertyName","locals","observers","upstreamObservers","camelCase","result","grouped","toUpperCase","_ref6","_ref7","bound","componentView","TextBinding","textContent","innerText","html","show","style","display","hide","enabled","disabled","toString","unchecked","tagName","setAttribute","marker","join","getAttribute","createComment","removeAttribute","nested","nextSibling","unless","function","iterated","collection","previous","_len2","pop","cloneNode","elClass","className","counter","weakmap","weakReference","_name","Object","defineProperty","callbacks","cleanupWeakReference","ref","keys","pointers","stubFunction","map","original","r","response","observeMutations","functions","isArray","unobserveMutations","idx","splice","desc","getOwnPropertyDescriptor","get","enumerable","newValue","cb","factory","_","module","exports","require","define","amd","rivets"],"mappings":"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","file":"E:\\workspace\\pantomath-chatbot\\node_modules\\rivets\\dist\\rivets.js"}","(function(){function t(t,s,i,h){return new e(t,s,i,h)}function e(t,e,i,h){this.options=h||{},this.options.adapters=this.options.adapters||{},this.obj=t,this.keypath=e,this.callback=i,this.objectPath=[],this.update=this.update.bind(this),this.parse(),s(this.target=this.realize())&&this.set(!0,this.key,this.target,this.callback)}function s(t){return\"object\"==typeof t&&null!==t}function i(t){throw new Error(\"[sightglass] \"+t)}t.adapters={},e.tokenize=function(t,e,s){var i,h,a=[],o={i:s,path:\"\"};for(i=0;i<t.length;i++)h=t.charAt(i),~e.indexOf(h)?(a.push(o),o={i:h,path:\"\"}):o.path+=h;return a.push(o),a},e.prototype.parse=function(){var s,h,a=this.interfaces();a.length||i(\"Must define at least one adapter interface.\"),~a.indexOf(this.keypath[0])?(s=this.keypath[0],h=this.keypath.substr(1)):(void 0===(s=this.options.root||t.root)&&i(\"Must define a default root adapter.\"),h=this.keypath),this.tokens=e.tokenize(h,a,s),this.key=this.tokens.pop()},e.prototype.realize=function(){var t,e=this.obj,i=!1;return this.tokens.forEach(function(h,a){s(e)?(void 0!==this.objectPath[a]?e!==(t=this.objectPath[a])&&(this.set(!1,h,t,this.update),this.set(!0,h,e,this.update),this.objectPath[a]=e):(this.set(!0,h,e,this.update),this.objectPath[a]=e),e=this.get(h,e)):(!1===i&&(i=a),(t=this.objectPath[a])&&this.set(!1,h,t,this.update))},this),!1!==i&&this.objectPath.splice(i),e},e.prototype.update=function(){var t,e;(t=this.realize())!==this.target&&(s(this.target)&&this.set(!1,this.key,this.target,this.callback),s(t)&&this.set(!0,this.key,t,this.callback),e=this.value(),this.target=t,(this.value()instanceof Function||this.value()!==e)&&this.callback())},e.prototype.value=function(){if(s(this.target))return this.get(this.key,this.target)},e.prototype.setValue=function(t){s(this.target)&&this.adapter(this.key).set(this.target,this.key.path,t)},e.prototype.get=function(t,e){return this.adapter(t).get(e,t.path)},e.prototype.set=function(t,e,s,i){var h=t?\"observe\":\"unobserve\";this.adapter(e)[h](s,e.path,i)},e.prototype.interfaces=function(){var e=Object.keys(this.options.adapters);return Object.keys(t.adapters).forEach(function(t){~e.indexOf(t)||e.push(t)}),e},e.prototype.adapter=function(e){return this.options.adapters[e.i]||t.adapters[e.i]},e.prototype.unobserve=function(){var t;this.tokens.forEach(function(e,s){(t=this.objectPath[s])&&this.set(!1,e,t,this.update)},this),s(this.target)&&this.set(!1,this.key,this.target,this.callback)},\"undefined\"!=typeof module&&module.exports?module.exports=t:\"function\"==typeof define&&define.amd?define([],function(){return this.sightglass=t}):this.sightglass=t}).call(this);\n\n//# sourceMappingURL=data:application/json;base64,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","function Agent(){this._defaults=[]}[\"use\",\"on\",\"once\",\"set\",\"query\",\"type\",\"accept\",\"auth\",\"withCredentials\",\"sortQuery\",\"retry\",\"ok\",\"redirects\",\"timeout\",\"buffer\",\"serialize\",\"parse\",\"ca\",\"key\",\"pfx\",\"cert\"].forEach(t=>{Agent.prototype[t]=function(...e){return this._defaults.push({fn:t,args:e}),this}}),Agent.prototype._setDefaults=function(t){this._defaults.forEach(e=>{t[e.fn].apply(t,e.args)})},module.exports=Agent;\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFnZW50LWJhc2UuanMiXSwibmFtZXMiOlsiQWdlbnQiLCJ0aGlzIiwiX2RlZmF1bHRzIiwiZm9yRWFjaCIsImZuIiwicHJvdG90eXBlIiwiYXJncyIsInB1c2giLCJfc2V0RGVmYXVsdHMiLCJyZXEiLCJkZWYiLCJhcHBseSIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFFBQ1BDLEtBQUtDLFVBQVksR0FHbkIsQ0FBQyxNQUFPLEtBQU0sT0FBUSxNQUFPLFFBQVMsT0FBUSxTQUFVLE9BQVEsa0JBQW1CLFlBQWEsUUFBUyxLQUFNLFlBQzlHLFVBQVcsU0FBVSxZQUFhLFFBQVMsS0FBTSxNQUFPLE1BQU8sUUFBUUMsUUFBUUMsSUFFOUVKLE1BQU1LLFVBQVVELEdBQU0sWUFBWUUsR0FFaEMsT0FEQUwsS0FBS0MsVUFBVUssS0FBSyxDQUFDSCxHQUFBQSxFQUFJRSxLQUFBQSxJQUNsQkwsUUFJWEQsTUFBTUssVUFBVUcsYUFBZSxTQUFTQyxHQUNwQ1IsS0FBS0MsVUFBVUMsUUFBUU8sSUFDckJELEVBQUlDLEVBQUlOLElBQUlPLE1BQU1GLEVBQUtDLEVBQUlKLFNBSWpDTSxPQUFPQyxRQUFVYiIsImZpbGUiOiJFOlxcV29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxzdXBlcmFnZW50XFxsaWJcXGFnZW50LWJhc2UuanMifQ==","let root;\"undefined\"!=typeof window?root=window:\"undefined\"!=typeof self?root=self:(console.warn(\"Using browser-only version of superagent in non-browser environment\"),root=this);const Emitter=require(\"component-emitter\"),RequestBase=require(\"./request-base\"),isObject=require(\"./is-object\"),ResponseBase=require(\"./response-base\"),Agent=require(\"./agent-base\");function noop(){}const request=exports=module.exports=function(e,t){return\"function\"==typeof t?new exports.Request(\"GET\",e).end(t):1==arguments.length?new exports.Request(\"GET\",e):new exports.Request(e,t)};exports.Request=Request,request.getXHR=(()=>{if(!(!root.XMLHttpRequest||root.location&&\"file:\"==root.location.protocol&&root.ActiveXObject))return new XMLHttpRequest;try{return new ActiveXObject(\"Microsoft.XMLHTTP\")}catch(e){}try{return new ActiveXObject(\"Msxml2.XMLHTTP.6.0\")}catch(e){}try{return new ActiveXObject(\"Msxml2.XMLHTTP.3.0\")}catch(e){}try{return new ActiveXObject(\"Msxml2.XMLHTTP\")}catch(e){}throw Error(\"Browser-only version of superagent could not find XHR\")});const trim=\"\".trim?e=>e.trim():e=>e.replace(/(^\\s*|\\s*$)/g,\"\");function serialize(e){if(!isObject(e))return e;const t=[];for(const s in e)pushEncodedKeyValuePair(t,s,e[s]);return t.join(\"&\")}function pushEncodedKeyValuePair(e,t,s){if(null!=s)if(Array.isArray(s))s.forEach(s=>{pushEncodedKeyValuePair(e,t,s)});else if(isObject(s))for(const r in s)pushEncodedKeyValuePair(e,`${t}[${r}]`,s[r]);else e.push(encodeURIComponent(t)+\"=\"+encodeURIComponent(s));else null===s&&e.push(encodeURIComponent(t))}function parseString(e){const t={},s=e.split(\"&\");let r,o;for(let e=0,n=s.length;e<n;++e)-1==(o=(r=s[e]).indexOf(\"=\"))?t[decodeURIComponent(r)]=\"\":t[decodeURIComponent(r.slice(0,o))]=decodeURIComponent(r.slice(o+1));return t}function parseHeader(e){const t=e.split(/\\r?\\n/),s={};let r,o,n,i;for(let e=0,u=t.length;e<u;++e)-1!==(r=(o=t[e]).indexOf(\":\"))&&(n=o.slice(0,r).toLowerCase(),i=trim(o.slice(r+1)),s[n]=i);return s}function isJSON(e){return/[\\/+]json($|[^-\\w])/.test(e)}function Response(e){this.req=e,this.xhr=this.req.xhr,this.text=\"HEAD\"!=this.req.method&&(\"\"===this.xhr.responseType||\"text\"===this.xhr.responseType)||void 0===this.xhr.responseType?this.xhr.responseText:null,this.statusText=this.req.xhr.statusText;let t=this.xhr.status;1223===t&&(t=204),this._setStatusProperties(t),this.header=this.headers=parseHeader(this.xhr.getAllResponseHeaders()),this.header[\"content-type\"]=this.xhr.getResponseHeader(\"content-type\"),this._setHeaderProperties(this.header),null===this.text&&e._responseType?this.body=this.xhr.response:this.body=\"HEAD\"!=this.req.method?this._parseBody(this.text?this.text:this.xhr.response):null}function Request(e,t){const s=this;this._query=this._query||[],this.method=e,this.url=t,this.header={},this._header={},this.on(\"end\",()=>{let e,t=null,r=null;try{r=new Response(s)}catch(e){return(t=new Error(\"Parser is unable to parse the response\")).parse=!0,t.original=e,s.xhr?(t.rawResponse=void 0===s.xhr.responseType?s.xhr.responseText:s.xhr.response,t.status=s.xhr.status?s.xhr.status:null,t.statusCode=t.status):(t.rawResponse=null,t.status=null),s.callback(t)}s.emit(\"response\",r);try{s._isResponseOK(r)||(e=new Error(r.statusText||\"Unsuccessful HTTP response\"))}catch(t){e=t}e?(e.original=t,e.response=r,e.status=r.status,s.callback(e,r)):s.callback(null,r)})}function del(e,t,s){const r=request(\"DELETE\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}request.serializeObject=serialize,request.parseString=parseString,request.types={html:\"text/html\",json:\"application/json\",xml:\"text/xml\",urlencoded:\"application/x-www-form-urlencoded\",form:\"application/x-www-form-urlencoded\",\"form-data\":\"application/x-www-form-urlencoded\"},request.serialize={\"application/x-www-form-urlencoded\":serialize,\"application/json\":JSON.stringify},request.parse={\"application/x-www-form-urlencoded\":parseString,\"application/json\":JSON.parse},ResponseBase(Response.prototype),Response.prototype._parseBody=function(e){let t=request.parse[this.type];return this.req._parser?this.req._parser(this,e):(!t&&isJSON(this.type)&&(t=request.parse[\"application/json\"]),t&&e&&(e.length||e instanceof Object)?t(e):null)},Response.prototype.toError=function(){const e=this.req,t=e.method,s=e.url,r=`cannot ${t} ${s} (${this.status})`,o=new Error(r);return o.status=this.status,o.method=t,o.url=s,o},request.Response=Response,Emitter(Request.prototype),RequestBase(Request.prototype),Request.prototype.type=function(e){return this.set(\"Content-Type\",request.types[e]||e),this},Request.prototype.accept=function(e){return this.set(\"Accept\",request.types[e]||e),this},Request.prototype.auth=function(e,t,s){1===arguments.length&&(t=\"\"),\"object\"==typeof t&&null!==t&&(s=t,t=\"\"),s||(s={type:\"function\"==typeof btoa?\"basic\":\"auto\"});return this._auth(e,t,s,e=>{if(\"function\"==typeof btoa)return btoa(e);throw new Error(\"Cannot use basic auth, btoa is not a function\")})},Request.prototype.query=function(e){return\"string\"!=typeof e&&(e=serialize(e)),e&&this._query.push(e),this},Request.prototype.attach=function(e,t,s){if(t){if(this._data)throw Error(\"superagent can't mix .send() and .attach()\");this._getFormData().append(e,t,s||t.name)}return this},Request.prototype._getFormData=function(){return this._formData||(this._formData=new root.FormData),this._formData},Request.prototype.callback=function(e,t){if(this._shouldRetry(e,t))return this._retry();const s=this._callback;this.clearTimeout(),e&&(this._maxRetries&&(e.retries=this._retries-1),this.emit(\"error\",e)),s(e,t)},Request.prototype.crossDomainError=function(){const e=new Error(\"Request has been terminated\\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.\");e.crossDomain=!0,e.status=this.status,e.method=this.method,e.url=this.url,this.callback(e)},Request.prototype.buffer=Request.prototype.ca=Request.prototype.agent=function(){return console.warn(\"This is not supported in browser version of superagent\"),this},Request.prototype.pipe=Request.prototype.write=(()=>{throw Error(\"Streaming is not supported in browser version of superagent\")}),Request.prototype._isHost=function(e){return e&&\"object\"==typeof e&&!Array.isArray(e)&&\"[object Object]\"!==Object.prototype.toString.call(e)},Request.prototype.end=function(e){this._endCalled&&console.warn(\"Warning: .end() was called twice. This is not supported in superagent\"),this._endCalled=!0,this._callback=e||noop,this._finalizeQueryString(),this._end()},Request.prototype._end=function(){if(this._aborted)return this.callback(Error(\"The request has been aborted even before .end() was called\"));const e=this,t=this.xhr=request.getXHR();let s=this._formData||this._data;this._setTimeouts(),t.onreadystatechange=(()=>{const s=t.readyState;if(s>=2&&e._responseTimeoutTimer&&clearTimeout(e._responseTimeoutTimer),4!=s)return;let r;try{r=t.status}catch(e){r=0}if(!r){if(e.timedout||e._aborted)return;return e.crossDomainError()}e.emit(\"end\")});const r=(t,s)=>{s.total>0&&(s.percent=s.loaded/s.total*100),s.direction=t,e.emit(\"progress\",s)};if(this.hasListeners(\"progress\"))try{t.onprogress=r.bind(null,\"download\"),t.upload&&(t.upload.onprogress=r.bind(null,\"upload\"))}catch(e){}try{this.username&&this.password?t.open(this.method,this.url,!0,this.username,this.password):t.open(this.method,this.url,!0)}catch(e){return this.callback(e)}if(this._withCredentials&&(t.withCredentials=!0),!this._formData&&\"GET\"!=this.method&&\"HEAD\"!=this.method&&\"string\"!=typeof s&&!this._isHost(s)){const e=this._header[\"content-type\"];let t=this._serializer||request.serialize[e?e.split(\";\")[0]:\"\"];!t&&isJSON(e)&&(t=request.serialize[\"application/json\"]),t&&(s=t(s))}for(const e in this.header)null!=this.header[e]&&this.header.hasOwnProperty(e)&&t.setRequestHeader(e,this.header[e]);this._responseType&&(t.responseType=this._responseType),this.emit(\"request\",this),t.send(void 0!==s?s:null)},request.agent=(()=>new Agent),[\"GET\",\"POST\",\"OPTIONS\",\"PATCH\",\"PUT\",\"DELETE\"].forEach(e=>{Agent.prototype[e.toLowerCase()]=function(t,s){const r=new request.Request(e,t);return this._setDefaults(r),s&&r.end(s),r}}),Agent.prototype.del=Agent.prototype.delete,request.get=((e,t,s)=>{const r=request(\"GET\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.query(t),s&&r.end(s),r}),request.head=((e,t,s)=>{const r=request(\"HEAD\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.query(t),s&&r.end(s),r}),request.options=((e,t,s)=>{const r=request(\"OPTIONS\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.del=del,request.delete=del,request.patch=((e,t,s)=>{const r=request(\"PATCH\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.post=((e,t,s)=>{const r=request(\"POST\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r}),request.put=((e,t,s)=>{const r=request(\"PUT\",e);return\"function\"==typeof t&&(s=t,t=null),t&&r.send(t),s&&r.end(s),r});\n\n//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["client.js"],"names":["root","window","self","console","warn","this","Emitter","require","RequestBase","isObject","ResponseBase","Agent","noop","request","exports","module","method","url","Request","end","arguments","length","getXHR","XMLHttpRequest","location","protocol","ActiveXObject","e","Error","trim","s","replace","serialize","obj","pairs","key","pushEncodedKeyValuePair","join","val","Array","isArray","forEach","v","subkey","push","encodeURIComponent","parseString","str","split","pair","pos","i","len","indexOf","decodeURIComponent","slice","parseHeader","lines","fields","index","line","field","toLowerCase","isJSON","mime","test","Response","req","xhr","text","responseType","responseText","statusText","status","_setStatusProperties","header","headers","getAllResponseHeaders","getResponseHeader","_setHeaderProperties","_responseType","body","response","_parseBody","_query","_header","on","new_err","err","res","parse","original","rawResponse","statusCode","callback","emit","_isResponseOK","custom_err","del","data","fn","send","serializeObject","types","html","json","xml","urlencoded","form","form-data","application/x-www-form-urlencoded","application/json","JSON","stringify","prototype","type","_parser","Object","toError","msg","set","accept","auth","user","pass","options","btoa","_auth","string","query","attach","file","_data","_getFormData","append","name","_formData","FormData","_shouldRetry","_retry","_callback","clearTimeout","_maxRetries","retries","_retries","crossDomainError","crossDomain","buffer","ca","agent","pipe","write","_isHost","toString","call","_endCalled","_finalizeQueryString","_end","_aborted","_setTimeouts","onreadystatechange","readyState","_responseTimeoutTimer","timedout","handleProgress","direction","total","percent","loaded","hasListeners","onprogress","bind","upload","username","password","open","_withCredentials","withCredentials","contentType","_serializer","hasOwnProperty","setRequestHeader","_setDefaults","get","head","patch","post","put"],"mappings":"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","file":"E:\\workspace\\pantomath-chatbot\\node_modules\\superagent\\lib\\client.js"}","\"use strict\";function isObject(t){return null!==t&&\"object\"==typeof t}module.exports=isObject;\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlzLW9iamVjdC5qcyJdLCJuYW1lcyI6WyJpc09iamVjdCIsIm9iaiIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLGFBVUEsU0FBU0EsU0FBU0MsR0FDaEIsT0FBTyxPQUFTQSxHQUFPLGlCQUFvQkEsRUFHN0NDLE9BQU9DLFFBQVVIIiwiZmlsZSI6IkU6XFxXb3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHN1cGVyYWdlbnRcXGxpYlxcaXMtb2JqZWN0LmpzIn0=","\"use strict\";const isObject=require(\"./is-object\");function RequestBase(t){if(t)return mixin(t)}function mixin(t){for(const e in RequestBase.prototype)t[e]=RequestBase.prototype[e];return t}module.exports=RequestBase,RequestBase.prototype.clearTimeout=function(){return clearTimeout(this._timer),clearTimeout(this._responseTimeoutTimer),delete this._timer,delete this._responseTimeoutTimer,this},RequestBase.prototype.parse=function(t){return this._parser=t,this},RequestBase.prototype.responseType=function(t){return this._responseType=t,this},RequestBase.prototype.serialize=function(t){return this._serializer=t,this},RequestBase.prototype.timeout=function(t){if(!t||\"object\"!=typeof t)return this._timeout=t,this._responseTimeout=0,this;for(const e in t)switch(e){case\"deadline\":this._timeout=t.deadline;break;case\"response\":this._responseTimeout=t.response;break;default:console.warn(\"Unknown timeout option\",e)}return this},RequestBase.prototype.retry=function(t,e){return 0!==arguments.length&&!0!==t||(t=1),t<=0&&(t=0),this._maxRetries=t,this._retries=0,this._retryCallback=e,this};const ERROR_CODES=[\"ECONNRESET\",\"ETIMEDOUT\",\"EADDRINFO\",\"ESOCKETTIMEDOUT\"];RequestBase.prototype._shouldRetry=function(t,e){if(!this._maxRetries||this._retries++>=this._maxRetries)return!1;if(this._retryCallback)try{const s=this._retryCallback(t,e);if(!0===s)return!0;if(!1===s)return!1}catch(t){console.error(t)}if(e&&e.status&&e.status>=500&&501!=e.status)return!0;if(t){if(t.code&&~ERROR_CODES.indexOf(t.code))return!0;if(t.timeout&&\"ECONNABORTED\"==t.code)return!0;if(t.crossDomain)return!0}return!1},RequestBase.prototype._retry=function(){return this.clearTimeout(),this.req&&(this.req=null,this.req=this.request()),this._aborted=!1,this.timedout=!1,this._end()},RequestBase.prototype.then=function(t,e){if(!this._fullfilledPromise){const t=this;this._endCalled&&console.warn(\"Warning: superagent request was sent twice, because both .end() and .then() were called. Never call .end() if you use promises\"),this._fullfilledPromise=new Promise((e,s)=>{t.on(\"error\",s),t.on(\"abort\",()=>{const t=new Error(\"Aborted\");t.code=\"ABORTED\",t.status=this.status,t.method=this.method,t.url=this.url,s(t)}),t.end((t,i)=>{t?s(t):e(i)})})}return this._fullfilledPromise.then(t,e)},RequestBase.prototype.catch=function(t){return this.then(void 0,t)},RequestBase.prototype.use=function(t){return t(this),this},RequestBase.prototype.ok=function(t){if(\"function\"!=typeof t)throw Error(\"Callback required\");return this._okCallback=t,this},RequestBase.prototype._isResponseOK=function(t){return!!t&&(this._okCallback?this._okCallback(t):t.status>=200&&t.status<300)},RequestBase.prototype.get=function(t){return this._header[t.toLowerCase()]},RequestBase.prototype.getHeader=RequestBase.prototype.get,RequestBase.prototype.set=function(t,e){if(isObject(t)){for(const e in t)this.set(e,t[e]);return this}return this._header[t.toLowerCase()]=e,this.header[t]=e,this},RequestBase.prototype.unset=function(t){return delete this._header[t.toLowerCase()],delete this.header[t],this},RequestBase.prototype.field=function(t,e){if(null==t)throw new Error(\".field(name, val) name can not be empty\");if(this._data)throw new Error(\".field() can't be used if .send() is used. Please use only .send() or only .field() & .attach()\");if(isObject(t)){for(const e in t)this.field(e,t[e]);return this}if(Array.isArray(e)){for(const s in e)this.field(t,e[s]);return this}if(null==e)throw new Error(\".field(name, val) val can not be empty\");return\"boolean\"==typeof e&&(e=\"\"+e),this._getFormData().append(t,e),this},RequestBase.prototype.abort=function(){return this._aborted?this:(this._aborted=!0,this.xhr&&this.xhr.abort(),this.req&&this.req.abort(),this.clearTimeout(),this.emit(\"abort\"),this)},RequestBase.prototype._auth=function(t,e,s,i){switch(s.type){case\"basic\":this.set(\"Authorization\",`Basic ${i(`${t}:${e}`)}`);break;case\"auto\":this.username=t,this.password=e;break;case\"bearer\":this.set(\"Authorization\",`Bearer ${t}`)}return this},RequestBase.prototype.withCredentials=function(t){return null==t&&(t=!0),this._withCredentials=t,this},RequestBase.prototype.redirects=function(t){return this._maxRedirects=t,this},RequestBase.prototype.maxResponseSize=function(t){if(\"number\"!=typeof t)throw TypeError(\"Invalid argument\");return this._maxResponseSize=t,this},RequestBase.prototype.toJSON=function(){return{method:this.method,url:this.url,data:this._data,headers:this._header}},RequestBase.prototype.send=function(t){const e=isObject(t);let s=this._header[\"content-type\"];if(this._formData)throw new Error(\".send() can't be used if .attach() or .field() is used. Please use only .send() or only .field() & .attach()\");if(e&&!this._data)Array.isArray(t)?this._data=[]:this._isHost(t)||(this._data={});else if(t&&this._data&&this._isHost(this._data))throw Error(\"Can't merge these send calls\");if(e&&isObject(this._data))for(const e in t)this._data[e]=t[e];else\"string\"==typeof t?(s||this.type(\"form\"),s=this._header[\"content-type\"],this._data=\"application/x-www-form-urlencoded\"==s?this._data?`${this._data}&${t}`:t:(this._data||\"\")+t):this._data=t;return!e||this._isHost(t)?this:(s||this.type(\"json\"),this)},RequestBase.prototype.sortQuery=function(t){return this._sort=void 0===t||t,this},RequestBase.prototype._finalizeQueryString=function(){const t=this._query.join(\"&\");if(t&&(this.url+=(this.url.indexOf(\"?\")>=0?\"&\":\"?\")+t),this._query.length=0,this._sort){const t=this.url.indexOf(\"?\");if(t>=0){const e=this.url.substring(t+1).split(\"&\");\"function\"==typeof this._sort?e.sort(this._sort):e.sort(),this.url=this.url.substring(0,t)+\"?\"+e.join(\"&\")}}},RequestBase.prototype._appendQueryString=(()=>{console.trace(\"Unsupported\")}),RequestBase.prototype._timeoutError=function(t,e,s){if(this._aborted)return;const i=new Error(`${t+e}ms exceeded`);i.timeout=e,i.code=\"ECONNABORTED\",i.errno=s,this.timedout=!0,this.abort(),this.callback(i)},RequestBase.prototype._setTimeouts=function(){const t=this;this._timeout&&!this._timer&&(this._timer=setTimeout(()=>{t._timeoutError(\"Timeout of \",t._timeout,\"ETIME\")},this._timeout)),this._responseTimeout&&!this._responseTimeoutTimer&&(this._responseTimeoutTimer=setTimeout(()=>{t._timeoutError(\"Response timeout of \",t._responseTimeout,\"ETIMEDOUT\")},this._responseTimeout))};\n\n//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["request-base.js"],"names":["isObject","require","RequestBase","obj","mixin","key","prototype","module","exports","clearTimeout","this","_timer","_responseTimeoutTimer","parse","fn","_parser","responseType","val","_responseType","serialize","_serializer","timeout","options","_timeout","_responseTimeout","option","deadline","response","console","warn","retry","count","arguments","length","_maxRetries","_retries","_retryCallback","ERROR_CODES","_shouldRetry","err","res","override","e","error","status","code","indexOf","crossDomain","_retry","req","request","_aborted","timedout","_end","then","resolve","reject","_fullfilledPromise","self","_endCalled","Promise","innerResolve","innerReject","on","Error","method","url","end","cb","undefined","use","ok","_okCallback","_isResponseOK","get","field","_header","toLowerCase","getHeader","set","header","unset","name","_data","Array","isArray","i","_getFormData","append","abort","xhr","emit","_auth","user","pass","base64Encoder","type","username","password","withCredentials","_withCredentials","redirects","n","_maxRedirects","maxResponseSize","TypeError","_maxResponseSize","toJSON","data","headers","send","isObj","_formData","_isHost","sortQuery","sort","_sort","_finalizeQueryString","query","_query","join","index","queryArr","substring","split","_appendQueryString","trace","_timeoutError","reason","errno","callback","_setTimeouts","setTimeout"],"mappings":"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","file":"E:\\Workspace\\wikia-is-answered\\node_modules\\superagent\\lib\\request-base.js"}","\"use strict\";const utils=require(\"./utils\");function ResponseBase(t){if(t)return mixin(t)}function mixin(t){for(const s in ResponseBase.prototype)t[s]=ResponseBase.prototype[s];return t}module.exports=ResponseBase,ResponseBase.prototype.get=function(t){return this.header[t.toLowerCase()]},ResponseBase.prototype._setHeaderProperties=function(t){const s=t[\"content-type\"]||\"\";this.type=utils.type(s);const e=utils.params(s);for(const t in e)this[t]=e[t];this.links={};try{t.link&&(this.links=utils.parseLinks(t.link))}catch(t){}},ResponseBase.prototype._setStatusProperties=function(t){const s=t/100|0;this.status=this.statusCode=t,this.statusType=s,this.info=1==s,this.ok=2==s,this.redirect=3==s,this.clientError=4==s,this.serverError=5==s,this.error=(4==s||5==s)&&this.toError(),this.created=201==t,this.accepted=202==t,this.noContent=204==t,this.badRequest=400==t,this.unauthorized=401==t,this.notAcceptable=406==t,this.forbidden=403==t,this.notFound=404==t,this.unprocessableEntity=422==t};\n\n//# sourceMappingURL=data:application/json;base64,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","\"use strict\";exports.type=(e=>e.split(/ *; */).shift()),exports.params=(e=>e.split(/ *; */).reduce((e,t)=>{const s=t.split(/ *= */),i=s.shift(),r=s.shift();return i&&r&&(e[i]=r),e},{})),exports.parseLinks=(e=>e.split(/ *, */).reduce((e,t)=>{const s=t.split(/ *; */),i=s[0].slice(1,-1);return e[s[1].split(/ *= */)[1].slice(1,-1)]=i,e},{})),exports.cleanHeader=((e,t)=>(delete e[\"content-type\"],delete e[\"content-length\"],delete e[\"transfer-encoding\"],delete e.host,t&&(delete e.authorization,delete e.cookie),e));\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInV0aWxzLmpzIl0sIm5hbWVzIjpbImV4cG9ydHMiLCJ0eXBlIiwic3RyIiwic3BsaXQiLCJzaGlmdCIsInBhcmFtcyIsInJlZHVjZSIsIm9iaiIsInBhcnRzIiwia2V5IiwidmFsIiwicGFyc2VMaW5rcyIsInVybCIsInNsaWNlIiwiY2xlYW5IZWFkZXIiLCJoZWFkZXIiLCJjaGFuZ2VzT3JpZ2luIl0sIm1hcHBpbmdzIjoiQUFBQSxhQVVBQSxRQUFRQyxLQUFPQyxDQUFBQSxHQUFPQSxFQUFJQyxNQUFNLFNBQVNDLFNBVXpDSixRQUFRSyxPQUFTSCxDQUFBQSxHQUFPQSxFQUFJQyxNQUFNLFNBQVNHLE9BQU8sQ0FBQ0MsRUFBS0wsS0FDdEQsTUFBTU0sRUFBUU4sRUFBSUMsTUFBTSxTQUNsQk0sRUFBTUQsRUFBTUosUUFDWk0sRUFBTUYsRUFBTUosUUFHbEIsT0FESUssR0FBT0MsSUFBS0gsRUFBSUUsR0FBT0MsR0FDcEJILEdBQ04sS0FVSFAsUUFBUVcsV0FBYVQsQ0FBQUEsR0FBT0EsRUFBSUMsTUFBTSxTQUFTRyxPQUFPLENBQUNDLEVBQUtMLEtBQzFELE1BQU1NLEVBQVFOLEVBQUlDLE1BQU0sU0FDbEJTLEVBQU1KLEVBQU0sR0FBR0ssTUFBTSxHQUFJLEdBRy9CLE9BREFOLEVBRFlDLEVBQU0sR0FBR0wsTUFBTSxTQUFTLEdBQUdVLE1BQU0sR0FBSSxJQUN0Q0QsRUFDSkwsR0FDTixLQVVIUCxRQUFRYyxZQUFjLEVBQUNDLEVBQVFDLFlBQ3RCRCxFQUFPLHVCQUNQQSxFQUFPLHlCQUNQQSxFQUFPLDRCQUNQQSxFQUFhLEtBRWhCQyxXQUNLRCxFQUFzQixxQkFDdEJBLEVBQWUsUUFFakJBIiwiZmlsZSI6IkU6XFxXb3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHN1cGVyYWdlbnRcXGxpYlxcdXRpbHMuanMifQ==","var toString=Object.prototype.toString;module.exports=function(e){switch(toString.call(e)){case\"[object Function]\":return\"function\";case\"[object Date]\":return\"date\";case\"[object RegExp]\":return\"regexp\";case\"[object Arguments]\":return\"arguments\";case\"[object Array]\":return\"array\";case\"[object String]\":return\"string\"}if(\"object\"==typeof e&&e&&\"number\"==typeof e.length)try{if(\"function\"==typeof e.callee)return\"arguments\"}catch(e){if(e instanceof TypeError)return\"arguments\"}return null===e?\"null\":void 0===e?\"undefined\":e&&1===e.nodeType?\"element\":e===Object(e)?\"object\":typeof e};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbInRvU3RyaW5nIiwiT2JqZWN0IiwicHJvdG90eXBlIiwibW9kdWxlIiwiZXhwb3J0cyIsInZhbCIsImNhbGwiLCJsZW5ndGgiLCJjYWxsZWUiLCJleCIsIlR5cGVFcnJvciIsInVuZGVmaW5lZCIsIm5vZGVUeXBlIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxTQUFXQyxPQUFPQyxVQUFVRixTQUVoQ0csT0FBT0MsUUFBVSxTQUFTQyxHQUN4QixPQUFRTCxTQUFTTSxLQUFLRCxJQUNwQixJQUFLLG9CQUFxQixNQUFPLFdBQ2pDLElBQUssZ0JBQWlCLE1BQU8sT0FDN0IsSUFBSyxrQkFBbUIsTUFBTyxTQUMvQixJQUFLLHFCQUFzQixNQUFPLFlBQ2xDLElBQUssaUJBQWtCLE1BQU8sUUFDOUIsSUFBSyxrQkFBbUIsTUFBTyxTQUdqQyxHQUFrQixpQkFBUEEsR0FBbUJBLEdBQTRCLGlCQUFkQSxFQUFJRSxPQUM5QyxJQUNFLEdBQXlCLG1CQUFkRixFQUFJRyxPQUFzQixNQUFPLFlBQzVDLE1BQU9DLEdBQ1AsR0FBSUEsYUFBY0MsVUFDaEIsTUFBTyxZQUtiLE9BQVksT0FBUkwsRUFBcUIsWUFDYk0sSUFBUk4sRUFBMEIsWUFDMUJBLEdBQXdCLElBQWpCQSxFQUFJTyxTQUF1QixVQUNsQ1AsSUFBUUosT0FBT0ksR0FBYSxnQkFFbEJBIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHBhbnRvbWF0aC1jaGF0Ym90XFxub2RlX21vZHVsZXNcXHR5cGUtb2ZcXGluZGV4LmpzIn0=","module.exports={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,menuitem:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJhcmVhIiwiYmFzZSIsImJyIiwiY29sIiwiZW1iZWQiLCJociIsImltZyIsImlucHV0Iiwia2V5Z2VuIiwibGluayIsIm1lbnVpdGVtIiwibWV0YSIsInBhcmFtIiwic291cmNlIiwidHJhY2siLCJ3YnIiXSwibWFwcGluZ3MiOiJBQUtBQSxPQUFPQyxRQUFVLENBQ2ZDLE1BQVEsRUFDUkMsTUFBUSxFQUNSQyxJQUFNLEVBQ05DLEtBQU8sRUFDUEMsT0FBUyxFQUNUQyxJQUFNLEVBQ05DLEtBQU8sRUFDUEMsT0FBUyxFQUNUQyxRQUFVLEVBQ1ZDLE1BQVEsRUFDUkMsVUFBWSxFQUNaQyxNQUFRLEVBQ1JDLE9BQVMsRUFDVEMsUUFBVSxFQUNWQyxPQUFTLEVBQ1RDLEtBQU8iLCJmaWxlIjoiRTpcXFdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcdm9pZC1lbGVtZW50c1xcaW5kZXguanMifQ==","\"use strict\";const type=require(\"type-of\"),request=require(\"superagent\"),h=require(\"hyperscript-string\"),$=require(\"domtastic\"),rivets=require(\"rivets\");$.fn.clear=function(){return this.forEach(e=>{e.innerHTML=\"\"}),this},$.fn.outerHTML=function(){return this.prop(\"outerHTML\")};const state={message:\"\",knowledge:[],conversation:[],error:!1};function _error(e,t,{response:s}){s=s?[s.status,s.text]:[],console.warn(`[${e} ${t}]`,...s)}function send_message(e=\"\",t){request.post(\"/message\").send(e).then(({body:e})=>{state.conversation.push({text:e})},e=>{_error(\"POST\",\"/message\",e),t&&t()})}function _const(e,t,s){return Object.defineProperty(e,t,{value:s,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),$(\".Conversation-input\").on(\"keydown\",e=>{let t=state.message;if(\"Enter\"==e.code&&!e.shiftKey&&!e.altKey&&!e.ctrlKey){if(\"\"==t)return;return state.message=\"\",state.conversation.push({text:t.split(/\\s*[\\n\\r]+\\s*/g),is_user:!0}),send_message(t,()=>{state.error=!0}),!1}}).on(\"paste\",e=>{e.preventDefault();let t=e.clipboardData.getData(\"text/plain\");return document.execCommand(\"insertHTML\",!1,t),!1});const{Binding:Binding}=rivets._;rivets._.Binding=class extends Binding{parseTarget(){return this.binder.parseTarget&&Object.assign(this,this.binder.parseTarget(this.keypath)),super.parseTarget()}publish(){_const(this,\"state\",\"publish\");super.publish();_const(this,\"state\")}},rivets.binders.input={parseTarget(e){let t;return[e,t]=e.trim().split(/\\s*\\?\\s*/),{keypath:e,empty_class:t}},bind:function(e){this._empty=!0,$(e).on(\"input.rv-input\",this.publish),this._watch=(()=>{e.innerHTML=\"\",\"\"==e.innerHTML&&clearInterval(this._watcher)})},unbind:function(e){$(e).off(\".rv-input\"),clearInterval(this._watcher)},routine:function(e,t){\"publish\"!=this.state&&(clearInterval(this._watcher),e.innerText=t),state.error=!1,this._empty=\"\"==t,this._empty&&(this._watcher=setInterval(this._watch,30)),this.empty_class&&$(e).toggleClass(this.empty_class,this._empty)},getValue:function(e){return e.innerText.trim()}},global.$state=state,rivets.bind(document.body,state);\n\n//# sourceMappingURL=data:application/json;base64,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"]} diff --git a/static/favicon.png b/static/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..d7c92543c078ed68fdc5265185094e31a37935a6 GIT binary patch literal 615 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbKJOS+@4BLl<6e(pbstU$g(vPY0F z14ES>14Ba#1H&(%P{RubhEf9thF1v;3|2E37{m+a>3ZGPv(*?m*yc2AzuJ9+NJ=^&B5sq?xf&FKXT_Dq^9X_2Vxkf!92 zrfi?4?2xWxpJwQttL2uZ>6)qSmaXNIDQ}x;;#Z|$o0(a?!Ze^-!7kI#D;H?pImQot zKuWkI$S;^7OwY%{spI&8V~38kpE$n%=)uDV$5SGJ(u_&o?k)@+tg;?J4rhT!WHAE+ z-w_aIoT|+y4HRTA@$_|Nf6OW_q^is#^ED7CG}F_?F+}2WZvS&Tj}EM8 zDBbe@e-G==?O}XA>rQg_t-Cjh_?)I(-X$CO+^W>6VTx!g57XD6e@z*R^Bb3^>~#8W{A#9i z^4i*^QSYZ&UR4sSl<55?#TH<`?Cr08*}lR5>)#3QVbpldyK%UO_ zQmvAUQh^kMk%6J5u7Rnpk#UHjnU%4*m9eR|fsvJgfjXP`925lTmk1WZti_{>U<5@#6toCL1O-7*ghb&I5rGhb;Z<^rIvpyS zR^AO52k}99>J(a3NEj8S1gDHnMTL?$Dd++raU>cHfw{3(iLFfgZ}wXEp8b7i?{m&Q zd!K!7{`O#hV$}1280Fy zWZ45?M*v>n6!r)podPgI2k0ZhY3qP_NC_Xw$gJ-E2<(AKK9v}e&l$0#^IA>uQ;EGbl0F1PTooK`na>_ zzf8<5$SWvw4`G#7oMCZ!`wx9;wJz2pgykG?kZ~yA+AHov@u}$KBcUkQBb2p1jJ?7? z(ae>WkbPliVp;XMngbcfay}_$$hsaHpN1(+aF~xZcGe zGr>%Bxc&37)Ze+htwth248L{9&|qJ@aH8+dXrJV=lpU?e8vWB{dRuzO?p@3S&jP<& z@nV;-X{{UEx2@$7!&tOW&&CV>HplB~DyaJVEiZ8VNYb$&<9~U;r8%tU9t-c~J7C2f zS!P&fI8tFbUZatuST8h(!|CHZ@8hLJ(Gr5qRVqQHp3Ie(OdfR+Mh?rBUGmZ=J6oqh zxjC%`-*I~dwB@q;h`O03@Ak+}^X?&X@no?NJQQ~|mP{ThmltJP&>UqyxJX8MjeXp) z+5$eVm4^_Dyr4&?7FmE9y(E|)6GFeR{wcC-hrC9TW zQ};3dz>$8o77cls&eKMU;)-z^pQ-)JY0I8oL8nu>Q&bCyW2r>W^LCQe3X~6@i&ZhZ zW-`mYAMxZRshaE=b95TDft%Lw09iEmYtRkEVQJKqGdpIjBdHP8QSz!CFnKkXZZ-Kid&@^dOwIzU` z0X@Cx4&uHXMz5`JUe&(A8bk0MAtD)#Ia4xQkQDJ}+!l!*Y|{?{k!jnS1#eBS1Iyg7 zqm_mPsRHa%Z69kAH5=|#G?PHpFff&CgI!yTz;WH96^O6kS7haZ#IGf7wy>@Hrnj-a z)VDXy?v$an%Fiw5jHI_>glZ~S7xB4^4W)`8@QKxN5uJP)O&v~bBE3#;8=NQok1|(a zkEq%QrWPi_&S|g6!6la#LEuE^A|3m80DF>DMXyZOQ*<2971$x)>`9*Pa)T5N+Vnmt z$`I?UAnDKY#O#b`p;u}KHP?B=)Wd&U8D=(IH~0Ic!Q0FZVpDU!JjN7r7#bGLBe>_7 zLGKbBqo!)z4S&_CsA@@mruHIlft*RbAUikhIwPlc3oZMN&kO{nqDbUgArzr}eg6?81#4Ryrt!W4uw?fS^PyPnRP27EymT+FaG~- z;n!jN{XYrV4Luc^x;R!!sxJ5vAIFZpIg%Z>myLSHvQWGM7s@IRC(0Tp7uT>=Zl11d zJzYHj YWune0ECzqv>t!{jZVvWs*hJ6!FK@%Vi~s-t literal 0 HcmV?d00001 diff --git a/static/index.html b/static/index.html new file mode 100644 index 0000000..768a5af --- /dev/null +++ b/static/index.html @@ -0,0 +1,41 @@ + + + + + + Whizbot + + + + + + + + + + + +
+
+

Whizbot

+
+ +
+
+
+
+ 
{ para }
+
+
+
+
+ Your message here... +
+
+
+
+ + + + + diff --git a/static/master.css b/static/master.css new file mode 100644 index 0000000..4fc7dca --- /dev/null +++ b/static/master.css @@ -0,0 +1,216 @@ +@import url('https://fonts.googleapis.com/css?family=Nunito'); + +:root { + --top: 0; + --left: 0; + font-size: 15px; +} + +html { + padding: 0; + overflow: hidden; +} + +body { + padding: 0; + position: relative; + margin: 0; +} + +body, textarea { + font-family: 'Nunito', sans-serif; +} + +textarea:focus { + outline: none; +} + +button { + cursor: pointer; +} + +.u-checkbox { + background: hsl(0deg, 0%, 68%); + --check: 0; + border-radius: 3px; + width: var(--size); + height: var(--size); + display: inline-block; + vertical-align: -5px; + -webkit-appearance: none; + position: relative; + --size: 16px; + cursor: pointer; + outline: none; + margin-right: 5px; +} + +.u-checkbox:checked { + --check: 0.8; +} + +.u-checkbox:before { + content: ''; + display: block; + position: absolute; + left: 0; + top: 0; + box-sizing: border-box; + width: 100%; + height: 100%; + background: no-repeat center/85% url(https://image.flaticon.com/icons/svg/128/128384.svg); + opacity: var(--check); + transition: 0.3s opacity; +} + +.u-textbox { + word-wrap: break-word; +} + +/*.u-textbox:before {*/ +/* content: attr(placeholder);*/ +.u-placeholder { + color: hsl(0deg, 0%, 67%); + font-style: italic; + opacity: 0; + position: absolute; + top: var(--top); + left: var(--left); + pointer-events: none; + + transition: 0.2s opacity; +} + +.u-textbox.empty * { + display: none; +} + +/*.u-textbox.empty:before {*/ +.u-textbox.empty + .u-placeholder { + opacity: 1; +} + +.error { + background: hsl(0deg, 68%, 87%); +} + +.Root { + height: 100vh; + width: 100vw; + overflow: hidden; +} + +.Root-body { + width: 100%; + height: 100%; + margin: 0; + padding: 0; + display: grid; + grid-template-columns: auto; + grid-template-rows: min-content auto; + background: hsl(0deg, 0%, 80%); +} + +.Header { + width: 100%; + padding: 10px 10px; + box-sizing: border-box; + margin-top: 0; + top: 0; + left: 0; + z-index: 1; + grid-row: 1; + grid-column: 1 / 2; +} + +.Header-title { + font-size: 1.2em; + text-align: left; + margin-bottom: 0; + text-shadow: 2px 2px 2px #0003; + width: min-content; + white-space: nowrap; + color: hsl(0deg, 0%, 15%); + padding: 1px 14px; + border-radius: 6px 6px 0 0; + margin-top: 0; +} + +.Conversation { + grid-row: 2; + grid-column: 1; + display: flex; + flex-direction: column-reverse; + background: hsl(0deg, 0%, 90%); + position: relative; + overflow-x: auto; + overflow-y: auto; + height: 100%; +} + +.Conversation-body { + grid-row: 1; + position: absolute; + bottom: 0; + width: 100%; + min-width: 380px; +} + +.Conversation-history { + padding: 15px; + margin: 0 auto; + display: flex; + flex-direction: column; + list-style: none; + box-sizing: border-box; + max-width: 900px; +} + +.Conversation-message { + border-radius: 13px; + background: hsl(0deg, 0%, 80%); + padding: 10px; + max-width: 80%; + width: max-content; + align-self: flex-end; + margin-bottom: 10px; + box-sizing: border-box; +} + +.Conversation-message.user { + align-self: initial; +} + +.Conversation-para { + font: inherit; + white-space: pre-line; + margin-top: 0; + margin-bottom: 8px; + line-height: 1.37; +} + +.Conversation-para:last-child { + margin-bottom: 0; +} + +.Conversation-textbox { + --top: 10px; + --left: 10px; + padding: var(--top) var(--left); + box-sizing: border-box; + position: sticky; + bottom: 0; + width: 100%; + background: hsla(0deg, 0%, 90%, 90%); + transition: 0.4s background-color; +} + +.Conversation-input { + border: none; + padding: 0; + bottom: 0; + background: none; + width: 100%; + min-height: 150px; + outline: none; +} diff --git a/util/__init__.py b/util/__init__.py new file mode 100644 index 0000000..9b03d4c --- /dev/null +++ b/util/__init__.py @@ -0,0 +1,251 @@ +import os, re +from platform import python_version_tuple as get_pyversion +from statistics import mean as _mean, StatisticsError +from time import time_ns +from datetime import timedelta +from concurrent.futures import ThreadPoolExecutor as _Executor +from html.parser import HTMLParser as _HTMLParser + +from munch import munchify + + +pyversion = tuple(int(e) for e in get_pyversion()) +if pyversion >= (3, 6, 0): + OrderedDict = dict +else: + from collections import OrderedDict + +__dir__ = os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + '/..') + +def realpath(path): + return os.path.join(__dir__, path) + +def new(cls, *args, **kw): + if not isinstance(cls, type): + cls = type(cls) + return cls(*args, **kw) + +def attach(target): + def deco(func): + setattr(target, func.__name__, func) + return func + return deco + +def mixin(target): + exclude = { '__module__', '__dict__', '__weakref__', '__doc__', '__new__' } + def deco(cls): + for name, attr in cls.__dict__.items(): + if name in exclude: + continue + setattr(target, name, attr) + return cls + return deco + +class Object: + def __new__(cls, **kw): + return munchify(kw) + +class Map: + def __new__(cls, data=None, key=None): + if isinstance(key, property): + key = property.fget + if data is None: + return + if key: + return dict((key(e), e) for e in data) + return dict(data) + +class String: + def encode(self, *args, **kw): + if str(self): + return str(self).encode(*args, **kw) + + def __str__(self): + pass + +class List: + def __new__(cls, self): + if self is None: + return [] + if hasattr(self, '__len__'): + return self + return list(self) + +class Data: + def __init__(self, data=None): + self._data = List(data) + + def __getitem__(self, index): + return self._data[index] if self else None + + def __len__(self): + return len(self._data) + + def __bool__(self): + return bool(self._data) + + def __iter__(self): + yield from self._data + + def _append(self, item): + return self._data.append(item) + +class TimeDelta: # Immutable data class + def __init__(self, days=0, secs=0, nanos=0, micros=0, millis=0, mins=0, *args, **kw): + self._time = timedelta(days, secs + nanos / 1e9, micros, millis, mins, *args, **kw) + self.secs = self.time.total_seconds() + + self.mins = self.secs / 60 + self.hours = self.mins / 60 + self.days = self.hours / 24 + + self.millis = self.secs * 1e3 + self.micros = self.secs * 1e6 + self.nanos = self.secs * 1e9 + + @property + def time(self): + return self._time + +class Timer: + def __init__(self, *args, **kw): + self._time = None + self.duration = TimeDelta(*args, **kw) + + @property + def duration(self): + return self._duration + + @duration.setter + def duration(self, value): + self._duration = value + return self.reset() + + def reset(self): + if self._time is None: + return False + self._time = None + return True + + @property + def elapsed(self): + return TimeDelta(nanos=self._elapsed) + + def restart(self): + return self() + + def __call__(self): + self._time = time_ns() + + def __bool__(self): + if self._elapsed <= self._duration.nanos: + return False + return self.reset() + + @property + def _elapsed(self): + if self._time is None: + return 0 + return time_ns() - self._time + +def mean(data, default=None): + try: + return _mean(data) + except StatisticsError: + return default + +def _bisect(self, value, key, a, b): + n = b - a + if n <= 0: + return a + m = (a + b) // 2 + x = key(self[m]) + if value == x: + return m + if value < x: + return _bisect(self, value, key, a, m-1) + return _bisect(self, value, key, m+1, b) + +def bisect(self, value, key=None): + if key is None: + key = lambda e: e + return _bisect(self, value, key, 0, len(self)) + +_newline = r'\s*[\n\r]+\s*' + +def strip(text): + return re.sub(_newline, '', text) + +def split(text): + return re.split(_newline, text) + +def casefold(self): + return str(self).casefold() + +def sign(self): + if self == 0: + return 0 + return -1 if self < 0 else 1 + +class Future: + def __init__(self, func, executor): + self._func = func + self._executor = executor + + def __call__(self, *args, **kw): + self._executor.submit(self._func, *args, **kw) + return self + +class Executor: + def __init__(self, src=None): #FIXME + self._executor = None + self._futures = None + + def __call__(self, *args, **kw): #FIXME + _range = range(*args, **kw) + self._executor = _Executor(max_workers=len(_range)) + self._futures = [] + yield from _range + + def __bool__(self): + return bool(self._executor) + + def __getitem__(self, func): + return Future(func, self) + + def __iter__(self): + if self: + for future in self._futures: + yield future.result() + self._executor.shutdown(False) + self._executor = None + + def collect(self): + return tuple(self) + + def submit(self, func, *args, **kw): + if self: + future = self._executor.submit(func, *args, **kw) + self._futures.append(future) + +class HTMLParser(_HTMLParser): + def __init__(self, html=None): + super().__init__() + self.strict = False + self.convert_charrefs = True + self._text = [] + self(html) + + def handle_data(self, text): + self._text.append(text) + + def __call__(self, html): + self.reset() + self._text.clear() + if html is not None: + self.feed(html) + return self + + @property + def text(self): + return re.sub(r" +", " ", ''.join(self._text)) diff --git a/util/list.py b/util/list.py new file mode 100644 index 0000000..49dc692 --- /dev/null +++ b/util/list.py @@ -0,0 +1,78 @@ +from util import new, Set + +class SortedList(list): + def __init__(self, src=None, key=None): + super().__init__(self, src) + self._key = key + + def sort(self): + super().sort(self._key) + return self + +class _List: + def __add__(self, item): + return new(self, [*self, item]) + + def __radd__(self, item): + return new(self, [item, *self]) + + def __and__(self, other): + return new(self, [*self, *other]) + + def __rand__(self, other): + return new(self, [*other, *self]) + + def __mul__(self, other): + return new(self, zip(self, other)) + + def __rmul__(self, other): + return new(self, zip(other, self)) + + def join(self, sep=''): + return sep.join(self) + + def range(self): + return range(len(self)) + + def get(self, index, default=None): + return self[index] if index in self.range() else default + + def index(self, item, default=None): + try: + return super().index(item) + except ValueError: + return default + +class Tuple(_List, tuple): + def __repr__(self): + return tuple.__repr__(self) + +class List(_List, list): + def __init__(self, src=None, banned=None, **kw): + super().__init__() + self.__banned = Set(banned) + self.__format = kw.get('format', '{item}') + self._str = kw.get('str', ', ') + self.extend(src) + + def __repr__(self): + return list.__repr__(self) + + def _format(self, item): + return self.__format.format(item=str(item)) + + def __str__(self): + return self._str.join(self._format(e) for e in self) + + def _banned(self, kw): + return self.__banned | kw.get('banned') + + def append(self, item, **kw): + if item not in self._banned(kw): + super().append(item) + + def extend(self, other, **kw): + if other is None: + return False + super().extend(e for e in other if e not in self._banned(kw)) + return True diff --git a/util/priority_queue.py b/util/priority_queue.py new file mode 100644 index 0000000..2e35e53 --- /dev/null +++ b/util/priority_queue.py @@ -0,0 +1,204 @@ +from __future__ import print_function +from math import inf +from collections import namedtuple +from sortedcontainers import SortedKeyList + + +Element = namedtuple('Element', ('value', 'rank')) + +class PriorityQueue: + def __init__(self, capacity=None, key=None): + self._data = SortedKeyList(key=self._rank) + self._capacity = inf if capacity is None else capacity + self._key = key + + def _rank(self, item): + if self._key: + return self._key(*item) + return item.rank + + def add(self, value, rank): + self._data.add(Element(value, rank)) + self._shrink() + + def clear(self): + return self._data.clear() + + def __repr__(self): + return f"PriorityQueue([{', '.join(f'{v}: {r}' for (v, r) in self._data)}])" + + def _shrink(self): + while len(self._data) > self._capacity: + self._data.pop() + + def update(self, src): + raise NotImplementedError + + def __contains__(self, value): + raise NotImplementedError + + def __iter__(self): + for value, rank in self._data: + yield value + + def __getitem__(self, index): + if isinstance(index, int): + return self._data[index].value + return list(self)[index] + + def size(self): + return len(self._data) + +# Based on the work of Pravin Paratey (April 15, 2011) +# Joachim Hagege (June 18, 2014) +# +# Code released under BSD license +# +class _PriorityQueue: + def __init__(self, size=inf, key=None, default=0): + self.heap = [] + self.k = size + self.__key = key + self._default = default + + def _key(self, obj): + value, key = obj + _key = self.__key + if key is None: + return _key(value) if _key else self._default + return key + + def __getitem__(self, index): + return self.heap[index] + + def __iter__(self): + for value, key in self.heap: + yield value + + def __repr__(self): + return repr(self.heap) + + def parent(self, index): + """ + Parent will be at math.floor(index/2). Since integer division + simulates the floor function, we don't explicity use it + """ + return int(index / 2) + + def left_child(self, index): + return 2 * index + 1 + + def right_child(self, index): + return 2 * index + 2 + + def max_heapify(self, index): + """ + Responsible for maintaining the heap property of the heap. + This function assumes that the subtree located at left and right + child satisfies the max-heap property. But the tree at index + (current node) does not. O(log n) + """ + left_index = self.left_child(index) + right_index = self.right_child(index) + + largest = index + #if left_index < len(self.heap) and self.heap[left_index][DISTANCE_INDEX] > self.heap[index][DISTANCE_INDEX]: + if left_index < len(self.heap) and self._item(left_index) > self._item(index): + largest = left_index + #if right_index < len(self.heap) and self.heap[right_index][DISTANCE_INDEX] > self.heap[largest][DISTANCE_INDEX]: + if right_index < len(self.heap) and self._item(right_index) > self._item(largest): + largest = right_index + + if largest != index: + self.heap[index], self.heap[largest] = self.heap[largest], self.heap[index] + self.max_heapify(largest) + + def build_max_heap(self): + """ + Responsible for building the heap bottom up. It starts with the lowest non-leaf nodes + and calls heapify on them. This function is useful for initialising a heap with an + unordered array. O(n) + We shall note that all the elements after floor(size/2) are leaves. + """ + for i in xrange(len(self.heap)/2, -1, -1): + self.max_heapify(i) + + def heap_sort(self): + """ The heap-sort algorithm with a time complexity O(n*log(n)) + We run n times the max_heapify (O(log n)) + """ + self.build_max_heap() + output = [] + for i in xrange(len(self.heap)-1, 0, -1): + self.heap[0], self.heap[i] = self.heap[i], self.heap[0] + output.append(self.heap.pop()) + self.max_heapify(0) + output.append(self.heap.pop()) + self.heap = output + + def _item(self, index): + return self._key(self.heap[index]) + + def propagate_up(self, index): + """ Compares index with parent and swaps node if larger O(log(n)) """ + #while index != 0 and self.heap[self.parent(index)][DISTANCE_INDEX] < self.heap[index][DISTANCE_INDEX]: + while index != 0 and self._item(self.parent(index)) < self._item(index): + self.heap[index], self.heap[self.parent(index)] = self.heap[self.parent(index)], self.heap[index] + index = self.parent(index) + + # Here is the whole logic of the Bounded Priority queue. + # Add an element only if size < k and if size == k, only if the element value is less than + def add(self, value, key=None): + obj = Element(value, key) + # If number of elements == k and new element < max_elem: + # extract_max and add the new element. + # Else: + # Add the new element. + size = self.size() + + # Size == k, The priority queue is at capacity. + if size == self.k: + max_elem = self.max() + + # The new element has a lower distance than the biggest one. + # Then we insert, otherwise, don't insert. + #if obj[DISTANCE_INDEX] < max_elem: + if self._key(obj) < max_elem: + self.extract_max() + self.heap_append(obj) + + # if size == 0 or 0 < Size < k + else: + self.heap_append(obj) + + def heap_append(self, obj): + """ Adds an element in the heap O(ln(n)) """ + self.heap.append(obj) + self.propagate_up(len(self.heap) - 1) # Index value is 1 less than length + + def max(self): + # The highest distance will always be at the index 0 (heap invariant) + return self.heap[0][1] + + def size(self): + return len(self.heap) + + def extract_max(self): + """ + Part of the Priority Queue, extracts the element on the top of the heap and + then re-heapifies. O(log n) + """ + max = self.heap[0] + data = self.heap.pop() + if len(self.heap) > 0: + self.heap[0] = data + self.max_heapify(0) + return max + + def increment(self, key, value): + """ Increments key by the input value. O(log n) """ + for i in xrange(len(self.heap)): + if self.heap[i][0] == key: + self.heap[i] = (value + self.heap[i][1], key) + self.propagate_up(i) + break diff --git a/util/pyquery.py b/util/pyquery.py new file mode 100644 index 0000000..b7acf9e --- /dev/null +++ b/util/pyquery.py @@ -0,0 +1,94 @@ +from itertools import islice + +from util import attach + +from pyquery import PyQuery as pq, text as _text + + +class Text: + _tag = 'text' + _html = f'<{_tag}>' + def __new__(cls, text, prev=None): + return pq(cls._html).append(text or '').before(prev) + +_text.INLINE_TAGS.update([Text._tag]) + +def _Text(node, prev=None): + return Text(node, prev)[0] if isinstance(node, str) else node + +_before = pq.before +@attach(pq.fn) +def before(other): + if other is None: + return this + return _before(this, other) + +#@attach(pq.fn) +def _iter(this): + if not this: + return this + prev = _Text(this[0]) + yield pq(prev) + for node in islice(this, 1, None): + if isinstance(node, str): + elem = Text(node) + yield elem.set(_prev=pq(prev)) + prev = elem[0] + else: + yield pq(node) + prev = node + +@attach(pq.fn) +def test(include=None, exclude=None): + if not this.is_(include): + return False + + if exclude and this.is_(exclude): + return False + + return True + +@attach(pq.fn) +def set(**kw): + for name, val in kw.items(): + setattr(this, name, val) + return this + +_prev = pq.prev +@attach(pq.fn) +def prev(sel=None): + if hasattr(this, '_prev'): + return this._prev.filter(sel) + return _prev(this, sel) + +@attach(pq.fn) +def default(name, default=None): + value = this.attr(name) + return default if value is None else value + +_items = pq.items +@attach(pq.fn) +def items(include=None, exclude=None): + for node in _iter(this): + if node.test(include, exclude): + yield node + +@attach(pq.fn) +def tail(sel=None): + return pq([Text(e.tail)[0] for e in this]).filter(sel) + +@attach(pq.fn) +def nextUntil(sel=None, filter=None): + res = OrderedSet() + if sel is None: + sel = ':not(*)' + for node in this.items(): + while True: + res.update(node.tail(filter)) + node = node.next() + if node.is_(sel) or not node: + break + if node.is_(filter): + res.update(node) + + return pq(res[:]) diff --git a/util/request.py b/util/request.py new file mode 100644 index 0000000..f35ead4 --- /dev/null +++ b/util/request.py @@ -0,0 +1,23 @@ +from util import mixin + +from munch import munchify +from requests import Request, Session, Response +_session = Session() + +@mixin(Request) +class _Request: + def __call__(self, params=None, json=None): + req = self.prepare() + if params: + req.prepare_url(req.url, params) + if json: + req.prepare_body(None, self.files, json) + return _session.send(req) + + +@mixin(Response) +class _Reponse: + def result(self): + if self.ok: + return munchify(self.json()) + diff --git a/util/set.py b/util/set.py new file mode 100644 index 0000000..54f2746 --- /dev/null +++ b/util/set.py @@ -0,0 +1,107 @@ +from util import OrderedDict + + +def _check(value): + if isinstance(value, bool): + return True + try: + iter(value) + return True + except TypeError: + return False + +class Set(set): + def __init__(self, src): + super().__init__() + self._bool = None + self.update(src) + + def clone(self): + res = Set(self) + res._bool = self._bool + return res + + def union(self, other): + if _check(other): + return self.clone().update(other) + return self + + def __contains__(self, item): + if super().__contains__(item): + return True + return self._bool is bool(item) + + def update(self, src): + if isinstance(src, bool): + if self._bool is None: + self._bool = src + return True + return False + if _check(src): + super().update(src) + return True + return False + +Set.__or__ = Set.union + +class OrderedSet: + def __init__(self, src=None): + super().__init__() + self._data = OrderedDict() + + if src: + self.update(src) + + def update(self, *sources): + for src in sources: + for item in src: + self.add(item) + return self + + def difference_update(self, src): + for item in src: + self.discard(item) + return self + + def add(self, item): + if item in self: + return False + self._data[item] = None + return True + + def __contains__(self, item): + return item in self._data + + def discard(self, item): + if item in self: + return False + del self._data[item] + return True + + def remove(self, item): + if not self.discard(item): + raise KeyError + + def __iter__(self): + yield from self._data + + def clear(self): + if not self: + return False + self._data.clear() + return True + + def __bool__(self): + return bool(self._data) + + def __repr__(self): + return f"{{{', '.join(repr(e) for e in self)}}}" + + def __len__(self): + return len(self._data) + + def __getitem__(self, index): + res = list(self) + if index == slice(None): + return res + return res[index] diff --git a/util/url.py b/util/url.py new file mode 100644 index 0000000..8e60c9e --- /dev/null +++ b/util/url.py @@ -0,0 +1,84 @@ +import os +from urllib.parse import urlsplit, urlunsplit, SplitResult + +from util import Tuple + + +class URL(object): + class _Dict(dict): + _extra = { 'basename', 'subdomain' } + + def regular(self, key): + return key in self and key not in self._extra + + def __setitem__(self, key, value): + if key is 'path': + super().__setitem__('basename', os.path.basename(value) if value else '') + elif key is 'netloc': + domain = value.rsplit('.', 2) + super().__setitem__('subdomain', domain[0] if len(domain) is 3 else '') + + return super().__setitem__(key, value) + + _keys = Tuple(SplitResult._fields) + basename = None + subdomain = None + + def __init__(self, url=None, cut=None): + self.__dict__ = self._Dict() + _keys = self._keys + if isinstance(url, str): + data = _keys * urlsplit(url) + elif isinstance(url, dict): + data = url + elif url is not None: + data = _keys * url + else: + data = [] + + index = len(_keys) + if isinstance(cut, str): + index = _keys.index(cut, index) + elif isinstance(cut, int): + index = cut + + _dict = dict(data) + for k in _keys[:index]: + self._set(k, _dict.get(k, '')) + for k in _keys[index:]: + self._set(k) + + def _set(self, key, value=''): + self.__dict__[key] = value + + def _regular(self, key): + return self.__dict__.regular(key) + + def _key(self, key): + return key if isinstance(key, str) else self._keys.get(key) + + def __getitem__(self, key): + return self.__dict__[self._key(key)] + + def __setitem__(self, key, value): + key = self._key(key) + if self._regular(key): + self._set(key, value) + + def __len__(self): + return len(self._keys) + + def __iter__(self): + for k in self._keys: + yield self[k] + + def __str__(self): + return urlunsplit(self) + + def format(self, *args, **kw): + return str(self).format(*args, **kw) + + def __repr__(self): + _name = self.__class__.__name__ + data = (f"{k}='{self[k]}'" for k in self._keys) + return f"{_name}({', '.join(data)})" diff --git a/watson/__init__.py b/watson/__init__.py new file mode 100644 index 0000000..1163b05 --- /dev/null +++ b/watson/__init__.py @@ -0,0 +1,8 @@ +from munch import munchify + + +class Result: + def __new__(cls, res): + return munchify(res.get_result()) + +from .assistant import Assistant diff --git a/watson/assistant.py b/watson/assistant.py new file mode 100644 index 0000000..50a0e61 --- /dev/null +++ b/watson/assistant.py @@ -0,0 +1,164 @@ +from itertools import chain, repeat +from collections import namedtuple, defaultdict +from uuid import uuid4 +from datetime import datetime +import re + +from ibm_watson import AssistantV2, AssistantV1 +from ibm_watson.assistant_v2 import MessageInput, MessageInputOptions, RuntimeIntent +from ibm_watson.assistant_v1 import \ + MessageInput as MessageInput_1, RuntimeIntent as RuntimeIntent_1, \ + Example, DialogNodeOutput, DialogNodeOutputGeneric, DialogNodeOutputTextValuesElement as DialogNodeText +from munch import munchify + +from util import Timer, Data, String, split, Object +from watson import Result + +def uuid(): + return uuid4().hex + +_Output = namedtuple('Output', 'text intent confidence') + +Fallback = namedtuple('Fallback', 'assistant threshold') + +class Assistant: + _api = AssistantV2 + api_version = 2 + @classmethod + def v1(cls, id, **kw): + return V1(id, **kw) + + def __init__(self, id, **kw): + self._id = id + self._service = self._api(**kw) + self._session = None + self._timer = Timer(mins=5) + self.return_context = True + self.version = self._service.version + self.context = None + self._fallback = None + + @property + def session_id(self): + if not self._session or self._timer: # expired + self._session = self._service.create_session(self._id).get_result()['session_id'] + self._timer() # restart timer + return self._session + + def _output(self, output, text, intents): + fallback = self._fallback + if not output: + return output + if fallback and output.confidence < fallback.threshold or not output.intent: + return fallback.assistant(text, intents) + return output + + def __call__(self, text=None, intents=None, bypass=False): + if intents: + intents = [RuntimeIntent(e, 1) for e in intents] + options = MessageInputOptions(return_context=self.return_context) + input = MessageInput(text=text, intents=intents, options=options)._to_dict() + + res = Result(self._service.message(self._id, self.session_id, input, self.context)) + self.context = res.get('context') + ret = Output(res.output) + return ret if bypass else self._output(ret, text, intents) + + def __setitem__(self, input, output): + raise NotImplementedError + + def link(self, assistant, threshold): + assert 0 < threshold <= 1 + self._fallback = Fallback(assistant, threshold) + +class Intent: + _maxlen = 1024 + def __new__(cls, text, description=None): + assert isinstance(text, str) + text = text.strip() + assert 0 < len(text) <= cls._maxlen + assert not re.match(r"[\n\r\t]", text) + examples = [Example(text, created=datetime.now())] + return Object(intent=uuid(), description=description, examples=examples) + +class DialogNode: + _maxlen = 4096 + def __new__(cls, intent, text): + assert isinstance(text, str) + text = text.strip() + assert 0 < len(text) <= cls._maxlen + values = [DialogNodeText(text)] + generic = [DialogNodeOutputGeneric('text', values)] + output = DialogNodeOutput(generic) + name = intent.intent + return Object(dialog_node=name, description=intent.description, conditions=f'#{name}', output=output) + +class V1(Assistant): + _api = AssistantV1 + api_version = 1 + def __call__(self, text, intents=None): + input = MessageInput_1(text=text)._to_dict() + res = Result(self._service.message(self._id, input, alternate_intents=False, context=self.context)) + self.context = res.get('context') + return self._output(Output_1(res), text, intents) + + def __setitem__(self, input, output): + description = None + if not isinstance(input, str): + input, description = input + + intent = Intent(input, description) + self._service.create_intent(self._id, **intent) + + node = DialogNode(intent, output) + self._service.create_dialog_node(self._id, **node) + +_entities = ({},) +_intents = repeat(RuntimeIntent(None, 1)) +class Output(Data): + def __init__(self, output): + super().__init__() + self._source = output + + entities = defaultdict(dict) + for e in output.entities: + entities[e.entity][e.value] = e + entities[e.entity, e.value] = e + self._entities = entities #munchify(entities) + + for g, i in zip(output.generic, chain(output.intents, _intents)): + self._append(_Output(g.text, i.intent, i.confidence)) + + @property + def entities(self): + return self._entities + + @property + def _text(self): + return self[0].text if self else None + + @property + def text(self): + return split(self._text) if self else [] + + @property + def intent(self): + return self[0].intent if self else None + + @property + def confidence(self): + return self[0].confidence if self else None + + @property + def data(self): + return self._source + +_intents_1 = repeat(RuntimeIntent_1(None, 1)) +class Output_1(Output): + def __init__(self, data): + Data.__init__(self) + #super().__init__() + self._source = data + for t, i in zip(data.output.text, chain(data.intents, _intents_1)): + self._append(_Output(t, i.intent, i.confidence)) + \ No newline at end of file