From 5456c4dc3c850d9f0df3ce56f39fd0ceb2509a69 Mon Sep 17 00:00:00 2001 From: denim2x Date: Sun, 19 May 2019 20:48:11 +0300 Subject: [PATCH] Updates Signed-off-by: denim2x --- README.md | 4 +- _bareasgi.py | 4 + _rom.py | 26 ++++++ app.js | 29 ++++-- dialogflow.py | 33 +++---- document.py | 122 ++++++++++++++++++------ engine.py | 138 +++++++++++++++++---------- phrase_metric.py | 184 ++++++++++++++++++++++++++++++++++++ requirements.txt | 7 +- semantic_similarity.py | 61 ------------ static/app.js | 4 +- static/index.html | 5 +- static/master.css | 78 +++++++++------- util/__init__.py | 103 ++++++++++++++++++++- util/list.py | 6 +- util/priority_queue.py | 206 +++++++++++++++++++++++++++++++++++++++++ util/set.py | 10 +- 17 files changed, 808 insertions(+), 212 deletions(-) create mode 100644 _rom.py create mode 100644 phrase_metric.py delete mode 100644 semantic_similarity.py create mode 100644 util/priority_queue.py diff --git a/README.md b/README.md index 39852f8..d31181a 100644 --- a/README.md +++ b/README.md @@ -43,8 +43,8 @@ dialogflow: redis: - host: - port: - pass: # optional + port: # optional (default: 6379) + auth: # optional - ... ``` - (optional) *\/account.json* with valid *GCP service account* data. diff --git a/_bareasgi.py b/_bareasgi.py index 83d3a16..4c3ffaf 100644 --- a/_bareasgi.py +++ b/_bareasgi.py @@ -4,3 +4,7 @@ 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/_rom.py b/_rom.py new file mode 100644 index 0000000..c9542d9 --- /dev/null +++ b/_rom.py @@ -0,0 +1,26 @@ +from rom import * +import rom as _rom +from rom.columns import String as _String +from rom.util import set_connection_settings as init, get_connection + + +class String(_String): + def _to_redis(self, value): + if isinstance(value, bytes): + return super()._to_redis(value) + return value + +class _Model: + def __getitem__(self, key): + value = getattr(self, key) + return value.decode() if isinstance(value, bytes) else bytes + +Model = (_Model, _rom.Model) + +def bgsave(): + db = get_connection() + try: + db.bgsave() + return True + except: + return False diff --git a/app.js b/app.js index 7540e5c..5cf6836 100644 --- a/app.js +++ b/app.js @@ -46,13 +46,11 @@ function get_knowledge() { } function send_message(text='', cb) { - request.post('/message').send(text).then(({ body }) => { - state.conversation.push(body); + request.post('/message').send(text).then(({ text }) => { + state.conversation.push({ text }); }, (e) => { _error('POST', '/message', e); - if (cb) { - cb(); - } + cb && cb(); }); } @@ -110,20 +108,33 @@ rivets.binders['input'] = { }, bind: function(el) { - $(el).on('input.rivets', this.publish); + 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('input.rivets'); + $(el).off('.rv-input'); + clearInterval(this._watcher) }, routine: function(el, value) { if (this.state != 'publish') { + clearInterval(this._watcher); el.innerText = value; } - state.error = false; + state.error = false; + this._empty = value == ''; + if (this._empty) { + this._watcher = setInterval(this._watch, 30); + } if (this.empty_class) { - $(el).toggleClass(this.empty_class, value == ''); + $(el).toggleClass(this.empty_class, this._empty); } }, diff --git a/dialogflow.py b/dialogflow.py index 374f292..97ec54b 100644 --- a/dialogflow.py +++ b/dialogflow.py @@ -4,6 +4,7 @@ from dialogflow_v2beta1 import SessionsClient, KnowledgeBasesClient, DocumentsClient from dialogflow_v2beta1 import types, enums from google.api_core.exceptions import InvalidArgument, GoogleAPICallError +from google.api_core.retry import Retry from util import realpath from config import project_id @@ -50,6 +51,10 @@ def __init__(self, session_id=uuid4(), language_code='en'): self._kb = kb.project_path(project_id) self.language_code = language_code self.min_confidence = 0.8 + self._retry = { + 'retry': Retry(), + 'timeout': 10 + } def __call__(self, text=None, event=None): language_code = self.language_code @@ -61,24 +66,20 @@ def __call__(self, text=None, event=None): query_input = types.QueryInput(event=event_input) else: return None - return session.detect_intent(session=self._session, query_input=query_input) + return session.detect_intent(session=self._session, query_input=query_input, **self._retry) - def get_answers(self, text, raw=False, kb=True, sort_key=None, **kw): + def get_answers(self, text, kb=True): res = self(text=text) - filter_fn = kw.get('filter') - if hasattr(res.query_result, 'knowledge_answers'): - if not kb and res.alternative_query_results: - answer = res.alternative_query_results[0] - if answer.intent_detection_confidence >= self.min_confidence: - return [answer.fulfillment_text] - return None - answers = [a for a in res.query_result.knowledge_answers.answers] - if filter_fn: - answers = list(filter(filter_fn, answers)) - if sort_key: - answers.sort(sort_key) - return answers if raw else [a.answer for a in answers] - return None + if not hasattr(res.query_result, 'knowledge_answers'): + return + + if not kb and res.alternative_query_results: + answer = res.alternative_query_results[0] + if answer.action != 'input.unknown' and answer.intent_detection_confidence >= self.min_confidence: + return [answer.fulfillment_text] + return None + + return res.query_result.knowledge_answers.answers def event(self, name, raw=False): res = self(event=name) diff --git a/document.py b/document.py index ebb142d..f834971 100644 --- a/document.py +++ b/document.py @@ -1,14 +1,13 @@ from urllib.error import HTTPError from collections import namedtuple -from util import pq, List +from util import pq, List, Text, OrderedSet _excludes = ( 'Recommended_Readings', 'See_Also', 'Residents', - 'Paraphernalia', 'Alternate_Reality_Versions' ) @@ -18,21 +17,24 @@ 'Links_and_References', 'References', 'Points_of_Interest', - 'Links' + 'Links', + 'Related' ], format=':not(#{item})', str='' ) -Fragment = namedtuple('Fragment', ('caption', 'text')) +Handle = namedtuple('Handle', ('pointer', 'until')) +Fragment = namedtuple('Fragment', ('handle', 'text')) def _text(el, to_strip=None): if el is None: return None - return el.text().strip().strip(to_strip).strip() + text = el.text() if isinstance(el, pq) else el + return text.strip().strip(to_strip).strip() class Document: - def __init__(self, url=None, name=None, quotes=False): + def __init__(self, url=None, name=None, quotes=False, prepare=False): if name is not None: url = url.format(*name.split('|')) self.name = name @@ -45,15 +47,20 @@ def __init__(self, url=None, name=None, quotes=False): except HTTPError: doc = pq([]) self.caption = doc.children('head > title').text().split('|', 1)[0].strip() - self.site = doc.find('link[rel="search').attr('title').rstrip('(en)').strip() + self.site = doc.find('link[rel="search"]').default('title', '').rstrip('(en)').strip() self._doc = doc self.__content = None - self._data = None + self.__h2 = None + self._fragments = None + self._refs = True self._quotes = quotes - sel = List(['h3, p, ul, ol']) + self._isel = 'text, a, b, i, em, strong, span' + sel = List([self._isel, 'p, ul, ol']) if self._quotes: sel.append('.quote') self._sel = str(sel) + if prepare: + iter(self) def __bool__(self): return bool(self._doc) @@ -62,20 +69,50 @@ def _content(self): if self.__content is None: content = self._doc.find('.mw-content-text') content.find('.noprint, noscript, script, style, link, iframe, embed, video, img, .editsection').remove() - content.find('*').remove_attr('style') self.__content = content return self.__content def __iter__(self): if not self: + raise StopIteration + + if self._fragments is not None: + yield from self._fragments + + self._fragments = {} + content = self._content() + + self._fragment(content.children('.portable-infobox'), name='Summary', until='#toc') + h2_list = content.children(f'h2{scrape_excludes} > {scrape_excludes}').closest('h2') + for h2 in h2_list.items(): + self._fragment(h2) + for h3 in h2.nextUntil('h2', 'h3').items(): + self._fragment(h2, h3) + + yield from tuple(self._fragments) + + def _fragment(self, *pointer, name=None, until=None): + if not name: + name = '/'.join(_text(h) for h in pointer) + + name = f"{self.name}#{_text(name)}" + fragment = Fragment(Handle(pointer[-1], until), None) + self._fragments[name] = fragment + + def __getitem__(self, name): + if name not in self._fragments: return - if self._data is not None: - yield from self._data + handle, text = self._fragments[name] + if text is not None: + return text - self._data = [] content = self._content() - content.find('.reference').remove() + + if self._refs: + content.find('.reference').remove() + self._refs = False + if self._quotes: for quote in content.find('.quote').items(): author = quote.find('.selflink').closest('b') @@ -83,22 +120,47 @@ def __iter__(self): _quote = quote.find('i') _quote.text('"' + _text(_quote, '"\'') + '"') author.append('said').prependTo(_quote.closest('dd')) - - h2_list = content.children(f'h2{scrape_excludes} > {scrape_excludes}').closest('h2') - for h2 in h2_list.items(): - self._append(h2.nextUntil('h2, h3', self._sel), h2) - for h3 in h2.nextUntil('h2', 'h3'): - self._append(h3.nextUntil('h2, h3', self._sel), h2, h3) - - def _append(self, body, *heads): - _data = self._data - if _data is None or not body: - return False - - caption = List((_text(h) for h in heads), str='/') - text = List((_text(e) for e in body.items()), False, str='\n') - _data.append(Fragment(f"{self.name}#{caption}", str(text))) - return True + + self._quotes = None + + pointer, until = handle + if not until: + until = 'h2, h3' + + if pointer.children('span').is_('#Abilities, #Equipment, #Transportation, #Weapons'): + body = pq([]) + for li in pointer.nextUntil('h2, h3', 'ul').children('li').items(): + nodes = pq([]) + for node in li.contents().items(exclude='ul, b > a'): + nodes.extend(Text(_text(node).lstrip(': ').rstrip() + ' ') if node.prev().is_('b > a') else node) + body.extend(pq('

