ketting/browser/ketting.min.js.map

{"version":3,"sources":["webpack://Ketting/webpack/universalModuleDefinition","webpack://Ketting/webpack/bootstrap","webpack://Ketting/./src/link.ts","webpack://Ketting/./src/http/util.ts","webpack://Ketting/./src/util/uri.web.ts","webpack://Ketting/./src/state/base-state.ts","webpack://Ketting/./src/state/index.ts","webpack://Ketting/./src/http/error.ts","webpack://Ketting/./src/resource.ts","webpack://Ketting/./node_modules/http-link-header/lib/link.js","webpack://Ketting/./src/follow-promise.ts","webpack://Ketting/./src/cache/index.ts","webpack://Ketting/./src/cache/forever.ts","webpack://Ketting/./src/index.ts","webpack://Ketting/./src/client.ts","webpack://Ketting/./src/http/fetcher.ts","webpack://Ketting/./src/state/interface.ts","webpack://Ketting/./src/action.ts","webpack://Ketting/./node_modules/querystring-browser/querystring.js","webpack://Ketting/./node_modules/buffer/index.js","webpack://Ketting/(webpack)/buildin/global.js","webpack://Ketting/./node_modules/base64-js/index.js","webpack://Ketting/./node_modules/ieee754/index.js","webpack://Ketting/./node_modules/isarray/index.js","webpack://Ketting/./src/state/hal.ts","webpack://Ketting/./src/state/binary.ts","webpack://Ketting/./src/state/jsonapi.ts","webpack://Ketting/./src/state/siren.ts","webpack://Ketting/./src/state/text.ts","webpack://Ketting/./src/state/collection-json.ts","webpack://Ketting/./src/state/html.ts","webpack://Ketting/./src/util/html.web.ts","webpack://Ketting/./src/state/head.ts","webpack://Ketting/./src/util/uri-template.ts","webpack://Ketting/./node_modules/uri-template/index.js","webpack://Ketting/./node_modules/uri-template/lib/classes.js","webpack://Ketting/./node_modules/uri-template/lib/encoders.js","webpack://Ketting/./node_modules/pct-encode/index.js","webpack://Ketting/./node_modules/events/events.js","webpack://Ketting/./src/util/fetch-body-helper.web.ts","webpack://Ketting/./src/cache/short.ts","webpack://Ketting/./src/cache/never.ts","webpack://Ketting/./src/http/basic-auth.ts","webpack://Ketting/./src/util/base64.web.ts","webpack://Ketting/./src/http/bearer-auth.ts","webpack://Ketting/./src/http/oauth2.ts","webpack://Ketting/./node_modules/fetch-mw-oauth2/browser/fetch-mw-oauth2.min.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","Links","defaultContext","links","this","store","Map","add","getAll","link","args","rel","href","context","map","has","push","set","arg1","arg2","length","delete","result","values","LinkNotFound","Error","contentType","includes","split","trim","header","httpLink","LinkHeader","parse","refs","uri","title","hreflang","type","safeMethods","method","base","relative","URL","exec","index","toString","doc","document","oldBase","getElementsByTagName","oldHref","docHead","head","ourBase","appendChild","createElement","resolver","resolvedUrl","removeChild","url","host","data","headers","embedded","actionInfo","timestamp","Date","now","contentHeaderNames","contentHeader","Headers","ActionNotFound","undefined","SimpleAction","client","action","isState","BaseState","HalState","BinaryState","JsonApiState","SirenState","TextState","CjState","HtmlState","HttpError","response","super","status","Problem","problemBody","body","message","async","match","json","Resource","EventEmitter","activeRefresh","getOptions","state","cache","Promise","resolve","refresh","headOptions","fetchOrThrow","optionsToRequestInit","headStateFactory","params","getContentHeaders","getStateForResponse","updateCache","options","requestInit","go","variables","FollowPromiseOne","FollowPromiseMany","init","fetcher","fetch","cacheState","getMany","serializeBody","needsJsonStringify","JSON","stringify","COMPATIBLE_ENCODING_PATTERN","WS_TRIM_PATTERN","WS_CHAR_PATTERN","WS_FOLD_PATTERN","DELIMITER_PATTERN","WS_DELIMITER_PATTERN","TOKEN_PATTERN","STATE","replace","hasWhitespace","test","skipWhitespace","offset","needsQuotes","Link","toLowerCase","attr","slice","ref","expandRelations","end","indexOf","attrValue","isSingleOccurenceAttr","parseExtendedValue","Array","isArray","keys","reduce","formatAttribute","join","isCompatibleEncoding","isTokenAttr","escapeQuotes","assign","parts","language","encoding","decodeURIComponent","formatExtendedAttribute","toUpperCase","Buffer","isBuffer","encodeURIComponent","item","FollowPromise","prefetchEnabled","preferPushEnabled","preferTranscludeEnabled","useHeadEnabled","resource","onfulfilled","onrejected","fetchLinkedResource","then","onfinally","Prefer","templated","expand","newResource","catch","err","console","warn","fetchLinkedResources","ForeverCache","ShortCache","NeverCache","clone","clear","default","bookmarkUri","contentTypeMap","halStateFactory","jsonApiStateFactory","sirenStateFactory","cjStateFactory","htmlStateFactory","acceptHeader","request","next","entries","stateFactory","q","cacheExpireHandler","noStaleEvent","isSafeMethod","ok","expireUris","resources","emit","Fetcher","use","follow","absoluteUri","middleware","origin","parseContentType","startsWith","textStateFactory","binaryStateFactory","embeddedState","getEmbedded","middlewares","advertiseKetting","Request","mws","getMiddlewaresByOrigin","innerRequest","version","invokeMiddlewares","nextRequest","filter","regex","mw","matchRegex","part","RegExp","input","formInfo","k","v","formData","search","qs","QueryString","qsUnescape","decodeSpaces","e","unescapeBuffer","hexchar","out","inIndex","outIndex","charCodeAt","NaN","unescape","hexTable","escape","str","lastPos","c2","URIError","stringifyPrimitive","isFinite","decodeStr","decoder","encode","obj","sep","eq","len","flast","fields","ks","vlen","vlast","j","decode","eqLen","sepLen","maxKeys","pairs","Infinity","customDecode","sepIdx","eqIdx","keyEncoded","valEncoded","encodeCheck","code","curValue","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","arg","encodingOrOffset","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","string","isEncoding","actual","write","fromString","checked","copy","buffer","val","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","hexWrite","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","max","target","thisStart","thisEnd","thisCopy","targetCopy","toJSON","_arr","ret","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","leadSurrogate","toByteArray","stringtrim","base64clean","src","dst","g","Function","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","rt","abs","log","LN2","_links","serializeLinks","self","attributes","parseHalLinks","foundLinks","Set","relType","linkList","parseHalLink","_embedded","innerBodies","innerBody","parseLink","_templates","newBody","halForm","parseHalEmbedded","embeddedList","embeddedItem","templ","properties","prop","parseHalField","halField","required","readOnly","pattern","label","prompt","blob","parseJsonApiLink","contextUri","linkValue","parseJsonApiLinks","member","selfLink","parseJsonApiCollection","parseSirenLinks","parseSirenLink","entities","subEntity","parseSirenSubEntityAsLink","rels","newLink","selfHref","parseSirenSubEntityAsEmbedded","subEntityUrl","entity","subState","parseSirenEmbedded","actions","field","sirenFieldToField","parseSirenAction","text","collection","items","queries","query","parseCjLinks","htmlResult","parseHtml","forms","form","id","enctype","formToAction","linkFromTags","elements","node","getAttribute","formFromTags","DOMParser","parseFromString","contentHeaders","arg3","template","vars","expanded","uriTemplate","quote","startRule","parseFunctions","result0","result1","pos0","parse_nonexpression","parse_expression","Template","parse_op","matchFailed","parse_paramList","parse_param","parse_cut","parse_listMarker","parse_substr","parse_extension","rightmostFailuresPos","rightmostFailuresExpected","failure","result2","result3","pos1","op","expression","charAt","pos2","pos3","hd","rst","unshift","chars","clm","explode","listMarker","cut","extended","digits","cls","errorPosition","line","column","seenCR","ch","computeErrorPosition","SyntaxError","expected","sort","lastExpected","cleanExpected","cleanupExpected","toSource","_source","expectedHumanized","buildMessage","FormContinuationExpression","FormStartExpression","FragmentExpression","LabelExpression","NamedExpression","PathParamExpression","PathSegmentExpression","ReservedExpression","SimpleExpression","encoders","__bind","fn","me","__hasProp","__extends","child","parent","ctor","constructor","__super__","pieces","_this","expressions","prefix","shift","forEach","suffix","expr","_super","explodeArray","stringifySingle","param","empty","definedPairs","explodeObject","_expandPair","first","named","allow","substring","_results","defined","pair","vv","_i","_len","pctEncode","regexp","encoded","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","once","emitter","reject","eventListener","errorListener","removeListener","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","warning","newListener","warned","w","count","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","handler","listeners","addListener","on","prependListener","prependOnceListener","position","originalListener","pop","spliceOne","off","removeAllListeners","rawListeners","eventNames","Blob","cacheTimeout","activeTimers","setTimer","clearTimeout","setTimeout","userName","password","basicAuthHeader","btoa","token","bearerAuthHeader","oauth2Options","oauth2","OAuth2","fetchMw","oauth2Code","httpCode","fetchMwOAuth2","OAuth2Error","__importDefault","accessToken","expiresAt","refreshToken","getAccessToken","getToken","clientId","grantType","tokenEndpoint","grant_type","refresh_token","clientSecret","client_id","scope","username","redirect_uri","redirectUri","Authorization","objToQueryString","error_description","access_token","expires_in","onTokenUpdate"],"mappings":"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","file":"ketting.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Ketting\"] = factory();\n\telse\n\t\troot[\"Ketting\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 11);\n","import { LinkHints } from 'hal-types';\n\nexport type Link = {\n  /**\n   * Target URI\n   */\n  href: string,\n\n  /**\n   * Context URI.\n   *\n   * Used to resolve relative URIs\n   */\n  context: string;\n\n  /**\n   * Relation type\n   */\n  rel: string,\n\n  /**\n   * Link title\n   */\n  title?: string,\n\n  /**\n   * Content type hint of the target resource\n   */\n  type?: string,\n\n  /**\n   * Anchor.\n   *\n   * This describes where the link is linked from, from for example\n   * a fragment in the current document\n   */\n  anchor?: string,\n\n  /**\n   * Language of the target resource\n   */\n  hreflang?: string,\n\n  /**\n   * HTML5 media attribute\n   */\n  media?: string,\n\n  /**\n   * If templated is set to true, the href is a templated URI.\n   */\n  templated?: boolean,\n\n  /**\n   * Link hints, as defined in draft-nottingham-link-hint\n   */\n  hints?: LinkHints;\n\n}\n\ntype NewLink = Omit<Link, 'context'>;\n\n\n/**\n * Links container, providing an easy way to manage a set of links.\n */\nexport class Links {\n\n  private store: Map<string, Link[]>\n\n  constructor(public defaultContext: string, links?: Link[] | Links) {\n\n    this.store = new Map();\n\n    if (links) {\n      if (links instanceof Links) {\n        this.add(...links.getAll());\n      } else {\n        for (const link of links) {\n          this.add(link);\n        }\n      }\n    }\n\n  }\n\n  /**\n   * Adds a link to the list\n   */\n  add(...links: (Link | NewLink)[]): void\n  add(rel: string, href: string): void\n  add(...args: any[]): void {\n\n    let links: Link[];\n\n    if (typeof args[0] === 'string') {\n      links = [{\n        rel: args[0],\n        href: args[1],\n        context: this.defaultContext,\n      }];\n    } else {\n      links = args.map( link => { return { context: this.defaultContext, ...link };} );\n    }\n\n    for(const link of links) {\n      if (this.store.has(link.rel)) {\n        this.store.get(link.rel)!.push(link);\n      } else {\n        this.store.set(link.rel, [link]);\n      }\n    }\n\n  }\n\n  /**\n   * Set a link\n   *\n   * If a link with the provided 'rel' already existed, it will be overwritten.\n   */\n  set(link: Link | NewLink): void\n  set(rel: string, href: string): void\n  set(arg1: any, arg2?: any): void {\n\n    let link: Link;\n    if (typeof arg1 === 'string') {\n      link = {\n        rel: arg1,\n        href: arg2,\n        context: this.defaultContext,\n      };\n    } else {\n      link = {\n        context: this.defaultContext,\n        ...arg1,\n      };\n    }\n    this.store.set(link.rel, [link]);\n\n  }\n\n  /**\n   * Return a single link by its 'rel'.\n   *\n   * If the link does not exist, undefined is returned.\n   */\n  get(rel: string): Link|undefined {\n\n    const links = this.store.get(rel);\n    if (!links || links.length < 0) {\n      return undefined;\n    }\n    return links[0];\n\n  }\n\n  /**\n   * Delete all links with the given 'rel'.\n   */\n  delete(rel: string): void {\n\n    this.store.delete(rel);\n\n  }\n\n  /**\n   * Return all links that have a given rel.\n   *\n   * If no links with the rel were found, an empty array is returned.\n   */\n  getMany(rel: string): Link[] {\n\n    return this.store.get(rel) || [];\n\n  }\n\n  /**\n   * Return all links.\n   */\n  getAll(): Link[] {\n    const result = [];\n    for(const links of this.store.values()) {\n      result.push(...links);\n    }\n    return result;\n  }\n\n  /**\n   * Returns true if at least 1 link with the given rel exists.\n   */\n  has(rel: string): boolean {\n\n    return this.store.has(rel);\n\n  }\n\n}\n\n/**\n * The LinkNotFound error gets thrown whenever something tries to follow a\n * link by its rel, that doesn't exist\n */\nexport class LinkNotFound extends Error {}\n\n/**\n * A key->value map of variables to place in a templated link\n */\nexport type LinkVariables = {\n  [key: string]: string | number\n};\n","import * as LinkHeader from 'http-link-header';\nimport { Links } from '../link';\n\n/**\n * Takes a Content-Type header, and only returns the mime-type part.\n */\nexport function parseContentType(contentType: string | null): string | null {\n\n  if (!contentType) {\n    return null;\n  }\n  if (contentType.includes(';')) {\n    contentType = contentType.split(';')[0];\n  }\n  return contentType.trim();\n\n}\n\n\nexport function parseLink(context: string, header: string|null): Links {\n\n  const result = new Links(context);\n  if (!header) {\n    return result;\n  }\n\n  for (const httpLink of LinkHeader.parse(header).refs) {\n    // Looping through individual links\n    for (const rel of httpLink.rel.split(' ')) {\n      // Looping through space separated rel values.\n      const link = {\n        rel: rel,\n        href: httpLink.uri,\n        context,\n        title: httpLink.title,\n        hreflang: httpLink.hreflang,\n        type: httpLink.type,\n      };\n      result.add(link);\n    }\n  }\n  return result;\n}\n\nconst safeMethods = ['GET', 'HEAD', 'OPTIONS', 'PRI', 'PROPFIND', 'REPORT', 'SEARCH', 'TRACE'];\n\nexport function isSafeMethod(method: string): boolean {\n  return safeMethods.includes(method);\n}\n","import { Link } from '../link';\n\ntype UrlParts = {\n  host?: string,\n};\n\n/**\n * Resolves a relative url using another url.\n *\n * This is the browser-based version.\n */\nexport function resolve(base: string, relative: string): string;\nexport function resolve(link: Link): string;\nexport function resolve(base: string|Link, relative?: string): string {\n\n  if (typeof base !== 'string') {\n    relative = base.href;\n    base = base.context;\n  }\n\n  // If the URL object is supported, we prefer that.\n  if (typeof URL !== 'undefined' && /https?:\\/\\//.exec(base)?.index === 0) {\n    return (new URL(relative!, base).toString());\n  }\n\n  // Code taken from this gist:;\n  // https://gist.github.com/johan/3915545#file-resolveurl-js\n\n  const doc     = document;\n  const oldBase = doc.getElementsByTagName('base')[0];\n  const oldHref = oldBase && oldBase.href;\n  const docHead = doc.head || doc.getElementsByTagName('head')[0];\n  const ourBase = oldBase || docHead.appendChild(doc.createElement('base'));\n  const resolver = doc.createElement('a');\n\n  ourBase.href = base;\n  resolver.href = relative!;\n  const resolvedUrl  = resolver.href; // browser magic at work here\n\n  if (oldBase) {\n    oldBase.href = oldHref;\n  } else {\n    docHead.removeChild(ourBase);\n  }\n  return resolvedUrl;\n\n}\n\n/**\n * Parses a url in multiple components.\n *\n * This is the browser-based version.\n */\nexport function parse(url: string): UrlParts {\n\n  const urlObj = new URL(url);\n  return {\n    host: urlObj.host,\n  };\n\n}\n","import { State } from './interface';\nimport { Links } from '../link';\nimport Client from '../client';\nimport { Action, ActionNotFound, ActionInfo, SimpleAction } from '../action';\n\n/**\n * The Base State provides a convenient way to implement a new State type.\n */\nexport abstract class BaseState<T> implements State<T> {\n\n  /**\n   * Timestamp of when the State was first generated\n   */\n  timestamp: number;\n\n  /**\n   * Reference to main client that created this state\n   */\n  client!: Client;\n\n  constructor(\n    public uri: string,\n    public data: T,\n    public headers: Headers,\n    public links: Links,\n    protected embedded: State[] = [],\n    protected actionInfo: ActionInfo[] = []) {\n\n    this.timestamp = Date.now();\n\n  }\n\n  /**\n   * Content-headers are a subset of HTTP headers that related directly\n   * to the content. The obvious ones are Content-Type.\n   *\n   * This set of headers will be sent by the server along with a GET\n   * response, but will also be sent back to the server in a PUT\n   * request.\n   */\n  contentHeaders(): Headers {\n\n    const contentHeaderNames = [\n      'Content-Type',\n      'Content-Language',\n      'ETag',\n      'Last-Modified',\n    ];\n\n    const result: {[name: string]: string} = {};\n\n    for(const contentHeader of contentHeaderNames) {\n      if (this.headers.has(contentHeader)) {\n        result[contentHeader] = this.headers.get(contentHeader)!;\n      }\n    }\n    return new Headers(result);\n\n  }\n\n  /**\n   * Return an action by name.\n   *\n   * If no name is given, the first action is returned. This is useful for\n   * formats that only supply 1 action, and no name.\n   */\n  action<TFormData = any>(name?: string): Action<TFormData> {\n\n    if (!this.actionInfo.length) {\n      throw new ActionNotFound('This State does not define any actions');\n    }\n    if (name === undefined) {\n      return new SimpleAction(this.client, this.actionInfo[0]);\n    }\n    for(const action of this.actionInfo) {\n      if (action.name === name) {\n        return new SimpleAction(this.client, this.actionInfo[0]);\n      }\n    }\n    throw new ActionNotFound('This State defines no action');\n\n  }\n\n  /**\n   * Returns all actions\n   */\n  actions(): Action[] {\n\n    return this.actionInfo.map(action => new SimpleAction(this.client, action));\n\n  }\n\n  /**\n   * Checks if the specified action exists.\n   *\n   * If no name is given, checks if _any_ action exists.\n   */\n  hasAction(name?: string): boolean {\n\n    if (name===undefined) return this.actionInfo.length>0;\n    for(const action of this.actionInfo) {\n      if (name === action.name) {\n        return true;\n      }\n    }\n    return false;\n\n  }\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  abstract serializeBody(): Buffer|Blob|string;\n\n  /**\n   * Certain formats can embed other resources, identified by their\n   * own URI.\n   *\n   * When a format has embedded resources, we will use these to warm\n   * the cache.\n   *\n   * This method returns every embedded resource.\n   */\n  getEmbedded(): State[] {\n\n    return this.embedded;\n\n  }\n\n  abstract clone(): State<T>;\n\n}\n","export { State, StateFactory, HeadState, isState } from './interface';\nexport { BaseState } from './base-state';\nexport { factory as halStateFactory, HalState } from './hal';\nexport { factory as binaryStateFactory, BinaryState } from './binary';\nexport { factory as jsonApiStateFactory, JsonApiState } from './jsonapi';\nexport { factory as sirenStateFactory, SirenState } from './siren';\nexport { factory as textStateFactory, TextState } from './text';\nexport { factory as cjStateFactory, CjState } from './collection-json';\nexport { factory as htmlStateFactory, HtmlState } from './html';\nexport { factory as headStateFactory } from './head';\n","/**\n * HttpError extends the Error object, and is thrown wheenever servers emit\n * HTTP errors.\n *\n * It has a response property, allowing users to find out more about the\n * nature of the error.\n */\nexport class HttpError extends Error {\n\n  response: Response;\n  status: number;\n\n  constructor(response: Response) {\n    super('HTTP error ' + response.status);\n    this.response = response;\n    this.status = response.status;\n  }\n\n}\n\n/**\n * Problem extends the HttpError object. If a server emits a HTTP error, and\n * the response body's content-type is application/problem+json.\n *\n * application/problem+json is defined in RFC7807 and provides a standardized\n * way to describe error conditions by a HTTP server.\n */\nexport class Problem extends HttpError {\n\n  body: {\n    title?: string\n  };\n\n  constructor(response: Response, problemBody: Record<string, any>) {\n    super(response);\n    this.body = problemBody;\n    if (this.body.title) {\n      this.message = 'HTTP Error ' + this.status + ': ' + this.body.title;\n    }\n  }\n\n}\n\n/**\n * This function creates problems, not unlike the the author of this file.\n *\n * It takes a Fetch Response object, and returns a HttpError. If the HTTP\n * response has a type of application/problem+json it will return a Problem\n * object.\n *\n * Because parsing the response might be asynchronous, the function returns\n * a Promise resolving in either object.\n */\nexport default async function problemFactory(response: Response): Promise<HttpError | Problem> {\n\n  const contentType = response.headers.get('Content-Type');\n  if (contentType && contentType.match(/^application\\/problem\\+json/i)) {\n    const problemBody = await response.json();\n    return new Problem(response, problemBody);\n  } else {\n    return new HttpError(response);\n  }\n\n}\n\n","import Client from './client';\nimport { State, headStateFactory, HeadState, isState } from './state';\nimport { resolve } from './util/uri';\nimport { FollowPromiseOne, FollowPromiseMany } from './follow-promise';\nimport { Link, LinkNotFound, LinkVariables } from './link';\nimport { EventEmitter } from 'events';\nimport { GetRequestOptions, PostRequestOptions, PatchRequestOptions, PutRequestOptions, HeadRequestOptions } from './types';\nimport { needsJsonStringify } from './util/fetch-body-helper';\n\n/**\n * A 'resource' represents an endpoint on a server.\n *\n * A resource has a uri, methods that correspond to HTTP methods,\n * and events to subscribe to state changes.\n */\nexport class Resource<T = any> extends EventEmitter {\n\n  /**\n   * URI of the current resource\n   */\n  uri: string;\n\n  /**\n   * Reference to the Client that created the resource\n   */\n  client: Client;\n\n  private activeRefresh: Promise<State<T>> | null;\n\n  /**\n   * Create the resource.\n   *\n   * This is usually done by the Client.\n   */\n  constructor(client: Client, uri: string) {\n    super();\n    this.client = client;\n    this.uri = uri;\n    this.activeRefresh = null;\n\n  }\n\n  /**\n   * Gets the current state of the resource.\n   *\n   * This function will return a State object.\n   */\n  get(getOptions?: GetRequestOptions): Promise<State<T>> {\n\n    const state = this.client.cache.get(this.uri);\n    if (!state) {\n      return this.refresh(getOptions);\n    }\n    return Promise.resolve(state);\n\n  }\n\n  /**\n   * Does a HEAD request and returns a HeadState object.\n   *\n   * If there was a valid existing cache for a GET request, it will\n   * still return that.\n   */\n  async head(headOptions?: HeadRequestOptions): Promise<HeadState> {\n\n    let state: State|HeadState|null = this.client.cache.get(this.uri);\n    if (state) {\n      return state;\n    }\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('HEAD', headOptions)\n    );\n\n    state = await headStateFactory(this.uri, response);\n    return state;\n\n  }\n\n\n  /**\n   * Gets the current state of the resource, skipping\n   * the cache.\n   *\n   * This function will return a State object.\n   */\n  refresh(getOptions?: GetRequestOptions): Promise<State<T>> {\n\n    const params: RequestInit = {\n      cache: 'reload',\n    };\n    if (getOptions?.getContentHeaders && !getOptions?.headers) {\n      params.headers = getOptions.getContentHeaders();\n    } else if (!getOptions?.getContentHeaders && getOptions?.headers) {\n      params.headers = getOptions.headers;\n    } else if (getOptions?.getContentHeaders && getOptions?.headers) {\n      params.headers = getOptions.getContentHeaders();\n      params.headers = { ...getOptions.headers, ...params.headers};\n    }\n\n    if (!this.activeRefresh) {\n      this.activeRefresh = (async() : Promise<State<T>> => {\n        try {\n          const response = await this.fetchOrThrow(params);\n          const state = await this.client.getStateForResponse(this.uri, response);\n          this.updateCache(state);\n          return state;\n        } finally {\n          this.activeRefresh = null;\n        }\n      })();\n    }\n\n    return this.activeRefresh;\n\n  }\n\n  /**\n   * Updates the server state with a PUT request\n   */\n  async put(options: PutRequestOptions<T> | State): Promise<void> {\n\n    const requestInit = optionsToRequestInit('PUT', options);\n\n    /**\n     * If we got a 'State' object passed, it means we don't need to emit a\n     * stale event, as the passed object is the new\n     * state.\n     *\n     * We're gonna track that with a custom header that will be removed\n     * later in the fetch pipeline.\n     */\n    if (isState(options)) {\n      requestInit.headers.set('X-KETTING-NO-STALE', '1');\n    }\n\n    await this.fetchOrThrow(requestInit);\n\n    if (isState(options)) {\n      this.updateCache(options);\n\n    }\n\n  }\n\n  /**\n   * Deletes the resource\n   */\n  async delete(): Promise<void> {\n\n    await this.fetchOrThrow(\n      { method: 'DELETE' }\n    );\n\n  }\n\n  /**\n   * Sends a POST request to the resource.\n   *\n   * See the documentation for PostRequestOptions for more details.\n   * This function is used for RPC-like endpoints and form submissions.\n   *\n   * This function will return the response as a State object.\n   */\n  async post(options: PostRequestOptions): Promise<State> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('POST', options)\n    );\n\n    return this.client.getStateForResponse(this.uri, response);\n\n  }\n\n  /**\n   * Sends a POST request, and follows to the next resource.\n   *\n   * If a server responds with a 201 Status code and a Location header,\n   * it will automatically return the newly created resource.\n   *\n   * If the server responded with a 204 or 205, this function will return\n   * `this`.\n   */\n  async postFollow(options: PostRequestOptions): Promise<Resource> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('POST', options)\n    );\n\n    switch (response.status) {\n      case 201:\n        if (response.headers.has('location')) {\n          return this.go(<string> response.headers.get('location'));\n        }\n        throw new Error('Could not follow after a 201 request, because the server did not reply with a Location header');\n      case 204 :\n      case 205 :\n        return this;\n      default:\n        throw new Error('Did not receive a 201, 204 or 205 status code so we could not follow to the next resource');\n    }\n\n  }\n\n  /**\n   * Sends a PATCH request to the resource.\n   *\n   * This function defaults to a application/json content-type header.\n   *\n   * If the server responds with 200 Status code this will return a State object\n   */\n  async patch(options: PatchRequestOptions): Promise<void | State<T>> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('PATCH', options)\n    );\n\n    if (response.status === 200) {\n      return await this.client.getStateForResponse(this.uri, response);\n    }\n  }\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TFollowedResource> {\n\n    return new FollowPromiseOne(this, rel, variables);\n\n  }\n\n  /**\n   * Follows a relationship based on its reltype. This function returns a\n   * Promise that resolves to an array of Resource objects.\n   *\n   * If no resources were found, the array will be empty.\n   */\n  followAll<TFollowedResource = any>(rel: string): FollowPromiseMany<TFollowedResource> {\n\n    return new FollowPromiseMany(this, rel);\n\n  }\n\n  /**\n   * Resolves a new resource based on a relative uri.\n   *\n   * Use this function to manually get a Resource object via a uri. The uri\n   * will be resolved based on the uri of the current resource.\n   *\n   * This function doesn't do any HTTP requests.\n   */\n  go<TGoResource = any>(uri: string): Resource<TGoResource> {\n\n    uri = resolve(this.uri, uri);\n    return this.client.go(uri);\n\n  }\n\n  /**\n   * Does a HTTP request on the current resource URI\n   */\n  fetch(init?: RequestInit): Promise<Response> {\n\n    return this.client.fetcher.fetch(this.uri, init);\n\n  }\n\n  /**\n   * Does a HTTP request on the current resource URI.\n   *\n   * If the response was a 4XX or 5XX, this function will throw\n   * an exception.\n   */\n  fetchOrThrow(init?: RequestInit): Promise<Response> {\n\n    return this.client.fetcher.fetchOrThrow(this.uri, init);\n\n  }\n\n  /**\n   * Updates the state cache, and emits events.\n   *\n   * This will update the local state but *not* update the server\n   */\n  updateCache(state: State<T>) {\n\n    if (state.uri !== this.uri) {\n      throw new Error('When calling updateCache on a resource, the uri of the State object must match the uri of the Resource');\n    }\n    this.client.cacheState(state);\n\n  }\n\n  /**\n   * Clears the state cache for this resource.\n   */\n  clearCache(): void {\n\n    this.client.cache.delete(this.uri);\n\n  }\n\n  /**\n   * Returns a Link object, by its REL.\n   *\n   * If the link does not exist, a LinkNotFound error will be thrown.\n   *\n   * @deprecated\n   */\n  async link(rel: string): Promise<Link> {\n\n    const state = await this.get();\n    const link = state.links.get(rel);\n\n    if (!link) {\n      throw new LinkNotFound(`Link with rel: ${rel} not found on ${this.uri}`);\n    }\n    return link;\n\n  }\n\n  /**\n   * Returns all links defined on this object.\n   *\n   * @deprecated\n   */\n  async links(rel?: string): Promise<Link[]> {\n\n    const state = await this.get();\n    if (!rel) {\n      return state.links.getAll();\n    } else {\n      return state.links.getMany(rel);\n    }\n\n  }\n\n  /**\n   *\n   * Returns true or false depending on if a link with the specified relation\n   * type exists.\n   *\n   * @deprecated\n   */\n  async hasLink(rel: string): Promise<boolean> {\n\n    const state = await this.get();\n    return state.links.has(rel);\n\n  }\n}\n\n// eslint doesn't like that we have a generic T but not using it.\n// eslint-disable-next-line\nexport declare interface Resource<T = any> {\n\n  /**\n   * Subscribe to the 'update' event.\n   *\n   * This event will get triggered whenever a new State is received\n   * from the server, either through a GET request or if it was\n   * transcluded.\n   *\n   * It will also trigger when calling 'PUT' with a full state object,\n   * and when updateCache() was used.\n   */\n  on(event: 'update', listener: (state: State) => void) : this\n\n  /**\n   * Subscribe to the 'stale' event.\n   *\n   * This event will get triggered whenever an unsafe method was\n   * used, such as POST, PUT, PATCH, etc.\n   *\n   * When any of these methods are used, the local cache is stale.\n   */\n  on(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'delete' event.\n   *\n   * This event gets triggered when the `DELETE` http method is used.\n   */\n  on(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'update' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'update', listener: (state: State) => void) : this\n\n  /**\n   * Subscribe to the 'stale' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'delete' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Unsubscribe from the 'update' event\n   */\n  off(event: 'update', listener: (state: State) => void) : this\n\n  /**\n   * Unsubscribe from the 'stale' event\n   */\n  off(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Unsubscribe from the 'delete' event\n   */\n  off(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Emit an 'update' event.\n   */\n  emit(event: 'update', state: State) : boolean\n\n  /**\n   * Emit a 'stale' event.\n   */\n  emit(event: 'stale') : boolean;\n\n  /**\n   * Emit a 'delete' event.\n   */\n  emit(event: 'delete') : boolean;\n\n}\n\nexport default Resource;\n\ntype StrictRequestInit = RequestInit & {\n  headers: Headers,\n};\n\n/**\n * Convert request options to RequestInit\n *\n * RequestInit is passed to the constructor of fetch(). We have our own 'options' format\n */\nfunction optionsToRequestInit(method: 'GET', options?: GetRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'HEAD', options?: HeadRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'PATCH', options?: PatchRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'POST', options?: PostRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'PUT', options?: PutRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: string, options?: GetRequestOptions | PostRequestOptions | PatchRequestOptions | PutRequestOptions): StrictRequestInit {\n\n  if (!options) {\n    return {\n      method,\n      headers: new Headers(),\n    };\n  }\n  let headers;\n  if (options.getContentHeaders) {\n    headers = new Headers(options.getContentHeaders());\n  } else if (options.headers) {\n    headers = new Headers(options.headers);\n  } else {\n    headers = new Headers();\n  }\n  if (!headers.has('Content-Type')) {\n    headers.set('Content-Type', 'application/json');\n  }\n  let body;\n  if ((options as any).serializeBody !== undefined) {\n    body = (options as any).serializeBody();\n  } else if ((options as any).data) {\n    body = (options as any).data;\n    if (needsJsonStringify(body)) {\n      body = JSON.stringify(body);\n    }\n  } else {\n    body = null;\n  }\n  return {\n    method,\n    body,\n    headers,\n  };\n\n}\n\n","'use strict'\n\nvar COMPATIBLE_ENCODING_PATTERN = /^utf-?8|ascii|utf-?16-?le|ucs-?2|base-?64|latin-?1$/i\nvar WS_TRIM_PATTERN = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g\nvar WS_CHAR_PATTERN = /\\s|\\uFEFF|\\xA0/\nvar WS_FOLD_PATTERN = /\\r?\\n[\\x20\\x09]+/g\nvar DELIMITER_PATTERN = /[;,\"]/\nvar WS_DELIMITER_PATTERN = /[;,\"]|\\s/\n\n/**\n * Token character pattern\n * @type {RegExp}\n * @see https://tools.ietf.org/html/rfc7230#section-3.2.6\n */\nvar TOKEN_PATTERN = /^[!#$%&'*+\\-\\.^_`|~\\da-zA-Z]+$/\n\nvar STATE = {\n  IDLE: 1 << 0,\n  URI: 1 << 1,\n  ATTR: 1 << 2,\n}\n\nfunction trim( value ) {\n  return value.replace( WS_TRIM_PATTERN, '' )\n}\n\nfunction hasWhitespace( value ) {\n  return WS_CHAR_PATTERN.test( value )\n}\n\nfunction skipWhitespace( value, offset ) {\n  while( hasWhitespace( value[offset] ) ) {\n    offset++\n  }\n  return offset\n}\n\nfunction needsQuotes( value ) {\n  return WS_DELIMITER_PATTERN.test( value ) ||\n    !TOKEN_PATTERN.test( value )\n}\n\nclass Link {\n\n  /**\n   * Link\n   * @constructor\n   * @param {String} [value]\n   * @returns {Link}\n   */\n  constructor( value ) {\n\n    /** @type {Array} URI references */\n    this.refs = []\n\n    if( value ) {\n      this.parse( value )\n    }\n\n  }\n\n  /**\n   * Get refs with given relation type\n   * @param {String} value\n   * @returns {Array<Object>}\n   */\n  rel( value ) {\n\n    var links = []\n    var type = value.toLowerCase()\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ].rel.toLowerCase() === type ) {\n        links.push( this.refs[ i ] )\n      }\n    }\n\n    return links\n\n  }\n\n  /**\n   * Get refs where given attribute has a given value\n   * @param {String} attr\n   * @param {String} value\n   * @returns {Array<Object>}\n   */\n  get( attr, value ) {\n\n    attr = attr.toLowerCase()\n\n    var links = []\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ][ attr ] === value ) {\n        links.push( this.refs[ i ] )\n      }\n    }\n\n    return links\n\n  }\n\n  set( link ) {\n    this.refs.push( link )\n    return this\n  }\n\n  has( attr, value ) {\n\n    attr = attr.toLowerCase()\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ][ attr ] === value ) {\n        return true\n      }\n    }\n\n    return false\n\n  }\n\n  parse( value, offset ) {\n\n    offset = offset || 0\n    value = offset ? value.slice( offset ) : value\n\n    // Trim & unfold folded lines\n    value = trim( value ).replace( WS_FOLD_PATTERN, '' )\n\n    var state = STATE.IDLE\n    var length = value.length\n    var offset = 0\n    var ref = null\n\n    while( offset < length ) {\n      if( state === STATE.IDLE ) {\n        if( hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        } else if( value[offset] === '<' ) {\n          if( ref != null ) {\n            ref.rel != null ?\n              this.refs.push( ...Link.expandRelations( ref ) ) :\n              this.refs.push( ref )\n          }\n          var end = value.indexOf( '>', offset )\n          if( end === -1 ) throw new Error( 'Expected end of URI delimiter at offset ' + offset )\n          ref = { uri: value.slice( offset + 1, end ) }\n          // this.refs.push( ref )\n          offset = end\n          state = STATE.URI\n        } else {\n          throw new Error( 'Unexpected character \"' + value[offset] + '\" at offset ' + offset )\n        }\n        offset++\n      } else if( state === STATE.URI ) {\n        if( hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        } else if( value[offset] === ';' ) {\n          state = STATE.ATTR\n          offset++\n        } else if( value[offset] === ',' ) {\n          state = STATE.IDLE\n          offset++\n        } else {\n          throw new Error( 'Unexpected character \"' + value[offset] + '\" at offset ' + offset )\n        }\n      } else if( state === STATE.ATTR ) {\n        if( value[offset] ===';' || hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        }\n        var end = value.indexOf( '=', offset )\n        if( end === -1 ) throw new Error( 'Expected attribute delimiter at offset ' + offset )\n        var attr = trim( value.slice( offset, end ) ).toLowerCase()\n        var attrValue = ''\n        offset = end + 1\n        offset = skipWhitespace( value, offset )\n        if( value[offset] === '\"' ) {\n          offset++\n          while( offset < length ) {\n            if( value[offset] === '\"' ) {\n              offset++; break\n            }\n            if( value[offset] === '\\\\' ) {\n              offset++\n            }\n            attrValue += value[offset]\n            offset++\n          }\n        } else {\n          var end = offset + 1\n          while( !DELIMITER_PATTERN.test( value[end] ) && end < length ) {\n            end++\n          }\n          attrValue = value.slice( offset, end )\n          offset = end\n        }\n        if( ref[ attr ] && Link.isSingleOccurenceAttr( attr ) ) {\n          // Ignore multiples of attributes which may only appear once\n        } else if( attr[ attr.length - 1 ] === '*' ) {\n          ref[ attr ] = Link.parseExtendedValue( attrValue )\n        } else {\n          attrValue = attr === 'type' ?\n            attrValue.toLowerCase() : attrValue\n          if( ref[ attr ] != null ) {\n            if( Array.isArray( ref[ attr ] ) ) {\n              ref[ attr ].push( attrValue )\n            } else {\n              ref[ attr ] = [ ref[ attr ], attrValue ]\n            }\n          } else {\n            ref[ attr ] = attrValue\n          }\n        }\n        switch( value[offset] ) {\n          case ',': state = STATE.IDLE; break\n          case ';': state = STATE.ATTR; break\n        }\n        offset++\n      } else {\n        throw new Error( 'Unknown parser state \"' + state + '\"' )\n      }\n    }\n\n    if( ref != null ) {\n      ref.rel != null ?\n        this.refs.push( ...Link.expandRelations( ref ) ) :\n        this.refs.push( ref )\n    }\n\n    ref = null\n\n    return this\n\n  }\n\n  toString() {\n\n    var refs = []\n    var link = ''\n    var ref = null\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      ref = this.refs[i]\n      link = Object.keys( this.refs[i] ).reduce( function( link, attr ) {\n        if( attr === 'uri' ) return link\n        return link + '; ' + Link.formatAttribute( attr, ref[ attr ] )\n      }, '<' + ref.uri + '>' )\n      refs.push( link )\n    }\n\n    return refs.join( ', ' )\n\n  }\n\n}\n\n/**\n * Determines whether an encoding can be\n * natively handled with a `Buffer`\n * @param {String} value\n * @returns {Boolean}\n */\nLink.isCompatibleEncoding = function( value ) {\n  return COMPATIBLE_ENCODING_PATTERN.test( value )\n}\n\nLink.parse = function( value, offset ) {\n  return new Link().parse( value, offset )\n}\n\nLink.isSingleOccurenceAttr = function( attr ) {\n  return attr === 'rel' || attr === 'type' || attr === 'media' ||\n    attr === 'title' || attr === 'title*'\n}\n\nLink.isTokenAttr = function( attr ) {\n  return attr === 'rel' || attr === 'type' || attr === 'anchor'\n}\n\nLink.escapeQuotes = function( value ) {\n  return value.replace( /\"/g, '\\\\\"' )\n}\n\nLink.expandRelations = function( ref ) {\n  var rels = ref.rel.split( ' ' )\n  return rels.map( function( rel ) {\n    var value = Object.assign( {}, ref )\n    value.rel = rel\n    return value\n  })\n}\n\n/**\n * Parses an extended value and attempts to decode it\n * @internal\n * @param {String} value\n * @return {Object}\n */\nLink.parseExtendedValue = function( value ) {\n  var parts = /([^']+)?(?:'([^']+)')?(.+)/.exec( value )\n  return {\n    language: parts[2].toLowerCase(),\n    encoding: Link.isCompatibleEncoding( parts[1] ) ?\n      null : parts[1].toLowerCase(),\n    value: Link.isCompatibleEncoding( parts[1] ) ?\n      decodeURIComponent( parts[3] ) : parts[3]\n  }\n}\n\n/**\n * Format a given extended attribute and it's value\n * @param {String} attr\n * @param {Object} data\n * @return {String}\n */\nLink.formatExtendedAttribute = function( attr, data ) {\n\n  var encoding = ( data.encoding || 'utf-8' ).toUpperCase()\n  var language = data.language || 'en'\n\n  var encodedValue = ''\n\n  if( Buffer.isBuffer( data.value ) && Link.isCompatibleEncoding( encoding ) ) {\n    encodedValue = data.value.toString( encoding )\n  } else if( Buffer.isBuffer( data.value ) ) {\n    encodedValue = data.value.toString( 'hex' )\n      .replace( /[0-9a-f]{2}/gi, '%$1' )\n  } else {\n    encodedValue = encodeURIComponent( data.value )\n  }\n\n  return attr + '=' + encoding + '\\'' +\n    language + '\\'' + encodedValue\n\n}\n\n/**\n * Format a given attribute and it's value\n * @param {String} attr\n * @param {String|Object} value\n * @return {String}\n */\nLink.formatAttribute = function( attr, value ) {\n\n  if( Array.isArray( value ) ) {\n    return value.map(( item ) => {\n      return Link.formatAttribute( attr, item )\n    }).join( '; ' )\n  }\n\n  if( attr[ attr.length - 1 ] === '*' || typeof value !== 'string' ) {\n    return Link.formatExtendedAttribute( attr, value )\n  }\n\n  if( Link.isTokenAttr( attr ) ) {\n    value = needsQuotes( value ) ?\n      '\"' + Link.escapeQuotes( value ) + '\"' :\n      Link.escapeQuotes( value )\n  } else if( needsQuotes( value ) ) {\n    value = encodeURIComponent( value )\n    // We don't need to escape <SP> <,> <;> within quotes\n    value = value\n      .replace( /%20/g, ' ' )\n      .replace( /%2C/g, ',' )\n      .replace( /%3B/g, ';' )\n\n    value = '\"' + value + '\"'\n  }\n\n  return attr + '=' + value\n\n}\n\nmodule.exports = Link\n","import Resource from './resource';\nimport { LinkVariables, LinkNotFound } from './link';\nimport { resolve } from './util/uri';\nimport { expand } from './util/uri-template';\n\n/**\n * Base interface for both FollowOne and FollowAll\n */\nabstract class FollowPromise<T> implements PromiseLike<T> {\n\n  protected prefetchEnabled: boolean;\n  protected preferPushEnabled: boolean;\n  protected preferTranscludeEnabled: boolean;\n  protected useHeadEnabled: boolean;\n\n  constructor() {\n    this.prefetchEnabled = false;\n    this.preferPushEnabled = false;\n    this.preferTranscludeEnabled = false;\n    this.useHeadEnabled = false;\n  }\n\n  preFetch(): this {\n    this.prefetchEnabled = true;\n    return this;\n  }\n\n  preferPush(): this {\n    this.preferPushEnabled = true;\n    return this;\n  }\n\n  preferTransclude(): this {\n    this.preferTranscludeEnabled = true;\n    return this;\n  }\n\n  /**\n   * Use a HTTP HEAD request to fetch the links.\n   *\n   * This is useful when interacting with servers that embed links in Link\n   * Headers.\n   */\n  useHead(): this {\n\n    this.useHeadEnabled = true;\n    return this;\n\n  }\n\n  abstract then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;\n  abstract catch<TResult1 = T, TResult2 = never>(onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;\n\n}\n\n/**\n * The FollowPromise class is what's being returned from follow() functions.\n *\n * It's 'PromiseLike', which means you can treat it like a Promise, and it\n * can be awaited. When used as a Promise, it resolves to the Resource object\n * that was followed.\n *\n * In addition to being a Promise<Resource> stand-in, it also exposes other\n * functions, namely:\n *\n * * `follow()` to allow a user to chain several follow() functions to do\n *   several 'hops' all at once.\n * * `followAll()`, allowing a user to call `followAll()` at the end of a\n *   chain.\n */\nexport class FollowPromiseOne<T = any> extends FollowPromise<Resource<T>> {\n\n  private resource: Resource | Promise<Resource>;\n  private rel: string;\n  private variables?: LinkVariables;\n\n  constructor(resource: Resource | Promise<Resource>, rel: string, variables?: LinkVariables) {\n\n    super();\n    this.resource = resource;\n    this.rel = rel;\n    this.variables = variables;\n\n  }\n\n  /**\n   * This 'then' function behaves like a Promise then() function.\n   *\n   * This method signature is pretty crazy, but trust that it's pretty much\n   * like any then() method on a promise.\n   */\n  then<TResult1 = Resource<T>, TResult2 = never>(\n    onfulfilled?: ((value: Resource<T>) => TResult1 | PromiseLike<TResult1>) | null | undefined,\n    onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined\n  ): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResource().then(onfulfilled, onrejected);\n\n  }\n\n  /**\n   * This 'catch' function behaves like a Promise catch() function.\n   */\n  catch<TResult1 = any, TResult2 = never>(onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResource().then(undefined, onrejected);\n\n  }\n\n  /**\n   * Implementation of a Promise.finally function\n   */\n  finally<TResult1 = any>(onfinally: () => TResult1 | PromiseLike<TResult1>): Promise<TResult1> {\n\n    return this.then(\n      () => onfinally(),\n      () => onfinally()\n    );\n\n  }\n\n  /**\n   * Follow another link immediately after following this link.\n   *\n   * This allows you to follow several hops of links in one go.\n   *\n   * For example: resource.follow('foo').follow('bar');\n   */\n  follow<TNested = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TNested> {\n\n    return new FollowPromiseOne(this.fetchLinkedResource(), rel, variables);\n\n  }\n\n  /**\n   * Follows a set of links immediately after following this link.\n   *\n   * For example: resource.follow('foo').followAll('item');\n   */\n  followAll<TNested = any>(rel: string): FollowPromiseMany<TNested> {\n\n    return new FollowPromiseMany(this.fetchLinkedResource(), rel);\n\n  }\n\n  /**\n   * This function does the actual fetching of the linked\n   * resource.\n   */\n  private async fetchLinkedResource(): Promise<Resource<T>> {\n\n    const resource = await this.resource;\n\n    const headers: { [name: string]: string } = {};\n    if (this.preferPushEnabled) {\n      headers['Prefer-Push'] = this.rel;\n    }\n    if (!this.useHeadEnabled && this.preferTranscludeEnabled) {\n      headers.Prefer = 'transclude=' + this.rel;\n    }\n\n    let state;\n    if (this.useHeadEnabled) {\n      state = await resource.head({headers});\n    } else {\n      state = await resource.get({\n        headers\n      });\n    }\n\n    const link = state.links.get(this.rel);\n\n    if (!link) throw new LinkNotFound(`Link with rel ${this.rel} on ${state.uri} not found`);\n    let href;\n\n    if (link.templated && this.variables) {\n      href = expand(link, this.variables);\n    } else {\n      href = resolve(link);\n    }\n\n    const newResource = resource.go(href);\n\n    if (this.prefetchEnabled) {\n      newResource.get().catch( err => {\n        // eslint-disable-next-line no-console\n        console.warn('Error while prefetching linked resource', err);\n      });\n    }\n\n    return newResource;\n\n  }\n\n}\n\n/**\n */\nexport class FollowPromiseMany<T = any> extends FollowPromise<Resource<T>[]> {\n\n  private resource: Resource | Promise<Resource>;\n  private rel: string;\n\n  constructor(resource: Resource | Promise<Resource>, rel: string) {\n\n    super();\n    this.resource = resource;\n    this.rel = rel;\n\n  }\n\n  /**\n   * This 'then' function behaves like a Promise then() function.\n   */\n  then<TResult1 = Resource<T>[], TResult2 = never>(\n    onfulfilled?: ((value: Resource<T>[]) => TResult1 | PromiseLike<TResult1>) | null | undefined,\n    onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined\n  ): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResources().then(onfulfilled, onrejected);\n\n  }\n\n  /**\n   * This 'catch' function behaves like a Promise catch() function.\n   */\n  catch<TResult1 = any, TResult2 = never>(onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResources().then(undefined, onrejected);\n\n  }\n\n  /**\n   * Implementation of a Promise.finally function\n   */\n  finally<TResult1 = any>(onfinally: () => TResult1 | PromiseLike<TResult1>): Promise<TResult1> {\n\n    return this.then(\n      () => onfinally(),\n      () => onfinally()\n    );\n\n  }\n\n  /**\n   * This function does the actual fetching, to obtained the url\n   * of the linked resource. It returns the Resource object.\n   */\n  private async fetchLinkedResources(): Promise<Resource<T>[]> {\n\n    const resource = await this.resource;\n    const headers: { [name: string]: string } = {};\n    if (this.preferPushEnabled) {\n      headers['Prefer-Push'] = this.rel;\n    }\n    if (!this.useHeadEnabled && this.preferTranscludeEnabled) {\n      headers.Prefer = 'transclude=' + this.rel;\n    }\n\n    let state;\n    if (this.useHeadEnabled) {\n      state = await resource.head({headers});\n    } else {\n      state = await resource.get({\n        headers\n      });\n    }\n\n    const links = state.links.getMany(this.rel);\n\n    let href;\n\n    const result: Resource<T>[] = [];\n\n    for (const link of links) {\n      href = resolve(link);\n\n      const newResource = resource.go(href);\n      result.push(newResource);\n      if (this.prefetchEnabled) {\n        newResource.get().catch( err => {\n          // eslint-disable-next-line no-console\n          console.warn('Error while prefetching linked resource', err);\n        });\n      }\n    }\n\n    return result;\n\n  }\n\n}\n","export { ForeverCache } from './forever';\nexport { ShortCache } from './short';\nexport { NeverCache } from './never';\nimport { State } from '../state';\n\n/**\n * Cache interface\n *\n * The cache is responsible for storing 'state' objects\n */\nexport interface StateCache {\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store: (state: State) => void;\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get: (uri: string) => State | null;\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has: (uri: string) => boolean;\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete: (uri: string) => void;\n\n  /**\n   * Purge the entire cache\n   */\n  clear: () => void;\n\n}\n","import { StateCache } from './';\nimport { State } from '../state';\n\n/**\n * The 'Forever' cache stores any State for as long as the application\n * lives.\n *\n * It is a good default for most applications, but it means that if\n * a resource was changed server-side, Ketting will not pick up that change\n * until something was done to expire caches.\n *\n * Executing an unsafe method, calling clearCache() on a resource, or\n * when a resource appears in Location, Content-Location, or \"invalidates\"\n * link relationships.\n */\nexport class ForeverCache implements StateCache {\n\n  private cache: Map<string, State>;\n\n  constructor() {\n    this.cache = new Map();\n  }\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    this.cache.set(\n      state.uri,\n      state.clone()\n    );\n  }\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get(uri: string): State | null {\n\n    const state = this.cache.get(uri);\n    if (!state) {\n      return null;\n    }\n    return state.clone();\n\n  }\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has(uri: string): boolean {\n\n    return this.cache.has(uri);\n\n  }\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete(uri: string) {\n    this.cache.delete(uri);\n  }\n\n  /**\n   * Purge the entire cache\n   */\n  clear() {\n    this.cache.clear();\n  }\n\n}\n","export { default as Client, default as Ketting, default } from './client';\nexport { default as Resource } from './resource';\n\nexport { Link, LinkNotFound, Links } from './link';\n\nexport { resolve } from './util/uri';\n\nexport {\n  State,\n  HalState,\n  BinaryState,\n  JsonApiState,\n  SirenState,\n  TextState,\n  CjState,\n  HtmlState,\n  isState,\n} from './state';\n\nexport {\n  ForeverCache,\n  NeverCache,\n  ShortCache,\n} from './cache';\n\nexport { default as basicAuth } from './http/basic-auth';\nexport { default as bearerAuth } from './http/bearer-auth';\nexport { default as oauth2 } from './http/oauth2';\n\nexport { Problem } from './http/error';\n\nexport { Action } from './action';\nexport * as Field from './field';\n\nexport { FollowPromiseOne, FollowPromiseMany } from './follow-promise';\n","import { Fetcher, FetchMiddleware } from './http/fetcher';\nimport Resource from './resource';\nimport { State, StateFactory } from './state';\nimport {\n  halStateFactory,\n  binaryStateFactory,\n  jsonApiStateFactory,\n  sirenStateFactory,\n  textStateFactory,\n  cjStateFactory,\n  htmlStateFactory\n} from './state';\nimport { parseContentType, isSafeMethod } from './http/util';\nimport { resolve } from './util/uri';\nimport { LinkVariables } from './link';\nimport { FollowPromiseOne } from './follow-promise';\nimport { StateCache, ForeverCache } from './cache';\nimport * as LinkHeader from 'http-link-header';\n\nexport default class Client {\n\n  /**\n   * All relative urls will by default use the bookmarkUri to\n   * expand. It should usually be the starting point of your\n   * API\n   */\n  bookmarkUri: string;\n\n  /**\n   * Supported content types\n   *\n   * Each content-type has a 'factory' that turns a HTTP response\n   * into a State object.\n   *\n   * The last value in the array is the 'q=' value, used in Accept\n   * headers. Higher means higher priority.\n   */\n  contentTypeMap: {\n    [mimeType: string]: [StateFactory<any>, string],\n  } = {\n    'application/prs.hal-forms+json': [halStateFactory, '1.0'],\n    'application/hal+json': [halStateFactory, '0.9'],\n    'application/vnd.api+json': [jsonApiStateFactory, '0.8'],\n    'application/vnd.siren+json': [sirenStateFactory, '0.8'],\n    'application/vnd.collection+json': [cjStateFactory, '0.8'],\n    'application/json': [halStateFactory, '0.7'],\n    'text/html': [htmlStateFactory, '0.6'],\n  }\n\n  /**\n   * The cache for 'State' objects\n   */\n  cache: StateCache;\n\n  /**\n   * The cache for 'Resource' objects. Each unique uri should\n   * only ever get 1 associated resource.\n   */\n  resources: Map<string, Resource>;\n\n  /**\n   * Fetcher is a utility object that handles fetch() requests\n   * and middlewares.\n   */\n  fetcher: Fetcher;\n\n  constructor(bookmarkUri: string) {\n    this.bookmarkUri = bookmarkUri;\n    this.fetcher = new Fetcher();\n    this.fetcher.use( this.cacheExpireHandler );\n    this.fetcher.use( this.acceptHeader );\n    this.cache = new ForeverCache();\n    this.resources = new Map();\n  }\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TFollowedResource> {\n\n    return this.go().follow(rel, variables);\n\n  }\n\n  /**\n   * Returns a resource by its uri.\n   *\n   * This function doesn't do any HTTP requests. The uri is optional. If it's\n   * not specified, it will return the bookmark resource.\n   *\n   * If a relative uri is passed, it will be resolved based on the bookmark\n   * uri.\n   *\n   * @example\n   * const res = ketting.go('https://example.org/);\n   * @example\n   * const res = ketting.go<Author>('/users/1');\n   * @example\n   * const res = ketting.go(); // bookmark\n   */\n  go<TResource = any>(uri?: string): Resource<TResource> {\n\n    let absoluteUri;\n    if (uri !== undefined) {\n      absoluteUri = resolve(this.bookmarkUri, uri);\n    } else {\n      absoluteUri = this.bookmarkUri;\n    }\n    if (!this.resources.has(absoluteUri)) {\n      const resource = new Resource(this, absoluteUri);\n      this.resources.set(absoluteUri, resource);\n      return resource;\n    }\n    return this.resources.get(absoluteUri)!;\n\n  }\n\n  /**\n   * Adds a fetch middleware, which will be executed for\n   * each fetch() call.\n   *\n   * If 'origin' is specified, fetch middlewares can be executed\n   * only if the host/origin matches.\n   */\n  use(middleware: FetchMiddleware, origin: string = '*') {\n\n    this.fetcher.use(middleware, origin);\n\n  }\n\n  /**\n   * Clears the entire state cache\n   */\n  clearCache() {\n\n    this.cache.clear();\n\n  }\n\n  /**\n   * Transforms a fetch Response to a State object.\n   */\n  async getStateForResponse(uri: string, response: Response): Promise<State> {\n\n    const contentType = parseContentType(response.headers.get('Content-Type')!);\n\n    let state: State;\n\n    if (!contentType) {\n      return binaryStateFactory(uri, response);\n    }\n\n    if (contentType in this.contentTypeMap) {\n      state = await this.contentTypeMap[contentType][0](uri, response);\n    } else if (contentType.startsWith('text/')) {\n      // Default to TextState for any format starting with text/\n      state = await textStateFactory(uri, response);\n    } else if (contentType.match(/^application\\/[A-Za-z-.]+\\+json/)) {\n      // Default to HalState for any format containing a pattern like application/*+json\n      state = await halStateFactory(uri, response);\n    } else {\n      state = await binaryStateFactory(uri, response);\n    }\n\n    state.client = this;\n    return state;\n\n  }\n\n  /**\n   * Caches a State object\n   *\n   * This function will also emit 'update' events to resources, and store all\n   * embedded states.\n   */\n  cacheState(state: State) {\n\n    this.cache.store(state);\n    const resource = this.resources.get(state.uri);\n    if (resource) {\n      // We have a resource for this object, notify it as well.\n      resource.emit('update', state);\n    }\n\n    for(const embeddedState of state.getEmbedded()) {\n      // Recursion. MADNESS\n      this.cacheState(embeddedState);\n    }\n\n  }\n\n  private acceptHeader: FetchMiddleware = (request, next) => {\n\n    if (!request.headers.has('Accept')) {\n      const acceptHeader = Object.entries(this.contentTypeMap).map(\n        ([contentType, [stateFactory, q]]) => contentType + ';q=' + q\n      ).join(', ');\n      request.headers.set('Accept', acceptHeader);\n    }\n    return next(request);\n\n  };\n\n  private cacheExpireHandler: FetchMiddleware = async(request, next) => {\n\n    /**\n     * Prevent a 'stale' event from being emitted, but only for the main\n     * uri\n     */\n    let noStaleEvent = false;\n\n    if (request.headers.has('X-KETTING-NO-STALE')) {\n      noStaleEvent = true;\n      request.headers.delete('X-KETTING-NO-STALE');\n    }\n\n    const response = await next(request);\n    if (isSafeMethod(request.method)) {\n      return response;\n    }\n\n    if (!response.ok) {\n      // There was an error, no cache changes\n      return response;\n    }\n\n    // We just processed an unsafe method, lets notify all subsystems.\n    const expireUris = [];\n    if (!noStaleEvent && request.method !== 'DELETE') {\n      // Sorry for the double negative\n      expireUris.push(request.url);\n    }\n\n    // If the response had a Link: rel=invalidate header, we want to\n    // expire those too.\n    if (response.headers.has('Link')) {\n      for (const httpLink of LinkHeader.parse(response.headers.get('Link')!).rel('invalidates')) {\n        const uri = resolve(request.url, httpLink.uri);\n        expireUris.push(uri);\n      }\n    }\n\n    // Location headers should also expire\n    if (response.headers.has('Location')) {\n      expireUris.push(\n        resolve(request.url, response.headers.get('Location')!)\n      );\n    }\n    // Content-Location headers should also expire\n    if (response.headers.has('Content-Location')) {\n      expireUris.push(\n        resolve(request.url, response.headers.get('Content-Location')!)\n      );\n    }\n\n    for (const uri of expireUris) {\n      this.cache.delete(request.url);\n\n      const resource = this.resources.get(uri);\n      if (resource) {\n        // We have a resource for this object, notify it as well.\n        resource.emit('stale');\n      }\n    }\n    if (request.method === 'DELETE') {\n      this.cache.delete(request.url);\n      const resource = this.resources.get(request.url);\n      if (resource) {\n        resource.emit('delete');\n      }\n    }\n\n    return response;\n\n  };\n\n}\n","import problemFactory from './error';\nimport './fetch-polyfill';\n\nexport type FetchMiddleware =\n  (request: Request, next: (request: Request) => Promise<Response>) => Promise<Response>;\n\n/**\n * The fetcher object is responsible for calling fetch()\n *\n * This is wrapped in an object because we want to support\n * 'fetch middlewares'. These middlewares are similar to server-side\n * middlewares and can intercept requests and alter requests/responses.\n */\nexport class Fetcher {\n\n  middlewares: [RegExp, FetchMiddleware][] = [];\n\n  advertiseKetting: boolean = true\n\n  /**\n   * A wrapper for MDN fetch()\n   *\n   * This wrapper supports 'fetch middlewares'. It will call them\n   * in sequence.\n   */\n  fetch(resource: string|Request, init?: RequestInit): Promise<Response> {\n\n    const request = new Request(resource, init);\n\n    const origin = new URL(request.url).origin;\n    const mws = this.getMiddlewaresByOrigin(origin);\n    mws.push((innerRequest: Request) => {\n\n      if (!innerRequest.headers.has('User-Agent') && this.advertiseKetting) {\n        // eslint-disable-next-line @typescript-eslint/no-var-requires\n        innerRequest.headers.set('User-Agent', 'Ketting/' + require('../../package.json').version);\n      }\n\n      return fetch(innerRequest);\n    }\n    );\n\n    return invokeMiddlewares(mws, request);\n\n  }\n\n  /**\n   * Returns the list of middlewares that are applicable to\n   * a specific origin\n   */\n  getMiddlewaresByOrigin(origin: string): FetchMiddleware[] {\n\n    return this.middlewares.filter( ([regex, middleware]) => {\n      return regex.test(origin);\n\n    }).map( ([regex, middleware]) => {\n      return middleware;\n    });\n\n  }\n\n  /**\n   * Add a middleware\n   */\n  use(mw: FetchMiddleware, origin: string = '*'): void {\n\n    const matchSplit = origin.split('*');\n    const matchRegex = matchSplit.map(\n      part =>\n        part.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n    ).join('(.*)');\n\n    const regex = new RegExp('^' + matchRegex + '$');\n    this.middlewares.push([regex, mw]);\n\n  }\n\n  /**\n   * Does a HTTP request and throws an exception if the server emitted\n   * a HTTP error.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/Request\n   */\n  async fetchOrThrow(resource: string|Request, init?: RequestInit): Promise<Response> {\n\n    const response = await this.fetch(resource, init);\n\n    if (response.ok) {\n      return response;\n    } else {\n      throw await problemFactory(response);\n    }\n\n  }\n\n}\nexport default Fetcher;\n\nfunction invokeMiddlewares(mws: FetchMiddleware[], request: Request): Promise<Response> {\n\n  return mws[0](\n    request,\n    (nextRequest: Request) => {\n      return invokeMiddlewares(mws.slice(1), nextRequest);\n    }\n  );\n\n}\n","import {Action} from '../action';\nimport { Links } from '../link';\nimport Client from '../client';\n\nexport interface State<T = any> {\n\n  /**\n   * The URI associated with this state\n   */\n  uri: string;\n\n  /**\n   * Represents the body of the HTTP response.\n   *\n   * In the case of a JSON response, this will be deserialized\n   */\n  data: T\n\n  /**\n   * All links associated with the resource.\n   */\n  links: Links,\n\n  /**\n   * The full list of HTTP headers that were sent with the response.\n   */\n  headers: Headers;\n\n  /**\n   * Reference to main client that created this state\n   */\n  client: Client;\n\n  /**\n   * Return an action by name.\n   *\n   * If the format provides a default action, the name may be omitted.\n   */\n  action<TFormData = any>(name?: string): Action<TFormData>;\n\n  /**\n   * Returns all actions\n   */\n  actions(): Action[];\n\n  /**\n   * Checks if the specified action exists.\n   *\n   * If no name is given, checks if _any_ action exists.\n   */\n  hasAction(name?: string): boolean;\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  serializeBody(): Buffer|Blob|string;\n\n  /**\n   * Content-headers are a subset of HTTP headers that related directly\n   * to the content. The obvious ones are Content-Type.\n   *\n   * This set of headers will be sent by the server along with a GET\n   * response, but will also be sent back to the server in a PUT\n   * request.\n   */\n  contentHeaders(): Headers;\n\n  /**\n   * Certain formats can embed other resources, identified by their\n   * own URI.\n   *\n   * When a format has embedded resources, we will use these to warm\n   * the cache.\n   *\n   * This method returns every embedded resource.\n   */\n  getEmbedded(): State[];\n\n  /**\n   * Timestamp of when the State was first generated\n   */\n  timestamp: number;\n\n  clone(): State<T>;\n\n}\n\n/**\n * HeadState represents the response to a HEAD request.\n *\n * Some information in HEAD responses might be available, but many aren't.\n * Notably, the body.\n */\nexport interface HeadState {\n\n  /**\n   * The URI associated with this state\n   */\n  uri: string;\n\n  /**\n   * All links associated with the resource.\n   */\n  links: Links,\n\n  /**\n   * The full list of HTTP headers that were sent with the response.\n   */\n  headers: Headers;\n\n  /**\n   * Content-headers are a subset of HTTP headers that related directly\n   * to the content. The obvious ones are Content-Type.\n   *\n   * This set of headers will be sent by the server along with a GET\n   * response, but will also be sent back to the server in a PUT\n   * request.\n   */\n  contentHeaders(): Headers;\n\n  /**\n   * Timestamp of when the State was first generated\n   */\n  timestamp: number;\n\n}\n\n/**\n * A 'StateFactory' is responsible for taking a Fetch Response, and returning\n * an object that impements the State interface\n */\nexport type StateFactory<T = any> = (uri: string, request: Response) => Promise<State<T>>;\n\nexport function isState(input: Record<string, any>): input is State {\n\n  return (\n    typeof (input as any).uri === 'string' &&\n    (input as any).links instanceof Links &&\n    (input as any).headers instanceof Headers\n  );\n\n}\n","import { State } from './state';\nimport * as qs from 'querystring';\nimport Client from './client';\nimport { Field } from './field';\n\nexport interface ActionInfo {\n\n  /**\n   * What url to post the form to.\n   */\n  uri: string;\n\n  /**\n   * Action name.\n   *\n   * Some formats call this the 'rel'\n   */\n  name: string | null;\n\n  /**\n   * Form title.\n   *\n   * Should be human-friendly.\n   */\n  title?: string;\n\n  /**\n   * The HTTP method to use\n   */\n  method: string;\n\n  /**\n   * The contentType to use for the form submission\n   */\n  contentType: string;\n\n  /**\n   * Returns the list of fields associated to an action\n   */\n  fields: Field[]\n\n}\n\n/**\n * An action represents a hypermedia form submission or action.\n */\nexport interface Action<T extends Record<string, any> = Record<string, any>> extends ActionInfo {\n\n  /**\n   * Execute the action or submit the form.\n   */\n  submit(formData: T): Promise<State>;\n\n}\n\nexport class SimpleAction<TFormData> implements Action {\n\n  /**\n   * What url to post the form to.\n   */\n  uri!: string;\n\n  /**\n   * Action name.\n   *\n   * Some formats call this the 'rel'\n   */\n  name!: string | null;\n\n  /**\n   * Form title.\n   *\n   * Should be human-friendly.\n   */\n  title!: string;\n\n  /**\n   * The HTTP method to use\n   */\n  method!: string;\n\n  /**\n   * The contentType to use for the form submission\n   */\n  contentType!: string;\n\n  /**\n   * Returns the list of fields associated to an action\n   */\n  fields!: Field[]\n\n  /**\n   * Reference to client\n   */\n  client: Client;\n\n  constructor(client: Client, formInfo: ActionInfo) {\n    this.client = client;\n\n    for(const [k, v] of Object.entries(formInfo)) {\n      this[k as keyof ActionInfo] = v;\n    }\n\n  }\n\n  /**\n   * Execute the action or submit the form.\n   */\n  async submit(formData: TFormData): Promise<State<any>> {\n\n    const uri = new URL(this.uri);\n\n    if (this.method === 'GET') {\n      uri.search = qs.stringify(formData);\n      const resource = this.client.go(uri.toString());\n      return resource.get();\n    }\n    let body;\n    switch (this.contentType) {\n      case 'application/x-www-form-urlencoded' :\n        body = qs.stringify(formData);\n        break;\n      case 'application/json':\n        body = JSON.stringify(formData);\n        break;\n      default :\n        throw new Error(`Serializing mimetype ${this.contentType} is not yet supported in actions`);\n    }\n    const response = await this.client.fetcher.fetchOrThrow(uri.toString(), {\n      method: this.method,\n      body,\n      headers: {\n        'Content-Type': this.contentType\n      }\n    });\n    const state = this.client.getStateForResponse(uri.toString(), response);\n    return state;\n\n  }\n}\n\nexport class ActionNotFound extends Error {}\n","// Query String Utilities\n\n'use strict';\n\nvar QueryString = exports;\nvar Buffer = require('buffer').Buffer;\n\n\n// a safe fast alternative to decodeURIComponent\nQueryString.unescapeBuffer = function(s, decodeSpaces) {\n  var out = new Buffer(s.length);\n  var state = 0;\n  var n, m, hexchar;\n\n  for (var inIndex = 0, outIndex = 0; inIndex <= s.length; inIndex++) {\n    var c = inIndex < s.length ? s.charCodeAt(inIndex) : NaN;\n    switch (state) {\n      case 0: // Any character\n        switch (c) {\n          case 37: // '%'\n            n = 0;\n            m = 0;\n            state = 1;\n            break;\n          case 43: // '+'\n            if (decodeSpaces)\n              c = 32; // ' '\n            // falls through\n          default:\n            out[outIndex++] = c;\n            break;\n        }\n        break;\n\n      case 1: // First hex digit\n        hexchar = c;\n        if (c >= 48/*0*/ && c <= 57/*9*/) {\n          n = c - 48/*0*/;\n        } else if (c >= 65/*A*/ && c <= 70/*F*/) {\n          n = c - 65/*A*/ + 10;\n        } else if (c >= 97/*a*/ && c <= 102/*f*/) {\n          n = c - 97/*a*/ + 10;\n        } else {\n          out[outIndex++] = 37/*%*/;\n          out[outIndex++] = c;\n          state = 0;\n          break;\n        }\n        state = 2;\n        break;\n\n      case 2: // Second hex digit\n        state = 0;\n        if (c >= 48/*0*/ && c <= 57/*9*/) {\n          m = c -  48/*0*/;\n        } else if (c >= 65/*A*/ && c <= 70/*F*/) {\n          m = c - 65/*A*/ + 10;\n        } else if (c >= 97/*a*/ && c <= 102/*f*/) {\n          m = c - 97/*a*/ + 10;\n        } else {\n          out[outIndex++] = 37/*%*/;\n          out[outIndex++] = hexchar;\n          out[outIndex++] = c;\n          break;\n        }\n        out[outIndex++] = 16 * n + m;\n        break;\n    }\n  }\n\n  // TODO support returning arbitrary buffers.\n\n  return out.slice(0, outIndex - 1);\n};\n\n\nfunction qsUnescape(s, decodeSpaces) {\n  try {\n    return decodeURIComponent(s);\n  } catch (e) {\n    return QueryString.unescapeBuffer(s, decodeSpaces).toString();\n  }\n}\nQueryString.unescape = qsUnescape;\n\n\nvar hexTable = new Array(256);\nfor (var i = 0; i < 256; ++i)\n  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();\nQueryString.escape = function(str) {\n  // replaces encodeURIComponent\n  // http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3.4\n  if (typeof str !== 'string')\n    str += '';\n  var out = '';\n  var lastPos = 0;\n\n  for (var i = 0; i < str.length; ++i) {\n    var c = str.charCodeAt(i);\n\n    // These characters do not need escaping (in order):\n    // ! - . _ ~\n    // ' ( ) *\n    // digits\n    // alpha (uppercase)\n    // alpha (lowercase)\n    if (c === 0x21 || c === 0x2D || c === 0x2E || c === 0x5F || c === 0x7E ||\n        (c >= 0x27 && c <= 0x2A) ||\n        (c >= 0x30 && c <= 0x39) ||\n        (c >= 0x41 && c <= 0x5A) ||\n        (c >= 0x61 && c <= 0x7A)) {\n      continue;\n    }\n\n    if (i - lastPos > 0)\n      out += str.slice(lastPos, i);\n\n    // Other ASCII characters\n    if (c < 0x80) {\n      lastPos = i + 1;\n      out += hexTable[c];\n      continue;\n    }\n\n    // Multi-byte characters ...\n    if (c < 0x800) {\n      lastPos = i + 1;\n      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    if (c < 0xD800 || c >= 0xE000) {\n      lastPos = i + 1;\n      out += hexTable[0xE0 | (c >> 12)] +\n             hexTable[0x80 | ((c >> 6) & 0x3F)] +\n             hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    // Surrogate pair\n    ++i;\n    var c2;\n    if (i < str.length)\n      c2 = str.charCodeAt(i) & 0x3FF;\n    else\n      throw new URIError('URI malformed');\n    lastPos = i + 1;\n    c = 0x10000 + (((c & 0x3FF) << 10) | c2);\n    out += hexTable[0xF0 | (c >> 18)] +\n           hexTable[0x80 | ((c >> 12) & 0x3F)] +\n           hexTable[0x80 | ((c >> 6) & 0x3F)] +\n           hexTable[0x80 | (c & 0x3F)];\n  }\n  if (lastPos === 0)\n    return str;\n  if (lastPos < str.length)\n    return out + str.slice(lastPos);\n  return out;\n};\n\nvar stringifyPrimitive = function(v) {\n  if (typeof v === 'string')\n    return v;\n  if (typeof v === 'number' && isFinite(v))\n    return '' + v;\n  if (typeof v === 'boolean')\n    return v ? 'true' : 'false';\n  return '';\n};\n\n\nQueryString.stringify = QueryString.encode = function(obj, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n\n  var encode = QueryString.escape;\n  if (options && typeof options.encodeURIComponent === 'function') {\n    encode = options.encodeURIComponent;\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    var keys = Object.keys(obj);\n    var len = keys.length;\n    var flast = len - 1;\n    var fields = '';\n    for (var i = 0; i < len; ++i) {\n      var k = keys[i];\n      var v = obj[k];\n      var ks = encode(stringifyPrimitive(k)) + eq;\n\n      if (Array.isArray(v)) {\n        var vlen = v.length;\n        var vlast = vlen - 1;\n        for (var j = 0; j < vlen; ++j) {\n          fields += ks + encode(stringifyPrimitive(v[j]));\n          if (j < vlast)\n            fields += sep;\n        }\n        if (vlen && i < flast)\n          fields += sep;\n      } else {\n        fields += ks + encode(stringifyPrimitive(v));\n        if (i < flast)\n          fields += sep;\n      }\n    }\n    return fields;\n  }\n  return '';\n};\n\n// Parse a key/val string.\nQueryString.parse = QueryString.decode = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  if (typeof sep !== 'string')\n    sep += '';\n\n  var eqLen = eq.length;\n  var sepLen = sep.length;\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var pairs = Infinity;\n  if (maxKeys > 0)\n    pairs = maxKeys;\n\n  var decode = QueryString.unescape;\n  if (options && typeof options.decodeURIComponent === 'function') {\n    decode = options.decodeURIComponent;\n  }\n  var customDecode = (decode !== qsUnescape);\n\n  var keys = [];\n  var lastPos = 0;\n  var sepIdx = 0;\n  var eqIdx = 0;\n  var key = '';\n  var value = '';\n  var keyEncoded = customDecode;\n  var valEncoded = customDecode;\n  var encodeCheck = 0;\n  for (var i = 0; i < qs.length; ++i) {\n    var code = qs.charCodeAt(i);\n\n    // Try matching key/value pair separator (e.g. '&')\n    if (code === sep.charCodeAt(sepIdx)) {\n      if (++sepIdx === sepLen) {\n        // Key/value pair separator match!\n        var end = i - sepIdx + 1;\n        if (eqIdx < eqLen) {\n          // If we didn't find the key/value separator, treat the substring as\n          // part of the key instead of the value\n          if (lastPos < end)\n            key += qs.slice(lastPos, end);\n        } else if (lastPos < end)\n          value += qs.slice(lastPos, end);\n        if (keyEncoded)\n          key = decodeStr(key, decode);\n        if (valEncoded)\n          value = decodeStr(value, decode);\n        // Use a key array lookup instead of using hasOwnProperty(), which is\n        // slower\n        if (keys.indexOf(key) === -1) {\n          obj[key] = value;\n          keys[keys.length] = key;\n        } else {\n          var curValue = obj[key];\n          // `instanceof Array` is used instead of Array.isArray() because it\n          // is ~15-20% faster with v8 4.7 and is safe to use because we are\n          // using it with values being created within this function\n          if (curValue instanceof Array)\n            curValue[curValue.length] = value;\n          else\n            obj[key] = [curValue, value];\n        }\n        if (--pairs === 0)\n          break;\n        keyEncoded = valEncoded = customDecode;\n        encodeCheck = 0;\n        key = value = '';\n        lastPos = i + 1;\n        sepIdx = eqIdx = 0;\n      }\n      continue;\n    } else {\n      sepIdx = 0;\n      if (!valEncoded) {\n        // Try to match an (valid) encoded byte (once) to minimize unnecessary\n        // calls to string decoding functions\n        if (code === 37/*%*/) {\n          encodeCheck = 1;\n        } else if (encodeCheck > 0 &&\n                   ((code >= 48/*0*/ && code <= 57/*9*/) ||\n                    (code >= 65/*A*/ && code <= 70/*Z*/) ||\n                    (code >= 97/*a*/ && code <= 102/*z*/))) {\n          if (++encodeCheck === 3)\n            valEncoded = true;\n        } else {\n          encodeCheck = 0;\n        }\n      }\n    }\n\n    // Try matching key/value separator (e.g. '=') if we haven't already\n    if (eqIdx < eqLen) {\n      if (code === eq.charCodeAt(eqIdx)) {\n        if (++eqIdx === eqLen) {\n          // Key/value separator match!\n          var end = i - eqIdx + 1;\n          if (lastPos < end)\n            key += qs.slice(lastPos, end);\n          encodeCheck = 0;\n          lastPos = i + 1;\n        }\n        continue;\n      } else {\n        eqIdx = 0;\n        if (!keyEncoded) {\n          // Try to match an (valid) encoded byte once to minimize unnecessary\n          // calls to string decoding functions\n          if (code === 37/*%*/) {\n            encodeCheck = 1;\n          } else if (encodeCheck > 0 &&\n                     ((code >= 48/*0*/ && code <= 57/*9*/) ||\n                      (code >= 65/*A*/ && code <= 70/*Z*/) ||\n                      (code >= 97/*a*/ && code <= 102/*z*/))) {\n            if (++encodeCheck === 3)\n              keyEncoded = true;\n          } else {\n            encodeCheck = 0;\n          }\n        }\n      }\n    }\n\n    if (code === 43/*+*/) {\n      if (eqIdx < eqLen) {\n        if (i - lastPos > 0)\n          key += qs.slice(lastPos, i);\n        key += '%20';\n        keyEncoded = true;\n      } else {\n        if (i - lastPos > 0)\n          value += qs.slice(lastPos, i);\n        value += '%20';\n        valEncoded = true;\n      }\n      lastPos = i + 1;\n    }\n  }\n\n  // Check if we have leftover key or value data\n  if (pairs > 0 && (lastPos < qs.length || eqIdx > 0)) {\n    if (lastPos < qs.length) {\n      if (eqIdx < eqLen)\n        key += qs.slice(lastPos);\n      else if (sepIdx < sepLen)\n        value += qs.slice(lastPos);\n    }\n    if (keyEncoded)\n      key = decodeStr(key, decode);\n    if (valEncoded)\n      value = decodeStr(value, decode);\n    // Use a key array lookup instead of using hasOwnProperty(), which is\n    // slower\n    if (keys.indexOf(key) === -1) {\n      obj[key] = value;\n      keys[keys.length] = key;\n    } else {\n      var curValue = obj[key];\n      // `instanceof Array` is used instead of Array.isArray() because it\n      // is ~15-20% faster with v8 4.7 and is safe to use because we are\n      // using it with values being created within this function\n      if (curValue instanceof Array)\n        curValue[curValue.length] = value;\n      else\n        obj[key] = [curValue, value];\n    }\n  }\n\n  return obj;\n};\n\n\n// v8 does not optimize functions with try-catch blocks, so we isolate them here\n// to minimize the damage\nfunction decodeStr(s, decoder) {\n  try {\n    return decoder(s);\n  } catch (e) {\n    return QueryString.unescape(s, true);\n  }\n}","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","import { BaseState } from './base-state';\nimport { HalResource, HalLink, HalFormsTemplate, HalFormsProperty } from 'hal-types';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\nimport { resolve } from '../util/uri';\nimport { ActionInfo } from '../action';\nimport { Field } from '../field';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class HalState<T = any> extends BaseState<T> {\n\n  serializeBody(): string {\n\n    return JSON.stringify({\n      _links: this.serializeLinks(),\n      ...this.data\n    });\n\n  }\n\n  private serializeLinks(): HalResource['_links'] {\n\n    const links: HalResource['_links'] = {\n      self: { href: this.uri },\n    };\n    for(const link of this.links.getAll()) {\n\n      const { rel, context, ...attributes } = link;\n\n      if (rel === 'self') {\n        // skip\n        continue;\n      }\n\n      if (links[rel] === undefined) {\n        // First link of its kind\n        links[rel] =  attributes;\n      } else if (Array.isArray(links[rel])) {\n        // Add link to link array.\n        (links[rel] as HalLink[]).push(attributes);\n      } else {\n        // 1 link with this rel existed, so we will transform it to an array.\n        links[rel] = [links[rel] as HalLink, attributes];\n      }\n\n    }\n\n    return links;\n\n  }\n\n  clone(): HalState {\n\n    return new HalState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links),\n      [],\n      this.actionInfo,\n    );\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a HalState\n */\nexport const factory = async (uri: string, response: Response): Promise<HalState> => {\n\n  const body = await response.json();\n  const links = parseLink(uri, response.headers.get('Link'));\n\n  // The HAL factory is also respondible for plain JSON, which might be an\n  // array.\n  if (Array.isArray(body)) {\n    return new HalState(\n      uri,\n      body,\n      response.headers,\n      links,\n      [],\n    );\n  }\n\n  links.add(...parseHalLinks(uri, body));\n\n  // Remove _links and _embedded from body\n  const {\n    _embedded,\n    _links,\n    _templates,\n    ...newBody\n  } = body;\n\n  const halForm: HalFormsTemplate|undefined = body._templates?.default;\n\n  return new HalState(\n    uri,\n    newBody,\n    response.headers,\n    links,\n    parseHalEmbedded(uri, body, response.headers),\n    halForm ? [parseHalForm(uri, halForm)] : [],\n  );\n\n};\n\n/**\n * Parse the Hal _links object and populate the 'links' property.\n */\nfunction parseHalLinks(context: string, body: HalResource): Link[] {\n\n  if (body._links === undefined) {\n    return [];\n  }\n\n  const result: Link[] = [];\n\n  /**\n   * We're capturing all rel-link pairs so we don't duplicate them if they\n   * re-appear in _embedded.\n   *\n   * Links that are embedded _should_ appear in both lists, but not everyone\n   * does this.\n   */\n  const foundLinks = new Set();\n\n  for (const [relType, links] of Object.entries(body._links)) {\n\n    const linkList = Array.isArray(links) ? links : [links];\n\n    for (const link of linkList) {\n      foundLinks.add(relType + ';' + link.href);\n    }\n\n    result.push(\n      ...parseHalLink(context, relType, linkList)\n    );\n\n\n  }\n\n  if (body._embedded) {\n    // eslint-disable-next-line prefer-const\n    for (let [rel, innerBodies] of Object.entries(body._embedded)) {\n\n      if (!Array.isArray(innerBodies)) {\n        innerBodies = [innerBodies];\n      }\n\n      for(const innerBody of innerBodies) {\n\n        const href:string = innerBody?._links?.self?.href;\n        if (!href) {\n          continue;\n        }\n\n        if (foundLinks.has(rel + ';' + href)) {\n          continue;\n        }\n        result.push({\n          rel: rel,\n          href: href,\n          context: context,\n        });\n\n      }\n\n    }\n\n  }\n\n  return result;\n\n}\n\n/**\n * Parses a single HAL link from a _links object\n */\nfunction parseHalLink(context: string, rel: string, links: HalLink[]): Link[] {\n\n  const result: Link[] = [];\n\n  for (const link of links) {\n    result.push({\n      rel,\n      context,\n      ...link,\n    });\n  }\n\n  return result;\n\n}\n\n/**\n * Parse the HAL _embedded object. Right now we're just grabbing the\n * information from _embedded and turn it into links.\n */\nfunction parseHalEmbedded(context: string, body: HalResource, headers: Headers): HalState<any>[] {\n\n  if (body._embedded === undefined) {\n    return [];\n  }\n\n  const result: HalState<any>[] = [];\n\n  for (const embedded of Object.values(body._embedded)) {\n\n    let embeddedList: HalResource[];\n\n    if (!Array.isArray(embedded)) {\n      embeddedList = [embedded];\n    } else {\n      embeddedList = embedded;\n\n    }\n    for (const embeddedItem of embeddedList) {\n\n      if (embeddedItem._links === undefined || embeddedItem._links.self === undefined || Array.isArray(embeddedItem._links.self)) {\n        // Skip any embedded without a self link.\n        continue;\n      }\n      // Remove _links and _embedded from body\n      const {\n        _embedded,\n        _links,\n        ...newBody\n      } = embeddedItem;\n\n      result.push(new HalState(\n        resolve(context, embeddedItem._links.self.href),\n        newBody,\n        new Headers({\n          'Content-Type': headers.get('Content-Type')!,\n        }),\n        new Links(context, parseHalLinks(context, embeddedItem)),\n        // Parsing nested embedded items. Note that we assume that the base url is relative to\n        // the outermost parent, not relative to the embedded item. HAL is not clear on this.\n        parseHalEmbedded(context, embeddedItem, headers),\n      ));\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseHalForm(context: string, templ: HalFormsTemplate): ActionInfo {\n\n  return {\n    uri: context,\n    name: 'default',\n    title: templ.title,\n    method: templ.method,\n    contentType: templ.contentType || 'application/json',\n    fields: templ.properties ? templ.properties.map(prop => parseHalField(prop)) : [],\n  };\n\n}\n\nfunction parseHalField(halField: HalFormsProperty): Field {\n\n  return {\n    name: halField.name,\n    type: 'text',\n    required: halField.required || false,\n    readOnly: halField.readOnly || false,\n    value: halField.value,\n    pattern: halField.regex ? new RegExp(halField.regex) : undefined,\n    label: halField.prompt,\n  };\n\n}\n","import { BaseState } from './base-state';\nimport { StateFactory } from './interface';\nimport { parseLink } from '../http/util';\nimport { Links } from '../link';\n\n/**\n * Represents a binary resource state.\n *\n * This is used for responses like images, video, etc.\n */\nexport class BinaryState extends BaseState<Blob> {\n\n  serializeBody(): Blob {\n\n    return this.data;\n\n  }\n\n  clone(): BinaryState {\n\n    return new BinaryState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links)\n    );\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a BinaryState\n */\nexport const factory: StateFactory<Blob> = async (uri: string, response: Response): Promise<BinaryState> => {\n\n  return new BinaryState(\n    uri,\n    await response.blob(),\n    response.headers,\n    parseLink(uri, response.headers.get('Link')),\n  );\n\n};\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class JsonApiState<T = any> extends BaseState<T> {\n\n  serializeBody(): string {\n\n    return JSON.stringify(this.data);\n\n  }\n\n  clone(): JsonApiState<T> {\n\n    return new JsonApiState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links)\n    );\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a JsonApiState\n */\nexport const factory = async (uri: string, response: Response): Promise<JsonApiState<JsonApiTopLevelObject>> => {\n\n  const body = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(\n    ...parseJsonApiLinks(uri, body),\n    ...parseJsonApiCollection(uri, body),\n  );\n\n  return new JsonApiState(\n    uri,\n    body,\n    response.headers,\n    links,\n  );\n\n};\n/**\n * A JSON:API link can either be a string, or an object with at least a href\n * property.\n */\ntype JsonApiLink = string | { href: string };\n\n/**\n * This type is a full 'links' object, which might appear on the top level\n * or on resource objects.\n */\ntype JsonApiLinksObject = {\n  self?: JsonApiLink,\n  profile?: JsonApiLink,\n  [rel: string]: JsonApiLink | JsonApiLink[] | undefined\n};\n\n/**\n * This is a single JSON:API resource. Its type contains just the properties\n * we care about.\n */\ntype JsonApiResource = {\n  type: string,\n  id: string,\n  links?: JsonApiLinksObject,\n};\n\n\n/**\n * This type represents a valid JSON:API response. We're only interested\n * in the links object at the moment, so everything else is (for now)\n * untyped.\n */\ntype JsonApiTopLevelObject = {\n  links?: JsonApiLinksObject,\n  data: JsonApiResource | JsonApiResource[] | null,\n  [s: string]: any\n};\n\n/**\n * This function takes a JSON:API object, and extracts the links property.\n */\nfunction parseJsonApiLinks(contextUri: string, body: JsonApiTopLevelObject): Link[] {\n\n  const result: Link[] = [];\n\n  if (body.links === undefined) {\n    return result;\n  }\n\n  for (const [rel, linkValue] of Object.entries(body.links)) {\n\n    if (Array.isArray(linkValue)) {\n      result.push(...linkValue.map( link => parseJsonApiLink(contextUri, rel, link)));\n    } else {\n      result.push(parseJsonApiLink(contextUri, rel, linkValue!));\n    }\n\n  }\n\n  return result;\n\n}\n\n/**\n * Find collection members in JSON:API objects.\n *\n * A JSON:API top-level object might represent a collection that has 0 or more\n * members.\n *\n * Members of this collection should appear as an 'item' link to the parent.\n */\nfunction parseJsonApiCollection(contextUri: string, body: JsonApiTopLevelObject): Link[] {\n\n  if (!Array.isArray(body.data)) {\n    // Not a collection\n    return [];\n  }\n\n  const result: Link[] = [];\n  for (const member of body.data) {\n\n    if ('links' in member && 'self' in member.links!) {\n\n      const selfLink = parseJsonApiLink(contextUri, 'self', member.links!.self!);\n      result.push({\n        context: contextUri,\n        href: selfLink.href,\n        rel: 'item'\n      });\n\n    }\n  }\n\n  return result;\n\n}\n\n/**\n * This function takes a single link value from a JSON:API link object, and\n * returns a object of type Link\n */\nfunction parseJsonApiLink(contextUri: string, rel: string, link: JsonApiLink): Link {\n\n  return ({\n    context: contextUri,\n    rel,\n    href: typeof link === 'string' ? link : link.href,\n  });\n\n}\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\nimport { resolve } from '../util/uri';\nimport { ActionInfo } from '../action';\nimport { Field } from '../field';\n\n/**\n * Represents a resource state in the Siren format\n */\nexport class SirenState<T> extends BaseState<T> {\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  serializeBody(): string {\n\n    throw new Error('Reserializing Siren states is not yet supported. Please log an issue in the Ketting project to help figure out how this should be done');\n\n  }\n\n  clone(): SirenState<T> {\n\n    return new SirenState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links),\n      [],\n      this.actionInfo,\n    );\n\n  }\n\n}\n\n\n/**\n * Turns a HTTP response into a SirenState\n */\nexport const factory = async (uri: string, response: Response): Promise<SirenState<any>> => {\n\n  const body:SirenEntity<any> = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(...parseSirenLinks(uri, body));\n\n  return new SirenState(\n    uri,\n    body.properties,\n    response.headers,\n    links,\n    parseSirenEmbedded(uri, body, response.headers),\n    body.actions ? body.actions.map( action => parseSirenAction(uri, action) ) : [],\n  );\n\n};\n\ntype SirenProperties = Record<string, any> | undefined;\n\ntype SirenEntity<T extends SirenProperties> = {\n\n  class?: string[],\n\n  properties: T\n  entities?: (SirenLink | SirenSubEntity)[],\n\n  links?: SirenLink[],\n  actions?: SirenAction[],\n  title?: string,\n\n};\n\ntype SirenSubEntity = SirenEntity<any> & { rel: string[] };\n\ntype SirenLink = {\n\n  class?: string[],\n  rel: string[],\n  href: string,\n  type?: string,\n  title?: string,\n\n};\n\ntype SirenAction = {\n  name: string,\n  class?: string[],\n  method?: string,\n  href: string,\n  title?: string,\n  type?: string,\n  fields?: SirenField[],\n};\n\ntype SirenField = {\n  name: string,\n  class?: string[],\n  type?: 'hidden' | 'text' | 'search' | 'tel' | 'url' | 'email' | 'password' | 'datetime' | 'date' | 'month' | 'week' | 'time' | 'datetime-local' | 'number' | 'range' | 'color' | 'checkbox' | 'radio' | 'file'\n  value?: string,\n  title?: string\n};\n\nfunction parseSirenLinks(contextUri: string, body: SirenEntity<any>): Link[] {\n\n  const result: Link[] = [];\n\n  if (body.links !== undefined) {\n    for (const link of body.links) {\n      result.push(...parseSirenLink(contextUri, link));\n    }\n  }\n\n  if (body.entities !== undefined) {\n    for (const subEntity of body.entities) {\n      if ((subEntity as SirenLink).href !== undefined) {\n        result.push(...parseSirenLink(contextUri, subEntity as SirenLink));\n      } else {\n        result.push(...parseSirenSubEntityAsLink(contextUri, subEntity as SirenSubEntity));\n      }\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseSirenLink(contextUri: string, link: SirenLink): Link[] {\n\n  const result: Link[] = [];\n\n  const {\n    rel: rels,\n    ...attributes\n  } = link;\n  for (const rel of rels) {\n\n    const newLink: Link = {\n      rel,\n      context: contextUri,\n      ...attributes,\n    };\n    result.push(newLink);\n\n  }\n\n  return result;\n\n}\n\nfunction parseSirenEmbedded(contextUri: string, body: SirenEntity<any>, headers: Headers): SirenState<SirenEntity<any>>[] {\n\n  if (body.entities === undefined) {\n    return [];\n  }\n\n  const result: SirenState<SirenEntity<any>>[] = [];\n\n  for (const entity of body.entities) {\n    if (isSubEntity(entity)) {\n      const subState = parseSirenSubEntityAsEmbedded(contextUri, entity, headers);\n      if (subState !== null) {\n        result.push(subState);\n      }\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseSirenSubEntityAsLink(contextUri: string, subEntity: SirenSubEntity): Link[] {\n\n  if (subEntity.links === undefined) {\n    // We don't yet support subentities that don't have a URI.\n    return [];\n  }\n  let selfHref: string | null = null;\n  for (const link of subEntity.links) {\n    if (link.rel.includes('self')) {\n      selfHref = link.href;\n    }\n  }\n  if (selfHref === null) {\n    // We don't yet support subentities that don't have a URI.\n    return [];\n  }\n\n  return subEntity.rel.map(rel => {\n    const title = subEntity.title;\n    const link: Link = {\n      href: selfHref!,\n      rel,\n      context: contextUri,\n    };\n    if (title) {\n      link.title = title;\n    }\n    return link;\n  });\n\n}\n\nfunction parseSirenSubEntityAsEmbedded(contextUri: string, subEntity: SirenSubEntity, headers: Headers): SirenState<SirenEntity<any>> | null {\n\n  if (subEntity.links === undefined) {\n    // We don't yet support subentities that don't have a URI.\n    return null;\n  }\n  let selfHref = null;\n  for (const link of subEntity.links) {\n    if (link.rel.includes('self')) {\n      selfHref = link.href;\n    }\n  }\n  if (!selfHref) {\n    // We don't yet support subentities that don't have a URI.\n    return null;\n  }\n\n  const subEntityUrl = resolve(contextUri, selfHref);\n\n  return new SirenState(\n    subEntityUrl,\n    subEntity.properties,\n    headers,\n    new Links(selfHref, parseSirenLinks(selfHref, subEntity)),\n\n  );\n\n}\n\nfunction isSubEntity(input: SirenLink | SirenSubEntity): input is SirenSubEntity {\n\n  return (input as any).href === undefined;\n\n}\n\nfunction parseSirenAction(uri: string, action: SirenAction): ActionInfo {\n  return {\n    uri: resolve(uri, action.href),\n    name: action.name,\n    title: action.title,\n    method: action.method || 'GET',\n    contentType: action.type || 'application/x-www-form-urlencoded',\n    fields: action.fields ? action.fields.map( field => sirenFieldToField(field)) : [],\n  };\n}\n\nfunction sirenFieldToField(input: SirenField): Field {\n  return {\n    name: input.name,\n    type: input.type || 'text',\n    required: false,\n    readOnly: false,\n  };\n}\n","import { BaseState } from './base-state';\nimport { StateFactory } from './interface';\nimport { parseLink } from '../http/util';\nimport { Links } from '../link';\n\n/**\n * Represents a resource state for text responses, such as text/plain, text/csv.\n * text/html, text/csv.\n */\nexport class TextState extends BaseState<string> {\n\n  serializeBody(): string {\n\n    return this.data;\n\n  }\n\n  clone(): TextState {\n\n    return new TextState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links),\n    );\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a TextState\n */\nexport const factory: StateFactory<string> = async (uri: string, response: Response): Promise<TextState> => {\n\n  return new TextState(\n    uri,\n    await response.text(),\n    response.headers,\n    parseLink(uri, response.headers.get('Link')),\n  );\n\n};\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class CjState<T = any> extends BaseState<T> {\n\n  serializeBody(): string {\n\n    throw new Error('Reserializing Collection+JSON states is not yet supported. Please log an issue in the Ketting project to help figure out how this should be done');\n  }\n\n  clone(): CjState<T> {\n\n    return new CjState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links)\n    );\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a CjState\n */\nexport const factory = async (uri: string, response: Response): Promise<CjState<CjCollection>> => {\n\n  const body = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(\n    ...parseCjLinks(uri, body),\n  );\n\n  // Remove _links and _embedded from body\n  const {\n    _embedded,\n    _links,\n    ...newBody\n  } = body;\n\n  return new CjState(\n    uri,\n    newBody,\n    response.headers,\n    links,\n  );\n\n};\n\ntype CjDocument = {\n  collection: CjCollection,\n};\n\ntype CjCollection = {\n  version?: string,\n  href?: string,\n  links?: CjLink[],\n  items?: CjItem[],\n  queries?: CjQuery[],\n  template?: CjTemplate,\n  error?: CjError\n};\n\ntype CjError = {\n  title?: string,\n  code?: string,\n  message?: string,\n};\n\ntype CjTemplate = {\n  data?: CjProperty[]\n};\n\ntype CjItem = {\n  href?: string,\n  data?: CjProperty[],\n  links?: CjLink[],\n};\n\ntype CjProperty = {\n  name: string,\n  value?: string,\n  prompt?: string\n};\n\ntype CjQuery = {\n  href: string,\n  rel: string,\n  name?: string,\n  prompt?: string,\n  data?: CjProperty[]\n};\n\ntype CjLink = {\n  href: string,\n  rel: string,\n  name?: string,\n  render?: 'image' | 'link',\n  prompt?: string\n};\n\n\nfunction parseCjLinks(contextUri: string, body: CjDocument) {\n\n  const result: Link[] = [];\n  if (body.collection.links !== undefined) {\n\n    // Lets start with all links from the links property.\n    for (const link of body.collection.links) {\n      result.push({\n        context: contextUri,\n        href: link.href,\n        rel: link.rel,\n        title: link.name,\n      });\n    }\n  }\n\n  if (body.collection.items !== undefined) {\n\n    // Things that are in the 'items' array should also be considered links\n    // with the 'item' link relationship.\n    for (const item of body.collection.items) {\n\n      if (!item.href) {\n        continue;\n      }\n\n      result.push({\n        context: contextUri,\n        href: item.href,\n        rel: 'item',\n      });\n    }\n\n  }\n\n\n  if (body.collection.queries !== undefined) {\n\n    // Things that are in the 'queries' array can be considered links too.\n    for (const query of body.collection.queries) {\n\n      if (!query.data) {\n        // Non-templated\n        result.push({\n          context: contextUri,\n          href: query.href,\n          rel: query.rel,\n          title: query.name,\n        });\n      } else {\n        // This query has a data property so we need 50% more magic\n        result.push({\n          context: contextUri,\n          href: query.href + query.data.map(\n            property => '{?' + property.name + '}'\n          ).join(''),\n          templated: true,\n          rel: query.rel,\n          title: query.name,\n        });\n      }\n    }\n\n  }\n\n  return result;\n\n}\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { parseHtml, HtmlForm } from '../util/html';\nimport { Links } from '../link';\nimport { ActionInfo } from '../action';\nimport { resolve } from '../util/uri';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class HtmlState extends BaseState<string> {\n\n  serializeBody(): string {\n\n    return this.data;\n\n  }\n\n  clone(): HtmlState {\n\n    const state = new HtmlState(\n      this.uri,\n      this.data,\n      new Headers(this.headers),\n      new Links(this.uri, this.links),\n      [],\n      this.actionInfo,\n    );\n    state.client = this.client;\n    return state;\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a HtmlState\n */\nexport const factory = async (uri: string, response: Response): Promise<HtmlState> => {\n\n  const body = await response.text();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  const htmlResult = parseHtml(uri, body);\n  links.add(...htmlResult.links);\n\n  return new HtmlState(\n    uri,\n    body,\n    response.headers,\n    links,\n    [],\n    htmlResult.forms.map(form => formToAction(uri, form)),\n  );\n\n};\n\nfunction formToAction(context: string, form: HtmlForm): ActionInfo {\n\n  return {\n    uri: resolve(context, form.action),\n    name: form.rel || form.id || '',\n    method: form.method || 'GET',\n    contentType: form.enctype || 'application/x-www-form-urlencoded',\n    // Fields are not yet supported :(\n    fields: [],\n  };\n}\n","import { Link } from '../link';\nimport { resolve } from './uri';\n\nexport type HtmlForm = {\n  action: string,\n  method: string | null,\n  enctype: string | null,\n  rel: string | null,\n  id: string | null,\n}\n\ntype ParseHtmlResult = {\n\n  links: Link[],\n  forms: HtmlForm[],\n\n}\nexport function parseHtml(contextUri: string, body: string): ParseHtmlResult {\n\n  const parser = new DOMParser();\n  const doc = parser.parseFromString(body, 'text/html');\n\n  return {\n    forms: formFromTags(\n      contextUri,\n      doc.getElementsByTagName('form')\n    ),\n    links: [\n      ...linkFromTags(\n        contextUri,\n        doc.getElementsByTagName('link')\n      ),\n      ...linkFromTags(\n        contextUri,\n        doc.getElementsByTagName('a')\n      )\n    ]\n  };\n\n}\n\nfunction linkFromTags(contextUri: string, elements: HTMLCollectionOf<HTMLElement>): Link[] {\n\n  const result: Link[] = [];\n\n  for (const node of elements) {\n\n    const rels = node.getAttribute('rel');\n    const href = node.getAttribute('href');\n    const type = node.getAttribute('type') || undefined;\n\n    if (!rels || !href) {\n      continue;\n    }\n\n    for (const rel of rels.split(' ')) {\n\n      const link:Link = {\n        rel: rel,\n        context: contextUri,\n        href: href,\n      };\n      if (type) link.type = type;\n      result.push(link);\n\n    }\n\n  }\n  return result;\n\n}\n\nfunction formFromTags(contextUri: string, elements: HTMLCollectionOf<HTMLFormElement>): HtmlForm[] {\n\n  const result = [];\n\n  for (const node of elements) {\n\n    const rels = node.getAttribute('rel');\n    const action = node.getAttribute('action')!;\n    const enctype = node.getAttribute('enctype') || 'application/x-www-form-urlencoded';\n    const id = node.getAttribute('id');\n    const method = node.getAttribute('method') || 'GET';\n\n    if (!rels) {\n      result.push({\n        rel: null,\n        action: resolve(contextUri, action),\n        enctype,\n        id,\n        method\n      });\n      continue;\n    }\n\n    for (const rel of rels.split(' ')) {\n\n      const form = {\n        rel,\n        action: resolve(contextUri, action),\n        enctype,\n        id,\n        method\n      };\n      result.push(form);\n\n    }\n\n  }\n  return result;\n\n}\n","import { HeadState } from './interface';\nimport { parseLink } from '../http/util';\n\n/**\n * Turns the response to a HTTP Head request into a HeadState object.\n *\n * HeadState is a bit different from normal State objects, because it's\n * missing a bunch of information.\n */\nexport const factory = async (uri: string, response: Response): Promise<HeadState> => {\n\n  const links = parseLink(uri, response.headers.get('Link'));\n\n  return {\n    uri,\n    headers: response.headers,\n    contentHeaders: (): Headers => {\n\n      const contentHeaderNames = [\n        'Content-Type',\n        'Content-Language',\n      ];\n\n      const result: {[name: string]: string} = {};\n\n      for(const contentHeader of contentHeaderNames) {\n        if (response.headers.has(contentHeader)) {\n          result[contentHeader] = response.headers.get(contentHeader)!;\n        }\n      }\n      return new Headers(result);\n\n    },\n    links,\n    timestamp: Date.now(),\n  };\n\n};\n","import * as uriTemplate from 'uri-template';\nimport { resolve } from './uri';\nimport { LinkVariables, Link } from '../link';\n\nexport function expand(context: string, template: string, vars: LinkVariables): string;\nexport function expand(link: Link, vars: LinkVariables): string;\nexport function expand(arg1: string|Link, arg2: string|LinkVariables, arg3?: LinkVariables): string {\n\n  let context:string;\n  let template:string;\n  let vars:LinkVariables;\n\n  if (typeof arg1 === 'string') {\n    context = arg1;\n    template = arg2 as string;\n    vars = arg3 as LinkVariables;\n  } else {\n    context = arg1.context;\n    template = arg1.href;\n    vars =  arg2 as LinkVariables;\n  }\n  const templ = uriTemplate.parse(template);\n  const expanded = templ.expand(vars);\n  return resolve(context, expanded);\n}\n","module.exports = (function(){\n  /*\n   * Generated by PEG.js 0.7.0.\n   *\n   * http://pegjs.majda.cz/\n   */\n  \n  function quote(s) {\n    /*\n     * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a\n     * string literal except for the closing quote character, backslash,\n     * carriage return, line separator, paragraph separator, and line feed.\n     * Any character may appear in the form of an escape sequence.\n     *\n     * For portability, we also escape escape all control and non-ASCII\n     * characters. Note that \"\\0\" and \"\\v\" escape sequences are not used\n     * because JSHint does not like the first and IE the second.\n     */\n     return '\"' + s\n      .replace(/\\\\/g, '\\\\\\\\')  // backslash\n      .replace(/\"/g, '\\\\\"')    // closing quote character\n      .replace(/\\x08/g, '\\\\b') // backspace\n      .replace(/\\t/g, '\\\\t')   // horizontal tab\n      .replace(/\\n/g, '\\\\n')   // line feed\n      .replace(/\\f/g, '\\\\f')   // form feed\n      .replace(/\\r/g, '\\\\r')   // carriage return\n      .replace(/[\\x00-\\x07\\x0B\\x0E-\\x1F\\x80-\\uFFFF]/g, escape)\n      + '\"';\n  }\n  \n  var result = {\n    /*\n     * Parses the input with a generated parser. If the parsing is successfull,\n     * returns a value explicitly or implicitly specified by the grammar from\n     * which the parser was generated (see |PEG.buildParser|). If the parsing is\n     * unsuccessful, throws |PEG.parser.SyntaxError| describing the error.\n     */\n    parse: function(input, startRule) {\n      var parseFunctions = {\n        \"uriTemplate\": parse_uriTemplate,\n        \"expression\": parse_expression,\n        \"op\": parse_op,\n        \"pathExpression\": parse_pathExpression,\n        \"paramList\": parse_paramList,\n        \"param\": parse_param,\n        \"cut\": parse_cut,\n        \"listMarker\": parse_listMarker,\n        \"substr\": parse_substr,\n        \"nonexpression\": parse_nonexpression,\n        \"extension\": parse_extension\n      };\n      \n      if (startRule !== undefined) {\n        if (parseFunctions[startRule] === undefined) {\n          throw new Error(\"Invalid rule name: \" + quote(startRule) + \".\");\n        }\n      } else {\n        startRule = \"uriTemplate\";\n      }\n      \n      var pos = 0;\n      var reportFailures = 0;\n      var rightmostFailuresPos = 0;\n      var rightmostFailuresExpected = [];\n      \n      function padLeft(input, padding, length) {\n        var result = input;\n        \n        var padLength = length - input.length;\n        for (var i = 0; i < padLength; i++) {\n          result = padding + result;\n        }\n        \n        return result;\n      }\n      \n      function escape(ch) {\n        var charCode = ch.charCodeAt(0);\n        var escapeChar;\n        var length;\n        \n        if (charCode <= 0xFF) {\n          escapeChar = 'x';\n          length = 2;\n        } else {\n          escapeChar = 'u';\n          length = 4;\n        }\n        \n        return '\\\\' + escapeChar + padLeft(charCode.toString(16).toUpperCase(), '0', length);\n      }\n      \n      function matchFailed(failure) {\n        if (pos < rightmostFailuresPos) {\n          return;\n        }\n        \n        if (pos > rightmostFailuresPos) {\n          rightmostFailuresPos = pos;\n          rightmostFailuresExpected = [];\n        }\n        \n        rightmostFailuresExpected.push(failure);\n      }\n      \n      function parse_uriTemplate() {\n        var result0, result1;\n        var pos0;\n        \n        pos0 = pos;\n        result0 = [];\n        result1 = parse_nonexpression();\n        if (result1 === null) {\n          result1 = parse_expression();\n        }\n        while (result1 !== null) {\n          result0.push(result1);\n          result1 = parse_nonexpression();\n          if (result1 === null) {\n            result1 = parse_expression();\n          }\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, pieces) { return new Template(pieces) })(pos0, result0);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_expression() {\n        var result0, result1, result2, result3;\n        var pos0, pos1;\n        \n        pos0 = pos;\n        pos1 = pos;\n        if (input.charCodeAt(pos) === 123) {\n          result0 = \"{\";\n          pos++;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"\\\"{\\\"\");\n          }\n        }\n        if (result0 !== null) {\n          result1 = parse_op();\n          if (result1 !== null) {\n            result2 = parse_paramList();\n            if (result2 !== null) {\n              if (input.charCodeAt(pos) === 125) {\n                result3 = \"}\";\n                pos++;\n              } else {\n                result3 = null;\n                if (reportFailures === 0) {\n                  matchFailed(\"\\\"}\\\"\");\n                }\n              }\n              if (result3 !== null) {\n                result0 = [result0, result1, result2, result3];\n              } else {\n                result0 = null;\n                pos = pos1;\n              }\n            } else {\n              result0 = null;\n              pos = pos1;\n            }\n          } else {\n            result0 = null;\n            pos = pos1;\n          }\n        } else {\n          result0 = null;\n          pos = pos1;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, op, params) { return expression(op, params) })(pos0, result0[1], result0[2]);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_op() {\n        var result0;\n        \n        if (/^[\\/;:.?&+#]/.test(input.charAt(pos))) {\n          result0 = input.charAt(pos);\n          pos++;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"[\\\\/;:.?&+#]\");\n          }\n        }\n        if (result0 === null) {\n          result0 = \"\";\n        }\n        return result0;\n      }\n      \n      function parse_pathExpression() {\n        var result0;\n        \n        if (input.substr(pos, 2) === \"{/\") {\n          result0 = \"{/\";\n          pos += 2;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"\\\"{/\\\"\");\n          }\n        }\n        return result0;\n      }\n      \n      function parse_paramList() {\n        var result0, result1, result2, result3;\n        var pos0, pos1, pos2, pos3;\n        \n        pos0 = pos;\n        pos1 = pos;\n        result0 = parse_param();\n        if (result0 !== null) {\n          result1 = [];\n          pos2 = pos;\n          pos3 = pos;\n          if (input.charCodeAt(pos) === 44) {\n            result2 = \",\";\n            pos++;\n          } else {\n            result2 = null;\n            if (reportFailures === 0) {\n              matchFailed(\"\\\",\\\"\");\n            }\n          }\n          if (result2 !== null) {\n            result3 = parse_param();\n            if (result3 !== null) {\n              result2 = [result2, result3];\n            } else {\n              result2 = null;\n              pos = pos3;\n            }\n          } else {\n            result2 = null;\n            pos = pos3;\n          }\n          if (result2 !== null) {\n            result2 = (function(offset, p) { return p; })(pos2, result2[1]);\n          }\n          if (result2 === null) {\n            pos = pos2;\n          }\n          while (result2 !== null) {\n            result1.push(result2);\n            pos2 = pos;\n            pos3 = pos;\n            if (input.charCodeAt(pos) === 44) {\n              result2 = \",\";\n              pos++;\n            } else {\n              result2 = null;\n              if (reportFailures === 0) {\n                matchFailed(\"\\\",\\\"\");\n              }\n            }\n            if (result2 !== null) {\n              result3 = parse_param();\n              if (result3 !== null) {\n                result2 = [result2, result3];\n              } else {\n                result2 = null;\n                pos = pos3;\n              }\n            } else {\n              result2 = null;\n              pos = pos3;\n            }\n            if (result2 !== null) {\n              result2 = (function(offset, p) { return p; })(pos2, result2[1]);\n            }\n            if (result2 === null) {\n              pos = pos2;\n            }\n          }\n          if (result1 !== null) {\n            result0 = [result0, result1];\n          } else {\n            result0 = null;\n            pos = pos1;\n          }\n        } else {\n          result0 = null;\n          pos = pos1;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, hd, rst) { rst.unshift(hd); return rst; })(pos0, result0[0], result0[1]);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_param() {\n        var result0, result1, result2;\n        var pos0, pos1;\n        \n        pos0 = pos;\n        pos1 = pos;\n        result0 = [];\n        if (/^[a-zA-Z0-9_.%]/.test(input.charAt(pos))) {\n          result1 = input.charAt(pos);\n          pos++;\n        } else {\n          result1 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"[a-zA-Z0-9_.%]\");\n          }\n        }\n        while (result1 !== null) {\n          result0.push(result1);\n          if (/^[a-zA-Z0-9_.%]/.test(input.charAt(pos))) {\n            result1 = input.charAt(pos);\n            pos++;\n          } else {\n            result1 = null;\n            if (reportFailures === 0) {\n              matchFailed(\"[a-zA-Z0-9_.%]\");\n            }\n          }\n        }\n        if (result0 !== null) {\n          result1 = parse_cut();\n          if (result1 === null) {\n            result1 = parse_listMarker();\n          }\n          result1 = result1 !== null ? result1 : \"\";\n          if (result1 !== null) {\n            result2 = parse_extension();\n            result2 = result2 !== null ? result2 : \"\";\n            if (result2 !== null) {\n              result0 = [result0, result1, result2];\n            } else {\n              result0 = null;\n              pos = pos1;\n            }\n          } else {\n            result0 = null;\n            pos = pos1;\n          }\n        } else {\n          result0 = null;\n          pos = pos1;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, chars, clm, e) { clm = clm || {};\n              return {\n              name: chars.join(''),\n              explode: clm.listMarker,\n              cut: clm.cut,\n              extended: e\n            } })(pos0, result0[0], result0[1], result0[2]);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_cut() {\n        var result0;\n        var pos0;\n        \n        pos0 = pos;\n        result0 = parse_substr();\n        if (result0 !== null) {\n          result0 = (function(offset, cut) { return {cut: cut}; })(pos0, result0);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_listMarker() {\n        var result0;\n        var pos0;\n        \n        pos0 = pos;\n        if (input.charCodeAt(pos) === 42) {\n          result0 = \"*\";\n          pos++;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"\\\"*\\\"\");\n          }\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, listMarker) { return {listMarker: listMarker}; })(pos0, result0);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_substr() {\n        var result0, result1, result2;\n        var pos0, pos1;\n        \n        pos0 = pos;\n        pos1 = pos;\n        if (input.charCodeAt(pos) === 58) {\n          result0 = \":\";\n          pos++;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"\\\":\\\"\");\n          }\n        }\n        if (result0 !== null) {\n          if (/^[0-9]/.test(input.charAt(pos))) {\n            result2 = input.charAt(pos);\n            pos++;\n          } else {\n            result2 = null;\n            if (reportFailures === 0) {\n              matchFailed(\"[0-9]\");\n            }\n          }\n          if (result2 !== null) {\n            result1 = [];\n            while (result2 !== null) {\n              result1.push(result2);\n              if (/^[0-9]/.test(input.charAt(pos))) {\n                result2 = input.charAt(pos);\n                pos++;\n              } else {\n                result2 = null;\n                if (reportFailures === 0) {\n                  matchFailed(\"[0-9]\");\n                }\n              }\n            }\n          } else {\n            result1 = null;\n          }\n          if (result1 !== null) {\n            result0 = [result0, result1];\n          } else {\n            result0 = null;\n            pos = pos1;\n          }\n        } else {\n          result0 = null;\n          pos = pos1;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, digits) { return parseInt(digits.join('')) })(pos0, result0[1]);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_nonexpression() {\n        var result0, result1;\n        var pos0;\n        \n        pos0 = pos;\n        if (/^[^{]/.test(input.charAt(pos))) {\n          result1 = input.charAt(pos);\n          pos++;\n        } else {\n          result1 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"[^{]\");\n          }\n        }\n        if (result1 !== null) {\n          result0 = [];\n          while (result1 !== null) {\n            result0.push(result1);\n            if (/^[^{]/.test(input.charAt(pos))) {\n              result1 = input.charAt(pos);\n              pos++;\n            } else {\n              result1 = null;\n              if (reportFailures === 0) {\n                matchFailed(\"[^{]\");\n              }\n            }\n          }\n        } else {\n          result0 = null;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, chars) { return chars.join(''); })(pos0, result0);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      function parse_extension() {\n        var result0, result1, result2;\n        var pos0, pos1;\n        \n        pos0 = pos;\n        pos1 = pos;\n        if (input.charCodeAt(pos) === 40) {\n          result0 = \"(\";\n          pos++;\n        } else {\n          result0 = null;\n          if (reportFailures === 0) {\n            matchFailed(\"\\\"(\\\"\");\n          }\n        }\n        if (result0 !== null) {\n          if (/^[^)]/.test(input.charAt(pos))) {\n            result2 = input.charAt(pos);\n            pos++;\n          } else {\n            result2 = null;\n            if (reportFailures === 0) {\n              matchFailed(\"[^)]\");\n            }\n          }\n          if (result2 !== null) {\n            result1 = [];\n            while (result2 !== null) {\n              result1.push(result2);\n              if (/^[^)]/.test(input.charAt(pos))) {\n                result2 = input.charAt(pos);\n                pos++;\n              } else {\n                result2 = null;\n                if (reportFailures === 0) {\n                  matchFailed(\"[^)]\");\n                }\n              }\n            }\n          } else {\n            result1 = null;\n          }\n          if (result1 !== null) {\n            if (input.charCodeAt(pos) === 41) {\n              result2 = \")\";\n              pos++;\n            } else {\n              result2 = null;\n              if (reportFailures === 0) {\n                matchFailed(\"\\\")\\\"\");\n              }\n            }\n            if (result2 !== null) {\n              result0 = [result0, result1, result2];\n            } else {\n              result0 = null;\n              pos = pos1;\n            }\n          } else {\n            result0 = null;\n            pos = pos1;\n          }\n        } else {\n          result0 = null;\n          pos = pos1;\n        }\n        if (result0 !== null) {\n          result0 = (function(offset, chars) { return chars.join('') })(pos0, result0[1]);\n        }\n        if (result0 === null) {\n          pos = pos0;\n        }\n        return result0;\n      }\n      \n      \n      function cleanupExpected(expected) {\n        expected.sort();\n        \n        var lastExpected = null;\n        var cleanExpected = [];\n        for (var i = 0; i < expected.length; i++) {\n          if (expected[i] !== lastExpected) {\n            cleanExpected.push(expected[i]);\n            lastExpected = expected[i];\n          }\n        }\n        return cleanExpected;\n      }\n      \n      function computeErrorPosition() {\n        /*\n         * The first idea was to use |String.split| to break the input up to the\n         * error position along newlines and derive the line and column from\n         * there. However IE's |split| implementation is so broken that it was\n         * enough to prevent it.\n         */\n        \n        var line = 1;\n        var column = 1;\n        var seenCR = false;\n        \n        for (var i = 0; i < Math.max(pos, rightmostFailuresPos); i++) {\n          var ch = input.charAt(i);\n          if (ch === \"\\n\") {\n            if (!seenCR) { line++; }\n            column = 1;\n            seenCR = false;\n          } else if (ch === \"\\r\" || ch === \"\\u2028\" || ch === \"\\u2029\") {\n            line++;\n            column = 1;\n            seenCR = true;\n          } else {\n            column++;\n            seenCR = false;\n          }\n        }\n        \n        return { line: line, column: column };\n      }\n      \n      \n          var cls = require('./lib/classes')\n          var Template = cls.Template\n          var expression = cls.expression\n      \n      \n      var result = parseFunctions[startRule]();\n      \n      /*\n       * The parser is now in one of the following three states:\n       *\n       * 1. The parser successfully parsed the whole input.\n       *\n       *    - |result !== null|\n       *    - |pos === input.length|\n       *    - |rightmostFailuresExpected| may or may not contain something\n       *\n       * 2. The parser successfully parsed only a part of the input.\n       *\n       *    - |result !== null|\n       *    - |pos < input.length|\n       *    - |rightmostFailuresExpected| may or may not contain something\n       *\n       * 3. The parser did not successfully parse any part of the input.\n       *\n       *   - |result === null|\n       *   - |pos === 0|\n       *   - |rightmostFailuresExpected| contains at least one failure\n       *\n       * All code following this comment (including called functions) must\n       * handle these states.\n       */\n      if (result === null || pos !== input.length) {\n        var offset = Math.max(pos, rightmostFailuresPos);\n        var found = offset < input.length ? input.charAt(offset) : null;\n        var errorPosition = computeErrorPosition();\n        \n        throw new this.SyntaxError(\n          cleanupExpected(rightmostFailuresExpected),\n          found,\n          offset,\n          errorPosition.line,\n          errorPosition.column\n        );\n      }\n      \n      return result;\n    },\n    \n    /* Returns the parser source code. */\n    toSource: function() { return this._source; }\n  };\n  \n  /* Thrown when a parser encounters a syntax error. */\n  \n  result.SyntaxError = function(expected, found, offset, line, column) {\n    function buildMessage(expected, found) {\n      var expectedHumanized, foundHumanized;\n      \n      switch (expected.length) {\n        case 0:\n          expectedHumanized = \"end of input\";\n          break;\n        case 1:\n          expectedHumanized = expected[0];\n          break;\n        default:\n          expectedHumanized = expected.slice(0, expected.length - 1).join(\", \")\n            + \" or \"\n            + expected[expected.length - 1];\n      }\n      \n      foundHumanized = found ? quote(found) : \"end of input\";\n      \n      return \"Expected \" + expectedHumanized + \" but \" + foundHumanized + \" found.\";\n    }\n    \n    this.name = \"SyntaxError\";\n    this.expected = expected;\n    this.found = found;\n    this.message = buildMessage(expected, found);\n    this.offset = offset;\n    this.line = line;\n    this.column = column;\n  };\n  \n  result.SyntaxError.prototype = Error.prototype;\n  \n  return result;\n})();\n","// Generated by CoffeeScript 1.6.3\n(function() {\n  var FormContinuationExpression, FormStartExpression, FragmentExpression, LabelExpression, NamedExpression, PathParamExpression, PathSegmentExpression, ReservedExpression, SimpleExpression, Template, encoders, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7,\n    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },\n    __hasProp = {}.hasOwnProperty,\n    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };\n\n  encoders = require('./encoders');\n\n  Template = Template = (function() {\n    function Template(pieces) {\n      /*\n      :param pieces: An array of strings and expressions in the order they appear in the template.\n      */\n\n      var i,\n        _this = this;\n      this.expressions = [];\n      this.prefix = 'string' === typeof pieces[0] ? pieces.shift() : '';\n      i = 0;\n      pieces.forEach(function(p) {\n        switch (typeof p) {\n          case 'object':\n            return _this.expressions[i++] = p;\n          case 'string':\n            return _this.expressions[i - 1].suffix = p;\n        }\n      });\n    }\n\n    Template.prototype.expand = function(vars) {\n      return this.prefix + this.expressions.map(function(expr) {\n        return expr.expand(vars);\n      }).join('');\n    };\n\n    Template.prototype.toString = function() {\n      return this.prefix + this.expressions.join('');\n    };\n\n    Template.prototype.toJSON = function() {\n      return this.toString();\n    };\n\n    return Template;\n\n  })();\n\n  SimpleExpression = (function() {\n    var definedPairs;\n\n    SimpleExpression.prototype.first = \"\";\n\n    SimpleExpression.prototype.sep = \",\";\n\n    SimpleExpression.prototype.named = false;\n\n    SimpleExpression.prototype.empty = \"\";\n\n    SimpleExpression.prototype.allow = \"U\";\n\n    function SimpleExpression(params) {\n      this.params = params;\n      this.explodeObject = __bind(this.explodeObject, this);\n      this.explodeArray = __bind(this.explodeArray, this);\n      this._expandPair = __bind(this._expandPair, this);\n      this.stringifySingle = __bind(this.stringifySingle, this);\n      this.encode = __bind(this.encode, this);\n      if (this.params == null) {\n        this.params = [];\n      }\n      this.suffix = '';\n    }\n\n    SimpleExpression.prototype.encode = function(string) {\n      /*\n      Encode a string value for the URI\n      */\n\n      return encoders[this.allow](string);\n    };\n\n    SimpleExpression.prototype.stringifySingle = function(param, value) {\n      /*\n      Encode a single value as a string\n      */\n\n      var k, type, v;\n      type = typeof value;\n      if (type === 'string' || type === 'boolean' || type === 'number') {\n        value = value.toString();\n        return this.encode(value.substring(0, param.cut || value.length));\n      } else if (Array.isArray(value)) {\n        if (param.cut) {\n          throw new Error(\"Prefixed Values do not support lists. Check \" + param.name);\n        }\n        return value.map(this.encode).join(',');\n      } else {\n        if (param.cut) {\n          throw new Error(\"Prefixed Values do not support maps. Check \" + param.name);\n        }\n        return ((function() {\n          var _results;\n          _results = [];\n          for (k in value) {\n            v = value[k];\n            _results.push([k, v].map(this.encode).join(','));\n          }\n          return _results;\n        }).call(this)).join(',');\n      }\n    };\n\n    SimpleExpression.prototype.expand = function(vars) {\n      var defined, expanded,\n        _this = this;\n      defined = definedPairs(this.params, vars);\n      expanded = defined.map(function(pair) {\n        return _this._expandPair.apply(_this, pair);\n      }).join(this.sep);\n      if (expanded) {\n        return this.first + expanded + this.suffix;\n      } else {\n        if (this.empty && defined.length) {\n          return this.empty + this.suffix;\n        } else {\n          return this.suffix;\n        }\n      }\n    };\n\n    definedPairs = function(params, vars) {\n      /*\n      Return an array of [key, value] arrays where ``key`` is a parameter name\n      from ``@params`` and ``value`` is the value from vars, when ``value`` is\n      neither undefined nor an empty collection.\n      */\n\n      var _this = this;\n      return params.map(function(p) {\n        return [p, vars[p.name]];\n      }).filter(function(pair) {\n        var k, v, vv;\n        v = pair[1];\n        switch (typeof v) {\n          case \"undefined\":\n            return false;\n          case \"object\":\n            if (Array.isArray(v)) {\n              v.length > 0;\n            }\n            for (k in v) {\n              vv = v[k];\n              if (vv) {\n                return true;\n              }\n            }\n            return false;\n          default:\n            return true;\n        }\n      });\n    };\n\n    SimpleExpression.prototype._expandPair = function(param, value) {\n      /*\n      Return the expanded string form of ``pair``.\n      \n      :param pair: A ``[param, value]`` tuple.\n      */\n\n      var name;\n      name = param.name;\n      if (param.explode) {\n        if (Array.isArray(value)) {\n          return this.explodeArray(param, value);\n        } else if (typeof value === 'string') {\n          return this.stringifySingle(param, value);\n        } else {\n          return this.explodeObject(value);\n        }\n      } else {\n        return this.stringifySingle(param, value);\n      }\n    };\n\n    SimpleExpression.prototype.explodeArray = function(param, array) {\n      return array.map(this.encode).join(this.sep);\n    };\n\n    SimpleExpression.prototype.explodeObject = function(object) {\n      var k, pairs, v, vv, _i, _len;\n      pairs = [];\n      for (k in object) {\n        v = object[k];\n        k = this.encode(k);\n        if (Array.isArray(v)) {\n          for (_i = 0, _len = v.length; _i < _len; _i++) {\n            vv = v[_i];\n            pairs.push([k, this.encode(vv)]);\n          }\n        } else {\n          pairs.push([k, this.encode(v)]);\n        }\n      }\n      return pairs.map(function(pair) {\n        return pair.join('=');\n      }).join(this.sep);\n    };\n\n    SimpleExpression.prototype.toString = function() {\n      var params;\n      params = this.params.map(function(p) {\n        return p.name + p.explode;\n      }).join(',');\n      return \"{\" + this.first + params + \"}\" + this.suffix;\n    };\n\n    SimpleExpression.prototype.toJSON = function() {\n      return this.toString();\n    };\n\n    return SimpleExpression;\n\n  })();\n\n  NamedExpression = (function(_super) {\n    __extends(NamedExpression, _super);\n\n    function NamedExpression() {\n      this.explodeArray = __bind(this.explodeArray, this);\n      this.stringifySingle = __bind(this.stringifySingle, this);\n      _ref = NamedExpression.__super__.constructor.apply(this, arguments);\n      return _ref;\n    }\n\n    /*\n    A NamedExpression uses name=value expansions in most cases\n    */\n\n\n    NamedExpression.prototype.stringifySingle = function(param, value) {\n      value = (value = NamedExpression.__super__.stringifySingle.apply(this, arguments)) ? \"=\" + value : this.empty;\n      return \"\" + param.name + value;\n    };\n\n    NamedExpression.prototype.explodeArray = function(param, array) {\n      var _this = this;\n      return array.map(function(v) {\n        return \"\" + param.name + \"=\" + (_this.encode(v));\n      }).join(this.sep);\n    };\n\n    return NamedExpression;\n\n  })(SimpleExpression);\n\n  ReservedExpression = (function(_super) {\n    __extends(ReservedExpression, _super);\n\n    function ReservedExpression() {\n      _ref1 = ReservedExpression.__super__.constructor.apply(this, arguments);\n      return _ref1;\n    }\n\n    ReservedExpression.prototype.encode = function(string) {\n      return encoders['U+R'](string);\n    };\n\n    ReservedExpression.prototype.toString = function() {\n      return '{+' + (ReservedExpression.__super__.toString.apply(this, arguments)).substring(1);\n    };\n\n    return ReservedExpression;\n\n  })(SimpleExpression);\n\n  FragmentExpression = (function(_super) {\n    __extends(FragmentExpression, _super);\n\n    function FragmentExpression() {\n      _ref2 = FragmentExpression.__super__.constructor.apply(this, arguments);\n      return _ref2;\n    }\n\n    FragmentExpression.prototype.first = '#';\n\n    FragmentExpression.prototype.empty = '#';\n\n    FragmentExpression.prototype.encode = function(string) {\n      return encoders['U+R'](string);\n    };\n\n    return FragmentExpression;\n\n  })(SimpleExpression);\n\n  LabelExpression = (function(_super) {\n    __extends(LabelExpression, _super);\n\n    function LabelExpression() {\n      _ref3 = LabelExpression.__super__.constructor.apply(this, arguments);\n      return _ref3;\n    }\n\n    LabelExpression.prototype.first = '.';\n\n    LabelExpression.prototype.sep = '.';\n\n    LabelExpression.prototype.empty = '.';\n\n    return LabelExpression;\n\n  })(SimpleExpression);\n\n  PathSegmentExpression = (function(_super) {\n    __extends(PathSegmentExpression, _super);\n\n    function PathSegmentExpression() {\n      _ref4 = PathSegmentExpression.__super__.constructor.apply(this, arguments);\n      return _ref4;\n    }\n\n    PathSegmentExpression.prototype.first = '/';\n\n    PathSegmentExpression.prototype.sep = '/';\n\n    return PathSegmentExpression;\n\n  })(SimpleExpression);\n\n  PathParamExpression = (function(_super) {\n    __extends(PathParamExpression, _super);\n\n    function PathParamExpression() {\n      _ref5 = PathParamExpression.__super__.constructor.apply(this, arguments);\n      return _ref5;\n    }\n\n    PathParamExpression.prototype.first = ';';\n\n    PathParamExpression.prototype.sep = ';';\n\n    return PathParamExpression;\n\n  })(NamedExpression);\n\n  FormStartExpression = (function(_super) {\n    __extends(FormStartExpression, _super);\n\n    function FormStartExpression() {\n      _ref6 = FormStartExpression.__super__.constructor.apply(this, arguments);\n      return _ref6;\n    }\n\n    FormStartExpression.prototype.first = '?';\n\n    FormStartExpression.prototype.sep = '&';\n\n    FormStartExpression.prototype.empty = '=';\n\n    return FormStartExpression;\n\n  })(NamedExpression);\n\n  FormContinuationExpression = (function(_super) {\n    __extends(FormContinuationExpression, _super);\n\n    function FormContinuationExpression() {\n      _ref7 = FormContinuationExpression.__super__.constructor.apply(this, arguments);\n      return _ref7;\n    }\n\n    FormContinuationExpression.prototype.first = '&';\n\n    return FormContinuationExpression;\n\n  })(FormStartExpression);\n\n  module.exports = {\n    Template: Template,\n    SimpleExpression: SimpleExpression,\n    NamedExpression: NamedExpression,\n    ReservedExpression: ReservedExpression,\n    FragmentExpression: FragmentExpression,\n    LabelExpression: LabelExpression,\n    PathSegmentExpression: PathSegmentExpression,\n    PathParamExpression: PathParamExpression,\n    FormStartExpression: FormStartExpression,\n    FormContinuationExpression: FormContinuationExpression,\n    expression: function(op, params) {\n      var cls;\n      cls = (function() {\n        switch (op) {\n          case '':\n            return SimpleExpression;\n          case '+':\n            return ReservedExpression;\n          case '#':\n            return FragmentExpression;\n          case '.':\n            return LabelExpression;\n          case '/':\n            return PathSegmentExpression;\n          case ';':\n            return PathParamExpression;\n          case '?':\n            return FormStartExpression;\n          case '&':\n            return FormContinuationExpression;\n        }\n      })();\n      return new cls(params);\n    }\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.6.3\n(function() {\n  var pctEncode;\n\n  pctEncode = require('pct-encode');\n\n  exports[\"U\"] = pctEncode(/[^\\w~.-]/g);\n\n  exports[\"U+R\"] = pctEncode(/[^\\w.~:\\/\\?#\\[\\]@!\\$&'()*+,;=%-]|%(?!\\d\\d)/g);\n\n}).call(this);\n","module.exports = function pctEncode(regexp) {\n  regexp = regexp || /\\W/g;\n  return function encode(string) {\n    string = String(string);\n    return string.replace(regexp, function (m) {\n      var c = m[0].charCodeAt(0)\n        , encoded = [];\n      if (c < 128) {\n        encoded.push(c);\n      } else if ((128 <= c && c < 2048)) {\n        encoded.push((c >> 6) | 192);\n        encoded.push((c & 63) | 128);\n      } else {\n        encoded.push((c >> 12) | 224);\n        encoded.push(((c >> 6) & 63) | 128);\n        encoded.push((c & 63) | 128);\n      }\n      return encoded.map(function (c) {\n        return '%' + c.toString(16).toUpperCase();\n      }).join('');\n    })\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n    var errorListener;\n\n    // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}\n","export function needsJsonStringify(input: any): boolean {\n\n  if (typeof input ==='string') {\n    return false;\n  }\n\n  if (input instanceof Blob) {\n    return false;\n  }\n\n  return true;\n\n}\n","import { State } from '../state';\nimport { ForeverCache } from './forever';\n\n/**\n * ShortCache stores items in the cache for a short time.\n *\n * This cache can be a good choice if your server heavily relies\n * on HTTP cache headers and Ketting runs in your browser, or if in general\n * you want very up-to-date data.\n *\n * The reason in this scenarios it's useful to still have a 'very temporary'\n * cache, is because during many operations `get()` may be called in rapid\n * succession, and it also allows for enough time for 'embedded items' to\n * pe placed in the cache and extracted again.\n */\nexport class ShortCache extends ForeverCache {\n\n  private cacheTimeout: number;\n  private activeTimers: Map<string, ReturnType<typeof setInterval>>;\n\n  /**\n   * Create the short cache.\n   *\n   * cacheTimeout is specified in ms.\n   */\n  constructor(cacheTimeout: number = 30000) {\n    super();\n    this.cacheTimeout = cacheTimeout;\n    this.activeTimers = new Map();\n  }\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    super.store(state);\n    this.setTimer(state.uri);\n  }\n\n  private setTimer(uri: string) {\n\n    if (this.activeTimers.has(uri)) {\n      clearTimeout(this.activeTimers.get(uri)!);\n    }\n    // If there is a TON in the cache, this algorithm might\n    // be optimized by using a linked list and a single timeout\n    // for the 'next scheduled' expiry.\n    //\n    // The expectation is that this is not the case though, so this is the\n    // lazy/easy way.\n    this.activeTimers.set(\n      uri,\n      setTimeout( () => {\n        this.delete(uri);\n        this.activeTimers.delete(uri);\n      }, this.cacheTimeout)\n    );\n\n  }\n\n}\n","import { StateCache } from './';\nimport { State } from '../state';\n\n/**\n * The NeverCache caches absolutely nothing.\n *\n * This should usually only be used in testing scenarios or if you really\n * know what you're doing.\n *\n * Using it could cause excessive requests, and will cause embedded items\n * to be ignored.\n */\nexport class NeverCache implements StateCache {\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    // Nothing to do\n  }\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get(uri: string): null {\n    return null;\n  }\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has(uri: string): boolean {\n\n    return false;\n\n  }\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete(uri: string) {\n    // Nothing to do\n  }\n\n  /**\n   * Purge the entire cache\n   */\n  clear() {\n    // Nothing to do\n  }\n\n}\n","import { FetchMiddleware } from './fetcher';\nimport * as base64 from '../util/base64';\n\nexport default (userName: string, password: string): FetchMiddleware => {\n\n  const basicAuthHeader = 'Basic ' + base64.encode(userName + ':' + password);\n\n  return (request, next) => {\n\n    request.headers.set('Authorization', basicAuthHeader);\n    return next(request);\n\n  };\n\n};\n","/**\n * Encoding a string to base64 in a browser.\n */\nexport function encode(input: string): string {\n\n  return btoa(input);\n\n}\n","import { FetchMiddleware } from './fetcher';\n\nexport default (token: string): FetchMiddleware => {\n\n  const bearerAuthHeader = 'Bearer ' + token;\n\n  return (request, next) => {\n\n    request.headers.set('Authorization', bearerAuthHeader);\n    return next(request);\n\n  };\n\n};\n","import { FetchMiddleware } from './fetcher';\nimport { OAuth2Options, OAuth2 } from 'fetch-mw-oauth2';\n\nexport default (oauth2Options: OAuth2Options): FetchMiddleware => {\n\n  const oauth2 = new OAuth2(oauth2Options);\n  return oauth2.fetchMw.bind(oauth2);\n\n};\n","!function(e,t){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.fetchMwOAuth2=t():e.fetchMwOAuth2=t()}(window,(function(){return function(e){var t={};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}return o.m=e,o.c=t,o.d=function(e,t,n){o.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},o.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},o.t=function(e,t){if(1&t&&(e=o(e)),8&t)return e;if(4&t&&\"object\"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,\"default\",{enumerable:!0,value:e}),2&t&&\"string\"!=typeof e)for(var r in e)o.d(n,r,function(t){return e[t]}.bind(null,r));return n},o.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(t,\"a\",t),t},o.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},o.p=\"\",o(o.s=1)}([function(e,t,o){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0});class n extends Error{constructor(e,t,o){super(e),this.oauth2Code=t,this.httpCode=o}}t.default=n},function(e,t,o){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0});var n=o(2);t.default=n.default,t.fetchMwOAuth2=n.default,t.OAuth2=n.default;var r=o(0);t.OAuth2Error=r.default},function(e,t,o){\"use strict\";var n=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,\"__esModule\",{value:!0});const r=o(3),s=n(o(0)),i=o(4);async function c(e,t){return e.headers.set(\"Authorization\",\"Bearer \"+t),await fetch(e)}t.default=class{constructor(e){this.options=e,this.token={accessToken:e.accessToken||\"\",expiresAt:e.accessToken?null:0,refreshToken:e.refreshToken||null}}async fetch(e,t){const o=new Request(e,t);let n=await this.getAccessToken(),r=await c(o.clone(),n);return r.ok||401!==r.status||(n=await this.refreshToken(),r=await c(o,n)),r}async fetchMw(e,t){let o=await this.getAccessToken(),n=e.clone();n.headers.set(\"Authorization\",\"Bearer \"+o);let r=await t(n);return r.ok||401!==r.status||(o=await this.refreshToken(),n=e.clone(),n.headers.set(\"Authorization\",\"Bearer \"+o),r=await t(n)),r}async getOptions(){const e=await this.getToken();return{clientId:this.options.clientId,grantType:void 0,accessToken:e.accessToken,refreshToken:e.refreshToken||void 0,tokenEndpoint:this.options.tokenEndpoint}}async getToken(){return await this.getAccessToken(),this.token}async getAccessToken(){return null===this.token.expiresAt||this.token.expiresAt>Date.now()?this.token.accessToken:this.refreshToken()}async refreshToken(){let e;const t=this.token;if(t.refreshToken)e={grant_type:\"refresh_token\",refresh_token:t.refreshToken},this.options.clientSecret||(e.client_id=this.options.clientId);else switch(this.options.grantType){case\"client_credentials\":e={grant_type:\"client_credentials\"},this.options.scope&&(e.scope=this.options.scope.join(\" \"));break;case\"password\":e={grant_type:\"password\",username:this.options.userName,password:this.options.password},this.options.scope&&(e.scope=this.options.scope.join(\" \"));break;case\"authorization_code\":e={grant_type:\"authorization_code\",code:this.options.code,redirect_uri:this.options.redirectUri,client_id:this.options.clientId};break;default:throw new Error(\"Unknown grantType: \"+this.options.grantType)}const o={\"Content-Type\":\"application/x-www-form-urlencoded\"};if(void 0!==this.options.clientSecret){const e=r.encode(this.options.clientId+\":\"+this.options.clientSecret);o.Authorization=\"Basic \"+e}const n=await fetch(this.options.tokenEndpoint,{method:\"POST\",headers:o,body:i.objToQueryString(e)}),c=await n.json();if(!n.ok){if(\"refresh_token\"===e.grant_type&&this.options.grantType)return this.token={accessToken:\"\",expiresAt:0,refreshToken:null},this.getAccessToken();let t=\"OAuth2 error \"+c.error+\".\";throw c.error_description&&(t+=\" \"+c.error_description),new s.default(t,c.error,401)}return this.token={accessToken:c.access_token,expiresAt:c.expires_in?Date.now()+1e3*c.expires_in:null,refreshToken:c.refresh_token?c.refresh_token:null},this.options.onTokenUpdate&&this.options.onTokenUpdate(this.token),this.token.accessToken}}},function(e,t,o){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0}),t.encode=function(e){return btoa(e)}},function(e,t,o){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0}),t.objToQueryString=function(e){return Object.entries(e).map(([e,t])=>void 0===t?\"\":encodeURIComponent(e)+\"=\"+encodeURIComponent(t)).join(\"&\")}}])}));\n//# sourceMappingURL=fetch-mw-oauth2.min.js.map"],"sourceRoot":""}