tnt.ensembl
Version:
Library to retrieve data via the Ensembl REST Api
1,740 lines (1,438 loc) • 155 kB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports = tnt_ensembl = require("./index.js");
},{"./index.js":2}],2:[function(require,module,exports){
module.exports = tnt_ensembl = require("./src/rest.js");
},{"./src/rest.js":20}],3:[function(require,module,exports){
(function (process,global){
/*!
* @overview es6-promise - a tiny implementation of Promises/A+.
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
* @license Licensed under MIT license
* See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
* @version 2.0.1
*/
(function() {
"use strict";
function $$utils$$objectOrFunction(x) {
return typeof x === 'function' || (typeof x === 'object' && x !== null);
}
function $$utils$$isFunction(x) {
return typeof x === 'function';
}
function $$utils$$isMaybeThenable(x) {
return typeof x === 'object' && x !== null;
}
var $$utils$$_isArray;
if (!Array.isArray) {
$$utils$$_isArray = function (x) {
return Object.prototype.toString.call(x) === '[object Array]';
};
} else {
$$utils$$_isArray = Array.isArray;
}
var $$utils$$isArray = $$utils$$_isArray;
var $$utils$$now = Date.now || function() { return new Date().getTime(); };
function $$utils$$F() { }
var $$utils$$o_create = (Object.create || function (o) {
if (arguments.length > 1) {
throw new Error('Second argument not supported');
}
if (typeof o !== 'object') {
throw new TypeError('Argument must be an object');
}
$$utils$$F.prototype = o;
return new $$utils$$F();
});
var $$asap$$len = 0;
var $$asap$$default = function asap(callback, arg) {
$$asap$$queue[$$asap$$len] = callback;
$$asap$$queue[$$asap$$len + 1] = arg;
$$asap$$len += 2;
if ($$asap$$len === 2) {
// If len is 1, that means that we need to schedule an async flush.
// If additional callbacks are queued before the queue is flushed, they
// will be processed by this flush that we are scheduling.
$$asap$$scheduleFlush();
}
};
var $$asap$$browserGlobal = (typeof window !== 'undefined') ? window : {};
var $$asap$$BrowserMutationObserver = $$asap$$browserGlobal.MutationObserver || $$asap$$browserGlobal.WebKitMutationObserver;
// test for web worker but not in IE10
var $$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
typeof importScripts !== 'undefined' &&
typeof MessageChannel !== 'undefined';
// node
function $$asap$$useNextTick() {
return function() {
process.nextTick($$asap$$flush);
};
}
function $$asap$$useMutationObserver() {
var iterations = 0;
var observer = new $$asap$$BrowserMutationObserver($$asap$$flush);
var node = document.createTextNode('');
observer.observe(node, { characterData: true });
return function() {
node.data = (iterations = ++iterations % 2);
};
}
// web worker
function $$asap$$useMessageChannel() {
var channel = new MessageChannel();
channel.port1.onmessage = $$asap$$flush;
return function () {
channel.port2.postMessage(0);
};
}
function $$asap$$useSetTimeout() {
return function() {
setTimeout($$asap$$flush, 1);
};
}
var $$asap$$queue = new Array(1000);
function $$asap$$flush() {
for (var i = 0; i < $$asap$$len; i+=2) {
var callback = $$asap$$queue[i];
var arg = $$asap$$queue[i+1];
callback(arg);
$$asap$$queue[i] = undefined;
$$asap$$queue[i+1] = undefined;
}
$$asap$$len = 0;
}
var $$asap$$scheduleFlush;
// Decide what async method to use to triggering processing of queued callbacks:
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
$$asap$$scheduleFlush = $$asap$$useNextTick();
} else if ($$asap$$BrowserMutationObserver) {
$$asap$$scheduleFlush = $$asap$$useMutationObserver();
} else if ($$asap$$isWorker) {
$$asap$$scheduleFlush = $$asap$$useMessageChannel();
} else {
$$asap$$scheduleFlush = $$asap$$useSetTimeout();
}
function $$$internal$$noop() {}
var $$$internal$$PENDING = void 0;
var $$$internal$$FULFILLED = 1;
var $$$internal$$REJECTED = 2;
var $$$internal$$GET_THEN_ERROR = new $$$internal$$ErrorObject();
function $$$internal$$selfFullfillment() {
return new TypeError("You cannot resolve a promise with itself");
}
function $$$internal$$cannotReturnOwn() {
return new TypeError('A promises callback cannot return that same promise.')
}
function $$$internal$$getThen(promise) {
try {
return promise.then;
} catch(error) {
$$$internal$$GET_THEN_ERROR.error = error;
return $$$internal$$GET_THEN_ERROR;
}
}
function $$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
try {
then.call(value, fulfillmentHandler, rejectionHandler);
} catch(e) {
return e;
}
}
function $$$internal$$handleForeignThenable(promise, thenable, then) {
$$asap$$default(function(promise) {
var sealed = false;
var error = $$$internal$$tryThen(then, thenable, function(value) {
if (sealed) { return; }
sealed = true;
if (thenable !== value) {
$$$internal$$resolve(promise, value);
} else {
$$$internal$$fulfill(promise, value);
}
}, function(reason) {
if (sealed) { return; }
sealed = true;
$$$internal$$reject(promise, reason);
}, 'Settle: ' + (promise._label || ' unknown promise'));
if (!sealed && error) {
sealed = true;
$$$internal$$reject(promise, error);
}
}, promise);
}
function $$$internal$$handleOwnThenable(promise, thenable) {
if (thenable._state === $$$internal$$FULFILLED) {
$$$internal$$fulfill(promise, thenable._result);
} else if (promise._state === $$$internal$$REJECTED) {
$$$internal$$reject(promise, thenable._result);
} else {
$$$internal$$subscribe(thenable, undefined, function(value) {
$$$internal$$resolve(promise, value);
}, function(reason) {
$$$internal$$reject(promise, reason);
});
}
}
function $$$internal$$handleMaybeThenable(promise, maybeThenable) {
if (maybeThenable.constructor === promise.constructor) {
$$$internal$$handleOwnThenable(promise, maybeThenable);
} else {
var then = $$$internal$$getThen(maybeThenable);
if (then === $$$internal$$GET_THEN_ERROR) {
$$$internal$$reject(promise, $$$internal$$GET_THEN_ERROR.error);
} else if (then === undefined) {
$$$internal$$fulfill(promise, maybeThenable);
} else if ($$utils$$isFunction(then)) {
$$$internal$$handleForeignThenable(promise, maybeThenable, then);
} else {
$$$internal$$fulfill(promise, maybeThenable);
}
}
}
function $$$internal$$resolve(promise, value) {
if (promise === value) {
$$$internal$$reject(promise, $$$internal$$selfFullfillment());
} else if ($$utils$$objectOrFunction(value)) {
$$$internal$$handleMaybeThenable(promise, value);
} else {
$$$internal$$fulfill(promise, value);
}
}
function $$$internal$$publishRejection(promise) {
if (promise._onerror) {
promise._onerror(promise._result);
}
$$$internal$$publish(promise);
}
function $$$internal$$fulfill(promise, value) {
if (promise._state !== $$$internal$$PENDING) { return; }
promise._result = value;
promise._state = $$$internal$$FULFILLED;
if (promise._subscribers.length === 0) {
} else {
$$asap$$default($$$internal$$publish, promise);
}
}
function $$$internal$$reject(promise, reason) {
if (promise._state !== $$$internal$$PENDING) { return; }
promise._state = $$$internal$$REJECTED;
promise._result = reason;
$$asap$$default($$$internal$$publishRejection, promise);
}
function $$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
var subscribers = parent._subscribers;
var length = subscribers.length;
parent._onerror = null;
subscribers[length] = child;
subscribers[length + $$$internal$$FULFILLED] = onFulfillment;
subscribers[length + $$$internal$$REJECTED] = onRejection;
if (length === 0 && parent._state) {
$$asap$$default($$$internal$$publish, parent);
}
}
function $$$internal$$publish(promise) {
var subscribers = promise._subscribers;
var settled = promise._state;
if (subscribers.length === 0) { return; }
var child, callback, detail = promise._result;
for (var i = 0; i < subscribers.length; i += 3) {
child = subscribers[i];
callback = subscribers[i + settled];
if (child) {
$$$internal$$invokeCallback(settled, child, callback, detail);
} else {
callback(detail);
}
}
promise._subscribers.length = 0;
}
function $$$internal$$ErrorObject() {
this.error = null;
}
var $$$internal$$TRY_CATCH_ERROR = new $$$internal$$ErrorObject();
function $$$internal$$tryCatch(callback, detail) {
try {
return callback(detail);
} catch(e) {
$$$internal$$TRY_CATCH_ERROR.error = e;
return $$$internal$$TRY_CATCH_ERROR;
}
}
function $$$internal$$invokeCallback(settled, promise, callback, detail) {
var hasCallback = $$utils$$isFunction(callback),
value, error, succeeded, failed;
if (hasCallback) {
value = $$$internal$$tryCatch(callback, detail);
if (value === $$$internal$$TRY_CATCH_ERROR) {
failed = true;
error = value.error;
value = null;
} else {
succeeded = true;
}
if (promise === value) {
$$$internal$$reject(promise, $$$internal$$cannotReturnOwn());
return;
}
} else {
value = detail;
succeeded = true;
}
if (promise._state !== $$$internal$$PENDING) {
// noop
} else if (hasCallback && succeeded) {
$$$internal$$resolve(promise, value);
} else if (failed) {
$$$internal$$reject(promise, error);
} else if (settled === $$$internal$$FULFILLED) {
$$$internal$$fulfill(promise, value);
} else if (settled === $$$internal$$REJECTED) {
$$$internal$$reject(promise, value);
}
}
function $$$internal$$initializePromise(promise, resolver) {
try {
resolver(function resolvePromise(value){
$$$internal$$resolve(promise, value);
}, function rejectPromise(reason) {
$$$internal$$reject(promise, reason);
});
} catch(e) {
$$$internal$$reject(promise, e);
}
}
function $$$enumerator$$makeSettledResult(state, position, value) {
if (state === $$$internal$$FULFILLED) {
return {
state: 'fulfilled',
value: value
};
} else {
return {
state: 'rejected',
reason: value
};
}
}
function $$$enumerator$$Enumerator(Constructor, input, abortOnReject, label) {
this._instanceConstructor = Constructor;
this.promise = new Constructor($$$internal$$noop, label);
this._abortOnReject = abortOnReject;
if (this._validateInput(input)) {
this._input = input;
this.length = input.length;
this._remaining = input.length;
this._init();
if (this.length === 0) {
$$$internal$$fulfill(this.promise, this._result);
} else {
this.length = this.length || 0;
this._enumerate();
if (this._remaining === 0) {
$$$internal$$fulfill(this.promise, this._result);
}
}
} else {
$$$internal$$reject(this.promise, this._validationError());
}
}
$$$enumerator$$Enumerator.prototype._validateInput = function(input) {
return $$utils$$isArray(input);
};
$$$enumerator$$Enumerator.prototype._validationError = function() {
return new Error('Array Methods must be provided an Array');
};
$$$enumerator$$Enumerator.prototype._init = function() {
this._result = new Array(this.length);
};
var $$$enumerator$$default = $$$enumerator$$Enumerator;
$$$enumerator$$Enumerator.prototype._enumerate = function() {
var length = this.length;
var promise = this.promise;
var input = this._input;
for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {
this._eachEntry(input[i], i);
}
};
$$$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
var c = this._instanceConstructor;
if ($$utils$$isMaybeThenable(entry)) {
if (entry.constructor === c && entry._state !== $$$internal$$PENDING) {
entry._onerror = null;
this._settledAt(entry._state, i, entry._result);
} else {
this._willSettleAt(c.resolve(entry), i);
}
} else {
this._remaining--;
this._result[i] = this._makeResult($$$internal$$FULFILLED, i, entry);
}
};
$$$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
var promise = this.promise;
if (promise._state === $$$internal$$PENDING) {
this._remaining--;
if (this._abortOnReject && state === $$$internal$$REJECTED) {
$$$internal$$reject(promise, value);
} else {
this._result[i] = this._makeResult(state, i, value);
}
}
if (this._remaining === 0) {
$$$internal$$fulfill(promise, this._result);
}
};
$$$enumerator$$Enumerator.prototype._makeResult = function(state, i, value) {
return value;
};
$$$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
var enumerator = this;
$$$internal$$subscribe(promise, undefined, function(value) {
enumerator._settledAt($$$internal$$FULFILLED, i, value);
}, function(reason) {
enumerator._settledAt($$$internal$$REJECTED, i, reason);
});
};
var $$promise$all$$default = function all(entries, label) {
return new $$$enumerator$$default(this, entries, true /* abort on reject */, label).promise;
};
var $$promise$race$$default = function race(entries, label) {
/*jshint validthis:true */
var Constructor = this;
var promise = new Constructor($$$internal$$noop, label);
if (!$$utils$$isArray(entries)) {
$$$internal$$reject(promise, new TypeError('You must pass an array to race.'));
return promise;
}
var length = entries.length;
function onFulfillment(value) {
$$$internal$$resolve(promise, value);
}
function onRejection(reason) {
$$$internal$$reject(promise, reason);
}
for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {
$$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
}
return promise;
};
var $$promise$resolve$$default = function resolve(object, label) {
/*jshint validthis:true */
var Constructor = this;
if (object && typeof object === 'object' && object.constructor === Constructor) {
return object;
}
var promise = new Constructor($$$internal$$noop, label);
$$$internal$$resolve(promise, object);
return promise;
};
var $$promise$reject$$default = function reject(reason, label) {
/*jshint validthis:true */
var Constructor = this;
var promise = new Constructor($$$internal$$noop, label);
$$$internal$$reject(promise, reason);
return promise;
};
var $$es6$promise$promise$$counter = 0;
function $$es6$promise$promise$$needsResolver() {
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
}
function $$es6$promise$promise$$needsNew() {
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
}
var $$es6$promise$promise$$default = $$es6$promise$promise$$Promise;
/**
Promise objects represent the eventual result of an asynchronous operation. The
primary way of interacting with a promise is through its `then` method, which
registers callbacks to receive either a promise’s eventual value or the reason
why the promise cannot be fulfilled.
Terminology
-----------
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
- `thenable` is an object or function that defines a `then` method.
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
- `exception` is a value that is thrown using the throw statement.
- `reason` is a value that indicates why a promise was rejected.
- `settled` the final resting state of a promise, fulfilled or rejected.
A promise can be in one of three states: pending, fulfilled, or rejected.
Promises that are fulfilled have a fulfillment value and are in the fulfilled
state. Promises that are rejected have a rejection reason and are in the
rejected state. A fulfillment value is never a thenable.
Promises can also be said to *resolve* a value. If this value is also a
promise, then the original promise's settled state will match the value's
settled state. So a promise that *resolves* a promise that rejects will
itself reject, and a promise that *resolves* a promise that fulfills will
itself fulfill.
Basic Usage:
------------
```js
var promise = new Promise(function(resolve, reject) {
// on success
resolve(value);
// on failure
reject(reason);
});
promise.then(function(value) {
// on fulfillment
}, function(reason) {
// on rejection
});
```
Advanced Usage:
---------------
Promises shine when abstracting away asynchronous interactions such as
`XMLHttpRequest`s.
```js
function getJSON(url) {
return new Promise(function(resolve, reject){
var xhr = new XMLHttpRequest();
xhr.open('GET', url);
xhr.onreadystatechange = handler;
xhr.responseType = 'json';
xhr.setRequestHeader('Accept', 'application/json');
xhr.send();
function handler() {
if (this.readyState === this.DONE) {
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
}
}
};
});
}
getJSON('/posts.json').then(function(json) {
// on fulfillment
}, function(reason) {
// on rejection
});
```
Unlike callbacks, promises are great composable primitives.
```js
Promise.all([
getJSON('/posts'),
getJSON('/comments')
]).then(function(values){
values[0] // => postsJSON
values[1] // => commentsJSON
return values;
});
```
@class Promise
@param {function} resolver
Useful for tooling.
@constructor
*/
function $$es6$promise$promise$$Promise(resolver) {
this._id = $$es6$promise$promise$$counter++;
this._state = undefined;
this._result = undefined;
this._subscribers = [];
if ($$$internal$$noop !== resolver) {
if (!$$utils$$isFunction(resolver)) {
$$es6$promise$promise$$needsResolver();
}
if (!(this instanceof $$es6$promise$promise$$Promise)) {
$$es6$promise$promise$$needsNew();
}
$$$internal$$initializePromise(this, resolver);
}
}
$$es6$promise$promise$$Promise.all = $$promise$all$$default;
$$es6$promise$promise$$Promise.race = $$promise$race$$default;
$$es6$promise$promise$$Promise.resolve = $$promise$resolve$$default;
$$es6$promise$promise$$Promise.reject = $$promise$reject$$default;
$$es6$promise$promise$$Promise.prototype = {
constructor: $$es6$promise$promise$$Promise,
/**
The primary way of interacting with a promise is through its `then` method,
which registers callbacks to receive either a promise's eventual value or the
reason why the promise cannot be fulfilled.
```js
findUser().then(function(user){
// user is available
}, function(reason){
// user is unavailable, and you are given the reason why
});
```
Chaining
--------
The return value of `then` is itself a promise. This second, 'downstream'
promise is resolved with the return value of the first promise's fulfillment
or rejection handler, or rejected if the handler throws an exception.
```js
findUser().then(function (user) {
return user.name;
}, function (reason) {
return 'default name';
}).then(function (userName) {
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
// will be `'default name'`
});
findUser().then(function (user) {
throw new Error('Found user, but still unhappy');
}, function (reason) {
throw new Error('`findUser` rejected and we're unhappy');
}).then(function (value) {
// never reached
}, function (reason) {
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
});
```
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
```js
findUser().then(function (user) {
throw new PedagogicalException('Upstream error');
}).then(function (value) {
// never reached
}).then(function (value) {
// never reached
}, function (reason) {
// The `PedgagocialException` is propagated all the way down to here
});
```
Assimilation
------------
Sometimes the value you want to propagate to a downstream promise can only be
retrieved asynchronously. This can be achieved by returning a promise in the
fulfillment or rejection handler. The downstream promise will then be pending
until the returned promise is settled. This is called *assimilation*.
```js
findUser().then(function (user) {
return findCommentsByAuthor(user);
}).then(function (comments) {
// The user's comments are now available
});
```
If the assimliated promise rejects, then the downstream promise will also reject.
```js
findUser().then(function (user) {
return findCommentsByAuthor(user);
}).then(function (comments) {
// If `findCommentsByAuthor` fulfills, we'll have the value here
}, function (reason) {
// If `findCommentsByAuthor` rejects, we'll have the reason here
});
```
Simple Example
--------------
Synchronous Example
```javascript
var result;
try {
result = findResult();
// success
} catch(reason) {
// failure
}
```
Errback Example
```js
findResult(function(result, err){
if (err) {
// failure
} else {
// success
}
});
```
Promise Example;
```javascript
findResult().then(function(result){
// success
}, function(reason){
// failure
});
```
Advanced Example
--------------
Synchronous Example
```javascript
var author, books;
try {
author = findAuthor();
books = findBooksByAuthor(author);
// success
} catch(reason) {
// failure
}
```
Errback Example
```js
function foundBooks(books) {
}
function failure(reason) {
}
findAuthor(function(author, err){
if (err) {
failure(err);
// failure
} else {
try {
findBoooksByAuthor(author, function(books, err) {
if (err) {
failure(err);
} else {
try {
foundBooks(books);
} catch(reason) {
failure(reason);
}
}
});
} catch(error) {
failure(err);
}
// success
}
});
```
Promise Example;
```javascript
findAuthor().
then(findBooksByAuthor).
then(function(books){
// found books
}).catch(function(reason){
// something went wrong
});
```
@method then
@param {Function} onFulfilled
@param {Function} onRejected
Useful for tooling.
@return {Promise}
*/
then: function(onFulfillment, onRejection) {
var parent = this;
var state = parent._state;
if (state === $$$internal$$FULFILLED && !onFulfillment || state === $$$internal$$REJECTED && !onRejection) {
return this;
}
var child = new this.constructor($$$internal$$noop);
var result = parent._result;
if (state) {
var callback = arguments[state - 1];
$$asap$$default(function(){
$$$internal$$invokeCallback(state, child, callback, result);
});
} else {
$$$internal$$subscribe(parent, child, onFulfillment, onRejection);
}
return child;
},
/**
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
as the catch block of a try/catch statement.
```js
function findAuthor(){
throw new Error('couldn't find that author');
}
// synchronous
try {
findAuthor();
} catch(reason) {
// something went wrong
}
// async with promises
findAuthor().catch(function(reason){
// something went wrong
});
```
@method catch
@param {Function} onRejection
Useful for tooling.
@return {Promise}
*/
'catch': function(onRejection) {
return this.then(null, onRejection);
}
};
var $$es6$promise$polyfill$$default = function polyfill() {
var local;
if (typeof global !== 'undefined') {
local = global;
} else if (typeof window !== 'undefined' && window.document) {
local = window;
} else {
local = self;
}
var es6PromiseSupport =
"Promise" in local &&
// Some of these methods are missing from
// Firefox/Chrome experimental implementations
"resolve" in local.Promise &&
"reject" in local.Promise &&
"all" in local.Promise &&
"race" in local.Promise &&
// Older version of the spec had a resolver object
// as the arg rather than a function
(function() {
var resolve;
new local.Promise(function(r) { resolve = r; });
return $$utils$$isFunction(resolve);
}());
if (!es6PromiseSupport) {
local.Promise = $$es6$promise$promise$$default;
}
};
var es6$promise$umd$$ES6Promise = {
'Promise': $$es6$promise$promise$$default,
'polyfill': $$es6$promise$polyfill$$default
};
/* global define:true module:true window: true */
if (typeof define === 'function' && define['amd']) {
define(function() { return es6$promise$umd$$ES6Promise; });
} else if (typeof module !== 'undefined' && module['exports']) {
module['exports'] = es6$promise$umd$$ES6Promise;
} else if (typeof this !== 'undefined') {
this['ES6Promise'] = es6$promise$umd$$ES6Promise;
}
}).call(this);
}).call(this,require("IrXUsu"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"IrXUsu":4}],4:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};
process.nextTick = (function () {
var canSetImmediate = typeof window !== 'undefined'
&& window.setImmediate;
var canPost = typeof window !== 'undefined'
&& window.postMessage && window.addEventListener
;
if (canSetImmediate) {
return function (f) { return window.setImmediate(f) };
}
if (canPost) {
var queue = [];
window.addEventListener('message', function (ev) {
var source = ev.source;
if ((source === window || source === null) && ev.data === 'process-tick') {
ev.stopPropagation();
if (queue.length > 0) {
var fn = queue.shift();
fn();
}
}
}, true);
return function nextTick(fn) {
queue.push(fn);
window.postMessage('process-tick', '*');
};
}
return function nextTick(fn) {
setTimeout(fn, 0);
};
})();
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
}
// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
},{}],5:[function(require,module,exports){
/*globals define */
'use strict';
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
define(function () {
return (root.httppleasepromises = factory(root));
});
} else if (typeof exports === 'object') {
module.exports = factory(root);
} else {
root.httppleasepromises = factory(root);
}
}(this, function (root) { // jshint ignore:line
return function (Promise) {
Promise = Promise || root && root.Promise;
if (!Promise) {
throw new Error('No Promise implementation found.');
}
return {
processRequest: function (req) {
var resolve, reject,
oldOnload = req.onload,
oldOnerror = req.onerror,
promise = new Promise(function (a, b) {
resolve = a;
reject = b;
});
req.onload = function (res) {
var result;
if (oldOnload) {
result = oldOnload.apply(this, arguments);
}
resolve(res);
return result;
};
req.onerror = function (err) {
var result;
if (oldOnerror) {
result = oldOnerror.apply(this, arguments);
}
reject(err);
return result;
};
req.then = function () {
return promise.then.apply(promise, arguments);
};
req['catch'] = function () {
return promise['catch'].apply(promise, arguments);
};
}
};
};
}));
},{}],6:[function(require,module,exports){
'use strict';
var Response = require('./response');
function RequestError(message, props) {
var err = new Error(message);
err.name = 'RequestError';
this.name = err.name;
this.message = err.message;
if (err.stack) {
this.stack = err.stack;
}
this.toString = function () {
return this.message;
};
for (var k in props) {
if (props.hasOwnProperty(k)) {
this[k] = props[k];
}
}
}
RequestError.prototype = Error.prototype;
RequestError.create = function (message, req, props) {
var err = new RequestError(message, props);
Response.call(err, req);
return err;
};
module.exports = RequestError;
},{"./response":9}],7:[function(require,module,exports){
'use strict';
var i,
cleanURL = require('../plugins/cleanurl'),
XHR = require('./xhr'),
delay = require('./utils/delay'),
createError = require('./error').create,
Response = require('./response'),
Request = require('./request'),
extend = require('xtend'),
once = require('./utils/once');
function factory(defaults, plugins) {
defaults = defaults || {};
plugins = plugins || [];
function http(req, cb) {
var xhr, plugin, done, k, timeoutId;
req = new Request(extend(defaults, req));
for (i = 0; i < plugins.length; i++) {
plugin = plugins[i];
if (plugin.processRequest) {
plugin.processRequest(req);
}
}
// Give the plugins a chance to create the XHR object
for (i = 0; i < plugins.length; i++) {
plugin = plugins[i];
if (plugin.createXHR) {
xhr = plugin.createXHR(req);
break; // First come, first serve
}
}
xhr = xhr || new XHR();
req.xhr = xhr;
// Because XHR can be an XMLHttpRequest or an XDomainRequest, we add
// `onreadystatechange`, `onload`, and `onerror` callbacks. We use the
// `once` util to make sure that only one is called (and it's only called
// one time).
done = once(delay(function (err) {
clearTimeout(timeoutId);
xhr.onload = xhr.onerror = xhr.onreadystatechange = xhr.ontimeout = xhr.onprogress = null;
var res = err && err.isHttpError ? err : new Response(req);
for (i = 0; i < plugins.length; i++) {
plugin = plugins[i];
if (plugin.processResponse) {
plugin.processResponse(res);
}
}
if (err) {
if (req.onerror) {
req.onerror(err);
}
} else {
if (req.onload) {
req.onload(res);
}
}
if (cb) {
cb(err, res);
}
}));
// When the request completes, continue.
xhr.onreadystatechange = function () {
if (req.timedOut) return;
if (req.aborted) {
done(createError('Request aborted', req, {name: 'Abort'}));
} else if (xhr.readyState === 4) {
var type = Math.floor(xhr.status / 100);
if (type === 2) {
done();
} else if (xhr.status === 404 && !req.errorOn404) {
done();
} else {
var kind;
switch (type) {
case 4:
kind = 'Client';
break;
case 5:
kind = 'Server';
break;
default:
kind = 'HTTP';
}
var msg = kind + ' Error: ' +
'The server returned a status of ' + xhr.status +
' for the request "' +
req.method.toUpperCase() + ' ' + req.url + '"';
done(createError(msg, req));
}
}
};
// `onload` is only called on success and, in IE, will be called without
// `xhr.status` having been set, so we don't check it.
xhr.onload = function () { done(); };
xhr.onerror = function () {
done(createError('Internal XHR Error', req));
};
// IE sometimes fails if you don't specify every handler.
// See http://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment
xhr.ontimeout = function () { /* noop */ };
xhr.onprogress = function () { /* noop */ };
xhr.open(req.method, req.url);
if (req.timeout) {
// If we use the normal XHR timeout mechanism (`xhr.timeout` and
// `xhr.ontimeout`), `onreadystatechange` will be triggered before
// `ontimeout`. There's no way to recognize that it was triggered by
// a timeout, and we'd be unable to dispatch the right error.
timeoutId = setTimeout(function () {
req.timedOut = true;
done(createError('Request timeout', req, {name: 'Timeout'}));
try {
xhr.abort();
} catch (err) {}
}, req.timeout);
}
for (k in req.headers) {
if (req.headers.hasOwnProperty(k)) {
xhr.setRequestHeader(k, req.headers[k]);
}
}
xhr.send(req.body);
return req;
}
var method,
methods = ['get', 'post', 'put', 'head', 'patch', 'delete'],
verb = function (method) {
return function (req, cb) {
req = new Request(req);
req.method = method;
return http(req, cb);
};
};
for (i = 0; i < methods.length; i++) {
method = methods[i];
http[method] = verb(method);
}
http.plugins = function () {
return plugins;
};
http.defaults = function (newValues) {
if (newValues) {
return factory(extend(defaults, newValues), plugins);
}
return defaults;
};
http.use = function () {
var newPlugins = Array.prototype.slice.call(arguments, 0);
return factory(defaults, plugins.concat(newPlugins));
};
http.bare = function () {
return factory();
};
http.Request = Request;
http.Response = Response;
return http;
}
module.exports = factory({}, [cleanURL]);
},{"../plugins/cleanurl":14,"./error":6,"./request":8,"./response":9,"./utils/delay":10,"./utils/once":11,"./xhr":12,"xtend":13}],8:[function(require,module,exports){
'use strict';
function Request(optsOrUrl) {
var opts = typeof optsOrUrl === 'string' ? {url: optsOrUrl} : optsOrUrl || {};
this.method = opts.method ? opts.method.toUpperCase() : 'GET';
this.url = opts.url;
this.headers = opts.headers || {};
this.body = opts.body;
this.timeout = opts.timeout || 0;
this.errorOn404 = opts.errorOn404 != null ? opts.errorOn404 : true;
this.onload = opts.onload;
this.onerror = opts.onerror;
}
Request.prototype.abort = function () {
if (this.aborted) return;
this.aborted = true;
this.xhr.abort();
return this;
};
Request.prototype.header = function (name, value) {
var k;
for (k in this.headers) {
if (this.headers.hasOwnProperty(k)) {
if (name.toLowerCase() === k.toLowerCase()) {
if (arguments.length === 1) {
return this.headers[k];
}
delete this.headers[k];
break;
}
}
}
if (value != null) {
this.headers[name] = value;
return value;
}
};
module.exports = Request;
},{}],9:[function(require,module,exports){
'use strict';
var Request = require('./request');
function Response(req) {
var i, lines, m,
xhr = req.xhr;
this.request = req;
this.xhr = xhr;
this.headers = {};
// Browsers don't like you trying to read XHR properties when you abort the
// request, so we don't.
if (req.aborted || req.timedOut) return;
this.status = xhr.status || 0;
this.text = xhr.responseText;
this.body = xhr.response || xhr.responseText;
this.contentType = xhr.contentType || (xhr.getResponseHeader && xhr.getResponseHeader('Content-Type'));
if (xhr.getAllResponseHeaders) {
lines = xhr.getAllResponseHeaders().split('\n');
for (i = 0; i < lines.length; i++) {
if ((m = lines[i].match(/\s*([^\s]+):\s+([^\s]+)/))) {
this.headers[m[1]] = m[2];
}
}
}
this.isHttpError = this.status >= 400;
}
Response.prototype.header = Request.prototype.header;
module.exports = Response;
},{"./request":8}],10:[function(require,module,exports){
'use strict';
// Wrap a function in a `setTimeout` call. This is used to guarantee async
// behavior, which can avoid unexpected errors.
module.exports = function (fn) {
return function () {
var
args = Array.prototype.slice.call(arguments, 0),
newFunc = function () {
return fn.apply(null, args);
};
setTimeout(newFunc, 0);
};
};
},{}],11:[function(require,module,exports){
'use strict';
// A "once" utility.
module.exports = function (fn) {
var result, called = false;
return function () {
if (!called) {
called = true;
result = fn.apply(this, arguments);
}
return result;
};
};
},{}],12:[function(require,module,exports){
module.exports = window.XMLHttpRequest;
},{}],13:[function(require,module,exports){
module.exports = extend
function extend() {
var target = {}
for (var i = 0; i < arguments.length; i++) {
var source = arguments[i]
for (var key in source) {
if (source.hasOwnProperty(key)) {
target[key] = source[key]
}
}
}
return target
}
},{}],14:[function(require,module,exports){
'use strict';
module.exports = {
processRequest: function (req) {
req.url = req.url.replace(/[^%]+/g, function (s) {
return encodeURI(s);
});
}
};
},{}],15:[function(require,module,exports){
'use strict';
var jsonrequest = require('./jsonrequest'),
jsonresponse = require('./jsonresponse');
module.exports = {
processRequest: function (req) {
jsonrequest.processRequest.call(this, req);
jsonresponse.processRequest.call(this, req);
},
processResponse: function (res) {
jsonresponse.processResponse.call(this, res);
}
};
},{"./jsonrequest":16,"./jsonresponse":17}],16:[function(require,module,exports){
'use strict';
module.exports = {
processRequest: function (req) {
var
contentType = req.header('Content-Type'),
hasJsonContentType = contentType &&
contentType.indexOf('application/json') !== -1;
if (contentType != null && !hasJsonContentType) {
return;
}
if (req.body) {
if (!contentType) {
req.header('Content-Type', 'application/json');
}
req.body = JSON.stringify(req.body);
}
}
};
},{}],17:[function(require,module,exports){
'use strict';
module.exports = {
processRequest: function (req) {
var accept = req.header('Accept');
if (accept == null) {
req.header('Accept', 'application/json');
}
},
processResponse: function (res) {
// Check to see if the contentype is "something/json" or
// "something/somethingelse+json"
if (res.contentType && /^.*\/(?:.*\+)?json(;|$)/i.test(res.contentType)) {
var raw = typeof res.body === 'string' ? res.body : res.text;
if (raw) {
res.body = JSON.parse(raw);
}
}
}
};
},{}],18:[function(require,module,exports){
module.exports = require("./src/api.js");
},{"./src/api.js":19}],19:[function(require,module,exports){
var api = function (who) {
var _methods = function () {
var m = [];
m.add_batch = function (obj) {
m.unshift(obj);
};
m.update = function (method, value) {
for (var i=0; i<m.length; i++) {
for (var p in m[i]) {
if (p === method) {
m[i][p] = value;
return true;
}
}
}
return false;
};
m.add = function (method, value) {
if (m.update (method, value) ) {
} else {
var reg = {};
reg[method] = value;
m.add_batch (reg);
}
};
m.get = function (method) {
for (var i=0; i<m.length; i++) {
for (var p in m[i]) {
if (p === method) {
return m[i][p];
}
}
}
};
return m;
};
var methods = _methods();
var api = function () {};
api.check = function (method, check, msg) {
if (method instanceof Array) {
for (var i=0; i<method.length; i++) {
api.check(method[i], check, msg);
}
return;
}
if (typeof (method) === 'function') {
method.check(check, msg);
} else {
who[method].check(check, msg);
}
return api;
};
api.transform = function (method, cbak) {
if (method instanceof Array) {
for (var i=0; i<method.length; i++) {
api.transform (method[i], cbak);
}
return;
}
if (typeof (method) === 'function') {
method.transform (cbak);
} else {
who[method].transform(cbak);
}
return api;
};
var attach_method = function (method, opts) {
var checks = [];
var transforms = [];
var getter = opts.on_getter || function () {
return methods.get(method);
};
var setter = opts.on_setter || function (x) {
for (var i=0; i<transforms.length; i++) {
x = transforms[i](x);
}
for (var j=0; j<checks.length; j++) {
if (!checks[j].check(x)) {
var msg = checks[j].msg ||
("Value " + x + " doesn't seem to be valid for this method");
throw (msg);
}
}
methods.add(method, x);
};
var new_method = function (new_val) {
if (!arguments.length) {
return getter();
}
setter(new_val);
return who; // Return this?
};
new_method.check = function (cbak, msg) {
if (!arguments.length) {
return checks;
}
checks.push ({check : cbak,
msg : msg});
return this;
};
new_method.transform = function (cbak) {
if (!arguments.length) {
return transforms;
}
transforms.push(cbak);
return this;
};
who[method] = new_method;
};
var getset = function (param, opts) {
if (typeof (param) === 'object') {
methods.add_batch (param);
for (var p in param) {
attach_method (p, opts);
}
} else {
methods.add (param, opts.default_value);
attach_method (param, opts);
}
};
api.getset = function (param, def) {
getset(param, {default_value : def});
return api;
};
api.get = function (param, def) {
var on_setter = function () {
throw ("Method defined only as a getter (you are trying to use it as a setter");
};
getset(param, {default_value : def,
on_setter : on_setter}
);
return api;
};
api.set = function (param, def) {
var on_getter = function () {
throw ("Method defined only as a setter (you are trying to use it as a getter");
};
getset(param, {default_value : def,
on_getter : on_getter}
);
return api;
};
api.method = function (name, cbak) {
if (typeof (name) === 'object') {
for (var p in name) {
who[p] = name[p];
}
} else {
who[name] = cbak;
}
return api;
};
return api;
};
module.exports = exports = api;
},{}],20:[function(require,module,exports){
var http = require("httpplease");
var apijs = require("tnt.api");
var promises = require('httpplease-promises');
var Promise = require('es6-promise').Promise;
var json = require("httpplease/plugins/json");
http = http.use(json).use(promises(Promise));
tnt_eRest = function() {
var config = {
proxyUrl : "https://rest.ensembl.org"
};
// Prefixes to use the REST API.
//var proxyUrl = "https://rest.ensembl.org";
//var prefix_region = prefix + "/overlap/region/";
//var prefix_ensgene = prefix + "/lookup/id/";
//var prefix_xref = prefix + "/xrefs/symbol/";
//var prefix_homologues = prefix + "/homology/id/";
//var prefix_chr_info = prefix + "/info/assembly/";
//var prefix_aln_region = prefix + "/alignment/region/";
//var prefix_gene_tree = prefix + "/genetree/id/";
//var prefix_assembly = prefix + "/info/assembly/";
//var prefix_sequence = prefix + "/sequence/region/";
//var prefix_variation = prefix + "/variation/";
// Number of connections made to the database
var connections = 0;
var eRest = functio