').append(nodes)) + else: + body = pointer.nextUntil(until, self._sel) + + return self._create(name, body) + + def _create(self, name, body): + fragment = self._fragments.get(name) + if not body: + del self._fragments[name] + return + + text = List(banned=False, str='\n') + span = List(banned=False, str=' ') + for node in body.items(): + if node.is_(self._isel): + span.append(_text(node)) + else: + text.extend([str(span), _text(node)]) + span.clear() + text.append(str(span)) + text_ = str(text) + if not text_: + del self._fragments[name] + return + + self._fragments[name] = Fragment(fragment.handle, text_) + return text_ @staticmethod def parse_name(name): diff --git a/engine.py b/engine.py index fc575e1..fefcc0b 100644 --- a/engine.py +++ b/engine.py @@ -1,10 +1,10 @@ import re +from collections import defaultdict -from _bareasgi import text_reader, json_response +from _bareasgi import text_reader, text_response, json_response #from redis import StrictRedis #from redis.exceptions import ResponseError -import rom -from rom import util as _rom, session +import _rom as rom from config import dialogflow as _dialogflow, redis from document import Document @@ -14,34 +14,29 @@ from uuid import uuid1 ping = bytes(str(uuid1()), 'utf-8') -db_error = '' +#ping = str(uuid1()) for server in redis: + host, port = server['host'], int(server.get('port', '6379')) try: - _rom.set_connection_settings(host=server['host'], port=server['port'], password=server.get('pass'), decode_responses=True) - db = _rom.get_connection() + rom.init(host=host, port=port, password=server.get('auth'), decode_responses=False) + db = rom.get_connection() #db = StrictRedis(host=server['host'], port=server['port'], password=server.get('pass'), db=0, decode_responses=True) if db is None: - db_error = '' - continue + raise Exception + if ping == db.execute_command('ECHO', ping): - db_error = None + server = db.connection_pool.connection_kwargs + print('[INFO] Redis connection:', f"{server['host']}:{server['port']}") break except Exception as e: - db_error = e - pass - -if db_error: - print('[WARN] Redis connection failed:', db_error) - db = None -else: - print('[INFO] Redis connection:', db.connection_pool.connection_kwargs['host']) + print("[WARN] Redis connection failed:", e if str(e) else f'{host}:{port}') -class _Fragment(rom.Model): +class _Fragment(*rom.Model): path = rom.String(required=True, unique=True) name = rom.String(required=True, unique=True) document = rom.ManyToOne('_Document', required=True, on_delete='no action') -class _Document(rom.Model): +class _Document(*rom.Model): name = rom.String(required=True, unique=True) url = rom.String(unique=True) caption = rom.String(required=True) @@ -53,11 +48,11 @@ class _Document(rom.Model): _url = fandom.caption # TODO: Delete database entries not present in Fandom KB -docs = {} +docs = defaultdict(list) for fragment in fandom: if not _Fragment.get_by(path=fragment.name): name, heads = Document.parse_name(fragment.display_name) - docs.setdefault(name, set()).add(fragment) + docs[name].append(fragment) for name, fragments in docs.items(): _doc = _Document.get_by(name=name) @@ -66,12 +61,12 @@ class _Document(rom.Model): _doc = _Document(name=name, url=doc.url, caption=doc.caption, site=doc.site) for fragment in fragments: _fragment = _Fragment(path=fragment.name, name=fragment.display_name, document=_doc) -session.flush() +rom.session.flush() -sites = {} +sites = defaultdict(dict) async def knowledge(scope, info, matches, content): for _doc in _Document.query.all(): - sites.setdefault(_doc.site, {}).setdefault(_doc.url, _doc.caption) + sites[_doc['site']].setdefault(_doc['url'], _doc['caption']) res = [] for site, docs in sites.items(): @@ -80,42 +75,87 @@ async def knowledge(scope, info, matches, content): return json_response(sorted(res, key=lambda e: e['caption'])) + +from util import PriorityQueue +from phrase_metric import similarity, validate + +# FIXME +def _search(self, text, threshold=0.8): + keys = (key.decode() for key in db.hkeys(self)) + keys = ((similarity(text, key), key) for key in keys) + s, key = max(keys, key=lambda k: k[0], default=(0, None)) + if s > threshold: + return key + +_save = db.hset + +def find_answer(query): + ret = _search('_answers', query) + return db.hget('_answers', ret).decode() if ret else None + +def save_answer(query, answer): + _save('_answers', query, answer) + rom.bgsave() + async def message(scope, info, matches, content): text = re.sub(r'\s+', ' ', (await text_reader(content)).strip().lstrip('.').strip()) if text == '': - return json_response([dialogflow.event('WELCOME')]) + return text_response(dialogflow.event('WELCOME')) answers = dialogflow.get_answers(text, kb=False) if answers: - return json_response(answers) + return text_response(answers[0]) query = text.strip('?!').strip() - if not query: - return 400 - - urls = set() - for url in search(query)[:10]: - if not _Document.get_by(url=str(url)): - doc = Document(url) - print('[INFO] Generating document:', doc.name) - if not doc: - print('[WARN] URL request failed:', doc.url) + if not validate(query): + return text_response(dialogflow.event('fallback')) + + answer = find_answer(query) + if answer: + return text_response(answer) + + fragments = PriorityQueue(5, lambda f, r: 1 - r) + for url in search(query)[:3]: + doc = Document(url) + if not doc: + print('[WARN] URL request failed:', doc.url) + continue + + for fragment_name in doc: + if _Fragment.get_by(name=fragment_name): + print('[INFO] Found fragment:', fragment_name) + continue + + print('[INFO] Generating fragment:', fragment_name) + fragment = doc[fragment_name] + if not fragment: + print('[INFO] Skipping empty fragment:', fragment_name) continue + + fragments.add((doc, fragment_name, fragment), similarity(fragment, query)) + + for doc, name, fragment in fragments: + print('[INFO] Uploading fragment:', name) + res = fandom.create(name, fragment) + if res is None: + print('[WARN] Fragment upload failed:', name) + continue + + _doc = _Document.get_by(name=doc.name) + if not _doc: _doc = _Document(name=doc.name, url=doc.url, caption=doc.caption, site=doc.site) - for fragment in doc: - res = fandom.create(fragment) - if res is None: - print('[WARN] Fragment creation failed:', fragment.caption) - continue - _fragment = _Fragment(path=res.name, name=fragment.caption, document=_doc) - print('[INFO] Document created:', doc.name) + _fragment = _Fragment(path=res.name, name=name, document=_doc) + print('[INFO] Fragment uploaded:', name) - urls.add(str(url)) + rom.session.flush() - session.flush() + #lambda a: _Fragment.get_by(path=a.source).document['url'] in urls) - answers = dialogflow.get_answers(text, filter=lambda a: _Fragment.get_by(path=a.source).document.url in urls) - if answers: - return json_response(answers) + answers = dialogflow.get_answers(query) + if not answers: + return text_response(dialogflow.event('fallback')) + + answer = max(answers, key=lambda a: a.match_confidence * similarity(a.answer, query)) + save_answer(query, answer.answer) - return json_response([dialogflow.event('fallback')]) + return text_response(answer) diff --git a/phrase_metric.py b/phrase_metric.py new file mode 100644 index 0000000..2648151 --- /dev/null +++ b/phrase_metric.py @@ -0,0 +1,184 @@ +# -*- coding: utf-8 -*- +import re +from collections import namedtuple + +from pattern.en import parsetree +from pattern.en.wordnet import _pattern2wordnet as _pos, wn_ic, wn, WordNetSynset as Synset +from pattern.text.tree import Text, Sentence, Chunk, Word + +from util import mixin, mean, casefold + +# Rationale: {Egypt} ~ {Egyptian} > {Tennessee} ~ {Egyptian} +IC_CORPUS = wn_ic.ic('ic-shaks.dat') + +def _parse(*args, **kw): # FIXME (workaround) + from pattern.text.en import parser + if isinstance(parser.model, str): + from pattern.text import Model + parser.model = Model(path=parser.model) + + return parsetree(*args, **kw) + +def _casefold(text): + return { casefold(text), casefold(getattr(text, 'lemma', text)) } + +def _similar(a, b): + return bool(_casefold(a) & _casefold(b)) + +def _ratio(*data): + _len = [len(e) for e in data] + return mean(_len) / max(_len) + +def _mean(data, threshold=0, default=0): + return mean((e for e in data if e > threshold), default) + +def _min(data, threshold=0, default=0): + return min((e for e in data if e > threshold), default=default) + +@mixin(Synset) +class _Synset: + def similarity(self, other): + if self._pos != other._pos: + return None + if self._pos in 'asr': + return self.wup_similarity(other) + return self.lin_similarity(other, IC_CORPUS) + +@mixin(Word) +class _Word: + def synsets(self, type=None): + return wn.synsets(str(self), _pos.get(type[:2] if type else None)) + + def _similarity(self, other, default=0): + #s = sorted((other.similarity(s) or default for s in self.synsets()), default=default) + #return max((other.similarity(s) or default for s in self.synsets()), default=default) + return (other.similarity(s) or default for s in self.synsets()) + + def similarity(self, other, default=0): + if isinstance(other, Chunk): + return max((self.similarity(w) for w in other), default=default) + if isinstance(other, Synset): + return max(self._similarity(other), default=default) + #return self._similarity(other) + + if self.type == other.type and _similar(self, other): + return 1 + return max(self._similarity(other), default=default) + #return self._similarity(other) + +Factor = namedtuple('Factor', ('factor', 'value')) + +@mixin(Chunk) +class _Chunk: + factors = dict(VP=0.07, ADJP=0.02, ADVP=0.01) + + @property + def nouns(self): + if not hasattr(self, '_nouns'): + nouns = [w for w in self if w.type[:2] == 'NN'] + self._nouns = Chunk(self.sentence, nouns, self.type, self.role, self.relation) + return self._nouns + + @property + def main(self): + return self.type == 'NP' + + def _related(self, other, type, scaling): + factor = self.factors[type] + a, b = (e.nearest(type) for e in (self, other)) + if None in {a, b}: + return Factor(0, 0) + return Factor(factor, a._similarity(b, scaling)) + + def similarity(self, other, value=None, scaling=True): + if value is None: + return self._similarity(other, scaling) + + related = [self._related(other, type, scaling) for type in self.factors] + factor = 1 - sum(e.factor for e in related) + + return factor * value + sum(e.factor * e.value for e in related) + + @property + def lemma(self): + if not hasattr(self, '_lemma'): + self._lemma = ' '.join(e for e in self.lemmata if e) + return self._lemma + + def _similarity(self, other, scaling, default=0): + if self.type == other.type and _similar(self, other): + return 1 + ratio = _ratio(self, other) if scaling else 1 + return _mean((w.similarity(other) for w in self), default=0) * ratio + +@mixin(Sentence) +class _Sentence: + @property + def noun_phrases(self): + if not hasattr(self, '_noun'): + self._noun = [p for p in self.phrases if p.nouns and p.main] + return self._noun + + @property + def main_phrases(self): + if not hasattr(self, '_main'): + self._main = [p for p in self.phrases if p.main] + return self._main + +@mixin(Text) +class _Text: + def __new__(cls, self, lemmata=True): + if self is None: + return self + if not isinstance(self, Text): + if isinstance(self, list): + self = '\n'.join(e for e in self if e) + self = _parse(self, lemmata=lemmata) + return self + + @property + def noun_phrases(self): + if not hasattr(self, '_noun'): + self._noun = [p for s in self for p in s.noun_phrases] + return self._noun + + @property + def main_phrases(self): + if not hasattr(self, '_main'): + self._main = [p for s in self for p in s.main_phrases] + return self._main + +def validate(self): # FIXME (workaround) + for s in _Text(self): + if s.phrases: + return True + return False + #return bool(_Text(self).noun_phrases) + + +def similarity(a, b, scaling='inner', split=5): + """Computes a non-negative score representing the amount of common information between a and b""" + X, Y = (_Text(e) for e in (a, b)) + if casefold(X) == casefold(Y): + return 1 + A, B = (e.noun_phrases for e in (X, Y)) + data = [] + scaling = 'total' if scaling is True else scaling + inner = scaling in { 'inner', 'total' } + for a in A: + S = sorted(((a.similarity(b, scaling=inner), b) for b in B), key=lambda e: e[0], reverse=True) + m = max((a.similarity(p, s, scaling=inner) for (s, p) in S[:split]), default=0) + _len = len(S) + if _len > split: + f = max([len(S[split:]) / _len, 0.3]) + data.append(m * (1 - f) + S[split][0] * f) + else: + data.append(m) + + ratio = _ratio(A, B) if scaling in { 'outer', 'total' } else 1 + return _mean(data) * ratio + + +def distance(a, b): + return 1 - similarity(a, b) + \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 2a6f974..9531742 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,12 +1,11 @@ -uvicorn -bareasgi +uvicorn==0.7.0 +bareasgi==1.0.3 bareasgi_static pyquery google-api-python-client dialogflow PyYAML -aiofiles redis rom -pywsd numpy +sortedcontainers diff --git a/semantic_similarity.py b/semantic_similarity.py deleted file mode 100644 index 04b3d74..0000000 --- a/semantic_similarity.py +++ /dev/null @@ -1,61 +0,0 @@ -# -*- coding: utf-8 -*- -from pywsd import disambiguate -#from pywsd.similarity import max_similarity as maxsim -import numpy as np -from collections import defaultdict -alpha = 0.2 -beta = 0.45 -benchmark_similarity = 0.8025 -gamma = 1.8 -""" -Semantic similarity based on the paper: - Calculating the similarity between words and sentences using a lexical database and corpus statistics -TKDE, 2018 -""" - -def _synset_similarity(s1,s2): - L1 =dict() - L2 =defaultdict(list) - - for syn1 in s1: - L1[syn1[0]] =list() - for syn2 in s2: - - subsumer = syn1[1].lowest_common_hypernyms(syn2[1], simulate_root=True)[0] - h =subsumer.max_depth() + 1 # as done on NLTK wordnet - syn1_dist_subsumer = syn1[1].shortest_path_distance(subsumer,simulate_root =True) - syn2_dist_subsumer = syn2[1].shortest_path_distance(subsumer,simulate_root =True) - l =syn1_dist_subsumer + syn2_dist_subsumer - f1 = np.exp(-alpha*l) - a = np.exp(beta*h) - b = np.exp(-beta*h) - f2 = (a-b) /(a+b) - sim = f1*f2 - L1[syn1[0]].append(sim) - L2[syn2[0]].append(sim) - return L1, L2 - -def similarity(s1,s2): - wsd = ( - [syn for syn in disambiguate(s) if syn[1]] - for s in (s1, s2) - ) - - #vector_length = max(len(s1_wsd), len(s2_wsd)) - - L = _synset_similarity(*wsd) - V1, V2 = ( - np.array([max(e[key]) for key in e.keys()]) - for e in L - ) - S = np.linalg.norm(V1)*np.linalg.norm(V2) - C1, C2 = ( - sum(V >= benchmark_similarity) - for V in (V1, V2) - ) - - Xi = (C1+C2) / gamma - - if C1+C2 == 0: - Xi = max(V1.size, V2.size) / 2 - return S/Xi diff --git a/static/app.js b/static/app.js index 32c9c6c..d1cc5b0 100644 --- a/static/app.js +++ b/static/app.js @@ -1,6 +1,6 @@ (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{e.innerHTML=""}),this},$.fn.outerHTML=function(){return this.prop("outerHTML")};const state={message:"",knowledge:[],conversation:[],error:!1};function _error(e,t,{response:n}){n=n?[n.status,n.text]:[],console.warn(`[${e} ${t}]`,...n)}function get_knowledge(){request.get("/knowledge").then(({body:e})=>{state.knowledge=e},e=>_error("GET","/knowledge",e))}function send_message(e="",t){request.post("/respond").send(e).then(({body:e})=>{state.conversation.push({text:e[0]})},e=>{_error("POST","/respond",e),t&&t()})}function _const(e,t,n){return Object.defineProperty(e,t,{value:n,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),get_knowledge(),$(".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,is_user:!0}),send_message(t,()=>{state.error=!0}),get_knowledge(),!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){$(e).on("input.rivets",this.publish)},unbind:function(e){$(e).off("input.rivets")},routine:function(e,t){"publish"!=this.state&&(e.innerText=t),state.error=!1,this.empty_class&&$(e).toggleClass(this.empty_class,""==t)},getValue:function(e){return e.innerText.trim()}},global.$state=state,rivets.bind(document.body,state); +"use strict";const type=require("type-of"),request=require("superagent"),h=require("hyperscript-string"),$=require("domtastic"),rivets=require("rivets");$.fn.innerText=function(e){return void 0===e?this[0].innerText:this.forEach(function(t){return t.innerText=""+e})},$.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:n}){n=n?[n.status,n.text]:[],console.warn(`[${e} ${t}]`,...n)}function get_knowledge(){request.get("/knowledge").then(({body:e})=>{state.knowledge=e},e=>_error("GET","/knowledge",e))}function send_message(e="",t){request.post("/message").send(e).then(({text:e})=>{state.conversation.push({text:e})},e=>{_error("POST","/message",e),t&&t()})}function _const(e,t,n){return Object.defineProperty(e,t,{value:n,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),get_knowledge(),$(".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,is_user:!0}),send_message(t,()=>{state.error=!0}),get_knowledge(),!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 : {}) @@ -62,4 +62,4 @@ var toString=Object.prototype.toString;module.exports=function(e){switch(toStrin 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}; },{}]},{},[1]) -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","app.js","node_modules/arrify/index.js","node_modules/classnames/index.js","node_modules/component-emitter/index.js","node_modules/domtastic/dist/domtastic.js","node_modules/hyperscript-string/src/index.js","node_modules/hyperscript-string/src/render.js","node_modules/hyperscript-string/src/utils.js","node_modules/is-plain-object/index.js","node_modules/isobject/index.js","node_modules/rivets/dist/rivets.js","node_modules/sightglass/index.js","node_modules/superagent/lib/agent-base.js","node_modules/superagent/lib/client.js","node_modules/superagent/lib/is-object.js","node_modules/superagent/lib/request-base.js","node_modules/superagent/lib/response-base.js","node_modules/superagent/lib/utils.js","node_modules/type-of/index.js","node_modules/void-elements/index.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\";const type=require(\"type-of\"),request=require(\"superagent\"),h=require(\"hyperscript-string\"),$=require(\"domtastic\"),rivets=require(\"rivets\");$.fn.innerText=function(e){return void 0===e?this[0].innerText:this.forEach(function(t){return t.innerText=\"\"+e})},$.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:n}){n=n?[n.status,n.text]:[],console.warn(`[${e} ${t}]`,...n)}function get_knowledge(){request.get(\"/knowledge\").then(({body:e})=>{state.knowledge=e},e=>_error(\"GET\",\"/knowledge\",e))}function send_message(e=\"\",t){request.post(\"/respond\").send(e).then(({body:e})=>{state.conversation.push({text:e[0]})},e=>{_error(\"POST\",\"/respond\",e),t&&t()})}function _const(e,t,n){return Object.defineProperty(e,t,{value:n,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),get_knowledge(),$(\".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,is_user:!0}),send_message(t,()=>{state.error=!0}),get_knowledge(),!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){$(e).on(\"input.rivets\",this.publish)},unbind:function(e){$(e).off(\"input.rivets\")},routine:function(e,t){\"publish\"!=this.state&&(e.innerText=t),state.error=!1,this.empty_class&&$(e).toggleClass(this.empty_class,\"\"==t)},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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","\"use strict\";module.exports=function(r){return null==r?[]:Array.isArray(r)?r:[r]};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJ2YWwiLCJBcnJheSIsImlzQXJyYXkiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0FBLE9BQU9DLFFBQVUsU0FBVUMsR0FDMUIsT0FBSUEsTUFBQUEsRUFDSSxHQUdEQyxNQUFNQyxRQUFRRixHQUFPQSxFQUFNLENBQUNBIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXGFycmlmeVxcaW5kZXguanMifQ==","!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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImhhc093biIsImhhc093blByb3BlcnR5IiwiY2xhc3NOYW1lcyIsImNsYXNzZXMiLCJpIiwiYXJndW1lbnRzIiwibGVuZ3RoIiwiYXJnIiwiYXJnVHlwZSIsInB1c2giLCJBcnJheSIsImlzQXJyYXkiLCJpbm5lciIsImFwcGx5Iiwia2V5IiwiY2FsbCIsImpvaW4iLCJtb2R1bGUiLCJleHBvcnRzIiwiZGVmYXVsdCIsImRlZmluZSIsImFtZCIsIndpbmRvdyJdLCJtYXBwaW5ncyI6IkNBT0MsV0FDQSxhQUVBLElBQUlBLEVBQVMsR0FBR0MsZUFFaEIsU0FBU0MsSUFHUixJQUZBLElBQUlDLEVBQVUsR0FFTEMsRUFBSSxFQUFHQSxFQUFJQyxVQUFVQyxPQUFRRixJQUFLLENBQzFDLElBQUlHLEVBQU1GLFVBQVVELEdBQ3BCLEdBQUtHLEVBQUwsQ0FFQSxJQUFJQyxTQUFpQkQsRUFFckIsR0FBZ0IsV0FBWkMsR0FBb0MsV0FBWkEsRUFDM0JMLEVBQVFNLEtBQUtGLFFBQ1AsR0FBSUcsTUFBTUMsUUFBUUosSUFBUUEsRUFBSUQsT0FBUSxDQUM1QyxJQUFJTSxFQUFRVixFQUFXVyxNQUFNLEtBQU1OLEdBQy9CSyxHQUNIVCxFQUFRTSxLQUFLRyxRQUVSLEdBQWdCLFdBQVpKLEVBQ1YsSUFBSyxJQUFJTSxLQUFPUCxFQUNYUCxFQUFPZSxLQUFLUixFQUFLTyxJQUFRUCxFQUFJTyxJQUNoQ1gsRUFBUU0sS0FBS0ssSUFNakIsT0FBT1gsRUFBUWEsS0FBSyxLQUdDLG9CQUFYQyxRQUEwQkEsT0FBT0MsU0FDM0NoQixFQUFXaUIsUUFBVWpCLEVBQ3JCZSxPQUFPQyxRQUFVaEIsR0FDVyxtQkFBWGtCLFFBQStDLGlCQUFmQSxPQUFPQyxLQUFvQkQsT0FBT0MsSUFFbkZELE9BQU8sYUFBYyxHQUFJLFdBQ3hCLE9BQU9sQixJQUdSb0IsT0FBT3BCLFdBQWFBLEVBMUN0QiIsImZpbGUiOiJFOlxcd29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxjbGFzc25hbWVzXFxpbmRleC5qcyJ9","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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImFycmlmeSIsInJlcXVpcmUiLCJpc1BsYWluT2JqZWN0IiwiY2xhc3NOYW1lcyIsInJlbmRlciIsInV0aWxzIiwiaCIsInNlbGVjdG9yIiwiYXR0cnMiLCJjaGlsZHJlbiIsInBhcnRzIiwiZ2V0U2VsZWN0b3JQYXJ0cyIsImlkIiwiY2xhc3NlcyIsImxlbmd0aCIsImNsYXNzIiwidGFnIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6IkFBQUEsYUFDQSxNQUFNQSxPQUFTQyxRQUFRLFVBQ2pCQyxjQUFnQkQsUUFBUSxtQkFDeEJFLFdBQWFGLFFBQVEsY0FDckJHLE9BQVNILFFBQVEsWUFDakJJLE1BQVFKLFFBQVEsV0FFaEJLLEVBQUksQ0FBQ0MsRUFBVUMsRUFBT0MsS0FDdkJELElBQVVOLGNBQWNNLElBQzNCQyxFQUFXRCxFQUNYQSxFQUFRLElBQ0dBLElBQ1hBLEVBQVEsSUFFVEMsRUFBV1QsT0FBT1MsR0FDbEIsTUFBTUMsRUFBUUwsTUFBTU0saUJBQWlCSixHQU9yQyxPQU5JRyxFQUFNRSxLQUNUSixFQUFNSSxHQUFLRixFQUFNRSxJQUVkRixFQUFNRyxRQUFRQyxTQUNqQk4sRUFBTU8sTUFBUVosV0FBV0ssRUFBTU8sTUFBT0wsRUFBTUcsVUFFdENULE9BQU9NLEVBQU1NLElBQUtSLEVBQU9DLElBR2pDUSxPQUFPQyxRQUFVQSxRQUFVWiIsImZpbGUiOiJFOlxcd29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxoeXBlcnNjcmlwdC1zdHJpbmdcXHNyY1xcaW5kZXguanMifQ==","\"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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlbmRlci5qcyJdLCJuYW1lcyI6WyJ2b2lkRWxlbWVudHMiLCJyZXF1aXJlIiwiYXJyaWZ5IiwicmVuZGVyQXR0cmlidXRlcyIsImF0dHJzIiwiT2JqZWN0Iiwia2V5cyIsImZpbHRlciIsIm5hbWUiLCJ1bmRlZmluZWQiLCJtYXAiLCJqb2luIiwicmVuZGVyQ2hpbGRyZW4iLCJjaGlsZHJlbiIsImxlbmd0aCIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0EsTUFBTUEsYUFBZUMsUUFBUSxpQkFDdkJDLE9BQVNELFFBQVEsVUFTdkIsU0FBU0UsaUJBQWlCQyxHQWF6QixPQVpBQSxFQUFRQyxPQUFPQyxLQUFLRixHQUNsQkcsT0FBT0MsUUFDU0MsSUFBaEJMLEVBQU1JLElBQ1UsT0FBaEJKLEVBQU1JLEtBQ1UsSUFBaEJKLEVBQU1JLElBRU5FLElBQUlGLElBQ1ksSUFBaEJKLEVBQU1JLEdBQ05BLEtBQ0dBLE1BQVNKLEVBQU1JLE9BRWxCRyxLQUFLLFVBRUtQLElBRUwsR0FHUixTQUFTUSxlQUFlQyxHQUV2QixPQUF3QixLQUR4QkEsRUFBV1gsT0FBT1csSUFDTEMsT0FDTCxHQUN1QixJQUFwQkQsRUFBU0MsT0FDWkQsRUFBUyxVQUVIQSxFQUFTRixLQUFLLFlBakM3QkksT0FBT0MsUUFBVUEsUUFBVSxTQUFnQlIsRUFBTUosRUFBT1MsR0FDdkQsTUFBYSxhQUFUTCxHQUF1QlIsYUFBYVEsT0FDNUJBLElBQU9MLGlCQUFpQkMsVUFFekJJLElBQU9MLGlCQUFpQkMsTUFBVVEsZUFBZUMsT0FBY0wiLCJmaWxlIjoiRTpcXHdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaHlwZXJzY3JpcHQtc3RyaW5nXFxzcmNcXHJlbmRlci5qcyJ9","\"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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInV0aWxzLmpzIl0sIm5hbWVzIjpbIlNFTEVDVE9SX1JFR0VYIiwiZ2V0VGFnIiwibWF0Y2hlcyIsInRvTG93ZXJDYXNlIiwiZ2V0Q2xhc3NlcyIsImZpbHRlciIsImlzQ2xhc3MiLCJtYXAiLCJzbGljZSIsImdldElkIiwiaXNJZCIsImEiLCJiIiwidmFsIiwic3RyIiwiZXhwb3J0cyIsImdldFNlbGVjdG9yUGFydHMiLCJzZWxlY3RvciIsIm1hdGNoIiwiRXJyb3IiLCJ0YWciLCJpZCIsImNsYXNzZXMiXSwibWFwcGluZ3MiOiJBQUFBLGFBQ0EsTUFBTUEsZUFBaUIsbUJBY3ZCLFNBQVNDLE9BQU9DLEdBQ2YsTUFBc0IsTUFBbEJBLEVBQVEsR0FBRyxJQUFnQyxNQUFsQkEsRUFBUSxHQUFHLEdBQ2hDLE1BRURBLEVBQVEsR0FBR0MsY0FHbkIsU0FBU0MsV0FBV0YsR0FDbkIsT0FBT0EsRUFBUUcsT0FBT0MsU0FBU0MsSUFBSUMsTUFBTSxJQUcxQyxTQUFTQyxNQUFNUCxHQUNkLE9BQU9BLEVBQVFHLE9BQU9LLE1BQU1ILElBQUlDLE1BQU0sSUFBSSxHQUczQyxTQUFTQSxNQUFNRyxFQUFHQyxHQUNqQixPQUFPQyxHQUFPQSxFQUFJTCxNQUFNRyxFQUFHQyxHQUc1QixTQUFTRixLQUFLSSxHQUNiLE1BQWtCLE1BQVhBLEVBQUksR0FHWixTQUFTUixRQUFRUSxHQUNoQixNQUFrQixNQUFYQSxFQUFJLEdBcENaQyxRQUFRQyxpQkFBbUIsQ0FBQ0MsSUFDM0IsTUFBTWYsRUFBVWUsRUFBU0MsTUFBTWxCLGdCQUMvQixJQUFLRSxFQUNKLE1BQU0sSUFBSWlCLHFGQUFxRkYsTUFFaEcsTUFBTyxDQUNORyxJQUFLbkIsT0FBT0MsR0FDWm1CLEdBQUlaLE1BQU1QLEdBQ1ZvQixRQUFTbEIsV0FBV0YiLCJmaWxlIjoiRTpcXHdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaHlwZXJzY3JpcHQtc3RyaW5nXFxzcmNcXHV0aWxzLmpzIn0=","\"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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImlzT2JqZWN0IiwicmVxdWlyZSIsImlzT2JqZWN0T2JqZWN0IiwibyIsIk9iamVjdCIsInByb3RvdHlwZSIsInRvU3RyaW5nIiwiY2FsbCIsIm1vZHVsZSIsImV4cG9ydHMiLCJjdG9yIiwicHJvdCIsImNvbnN0cnVjdG9yIiwiaGFzT3duUHJvcGVydHkiXSwibWFwcGluZ3MiOiJBQU9BLGFBRUEsSUFBSUEsU0FBV0MsUUFBUSxZQUV2QixTQUFTQyxlQUFlQyxHQUN0QixPQUF1QixJQUFoQkgsU0FBU0csSUFDMkIsb0JBQXRDQyxPQUFPQyxVQUFVQyxTQUFTQyxLQUFLSixHQUd0Q0ssT0FBT0MsUUFBVSxTQUF1Qk4sR0FDdEMsSUFBSU8sRUFBS0MsRUFFVCxPQUEwQixJQUF0QlQsZUFBZUMsS0FJQyxtQkFEcEJPLEVBQU9QLEVBQUVTLGdCQUtvQixJQUF6QlYsZUFESlMsRUFBT0QsRUFBS0wsYUFJaUMsSUFBekNNLEVBQUtFLGVBQWUiLCJmaWxlIjoiRTpcXHdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcaXMtcGxhaW4tb2JqZWN0XFxpbmRleC5qcyJ9","\"use strict\";module.exports=function(r){return null!=r&&\"object\"==typeof r&&!1===Array.isArray(r)};\n\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJ2YWwiLCJBcnJheSIsImlzQXJyYXkiXSwibWFwcGluZ3MiOiJBQU9BLGFBRUFBLE9BQU9DLFFBQVUsU0FBa0JDLEdBQ2pDLE9BQWMsTUFBUEEsR0FBOEIsaUJBQVJBLElBQTJDLElBQXZCQyxNQUFNQyxRQUFRRiIsImZpbGUiOiJFOlxcd29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxpc29iamVjdFxcaW5kZXguanMifQ==","(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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFnZW50LWJhc2UuanMiXSwibmFtZXMiOlsiQWdlbnQiLCJ0aGlzIiwiX2RlZmF1bHRzIiwiZm9yRWFjaCIsImZuIiwicHJvdG90eXBlIiwiYXJncyIsInB1c2giLCJfc2V0RGVmYXVsdHMiLCJyZXEiLCJkZWYiLCJhcHBseSIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFFBQ1BDLEtBQUtDLFVBQVksR0FHbkIsQ0FBQyxNQUFPLEtBQU0sT0FBUSxNQUFPLFFBQVMsT0FBUSxTQUFVLE9BQVEsa0JBQW1CLFlBQWEsUUFBUyxLQUFNLFlBQzlHLFVBQVcsU0FBVSxZQUFhLFFBQVMsS0FBTSxNQUFPLE1BQU8sUUFBUUMsUUFBUUMsSUFFOUVKLE1BQU1LLFVBQVVELEdBQU0sWUFBWUUsR0FFaEMsT0FEQUwsS0FBS0MsVUFBVUssS0FBSyxDQUFDSCxHQUFBQSxFQUFJRSxLQUFBQSxJQUNsQkwsUUFJWEQsTUFBTUssVUFBVUcsYUFBZSxTQUFTQyxHQUNwQ1IsS0FBS0MsVUFBVUMsUUFBUU8sSUFDckJELEVBQUlDLEVBQUlOLElBQUlPLE1BQU1GLEVBQUtDLEVBQUlKLFNBSWpDTSxPQUFPQyxRQUFVYiIsImZpbGUiOiJFOlxcd29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxzdXBlcmFnZW50XFxsaWJcXGFnZW50LWJhc2UuanMifQ==","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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlzLW9iamVjdC5qcyJdLCJuYW1lcyI6WyJpc09iamVjdCIsIm9iaiIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiJBQUFBLGFBVUEsU0FBU0EsU0FBU0MsR0FDaEIsT0FBTyxPQUFTQSxHQUFPLGlCQUFvQkEsRUFHN0NDLE9BQU9DLFFBQVVIIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHN1cGVyYWdlbnRcXGxpYlxcaXMtb2JqZWN0LmpzIn0=","\"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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlc3BvbnNlLWJhc2UuanMiXSwibmFtZXMiOlsidXRpbHMiLCJyZXF1aXJlIiwiUmVzcG9uc2VCYXNlIiwib2JqIiwibWl4aW4iLCJrZXkiLCJwcm90b3R5cGUiLCJtb2R1bGUiLCJleHBvcnRzIiwiZ2V0IiwiZmllbGQiLCJ0aGlzIiwiaGVhZGVyIiwidG9Mb3dlckNhc2UiLCJfc2V0SGVhZGVyUHJvcGVydGllcyIsImN0IiwidHlwZSIsInBhcmFtcyIsImxpbmtzIiwibGluayIsInBhcnNlTGlua3MiLCJlcnIiLCJfc2V0U3RhdHVzUHJvcGVydGllcyIsInN0YXR1cyIsInN0YXR1c0NvZGUiLCJzdGF0dXNUeXBlIiwiaW5mbyIsIm9rIiwicmVkaXJlY3QiLCJjbGllbnRFcnJvciIsInNlcnZlckVycm9yIiwiZXJyb3IiLCJ0b0Vycm9yIiwiY3JlYXRlZCIsImFjY2VwdGVkIiwibm9Db250ZW50IiwiYmFkUmVxdWVzdCIsInVuYXV0aG9yaXplZCIsIm5vdEFjY2VwdGFibGUiLCJmb3JiaWRkZW4iLCJub3RGb3VuZCIsInVucHJvY2Vzc2FibGVFbnRpdHkiXSwibWFwcGluZ3MiOiJBQUFBLGFBTUEsTUFBTUEsTUFBUUMsUUFBUSxXQWN0QixTQUFTQyxhQUFhQyxHQUNwQixHQUFJQSxFQUFLLE9BQU9DLE1BQU1ELEdBV3hCLFNBQVNDLE1BQU1ELEdBQ2IsSUFBSyxNQUFNRSxLQUFPSCxhQUFhSSxVQUM3QkgsRUFBSUUsR0FBT0gsYUFBYUksVUFBVUQsR0FFcEMsT0FBT0YsRUF4QlRJLE9BQU9DLFFBQVVOLGFBbUNqQkEsYUFBYUksVUFBVUcsSUFBTSxTQUFTQyxHQUNwQyxPQUFPQyxLQUFLQyxPQUFPRixFQUFNRyxnQkFlM0JYLGFBQWFJLFVBQVVRLHFCQUF1QixTQUFTRixHQUtuRCxNQUFNRyxFQUFLSCxFQUFPLGlCQUFtQixHQUNyQ0QsS0FBS0ssS0FBT2hCLE1BQU1nQixLQUFLRCxHQUd2QixNQUFNRSxFQUFTakIsTUFBTWlCLE9BQU9GLEdBQzVCLElBQUssTUFBTVYsS0FBT1ksRUFBUU4sS0FBS04sR0FBT1ksRUFBT1osR0FFN0NNLEtBQUtPLE1BQVEsR0FHYixJQUNRTixFQUFPTyxPQUNQUixLQUFLTyxNQUFRbEIsTUFBTW9CLFdBQVdSLEVBQU9PLE9BRTNDLE1BQU9FLE1BMEJibkIsYUFBYUksVUFBVWdCLHFCQUF1QixTQUFTQyxHQUNuRCxNQUFNUCxFQUFPTyxFQUFTLElBQU0sRUFHNUJaLEtBQUtZLE9BQVNaLEtBQUthLFdBQWFELEVBQ2hDWixLQUFLYyxXQUFhVCxFQUdsQkwsS0FBS2UsS0FBTyxHQUFLVixFQUNqQkwsS0FBS2dCLEdBQUssR0FBS1gsRUFDZkwsS0FBS2lCLFNBQVcsR0FBS1osRUFDckJMLEtBQUtrQixZQUFjLEdBQUtiLEVBQ3hCTCxLQUFLbUIsWUFBYyxHQUFLZCxFQUN4QkwsS0FBS29CLE9BQVMsR0FBS2YsR0FBUSxHQUFLQSxJQUMxQkwsS0FBS3FCLFVBSVhyQixLQUFLc0IsUUFBVSxLQUFPVixFQUN0QlosS0FBS3VCLFNBQVcsS0FBT1gsRUFDdkJaLEtBQUt3QixVQUFZLEtBQU9aLEVBQ3hCWixLQUFLeUIsV0FBYSxLQUFPYixFQUN6QlosS0FBSzBCLGFBQWUsS0FBT2QsRUFDM0JaLEtBQUsyQixjQUFnQixLQUFPZixFQUM1QlosS0FBSzRCLFVBQVksS0FBT2hCLEVBQ3hCWixLQUFLNkIsU0FBVyxLQUFPakIsRUFDdkJaLEtBQUs4QixvQkFBc0IsS0FBT2xCIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHN1cGVyYWdlbnRcXGxpYlxccmVzcG9uc2UtYmFzZS5qcyJ9","\"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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInV0aWxzLmpzIl0sIm5hbWVzIjpbImV4cG9ydHMiLCJ0eXBlIiwic3RyIiwic3BsaXQiLCJzaGlmdCIsInBhcmFtcyIsInJlZHVjZSIsIm9iaiIsInBhcnRzIiwia2V5IiwidmFsIiwicGFyc2VMaW5rcyIsInVybCIsInNsaWNlIiwiY2xlYW5IZWFkZXIiLCJoZWFkZXIiLCJjaGFuZ2VzT3JpZ2luIl0sIm1hcHBpbmdzIjoiQUFBQSxhQVVBQSxRQUFRQyxLQUFPQyxDQUFBQSxHQUFPQSxFQUFJQyxNQUFNLFNBQVNDLFNBVXpDSixRQUFRSyxPQUFTSCxDQUFBQSxHQUFPQSxFQUFJQyxNQUFNLFNBQVNHLE9BQU8sQ0FBQ0MsRUFBS0wsS0FDdEQsTUFBTU0sRUFBUU4sRUFBSUMsTUFBTSxTQUNsQk0sRUFBTUQsRUFBTUosUUFDWk0sRUFBTUYsRUFBTUosUUFHbEIsT0FESUssR0FBT0MsSUFBS0gsRUFBSUUsR0FBT0MsR0FDcEJILEdBQ04sS0FVSFAsUUFBUVcsV0FBYVQsQ0FBQUEsR0FBT0EsRUFBSUMsTUFBTSxTQUFTRyxPQUFPLENBQUNDLEVBQUtMLEtBQzFELE1BQU1NLEVBQVFOLEVBQUlDLE1BQU0sU0FDbEJTLEVBQU1KLEVBQU0sR0FBR0ssTUFBTSxHQUFJLEdBRy9CLE9BREFOLEVBRFlDLEVBQU0sR0FBR0wsTUFBTSxTQUFTLEdBQUdVLE1BQU0sR0FBSSxJQUN0Q0QsRUFDSkwsR0FDTixLQVVIUCxRQUFRYyxZQUFjLEVBQUNDLEVBQVFDLFlBQ3RCRCxFQUFPLHVCQUNQQSxFQUFPLHlCQUNQQSxFQUFPLDRCQUNQQSxFQUFhLEtBRWhCQyxXQUNLRCxFQUFzQixxQkFDdEJBLEVBQWUsUUFFakJBIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHN1cGVyYWdlbnRcXGxpYlxcdXRpbHMuanMifQ==","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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbInRvU3RyaW5nIiwiT2JqZWN0IiwicHJvdG90eXBlIiwibW9kdWxlIiwiZXhwb3J0cyIsInZhbCIsImNhbGwiLCJsZW5ndGgiLCJjYWxsZWUiLCJleCIsIlR5cGVFcnJvciIsInVuZGVmaW5lZCIsIm5vZGVUeXBlIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxTQUFXQyxPQUFPQyxVQUFVRixTQUVoQ0csT0FBT0MsUUFBVSxTQUFTQyxHQUN4QixPQUFRTCxTQUFTTSxLQUFLRCxJQUNwQixJQUFLLG9CQUFxQixNQUFPLFdBQ2pDLElBQUssZ0JBQWlCLE1BQU8sT0FDN0IsSUFBSyxrQkFBbUIsTUFBTyxTQUMvQixJQUFLLHFCQUFzQixNQUFPLFlBQ2xDLElBQUssaUJBQWtCLE1BQU8sUUFDOUIsSUFBSyxrQkFBbUIsTUFBTyxTQUdqQyxHQUFrQixpQkFBUEEsR0FBbUJBLEdBQTRCLGlCQUFkQSxFQUFJRSxPQUM5QyxJQUNFLEdBQXlCLG1CQUFkRixFQUFJRyxPQUFzQixNQUFPLFlBQzVDLE1BQU9DLEdBQ1AsR0FBSUEsYUFBY0MsVUFDaEIsTUFBTyxZQUtiLE9BQVksT0FBUkwsRUFBcUIsWUFDYk0sSUFBUk4sRUFBMEIsWUFDMUJBLEdBQXdCLElBQWpCQSxFQUFJTyxTQUF1QixVQUNsQ1AsSUFBUUosT0FBT0ksR0FBYSxnQkFFbEJBIiwiZmlsZSI6IkU6XFx3b3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHR5cGUtb2ZcXGluZGV4LmpzIn0=","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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJhcmVhIiwiYmFzZSIsImJyIiwiY29sIiwiZW1iZWQiLCJociIsImltZyIsImlucHV0Iiwia2V5Z2VuIiwibGluayIsIm1lbnVpdGVtIiwibWV0YSIsInBhcmFtIiwic291cmNlIiwidHJhY2siLCJ3YnIiXSwibWFwcGluZ3MiOiJBQUtBQSxPQUFPQyxRQUFVLENBQ2ZDLE1BQVEsRUFDUkMsTUFBUSxFQUNSQyxJQUFNLEVBQ05DLEtBQU8sRUFDUEMsT0FBUyxFQUNUQyxJQUFNLEVBQ05DLEtBQU8sRUFDUEMsT0FBUyxFQUNUQyxRQUFVLEVBQ1ZDLE1BQVEsRUFDUkMsVUFBWSxFQUNaQyxNQUFRLEVBQ1JDLE9BQVMsRUFDVEMsUUFBVSxFQUNWQyxPQUFTLEVBQ1RDLEtBQU8iLCJmaWxlIjoiRTpcXHdvcmtzcGFjZVxcd2lraWEtaXMtYW5zd2VyZWRcXG5vZGVfbW9kdWxlc1xcdm9pZC1lbGVtZW50c1xcaW5kZXguanMifQ=="]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","app.js","node_modules/arrify/index.js","node_modules/classnames/index.js","node_modules/component-emitter/index.js","node_modules/domtastic/dist/domtastic.js","node_modules/hyperscript-string/src/index.js","node_modules/hyperscript-string/src/render.js","node_modules/hyperscript-string/src/utils.js","node_modules/is-plain-object/index.js","node_modules/isobject/index.js","node_modules/rivets/dist/rivets.js","node_modules/sightglass/index.js","node_modules/superagent/lib/agent-base.js","node_modules/superagent/lib/client.js","node_modules/superagent/lib/is-object.js","node_modules/superagent/lib/request-base.js","node_modules/superagent/lib/response-base.js","node_modules/superagent/lib/utils.js","node_modules/type-of/index.js","node_modules/void-elements/index.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\";const type=require(\"type-of\"),request=require(\"superagent\"),h=require(\"hyperscript-string\"),$=require(\"domtastic\"),rivets=require(\"rivets\");$.fn.innerText=function(e){return void 0===e?this[0].innerText:this.forEach(function(t){return t.innerText=\"\"+e})},$.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:n}){n=n?[n.status,n.text]:[],console.warn(`[${e} ${t}]`,...n)}function get_knowledge(){request.get(\"/knowledge\").then(({body:e})=>{state.knowledge=e},e=>_error(\"GET\",\"/knowledge\",e))}function send_message(e=\"\",t){request.post(\"/message\").send(e).then(({text:e})=>{state.conversation.push({text:e})},e=>{_error(\"POST\",\"/message\",e),t&&t()})}function _const(e,t,n){return Object.defineProperty(e,t,{value:n,writable:!1,enumerable:!0,configurable:!0}),e}send_message(),get_knowledge(),$(\".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,is_user:!0}),send_message(t,()=>{state.error=!0}),get_knowledge(),!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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","\"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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImFycmlmeSIsInJlcXVpcmUiLCJpc1BsYWluT2JqZWN0IiwiY2xhc3NOYW1lcyIsInJlbmRlciIsInV0aWxzIiwiaCIsInNlbGVjdG9yIiwiYXR0cnMiLCJjaGlsZHJlbiIsInBhcnRzIiwiZ2V0U2VsZWN0b3JQYXJ0cyIsImlkIiwiY2xhc3NlcyIsImxlbmd0aCIsImNsYXNzIiwidGFnIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6IkFBQUEsYUFDQSxNQUFNQSxPQUFTQyxRQUFRLFVBQ2pCQyxjQUFnQkQsUUFBUSxtQkFDeEJFLFdBQWFGLFFBQVEsY0FDckJHLE9BQVNILFFBQVEsWUFDakJJLE1BQVFKLFFBQVEsV0FFaEJLLEVBQUksQ0FBQ0MsRUFBVUMsRUFBT0MsS0FDdkJELElBQVVOLGNBQWNNLElBQzNCQyxFQUFXRCxFQUNYQSxFQUFRLElBQ0dBLElBQ1hBLEVBQVEsSUFFVEMsRUFBV1QsT0FBT1MsR0FDbEIsTUFBTUMsRUFBUUwsTUFBTU0saUJBQWlCSixHQU9yQyxPQU5JRyxFQUFNRSxLQUNUSixFQUFNSSxHQUFLRixFQUFNRSxJQUVkRixFQUFNRyxRQUFRQyxTQUNqQk4sRUFBTU8sTUFBUVosV0FBV0ssRUFBTU8sTUFBT0wsRUFBTUcsVUFFdENULE9BQU9NLEVBQU1NLElBQUtSLEVBQU9DLElBR2pDUSxPQUFPQyxRQUFVQSxRQUFVWiIsImZpbGUiOiJFOlxcV29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxoeXBlcnNjcmlwdC1zdHJpbmdcXHNyY1xcaW5kZXguanMifQ==","\"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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbInNpZ2h0Z2xhc3MiLCJvYmoiLCJrZXlwYXRoIiwiY2FsbGJhY2siLCJvcHRpb25zIiwiT2JzZXJ2ZXIiLCJ0aGlzIiwiYWRhcHRlcnMiLCJvYmplY3RQYXRoIiwidXBkYXRlIiwiYmluZCIsInBhcnNlIiwiaXNPYmplY3QiLCJ0YXJnZXQiLCJyZWFsaXplIiwic2V0Iiwia2V5IiwiZXJyb3IiLCJtZXNzYWdlIiwiRXJyb3IiLCJ0b2tlbml6ZSIsImludGVyZmFjZXMiLCJyb290IiwiaW5kZXgiLCJjaHIiLCJ0b2tlbnMiLCJjdXJyZW50IiwiaSIsInBhdGgiLCJsZW5ndGgiLCJjaGFyQXQiLCJpbmRleE9mIiwicHVzaCIsInByb3RvdHlwZSIsInN1YnN0ciIsInBvcCIsInByZXYiLCJ1bnJlYWNoZWQiLCJmb3JFYWNoIiwidG9rZW4iLCJnZXQiLCJzcGxpY2UiLCJuZXh0Iiwib2xkVmFsdWUiLCJ2YWx1ZSIsIkZ1bmN0aW9uIiwic2V0VmFsdWUiLCJhZGFwdGVyIiwiYWN0aXZlIiwiYWN0aW9uIiwiT2JqZWN0Iiwia2V5cyIsInVub2JzZXJ2ZSIsIm1vZHVsZSIsImV4cG9ydHMiLCJkZWZpbmUiLCJhbWQiLCJjYWxsIl0sIm1hcHBpbmdzIjoiQ0FBQSxXQUVFLFNBQVNBLEVBQVdDLEVBQUtDLEVBQVNDLEVBQVVDLEdBQzFDLE9BQU8sSUFBSUMsRUFBU0osRUFBS0MsRUFBU0MsRUFBVUMsR0FPOUMsU0FBU0MsRUFBU0osRUFBS0MsRUFBU0MsRUFBVUMsR0FDeENFLEtBQUtGLFFBQVVBLEdBQVcsR0FDMUJFLEtBQUtGLFFBQVFHLFNBQVdELEtBQUtGLFFBQVFHLFVBQVksR0FDakRELEtBQUtMLElBQU1BLEVBQ1hLLEtBQUtKLFFBQVVBLEVBQ2ZJLEtBQUtILFNBQVdBLEVBQ2hCRyxLQUFLRSxXQUFhLEdBQ2xCRixLQUFLRyxPQUFTSCxLQUFLRyxPQUFPQyxLQUFLSixNQUMvQkEsS0FBS0ssUUFFREMsRUFBU04sS0FBS08sT0FBU1AsS0FBS1EsWUFDOUJSLEtBQUtTLEtBQUksRUFBTVQsS0FBS1UsSUFBS1YsS0FBS08sT0FBUVAsS0FBS0gsVUE2Sy9DLFNBQVNTLEVBQVNYLEdBQ2hCLE1BQXNCLGlCQUFSQSxHQUE0QixPQUFSQSxFQUlwQyxTQUFTZ0IsRUFBTUMsR0FDYixNQUFNLElBQUlDLE1BQU0sZ0JBQWtCRCxHQWpNcENsQixFQUFXTyxTQUFXLEdBb0J0QkYsRUFBU2UsU0FBVyxTQUFTbEIsRUFBU21CLEVBQVlDLEdBQ2hELElBRUlDLEVBQU9DLEVBRlBDLEVBQVMsR0FDVEMsRUFBVSxDQUFDQyxFQUFHTCxFQUFNTSxLQUFNLElBRzlCLElBQUtMLEVBQVEsRUFBR0EsRUFBUXJCLEVBQVEyQixPQUFRTixJQUN0Q0MsRUFBTXRCLEVBQVE0QixPQUFPUCxJQUVkRixFQUFXVSxRQUFRUCxJQUN4QkMsRUFBT08sS0FBS04sR0FDWkEsRUFBVSxDQUFDQyxFQUFHSCxFQUFLSSxLQUFNLEtBRXpCRixFQUFRRSxNQUFRSixFQUtwQixPQURBQyxFQUFPTyxLQUFLTixHQUNMRCxHQUtUcEIsRUFBUzRCLFVBQVV0QixNQUFRLFdBQ3pCLElBQ0lXLEVBQU1NLEVBRE5QLEVBQWFmLEtBQUtlLGFBR2pCQSxFQUFXUSxRQUNkWixFQUFNLGdEQUdESSxFQUFXVSxRQUFRekIsS0FBS0osUUFBUSxLQUNyQ29CLEVBQU9oQixLQUFLSixRQUFRLEdBQ3BCMEIsRUFBT3RCLEtBQUtKLFFBQVFnQyxPQUFPLFVBRWtDLEtBQWpEWixFQUFPaEIsS0FBS0YsUUFBUWtCLE1BQVF0QixFQUFXc0IsT0FDakRMLEVBQU0sdUNBR1JXLEVBQU90QixLQUFLSixTQUdkSSxLQUFLbUIsT0FBU3BCLEVBQVNlLFNBQVNRLEVBQU1QLEVBQVlDLEdBQ2xEaEIsS0FBS1UsSUFBTVYsS0FBS21CLE9BQU9VLE9BS3pCOUIsRUFBUzRCLFVBQVVuQixRQUFVLFdBQzNCLElBRUlzQixFQUZBVixFQUFVcEIsS0FBS0wsSUFDZm9DLEdBQVksRUFnQ2hCLE9BN0JBL0IsS0FBS21CLE9BQU9hLFFBQVEsU0FBU0MsRUFBT2hCLEdBQzlCWCxFQUFTYyxTQUMyQixJQUEzQnBCLEtBQUtFLFdBQVdlLEdBQ3JCRyxLQUFhVSxFQUFPOUIsS0FBS0UsV0FBV2UsTUFDdENqQixLQUFLUyxLQUFJLEVBQU93QixFQUFPSCxFQUFNOUIsS0FBS0csUUFDbENILEtBQUtTLEtBQUksRUFBTXdCLEVBQU9iLEVBQVNwQixLQUFLRyxRQUNwQ0gsS0FBS0UsV0FBV2UsR0FBU0csSUFHM0JwQixLQUFLUyxLQUFJLEVBQU13QixFQUFPYixFQUFTcEIsS0FBS0csUUFDcENILEtBQUtFLFdBQVdlLEdBQVNHLEdBRzNCQSxFQUFVcEIsS0FBS2tDLElBQUlELEVBQU9iLE1BRVIsSUFBZFcsSUFDRkEsRUFBWWQsSUFHVmEsRUFBTzlCLEtBQUtFLFdBQVdlLEtBQ3pCakIsS0FBS1MsS0FBSSxFQUFPd0IsRUFBT0gsRUFBTTlCLEtBQUtHLFVBR3JDSCxPQUVlLElBQWQrQixHQUNGL0IsS0FBS0UsV0FBV2lDLE9BQU9KLEdBR2xCWCxHQUlUckIsRUFBUzRCLFVBQVV4QixPQUFTLFdBQzFCLElBQUlpQyxFQUFNQyxHQUVMRCxFQUFPcEMsS0FBS1EsYUFBZVIsS0FBS08sU0FDL0JELEVBQVNOLEtBQUtPLFNBQ2hCUCxLQUFLUyxLQUFJLEVBQU9ULEtBQUtVLElBQUtWLEtBQUtPLE9BQVFQLEtBQUtILFVBRzFDUyxFQUFTOEIsSUFDWHBDLEtBQUtTLEtBQUksRUFBTVQsS0FBS1UsSUFBSzBCLEVBQU1wQyxLQUFLSCxVQUd0Q3dDLEVBQVdyQyxLQUFLc0MsUUFDaEJ0QyxLQUFLTyxPQUFTNkIsR0FHVnBDLEtBQUtzQyxrQkFBbUJDLFVBQVl2QyxLQUFLc0MsVUFBWUQsSUFBVXJDLEtBQUtILGFBTTVFRSxFQUFTNEIsVUFBVVcsTUFBUSxXQUN6QixHQUFJaEMsRUFBU04sS0FBS08sUUFDaEIsT0FBT1AsS0FBS2tDLElBQUlsQyxLQUFLVSxJQUFLVixLQUFLTyxTQU1uQ1IsRUFBUzRCLFVBQVVhLFNBQVcsU0FBU0YsR0FDakNoQyxFQUFTTixLQUFLTyxTQUNoQlAsS0FBS3lDLFFBQVF6QyxLQUFLVSxLQUFLRCxJQUFJVCxLQUFLTyxPQUFRUCxLQUFLVSxJQUFJWSxLQUFNZ0IsSUFLM0R2QyxFQUFTNEIsVUFBVU8sSUFBTSxTQUFTeEIsRUFBS2YsR0FDckMsT0FBT0ssS0FBS3lDLFFBQVEvQixHQUFLd0IsSUFBSXZDLEVBQUtlLEVBQUlZLE9BSXhDdkIsRUFBUzRCLFVBQVVsQixJQUFNLFNBQVNpQyxFQUFRaEMsRUFBS2YsRUFBS0UsR0FDbEQsSUFBSThDLEVBQVNELEVBQVMsVUFBWSxZQUNsQzFDLEtBQUt5QyxRQUFRL0IsR0FBS2lDLEdBQVFoRCxFQUFLZSxFQUFJWSxLQUFNekIsSUFJM0NFLEVBQVM0QixVQUFVWixXQUFhLFdBQzlCLElBQUlBLEVBQWE2QixPQUFPQyxLQUFLN0MsS0FBS0YsUUFBUUcsVUFRMUMsT0FOQTJDLE9BQU9DLEtBQUtuRCxFQUFXTyxVQUFVK0IsUUFBUSxTQUFTWCxJQUMxQ04sRUFBV1UsUUFBUUosSUFDdkJOLEVBQVdXLEtBQUtMLEtBSWJOLEdBSVRoQixFQUFTNEIsVUFBVWMsUUFBVSxTQUFTL0IsR0FDcEMsT0FBT1YsS0FBS0YsUUFBUUcsU0FBU1MsRUFBSVcsSUFDL0IzQixFQUFXTyxTQUFTUyxFQUFJVyxJQUk1QnRCLEVBQVM0QixVQUFVbUIsVUFBWSxXQUM3QixJQUFJbkQsRUFFSkssS0FBS21CLE9BQU9hLFFBQVEsU0FBU0MsRUFBT2hCLElBQzlCdEIsRUFBTUssS0FBS0UsV0FBV2UsS0FDeEJqQixLQUFLUyxLQUFJLEVBQU93QixFQUFPdEMsRUFBS0ssS0FBS0csU0FFbENILE1BRUNNLEVBQVNOLEtBQUtPLFNBQ2hCUCxLQUFLUyxLQUFJLEVBQU9ULEtBQUtVLElBQUtWLEtBQUtPLE9BQVFQLEtBQUtILFdBZTFCLG9CQUFYa0QsUUFBMEJBLE9BQU9DLFFBQzFDRCxPQUFPQyxRQUFVdEQsRUFDVSxtQkFBWHVELFFBQXlCQSxPQUFPQyxJQUNoREQsT0FBTyxHQUFJLFdBQ1QsT0FBT2pELEtBQUtOLFdBQWFBLElBRzNCTSxLQUFLTixXQUFhQSxJQUVuQnlELEtBQUtuRCIsImZpbGUiOiJFOlxcV29ya3NwYWNlXFx3aWtpYS1pcy1hbnN3ZXJlZFxcbm9kZV9tb2R1bGVzXFxzaWdodGdsYXNzXFxpbmRleC5qcyJ9","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\\wikia-is-answered\\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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbInRvU3RyaW5nIiwiT2JqZWN0IiwicHJvdG90eXBlIiwibW9kdWxlIiwiZXhwb3J0cyIsInZhbCIsImNhbGwiLCJsZW5ndGgiLCJjYWxsZWUiLCJleCIsIlR5cGVFcnJvciIsInVuZGVmaW5lZCIsIm5vZGVUeXBlIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxTQUFXQyxPQUFPQyxVQUFVRixTQUVoQ0csT0FBT0MsUUFBVSxTQUFTQyxHQUN4QixPQUFRTCxTQUFTTSxLQUFLRCxJQUNwQixJQUFLLG9CQUFxQixNQUFPLFdBQ2pDLElBQUssZ0JBQWlCLE1BQU8sT0FDN0IsSUFBSyxrQkFBbUIsTUFBTyxTQUMvQixJQUFLLHFCQUFzQixNQUFPLFlBQ2xDLElBQUssaUJBQWtCLE1BQU8sUUFDOUIsSUFBSyxrQkFBbUIsTUFBTyxTQUdqQyxHQUFrQixpQkFBUEEsR0FBbUJBLEdBQTRCLGlCQUFkQSxFQUFJRSxPQUM5QyxJQUNFLEdBQXlCLG1CQUFkRixFQUFJRyxPQUFzQixNQUFPLFlBQzVDLE1BQU9DLEdBQ1AsR0FBSUEsYUFBY0MsVUFDaEIsTUFBTyxZQUtiLE9BQVksT0FBUkwsRUFBcUIsWUFDYk0sSUFBUk4sRUFBMEIsWUFDMUJBLEdBQXdCLElBQWpCQSxFQUFJTyxTQUF1QixVQUNsQ1AsSUFBUUosT0FBT0ksR0FBYSxnQkFFbEJBIiwiZmlsZSI6IkU6XFxXb3Jrc3BhY2VcXHdpa2lhLWlzLWFuc3dlcmVkXFxub2RlX21vZHVsZXNcXHR5cGUtb2ZcXGluZGV4LmpzIn0=","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=="]} diff --git a/static/index.html b/static/index.html index a144670..57205e4 100644 --- a/static/index.html +++ b/static/index.html @@ -40,7 +40,10 @@

