@ui5/task-adaptation 1.1.0 → 1.1.2

package/dist/bundle.js

@@ -1,11 +1,8 @@
-//1.115.0
 var window = {};
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var path = require('path');
-
 var fnIsEmptyObject = function isEmptyObject(obj) {
   for (var sName in obj) {
     return false;
@@ -57,20 +54,1796 @@ var Applier = {
   }
 };
 
-class URI {
-    constructor(value) {
-        this.value = value;
+var _URI = window && window.URI;
+function URI(url, base) {
+  var _urlSupplied = arguments.length >= 1;
+  var _baseSupplied = arguments.length >= 2;
+  if (!(this instanceof URI)) {
+    if (_urlSupplied) {
+      if (_baseSupplied) {
+        return new URI(url, base);
+      }
+      return new URI(url);
     }
-
-    normalize() {
-        this.value = path.posix.normalize(this.value).replace(/\\/g, "/");
-        return this;
+    return new URI();
+  }
+  if (url === undefined) {
+    if (_urlSupplied) {
+      throw new TypeError("undefined is not a valid argument for URI");
     }
-
-    path() {
-        return this.value;
+    if (typeof location !== "undefined") {
+      url = location.href + "";
+    } else {
+      url = "";
+    }
+  }
+  if (url === null) {
+    if (_urlSupplied) {
+      throw new TypeError("null is not a valid argument for URI");
+    }
+  }
+  this.href(url);
+  if (base !== undefined) {
+    return this.absoluteTo(base);
+  }
+  return this;
+}
+function isInteger(value) {
+  return (/^[0-9]+$/).test(value);
+}
+URI.version = "1.19.11";
+var p = URI.prototype;
+var hasOwn$1 = Object.prototype.hasOwnProperty;
+function escapeRegEx(string) {
+  return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
+}
+function getType(value) {
+  if (value === undefined) {
+    return "Undefined";
+  }
+  return String(Object.prototype.toString.call(value)).slice(8, -1);
+}
+function isArray(obj) {
+  return getType(obj) === "Array";
+}
+function filterArrayValues(data, value) {
+  var lookup = {};
+  var i, length;
+  if (getType(value) === "RegExp") {
+    lookup = null;
+  } else if (isArray(value)) {
+    for ((i = 0, length = value.length); i < length; i++) {
+      lookup[value[i]] = true;
+    }
+  } else {
+    lookup[value] = true;
+  }
+  for ((i = 0, length = data.length); i < length; i++) {
+    var _match = lookup && lookup[data[i]] !== undefined || !lookup && value.test(data[i]);
+    if (_match) {
+      data.splice(i, 1);
+      length--;
+      i--;
+    }
+  }
+  return data;
+}
+function arrayContains(list, value) {
+  var i, length;
+  if (isArray(value)) {
+    for ((i = 0, length = value.length); i < length; i++) {
+      if (!arrayContains(list, value[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var _type = getType(value);
+  for ((i = 0, length = list.length); i < length; i++) {
+    if (_type === "RegExp") {
+      if (typeof list[i] === "string" && list[i].match(value)) {
+        return true;
+      }
+    } else if (list[i] === value) {
+      return true;
+    }
+  }
+  return false;
+}
+function arraysEqual(one, two) {
+  if (!isArray(one) || !isArray(two)) {
+    return false;
+  }
+  if (one.length !== two.length) {
+    return false;
+  }
+  one.sort();
+  two.sort();
+  for (var i = 0, l = one.length; i < l; i++) {
+    if (one[i] !== two[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function trimSlashes(text) {
+  var trim_expression = /^\/+|\/+$/g;
+  return text.replace(trim_expression, "");
+}
+URI._parts = function () {
+  return {
+    protocol: null,
+    username: null,
+    password: null,
+    hostname: null,
+    urn: null,
+    port: null,
+    path: null,
+    query: null,
+    fragment: null,
+    preventInvalidHostname: URI.preventInvalidHostname,
+    duplicateQueryParameters: URI.duplicateQueryParameters,
+    escapeQuerySpace: URI.escapeQuerySpace
+  };
+};
+URI.preventInvalidHostname = false;
+URI.duplicateQueryParameters = false;
+URI.escapeQuerySpace = true;
+URI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;
+URI.idn_expression = /[^a-z0-9\._-]/i;
+URI.punycode_expression = /(xn--)/i;
+URI.ip4_expression = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+URI.ip6_expression = /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/;
+URI.find_uri_expression = /\b((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))/ig;
+URI.findUri = {
+  start: /\b(?:([a-z][a-z0-9.+-]*:\/\/)|www\.)/gi,
+  end: /[\s\r\n]|$/,
+  trim: /[`!()\[\]{};:'".,<>?«»“”„‘’]+$/,
+  parens: /(\([^\)]*\)|\[[^\]]*\]|\{[^}]*\}|<[^>]*>)/g
+};
+URI.leading_whitespace_expression = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
+URI.ascii_tab_whitespace = /[\u0009\u000A\u000D]+/g;
+URI.defaultPorts = {
+  http: "80",
+  https: "443",
+  ftp: "21",
+  gopher: "70",
+  ws: "80",
+  wss: "443"
+};
+URI.hostProtocols = ["http", "https"];
+URI.invalid_hostname_characters = /[^a-zA-Z0-9\.\-:_]/;
+URI.domAttributes = {
+  "a": "href",
+  "blockquote": "cite",
+  "link": "href",
+  "base": "href",
+  "script": "src",
+  "form": "action",
+  "img": "src",
+  "area": "href",
+  "iframe": "src",
+  "embed": "src",
+  "source": "src",
+  "track": "src",
+  "input": "src",
+  "audio": "src",
+  "video": "src"
+};
+URI.getDomAttribute = function (node) {
+  if (!node || !node.nodeName) {
+    return undefined;
+  }
+  var nodeName = node.nodeName.toLowerCase();
+  if (nodeName === "input" && node.type !== "image") {
+    return undefined;
+  }
+  return URI.domAttributes[nodeName];
+};
+function escapeForDumbFirefox36(value) {
+  return escape(value);
+}
+function strictEncodeURIComponent(string) {
+  return encodeURIComponent(string).replace(/[!'()*]/g, escapeForDumbFirefox36).replace(/\*/g, "%2A");
+}
+URI.encode = strictEncodeURIComponent;
+URI.decode = decodeURIComponent;
+URI.iso8859 = function () {
+  URI.encode = escape;
+  URI.decode = unescape;
+};
+URI.unicode = function () {
+  URI.encode = strictEncodeURIComponent;
+  URI.decode = decodeURIComponent;
+};
+URI.characters = {
+  pathname: {
+    encode: {
+      expression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,
+      map: {
+        "%24": "$",
+        "%26": "&",
+        "%2B": "+",
+        "%2C": ",",
+        "%3B": ";",
+        "%3D": "=",
+        "%3A": ":",
+        "%40": "@"
+      }
+    },
+    decode: {
+      expression: /[\/\?#]/g,
+      map: {
+        "/": "%2F",
+        "?": "%3F",
+        "#": "%23"
+      }
+    }
+  },
+  reserved: {
+    encode: {
+      expression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,
+      map: {
+        "%3A": ":",
+        "%2F": "/",
+        "%3F": "?",
+        "%23": "#",
+        "%5B": "[",
+        "%5D": "]",
+        "%40": "@",
+        "%21": "!",
+        "%24": "$",
+        "%26": "&",
+        "%27": "'",
+        "%28": "(",
+        "%29": ")",
+        "%2A": "*",
+        "%2B": "+",
+        "%2C": ",",
+        "%3B": ";",
+        "%3D": "="
+      }
+    }
+  },
+  urnpath: {
+    encode: {
+      expression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,
+      map: {
+        "%21": "!",
+        "%24": "$",
+        "%27": "'",
+        "%28": "(",
+        "%29": ")",
+        "%2A": "*",
+        "%2B": "+",
+        "%2C": ",",
+        "%3B": ";",
+        "%3D": "=",
+        "%40": "@"
+      }
+    },
+    decode: {
+      expression: /[\/\?#:]/g,
+      map: {
+        "/": "%2F",
+        "?": "%3F",
+        "#": "%23",
+        ":": "%3A"
+      }
+    }
+  }
+};
+URI.encodeQuery = function (string, escapeQuerySpace) {
+  var escaped = URI.encode(string + "");
+  if (escapeQuerySpace === undefined) {
+    escapeQuerySpace = URI.escapeQuerySpace;
+  }
+  return escapeQuerySpace ? escaped.replace(/%20/g, "+") : escaped;
+};
+URI.decodeQuery = function (string, escapeQuerySpace) {
+  string += "";
+  if (escapeQuerySpace === undefined) {
+    escapeQuerySpace = URI.escapeQuerySpace;
+  }
+  try {
+    return URI.decode(escapeQuerySpace ? string.replace(/\+/g, "%20") : string);
+  } catch (e) {
+    return string;
+  }
+};
+var _parts = {
+  "encode": "encode",
+  "decode": "decode"
+};
+var _part;
+var generateAccessor = function (_group, _part) {
+  return function (string) {
+    try {
+      return URI[_part](string + "").replace(URI.characters[_group][_part].expression, function (c) {
+        return URI.characters[_group][_part].map[c];
+      });
+    } catch (e) {
+      return string;
+    }
+  };
+};
+for (_part in _parts) {
+  URI[_part + "PathSegment"] = generateAccessor("pathname", _parts[_part]);
+  URI[_part + "UrnPathSegment"] = generateAccessor("urnpath", _parts[_part]);
+}
+var generateSegmentedPathFunction = function (_sep, _codingFuncName, _innerCodingFuncName) {
+  return function (string) {
+    var actualCodingFunc;
+    if (!_innerCodingFuncName) {
+      actualCodingFunc = URI[_codingFuncName];
+    } else {
+      actualCodingFunc = function (string) {
+        return URI[_codingFuncName](URI[_innerCodingFuncName](string));
+      };
+    }
+    var segments = (string + "").split(_sep);
+    for (var i = 0, length = segments.length; i < length; i++) {
+      segments[i] = actualCodingFunc(segments[i]);
+    }
+    return segments.join(_sep);
+  };
+};
+URI.decodePath = generateSegmentedPathFunction("/", "decodePathSegment");
+URI.decodeUrnPath = generateSegmentedPathFunction(":", "decodeUrnPathSegment");
+URI.recodePath = generateSegmentedPathFunction("/", "encodePathSegment", "decode");
+URI.recodeUrnPath = generateSegmentedPathFunction(":", "encodeUrnPathSegment", "decode");
+URI.encodeReserved = generateAccessor("reserved", "encode");
+URI.parse = function (string, parts) {
+  var pos;
+  if (!parts) {
+    parts = {
+      preventInvalidHostname: URI.preventInvalidHostname
+    };
+  }
+  string = string.replace(URI.leading_whitespace_expression, "");
+  string = string.replace(URI.ascii_tab_whitespace, "");
+  pos = string.indexOf("#");
+  if (pos > -1) {
+    parts.fragment = string.substring(pos + 1) || null;
+    string = string.substring(0, pos);
+  }
+  pos = string.indexOf("?");
+  if (pos > -1) {
+    parts.query = string.substring(pos + 1) || null;
+    string = string.substring(0, pos);
+  }
+  string = string.replace(/^(https?|ftp|wss?)?:+[/\\]*/i, "$1://");
+  string = string.replace(/^[/\\]{2,}/i, "//");
+  if (string.substring(0, 2) === "//") {
+    parts.protocol = null;
+    string = string.substring(2);
+    string = URI.parseAuthority(string, parts);
+  } else {
+    pos = string.indexOf(":");
+    if (pos > -1) {
+      parts.protocol = string.substring(0, pos) || null;
+      if (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {
+        parts.protocol = undefined;
+      } else if (string.substring(pos + 1, pos + 3).replace(/\\/g, "/") === "//") {
+        string = string.substring(pos + 3);
+        string = URI.parseAuthority(string, parts);
+      } else {
+        string = string.substring(pos + 1);
+        parts.urn = true;
+      }
+    }
+  }
+  parts.path = string;
+  return parts;
+};
+URI.parseHost = function (string, parts) {
+  if (!string) {
+    string = "";
+  }
+  string = string.replace(/\\/g, "/");
+  var pos = string.indexOf("/");
+  var bracketPos;
+  var t;
+  if (pos === -1) {
+    pos = string.length;
+  }
+  if (string.charAt(0) === "[") {
+    bracketPos = string.indexOf("]");
+    parts.hostname = string.substring(1, bracketPos) || null;
+    parts.port = string.substring(bracketPos + 2, pos) || null;
+    if (parts.port === "/") {
+      parts.port = null;
+    }
+  } else {
+    var firstColon = string.indexOf(":");
+    var firstSlash = string.indexOf("/");
+    var nextColon = string.indexOf(":", firstColon + 1);
+    if (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {
+      parts.hostname = string.substring(0, pos) || null;
+      parts.port = null;
+    } else {
+      t = string.substring(0, pos).split(":");
+      parts.hostname = t[0] || null;
+      parts.port = t[1] || null;
+    }
+  }
+  if (parts.hostname && string.substring(pos).charAt(0) !== "/") {
+    pos++;
+    string = "/" + string;
+  }
+  if (parts.preventInvalidHostname) {
+    URI.ensureValidHostname(parts.hostname, parts.protocol);
+  }
+  if (parts.port) {
+    URI.ensureValidPort(parts.port);
+  }
+  return string.substring(pos) || "/";
+};
+URI.parseAuthority = function (string, parts) {
+  string = URI.parseUserinfo(string, parts);
+  return URI.parseHost(string, parts);
+};
+URI.parseUserinfo = function (string, parts) {
+  var _string = string;
+  var firstBackSlash = string.indexOf("\\");
+  if (firstBackSlash !== -1) {
+    string = string.replace(/\\/g, "/");
+  }
+  var firstSlash = string.indexOf("/");
+  var pos = string.lastIndexOf("@", firstSlash > -1 ? firstSlash : string.length - 1);
+  var t;
+  if (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {
+    t = string.substring(0, pos).split(":");
+    parts.username = t[0] ? URI.decode(t[0]) : null;
+    t.shift();
+    parts.password = t[0] ? URI.decode(t.join(":")) : null;
+    string = _string.substring(pos + 1);
+  } else {
+    parts.username = null;
+    parts.password = null;
+  }
+  return string;
+};
+URI.parseQuery = function (string, escapeQuerySpace) {
+  if (!string) {
+    return {};
+  }
+  string = string.replace(/&+/g, "&").replace(/^\?*&*|&+$/g, "");
+  if (!string) {
+    return {};
+  }
+  var items = {};
+  var splits = string.split("&");
+  var length = splits.length;
+  var v, name, value;
+  for (var i = 0; i < length; i++) {
+    v = splits[i].split("=");
+    name = URI.decodeQuery(v.shift(), escapeQuerySpace);
+    value = v.length ? URI.decodeQuery(v.join("="), escapeQuerySpace) : null;
+    if (name === "__proto__") {
+      continue;
+    } else if (hasOwn$1.call(items, name)) {
+      if (typeof items[name] === "string" || items[name] === null) {
+        items[name] = [items[name]];
+      }
+      items[name].push(value);
+    } else {
+      items[name] = value;
+    }
+  }
+  return items;
+};
+URI.build = function (parts) {
+  var t = "";
+  var requireAbsolutePath = false;
+  if (parts.protocol) {
+    t += parts.protocol + ":";
+  }
+  if (!parts.urn && (t || parts.hostname)) {
+    t += "//";
+    requireAbsolutePath = true;
+  }
+  t += URI.buildAuthority(parts) || "";
+  if (typeof parts.path === "string") {
+    if (parts.path.charAt(0) !== "/" && requireAbsolutePath) {
+      t += "/";
+    }
+    t += parts.path;
+  }
+  if (typeof parts.query === "string" && parts.query) {
+    t += "?" + parts.query;
+  }
+  if (typeof parts.fragment === "string" && parts.fragment) {
+    t += "#" + parts.fragment;
+  }
+  return t;
+};
+URI.buildHost = function (parts) {
+  var t = "";
+  if (!parts.hostname) {
+    return "";
+  } else if (URI.ip6_expression.test(parts.hostname)) {
+    t += "[" + parts.hostname + "]";
+  } else {
+    t += parts.hostname;
+  }
+  if (parts.port) {
+    t += ":" + parts.port;
+  }
+  return t;
+};
+URI.buildAuthority = function (parts) {
+  return URI.buildUserinfo(parts) + URI.buildHost(parts);
+};
+URI.buildUserinfo = function (parts) {
+  var t = "";
+  if (parts.username) {
+    t += URI.encode(parts.username);
+  }
+  if (parts.password) {
+    t += ":" + URI.encode(parts.password);
+  }
+  if (t) {
+    t += "@";
+  }
+  return t;
+};
+URI.buildQuery = function (data, duplicateQueryParameters, escapeQuerySpace) {
+  var t = "";
+  var unique, key, i, length;
+  for (key in data) {
+    if (key === "__proto__") {
+      continue;
+    } else if (hasOwn$1.call(data, key)) {
+      if (isArray(data[key])) {
+        unique = {};
+        for ((i = 0, length = data[key].length); i < length; i++) {
+          if (data[key][i] !== undefined && unique[data[key][i] + ""] === undefined) {
+            t += "&" + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);
+            if (duplicateQueryParameters !== true) {
+              unique[data[key][i] + ""] = true;
+            }
+          }
+        }
+      } else if (data[key] !== undefined) {
+        t += "&" + URI.buildQueryParameter(key, data[key], escapeQuerySpace);
+      }
+    }
+  }
+  return t.substring(1);
+};
+URI.buildQueryParameter = function (name, value, escapeQuerySpace) {
+  return URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? "=" + URI.encodeQuery(value, escapeQuerySpace) : "");
+};
+URI.addQuery = function (data, name, value) {
+  if (typeof name === "object") {
+    for (var key in name) {
+      if (hasOwn$1.call(name, key)) {
+        URI.addQuery(data, key, name[key]);
+      }
+    }
+  } else if (typeof name === "string") {
+    if (data[name] === undefined) {
+      data[name] = value;
+      return;
+    } else if (typeof data[name] === "string") {
+      data[name] = [data[name]];
+    }
+    if (!isArray(value)) {
+      value = [value];
+    }
+    data[name] = (data[name] || []).concat(value);
+  } else {
+    throw new TypeError("URI.addQuery() accepts an object, string as the name parameter");
+  }
+};
+URI.setQuery = function (data, name, value) {
+  if (typeof name === "object") {
+    for (var key in name) {
+      if (hasOwn$1.call(name, key)) {
+        URI.setQuery(data, key, name[key]);
+      }
+    }
+  } else if (typeof name === "string") {
+    data[name] = value === undefined ? null : value;
+  } else {
+    throw new TypeError("URI.setQuery() accepts an object, string as the name parameter");
+  }
+};
+URI.removeQuery = function (data, name, value) {
+  var i, length, key;
+  if (isArray(name)) {
+    for ((i = 0, length = name.length); i < length; i++) {
+      data[name[i]] = undefined;
+    }
+  } else if (getType(name) === "RegExp") {
+    for (key in data) {
+      if (name.test(key)) {
+        data[key] = undefined;
+      }
+    }
+  } else if (typeof name === "object") {
+    for (key in name) {
+      if (hasOwn$1.call(name, key)) {
+        URI.removeQuery(data, key, name[key]);
+      }
+    }
+  } else if (typeof name === "string") {
+    if (value !== undefined) {
+      if (getType(value) === "RegExp") {
+        if (!isArray(data[name]) && value.test(data[name])) {
+          data[name] = undefined;
+        } else {
+          data[name] = filterArrayValues(data[name], value);
+        }
+      } else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {
+        data[name] = undefined;
+      } else if (isArray(data[name])) {
+        data[name] = filterArrayValues(data[name], value);
+      }
+    } else {
+      data[name] = undefined;
+    }
+  } else {
+    throw new TypeError("URI.removeQuery() accepts an object, string, RegExp as the first parameter");
+  }
+};
+URI.hasQuery = function (data, name, value, withinArray) {
+  switch (getType(name)) {
+    case "String":
+      break;
+    case "RegExp":
+      for (var key in data) {
+        if (hasOwn$1.call(data, key)) {
+          if (name.test(key) && (value === undefined || URI.hasQuery(data, key, value))) {
+            return true;
+          }
+        }
+      }
+      return false;
+    case "Object":
+      for (var _key in name) {
+        if (hasOwn$1.call(name, _key)) {
+          if (!URI.hasQuery(data, _key, name[_key])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    default:
+      throw new TypeError("URI.hasQuery() accepts a string, regular expression or object as the name parameter");
+  }
+  switch (getType(value)) {
+    case "Undefined":
+      return (name in data);
+    case "Boolean":
+      var _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);
+      return value === _booly;
+    case "Function":
+      return !!value(data[name], name, data);
+    case "Array":
+      if (!isArray(data[name])) {
+        return false;
+      }
+      var op = withinArray ? arrayContains : arraysEqual;
+      return op(data[name], value);
+    case "RegExp":
+      if (!isArray(data[name])) {
+        return Boolean(data[name] && data[name].match(value));
+      }
+      if (!withinArray) {
+        return false;
+      }
+      return arrayContains(data[name], value);
+    case "Number":
+      value = String(value);
+    case "String":
+      if (!isArray(data[name])) {
+        return data[name] === value;
+      }
+      if (!withinArray) {
+        return false;
+      }
+      return arrayContains(data[name], value);
+    default:
+      throw new TypeError("URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter");
+  }
+};
+URI.joinPaths = function () {
+  var input = [];
+  var segments = [];
+  var nonEmptySegments = 0;
+  for (var i = 0; i < arguments.length; i++) {
+    var url = new URI(arguments[i]);
+    input.push(url);
+    var _segments = url.segment();
+    for (var s = 0; s < _segments.length; s++) {
+      if (typeof _segments[s] === "string") {
+        segments.push(_segments[s]);
+      }
+      if (_segments[s]) {
+        nonEmptySegments++;
+      }
+    }
+  }
+  if (!segments.length || !nonEmptySegments) {
+    return new URI("");
+  }
+  var uri = new URI("").segment(segments);
+  if (input[0].path() === "" || input[0].path().slice(0, 1) === "/") {
+    uri.path("/" + uri.path());
+  }
+  return uri.normalize();
+};
+URI.commonPath = function (one, two) {
+  var length = Math.min(one.length, two.length);
+  var pos;
+  for (pos = 0; pos < length; pos++) {
+    if (one.charAt(pos) !== two.charAt(pos)) {
+      pos--;
+      break;
+    }
+  }
+  if (pos < 1) {
+    return one.charAt(0) === two.charAt(0) && one.charAt(0) === "/" ? "/" : "";
+  }
+  if (one.charAt(pos) !== "/" || two.charAt(pos) !== "/") {
+    pos = one.substring(0, pos).lastIndexOf("/");
+  }
+  return one.substring(0, pos + 1);
+};
+URI.withinString = function (string, callback, options) {
+  options || (options = {});
+  var _start = options.start || URI.findUri.start;
+  var _end = options.end || URI.findUri.end;
+  var _trim = options.trim || URI.findUri.trim;
+  var _parens = options.parens || URI.findUri.parens;
+  var _attributeOpen = /[a-z0-9-]=["']?$/i;
+  _start.lastIndex = 0;
+  while (true) {
+    var match = _start.exec(string);
+    if (!match) {
+      break;
+    }
+    var start = match.index;
+    if (options.ignoreHtml) {
+      var attributeOpen = string.slice(Math.max(start - 3, 0), start);
+      if (attributeOpen && _attributeOpen.test(attributeOpen)) {
+        continue;
+      }
+    }
+    var end = start + string.slice(start).search(_end);
+    var slice = string.slice(start, end);
+    var parensEnd = -1;
+    while (true) {
+      var parensMatch = _parens.exec(slice);
+      if (!parensMatch) {
+        break;
+      }
+      var parensMatchEnd = parensMatch.index + parensMatch[0].length;
+      parensEnd = Math.max(parensEnd, parensMatchEnd);
+    }
+    if (parensEnd > -1) {
+      slice = slice.slice(0, parensEnd) + slice.slice(parensEnd).replace(_trim, "");
+    } else {
+      slice = slice.replace(_trim, "");
+    }
+    if (slice.length <= match[0].length) {
+      continue;
+    }
+    if (options.ignore && options.ignore.test(slice)) {
+      continue;
+    }
+    end = start + slice.length;
+    var result = callback(slice, start, end, string);
+    if (result === undefined) {
+      _start.lastIndex = end;
+      continue;
+    }
+    result = String(result);
+    string = string.slice(0, start) + result + string.slice(end);
+    _start.lastIndex = start + result.length;
+  }
+  _start.lastIndex = 0;
+  return string;
+};
+URI.ensureValidHostname = function (v, protocol) {
+  var hasHostname = !!v;
+  var hasProtocol = !!protocol;
+  var rejectEmptyHostname = false;
+  if (hasProtocol) {
+    rejectEmptyHostname = arrayContains(URI.hostProtocols, protocol);
+  }
+  if (rejectEmptyHostname && !hasHostname) {
+    throw new TypeError("Hostname cannot be empty, if protocol is " + protocol);
+  } else if (v && v.match(URI.invalid_hostname_characters)) {
+    if (!punycode) {
+      throw new TypeError("Hostname \"" + v + "\" contains characters other than [A-Z0-9.-:_] and Punycode.js is not available");
+    }
+    if (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {
+      throw new TypeError("Hostname \"" + v + "\" contains characters other than [A-Z0-9.-:_]");
+    }
+  }
+};
+URI.ensureValidPort = function (v) {
+  if (!v) {
+    return;
+  }
+  var port = Number(v);
+  if (isInteger(port) && port > 0 && port < 65536) {
+    return;
+  }
+  throw new TypeError("Port \"" + v + "\" is not a valid port");
+};
+URI.noConflict = function (removeAll) {
+  if (removeAll) {
+    var unconflicted = {
+      URI: this.noConflict()
+    };
+    if (window.URITemplate && typeof window.URITemplate.noConflict === "function") {
+      unconflicted.URITemplate = window.URITemplate.noConflict();
+    }
+    if (window.IPv6 && typeof window.IPv6.noConflict === "function") {
+      unconflicted.IPv6 = window.IPv6.noConflict();
+    }
+    if (window.SecondLevelDomains && typeof window.SecondLevelDomains.noConflict === "function") {
+      unconflicted.SecondLevelDomains = window.SecondLevelDomains.noConflict();
     }
+    return unconflicted;
+  } else if (window.URI === this) {
+    window.URI = _URI;
+  }
+  return this;
+};
+p.build = function (deferBuild) {
+  if (deferBuild === true) {
+    this._deferred_build = true;
+  } else if (deferBuild === undefined || this._deferred_build) {
+    this._string = URI.build(this._parts);
+    this._deferred_build = false;
+  }
+  return this;
+};
+p.clone = function () {
+  return new URI(this);
+};
+p.valueOf = p.toString = function () {
+  return this.build(false)._string;
+};
+function generateSimpleAccessor(_part) {
+  return function (v, build) {
+    if (v === undefined) {
+      return this._parts[_part] || "";
+    } else {
+      this._parts[_part] = v || null;
+      this.build(!build);
+      return this;
+    }
+  };
 }
+function generatePrefixAccessor(_part, _key) {
+  return function (v, build) {
+    if (v === undefined) {
+      return this._parts[_part] || "";
+    } else {
+      if (v !== null) {
+        v = v + "";
+        if (v.charAt(0) === _key) {
+          v = v.substring(1);
+        }
+      }
+      this._parts[_part] = v;
+      this.build(!build);
+      return this;
+    }
+  };
+}
+p.protocol = generateSimpleAccessor("protocol");
+p.username = generateSimpleAccessor("username");
+p.password = generateSimpleAccessor("password");
+p.hostname = generateSimpleAccessor("hostname");
+p.port = generateSimpleAccessor("port");
+p.query = generatePrefixAccessor("query", "?");
+p.fragment = generatePrefixAccessor("fragment", "#");
+p.search = function (v, build) {
+  var t = this.query(v, build);
+  return typeof t === "string" && t.length ? "?" + t : t;
+};
+p.hash = function (v, build) {
+  var t = this.fragment(v, build);
+  return typeof t === "string" && t.length ? "#" + t : t;
+};
+p.pathname = function (v, build) {
+  if (v === undefined || v === true) {
+    var res = this._parts.path || (this._parts.hostname ? "/" : "");
+    return v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;
+  } else {
+    if (this._parts.urn) {
+      this._parts.path = v ? URI.recodeUrnPath(v) : "";
+    } else {
+      this._parts.path = v ? URI.recodePath(v) : "/";
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.path = p.pathname;
+p.href = function (href, build) {
+  var key;
+  if (href === undefined) {
+    return this.toString();
+  }
+  this._string = "";
+  this._parts = URI._parts();
+  var _URI = href instanceof URI;
+  var _object = typeof href === "object" && (href.hostname || href.path || href.pathname);
+  if (href.nodeName) {
+    var attribute = URI.getDomAttribute(href);
+    href = href[attribute] || "";
+    _object = false;
+  }
+  if (!_URI && _object && href.pathname !== undefined) {
+    href = href.toString();
+  }
+  if (typeof href === "string" || href instanceof String) {
+    this._parts = URI.parse(String(href), this._parts);
+  } else if (_URI || _object) {
+    var src = _URI ? href._parts : href;
+    for (key in src) {
+      if (key === "query") {
+        continue;
+      }
+      if (hasOwn$1.call(this._parts, key)) {
+        this._parts[key] = src[key];
+      }
+    }
+    if (src.query) {
+      this.query(src.query, false);
+    }
+  } else {
+    throw new TypeError("invalid input");
+  }
+  this.build(!build);
+  return this;
+};
+p.is = function (what) {
+  var ip = false;
+  var ip4 = false;
+  var ip6 = false;
+  var name = false;
+  var sld = false;
+  var idn = false;
+  var punycode = false;
+  var relative = !this._parts.urn;
+  if (this._parts.hostname) {
+    relative = false;
+    ip4 = URI.ip4_expression.test(this._parts.hostname);
+    ip6 = URI.ip6_expression.test(this._parts.hostname);
+    ip = ip4 || ip6;
+    name = !ip;
+    sld = name && SLD && SLD.has(this._parts.hostname);
+    idn = name && URI.idn_expression.test(this._parts.hostname);
+    punycode = name && URI.punycode_expression.test(this._parts.hostname);
+  }
+  switch (what.toLowerCase()) {
+    case "relative":
+      return relative;
+    case "absolute":
+      return !relative;
+    case "domain":
+    case "name":
+      return name;
+    case "sld":
+      return sld;
+    case "ip":
+      return ip;
+    case "ip4":
+    case "ipv4":
+    case "inet4":
+      return ip4;
+    case "ip6":
+    case "ipv6":
+    case "inet6":
+      return ip6;
+    case "idn":
+      return idn;
+    case "url":
+      return !this._parts.urn;
+    case "urn":
+      return !!this._parts.urn;
+    case "punycode":
+      return punycode;
+  }
+  return null;
+};
+var _protocol = p.protocol;
+var _port = p.port;
+var _hostname = p.hostname;
+p.protocol = function (v, build) {
+  if (v) {
+    v = v.replace(/:(\/\/)?$/, "");
+    if (!v.match(URI.protocol_expression)) {
+      throw new TypeError("Protocol \"" + v + "\" contains characters other than [A-Z0-9.+-] or doesn't start with [A-Z]");
+    }
+  }
+  return _protocol.call(this, v, build);
+};
+p.scheme = p.protocol;
+p.port = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v !== undefined) {
+    if (v === 0) {
+      v = null;
+    }
+    if (v) {
+      v += "";
+      if (v.charAt(0) === ":") {
+        v = v.substring(1);
+      }
+      URI.ensureValidPort(v);
+    }
+  }
+  return _port.call(this, v, build);
+};
+p.hostname = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v !== undefined) {
+    var x = {
+      preventInvalidHostname: this._parts.preventInvalidHostname
+    };
+    var res = URI.parseHost(v, x);
+    if (res !== "/") {
+      throw new TypeError("Hostname \"" + v + "\" contains characters other than [A-Z0-9.-]");
+    }
+    v = x.hostname;
+    if (this._parts.preventInvalidHostname) {
+      URI.ensureValidHostname(v, this._parts.protocol);
+    }
+  }
+  return _hostname.call(this, v, build);
+};
+p.origin = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined) {
+    var protocol = this.protocol();
+    var authority = this.authority();
+    if (!authority) {
+      return "";
+    }
+    return (protocol ? protocol + "://" : "") + this.authority();
+  } else {
+    var origin = URI(v);
+    this.protocol(origin.protocol()).authority(origin.authority()).build(!build);
+    return this;
+  }
+};
+p.host = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined) {
+    return this._parts.hostname ? URI.buildHost(this._parts) : "";
+  } else {
+    var res = URI.parseHost(v, this._parts);
+    if (res !== "/") {
+      throw new TypeError("Hostname \"" + v + "\" contains characters other than [A-Z0-9.-]");
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.authority = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined) {
+    return this._parts.hostname ? URI.buildAuthority(this._parts) : "";
+  } else {
+    var res = URI.parseAuthority(v, this._parts);
+    if (res !== "/") {
+      throw new TypeError("Hostname \"" + v + "\" contains characters other than [A-Z0-9.-]");
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.userinfo = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined) {
+    var t = URI.buildUserinfo(this._parts);
+    return t ? t.substring(0, t.length - 1) : t;
+  } else {
+    if (v[v.length - 1] !== "@") {
+      v += "@";
+    }
+    URI.parseUserinfo(v, this._parts);
+    this.build(!build);
+    return this;
+  }
+};
+p.resource = function (v, build) {
+  var parts;
+  if (v === undefined) {
+    return this.path() + this.search() + this.hash();
+  }
+  parts = URI.parse(v);
+  this._parts.path = parts.path;
+  this._parts.query = parts.query;
+  this._parts.fragment = parts.fragment;
+  this.build(!build);
+  return this;
+};
+p.subdomain = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined) {
+    if (!this._parts.hostname || this.is("IP")) {
+      return "";
+    }
+    var end = this._parts.hostname.length - this.domain().length - 1;
+    return this._parts.hostname.substring(0, end) || "";
+  } else {
+    var e = this._parts.hostname.length - this.domain().length;
+    var sub = this._parts.hostname.substring(0, e);
+    var replace = new RegExp("^" + escapeRegEx(sub));
+    if (v && v.charAt(v.length - 1) !== ".") {
+      v += ".";
+    }
+    if (v.indexOf(":") !== -1) {
+      throw new TypeError("Domains cannot contain colons");
+    }
+    if (v) {
+      URI.ensureValidHostname(v, this._parts.protocol);
+    }
+    this._parts.hostname = this._parts.hostname.replace(replace, v);
+    this.build(!build);
+    return this;
+  }
+};
+p.domain = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (typeof v === "boolean") {
+    build = v;
+    v = undefined;
+  }
+  if (v === undefined) {
+    if (!this._parts.hostname || this.is("IP")) {
+      return "";
+    }
+    var t = this._parts.hostname.match(/\./g);
+    if (t && t.length < 2) {
+      return this._parts.hostname;
+    }
+    var end = this._parts.hostname.length - this.tld(build).length - 1;
+    end = this._parts.hostname.lastIndexOf(".", end - 1) + 1;
+    return this._parts.hostname.substring(end) || "";
+  } else {
+    if (!v) {
+      throw new TypeError("cannot set domain empty");
+    }
+    if (v.indexOf(":") !== -1) {
+      throw new TypeError("Domains cannot contain colons");
+    }
+    URI.ensureValidHostname(v, this._parts.protocol);
+    if (!this._parts.hostname || this.is("IP")) {
+      this._parts.hostname = v;
+    } else {
+      var replace = new RegExp(escapeRegEx(this.domain()) + "$");
+      this._parts.hostname = this._parts.hostname.replace(replace, v);
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.tld = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (typeof v === "boolean") {
+    build = v;
+    v = undefined;
+  }
+  if (v === undefined) {
+    if (!this._parts.hostname || this.is("IP")) {
+      return "";
+    }
+    var pos = this._parts.hostname.lastIndexOf(".");
+    var tld = this._parts.hostname.substring(pos + 1);
+    if (build !== true && SLD && SLD.list[tld.toLowerCase()]) {
+      return SLD.get(this._parts.hostname) || tld;
+    }
+    return tld;
+  } else {
+    var replace;
+    if (!v) {
+      throw new TypeError("cannot set TLD empty");
+    } else if (v.match(/[^a-zA-Z0-9-]/)) {
+      if (SLD && SLD.is(v)) {
+        replace = new RegExp(escapeRegEx(this.tld()) + "$");
+        this._parts.hostname = this._parts.hostname.replace(replace, v);
+      } else {
+        throw new TypeError("TLD \"" + v + "\" contains characters other than [A-Z0-9]");
+      }
+    } else if (!this._parts.hostname || this.is("IP")) {
+      throw new ReferenceError("cannot set TLD on non-domain host");
+    } else {
+      replace = new RegExp(escapeRegEx(this.tld()) + "$");
+      this._parts.hostname = this._parts.hostname.replace(replace, v);
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.directory = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined || v === true) {
+    if (!this._parts.path && !this._parts.hostname) {
+      return "";
+    }
+    if (this._parts.path === "/") {
+      return "/";
+    }
+    var end = this._parts.path.length - this.filename().length - 1;
+    var res = this._parts.path.substring(0, end) || (this._parts.hostname ? "/" : "");
+    return v ? URI.decodePath(res) : res;
+  } else {
+    var e = this._parts.path.length - this.filename().length;
+    var directory = this._parts.path.substring(0, e);
+    var replace = new RegExp("^" + escapeRegEx(directory));
+    if (!this.is("relative")) {
+      if (!v) {
+        v = "/";
+      }
+      if (v.charAt(0) !== "/") {
+        v = "/" + v;
+      }
+    }
+    if (v && v.charAt(v.length - 1) !== "/") {
+      v += "/";
+    }
+    v = URI.recodePath(v);
+    this._parts.path = this._parts.path.replace(replace, v);
+    this.build(!build);
+    return this;
+  }
+};
+p.filename = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (typeof v !== "string") {
+    if (!this._parts.path || this._parts.path === "/") {
+      return "";
+    }
+    var pos = this._parts.path.lastIndexOf("/");
+    var res = this._parts.path.substring(pos + 1);
+    return v ? URI.decodePathSegment(res) : res;
+  } else {
+    var mutatedDirectory = false;
+    if (v.charAt(0) === "/") {
+      v = v.substring(1);
+    }
+    if (v.match(/\.?\//)) {
+      mutatedDirectory = true;
+    }
+    var replace = new RegExp(escapeRegEx(this.filename()) + "$");
+    v = URI.recodePath(v);
+    this._parts.path = this._parts.path.replace(replace, v);
+    if (mutatedDirectory) {
+      this.normalizePath(build);
+    } else {
+      this.build(!build);
+    }
+    return this;
+  }
+};
+p.suffix = function (v, build) {
+  if (this._parts.urn) {
+    return v === undefined ? "" : this;
+  }
+  if (v === undefined || v === true) {
+    if (!this._parts.path || this._parts.path === "/") {
+      return "";
+    }
+    var filename = this.filename();
+    var pos = filename.lastIndexOf(".");
+    var s, res;
+    if (pos === -1) {
+      return "";
+    }
+    s = filename.substring(pos + 1);
+    res = (/^[a-z0-9%]+$/i).test(s) ? s : "";
+    return v ? URI.decodePathSegment(res) : res;
+  } else {
+    if (v.charAt(0) === ".") {
+      v = v.substring(1);
+    }
+    var suffix = this.suffix();
+    var replace;
+    if (!suffix) {
+      if (!v) {
+        return this;
+      }
+      this._parts.path += "." + URI.recodePath(v);
+    } else if (!v) {
+      replace = new RegExp(escapeRegEx("." + suffix) + "$");
+    } else {
+      replace = new RegExp(escapeRegEx(suffix) + "$");
+    }
+    if (replace) {
+      v = URI.recodePath(v);
+      this._parts.path = this._parts.path.replace(replace, v);
+    }
+    this.build(!build);
+    return this;
+  }
+};
+p.segment = function (segment, v, build) {
+  var separator = this._parts.urn ? ":" : "/";
+  var path = this.path();
+  var absolute = path.substring(0, 1) === "/";
+  var segments = path.split(separator);
+  if (segment !== undefined && typeof segment !== "number") {
+    build = v;
+    v = segment;
+    segment = undefined;
+  }
+  if (segment !== undefined && typeof segment !== "number") {
+    throw new Error("Bad segment \"" + segment + "\", must be 0-based integer");
+  }
+  if (absolute) {
+    segments.shift();
+  }
+  if (segment < 0) {
+    segment = Math.max(segments.length + segment, 0);
+  }
+  if (v === undefined) {
+    return segment === undefined ? segments : segments[segment];
+  } else if (segment === null || segments[segment] === undefined) {
+    if (isArray(v)) {
+      segments = [];
+      for (var i = 0, l = v.length; i < l; i++) {
+        if (!v[i].length && (!segments.length || !segments[segments.length - 1].length)) {
+          continue;
+        }
+        if (segments.length && !segments[segments.length - 1].length) {
+          segments.pop();
+        }
+        segments.push(trimSlashes(v[i]));
+      }
+    } else if (v || typeof v === "string") {
+      v = trimSlashes(v);
+      if (segments[segments.length - 1] === "") {
+        segments[segments.length - 1] = v;
+      } else {
+        segments.push(v);
+      }
+    }
+  } else {
+    if (v) {
+      segments[segment] = trimSlashes(v);
+    } else {
+      segments.splice(segment, 1);
+    }
+  }
+  if (absolute) {
+    segments.unshift("");
+  }
+  return this.path(segments.join(separator), build);
+};
+p.segmentCoded = function (segment, v, build) {
+  var segments, i, l;
+  if (typeof segment !== "number") {
+    build = v;
+    v = segment;
+    segment = undefined;
+  }
+  if (v === undefined) {
+    segments = this.segment(segment, v, build);
+    if (!isArray(segments)) {
+      segments = segments !== undefined ? URI.decode(segments) : undefined;
+    } else {
+      for ((i = 0, l = segments.length); i < l; i++) {
+        segments[i] = URI.decode(segments[i]);
+      }
+    }
+    return segments;
+  }
+  if (!isArray(v)) {
+    v = typeof v === "string" || v instanceof String ? URI.encode(v) : v;
+  } else {
+    for ((i = 0, l = v.length); i < l; i++) {
+      v[i] = URI.encode(v[i]);
+    }
+  }
+  return this.segment(segment, v, build);
+};
+var q = p.query;
+p.query = function (v, build) {
+  if (v === true) {
+    return URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+  } else if (typeof v === "function") {
+    var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+    var result = v.call(this, data);
+    this._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
+    this.build(!build);
+    return this;
+  } else if (v !== undefined && typeof v !== "string") {
+    this._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
+    this.build(!build);
+    return this;
+  } else {
+    return q.call(this, v, build);
+  }
+};
+p.setQuery = function (name, value, build) {
+  var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+  if (typeof name === "string" || name instanceof String) {
+    data[name] = value !== undefined ? value : null;
+  } else if (typeof name === "object") {
+    for (var key in name) {
+      if (hasOwn$1.call(name, key)) {
+        data[key] = name[key];
+      }
+    }
+  } else {
+    throw new TypeError("URI.addQuery() accepts an object, string as the name parameter");
+  }
+  this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
+  if (typeof name !== "string") {
+    build = value;
+  }
+  this.build(!build);
+  return this;
+};
+p.addQuery = function (name, value, build) {
+  var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+  URI.addQuery(data, name, value === undefined ? null : value);
+  this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
+  if (typeof name !== "string") {
+    build = value;
+  }
+  this.build(!build);
+  return this;
+};
+p.removeQuery = function (name, value, build) {
+  var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+  URI.removeQuery(data, name, value);
+  this._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
+  if (typeof name !== "string") {
+    build = value;
+  }
+  this.build(!build);
+  return this;
+};
+p.hasQuery = function (name, value, withinArray) {
+  var data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
+  return URI.hasQuery(data, name, value, withinArray);
+};
+p.setSearch = p.setQuery;
+p.addSearch = p.addQuery;
+p.removeSearch = p.removeQuery;
+p.hasSearch = p.hasQuery;
+p.normalize = function () {
+  if (this._parts.urn) {
+    return this.normalizeProtocol(false).normalizePath(false).normalizeQuery(false).normalizeFragment(false).build();
+  }
+  return this.normalizeProtocol(false).normalizeHostname(false).normalizePort(false).normalizePath(false).normalizeQuery(false).normalizeFragment(false).build();
+};
+p.normalizeProtocol = function (build) {
+  if (typeof this._parts.protocol === "string") {
+    this._parts.protocol = this._parts.protocol.toLowerCase();
+    this.build(!build);
+  }
+  return this;
+};
+p.normalizeHostname = function (build) {
+  if (this._parts.hostname) {
+    if (this.is("IDN") && punycode) {
+      this._parts.hostname = punycode.toASCII(this._parts.hostname);
+    } else if (this.is("IPv6") && IPv6) {
+      this._parts.hostname = IPv6.best(this._parts.hostname);
+    }
+    this._parts.hostname = this._parts.hostname.toLowerCase();
+    this.build(!build);
+  }
+  return this;
+};
+p.normalizePort = function (build) {
+  if (typeof this._parts.protocol === "string" && this._parts.port === URI.defaultPorts[this._parts.protocol]) {
+    this._parts.port = null;
+    this.build(!build);
+  }
+  return this;
+};
+p.normalizePath = function (build) {
+  var _path = this._parts.path;
+  if (!_path) {
+    return this;
+  }
+  if (this._parts.urn) {
+    this._parts.path = URI.recodeUrnPath(this._parts.path);
+    this.build(!build);
+    return this;
+  }
+  if (this._parts.path === "/") {
+    return this;
+  }
+  _path = URI.recodePath(_path);
+  var _was_relative;
+  var _leadingParents = "";
+  var _parent, _pos;
+  if (_path.charAt(0) !== "/") {
+    _was_relative = true;
+    _path = "/" + _path;
+  }
+  if (_path.slice(-3) === "/.." || _path.slice(-2) === "/.") {
+    _path += "/";
+  }
+  _path = _path.replace(/(\/(\.\/)+)|(\/\.$)/g, "/").replace(/\/{2,}/g, "/");
+  if (_was_relative) {
+    _leadingParents = _path.substring(1).match(/^(\.\.\/)+/) || "";
+    if (_leadingParents) {
+      _leadingParents = _leadingParents[0];
+    }
+  }
+  while (true) {
+    _parent = _path.search(/\/\.\.(\/|$)/);
+    if (_parent === -1) {
+      break;
+    } else if (_parent === 0) {
+      _path = _path.substring(3);
+      continue;
+    }
+    _pos = _path.substring(0, _parent).lastIndexOf("/");
+    if (_pos === -1) {
+      _pos = _parent;
+    }
+    _path = _path.substring(0, _pos) + _path.substring(_parent + 3);
+  }
+  if (_was_relative && this.is("relative")) {
+    _path = _leadingParents + _path.substring(1);
+  }
+  this._parts.path = _path;
+  this.build(!build);
+  return this;
+};
+p.normalizePathname = p.normalizePath;
+p.normalizeQuery = function (build) {
+  if (typeof this._parts.query === "string") {
+    if (!this._parts.query.length) {
+      this._parts.query = null;
+    } else {
+      this.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));
+    }
+    this.build(!build);
+  }
+  return this;
+};
+p.normalizeFragment = function (build) {
+  if (!this._parts.fragment) {
+    this._parts.fragment = null;
+    this.build(!build);
+  }
+  return this;
+};
+p.normalizeSearch = p.normalizeQuery;
+p.normalizeHash = p.normalizeFragment;
+p.iso8859 = function () {
+  var e = URI.encode;
+  var d = URI.decode;
+  URI.encode = escape;
+  URI.decode = decodeURIComponent;
+  try {
+    this.normalize();
+  } finally {
+    URI.encode = e;
+    URI.decode = d;
+  }
+  return this;
+};
+p.unicode = function () {
+  var e = URI.encode;
+  var d = URI.decode;
+  URI.encode = strictEncodeURIComponent;
+  URI.decode = unescape;
+  try {
+    this.normalize();
+  } finally {
+    URI.encode = e;
+    URI.decode = d;
+  }
+  return this;
+};
+p.readable = function () {
+  var uri = this.clone();
+  uri.username("").password("").normalize();
+  var t = "";
+  if (uri._parts.protocol) {
+    t += uri._parts.protocol + "://";
+  }
+  if (uri._parts.hostname) {
+    if (uri.is("punycode") && punycode) {
+      t += punycode.toUnicode(uri._parts.hostname);
+      if (uri._parts.port) {
+        t += ":" + uri._parts.port;
+      }
+    } else {
+      t += uri.host();
+    }
+  }
+  if (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== "/") {
+    t += "/";
+  }
+  t += uri.path(true);
+  if (uri._parts.query) {
+    var q = "";
+    for (var i = 0, qp = uri._parts.query.split("&"), l = qp.length; i < l; i++) {
+      var kv = (qp[i] || "").split("=");
+      q += "&" + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace).replace(/&/g, "%26");
+      if (kv[1] !== undefined) {
+        q += "=" + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace).replace(/&/g, "%26");
+      }
+    }
+    t += "?" + q.substring(1);
+  }
+  t += URI.decodeQuery(uri.hash(), true);
+  return t;
+};
+p.absoluteTo = function (base) {
+  var resolved = this.clone();
+  var properties = ["protocol", "username", "password", "hostname", "port"];
+  var basedir, i, p;
+  if (this._parts.urn) {
+    throw new Error("URNs do not have any generally defined hierarchical components");
+  }
+  if (!(base instanceof URI)) {
+    base = new URI(base);
+  }
+  if (resolved._parts.protocol) {
+    return resolved;
+  } else {
+    resolved._parts.protocol = base._parts.protocol;
+  }
+  if (this._parts.hostname) {
+    return resolved;
+  }
+  for (i = 0; p = properties[i]; i++) {
+    resolved._parts[p] = base._parts[p];
+  }
+  if (!resolved._parts.path) {
+    resolved._parts.path = base._parts.path;
+    if (!resolved._parts.query) {
+      resolved._parts.query = base._parts.query;
+    }
+  } else {
+    if (resolved._parts.path.substring(-2) === "..") {
+      resolved._parts.path += "/";
+    }
+    if (resolved.path().charAt(0) !== "/") {
+      basedir = base.directory();
+      basedir = basedir ? basedir : base.path().indexOf("/") === 0 ? "/" : "";
+      resolved._parts.path = (basedir ? basedir + "/" : "") + resolved._parts.path;
+      resolved.normalizePath();
+    }
+  }
+  resolved.build();
+  return resolved;
+};
+p.relativeTo = function (base) {
+  var relative = this.clone().normalize();
+  var relativeParts, baseParts, common, relativePath, basePath;
+  if (relative._parts.urn) {
+    throw new Error("URNs do not have any generally defined hierarchical components");
+  }
+  base = new URI(base).normalize();
+  relativeParts = relative._parts;
+  baseParts = base._parts;
+  relativePath = relative.path();
+  basePath = base.path();
+  if (relativePath.charAt(0) !== "/") {
+    throw new Error("URI is already relative");
+  }
+  if (basePath.charAt(0) !== "/") {
+    throw new Error("Cannot calculate a URI relative to another relative URI");
+  }
+  if (relativeParts.protocol === baseParts.protocol) {
+    relativeParts.protocol = null;
+  }
+  if (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {
+    return relative.build();
+  }
+  if (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {
+    return relative.build();
+  }
+  if (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {
+    relativeParts.hostname = null;
+    relativeParts.port = null;
+  } else {
+    return relative.build();
+  }
+  if (relativePath === basePath) {
+    relativeParts.path = "";
+    return relative.build();
+  }
+  common = URI.commonPath(relativePath, basePath);
+  if (!common) {
+    return relative.build();
+  }
+  var parents = baseParts.path.substring(common.length).replace(/[^\/]*$/, "").replace(/.*?\//g, "../");
+  relativeParts.path = parents + relativeParts.path.substring(common.length) || "./";
+  return relative.build();
+};
+p.equals = function (uri) {
+  var one = this.clone();
+  var two = new URI(uri);
+  var one_map = {};
+  var two_map = {};
+  var checked = {};
+  var one_query, two_query, key;
+  one.normalize();
+  two.normalize();
+  if (one.toString() === two.toString()) {
+    return true;
+  }
+  one_query = one.query();
+  two_query = two.query();
+  one.query("");
+  two.query("");
+  if (one.toString() !== two.toString()) {
+    return false;
+  }
+  if (one_query.length !== two_query.length) {
+    return false;
+  }
+  one_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);
+  two_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);
+  for (key in one_map) {
+    if (hasOwn$1.call(one_map, key)) {
+      if (!isArray(one_map[key])) {
+        if (one_map[key] !== two_map[key]) {
+          return false;
+        }
+      } else if (!arraysEqual(one_map[key], two_map[key])) {
+        return false;
+      }
+      checked[key] = true;
+    }
+  }
+  for (key in two_map) {
+    if (hasOwn$1.call(two_map, key)) {
+      if (!checked[key]) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+p.preventInvalidHostname = function (v) {
+  this._parts.preventInvalidHostname = !!v;
+  return this;
+};
+p.duplicateQueryParameters = function (v) {
+  this._parts.duplicateQueryParameters = !!v;
+  return this;
+};
+p.escapeQuerySpace = function (v) {
+  this._parts.escapeQuerySpace = !!v;
+  return this;
+};
 
 var ApplyUtil = {
   formatBundleName: function (sId, sBundleUrl) {