- = (_i = _it.next()).value,!_i.done;)
+ for (var header, _i, _it = response.headers[Symbol.iterator](); header = (_i = _it.next()).value, !_i.done;) {
+ self.headers[header[0].toLowerCase()] = header[1]
+ self.rawHeaders.push(header[0], header[1])
+ }
+
+ // TODO: this doesn't respect backpressure. Once WritableStream is available, this can be fixed
+ var reader = response.body.getReader()
+ function read () {
+ reader.read().then(function (result) {
+ if (self._destroyed)
+ return
+ if (result.done) {
+ self.push(null)
+ return
+ }
+ self.push(new Buffer(result.value))
+ read()
+ })
+ }
+ read()
+
+ } else {
+ self._xhr = xhr
+ self._pos = 0
+
+ self.url = xhr.responseURL
+ self.statusCode = xhr.status
+ self.statusMessage = xhr.statusText
+ var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
+ headers.forEach(function (header) {
+ var matches = header.match(/^([^:]+):\s*(.*)/)
+ if (matches) {
+ var key = matches[1].toLowerCase()
+ if (key === 'set-cookie') {
+ if (self.headers[key] === undefined) {
+ self.headers[key] = []
+ }
+ self.headers[key].push(matches[2])
+ } else if (self.headers[key] !== undefined) {
+ self.headers[key] += ', ' + matches[2]
+ } else {
+ self.headers[key] = matches[2]
+ }
+ self.rawHeaders.push(matches[1], matches[2])
+ }
+ })
+
+ self._charset = 'x-user-defined'
+ if (!capability.overrideMimeType) {
+ var mimeType = self.rawHeaders['mime-type']
+ if (mimeType) {
+ var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
+ if (charsetMatch) {
+ self._charset = charsetMatch[1].toLowerCase()
+ }
+ }
+ if (!self._charset)
+ self._charset = 'utf-8' // best guess
+ }
+ }
+}
+
+inherits(IncomingMessage, stream.Readable)
+
+IncomingMessage.prototype._read = function () {}
+
+IncomingMessage.prototype._onXHRProgress = function () {
+ var self = this
+
+ var xhr = self._xhr
+
+ var response = null
+ switch (self._mode) {
+ case 'text:vbarray': // For IE9
+ if (xhr.readyState !== rStates.DONE)
+ break
+ try {
+ // This fails in IE8
+ response = new global.VBArray(xhr.responseBody).toArray()
+ } catch (e) {}
+ if (response !== null) {
+ self.push(new Buffer(response))
+ break
+ }
+ // Falls through in IE8
+ case 'text':
+ try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
+ response = xhr.responseText
+ } catch (e) {
+ self._mode = 'text:vbarray'
+ break
+ }
+ if (response.length > self._pos) {
+ var newData = response.substr(self._pos)
+ if (self._charset === 'x-user-defined') {
+ var buffer = new Buffer(newData.length)
+ for (var i = 0; i < newData.length; i++)
+ buffer[i] = newData.charCodeAt(i) & 0xff
+
+ self.push(buffer)
+ } else {
+ self.push(newData, self._charset)
+ }
+ self._pos = response.length
+ }
+ break
+ case 'arraybuffer':
+ if (xhr.readyState !== rStates.DONE || !xhr.response)
+ break
+ response = xhr.response
+ self.push(new Buffer(new Uint8Array(response)))
+ break
+ case 'moz-chunked-arraybuffer': // take whole
+ response = xhr.response
+ if (xhr.readyState !== rStates.LOADING || !response)
+ break
+ self.push(new Buffer(new Uint8Array(response)))
+ break
+ case 'ms-stream':
+ response = xhr.response
+ if (xhr.readyState !== rStates.LOADING)
+ break
+ var reader = new global.MSStreamReader()
+ reader.onprogress = function () {
+ if (reader.result.byteLength > self._pos) {
+ self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))
+ self._pos = reader.result.byteLength
+ }
+ }
+ reader.onload = function () {
+ self.push(null)
+ }
+ // reader.onerror = ??? // TODO: this
+ reader.readAsArrayBuffer(response)
+ break
+ }
+
+ // The ms-stream case handles end separately in reader.onload()
+ if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
+ self.push(null)
+ }
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./capability":50,"_process":37,"buffer":5,"inherits":11,"readable-stream":48}],53:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+ || function(encoding) {
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+ default: return false;
+ }
+ }
+
+
+function assertEncoding(encoding) {
+ if (encoding && !isBufferEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ // Enough space to store all bytes of a single character. UTF-8 needs 4
+ // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+ this.charBuffer = new Buffer(6);
+ // Number of bytes received for the current incomplete multi-byte character.
+ this.charReceived = 0;
+ // Number of bytes expected for the current incomplete multi-byte character.
+ this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var available = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, 0, available);
+ this.charReceived += available;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // remove bytes belonging to the current character from the buffer
+ buffer = buffer.slice(available, buffer.length);
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (buffer.length === 0) {
+ return charStr;
+ }
+ break;
+ }
+
+ // determine and set charLength / charReceived
+ this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+ end -= this.charReceived;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ buffer.copy(this.charBuffer, 0, 0, size);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+ this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ this.charReceived = buffer.length % 2;
+ this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ this.charReceived = buffer.length % 3;
+ this.charLength = this.charReceived ? 3 : 0;
+}
+
+},{"buffer":5}],54:[function(require,module,exports){
+var Buffer = require('buffer').Buffer
+
+module.exports = function (buf) {
+ // If the buffer is backed by a Uint8Array, a faster version will work
+ if (buf instanceof Uint8Array) {
+ // If the buffer isn't a subarray, return the underlying ArrayBuffer
+ if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+ return buf.buffer
+ } else if (typeof buf.buffer.slice === 'function') {
+ // Otherwise we need to get a proper copy
+ return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+ }
+ }
+
+ if (Buffer.isBuffer(buf)) {
+ // This is the slow version that will work with any Buffer
+ // implementation (even in old browsers)
+ var arrayCopy = new Uint8Array(buf.length)
+ var len = buf.length
+ for (var i = 0; i < len; i++) {
+ arrayCopy[i] = buf[i]
+ }
+ return arrayCopy.buffer
+ } else {
+ throw new Error('Argument must be a Buffer')
+ }
+}
+
+},{"buffer":5}],55:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+var punycode = require('punycode');
+var util = require('./util');
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+ this.protocol = null;
+ this.slashes = null;
+ this.auth = null;
+ this.host = null;
+ this.port = null;
+ this.hostname = null;
+ this.hash = null;
+ this.search = null;
+ this.query = null;
+ this.pathname = null;
+ this.path = null;
+ this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+ portPattern = /:[0-9]*$/,
+
+ // Special case for a simple path URL
+ simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+ // RFC 2396: characters reserved for delimiting URLs.
+ // We actually just auto-escape these.
+ delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+ // RFC 2396: characters not allowed for various reasons.
+ unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+ // Allowed by RFCs, but cause of XSS attacks. Always escape these.
+ autoEscape = ['\''].concat(unwise),
+ // Characters that are never ever allowed in a hostname.
+ // Note that any invalid chars are also handled, but these
+ // are the ones that are *expected* to be seen, so we fast-path
+ // them.
+ nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+ hostEndingChars = ['/', '?', '#'],
+ hostnameMaxLen = 255,
+ hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+ hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+ // protocols that can allow "unsafe" and "unwise" chars.
+ unsafeProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that never have a hostname.
+ hostlessProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ // protocols that always contain a // bit.
+ slashedProtocol = {
+ 'http': true,
+ 'https': true,
+ 'ftp': true,
+ 'gopher': true,
+ 'file': true,
+ 'http:': true,
+ 'https:': true,
+ 'ftp:': true,
+ 'gopher:': true,
+ 'file:': true
+ },
+ querystring = require('querystring');
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+ if (url && util.isObject(url) && url instanceof Url) return url;
+
+ var u = new Url;
+ u.parse(url, parseQueryString, slashesDenoteHost);
+ return u;
+}
+
+Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+ if (!util.isString(url)) {
+ throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+ }
+
+ // Copy chrome, IE, opera backslash-handling behavior.
+ // Back slashes before the query string get converted to forward slashes
+ // See: https://code.google.com/p/chromium/issues/detail?id=25916
+ var queryIndex = url.indexOf('?'),
+ splitter =
+ (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+ uSplit = url.split(splitter),
+ slashRegex = /\\/g;
+ uSplit[0] = uSplit[0].replace(slashRegex, '/');
+ url = uSplit.join(splitter);
+
+ var rest = url;
+
+ // trim before proceeding.
+ // This is to support parse stuff like " http://foo.com \n"
+ rest = rest.trim();
+
+ if (!slashesDenoteHost && url.split('#').length === 1) {
+ // Try fast path regexp
+ var simplePath = simplePathPattern.exec(rest);
+ if (simplePath) {
+ this.path = rest;
+ this.href = rest;
+ this.pathname = simplePath[1];
+ if (simplePath[2]) {
+ this.search = simplePath[2];
+ if (parseQueryString) {
+ this.query = querystring.parse(this.search.substr(1));
+ } else {
+ this.query = this.search.substr(1);
+ }
+ } else if (parseQueryString) {
+ this.search = '';
+ this.query = {};
+ }
+ return this;
+ }
+ }
+
+ var proto = protocolPattern.exec(rest);
+ if (proto) {
+ proto = proto[0];
+ var lowerProto = proto.toLowerCase();
+ this.protocol = lowerProto;
+ rest = rest.substr(proto.length);
+ }
+
+ // figure out if it's got a host
+ // user@server is *always* interpreted as a hostname, and url
+ // resolution will treat //foo/bar as host=foo,path=bar because that's
+ // how the browser resolves relative URLs.
+ if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+ var slashes = rest.substr(0, 2) === '//';
+ if (slashes && !(proto && hostlessProtocol[proto])) {
+ rest = rest.substr(2);
+ this.slashes = true;
+ }
+ }
+
+ if (!hostlessProtocol[proto] &&
+ (slashes || (proto && !slashedProtocol[proto]))) {
+
+ // there's a hostname.
+ // the first instance of /, ?, ;, or # ends the host.
+ //
+ // If there is an @ in the hostname, then non-host chars *are* allowed
+ // to the left of the last @ sign, unless some host-ending character
+ // comes *before* the @-sign.
+ // URLs are obnoxious.
+ //
+ // ex:
+ // http://a@b@c/ => user:a@b host:c
+ // http://a@b?@c => user:a host:c path:/?@c
+
+ // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+ // Review our test case against browsers more comprehensively.
+
+ // find the first instance of any hostEndingChars
+ var hostEnd = -1;
+ for (var i = 0; i < hostEndingChars.length; i++) {
+ var hec = rest.indexOf(hostEndingChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+
+ // at this point, either we have an explicit point where the
+ // auth portion cannot go past, or the last @ char is the decider.
+ var auth, atSign;
+ if (hostEnd === -1) {
+ // atSign can be anywhere.
+ atSign = rest.lastIndexOf('@');
+ } else {
+ // atSign must be in auth portion.
+ // http://a@b/c@d => host:b auth:a path:/c@d
+ atSign = rest.lastIndexOf('@', hostEnd);
+ }
+
+ // Now we have a portion which is definitely the auth.
+ // Pull that off.
+ if (atSign !== -1) {
+ auth = rest.slice(0, atSign);
+ rest = rest.slice(atSign + 1);
+ this.auth = decodeURIComponent(auth);
+ }
+
+ // the host is the remaining to the left of the first non-host char
+ hostEnd = -1;
+ for (var i = 0; i < nonHostChars.length; i++) {
+ var hec = rest.indexOf(nonHostChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+ // if we still have not hit it, then the entire thing is a host.
+ if (hostEnd === -1)
+ hostEnd = rest.length;
+
+ this.host = rest.slice(0, hostEnd);
+ rest = rest.slice(hostEnd);
+
+ // pull out port.
+ this.parseHost();
+
+ // we've indicated that there is a hostname,
+ // so even if it's empty, it has to be present.
+ this.hostname = this.hostname || '';
+
+ // if hostname begins with [ and ends with ]
+ // assume that it's an IPv6 address.
+ var ipv6Hostname = this.hostname[0] === '[' &&
+ this.hostname[this.hostname.length - 1] === ']';
+
+ // validate a little.
+ if (!ipv6Hostname) {
+ var hostparts = this.hostname.split(/\./);
+ for (var i = 0, l = hostparts.length; i < l; i++) {
+ var part = hostparts[i];
+ if (!part) continue;
+ if (!part.match(hostnamePartPattern)) {
+ var newpart = '';
+ for (var j = 0, k = part.length; j < k; j++) {
+ if (part.charCodeAt(j) > 127) {
+ // we replace non-ASCII char with a temporary placeholder
+ // we need this to make sure size of hostname is not
+ // broken by replacing non-ASCII by nothing
+ newpart += 'x';
+ } else {
+ newpart += part[j];
+ }
+ }
+ // we test again with ASCII char only
+ if (!newpart.match(hostnamePartPattern)) {
+ var validParts = hostparts.slice(0, i);
+ var notHost = hostparts.slice(i + 1);
+ var bit = part.match(hostnamePartStart);
+ if (bit) {
+ validParts.push(bit[1]);
+ notHost.unshift(bit[2]);
+ }
+ if (notHost.length) {
+ rest = '/' + notHost.join('.') + rest;
+ }
+ this.hostname = validParts.join('.');
+ break;
+ }
+ }
+ }
+ }
+
+ if (this.hostname.length > hostnameMaxLen) {
+ this.hostname = '';
+ } else {
+ // hostnames are always lower case.
+ this.hostname = this.hostname.toLowerCase();
+ }
+
+ if (!ipv6Hostname) {
+ // IDNA Support: Returns a punycoded representation of "domain".
+ // It only converts parts of the domain name that
+ // have non-ASCII characters, i.e. it doesn't matter if
+ // you call it with a domain that already is ASCII-only.
+ this.hostname = punycode.toASCII(this.hostname);
+ }
+
+ var p = this.port ? ':' + this.port : '';
+ var h = this.hostname || '';
+ this.host = h + p;
+ this.href += this.host;
+
+ // strip [ and ] from the hostname
+ // the host field still retains them, though
+ if (ipv6Hostname) {
+ this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+ if (rest[0] !== '/') {
+ rest = '/' + rest;
+ }
+ }
+ }
+
+ // now rest is set to the post-host stuff.
+ // chop off any delim chars.
+ if (!unsafeProtocol[lowerProto]) {
+
+ // First, make 100% sure that any "autoEscape" chars get
+ // escaped, even if encodeURIComponent doesn't think they
+ // need to be.
+ for (var i = 0, l = autoEscape.length; i < l; i++) {
+ var ae = autoEscape[i];
+ if (rest.indexOf(ae) === -1)
+ continue;
+ var esc = encodeURIComponent(ae);
+ if (esc === ae) {
+ esc = escape(ae);
+ }
+ rest = rest.split(ae).join(esc);
+ }
+ }
+
+
+ // chop off from the tail first.
+ var hash = rest.indexOf('#');
+ if (hash !== -1) {
+ // got a fragment string.
+ this.hash = rest.substr(hash);
+ rest = rest.slice(0, hash);
+ }
+ var qm = rest.indexOf('?');
+ if (qm !== -1) {
+ this.search = rest.substr(qm);
+ this.query = rest.substr(qm + 1);
+ if (parseQueryString) {
+ this.query = querystring.parse(this.query);
+ }
+ rest = rest.slice(0, qm);
+ } else if (parseQueryString) {
+ // no query string, but parseQueryString still requested
+ this.search = '';
+ this.query = {};
+ }
+ if (rest) this.pathname = rest;
+ if (slashedProtocol[lowerProto] &&
+ this.hostname && !this.pathname) {
+ this.pathname = '/';
+ }
+
+ //to support http.request
+ if (this.pathname || this.search) {
+ var p = this.pathname || '';
+ var s = this.search || '';
+ this.path = p + s;
+ }
+
+ // finally, reconstruct the href based on what has been validated.
+ this.href = this.format();
+ return this;
+};
+
+// format a parsed object into a url string
+function urlFormat(obj) {
+ // ensure it's an object, and not a string url.
+ // If it's an obj, this is a no-op.
+ // this way, you can call url_format() on strings
+ // to clean up potentially wonky urls.
+ if (util.isString(obj)) obj = urlParse(obj);
+ if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+ return obj.format();
+}
+
+Url.prototype.format = function() {
+ var auth = this.auth || '';
+ if (auth) {
+ auth = encodeURIComponent(auth);
+ auth = auth.replace(/%3A/i, ':');
+ auth += '@';
+ }
+
+ var protocol = this.protocol || '',
+ pathname = this.pathname || '',
+ hash = this.hash || '',
+ host = false,
+ query = '';
+
+ if (this.host) {
+ host = auth + this.host;
+ } else if (this.hostname) {
+ host = auth + (this.hostname.indexOf(':') === -1 ?
+ this.hostname :
+ '[' + this.hostname + ']');
+ if (this.port) {
+ host += ':' + this.port;
+ }
+ }
+
+ if (this.query &&
+ util.isObject(this.query) &&
+ Object.keys(this.query).length) {
+ query = querystring.stringify(this.query);
+ }
+
+ var search = this.search || (query && ('?' + query)) || '';
+
+ if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+ // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
+ // unless they had them to begin with.
+ if (this.slashes ||
+ (!protocol || slashedProtocol[protocol]) && host !== false) {
+ host = '//' + (host || '');
+ if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+ } else if (!host) {
+ host = '';
+ }
+
+ if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+ if (search && search.charAt(0) !== '?') search = '?' + search;
+
+ pathname = pathname.replace(/[?#]/g, function(match) {
+ return encodeURIComponent(match);
+ });
+ search = search.replace('#', '%23');
+
+ return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+ return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function(relative) {
+ return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+ if (!source) return relative;
+ return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function(relative) {
+ if (util.isString(relative)) {
+ var rel = new Url();
+ rel.parse(relative, false, true);
+ relative = rel;
+ }
+
+ var result = new Url();
+ var tkeys = Object.keys(this);
+ for (var tk = 0; tk < tkeys.length; tk++) {
+ var tkey = tkeys[tk];
+ result[tkey] = this[tkey];
+ }
+
+ // hash is always overridden, no matter what.
+ // even href="" will remove it.
+ result.hash = relative.hash;
+
+ // if the relative url is empty, then there's nothing left to do here.
+ if (relative.href === '') {
+ result.href = result.format();
+ return result;
+ }
+
+ // hrefs like //foo/bar always cut to the protocol.
+ if (relative.slashes && !relative.protocol) {
+ // take everything except the protocol from relative
+ var rkeys = Object.keys(relative);
+ for (var rk = 0; rk < rkeys.length; rk++) {
+ var rkey = rkeys[rk];
+ if (rkey !== 'protocol')
+ result[rkey] = relative[rkey];
+ }
+
+ //urlParse appends trailing / to urls like http://www.example.com
+ if (slashedProtocol[result.protocol] &&
+ result.hostname && !result.pathname) {
+ result.path = result.pathname = '/';
+ }
+
+ result.href = result.format();
+ return result;
+ }
+
+ if (relative.protocol && relative.protocol !== result.protocol) {
+ // if it's a known url protocol, then changing
+ // the protocol does weird things
+ // first, if it's not file:, then we MUST have a host,
+ // and if there was a path
+ // to begin with, then we MUST have a path.
+ // if it is file:, then the host is dropped,
+ // because that's known to be hostless.
+ // anything else is assumed to be absolute.
+ if (!slashedProtocol[relative.protocol]) {
+ var keys = Object.keys(relative);
+ for (var v = 0; v < keys.length; v++) {
+ var k = keys[v];
+ result[k] = relative[k];
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ result.protocol = relative.protocol;
+ if (!relative.host && !hostlessProtocol[relative.protocol]) {
+ var relPath = (relative.pathname || '').split('/');
+ while (relPath.length && !(relative.host = relPath.shift()));
+ if (!relative.host) relative.host = '';
+ if (!relative.hostname) relative.hostname = '';
+ if (relPath[0] !== '') relPath.unshift('');
+ if (relPath.length < 2) relPath.unshift('');
+ result.pathname = relPath.join('/');
+ } else {
+ result.pathname = relative.pathname;
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ result.host = relative.host || '';
+ result.auth = relative.auth;
+ result.hostname = relative.hostname || relative.host;
+ result.port = relative.port;
+ // to support http.request
+ if (result.pathname || result.search) {
+ var p = result.pathname || '';
+ var s = result.search || '';
+ result.path = p + s;
+ }
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+ }
+
+ var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+ isRelAbs = (
+ relative.host ||
+ relative.pathname && relative.pathname.charAt(0) === '/'
+ ),
+ mustEndAbs = (isRelAbs || isSourceAbs ||
+ (result.host && relative.pathname)),
+ removeAllDots = mustEndAbs,
+ srcPath = result.pathname && result.pathname.split('/') || [],
+ relPath = relative.pathname && relative.pathname.split('/') || [],
+ psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+ // if the url is a non-slashed url, then relative
+ // links like ../.. should be able
+ // to crawl up to the hostname, as well. This is strange.
+ // result.protocol has already been set by now.
+ // Later on, put the first path part into the host field.
+ if (psychotic) {
+ result.hostname = '';
+ result.port = null;
+ if (result.host) {
+ if (srcPath[0] === '') srcPath[0] = result.host;
+ else srcPath.unshift(result.host);
+ }
+ result.host = '';
+ if (relative.protocol) {
+ relative.hostname = null;
+ relative.port = null;
+ if (relative.host) {
+ if (relPath[0] === '') relPath[0] = relative.host;
+ else relPath.unshift(relative.host);
+ }
+ relative.host = null;
+ }
+ mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+ }
+
+ if (isRelAbs) {
+ // it's absolute.
+ result.host = (relative.host || relative.host === '') ?
+ relative.host : result.host;
+ result.hostname = (relative.hostname || relative.hostname === '') ?
+ relative.hostname : result.hostname;
+ result.search = relative.search;
+ result.query = relative.query;
+ srcPath = relPath;
+ // fall through to the dot-handling below.
+ } else if (relPath.length) {
+ // it's relative
+ // throw away the existing file, and take the new path instead.
+ if (!srcPath) srcPath = [];
+ srcPath.pop();
+ srcPath = srcPath.concat(relPath);
+ result.search = relative.search;
+ result.query = relative.query;
+ } else if (!util.isNullOrUndefined(relative.search)) {
+ // just pull out the search.
+ // like href='?foo'.
+ // Put this after the other two cases because it simplifies the booleans
+ if (psychotic) {
+ result.hostname = result.host = srcPath.shift();
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ //to support http.request
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ if (!srcPath.length) {
+ // no path at all. easy.
+ // we've already handled the other stuff above.
+ result.pathname = null;
+ //to support http.request
+ if (result.search) {
+ result.path = '/' + result.search;
+ } else {
+ result.path = null;
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ // if a url ENDs in . or .., then it must get a trailing slash.
+ // however, if it ends in anything else non-slashy,
+ // then it must NOT get a trailing slash.
+ var last = srcPath.slice(-1)[0];
+ var hasTrailingSlash = (
+ (result.host || relative.host || srcPath.length > 1) &&
+ (last === '.' || last === '..') || last === '');
+
+ // strip single dots, resolve double dots to parent dir
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = srcPath.length; i >= 0; i--) {
+ last = srcPath[i];
+ if (last === '.') {
+ srcPath.splice(i, 1);
+ } else if (last === '..') {
+ srcPath.splice(i, 1);
+ up++;
+ } else if (up) {
+ srcPath.splice(i, 1);
+ up--;
+ }
+ }
+
+ // if the path is allowed to go above the root, restore leading ..s
+ if (!mustEndAbs && !removeAllDots) {
+ for (; up--; up) {
+ srcPath.unshift('..');
+ }
+ }
+
+ if (mustEndAbs && srcPath[0] !== '' &&
+ (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+ srcPath.unshift('');
+ }
+
+ if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+ srcPath.push('');
+ }
+
+ var isAbsolute = srcPath[0] === '' ||
+ (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+ // put the host back
+ if (psychotic) {
+ result.hostname = result.host = isAbsolute ? '' :
+ srcPath.length ? srcPath.shift() : '';
+ //occationaly the auth can get stuck only in host
+ //this especially happens in cases like
+ //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+
+ mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+ if (mustEndAbs && !isAbsolute) {
+ srcPath.unshift('');
+ }
+
+ if (!srcPath.length) {
+ result.pathname = null;
+ result.path = null;
+ } else {
+ result.pathname = srcPath.join('/');
+ }
+
+ //to support request.http
+ if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.auth = relative.auth || result.auth;
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+};
+
+Url.prototype.parseHost = function() {
+ var host = this.host;
+ var port = portPattern.exec(host);
+ if (port) {
+ port = port[0];
+ if (port !== ':') {
+ this.port = port.substr(1);
+ }
+ host = host.substr(0, host.length - port.length);
+ }
+ if (host) this.hostname = host;
+};
+
+},{"./util":56,"punycode":38,"querystring":41}],56:[function(require,module,exports){
+'use strict';
+
+module.exports = {
+ isString: function(arg) {
+ return typeof(arg) === 'string';
+ },
+ isObject: function(arg) {
+ return typeof(arg) === 'object' && arg !== null;
+ },
+ isNull: function(arg) {
+ return arg === null;
+ },
+ isNullOrUndefined: function(arg) {
+ return arg == null;
+ }
+};
+
+},{}],57:[function(require,module,exports){
+(function (global){
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+ if (config('noDeprecation')) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (config('throwDeprecation')) {
+ throw new Error(msg);
+ } else if (config('traceDeprecation')) {
+ console.trace(msg);
+ } else {
+ console.warn(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+ // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+ try {
+ if (!global.localStorage) return false;
+ } catch (_) {
+ return false;
+ }
+ var val = global.localStorage[name];
+ if (null == val) return false;
+ return String(val).toLowerCase() === 'true';
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],58:[function(require,module,exports){
+module.exports = extend
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ for (var key in source) {
+ if (hasOwnProperty.call(source, key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+
+ return target
+}
+
+},{}]},{},[1])(1)
+});
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.manifold = f()}})(function(){var define,module,exports;return (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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o
+///
+
+var Manifold;
+(function (Manifold) {
+ var Bootstrapper = (function () {
+ function Bootstrapper(options) {
+ this._options = options;
+ this._options.locale = this._options.locale || 'en-GB'; // default locale
+ }
+ Bootstrapper.prototype.bootstrap = function () {
+ var that = this;
+ return new Promise(function (resolve, reject) {
+ var msie = that._msieversion();
+ // if not a recent version of IE
+ if (msie > 0 && msie < 11) {
+ if (msie === 9) {
+ // CORS not available, use jsonp
+ var settings = {
+ url: that._options.iiifResourceUri,
+ type: 'GET',
+ dataType: 'jsonp',
+ jsonp: 'callback',
+ jsonpCallback: 'manifestCallback'
+ };
+ $.ajax(settings);
+ window.manifestCallback = function (json) {
+ that._loaded(that, JSON.stringify(json), resolve, reject);
+ };
+ }
+ else if (msie === 10) {
+ $.getJSON(that._options.iiifResourceUri, function (json) {
+ that._loaded(that, JSON.stringify(json), resolve, reject);
+ });
+ }
+ }
+ else {
+ manifesto.loadManifest(that._options.iiifResourceUri).then(function (json) {
+ that._loaded(that, json, resolve, reject);
+ });
+ }
+ });
+ };
+ Bootstrapper.prototype._loaded = function (bootstrapper, json, resolve, reject) {
+ var iiifResource = manifesto.create(json, {
+ locale: bootstrapper._options.locale
+ });
+ // only set the root IIIFResource on the first load
+ if (!bootstrapper._options.iiifResource) {
+ bootstrapper._options.iiifResource = iiifResource;
+ }
+ if (iiifResource.getIIIFResourceType().toString() === manifesto.IIIFResourceType.collection().toString()) {
+ // if it's a collection and has child collections, get the collection by index
+ var collections = iiifResource.getCollections();
+ if (collections && collections.length) {
+ iiifResource.getCollectionByIndex(bootstrapper._options.collectionIndex).then(function (collection) {
+ if (!collection) {
+ reject('Collection index not found');
+ }
+ // Special case: we're trying to load the first manifest of the
+ // collection, but the collection has no manifests but does have
+ // subcollections. Thus, we should dive in until we find something
+ // we can display!
+ if (collection.getTotalManifests() === 0 && bootstrapper._options.manifestIndex === 0 && collection.getTotalCollections() > 0) {
+ bootstrapper._options.collectionIndex = 0;
+ bootstrapper._options.iiifResourceUri = collection.id;
+ bootstrapper.bootstrap();
+ }
+ collection.getManifestByIndex(bootstrapper._options.manifestIndex).then(function (manifest) {
+ bootstrapper._options.manifest = manifest;
+ var helper = new Manifold.Helper(bootstrapper._options);
+ resolve(helper);
+ });
+ });
+ }
+ else {
+ iiifResource.getManifestByIndex(bootstrapper._options.manifestIndex).then(function (manifest) {
+ bootstrapper._options.manifest = manifest;
+ var helper = new Manifold.Helper(bootstrapper._options);
+ resolve(helper);
+ });
+ }
+ }
+ else {
+ bootstrapper._options.manifest = iiifResource;
+ var helper = new Manifold.Helper(bootstrapper._options);
+ resolve(helper);
+ }
+ };
+ Bootstrapper.prototype._msieversion = function () {
+ var ua = window.navigator.userAgent;
+ var msie = ua.indexOf("MSIE ");
+ if (msie > 0) {
+ return parseInt(ua.substring(msie + 5, ua.indexOf(".", msie)));
+ }
+ else {
+ return 0;
+ }
+ };
+ return Bootstrapper;
+ }());
+ Manifold.Bootstrapper = Bootstrapper;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var ExternalResource = (function () {
+ function ExternalResource(resource, dataUriFunc) {
+ this.isResponseHandled = false;
+ resource.externalResource = this;
+ this.dataUri = dataUriFunc(resource);
+ this._parseAuthServices(resource);
+ }
+ ExternalResource.prototype._parseAuthServices = function (resource) {
+ this.clickThroughService = manifesto.Utils.getService(resource, manifesto.ServiceProfile.clickThrough().toString());
+ this.loginService = manifesto.Utils.getService(resource, manifesto.ServiceProfile.login().toString());
+ this.restrictedService = manifesto.Utils.getService(resource, manifesto.ServiceProfile.restricted().toString());
+ // todo: create this.preferredService?
+ if (this.clickThroughService) {
+ this.logoutService = this.clickThroughService.getService(manifesto.ServiceProfile.logout().toString());
+ this.tokenService = this.clickThroughService.getService(manifesto.ServiceProfile.token().toString());
+ }
+ else if (this.loginService) {
+ this.logoutService = this.loginService.getService(manifesto.ServiceProfile.logout().toString());
+ this.tokenService = this.loginService.getService(manifesto.ServiceProfile.token().toString());
+ }
+ else if (this.restrictedService) {
+ this.logoutService = this.restrictedService.getService(manifesto.ServiceProfile.logout().toString());
+ this.tokenService = this.restrictedService.getService(manifesto.ServiceProfile.token().toString());
+ }
+ };
+ ExternalResource.prototype.isAccessControlled = function () {
+ if (this.clickThroughService || this.loginService || this.restrictedService) {
+ return true;
+ }
+ return false;
+ };
+ ExternalResource.prototype.hasServiceDescriptor = function () {
+ return this.dataUri.endsWith('info.json');
+ };
+ ExternalResource.prototype.getData = function (accessToken) {
+ var that = this;
+ that.data = {};
+ return new Promise(function (resolve, reject) {
+ // check if dataUri ends with info.json
+ // if not issue a HEAD request.
+ var type = 'GET';
+ if (!that.hasServiceDescriptor()) {
+ // If access control is unnecessary, short circuit the process.
+ // Note that isAccessControlled check for short-circuiting only
+ // works in the "binary resource" context, since in that case,
+ // we know about access control from the manifest. For image
+ // resources, we need to check info.json for details and can't
+ // short-circuit like this.
+ if (!that.isAccessControlled()) {
+ that.status = HTTPStatusCode.OK;
+ resolve(that);
+ return;
+ }
+ type = 'HEAD';
+ }
+ $.ajax({
+ url: that.dataUri,
+ type: type,
+ dataType: 'json',
+ beforeSend: function (xhr) {
+ if (accessToken) {
+ xhr.setRequestHeader("Authorization", "Bearer " + accessToken.accessToken);
+ }
+ }
+ }).done(function (data) {
+ // if it's a resource without an info.json
+ // todo: if resource doesn't have a @profile
+ if (!data) {
+ that.status = HTTPStatusCode.OK;
+ resolve(that);
+ }
+ else {
+ var uri = unescape(data['@id']);
+ that.data = data;
+ that._parseAuthServices(that.data);
+ // remove trailing /info.json
+ if (uri.endsWith('/info.json')) {
+ uri = uri.substr(0, uri.lastIndexOf('/'));
+ }
+ var dataUri = that.dataUri;
+ if (dataUri.endsWith('/info.json')) {
+ dataUri = dataUri.substr(0, dataUri.lastIndexOf('/'));
+ }
+ // if the request was redirected to a degraded version and there's a login service to get the full quality version
+ if (uri !== dataUri && that.loginService) {
+ that.status = HTTPStatusCode.MOVED_TEMPORARILY;
+ }
+ else {
+ that.status = HTTPStatusCode.OK;
+ }
+ resolve(that);
+ }
+ }).fail(function (error) {
+ that.status = error.status;
+ that.error = error;
+ if (error.responseJSON) {
+ that._parseAuthServices(error.responseJSON);
+ }
+ resolve(that);
+ });
+ });
+ };
+ return ExternalResource;
+ }());
+ Manifold.ExternalResource = ExternalResource;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var Helper = (function () {
+ function Helper(options) {
+ this.options = options;
+ this.iiifResource = this.options.iiifResource;
+ this.iiifResourceUri = this.options.iiifResourceUri;
+ this.manifest = this.options.manifest;
+ this.collectionIndex = this.options.collectionIndex || 0;
+ this.manifestIndex = this.options.manifestIndex || 0;
+ this.sequenceIndex = this.options.sequenceIndex || 0;
+ this.canvasIndex = this.options.canvasIndex || 0;
+ }
+ // getters //
+ Helper.prototype.getAutoCompleteService = function () {
+ var service = this.getSearchWithinService();
+ if (!service)
+ return null;
+ return service.getService(manifesto.ServiceProfile.autoComplete());
+ };
+ Helper.prototype.getAttribution = function () {
+ return Manifesto.TranslationCollection.getValue(this.manifest.getAttribution());
+ };
+ Helper.prototype.getCanvases = function () {
+ return this.getCurrentSequence().getCanvases();
+ };
+ Helper.prototype.getCanvasById = function (id) {
+ return this.getCurrentSequence().getCanvasById(id);
+ };
+ Helper.prototype.getCanvasesById = function (ids) {
+ var canvases = [];
+ for (var i = 0; i < ids.length; i++) {
+ var id = ids[i];
+ canvases.push(this.getCanvasById(id));
+ }
+ return canvases;
+ };
+ Helper.prototype.getCanvasByIndex = function (index) {
+ return this.getCurrentSequence().getCanvasByIndex(index);
+ };
+ Helper.prototype.getCanvasIndexById = function (id) {
+ return this.getCurrentSequence().getCanvasIndexById(id);
+ };
+ Helper.prototype.getCanvasIndexByLabel = function (label) {
+ var foliated = this.getManifestType().toString() === manifesto.ManifestType.manuscript().toString();
+ return this.getCurrentSequence().getCanvasIndexByLabel(label, foliated);
+ };
+ Helper.prototype.getCanvasRange = function (canvas, path) {
+ var ranges = this.getCanvasRanges(canvas);
+ if (path) {
+ for (var i = 0; i < ranges.length; i++) {
+ var range = ranges[i];
+ if (range.path === path) {
+ return range;
+ }
+ }
+ return null;
+ }
+ else {
+ return ranges[0]; // else return the first range
+ }
+ };
+ Helper.prototype.getCanvasRanges = function (canvas) {
+ if (canvas.ranges) {
+ return canvas.ranges; // cache
+ }
+ else {
+ canvas.ranges = this.manifest.getAllRanges().en().where(function (range) { return (range.getCanvasIds().en().any(function (c) { return c === canvas.id; })); }).toArray();
+ }
+ return canvas.ranges;
+ };
+ Helper.prototype.getCollectionIndex = function (iiifResource) {
+ // todo: support nested collections. walk up parents adding to array and return csv string.
+ var index;
+ if (iiifResource.parentCollection) {
+ index = iiifResource.parentCollection.index;
+ }
+ return index;
+ };
+ Helper.prototype.getCurrentCanvas = function () {
+ return this.getCurrentSequence().getCanvasByIndex(this.canvasIndex);
+ };
+ Helper.prototype.getCurrentElement = function () {
+ return this.getCanvasByIndex(this.canvasIndex);
+ };
+ Helper.prototype.getCurrentSequence = function () {
+ return this.getSequenceByIndex(this.sequenceIndex);
+ };
+ Helper.prototype.getElementType = function (element) {
+ if (!element) {
+ element = this.getCurrentCanvas();
+ }
+ return element.getType();
+ };
+ Helper.prototype.getFirstPageIndex = function () {
+ return 0;
+ };
+ Helper.prototype.getInfoUri = function (canvas) {
+ var images = canvas.getImages();
+ // if the canvas has images it's IIIF
+ if (images && images.length) {
+ var infoUri;
+ var firstImage = images[0];
+ var resource = firstImage.getResource();
+ var services = resource.getServices();
+ for (var i = 0; i < services.length; i++) {
+ var service = services[i];
+ var id = service.id;
+ if (!id.endsWith('/')) {
+ id += '/';
+ }
+ if (manifesto.Utils.isImageProfile(service.getProfile())) {
+ infoUri = id + 'info.json';
+ }
+ }
+ return infoUri;
+ }
+ else {
+ // IxIF
+ var service = canvas.getService(manifesto.ServiceProfile.ixif());
+ if (service) {
+ return service.getInfoUri();
+ }
+ // return the canvas id.
+ return canvas.id;
+ }
+ };
+ Helper.prototype.getLabel = function () {
+ return Manifesto.TranslationCollection.getValue(this.manifest.getLabel());
+ };
+ Helper.prototype.getLastCanvasLabel = function (alphanumeric) {
+ return this.getCurrentSequence().getLastCanvasLabel(alphanumeric);
+ };
+ Helper.prototype.getLastPageIndex = function () {
+ return this.getTotalCanvases() - 1;
+ };
+ Helper.prototype.getLicense = function () {
+ return this.manifest.getLicense();
+ };
+ Helper.prototype.getLogo = function () {
+ return this.manifest.getLogo();
+ };
+ Helper.prototype.getManifestType = function () {
+ var manifestType = this.manifest.getManifestType();
+ // default to monograph
+ if (manifestType.toString() === "") {
+ manifestType = manifesto.ManifestType.monograph();
+ }
+ return manifestType;
+ };
+ Helper.prototype.getMetadata = function (options) {
+ var metadataGroups = [];
+ var manifestMetadata = this.manifest.getMetadata();
+ var manifestGroup = new Manifold.MetadataGroup(this.manifest);
+ if (manifestMetadata && manifestMetadata.length) {
+ manifestGroup.addMetadata(manifestMetadata, true);
+ }
+ if (this.manifest.getDescription().length) {
+ var metadataItem = new Manifesto.MetadataItem(this.options.locale);
+ metadataItem.label = [new Manifesto.Translation("description", this.options.locale)];
+ metadataItem.value = this.manifest.getDescription();
+ metadataItem.isRootLevel = true;
+ manifestGroup.addItem(metadataItem);
+ }
+ if (this.manifest.getAttribution().length) {
+ var metadataItem = new Manifesto.MetadataItem(this.options.locale);
+ metadataItem.label = [new Manifesto.Translation("attribution", this.options.locale)];
+ metadataItem.value = this.manifest.getAttribution();
+ metadataItem.isRootLevel = true;
+ manifestGroup.addItem(metadataItem);
+ }
+ if (this.manifest.getLicense()) {
+ var item = {
+ label: "license",
+ value: (options && options.licenseFormatter) ? options.licenseFormatter.format(this.manifest.getLicense()) : this.manifest.getLicense()
+ };
+ var metadataItem = new Manifesto.MetadataItem(this.options.locale);
+ metadataItem.parse(item);
+ metadataItem.isRootLevel = true;
+ manifestGroup.addItem(metadataItem);
+ }
+ if (this.manifest.getLogo()) {
+ var item = {
+ label: "logo",
+ value: '
 + ')
'
+ };
+ var metadataItem = new Manifesto.MetadataItem(this.options.locale);
+ metadataItem.parse(item);
+ metadataItem.isRootLevel = true;
+ manifestGroup.addItem(metadataItem);
+ }
+ metadataGroups.push(manifestGroup);
+ if (options) {
+ return this._parseMetadataOptions(options, metadataGroups);
+ }
+ else {
+ return metadataGroups;
+ }
+ };
+ Helper.prototype._parseMetadataOptions = function (options, metadataGroups) {
+ // get sequence metadata
+ var sequence = this.getCurrentSequence();
+ var sequenceMetadata = sequence.getMetadata();
+ if (sequenceMetadata && sequenceMetadata.length) {
+ var sequenceGroup = new Manifold.MetadataGroup(sequence);
+ sequenceGroup.addMetadata(sequenceMetadata);
+ metadataGroups.push(sequenceGroup);
+ }
+ // get range metadata
+ if (options.range) {
+ var rangeGroups = this._getRangeMetadata([], options.range);
+ rangeGroups = rangeGroups.reverse();
+ metadataGroups = metadataGroups.concat(rangeGroups);
+ }
+ // get canvas metadata
+ if (options.canvases && options.canvases.length) {
+ for (var i = 0; i < options.canvases.length; i++) {
+ var canvas = options.canvases[i];
+ var canvasMetadata = canvas.getMetadata();
+ if (canvasMetadata && canvasMetadata.length) {
+ var canvasGroup = new Manifold.MetadataGroup(canvas);
+ canvasGroup.addMetadata(canvas.getMetadata());
+ metadataGroups.push(canvasGroup);
+ }
+ // add image metadata
+ var images = canvas.getImages();
+ for (var j = 0; j < images.length; j++) {
+ var image = images[j];
+ var imageMetadata = image.getMetadata();
+ if (imageMetadata && imageMetadata.length) {
+ var imageGroup = new Manifold.MetadataGroup(image);
+ imageGroup.addMetadata(imageMetadata);
+ metadataGroups.push(imageGroup);
+ }
+ }
+ }
+ }
+ return metadataGroups;
+ };
+ Helper.prototype._getRangeMetadata = function (metadataGroups, range) {
+ var rangeMetadata = range.getMetadata();
+ if (rangeMetadata && rangeMetadata.length) {
+ var rangeGroup = new Manifold.MetadataGroup(range);
+ rangeGroup.addMetadata(rangeMetadata);
+ metadataGroups.push(rangeGroup);
+ }
+ if (range.parentRange) {
+ return this._getRangeMetadata(metadataGroups, range.parentRange);
+ }
+ else {
+ return metadataGroups;
+ }
+ };
+ Helper.prototype.getMultiSelectState = function () {
+ if (!this._multiSelectState) {
+ this._multiSelectState = new Manifold.MultiSelectState();
+ this._multiSelectState.ranges = this.getRanges().clone();
+ this._multiSelectState.canvases = this.getCurrentSequence().getCanvases().clone();
+ }
+ return this._multiSelectState;
+ };
+ Helper.prototype.getRanges = function () {
+ return this.manifest.getAllRanges();
+ };
+ Helper.prototype.getRangeByPath = function (path) {
+ return this.manifest.getRangeByPath(path);
+ };
+ Helper.prototype.getRangeCanvases = function (range) {
+ var ids = range.getCanvasIds();
+ return this.getCanvasesById(ids);
+ };
+ Helper.prototype.getRelated = function () {
+ return this.manifest.getRelated();
+ };
+ Helper.prototype.getResources = function () {
+ var element = this.getCurrentElement();
+ return element.getResources();
+ };
+ Helper.prototype.getSearchWithinService = function () {
+ return this.manifest.getService(manifesto.ServiceProfile.searchWithin());
+ };
+ Helper.prototype.getSeeAlso = function () {
+ return this.manifest.getSeeAlso();
+ };
+ Helper.prototype.getSequenceByIndex = function (index) {
+ return this.manifest.getSequenceByIndex(index);
+ };
+ Helper.prototype.getShareServiceUrl = function () {
+ var url;
+ var shareService = this.manifest.getService(manifesto.ServiceProfile.shareExtensions());
+ if (shareService) {
+ if (shareService.length) {
+ shareService = shareService[0];
+ }
+ url = shareService.__jsonld.shareUrl;
+ }
+ return url;
+ };
+ Helper.prototype.getSortedTreeNodesByDate = function (sortedTree, tree) {
+ var all = tree.nodes.en().traverseUnique(function (node) { return node.nodes; })
+ .where(function (n) { return n.data.type === manifesto.TreeNodeType.collection().toString() ||
+ n.data.type === manifesto.TreeNodeType.manifest().toString(); }).toArray();
+ //var collections: ITreeNode[] = tree.nodes.en().traverseUnique(n => n.nodes)
+ // .where((n) => n.data.type === ITreeNodeType.collection().toString()).toArray();
+ var manifests = tree.nodes.en().traverseUnique(function (n) { return n.nodes; })
+ .where(function (n) { return n.data.type === manifesto.TreeNodeType.manifest().toString(); }).toArray();
+ this.createDecadeNodes(sortedTree, all);
+ this.sortDecadeNodes(sortedTree);
+ this.createYearNodes(sortedTree, all);
+ this.sortYearNodes(sortedTree);
+ this.createMonthNodes(sortedTree, manifests);
+ this.sortMonthNodes(sortedTree);
+ this.createDateNodes(sortedTree, manifests);
+ this.pruneDecadeNodes(sortedTree);
+ };
+ Helper.prototype.getStartCanvasIndex = function () {
+ return this.getCurrentSequence().getStartCanvasIndex();
+ };
+ Helper.prototype.getThumbs = function (width, height) {
+ return this.getCurrentSequence().getThumbs(width, height);
+ };
+ Helper.prototype.getTopRanges = function () {
+ return this.manifest.getTopRanges();
+ };
+ Helper.prototype.getTotalCanvases = function () {
+ return this.getCurrentSequence().getTotalCanvases();
+ };
+ Helper.prototype.getTrackingLabel = function () {
+ return this.manifest.getTrackingLabel();
+ };
+ Helper.prototype.getTree = function (topRangeIndex, sortType) {
+ // if it's a collection, use IIIFResource.getDefaultTree()
+ // otherwise, get the top range by index and use Range.getTree()
+ if (topRangeIndex === void 0) { topRangeIndex = 0; }
+ if (sortType === void 0) { sortType = Manifold.TreeSortType.NONE; }
+ var tree;
+ if (this.iiifResource.isCollection()) {
+ tree = this.iiifResource.getDefaultTree();
+ }
+ else {
+ var topRanges = this.iiifResource.getTopRanges();
+ var root = new manifesto.TreeNode();
+ root.label = 'root';
+ root.data = this.iiifResource;
+ if (topRanges.length) {
+ var range = topRanges[topRangeIndex];
+ tree = range.getTree(root);
+ }
+ else {
+ return root;
+ }
+ }
+ var sortedTree = new manifesto.TreeNode();
+ switch (sortType.toString()) {
+ case Manifold.TreeSortType.DATE.toString():
+ // returns a list of treenodes for each decade.
+ // expanding a decade generates a list of years
+ // expanding a year gives a list of months containing issues
+ // expanding a month gives a list of issues.
+ if (this.treeHasNavDates(tree)) {
+ this.getSortedTreeNodesByDate(sortedTree, tree);
+ break;
+ }
+ default:
+ sortedTree = tree;
+ }
+ return sortedTree;
+ };
+ Helper.prototype.treeHasNavDates = function (tree) {
+ var node = tree.nodes.en().traverseUnique(function (node) { return node.nodes; }).where(function (n) { return !isNaN(n.navDate); }).first();
+ return (node) ? true : false;
+ };
+ Helper.prototype.getViewingDirection = function () {
+ var viewingDirection = this.getCurrentSequence().getViewingDirection();
+ if (!viewingDirection.toString()) {
+ viewingDirection = this.manifest.getViewingDirection();
+ }
+ return viewingDirection;
+ };
+ Helper.prototype.getViewingHint = function () {
+ var viewingHint = this.getCurrentSequence().getViewingHint();
+ if (!viewingHint.toString()) {
+ viewingHint = this.manifest.getViewingHint();
+ }
+ return viewingHint;
+ };
+ // inquiries //
+ Helper.prototype.hasParentCollection = function () {
+ return !!this.manifest.parentCollection;
+ };
+ Helper.prototype.hasRelatedPage = function () {
+ var related = this.getRelated();
+ if (!related)
+ return false;
+ if (related.length) {
+ related = related[0];
+ }
+ return related['format'] === 'text/html';
+ };
+ Helper.prototype.hasResources = function () {
+ return this.getResources().length > 0;
+ };
+ Helper.prototype.isBottomToTop = function () {
+ return this.getViewingDirection().toString() === manifesto.ViewingDirection.bottomToTop().toString();
+ };
+ Helper.prototype.isCanvasIndexOutOfRange = function (index) {
+ return this.getCurrentSequence().isCanvasIndexOutOfRange(index);
+ };
+ Helper.prototype.isContinuous = function () {
+ return this.getViewingHint().toString() === manifesto.ViewingHint.continuous().toString();
+ };
+ Helper.prototype.isFirstCanvas = function (index) {
+ if (typeof index !== 'undefined') {
+ return this.getCurrentSequence().isFirstCanvas(index);
+ }
+ return this.getCurrentSequence().isFirstCanvas(this.canvasIndex);
+ };
+ Helper.prototype.isHorizontallyAligned = function () {
+ return this.isLeftToRight() || this.isRightToLeft();
+ };
+ Helper.prototype.isLastCanvas = function (index) {
+ if (typeof index !== 'undefined') {
+ return this.getCurrentSequence().isLastCanvas(index);
+ }
+ return this.getCurrentSequence().isLastCanvas(this.canvasIndex);
+ };
+ Helper.prototype.isLeftToRight = function () {
+ return this.getViewingDirection().toString() === manifesto.ViewingDirection.leftToRight().toString();
+ };
+ Helper.prototype.isMultiCanvas = function () {
+ return this.getCurrentSequence().isMultiCanvas();
+ };
+ Helper.prototype.isMultiSequence = function () {
+ return this.manifest.isMultiSequence();
+ };
+ Helper.prototype.isPaged = function () {
+ return this.getViewingHint().toString() === manifesto.ViewingHint.paged().toString();
+ };
+ Helper.prototype.isPagingAvailable = function () {
+ // paged mode is useless unless you have at least 3 pages...
+ return this.isPagingEnabled() && this.getTotalCanvases() > 2;
+ };
+ Helper.prototype.isPagingEnabled = function () {
+ return (this.manifest.isPagingEnabled() || this.getCurrentSequence().isPagingEnabled());
+ };
+ Helper.prototype.isRightToLeft = function () {
+ return this.getViewingDirection().toString() === manifesto.ViewingDirection.rightToLeft().toString();
+ };
+ Helper.prototype.isTopToBottom = function () {
+ return this.getViewingDirection().toString() === manifesto.ViewingDirection.topToBottom().toString();
+ };
+ Helper.prototype.isTotalCanvasesEven = function () {
+ return this.getCurrentSequence().isTotalCanvasesEven();
+ };
+ Helper.prototype.isUIEnabled = function (name) {
+ var uiExtensions = this.manifest.getService(manifesto.ServiceProfile.uiExtensions());
+ if (uiExtensions) {
+ var disableUI = uiExtensions.getProperty('disableUI');
+ if (disableUI) {
+ if (disableUI.contains(name) || disableUI.contains(name.toLowerCase())) {
+ return false;
+ }
+ }
+ }
+ return true;
+ };
+ Helper.prototype.isVerticallyAligned = function () {
+ return this.isTopToBottom() || this.isBottomToTop();
+ };
+ // dates //
+ Helper.prototype.createDateNodes = function (rootNode, nodes) {
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ var year = this.getNodeYear(node);
+ var month = this.getNodeMonth(node);
+ var dateNode = new manifesto.TreeNode();
+ dateNode.id = node.id;
+ dateNode.label = this.getNodeDisplayDate(node);
+ dateNode.data = node.data;
+ dateNode.data.type = manifesto.TreeNodeType.manifest().toString();
+ dateNode.data.year = year;
+ dateNode.data.month = month;
+ var decadeNode = this.getDecadeNode(rootNode, year);
+ if (decadeNode) {
+ var yearNode = this.getYearNode(decadeNode, year);
+ if (yearNode) {
+ var monthNode = this.getMonthNode(yearNode, month);
+ if (monthNode) {
+ monthNode.addNode(dateNode);
+ }
+ }
+ }
+ }
+ };
+ Helper.prototype.createDecadeNodes = function (rootNode, nodes) {
+ var decadeNode;
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ var year = this.getNodeYear(node);
+ var decade = Number(year.toString().substr(2, 1));
+ var endYear = Number(year.toString().substr(0, 3) + "9");
+ if (!this.getDecadeNode(rootNode, year)) {
+ decadeNode = new manifesto.TreeNode();
+ decadeNode.label = year + " - " + endYear;
+ decadeNode.navDate = node.navDate;
+ decadeNode.data.startYear = year;
+ decadeNode.data.endYear = endYear;
+ rootNode.addNode(decadeNode);
+ }
+ }
+ };
+ Helper.prototype.createMonthNodes = function (rootNode, nodes) {
+ var monthNode;
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ var year = this.getNodeYear(node);
+ var month = this.getNodeMonth(node);
+ var decadeNode = this.getDecadeNode(rootNode, year);
+ var yearNode = this.getYearNode(decadeNode, year);
+ if (decadeNode && yearNode && !this.getMonthNode(yearNode, month)) {
+ monthNode = new manifesto.TreeNode();
+ monthNode.label = this.getNodeDisplayMonth(node);
+ monthNode.navDate = node.navDate;
+ monthNode.data.year = year;
+ monthNode.data.month = month;
+ yearNode.addNode(monthNode);
+ }
+ }
+ };
+ Helper.prototype.createYearNodes = function (rootNode, nodes) {
+ var yearNode;
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ var year = this.getNodeYear(node);
+ var decadeNode = this.getDecadeNode(rootNode, year);
+ if (decadeNode && !this.getYearNode(decadeNode, year)) {
+ yearNode = new manifesto.TreeNode();
+ yearNode.label = year.toString();
+ yearNode.navDate = node.navDate;
+ yearNode.data.year = year;
+ decadeNode.addNode(yearNode);
+ }
+ }
+ };
+ Helper.prototype.getDecadeNode = function (rootNode, year) {
+ for (var i = 0; i < rootNode.nodes.length; i++) {
+ var n = rootNode.nodes[i];
+ if (year >= n.data.startYear && year <= n.data.endYear)
+ return n;
+ }
+ return null;
+ };
+ Helper.prototype.getMonthNode = function (yearNode, month) {
+ for (var i = 0; i < yearNode.nodes.length; i++) {
+ var n = yearNode.nodes[i];
+ if (month === this.getNodeMonth(n))
+ return n;
+ }
+ return null;
+ };
+ Helper.prototype.getNodeDisplayDate = function (node) {
+ return node.navDate.toDateString();
+ };
+ Helper.prototype.getNodeDisplayMonth = function (node) {
+ var months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+ return months[node.navDate.getMonth()];
+ };
+ Helper.prototype.getNodeMonth = function (node) {
+ return node.navDate.getMonth();
+ };
+ Helper.prototype.getNodeYear = function (node) {
+ return node.navDate.getFullYear();
+ };
+ Helper.prototype.getYearNode = function (decadeNode, year) {
+ for (var i = 0; i < decadeNode.nodes.length; i++) {
+ var n = decadeNode.nodes[i];
+ if (year === this.getNodeYear(n))
+ return n;
+ }
+ return null;
+ };
+ // delete any empty decades
+ Helper.prototype.pruneDecadeNodes = function (rootNode) {
+ var pruned = [];
+ for (var i = 0; i < rootNode.nodes.length; i++) {
+ var n = rootNode.nodes[i];
+ if (!n.nodes.length) {
+ pruned.push(n);
+ }
+ }
+ for (var j = 0; j < pruned.length; j++) {
+ var p = pruned[j];
+ rootNode.nodes.remove(p);
+ }
+ };
+ Helper.prototype.sortDecadeNodes = function (rootNode) {
+ rootNode.nodes = rootNode.nodes.sort(function (a, b) {
+ return a.data.startYear - b.data.startYear;
+ });
+ };
+ Helper.prototype.sortMonthNodes = function (rootNode) {
+ var _this = this;
+ for (var i = 0; i < rootNode.nodes.length; i++) {
+ var decadeNode = rootNode.nodes[i];
+ for (var j = 0; j < decadeNode.nodes.length; j++) {
+ var monthNode = decadeNode.nodes[j];
+ monthNode.nodes = monthNode.nodes.sort(function (a, b) {
+ return _this.getNodeMonth(a) - _this.getNodeMonth(b);
+ });
+ }
+ }
+ };
+ Helper.prototype.sortYearNodes = function (rootNode) {
+ var _this = this;
+ for (var i = 0; i < rootNode.nodes.length; i++) {
+ var decadeNode = rootNode.nodes[i];
+ decadeNode.nodes = decadeNode.nodes.sort(function (a, b) {
+ return (_this.getNodeYear(a) - _this.getNodeYear(b));
+ });
+ }
+ };
+ return Helper;
+ }());
+ Manifold.Helper = Helper;
+})(Manifold || (Manifold = {}));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var Manifold;
+(function (Manifold) {
+ function loadManifest(options) {
+ var bootstrapper = new Manifold.Bootstrapper(options);
+ return bootstrapper.bootstrap();
+ }
+ Manifold.loadManifest = loadManifest;
+})(Manifold || (Manifold = {}));
+(function (w) {
+ if (!w.Manifold) {
+ w.Manifold = Manifold;
+ }
+})(window);
+
+var Manifold;
+(function (Manifold) {
+ var MetadataGroup = (function () {
+ function MetadataGroup(resource, label) {
+ this.items = [];
+ this.resource = resource;
+ this.label = label;
+ }
+ MetadataGroup.prototype.addItem = function (item) {
+ this.items.push(item);
+ };
+ MetadataGroup.prototype.addMetadata = function (metadata, isRootLevel) {
+ if (isRootLevel === void 0) { isRootLevel = false; }
+ for (var i = 0; i < metadata.length; i++) {
+ var item = metadata[i];
+ item.isRootLevel = isRootLevel;
+ this.addItem(item);
+ }
+ };
+ return MetadataGroup;
+ }());
+ Manifold.MetadataGroup = MetadataGroup;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var MetadataOptions = (function () {
+ function MetadataOptions() {
+ }
+ return MetadataOptions;
+ }());
+ Manifold.MetadataOptions = MetadataOptions;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var MultiSelectState = (function () {
+ function MultiSelectState() {
+ this.isEnabled = false;
+ this.ranges = [];
+ this.canvases = [];
+ }
+ MultiSelectState.prototype.allCanvasesSelected = function () {
+ return this.canvases.length > 0 && this.getAllSelectedCanvases().length === this.canvases.length;
+ };
+ MultiSelectState.prototype.allRangesSelected = function () {
+ return this.ranges.length > 0 && this.getAllSelectedRanges().length === this.ranges.length;
+ };
+ MultiSelectState.prototype.allSelected = function () {
+ return this.allRangesSelected() && this.allCanvasesSelected();
+ };
+ MultiSelectState.prototype.getAll = function () {
+ return this.canvases.concat(this.ranges);
+ };
+ MultiSelectState.prototype.getAllSelectedCanvases = function () {
+ return this.canvases.en().where(function (c) { return c.multiSelected; }).toArray();
+ };
+ MultiSelectState.prototype.getAllSelectedRanges = function () {
+ return this.ranges.en().where(function (r) { return r.multiSelected; }).toArray();
+ };
+ MultiSelectState.prototype.getCanvasById = function (id) {
+ return this.canvases.en().where(function (c) { return c.id === id; }).first();
+ };
+ MultiSelectState.prototype.getCanvasesByIds = function (ids) {
+ var canvases = [];
+ for (var i = 0; i < ids.length; i++) {
+ var id = ids[i];
+ canvases.push(this.getCanvasById(id));
+ }
+ return canvases;
+ };
+ MultiSelectState.prototype.getRangeCanvases = function (range) {
+ var ids = range.getCanvasIds();
+ return this.getCanvasesByIds(ids);
+ };
+ MultiSelectState.prototype.selectAll = function (selected) {
+ this.selectRanges(this.ranges, selected);
+ this.selectCanvases(this.canvases, selected);
+ };
+ MultiSelectState.prototype.selectCanvas = function (canvas, selected) {
+ var c = this.canvases.en().where(function (c) { return c.id === canvas.id; }).first();
+ c.multiSelected = selected;
+ };
+ MultiSelectState.prototype.selectAllCanvases = function (selected) {
+ this.selectCanvases(this.canvases, selected);
+ };
+ MultiSelectState.prototype.selectCanvases = function (canvases, selected) {
+ for (var j = 0; j < canvases.length; j++) {
+ var canvas = canvases[j];
+ canvas.multiSelected = selected;
+ }
+ };
+ MultiSelectState.prototype.selectRange = function (range, selected) {
+ var r = this.ranges.en().where(function (r) { return r.id === range.id; }).first();
+ r.multiSelected = selected;
+ var canvases = this.getRangeCanvases(r);
+ this.selectCanvases(canvases, selected);
+ };
+ MultiSelectState.prototype.selectAllRanges = function (selected) {
+ this.selectRanges(this.ranges, selected);
+ };
+ MultiSelectState.prototype.selectRanges = function (ranges, selected) {
+ for (var i = 0; i < ranges.length; i++) {
+ var range = ranges[i];
+ range.multiSelected = selected;
+ var canvases = this.getCanvasesByIds(range.getCanvasIds());
+ this.selectCanvases(canvases, selected);
+ }
+ };
+ MultiSelectState.prototype.setEnabled = function (enabled) {
+ this.isEnabled = enabled;
+ var items = this.getAll();
+ for (var i = 0; i < items.length; i++) {
+ var item = items[i];
+ item.multiSelectEnabled = this.isEnabled;
+ if (!enabled) {
+ item.multiSelected = false;
+ }
+ }
+ };
+ return MultiSelectState;
+ }());
+ Manifold.MultiSelectState = MultiSelectState;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var SearchResult = (function () {
+ function SearchResult(resource, canvasIndex) {
+ this.rects = [];
+ this.canvasIndex = canvasIndex;
+ this.addRect(resource);
+ }
+ SearchResult.prototype.addRect = function (resource) {
+ var rect = new Manifold.SearchResultRect(resource);
+ rect.canvasIndex = this.canvasIndex;
+ rect.index = this.rects.length;
+ this.rects.push(rect);
+ // sort ascending
+ this.rects.sort(function (a, b) {
+ return a.index - b.index;
+ });
+ };
+ return SearchResult;
+ }());
+ Manifold.SearchResult = SearchResult;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var SearchResultRect = (function () {
+ function SearchResultRect(result) {
+ this.isVisible = true;
+ var xywh = result.on.match(/.*xywh=(\d*),(\d*),(\d*),(\d*)/);
+ this.x = Number(xywh[1]);
+ this.y = Number(xywh[2]);
+ this.width = Number(xywh[3]);
+ this.height = Number(xywh[4]);
+ this.chars = result.resource.chars;
+ }
+ return SearchResultRect;
+ }());
+ Manifold.SearchResultRect = SearchResultRect;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ var Translation = (function () {
+ function Translation(value, locale) {
+ this.value = value;
+ this.locale = locale;
+ }
+ return Translation;
+ }());
+ Manifold.Translation = Translation;
+})(Manifold || (Manifold = {}));
+
+var Manifold;
+(function (Manifold) {
+ // This class formats URIs into HTML links, applying labels when available
+ var UriLabeller = (function () {
+ function UriLabeller(labels) {
+ this.labels = labels;
+ }
+ UriLabeller.prototype.format = function (url) {
+ // if already a link, do nothing.
+ if (url.indexOf('' + label + '';
+ };
+ return UriLabeller;
+ }());
+ Manifold.UriLabeller = UriLabeller;
+})(Manifold || (Manifold = {}));
+
+},{}]},{},[1])(1)
});
-(function(t,e,o){"use strict";function r(t,e,r,p){r=r||"width";var n,l,m,c=(e.match(s)||[])[2],f="px"===c?1:d[c+"toPx"],u=/r?em/i;if(f||u.test(c)&&!p)t=f?t:"rem"===c?i:"fontSize"===r?t.parentNode||t:t,f=f||parseFloat(a(t,"fontSize")),m=parseFloat(e)*f;else{n=t.style,l=n[r];try{n[r]=e}catch(x){return 0}m=n[r]?parseFloat(a(t,r)):0,n[r]=l!==o?l:null}return m}function a(t,e){var o,n,i,l,d,c=/^top|bottom/,f=["paddingTop","paddingBottom","borderTop","borderBottom"],u=4;if(o=m?m(t)[e]:(n=t.style["pixel"+e.charAt(0).toUpperCase()+e.slice(1)])?n+"px":"fontSize"===e?r(t,"1em","left",1)+"px":t.currentStyle[e],i=(o.match(s)||[])[2],"%"===i&&p)if(c.test(e)){for(l=(d=t.parentNode||t).offsetHeight;u--;)l-=parseFloat(a(d,f[u]));o=parseFloat(o)/100*l+"px"}else o=r(t,o);else("auto"===o||i&&"px"!==i)&&m?o=0:i&&"px"!==i&&!m&&(o=r(t,o)+"px");return o}var p,n=e.createElement("test"),i=e.documentElement,l=e.defaultView,m=l&&l.getComputedStyle,s=/^(-?[\d+\.\-]+)([a-z]+|%)$/i,d={},c=[1/25.4,1/2.54,1/72,1/6],f=["mm","cm","pt","pc","in","mozmm"],u=6;for(i.appendChild(n),m&&(n.style.marginTop="1%",p="1%"===m(n).marginTop);u--;)d[f[u]+"toPx"]=c[u]?c[u]*d.inToPx:r(n,"1"+f[u]);i.removeChild(n),n=o,t.Length={toPx:r}})(this,this.document);
-/*
-//@ sourceMappingURL=Length.min.js.map
+(function(t,e,o){"use strict";function r(t,e,r,p){r=r||"width";var n,l,m,c=(e.match(s)||[])[2],f="px"===c?1:d[c+"toPx"],u=/r?em/i;if(f||u.test(c)&&!p)t=f?t:"rem"===c?i:"fontSize"===r?t.parentNode||t:t,f=f||parseFloat(a(t,"fontSize")),m=parseFloat(e)*f;else{n=t.style,l=n[r];try{n[r]=e}catch(x){return 0}m=n[r]?parseFloat(a(t,r)):0,n[r]=l!==o?l:null}return m}function a(t,e){var o,n,i,l,d,c=/^top|bottom/,f=["paddingTop","paddingBottom","borderTop","borderBottom"],u=4;if(o=m?m(t)[e]:(n=t.style["pixel"+e.charAt(0).toUpperCase()+e.slice(1)])?n+"px":"fontSize"===e?r(t,"1em","left",1)+"px":t.currentStyle[e],i=(o.match(s)||[])[2],"%"===i&&p)if(c.test(e)){for(l=(d=t.parentNode||t).offsetHeight;u--;)l-=parseFloat(a(d,f[u]));o=parseFloat(o)/100*l+"px"}else o=r(t,o);else("auto"===o||i&&"px"!==i)&&m?o=0:i&&"px"!==i&&!m&&(o=r(t,o)+"px");return o}var p,n=e.createElement("test"),i=e.documentElement,l=e.defaultView,m=l&&l.getComputedStyle,s=/^(-?[\d+\.\-]+)([a-z]+|%)$/i,d={},c=[1/25.4,1/2.54,1/72,1/6],f=["mm","cm","pt","pc","in","mozmm"],u=6;for(i.appendChild(n),m&&(n.style.marginTop="1%",p="1%"===m(n).marginTop);u--;)d[f[u]+"toPx"]=c[u]?c[u]*d.inToPx:r(n,"1"+f[u]);i.removeChild(n),n=o,t.Length={toPx:r}})(this,this.document);
+/*
+//@ sourceMappingURL=Length.min.js.map
*/
-var Utils;
-(function (Utils) {
- var Async = (function () {
- function Async() {
- }
- Async.waitFor = function (test, successCallback, failureCallback, interval, maxTries, numTries) {
- if (!interval)
- interval = 200;
- if (!maxTries)
- maxTries = 100; // try 100 times over 20 seconds
- if (!numTries)
- numTries = 0;
- numTries += 1;
- if (numTries > maxTries) {
- if (failureCallback)
- failureCallback();
- }
- else if (test()) {
- successCallback();
- }
- else {
- setTimeout(function () {
- Async.waitFor(test, successCallback, failureCallback, interval, maxTries, numTries);
- }, interval);
- }
- };
- return Async;
- })();
- Utils.Async = Async;
-})(Utils || (Utils = {}));
-var Utils;
-(function (Utils) {
- var Bools = (function () {
- function Bools() {
- }
- Bools.getBool = function (val, defaultVal) {
- if (val === null || typeof (val) === 'undefined') {
- return defaultVal;
- }
- return val;
- };
- return Bools;
- })();
- Utils.Bools = Bools;
-})(Utils || (Utils = {}));
-var Utils;
-(function (Utils) {
- var Clipboard = (function () {
- function Clipboard() {
- }
- Clipboard.copy = function (text) {
- var $tempDiv = $("");
- var brRegex = //gi;
- text = text.replace(brRegex, "\n");
- $("body").append($tempDiv);
- $tempDiv.append(text);
- var $tempInput = $("