{ base.caption }

{ item.text }
-
+
+
+ Your message here... +
diff --git a/static/master.css b/static/master.css index cec6fee..520bb4e 100644 --- a/static/master.css +++ b/static/master.css @@ -1,5 +1,10 @@ @import url('https://fonts.googleapis.com/css?family=Nunito'); +:root { + --top: 0; + --left: 0; +} + html { padding: 0; overflow: hidden; @@ -58,18 +63,19 @@ button { } .u-textbox { - background: transparent; - position: relative; - - transition: 0.4s background-color; + word-wrap: break-word; } -.u-textbox:before { - content: attr(placeholder); +/*.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; } @@ -78,11 +84,12 @@ button { display: none; } -.u-textbox.empty:before { +/*.u-textbox.empty:before {*/ +.u-textbox.empty + .u-placeholder { opacity: 1; } -.u-textbox.error { +.error { background: hsl(0deg, 68%, 87%); } @@ -177,10 +184,10 @@ button { display: block; } -.Knowledge-documentCaption { - color: inherit; - text-decoration: none; - font-size: 14px; +.Knowledge-documentCaption { + color: inherit; + text-decoration: none; + font-size: 14px; } .Knowledge-documentCaption:hover { @@ -214,32 +221,41 @@ button { box-sizing: border-box; } -.Converstion-historyItem { - border-radius: 13px; - background: hsl(0deg, 0%, 80%); - padding: 10px; - max-width: 80%; - width: max-content; - align-self: flex-end; - margin-bottom: 10px; - font: inherit; - box-sizing: border-box; - white-space: pre-line; +.Converstion-historyItem { + border-radius: 13px; + background: hsl(0deg, 0%, 80%); + padding: 10px; + max-width: 80%; + width: max-content; + align-self: flex-end; + margin-bottom: 10px; + font: inherit; + box-sizing: border-box; + white-space: pre-line; } .Converstion-historyItem.user { align-self: initial; } -.Conversation-input { - background: none; - border: none; - padding: 10px; +.Conversation-textbox { + --top: 10px; + --left: 10px; + padding: var(--top) var(--left); box-sizing: border-box; - min-height: 150px; position: sticky; bottom: 0; - background: hsla(0deg, 0%, 90%, 90%); width: 100%; - outline: none; -} \ No newline at end of file + 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 index f6609d4..778323e 100644 --- a/util/__init__.py +++ b/util/__init__.py @@ -1,7 +1,8 @@ import os from platform import python_version_tuple as get_pyversion +from statistics import mean as _mean, StatisticsError -from pyquery import PyQuery as pq +from pyquery import PyQuery as pq, text as _text pyversion = tuple(int(e) for e in get_pyversion()) if pyversion >= (3, 6, 0): @@ -22,6 +23,8 @@ def new(cls, *args, **kw): from .set import Set, OrderedSet from .list import Tuple, List from .url import URL +from .priority_queue import PriorityQueue +from itertools import islice def attach(target): def deco(func): @@ -29,15 +32,109 @@ def deco(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 + +def mean(data, default=None): + try: + return _mean(data) + except StatisticsError: + return default + +def casefold(self): + return str(self).casefold() + +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: + raise StopIteration + 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, filter=None): +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.add(node[0]) + res.update(node) return pq(res[:]) diff --git a/util/list.py b/util/list.py index 41fbb59..7ccdabe 100644 --- a/util/list.py +++ b/util/list.py @@ -36,7 +36,8 @@ def index(self, item, default=None): return default class Tuple(_List, tuple): - pass + def __repr__(self): + return tuple.__repr__(self) class List(_List, list): def __init__(self, src=None, banned=None, **kw): @@ -46,6 +47,9 @@ def __init__(self, src=None, banned=None, **kw): 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)) diff --git a/util/priority_queue.py b/util/priority_queue.py new file mode 100644 index 0000000..a10e5bd --- /dev/null +++ b/util/priority_queue.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python +# +# Based on the work of Pravin Paratey (April 15, 2011) +# Joachim Hagege (June 18, 2014) +# +# Code released under BSD license +# +from __future__ import print_function +from math import inf +from collections import namedtuple +from sortedcontainers import SortedList + + +Element = namedtuple('Element', ('value', 'rank')) + +class PriorityQueue: + def __init__(self, capacity=None, key=None): + self._data = SortedList(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): + return self._data[index] + + def size(self): + return len(self._data) + +class _PriorityQueue: + """ This class illustrates a PriorityQueue and its associated functions """ + + 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/set.py b/util/set.py index d35ce36..54f2746 100644 --- a/util/set.py +++ b/util/set.py @@ -33,13 +33,17 @@ def __contains__(self, item): def update(self, src): if isinstance(src, bool): - self._bool = src - return True + 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__() @@ -91,7 +95,7 @@ def __bool__(self): return bool(self._data) def __repr__(self): - return f"{{{', '.join(self)}}}" + return f"{{{', '.join(repr(e) for e in self)}}}" def __len__(self): return len(self._data)