solid-auth-client.bundle.js.map

{"version":3,"sources":["webpack://solid.auth/webpack/universalModuleDefinition","webpack://solid.auth/webpack/bootstrap","webpack://solid.auth/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/index.js","webpack://solid.auth/./node_modules/base64url/index.js","webpack://solid.auth/./node_modules/@solid/jose/lib/index.js","webpack://solid.auth/./node_modules/buffer/index.js","webpack://solid.auth/(webpack)/buildin/global.js","webpack://solid.auth/external \"window\"","webpack://solid.auth/external \"fetch\"","webpack://solid.auth/external \"crypto\"","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/JWKSchema.js","webpack://solid.auth/./node_modules/assert/assert.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/JSONPointer.js","webpack://solid.auth/./node_modules/@solid/jose/lib/jose/JWA.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/FormUrlEncoded.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/onHttpError.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/index.js","webpack://solid.auth/./node_modules/auth-header/dist/util.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/RelyingParty.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/Formats.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/Initializer.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/JSONPatch.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/Validator.js","webpack://solid.auth/./node_modules/@solid/jose/lib/text-encoder/index.js","webpack://solid.auth/./node_modules/@solid/jose/lib/errors/NotSupportedError.js","webpack://solid.auth/./node_modules/@solid/jose/lib/errors/index.js","webpack://solid.auth/./node_modules/@solid/jose/lib/errors/DataError.js","webpack://solid.auth/./node_modules/@solid/jose/lib/jose/JWK.js","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/JWKSetSchema.js","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/JWTSchema.js","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/Base64URLSchema.js","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/JWTClaimsSetSchema.js","webpack://solid.auth/./node_modules/@solid/jose/lib/schemas/JOSEHeaderSchema.js","webpack://solid.auth/./node_modules/@solid/jose/lib/jose/JWS.js","webpack://solid.auth/./node_modules/events/events.js","webpack://solid.auth/./node_modules/@babel/runtime/helpers/objectWithoutProperties.js","webpack://solid.auth/./node_modules/auth-header/dist/index.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/lib/PoPToken.js","webpack://solid.auth/./node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","webpack://solid.auth/./node_modules/auth-header/dist/format.js","webpack://solid.auth/./node_modules/auth-header/dist/parse.js","webpack://solid.auth/./node_modules/object-assign/index.js","webpack://solid.auth/./node_modules/util/util.js","webpack://solid.auth/./node_modules/process/browser.js","webpack://solid.auth/./node_modules/util/support/isBufferBrowser.js","webpack://solid.auth/./node_modules/util/node_modules/inherits/inherits_browser.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/JSONDocument.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/JSONMapping.js","webpack://solid.auth/./node_modules/@trust/json-document/lib/JSONSchema.js","webpack://solid.auth/./node_modules/base64url/dist/base64url.js","webpack://solid.auth/./node_modules/base64-js/index.js","webpack://solid.auth/./node_modules/ieee754/index.js","webpack://solid.auth/./node_modules/isarray/index.js","webpack://solid.auth/./node_modules/base64url/dist/pad-string.js","webpack://solid.auth/./node_modules/@solid/jose/lib/algorithms/index.js","webpack://solid.auth/./node_modules/@solid/jose/lib/algorithms/NONE.js","webpack://solid.auth/./node_modules/@solid/jose/lib/algorithms/HMAC.js","webpack://solid.auth/external \"TextEncoder\"","webpack://solid.auth/./node_modules/@solid/jose/lib/algorithms/RSASSA-PKCS1-v1_5.js","webpack://solid.auth/./node_modules/@solid/jose/lib/algorithms/SupportedAlgorithms.js","webpack://solid.auth/./node_modules/@solid/jose/lib/formats/index.js","webpack://solid.auth/./node_modules/@solid/jose/lib/jose/JWKSet.js","webpack://solid.auth/./node_modules/@solid/jose/lib/jose/JWT.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/AuthenticationRequest.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/AuthenticationResponse.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/IDToken.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/IDTokenSchema.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/Session.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/PoPToken.js","webpack://solid.auth/./node_modules/standard-http-error/index.js","webpack://solid.auth/./node_modules/standard-error/index.js","webpack://solid.auth/./node_modules/@solid/oidc-rp/src/RelyingPartySchema.js","webpack://solid.auth/./src/url-util.js","webpack://solid.auth/./src/ipc.js","webpack://solid.auth/./src/storage.js","webpack://solid.auth/./src/session.js","webpack://solid.auth/./src/webid-oidc.js","webpack://solid.auth/./src/host.js","webpack://solid.auth/./src/authn-fetch.js","webpack://solid.auth/./src/popup.js","webpack://solid.auth/./src/solid-auth-client.js","webpack://solid.auth/./src/index.js"],"names":["root","factory","exports","module","require","define","amd","window","__WEBPACK_EXTERNAL_MODULE__6__","__WEBPACK_EXTERNAL_MODULE__7__","__WEBPACK_EXTERNAL_MODULE__8__","__WEBPACK_EXTERNAL_MODULE__56__","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","obj","configurable","writable","Formats","Initializer","JSONDocument","JSONMapping","JSONPatch","JSONPointer","JSONSchema","Validator","default","JWA","JWK","JWKSet","JWT","JWS","Base64URLSchema","JOSEHeaderSchema","JWKSchema","JWKSetSchema","JWTClaimsSetSchema","JWTSchema","base64","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","length","RangeError","Uint8Array","__proto__","arg","encodingOrOffset","this","Error","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","byteLength","undefined","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","slice","fromString","isBuffer","len","checked","copy","buffer","val","type","data","fromObject","assertSize","size","toString","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","push","charCodeAt","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","e","typedArraySupport","poolSize","_augment","species","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","ret","out","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","set","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","replace","stringtrim","base64clean","src","dst","g","Function","BASE64_REGEXP","properties","kty","enum","use","key_ops","items","alg","kid","x5u","x5c","x5t","objectAssign","util","hasOwn","pSlice","functionsHaveNames","pToString","arrbuf","DataView","assert","ok","regex","getName","func","isFunction","truncate","something","rawname","fail","expected","message","operator","stackStartFunction","AssertionError","_deepEqual","strict","memos","isDate","getTime","isRegExp","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","actualIndex","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","isArguments","bIsArgs","ka","objectKeys","kb","sort","objEquiv","expectedException","test","isPrototypeOf","_throws","shouldThrow","block","error","_tryBlock","userProvidedMessage","isUnexpectedException","isError","options","self","generatedMessage","captureStackTrace","err","stack","fn_name","idx","next_line","substring","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","keys","_createClass","defineProperties","props","descriptor","Constructor","protoProps","staticProps","THROW","expr","instance","_classCallCheck","tokens","charAt","parseURIFragmentIdentifier","parseJSONString","split","map","unescape","escape","decodeURIComponent","_this","token","encodeURIComponent","current","splice","supportedAlgorithms","NotSupportedError","normalizedAlgorithm","normalize","Promise","reject","sign","signature","verify","importKey","pairs","forEach","pair","response","status","errorMessage","statusText","statusCode","unquote","quote","isScheme","isToken","fetch","URL","Headers","AuthenticationRequest","AuthenticationResponse","RelyingPartySchema","onHttpError","FormUrlEncoded","RelyingParty","rp","validation","validate","valid","JSON","stringify","jwks","provider","importKeys","then","issuer","registration","url","defaults","assign","store","resolve","discover","register","pathname","json","configuration","registration_endpoint","uri","method","headers","params","body","serialize","jwks_uri","createRequest","session","validateResponse","redirect","authResponse","userinfo","userinfo_endpoint","access_token","logoutRequest","id_token_hint","post_logout_redirect_uri","state","end_session_endpoint","console","log","search","encode","href","logout","clearSession","credentials","SESSION_PRIVATE_KEY","popTokenFor","idToken","PoPToken","issueFor","DATETIME_REGEXP","URI_REGEXP","EMAIL_REGEXP","IPV4_REGEXP","IPV6_REGEXP","HOSTNAME_REGEXP","pattern","RegExp","format","formats","initialize","_typeof","iterator","constructor","schema","depth","level","declarations","member","item","declaration","index","additionalProperties","additionalItems","initializer","compile","_index","OPERATIONS","ops","operation","op","path","add","remove","pointer","indexCount","address","required","number","anyOf","allOf","not","oneOf","validations","keywords","filter","keyword","enumerated","conditions","subschema","validator","isRequired","segment","pop","patternValidations","additionalValidations","patternProperties","_schema","otherPropertiesCalled","otherProperties","minProperties","maxProperties","dependencies","dependency","_schema2","counter","minItems","maxItems","uniqueItems","minLength","maxLength","matcher","_schema3","minimum","exclusiveMinimum","_schema4","maximum","exclusiveMaximum","multipleOf","decimals","toFixed","TextEncoder","_Error","ReferenceError","_possibleConstructorReturn","subClass","superClass","setPrototypeOf","_inherits","DataError","_JSONDocument","jwk","segments","header","protected","unprotected","iv","aad","ciphertext","tag","recipients","encrypted_key","payload","signatures","verified","serialization","iss","aud","exp","nbf","iat","jti","typ","cty","jku","crit","enc","zip","_slicedToArray","_n","_d","_e","_s","_i","next","done","sliceIterator","base64url","jwt","_jwt$segments","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","args","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","EventEmitter","init","_events","_eventsCount","_maxListeners","defaultMaxListeners","$getMaxListeners","_addListener","listener","prepend","events","existing","warning","newListener","emit","unshift","warned","w","emitter","count","warn","_onceWrap","fired","wrapFn","wrapped","removeListener","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","setMaxListeners","getMaxListeners","doError","er","context","handler","listeners","addListener","on","prependListener","once","prependOnceListener","position","originalListener","shift","spliceOne","off","removeAllListeners","rawListeners","eventNames","objectWithoutPropertiesLoose","excluded","sourceSymbolKeys","propertyIsEnumerable","_format","_parse","_interopRequireDefault","_require2","_JWT","resourceServerUri","sessionKey","authorization","id_token","parse","importedSessionJwk","origin","client_id","issue","Date","now","token_type","cryptoKey","sourceKeys","_util","_toConsumableArray","arr2","_arrayWithoutHoles","iter","_iterableToArray","_nonIterableSpread","_arrayWithHoles","_iterableToArrayLimit","_nonIterableRest","build","reduce","prev","_ref","_ref2","values","transform","xxx","scheme","challenge","entries","_cur","cur","exec","parseProperties","propIsEnumerable","toObject","test1","test2","test3","letter","shouldUseNative","symbols","to","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","f","isString","objects","_","isNull","isObject","deprecate","fn","msg","process","noDeprecation","throwDeprecation","traceDeprecation","trace","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","primitive","simple","isNumber","formatPrimitive","visibleKeys","hash","arrayToHash","formatError","output","base","braces","toUTCString","formatProperty","formatArray","numLinesEst","reduceToSingleString","desc","line","ar","re","objectToString","pad","debuglog","env","NODE_DEBUG","toUpperCase","pid","isNullOrUndefined","isSymbol","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","kCustomPromisifiedSymbol","callbackifyOnRejected","reason","cb","newReason","promisify","original","promiseResolve","promiseReject","promise","custom","callbackify","callbackified","maybeCb","nextTick","rej","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","title","browser","argv","version","versions","binding","cwd","chdir","umask","ctor","superCtor","super_","TempCtor","alternate","patch","mapping","project","RECOVER","Map","right","left","_defineProperty","writeable","extender","result","pad_string_1","input","fromBase64","toBase64","decode","toBuffer","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","LN2","stringLength","diff","padLength","paddedStringLength","None","HMAC","RSASSA_PKCS1_v1_5","crypto","algorithm","subtle","bitlength","usages","operations","SupportedAlgorithms","argument","registeredAlgorithms","SyntaxError","imported","importing","all","find","isJWE","JWE","encrypt","startsWith","endpoint","client","authenticate","authorization_endpoint","scope","response_type","redirect_uri","getRandomValues","nonce","digest","digests","generateSessionKeys","sessionKeys","storeSessionKeys","request_parameter_supported","encodeRequestParams","encodedParams","generateKey","modulusLength","publicExponent","keyPair","exportKey","publicKey","privateKey","jwkPair","publicJwk","privateJwk","public","private","excludeParams","keysToEncode","requestParamCompact","request","IDToken","Session","HttpError","parseResponse","errorResponse","matchRequest","validateStateParam","validateResponseMode","validateResponseParams","exchangeAuthorizationCode","validateIDToken","fromAuthResponse","errorCode","errorParams","info","octets","encoded","expectedParams","id","secret","token_endpoint","bodyContents","authMethod","tokenResponse","decryptIDToken","decodeIDToken","validateIssuer","validateAudience","resolveKeys","verifySignature","validateExpires","verifyNonce","validateAcr","validateAuthTime","validateAccessTokenHash","validateAuthorizationCodeHash","decoded","decodeError","cause","azp","expectedAlgorithm","IDTokenSchema","extend","auth_time","acr","amr","credentialType","idClaims","accessClaims","popToken","refresh_token","hasCredentials","fetchWithCredentials","bearerTokenFor","DEFAULT_MAX_AGE","StandardError","STATUS_CODE_TO_NAME","STATUS_NAME_TO_CODE","alias","statusMessage","has","proto","display","getLocation","location","currentUrl","currentUrlNoParams","navigateTo","originOf","toUrlString","NAMESPACE","Server","clientWindow","clientOrigin","handle","_clientWindow","_clientOrigin","_handler","_messageListener","event","_handleMessage","req","postMessage","addEventListener","stop","removeEventListener","defaultStorage","storage","getItem","setItem","removeItem","asyncStorage","localStorage","memStorage","async","getData","serialized","updateStorage","update","newData","getSession","login","idp","getStoredRp","redirect_uris","callbackUri","clientNameI18n","supplementaryOptions","logo_uri","logoUri","contacts","client_name","clientName","grant_types","response_types","registerRp","rpConfig","storeRp","getRegisteredRp","appHashFragment","saveAppHashFragment","sendAuthRequest","currentSession","restoreAppHashFragment","storeData","webId","origHeaders","updateHostFromResponse","resp","wwwAuthHeader","auth","WebIdOidc","host","requiresAuth","hosts","saveHost","shouldShareCredentials","requestHost","getHost","obtainSession","popup","popupServer","popupUri","foundSessionCb","popupHandler","globalFetch","SolidAuthClient","authnFetch","defaultLoginOptions","screenX","innerWidth","top","screenY","innerHeight","settings","open","openIdpPopup","_pendingSession","saveSession","callback","stopTrackSession"],"mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,EAAQG,QAAQ,UAAWA,QAAQ,SAAUA,QAAQ,UAAWA,QAAQ,gBAChE,mBAAXC,QAAyBA,OAAOC,IAC9CD,OAAO,CAAC,SAAU,QAAS,SAAU,eAAgBJ,GAC3B,iBAAZC,QACdA,QAAc,KAAID,EAAQG,QAAQ,UAAWA,QAAQ,SAAUA,QAAQ,UAAWA,QAAQ,iBAE1FJ,EAAY,MAAIA,EAAY,OAAK,GAAIA,EAAY,MAAQ,KAAIC,EAAQD,EAAa,OAAGA,EAAY,MAAGA,EAAa,OAAGA,EAAkB,cARxI,CASGO,OAAQ,SAASC,EAAgCC,EAAgCC,EAAgCC,GACpH,O,YCTE,IAAIC,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUZ,QAGnC,IAAIC,EAASS,EAAiBE,GAAY,CACzCC,EAAGD,EACHE,GAAG,EACHd,QAAS,IAUV,OANAe,EAAQH,GAAUI,KAAKf,EAAOD,QAASC,EAAQA,EAAOD,QAASW,GAG/DV,EAAOa,GAAI,EAGJb,EAAOD,QA0Df,OArDAW,EAAoBM,EAAIF,EAGxBJ,EAAoBO,EAAIR,EAGxBC,EAAoBQ,EAAI,SAASnB,EAASoB,EAAMC,GAC3CV,EAAoBW,EAAEtB,EAASoB,IAClCG,OAAOC,eAAexB,EAASoB,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEV,EAAoBgB,EAAI,SAAS3B,GACX,oBAAX4B,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAexB,EAAS4B,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAexB,EAAS,aAAc,CAAE8B,OAAO,KAQvDnB,EAAoBoB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQnB,EAAoBmB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFAxB,EAAoBgB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOnB,EAAoBQ,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRvB,EAAoB2B,EAAI,SAASrC,GAChC,IAAIoB,EAASpB,GAAUA,EAAOgC,WAC7B,WAAwB,OAAOhC,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAU,EAAoBQ,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRV,EAAoBW,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG7B,EAAoBgC,EAAI,GAIjBhC,EAAoBA,EAAoBiC,EAAI,I,gBCnErD3C,EAAOD,QAfP,SAAyB6C,EAAKT,EAAKN,GAYjC,OAXIM,KAAOS,EACTtB,OAAOC,eAAeqB,EAAKT,EAAK,CAC9BN,MAAOA,EACPL,YAAY,EACZqB,cAAc,EACdC,UAAU,IAGZF,EAAIT,GAAON,EAGNe,I,6BCVT5C,EAAOD,QAAU,CACfgD,QAAS,EAAQ,IACjBC,YAAa,EAAQ,IACrBC,aAAc,EAAQ,IACtBC,YAAa,EAAQ,IACrBC,UAAW,EAAQ,IACnBC,YAAa,EAAQ,IACrBC,WAAY,EAAQ,IACpBC,UAAW,EAAQ,M,gBCVrBtD,EAAOD,QAAU,EAAQ,IAAoBwD,QAC7CvD,EAAOD,QAAQwD,QAAUvD,EAAOD,S,6BCIhC,IAAIyD,EAAM,EAAQ,IACdC,EAAM,EAAQ,IACdC,EAAS,EAAQ,IACjBC,EAAM,EAAQ,IACdC,EAAM,EAAQ,IACdC,EAAkB,EAAQ,IAC1BC,EAAmB,EAAQ,IAC3BC,EAAY,EAAQ,GACpBC,EAAe,EAAQ,IACvBC,EAAqB,EAAQ,IAC7BC,EAAY,EAAQ,IAKxBlE,EAAOD,QAAU,CACfyD,IAAKA,EACLC,IAAKA,EACLC,OAAQA,EACRC,IAAKA,EACLC,IAAKA,EACLC,gBAAiBA,EACjBC,iBAAkBA,EAClBC,UAAWA,EACXC,aAAcA,EACdC,mBAAoBA,EACpBC,UAAWA,I,8BC/Bb;;;;;;;AAUA,IAAIC,EAAS,EAAQ,IACjBC,EAAU,EAAQ,IAClBC,EAAU,EAAQ,IAmDtB,SAASC,IACP,OAAOC,EAAOC,oBACV,WACA,WAGN,SAASC,EAAcC,EAAMC,GAC3B,GAAIL,IAAeK,EACjB,MAAM,IAAIC,WAAW,8BAcvB,OAZIL,EAAOC,qBAETE,EAAO,IAAIG,WAAWF,IACjBG,UAAYP,EAAO/B,WAGX,OAATkC,IACFA,EAAO,IAAIH,EAAOI,IAEpBD,EAAKC,OAASA,GAGTD,EAaT,SAASH,EAAQQ,EAAKC,EAAkBL,GACtC,KAAKJ,EAAOC,qBAAyBS,gBAAgBV,GACnD,OAAO,IAAIA,EAAOQ,EAAKC,EAAkBL,GAI3C,GAAmB,iBAARI,EAAkB,CAC3B,GAAgC,iBAArBC,EACT,MAAM,IAAIE,MACR,qEAGJ,OAAOC,EAAYF,KAAMF,GAE3B,OAAOK,EAAKH,KAAMF,EAAKC,EAAkBL,GAW3C,SAASS,EAAMV,EAAM7C,EAAOmD,EAAkBL,GAC5C,GAAqB,iBAAV9C,EACT,MAAM,IAAIwD,UAAU,yCAGtB,MAA2B,oBAAhBC,aAA+BzD,aAAiByD,YA6H7D,SAA0BZ,EAAMa,EAAOC,EAAYb,GAGjD,GAFAY,EAAME,WAEFD,EAAa,GAAKD,EAAME,WAAaD,EACvC,MAAM,IAAIZ,WAAW,6BAGvB,GAAIW,EAAME,WAAaD,GAAcb,GAAU,GAC7C,MAAM,IAAIC,WAAW,6BAIrBW,OADiBG,IAAfF,QAAuCE,IAAXf,EACtB,IAAIE,WAAWU,QACHG,IAAXf,EACD,IAAIE,WAAWU,EAAOC,GAEtB,IAAIX,WAAWU,EAAOC,EAAYb,GAGxCJ,EAAOC,qBAETE,EAAOa,GACFT,UAAYP,EAAO/B,UAGxBkC,EAAOiB,EAAcjB,EAAMa,GAE7B,OAAOb,EAvJEkB,CAAgBlB,EAAM7C,EAAOmD,EAAkBL,GAGnC,iBAAV9C,EAwFb,SAAqB6C,EAAMmB,EAAQC,GACT,iBAAbA,GAAsC,KAAbA,IAClCA,EAAW,QAGb,IAAKvB,EAAOwB,WAAWD,GACrB,MAAM,IAAIT,UAAU,8CAGtB,IAAIV,EAAwC,EAA/Bc,EAAWI,EAAQC,GAG5BE,GAFJtB,EAAOD,EAAaC,EAAMC,IAERsB,MAAMJ,EAAQC,GAE5BE,IAAWrB,IAIbD,EAAOA,EAAKwB,MAAM,EAAGF,IAGvB,OAAOtB,EA5GEyB,CAAWzB,EAAM7C,EAAOmD,GAsJnC,SAAqBN,EAAM9B,GACzB,GAAI2B,EAAO6B,SAASxD,GAAM,CACxB,IAAIyD,EAA4B,EAAtBC,EAAQ1D,EAAI+B,QAGtB,OAAoB,KAFpBD,EAAOD,EAAaC,EAAM2B,IAEjB1B,OACAD,GAGT9B,EAAI2D,KAAK7B,EAAM,EAAG,EAAG2B,GACd3B,GAGT,GAAI9B,EAAK,CACP,GAA4B,oBAAhB0C,aACR1C,EAAI4D,kBAAkBlB,aAAgB,WAAY1C,EACpD,MAA0B,iBAAfA,EAAI+B,SA+8CL8B,EA/8CkC7D,EAAI+B,SAg9CrC8B,EA/8CFhC,EAAaC,EAAM,GAErBiB,EAAcjB,EAAM9B,GAG7B,GAAiB,WAAbA,EAAI8D,MAAqBrC,EAAQzB,EAAI+D,MACvC,OAAOhB,EAAcjB,EAAM9B,EAAI+D,MAw8CrC,IAAgBF,EAp8Cd,MAAM,IAAIpB,UAAU,sFA9KbuB,CAAWlC,EAAM7C,GA4B1B,SAASgF,EAAYC,GACnB,GAAoB,iBAATA,EACT,MAAM,IAAIzB,UAAU,oCACf,GAAIyB,EAAO,EAChB,MAAM,IAAIlC,WAAW,wCA4BzB,SAASO,EAAaT,EAAMoC,GAG1B,GAFAD,EAAWC,GACXpC,EAAOD,EAAaC,EAAMoC,EAAO,EAAI,EAAoB,EAAhBR,EAAQQ,KAC5CvC,EAAOC,oBACV,IAAK,IAAI5D,EAAI,EAAGA,EAAIkG,IAAQlG,EAC1B8D,EAAK9D,GAAK,EAGd,OAAO8D,EAwCT,SAASiB,EAAejB,EAAMa,GAC5B,IAAIZ,EAASY,EAAMZ,OAAS,EAAI,EAA4B,EAAxB2B,EAAQf,EAAMZ,QAClDD,EAAOD,EAAaC,EAAMC,GAC1B,IAAK,IAAI/D,EAAI,EAAGA,EAAI+D,EAAQ/D,GAAK,EAC/B8D,EAAK9D,GAAgB,IAAX2E,EAAM3E,GAElB,OAAO8D,EA+DT,SAAS4B,EAAS3B,GAGhB,GAAIA,GAAUL,IACZ,MAAM,IAAIM,WAAW,0DACaN,IAAayC,SAAS,IAAM,UAEhE,OAAgB,EAATpC,EAsFT,SAASc,EAAYI,EAAQC,GAC3B,GAAIvB,EAAO6B,SAASP,GAClB,OAAOA,EAAOlB,OAEhB,GAA2B,oBAAhBW,aAA6D,mBAAvBA,YAAY0B,SACxD1B,YAAY0B,OAAOnB,IAAWA,aAAkBP,aACnD,OAAOO,EAAOJ,WAEM,iBAAXI,IACTA,EAAS,GAAKA,GAGhB,IAAIQ,EAAMR,EAAOlB,OACjB,GAAY,IAAR0B,EAAW,OAAO,EAItB,IADA,IAAIY,GAAc,IAEhB,OAAQnB,GACN,IAAK,QACL,IAAK,SACL,IAAK,SACH,OAAOO,EACT,IAAK,OACL,IAAK,QACL,UAAKX,EACH,OAAOwB,EAAYrB,GAAQlB,OAC7B,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAa,EAAN0B,EACT,IAAK,MACH,OAAOA,IAAQ,EACjB,IAAK,SACH,OAAOc,EAActB,GAAQlB,OAC/B,QACE,GAAIsC,EAAa,OAAOC,EAAYrB,GAAQlB,OAC5CmB,GAAY,GAAKA,GAAUsB,cAC3BH,GAAc,GAMtB,SAASI,EAAcvB,EAAUwB,EAAOC,GACtC,IAAIN,GAAc,EAclB,SALcvB,IAAV4B,GAAuBA,EAAQ,KACjCA,EAAQ,GAINA,EAAQrC,KAAKN,OACf,MAAO,GAOT,SAJYe,IAAR6B,GAAqBA,EAAMtC,KAAKN,UAClC4C,EAAMtC,KAAKN,QAGT4C,GAAO,EACT,MAAO,GAOT,IAHAA,KAAS,KACTD,KAAW,GAGT,MAAO,GAKT,IAFKxB,IAAUA,EAAW,UAGxB,OAAQA,GACN,IAAK,MACH,OAAO0B,EAASvC,KAAMqC,EAAOC,GAE/B,IAAK,OACL,IAAK,QACH,OAAOE,EAAUxC,KAAMqC,EAAOC,GAEhC,IAAK,QACH,OAAOG,EAAWzC,KAAMqC,EAAOC,GAEjC,IAAK,SACL,IAAK,SACH,OAAOI,EAAY1C,KAAMqC,EAAOC,GAElC,IAAK,SACH,OAAOK,EAAY3C,KAAMqC,EAAOC,GAElC,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOM,EAAa5C,KAAMqC,EAAOC,GAEnC,QACE,GAAIN,EAAa,MAAM,IAAI5B,UAAU,qBAAuBS,GAC5DA,GAAYA,EAAW,IAAIsB,cAC3BH,GAAc,GAStB,SAASa,EAAMC,EAAG1F,EAAGrB,GACnB,IAAIJ,EAAImH,EAAE1F,GACV0F,EAAE1F,GAAK0F,EAAE/G,GACT+G,EAAE/G,GAAKJ,EAmIT,SAASoH,EAAsBxB,EAAQC,EAAKjB,EAAYM,EAAUmC,GAEhE,GAAsB,IAAlBzB,EAAO7B,OAAc,OAAQ,EAmBjC,GAhB0B,iBAAfa,GACTM,EAAWN,EACXA,EAAa,GACJA,EAAa,WACtBA,EAAa,WACJA,GAAc,aACvBA,GAAc,YAEhBA,GAAcA,EACV0C,MAAM1C,KAERA,EAAayC,EAAM,EAAKzB,EAAO7B,OAAS,GAItCa,EAAa,IAAGA,EAAagB,EAAO7B,OAASa,GAC7CA,GAAcgB,EAAO7B,OAAQ,CAC/B,GAAIsD,EAAK,OAAQ,EACZzC,EAAagB,EAAO7B,OAAS,OAC7B,GAAIa,EAAa,EAAG,CACzB,IAAIyC,EACC,OAAQ,EADJzC,EAAa,EAUxB,GALmB,iBAARiB,IACTA,EAAMlC,EAAOa,KAAKqB,EAAKX,IAIrBvB,EAAO6B,SAASK,GAElB,OAAmB,IAAfA,EAAI9B,QACE,EAEHwD,EAAa3B,EAAQC,EAAKjB,EAAYM,EAAUmC,GAClD,GAAmB,iBAARxB,EAEhB,OADAA,GAAY,IACRlC,EAAOC,qBACiC,mBAAjCK,WAAWrC,UAAU4F,QAC1BH,EACKpD,WAAWrC,UAAU4F,QAAQrH,KAAKyF,EAAQC,EAAKjB,GAE/CX,WAAWrC,UAAU6F,YAAYtH,KAAKyF,EAAQC,EAAKjB,GAGvD2C,EAAa3B,EAAQ,CAAEC,GAAOjB,EAAYM,EAAUmC,GAG7D,MAAM,IAAI5C,UAAU,wCAGtB,SAAS8C,EAAcG,EAAK7B,EAAKjB,EAAYM,EAAUmC,GACrD,IA0BIrH,EA1BA2H,EAAY,EACZC,EAAYF,EAAI3D,OAChB8D,EAAYhC,EAAI9B,OAEpB,QAAiBe,IAAbI,IAEe,UADjBA,EAAW4C,OAAO5C,GAAUsB,gBACY,UAAbtB,GACV,YAAbA,GAAuC,aAAbA,GAAyB,CACrD,GAAIwC,EAAI3D,OAAS,GAAK8B,EAAI9B,OAAS,EACjC,OAAQ,EAEV4D,EAAY,EACZC,GAAa,EACbC,GAAa,EACbjD,GAAc,EAIlB,SAASmD,EAAMC,EAAKhI,GAClB,OAAkB,IAAd2H,EACKK,EAAIhI,GAEJgI,EAAIC,aAAajI,EAAI2H,GAKhC,GAAIN,EAAK,CACP,IAAIa,GAAc,EAClB,IAAKlI,EAAI4E,EAAY5E,EAAI4H,EAAW5H,IAClC,GAAI+H,EAAKL,EAAK1H,KAAO+H,EAAKlC,GAAqB,IAAhBqC,EAAoB,EAAIlI,EAAIkI,IAEzD,IADoB,IAAhBA,IAAmBA,EAAalI,GAChCA,EAAIkI,EAAa,IAAML,EAAW,OAAOK,EAAaP,OAEtC,IAAhBO,IAAmBlI,GAAKA,EAAIkI,GAChCA,GAAc,OAKlB,IADItD,EAAaiD,EAAYD,IAAWhD,EAAagD,EAAYC,GAC5D7H,EAAI4E,EAAY5E,GAAK,EAAGA,IAAK,CAEhC,IADA,IAAImI,GAAQ,EACHC,EAAI,EAAGA,EAAIP,EAAWO,IAC7B,GAAIL,EAAKL,EAAK1H,EAAIoI,KAAOL,EAAKlC,EAAKuC,GAAI,CACrCD,GAAQ,EACR,MAGJ,GAAIA,EAAO,OAAOnI,EAItB,OAAQ,EAeV,SAASqI,EAAUL,EAAK/C,EAAQqD,EAAQvE,GACtCuE,EAASC,OAAOD,IAAW,EAC3B,IAAIE,EAAYR,EAAIjE,OAASuE,EACxBvE,GAGHA,EAASwE,OAAOxE,IACHyE,IACXzE,EAASyE,GAJXzE,EAASyE,EASX,IAAIC,EAASxD,EAAOlB,OACpB,GAAI0E,EAAS,GAAM,EAAG,MAAM,IAAIhE,UAAU,sBAEtCV,EAAS0E,EAAS,IACpB1E,EAAS0E,EAAS,GAEpB,IAAK,IAAIzI,EAAI,EAAGA,EAAI+D,IAAU/D,EAAG,CAC/B,IAAI0I,EAASC,SAAS1D,EAAO2D,OAAW,EAAJ5I,EAAO,GAAI,IAC/C,GAAIsH,MAAMoB,GAAS,OAAO1I,EAC1BgI,EAAIM,EAAStI,GAAK0I,EAEpB,OAAO1I,EAGT,SAAS6I,EAAWb,EAAK/C,EAAQqD,EAAQvE,GACvC,OAAO+E,EAAWxC,EAAYrB,EAAQ+C,EAAIjE,OAASuE,GAASN,EAAKM,EAAQvE,GAG3E,SAASgF,EAAYf,EAAK/C,EAAQqD,EAAQvE,GACxC,OAAO+E,EAq6BT,SAAuBE,GAErB,IADA,IAAIC,EAAY,GACPjJ,EAAI,EAAGA,EAAIgJ,EAAIjF,SAAU/D,EAEhCiJ,EAAUC,KAAyB,IAApBF,EAAIG,WAAWnJ,IAEhC,OAAOiJ,EA36BWG,CAAanE,GAAS+C,EAAKM,EAAQvE,GAGvD,SAASsF,EAAarB,EAAK/C,EAAQqD,EAAQvE,GACzC,OAAOgF,EAAWf,EAAK/C,EAAQqD,EAAQvE,GAGzC,SAASuF,EAAatB,EAAK/C,EAAQqD,EAAQvE,GACzC,OAAO+E,EAAWvC,EAActB,GAAS+C,EAAKM,EAAQvE,GAGxD,SAASwF,EAAWvB,EAAK/C,EAAQqD,EAAQvE,GACvC,OAAO+E,EAk6BT,SAAyBE,EAAKQ,GAG5B,IAFA,IAAInJ,EAAGoJ,EAAIC,EACPT,EAAY,GACPjJ,EAAI,EAAGA,EAAIgJ,EAAIjF,WACjByF,GAAS,GAAK,KADaxJ,EAGhCK,EAAI2I,EAAIG,WAAWnJ,GACnByJ,EAAKpJ,GAAK,EACVqJ,EAAKrJ,EAAI,IACT4I,EAAUC,KAAKQ,GACfT,EAAUC,KAAKO,GAGjB,OAAOR,EA/6BWU,CAAe1E,EAAQ+C,EAAIjE,OAASuE,GAASN,EAAKM,EAAQvE,GAkF9E,SAASiD,EAAagB,EAAKtB,EAAOC,GAChC,OAAc,IAAVD,GAAeC,IAAQqB,EAAIjE,OACtBR,EAAOqG,cAAc5B,GAErBzE,EAAOqG,cAAc5B,EAAI1C,MAAMoB,EAAOC,IAIjD,SAASE,EAAWmB,EAAKtB,EAAOC,GAC9BA,EAAMkD,KAAKC,IAAI9B,EAAIjE,OAAQ4C,GAI3B,IAHA,IAAIoD,EAAM,GAEN/J,EAAI0G,EACD1G,EAAI2G,GAAK,CACd,IAQMqD,EAAYC,EAAWC,EAAYC,EARrCC,EAAYpC,EAAIhI,GAChBqK,EAAY,KACZC,EAAoBF,EAAY,IAAQ,EACvCA,EAAY,IAAQ,EACpBA,EAAY,IAAQ,EACrB,EAEJ,GAAIpK,EAAIsK,GAAoB3D,EAG1B,OAAQ2D,GACN,KAAK,EACCF,EAAY,MACdC,EAAYD,GAEd,MACF,KAAK,EAEyB,MAAV,KADlBJ,EAAahC,EAAIhI,EAAI,OAEnBmK,GAA6B,GAAZC,IAAqB,EAAoB,GAAbJ,GACzB,MAClBK,EAAYF,GAGhB,MACF,KAAK,EACHH,EAAahC,EAAIhI,EAAI,GACrBiK,EAAYjC,EAAIhI,EAAI,GACQ,MAAV,IAAbgK,IAAsD,MAAV,IAAZC,KACnCE,GAA6B,GAAZC,IAAoB,IAAoB,GAAbJ,IAAsB,EAAmB,GAAZC,GACrD,OAAUE,EAAgB,OAAUA,EAAgB,SACtEE,EAAYF,GAGhB,MACF,KAAK,EACHH,EAAahC,EAAIhI,EAAI,GACrBiK,EAAYjC,EAAIhI,EAAI,GACpBkK,EAAalC,EAAIhI,EAAI,GACO,MAAV,IAAbgK,IAAsD,MAAV,IAAZC,IAAsD,MAAV,IAAbC,KAClEC,GAA6B,GAAZC,IAAoB,IAAqB,GAAbJ,IAAsB,IAAmB,GAAZC,IAAqB,EAAoB,GAAbC,GAClF,OAAUC,EAAgB,UAC5CE,EAAYF,GAMJ,OAAdE,GAGFA,EAAY,MACZC,EAAmB,GACVD,EAAY,QAErBA,GAAa,MACbN,EAAIb,KAAKmB,IAAc,GAAK,KAAQ,OACpCA,EAAY,MAAqB,KAAZA,GAGvBN,EAAIb,KAAKmB,GACTrK,GAAKsK,EAGP,OAQF,SAAgCC,GAC9B,IAAI9E,EAAM8E,EAAWxG,OACrB,GAAI0B,GAAO+E,EACT,OAAO1C,OAAO2C,aAAaC,MAAM5C,OAAQyC,GAI3C,IAAIR,EAAM,GACN/J,EAAI,EACR,KAAOA,EAAIyF,GACTsE,GAAOjC,OAAO2C,aAAaC,MACzB5C,OACAyC,EAAWjF,MAAMtF,EAAGA,GAAKwK,IAG7B,OAAOT,EAvBAY,CAAsBZ,GA98B/B5K,EAAQwE,OAASA,EACjBxE,EAAQyL,WAoTR,SAAqB7G,IACdA,GAAUA,IACbA,EAAS,GAEX,OAAOJ,EAAOkH,OAAO9G,IAvTvB5E,EAAQ2L,kBAAoB,GA0B5BnH,EAAOC,yBAAqDkB,IAA/BiG,EAAOnH,oBAChCmH,EAAOnH,oBAQX,WACE,IACE,IAAI8D,EAAM,IAAIzD,WAAW,GAEzB,OADAyD,EAAIxD,UAAY,CAACA,UAAWD,WAAWrC,UAAWoJ,IAAK,WAAc,OAAO,KACvD,KAAdtD,EAAIsD,OACiB,mBAAjBtD,EAAIuD,UACuB,IAAlCvD,EAAIuD,SAAS,EAAG,GAAGpG,WACvB,MAAOqG,GACP,OAAO,GAfPC,GAKJhM,EAAQuE,WAAaA,IAkErBC,EAAOyH,SAAW,KAGlBzH,EAAO0H,SAAW,SAAU3D,GAE1B,OADAA,EAAIxD,UAAYP,EAAO/B,UAChB8F,GA2BT/D,EAAOa,KAAO,SAAUvD,EAAOmD,EAAkBL,GAC/C,OAAOS,EAAK,KAAMvD,EAAOmD,EAAkBL,IAGzCJ,EAAOC,sBACTD,EAAO/B,UAAUsC,UAAYD,WAAWrC,UACxC+B,EAAOO,UAAYD,WACG,oBAAXlD,QAA0BA,OAAOuK,SACxC3H,EAAO5C,OAAOuK,WAAa3H,GAE7BjD,OAAOC,eAAegD,EAAQ5C,OAAOuK,QAAS,CAC5CrK,MAAO,KACPgB,cAAc,KAiCpB0B,EAAOkH,MAAQ,SAAU3E,EAAMqF,EAAMrG,GACnC,OArBF,SAAgBpB,EAAMoC,EAAMqF,EAAMrG,GAEhC,OADAe,EAAWC,GACPA,GAAQ,EACHrC,EAAaC,EAAMoC,QAEfpB,IAATyG,EAIyB,iBAAbrG,EACVrB,EAAaC,EAAMoC,GAAMqF,KAAKA,EAAMrG,GACpCrB,EAAaC,EAAMoC,GAAMqF,KAAKA,GAE7B1H,EAAaC,EAAMoC,GAQnB2E,CAAM,KAAM3E,EAAMqF,EAAMrG,IAiBjCvB,EAAOY,YAAc,SAAU2B,GAC7B,OAAO3B,EAAY,KAAM2B,IAK3BvC,EAAO6H,gBAAkB,SAAUtF,GACjC,OAAO3B,EAAY,KAAM2B,IAiH3BvC,EAAO6B,SAAW,SAAmB2B,GACnC,QAAe,MAALA,IAAaA,EAAEsE,YAG3B9H,EAAO+H,QAAU,SAAkBC,EAAGxE,GACpC,IAAKxD,EAAO6B,SAASmG,KAAOhI,EAAO6B,SAAS2B,GAC1C,MAAM,IAAI1C,UAAU,6BAGtB,GAAIkH,IAAMxE,EAAG,OAAO,EAKpB,IAHA,IAAIyE,EAAID,EAAE5H,OACN8H,EAAI1E,EAAEpD,OAED/D,EAAI,EAAGyF,EAAMoE,KAAKC,IAAI8B,EAAGC,GAAI7L,EAAIyF,IAAOzF,EAC/C,GAAI2L,EAAE3L,KAAOmH,EAAEnH,GAAI,CACjB4L,EAAID,EAAE3L,GACN6L,EAAI1E,EAAEnH,GACN,MAIJ,OAAI4L,EAAIC,GAAW,EACfA,EAAID,EAAU,EACX,GAGTjI,EAAOwB,WAAa,SAAqBD,GACvC,OAAQ4C,OAAO5C,GAAUsB,eACvB,IAAK,MACL,IAAK,OACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAO,EACT,QACE,OAAO,IAIb7C,EAAOmI,OAAS,SAAiBC,EAAMhI,GACrC,IAAKN,EAAQsI,GACX,MAAM,IAAItH,UAAU,+CAGtB,GAAoB,IAAhBsH,EAAKhI,OACP,OAAOJ,EAAOkH,MAAM,GAGtB,IAAI7K,EACJ,QAAe8E,IAAXf,EAEF,IADAA,EAAS,EACJ/D,EAAI,EAAGA,EAAI+L,EAAKhI,SAAU/D,EAC7B+D,GAAUgI,EAAK/L,GAAG+D,OAItB,IAAI6B,EAASjC,EAAOY,YAAYR,GAC5BiI,EAAM,EACV,IAAKhM,EAAI,EAAGA,EAAI+L,EAAKhI,SAAU/D,EAAG,CAChC,IAAIgI,EAAM+D,EAAK/L,GACf,IAAK2D,EAAO6B,SAASwC,GACnB,MAAM,IAAIvD,UAAU,+CAEtBuD,EAAIrC,KAAKC,EAAQoG,GACjBA,GAAOhE,EAAIjE,OAEb,OAAO6B,GA8CTjC,EAAOkB,WAAaA,EA0EpBlB,EAAO/B,UAAU6J,WAAY,EAQ7B9H,EAAO/B,UAAUqK,OAAS,WACxB,IAAIxG,EAAMpB,KAAKN,OACf,GAAI0B,EAAM,GAAM,EACd,MAAM,IAAIzB,WAAW,6CAEvB,IAAK,IAAIhE,EAAI,EAAGA,EAAIyF,EAAKzF,GAAK,EAC5BkH,EAAK7C,KAAMrE,EAAGA,EAAI,GAEpB,OAAOqE,MAGTV,EAAO/B,UAAUsK,OAAS,WACxB,IAAIzG,EAAMpB,KAAKN,OACf,GAAI0B,EAAM,GAAM,EACd,MAAM,IAAIzB,WAAW,6CAEvB,IAAK,IAAIhE,EAAI,EAAGA,EAAIyF,EAAKzF,GAAK,EAC5BkH,EAAK7C,KAAMrE,EAAGA,EAAI,GAClBkH,EAAK7C,KAAMrE,EAAI,EAAGA,EAAI,GAExB,OAAOqE,MAGTV,EAAO/B,UAAUuK,OAAS,WACxB,IAAI1G,EAAMpB,KAAKN,OACf,GAAI0B,EAAM,GAAM,EACd,MAAM,IAAIzB,WAAW,6CAEvB,IAAK,IAAIhE,EAAI,EAAGA,EAAIyF,EAAKzF,GAAK,EAC5BkH,EAAK7C,KAAMrE,EAAGA,EAAI,GAClBkH,EAAK7C,KAAMrE,EAAI,EAAGA,EAAI,GACtBkH,EAAK7C,KAAMrE,EAAI,EAAGA,EAAI,GACtBkH,EAAK7C,KAAMrE,EAAI,EAAGA,EAAI,GAExB,OAAOqE,MAGTV,EAAO/B,UAAUuE,SAAW,WAC1B,IAAIpC,EAAuB,EAAdM,KAAKN,OAClB,OAAe,IAAXA,EAAqB,GACA,IAArBqI,UAAUrI,OAAqB8C,EAAUxC,KAAM,EAAGN,GAC/C0C,EAAaiE,MAAMrG,KAAM+H,YAGlCzI,EAAO/B,UAAUyK,OAAS,SAAiBlF,GACzC,IAAKxD,EAAO6B,SAAS2B,GAAI,MAAM,IAAI1C,UAAU,6BAC7C,OAAIJ,OAAS8C,GACsB,IAA5BxD,EAAO+H,QAAQrH,KAAM8C,IAG9BxD,EAAO/B,UAAU0K,QAAU,WACzB,IAAItD,EAAM,GACNuD,EAAMpN,EAAQ2L,kBAKlB,OAJIzG,KAAKN,OAAS,IAChBiF,EAAM3E,KAAK8B,SAAS,MAAO,EAAGoG,GAAKC,MAAM,SAASC,KAAK,KACnDpI,KAAKN,OAASwI,IAAKvD,GAAO,UAEzB,WAAaA,EAAM,KAG5BrF,EAAO/B,UAAU8J,QAAU,SAAkBgB,EAAQhG,EAAOC,EAAKgG,EAAWC,GAC1E,IAAKjJ,EAAO6B,SAASkH,GACnB,MAAM,IAAIjI,UAAU,6BAgBtB,QAbcK,IAAV4B,IACFA,EAAQ,QAEE5B,IAAR6B,IACFA,EAAM+F,EAASA,EAAO3I,OAAS,QAEfe,IAAd6H,IACFA,EAAY,QAEE7H,IAAZ8H,IACFA,EAAUvI,KAAKN,QAGb2C,EAAQ,GAAKC,EAAM+F,EAAO3I,QAAU4I,EAAY,GAAKC,EAAUvI,KAAKN,OACtE,MAAM,IAAIC,WAAW,sBAGvB,GAAI2I,GAAaC,GAAWlG,GAASC,EACnC,OAAO,EAET,GAAIgG,GAAaC,EACf,OAAQ,EAEV,GAAIlG,GAASC,EACX,OAAO,EAQT,GAAItC,OAASqI,EAAQ,OAAO,EAS5B,IAPA,IAAId,GAJJgB,KAAa,IADbD,KAAe,GAMXd,GAPJlF,KAAS,IADTD,KAAW,GASPjB,EAAMoE,KAAKC,IAAI8B,EAAGC,GAElBgB,EAAWxI,KAAKiB,MAAMqH,EAAWC,GACjCE,EAAaJ,EAAOpH,MAAMoB,EAAOC,GAE5B3G,EAAI,EAAGA,EAAIyF,IAAOzF,EACzB,GAAI6M,EAAS7M,KAAO8M,EAAW9M,GAAI,CACjC4L,EAAIiB,EAAS7M,GACb6L,EAAIiB,EAAW9M,GACf,MAIJ,OAAI4L,EAAIC,GAAW,EACfA,EAAID,EAAU,EACX,GA6HTjI,EAAO/B,UAAUmL,SAAW,SAAmBlH,EAAKjB,EAAYM,GAC9D,OAAoD,IAA7Cb,KAAKmD,QAAQ3B,EAAKjB,EAAYM,IAGvCvB,EAAO/B,UAAU4F,QAAU,SAAkB3B,EAAKjB,EAAYM,GAC5D,OAAOkC,EAAqB/C,KAAMwB,EAAKjB,EAAYM,GAAU,IAG/DvB,EAAO/B,UAAU6F,YAAc,SAAsB5B,EAAKjB,EAAYM,GACpE,OAAOkC,EAAqB/C,KAAMwB,EAAKjB,EAAYM,GAAU,IAkD/DvB,EAAO/B,UAAUyD,MAAQ,SAAgBJ,EAAQqD,EAAQvE,EAAQmB,GAE/D,QAAeJ,IAAXwD,EACFpD,EAAW,OACXnB,EAASM,KAAKN,OACduE,EAAS,OAEJ,QAAexD,IAAXf,GAA0C,iBAAXuE,EACxCpD,EAAWoD,EACXvE,EAASM,KAAKN,OACduE,EAAS,MAEJ,KAAI0E,SAAS1E,GAWlB,MAAM,IAAIhE,MACR,2EAXFgE,GAAkB,EACd0E,SAASjJ,IACXA,GAAkB,OACDe,IAAbI,IAAwBA,EAAW,UAEvCA,EAAWnB,EACXA,OAASe,GASb,IAAI0D,EAAYnE,KAAKN,OAASuE,EAG9B,SAFexD,IAAXf,GAAwBA,EAASyE,KAAWzE,EAASyE,GAEpDvD,EAAOlB,OAAS,IAAMA,EAAS,GAAKuE,EAAS,IAAOA,EAASjE,KAAKN,OACrE,MAAM,IAAIC,WAAW,0CAGlBkB,IAAUA,EAAW,QAG1B,IADA,IAAImB,GAAc,IAEhB,OAAQnB,GACN,IAAK,MACH,OAAOmD,EAAShE,KAAMY,EAAQqD,EAAQvE,GAExC,IAAK,OACL,IAAK,QACH,OAAO8E,EAAUxE,KAAMY,EAAQqD,EAAQvE,GAEzC,IAAK,QACH,OAAOgF,EAAW1E,KAAMY,EAAQqD,EAAQvE,GAE1C,IAAK,SACL,IAAK,SACH,OAAOsF,EAAYhF,KAAMY,EAAQqD,EAAQvE,GAE3C,IAAK,SAEH,OAAOuF,EAAYjF,KAAMY,EAAQqD,EAAQvE,GAE3C,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOwF,EAAUlF,KAAMY,EAAQqD,EAAQvE,GAEzC,QACE,GAAIsC,EAAa,MAAM,IAAI5B,UAAU,qBAAuBS,GAC5DA,GAAY,GAAKA,GAAUsB,cAC3BH,GAAc,IAKtB1C,EAAO/B,UAAUqL,OAAS,WACxB,MAAO,CACLnH,KAAM,SACNC,KAAMmH,MAAMtL,UAAU0D,MAAMnF,KAAKkE,KAAK8I,MAAQ9I,KAAM,KAwFxD,IAAImG,EAAuB,KAoB3B,SAAS1D,EAAYkB,EAAKtB,EAAOC,GAC/B,IAAIyG,EAAM,GACVzG,EAAMkD,KAAKC,IAAI9B,EAAIjE,OAAQ4C,GAE3B,IAAK,IAAI3G,EAAI0G,EAAO1G,EAAI2G,IAAO3G,EAC7BoN,GAAOtF,OAAO2C,aAAsB,IAATzC,EAAIhI,IAEjC,OAAOoN,EAGT,SAASrG,EAAaiB,EAAKtB,EAAOC,GAChC,IAAIyG,EAAM,GACVzG,EAAMkD,KAAKC,IAAI9B,EAAIjE,OAAQ4C,GAE3B,IAAK,IAAI3G,EAAI0G,EAAO1G,EAAI2G,IAAO3G,EAC7BoN,GAAOtF,OAAO2C,aAAazC,EAAIhI,IAEjC,OAAOoN,EAGT,SAASxG,EAAUoB,EAAKtB,EAAOC,GAC7B,IAAIlB,EAAMuC,EAAIjE,SAET2C,GAASA,EAAQ,KAAGA,EAAQ,KAC5BC,GAAOA,EAAM,GAAKA,EAAMlB,KAAKkB,EAAMlB,GAGxC,IADA,IAAI4H,EAAM,GACDrN,EAAI0G,EAAO1G,EAAI2G,IAAO3G,EAC7BqN,GAAOC,EAAMtF,EAAIhI,IAEnB,OAAOqN,EAGT,SAASpG,EAAce,EAAKtB,EAAOC,GAGjC,IAFA,IAAI4G,EAAQvF,EAAI1C,MAAMoB,EAAOC,GACzBoD,EAAM,GACD/J,EAAI,EAAGA,EAAIuN,EAAMxJ,OAAQ/D,GAAK,EACrC+J,GAAOjC,OAAO2C,aAAa8C,EAAMvN,GAAoB,IAAfuN,EAAMvN,EAAI,IAElD,OAAO+J,EA0CT,SAASyD,EAAalF,EAAQmF,EAAK1J,GACjC,GAAKuE,EAAS,GAAO,GAAKA,EAAS,EAAG,MAAM,IAAItE,WAAW,sBAC3D,GAAIsE,EAASmF,EAAM1J,EAAQ,MAAM,IAAIC,WAAW,yCA+JlD,SAAS0J,EAAU1F,EAAK/G,EAAOqH,EAAQmF,EAAKlB,EAAKzC,GAC/C,IAAKnG,EAAO6B,SAASwC,GAAM,MAAM,IAAIvD,UAAU,+CAC/C,GAAIxD,EAAQsL,GAAOtL,EAAQ6I,EAAK,MAAM,IAAI9F,WAAW,qCACrD,GAAIsE,EAASmF,EAAMzF,EAAIjE,OAAQ,MAAM,IAAIC,WAAW,sBAkDtD,SAAS2J,EAAmB3F,EAAK/G,EAAOqH,EAAQsF,GAC1C3M,EAAQ,IAAGA,EAAQ,MAASA,EAAQ,GACxC,IAAK,IAAIjB,EAAI,EAAGoI,EAAIyB,KAAKC,IAAI9B,EAAIjE,OAASuE,EAAQ,GAAItI,EAAIoI,IAAKpI,EAC7DgI,EAAIM,EAAStI,IAAMiB,EAAS,KAAS,GAAK2M,EAAe5N,EAAI,EAAIA,MAClC,GAA5B4N,EAAe5N,EAAI,EAAIA,GA8B9B,SAAS6N,EAAmB7F,EAAK/G,EAAOqH,EAAQsF,GAC1C3M,EAAQ,IAAGA,EAAQ,WAAaA,EAAQ,GAC5C,IAAK,IAAIjB,EAAI,EAAGoI,EAAIyB,KAAKC,IAAI9B,EAAIjE,OAASuE,EAAQ,GAAItI,EAAIoI,IAAKpI,EAC7DgI,EAAIM,EAAStI,GAAMiB,IAAuC,GAA5B2M,EAAe5N,EAAI,EAAIA,GAAU,IAmJnE,SAAS8N,EAAc9F,EAAK/G,EAAOqH,EAAQmF,EAAKlB,EAAKzC,GACnD,GAAIxB,EAASmF,EAAMzF,EAAIjE,OAAQ,MAAM,IAAIC,WAAW,sBACpD,GAAIsE,EAAS,EAAG,MAAM,IAAItE,WAAW,sBAGvC,SAAS+J,EAAY/F,EAAK/G,EAAOqH,EAAQsF,EAAcI,GAKrD,OAJKA,GACHF,EAAa9F,EAAK/G,EAAOqH,EAAQ,GAEnC9E,EAAQ6B,MAAM2C,EAAK/G,EAAOqH,EAAQsF,EAAc,GAAI,GAC7CtF,EAAS,EAWlB,SAAS2F,EAAajG,EAAK/G,EAAOqH,EAAQsF,EAAcI,GAKtD,OAJKA,GACHF,EAAa9F,EAAK/G,EAAOqH,EAAQ,GAEnC9E,EAAQ6B,MAAM2C,EAAK/G,EAAOqH,EAAQsF,EAAc,GAAI,GAC7CtF,EAAS,EA/clB3E,EAAO/B,UAAU0D,MAAQ,SAAgBoB,EAAOC,GAC9C,IAoBIuH,EApBAzI,EAAMpB,KAAKN,OAqBf,IApBA2C,IAAUA,GAGE,GACVA,GAASjB,GACG,IAAGiB,EAAQ,GACdA,EAAQjB,IACjBiB,EAAQjB,IANVkB,OAAc7B,IAAR6B,EAAoBlB,IAAQkB,GASxB,GACRA,GAAOlB,GACG,IAAGkB,EAAM,GACVA,EAAMlB,IACfkB,EAAMlB,GAGJkB,EAAMD,IAAOC,EAAMD,GAGnB/C,EAAOC,qBACTsK,EAAS7J,KAAK4G,SAASvE,EAAOC,IACvBzC,UAAYP,EAAO/B,cACrB,CACL,IAAIuM,EAAWxH,EAAMD,EACrBwH,EAAS,IAAIvK,EAAOwK,OAAUrJ,GAC9B,IAAK,IAAI9E,EAAI,EAAGA,EAAImO,IAAYnO,EAC9BkO,EAAOlO,GAAKqE,KAAKrE,EAAI0G,GAIzB,OAAOwH,GAWTvK,EAAO/B,UAAUwM,WAAa,SAAqB9F,EAAQzD,EAAYmJ,GACrE1F,GAAkB,EAClBzD,GAA0B,EACrBmJ,GAAUR,EAAYlF,EAAQzD,EAAYR,KAAKN,QAKpD,IAHA,IAAI8B,EAAMxB,KAAKiE,GACX+F,EAAM,EACNrO,EAAI,IACCA,EAAI6E,IAAewJ,GAAO,MACjCxI,GAAOxB,KAAKiE,EAAStI,GAAKqO,EAG5B,OAAOxI,GAGTlC,EAAO/B,UAAU0M,WAAa,SAAqBhG,EAAQzD,EAAYmJ,GACrE1F,GAAkB,EAClBzD,GAA0B,EACrBmJ,GACHR,EAAYlF,EAAQzD,EAAYR,KAAKN,QAKvC,IAFA,IAAI8B,EAAMxB,KAAKiE,IAAWzD,GACtBwJ,EAAM,EACHxJ,EAAa,IAAMwJ,GAAO,MAC/BxI,GAAOxB,KAAKiE,IAAWzD,GAAcwJ,EAGvC,OAAOxI,GAGTlC,EAAO/B,UAAU2M,UAAY,SAAoBjG,EAAQ0F,GAEvD,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCM,KAAKiE,IAGd3E,EAAO/B,UAAU4M,aAAe,SAAuBlG,EAAQ0F,GAE7D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCM,KAAKiE,GAAWjE,KAAKiE,EAAS,IAAM,GAG7C3E,EAAO/B,UAAUqG,aAAe,SAAuBK,EAAQ0F,GAE7D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACnCM,KAAKiE,IAAW,EAAKjE,KAAKiE,EAAS,IAG7C3E,EAAO/B,UAAU6M,aAAe,SAAuBnG,EAAQ0F,GAG7D,OAFKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,SAElCM,KAAKiE,GACTjE,KAAKiE,EAAS,IAAM,EACpBjE,KAAKiE,EAAS,IAAM,IACD,SAAnBjE,KAAKiE,EAAS,IAGrB3E,EAAO/B,UAAU8M,aAAe,SAAuBpG,EAAQ0F,GAG7D,OAFKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QAEpB,SAAfM,KAAKiE,IACTjE,KAAKiE,EAAS,IAAM,GACrBjE,KAAKiE,EAAS,IAAM,EACrBjE,KAAKiE,EAAS,KAGlB3E,EAAO/B,UAAU+M,UAAY,SAAoBrG,EAAQzD,EAAYmJ,GACnE1F,GAAkB,EAClBzD,GAA0B,EACrBmJ,GAAUR,EAAYlF,EAAQzD,EAAYR,KAAKN,QAKpD,IAHA,IAAI8B,EAAMxB,KAAKiE,GACX+F,EAAM,EACNrO,EAAI,IACCA,EAAI6E,IAAewJ,GAAO,MACjCxI,GAAOxB,KAAKiE,EAAStI,GAAKqO,EAM5B,OAFIxI,IAFJwI,GAAO,OAESxI,GAAOgE,KAAK+E,IAAI,EAAG,EAAI/J,IAEhCgB,GAGTlC,EAAO/B,UAAUiN,UAAY,SAAoBvG,EAAQzD,EAAYmJ,GACnE1F,GAAkB,EAClBzD,GAA0B,EACrBmJ,GAAUR,EAAYlF,EAAQzD,EAAYR,KAAKN,QAKpD,IAHA,IAAI/D,EAAI6E,EACJwJ,EAAM,EACNxI,EAAMxB,KAAKiE,IAAWtI,GACnBA,EAAI,IAAMqO,GAAO,MACtBxI,GAAOxB,KAAKiE,IAAWtI,GAAKqO,EAM9B,OAFIxI,IAFJwI,GAAO,OAESxI,GAAOgE,KAAK+E,IAAI,EAAG,EAAI/J,IAEhCgB,GAGTlC,EAAO/B,UAAUkN,SAAW,SAAmBxG,EAAQ0F,GAErD,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACtB,IAAfM,KAAKiE,IAC0B,GAA5B,IAAOjE,KAAKiE,GAAU,GADKjE,KAAKiE,IAI3C3E,EAAO/B,UAAUmN,YAAc,SAAsBzG,EAAQ0F,GACtDA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QAC3C,IAAI8B,EAAMxB,KAAKiE,GAAWjE,KAAKiE,EAAS,IAAM,EAC9C,OAAc,MAANzC,EAAsB,WAANA,EAAmBA,GAG7ClC,EAAO/B,UAAUoN,YAAc,SAAsB1G,EAAQ0F,GACtDA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QAC3C,IAAI8B,EAAMxB,KAAKiE,EAAS,GAAMjE,KAAKiE,IAAW,EAC9C,OAAc,MAANzC,EAAsB,WAANA,EAAmBA,GAG7ClC,EAAO/B,UAAUqN,YAAc,SAAsB3G,EAAQ0F,GAG3D,OAFKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QAEnCM,KAAKiE,GACVjE,KAAKiE,EAAS,IAAM,EACpBjE,KAAKiE,EAAS,IAAM,GACpBjE,KAAKiE,EAAS,IAAM,IAGzB3E,EAAO/B,UAAUsN,YAAc,SAAsB5G,EAAQ0F,GAG3D,OAFKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QAEnCM,KAAKiE,IAAW,GACrBjE,KAAKiE,EAAS,IAAM,GACpBjE,KAAKiE,EAAS,IAAM,EACpBjE,KAAKiE,EAAS,IAGnB3E,EAAO/B,UAAUuN,YAAc,SAAsB7G,EAAQ0F,GAE3D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCP,EAAQuE,KAAK1D,KAAMiE,GAAQ,EAAM,GAAI,IAG9C3E,EAAO/B,UAAUwN,YAAc,SAAsB9G,EAAQ0F,GAE3D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCP,EAAQuE,KAAK1D,KAAMiE,GAAQ,EAAO,GAAI,IAG/C3E,EAAO/B,UAAUyN,aAAe,SAAuB/G,EAAQ0F,GAE7D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCP,EAAQuE,KAAK1D,KAAMiE,GAAQ,EAAM,GAAI,IAG9C3E,EAAO/B,UAAU0N,aAAe,SAAuBhH,EAAQ0F,GAE7D,OADKA,GAAUR,EAAYlF,EAAQ,EAAGjE,KAAKN,QACpCP,EAAQuE,KAAK1D,KAAMiE,GAAQ,EAAO,GAAI,IAS/C3E,EAAO/B,UAAU2N,YAAc,SAAsBtO,EAAOqH,EAAQzD,EAAYmJ,IAC9E/M,GAASA,EACTqH,GAAkB,EAClBzD,GAA0B,EACrBmJ,IAEHN,EAASrJ,KAAMpD,EAAOqH,EAAQzD,EADfgF,KAAK+E,IAAI,EAAG,EAAI/J,GAAc,EACO,GAGtD,IAAIwJ,EAAM,EACNrO,EAAI,EAER,IADAqE,KAAKiE,GAAkB,IAARrH,IACNjB,EAAI6E,IAAewJ,GAAO,MACjChK,KAAKiE,EAAStI,GAAMiB,EAAQoN,EAAO,IAGrC,OAAO/F,EAASzD,GAGlBlB,EAAO/B,UAAU4N,YAAc,SAAsBvO,EAAOqH,EAAQzD,EAAYmJ,IAC9E/M,GAASA,EACTqH,GAAkB,EAClBzD,GAA0B,EACrBmJ,IAEHN,EAASrJ,KAAMpD,EAAOqH,EAAQzD,EADfgF,KAAK+E,IAAI,EAAG,EAAI/J,GAAc,EACO,GAGtD,IAAI7E,EAAI6E,EAAa,EACjBwJ,EAAM,EAEV,IADAhK,KAAKiE,EAAStI,GAAa,IAARiB,IACVjB,GAAK,IAAMqO,GAAO,MACzBhK,KAAKiE,EAAStI,GAAMiB,EAAQoN,EAAO,IAGrC,OAAO/F,EAASzD,GAGlBlB,EAAO/B,UAAU6N,WAAa,SAAqBxO,EAAOqH,EAAQ0F,GAMhE,OALA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,IAAM,GACjD3E,EAAOC,sBAAqB3C,EAAQ4I,KAAK6F,MAAMzO,IACpDoD,KAAKiE,GAAmB,IAARrH,EACTqH,EAAS,GAWlB3E,EAAO/B,UAAU+N,cAAgB,SAAwB1O,EAAOqH,EAAQ0F,GAUtE,OATA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,MAAQ,GACpD3E,EAAOC,qBACTS,KAAKiE,GAAmB,IAARrH,EAChBoD,KAAKiE,EAAS,GAAMrH,IAAU,GAE9B0M,EAAkBtJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAUgO,cAAgB,SAAwB3O,EAAOqH,EAAQ0F,GAUtE,OATA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,MAAQ,GACpD3E,EAAOC,qBACTS,KAAKiE,GAAWrH,IAAU,EAC1BoD,KAAKiE,EAAS,GAAc,IAARrH,GAEpB0M,EAAkBtJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAUlB3E,EAAO/B,UAAUiO,cAAgB,SAAwB5O,EAAOqH,EAAQ0F,GAYtE,OAXA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,WAAY,GACxD3E,EAAOC,qBACTS,KAAKiE,EAAS,GAAMrH,IAAU,GAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,GAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,EAC9BoD,KAAKiE,GAAmB,IAARrH,GAEhB4M,EAAkBxJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAUkO,cAAgB,SAAwB7O,EAAOqH,EAAQ0F,GAYtE,OAXA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,WAAY,GACxD3E,EAAOC,qBACTS,KAAKiE,GAAWrH,IAAU,GAC1BoD,KAAKiE,EAAS,GAAMrH,IAAU,GAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,EAC9BoD,KAAKiE,EAAS,GAAc,IAARrH,GAEpB4M,EAAkBxJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAUmO,WAAa,SAAqB9O,EAAOqH,EAAQzD,EAAYmJ,GAG5E,GAFA/M,GAASA,EACTqH,GAAkB,GACb0F,EAAU,CACb,IAAIgC,EAAQnG,KAAK+E,IAAI,EAAG,EAAI/J,EAAa,GAEzC6I,EAASrJ,KAAMpD,EAAOqH,EAAQzD,EAAYmL,EAAQ,GAAIA,GAGxD,IAAIhQ,EAAI,EACJqO,EAAM,EACN4B,EAAM,EAEV,IADA5L,KAAKiE,GAAkB,IAARrH,IACNjB,EAAI6E,IAAewJ,GAAO,MAC7BpN,EAAQ,GAAa,IAARgP,GAAsC,IAAzB5L,KAAKiE,EAAStI,EAAI,KAC9CiQ,EAAM,GAER5L,KAAKiE,EAAStI,IAAOiB,EAAQoN,GAAQ,GAAK4B,EAAM,IAGlD,OAAO3H,EAASzD,GAGlBlB,EAAO/B,UAAUsO,WAAa,SAAqBjP,EAAOqH,EAAQzD,EAAYmJ,GAG5E,GAFA/M,GAASA,EACTqH,GAAkB,GACb0F,EAAU,CACb,IAAIgC,EAAQnG,KAAK+E,IAAI,EAAG,EAAI/J,EAAa,GAEzC6I,EAASrJ,KAAMpD,EAAOqH,EAAQzD,EAAYmL,EAAQ,GAAIA,GAGxD,IAAIhQ,EAAI6E,EAAa,EACjBwJ,EAAM,EACN4B,EAAM,EAEV,IADA5L,KAAKiE,EAAStI,GAAa,IAARiB,IACVjB,GAAK,IAAMqO,GAAO,MACrBpN,EAAQ,GAAa,IAARgP,GAAsC,IAAzB5L,KAAKiE,EAAStI,EAAI,KAC9CiQ,EAAM,GAER5L,KAAKiE,EAAStI,IAAOiB,EAAQoN,GAAQ,GAAK4B,EAAM,IAGlD,OAAO3H,EAASzD,GAGlBlB,EAAO/B,UAAUuO,UAAY,SAAoBlP,EAAOqH,EAAQ0F,GAO9D,OANA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,KAAO,KAClD3E,EAAOC,sBAAqB3C,EAAQ4I,KAAK6F,MAAMzO,IAChDA,EAAQ,IAAGA,EAAQ,IAAOA,EAAQ,GACtCoD,KAAKiE,GAAmB,IAARrH,EACTqH,EAAS,GAGlB3E,EAAO/B,UAAUwO,aAAe,SAAuBnP,EAAOqH,EAAQ0F,GAUpE,OATA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,OAAS,OACrD3E,EAAOC,qBACTS,KAAKiE,GAAmB,IAARrH,EAChBoD,KAAKiE,EAAS,GAAMrH,IAAU,GAE9B0M,EAAkBtJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAUyO,aAAe,SAAuBpP,EAAOqH,EAAQ0F,GAUpE,OATA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,OAAS,OACrD3E,EAAOC,qBACTS,KAAKiE,GAAWrH,IAAU,EAC1BoD,KAAKiE,EAAS,GAAc,IAARrH,GAEpB0M,EAAkBtJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAU0O,aAAe,SAAuBrP,EAAOqH,EAAQ0F,GAYpE,OAXA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,YAAa,YACzD3E,EAAOC,qBACTS,KAAKiE,GAAmB,IAARrH,EAChBoD,KAAKiE,EAAS,GAAMrH,IAAU,EAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,GAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,IAE9B4M,EAAkBxJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAGlB3E,EAAO/B,UAAU2O,aAAe,SAAuBtP,EAAOqH,EAAQ0F,GAapE,OAZA/M,GAASA,EACTqH,GAAkB,EACb0F,GAAUN,EAASrJ,KAAMpD,EAAOqH,EAAQ,EAAG,YAAa,YACzDrH,EAAQ,IAAGA,EAAQ,WAAaA,EAAQ,GACxC0C,EAAOC,qBACTS,KAAKiE,GAAWrH,IAAU,GAC1BoD,KAAKiE,EAAS,GAAMrH,IAAU,GAC9BoD,KAAKiE,EAAS,GAAMrH,IAAU,EAC9BoD,KAAKiE,EAAS,GAAc,IAARrH,GAEpB4M,EAAkBxJ,KAAMpD,EAAOqH,GAAQ,GAElCA,EAAS,GAgBlB3E,EAAO/B,UAAU4O,aAAe,SAAuBvP,EAAOqH,EAAQ0F,GACpE,OAAOD,EAAW1J,KAAMpD,EAAOqH,GAAQ,EAAM0F,IAG/CrK,EAAO/B,UAAU6O,aAAe,SAAuBxP,EAAOqH,EAAQ0F,GACpE,OAAOD,EAAW1J,KAAMpD,EAAOqH,GAAQ,EAAO0F,IAWhDrK,EAAO/B,UAAU8O,cAAgB,SAAwBzP,EAAOqH,EAAQ0F,GACtE,OAAOC,EAAY5J,KAAMpD,EAAOqH,GAAQ,EAAM0F,IAGhDrK,EAAO/B,UAAU+O,cAAgB,SAAwB1P,EAAOqH,EAAQ0F,GACtE,OAAOC,EAAY5J,KAAMpD,EAAOqH,GAAQ,EAAO0F,IAIjDrK,EAAO/B,UAAU+D,KAAO,SAAe+G,EAAQkE,EAAalK,EAAOC,GAQjE,GAPKD,IAAOA,EAAQ,GACfC,GAAe,IAARA,IAAWA,EAAMtC,KAAKN,QAC9B6M,GAAelE,EAAO3I,SAAQ6M,EAAclE,EAAO3I,QAClD6M,IAAaA,EAAc,GAC5BjK,EAAM,GAAKA,EAAMD,IAAOC,EAAMD,GAG9BC,IAAQD,EAAO,OAAO,EAC1B,GAAsB,IAAlBgG,EAAO3I,QAAgC,IAAhBM,KAAKN,OAAc,OAAO,EAGrD,GAAI6M,EAAc,EAChB,MAAM,IAAI5M,WAAW,6BAEvB,GAAI0C,EAAQ,GAAKA,GAASrC,KAAKN,OAAQ,MAAM,IAAIC,WAAW,6BAC5D,GAAI2C,EAAM,EAAG,MAAM,IAAI3C,WAAW,2BAG9B2C,EAAMtC,KAAKN,SAAQ4C,EAAMtC,KAAKN,QAC9B2I,EAAO3I,OAAS6M,EAAcjK,EAAMD,IACtCC,EAAM+F,EAAO3I,OAAS6M,EAAclK,GAGtC,IACI1G,EADAyF,EAAMkB,EAAMD,EAGhB,GAAIrC,OAASqI,GAAUhG,EAAQkK,GAAeA,EAAcjK,EAE1D,IAAK3G,EAAIyF,EAAM,EAAGzF,GAAK,IAAKA,EAC1B0M,EAAO1M,EAAI4Q,GAAevM,KAAKrE,EAAI0G,QAEhC,GAAIjB,EAAM,MAAS9B,EAAOC,oBAE/B,IAAK5D,EAAI,EAAGA,EAAIyF,IAAOzF,EACrB0M,EAAO1M,EAAI4Q,GAAevM,KAAKrE,EAAI0G,QAGrCzC,WAAWrC,UAAUiP,IAAI1Q,KACvBuM,EACArI,KAAK4G,SAASvE,EAAOA,EAAQjB,GAC7BmL,GAIJ,OAAOnL,GAOT9B,EAAO/B,UAAU2J,KAAO,SAAe1F,EAAKa,EAAOC,EAAKzB,GAEtD,GAAmB,iBAARW,EAAkB,CAS3B,GARqB,iBAAVa,GACTxB,EAAWwB,EACXA,EAAQ,EACRC,EAAMtC,KAAKN,QACa,iBAAR4C,IAChBzB,EAAWyB,EACXA,EAAMtC,KAAKN,QAEM,IAAf8B,EAAI9B,OAAc,CACpB,IAAI+M,EAAOjL,EAAIsD,WAAW,GACtB2H,EAAO,MACTjL,EAAMiL,GAGV,QAAiBhM,IAAbI,GAA8C,iBAAbA,EACnC,MAAM,IAAIT,UAAU,6BAEtB,GAAwB,iBAAbS,IAA0BvB,EAAOwB,WAAWD,GACrD,MAAM,IAAIT,UAAU,qBAAuBS,OAErB,iBAARW,IAChBA,GAAY,KAId,GAAIa,EAAQ,GAAKrC,KAAKN,OAAS2C,GAASrC,KAAKN,OAAS4C,EACpD,MAAM,IAAI3C,WAAW,sBAGvB,GAAI2C,GAAOD,EACT,OAAOrC,KAQT,IAAIrE,EACJ,GANA0G,KAAkB,EAClBC,OAAc7B,IAAR6B,EAAoBtC,KAAKN,OAAS4C,IAAQ,EAE3Cd,IAAKA,EAAM,GAGG,iBAARA,EACT,IAAK7F,EAAI0G,EAAO1G,EAAI2G,IAAO3G,EACzBqE,KAAKrE,GAAK6F,MAEP,CACL,IAAI0H,EAAQ5J,EAAO6B,SAASK,GACxBA,EACAS,EAAY,IAAI3C,EAAOkC,EAAKX,GAAUiB,YACtCV,EAAM8H,EAAMxJ,OAChB,IAAK/D,EAAI,EAAGA,EAAI2G,EAAMD,IAAS1G,EAC7BqE,KAAKrE,EAAI0G,GAAS6G,EAAMvN,EAAIyF,GAIhC,OAAOpB,MAMT,IAAI0M,EAAoB,qBAmBxB,SAASzD,EAAO7L,GACd,OAAIA,EAAI,GAAW,IAAMA,EAAE0E,SAAS,IAC7B1E,EAAE0E,SAAS,IAGpB,SAASG,EAAarB,EAAQuE,GAE5B,IAAIa,EADJb,EAAQA,GAASwH,IAMjB,IAJA,IAAIjN,EAASkB,EAAOlB,OAChBkN,EAAgB,KAChB1D,EAAQ,GAEHvN,EAAI,EAAGA,EAAI+D,IAAU/D,EAAG,CAI/B,IAHAqK,EAAYpF,EAAOkE,WAAWnJ,IAGd,OAAUqK,EAAY,MAAQ,CAE5C,IAAK4G,EAAe,CAElB,GAAI5G,EAAY,MAAQ,EAEjBb,GAAS,IAAM,GAAG+D,EAAMrE,KAAK,IAAM,IAAM,KAC9C,SACK,GAAIlJ,EAAI,IAAM+D,EAAQ,EAEtByF,GAAS,IAAM,GAAG+D,EAAMrE,KAAK,IAAM,IAAM,KAC9C,SAIF+H,EAAgB5G,EAEhB,SAIF,GAAIA,EAAY,MAAQ,EACjBb,GAAS,IAAM,GAAG+D,EAAMrE,KAAK,IAAM,IAAM,KAC9C+H,EAAgB5G,EAChB,SAIFA,EAAkE,OAArD4G,EAAgB,OAAU,GAAK5G,EAAY,YAC/C4G,IAEJzH,GAAS,IAAM,GAAG+D,EAAMrE,KAAK,IAAM,IAAM,KAMhD,GAHA+H,EAAgB,KAGZ5G,EAAY,IAAM,CACpB,IAAKb,GAAS,GAAK,EAAG,MACtB+D,EAAMrE,KAAKmB,QACN,GAAIA,EAAY,KAAO,CAC5B,IAAKb,GAAS,GAAK,EAAG,MACtB+D,EAAMrE,KACJmB,GAAa,EAAM,IACP,GAAZA,EAAmB,UAEhB,GAAIA,EAAY,MAAS,CAC9B,IAAKb,GAAS,GAAK,EAAG,MACtB+D,EAAMrE,KACJmB,GAAa,GAAM,IACnBA,GAAa,EAAM,GAAO,IACd,GAAZA,EAAmB,SAEhB,MAAIA,EAAY,SASrB,MAAM,IAAI/F,MAAM,sBARhB,IAAKkF,GAAS,GAAK,EAAG,MACtB+D,EAAMrE,KACJmB,GAAa,GAAO,IACpBA,GAAa,GAAM,GAAO,IAC1BA,GAAa,EAAM,GAAO,IACd,GAAZA,EAAmB,MAOzB,OAAOkD,EA4BT,SAAShH,EAAeyC,GACtB,OAAOzF,EAAO2N,YAhIhB,SAAsBlI,GAIpB,IAFAA,EAUF,SAAqBA,GACnB,OAAIA,EAAImI,KAAanI,EAAImI,OAClBnI,EAAIoI,QAAQ,aAAc,IAZ3BC,CAAWrI,GAAKoI,QAAQL,EAAmB,KAEzChN,OAAS,EAAG,MAAO,GAE3B,KAAOiF,EAAIjF,OAAS,GAAM,GACxBiF,GAAY,IAEd,OAAOA,EAuHmBsI,CAAYtI,IAGxC,SAASF,EAAYyI,EAAKC,EAAKlJ,EAAQvE,GACrC,IAAK,IAAI/D,EAAI,EAAGA,EAAI+D,KACb/D,EAAIsI,GAAUkJ,EAAIzN,QAAY/D,GAAKuR,EAAIxN,UADhB/D,EAE5BwR,EAAIxR,EAAIsI,GAAUiJ,EAAIvR,GAExB,OAAOA,K,+BCvvDT,IAAIyR,EAGJA,EAAI,WACH,OAAOpN,KADJ,GAIJ,IAECoN,EAAIA,GAAK,IAAIC,SAAS,cAAb,GACR,MAAOxG,GAEc,iBAAX1L,SAAqBiS,EAAIjS,QAOrCJ,EAAOD,QAAUsS,G,cCnBjBrS,EAAOD,QAAUM,G,cCAjBL,EAAOD,QAAUO,G,cCAjBN,EAAOD,QAAUQ,G,6BCOjB,IACI8C,EADW,EAAQ,GACGA,WAUtBU,GARY,EAAQ,IACMwO,cAOd,IAAIlP,EAAW,CAC7BqD,KAAM,SACN8L,WAAY,CAEVC,IAAK,CACH/L,KAAM,SAENgM,KAAM,CAAC,MAAO,KAAM,QAGtBC,IAAK,CACHjM,KAAM,SAENgM,KAAM,CAAC,MAAO,QAGhBE,QAAS,CACPlM,KAAM,QAENmM,MAAO,CACLH,KAAM,CAAC,OAAQ,SAAU,UAAW,UAAW,UAAW,YAAa,YAAa,gBAIxFI,IAAK,CACHpM,KAAM,SAENgM,KAAM,CAAC,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,SAGrHK,IAAK,CACHrM,KAAM,UAGRsM,IAAK,CACHtM,KAAM,UAIRuM,IAAK,CACHvM,KAAM,SAIRwM,IAAK,CACHxM,KAAM,cAcZ1G,EAAOD,QAAUgE,G,8BC7EjB,YAEA,IAAIoP,EAAe,EAAQ;;;;;;GAW3B,SAAS7G,EAAQC,EAAGxE,GAClB,GAAIwE,IAAMxE,EACR,OAAO,EAMT,IAHA,IAAIyE,EAAID,EAAE5H,OACN8H,EAAI1E,EAAEpD,OAED/D,EAAI,EAAGyF,EAAMoE,KAAKC,IAAI8B,EAAGC,GAAI7L,EAAIyF,IAAOzF,EAC/C,GAAI2L,EAAE3L,KAAOmH,EAAEnH,GAAI,CACjB4L,EAAID,EAAE3L,GACN6L,EAAI1E,EAAEnH,GACN,MAIJ,OAAI4L,EAAIC,GACE,EAENA,EAAID,EACC,EAEF,EAET,SAASpG,EAAS2B,GAChB,OAAI4D,EAAOpH,QAA4C,mBAA3BoH,EAAOpH,OAAO6B,SACjCuF,EAAOpH,OAAO6B,SAAS2B,KAEjB,MAALA,IAAaA,EAAEsE,WA+B3B,IAAI+G,EAAO,EAAQ,IACfC,EAAS/R,OAAOkB,UAAUC,eAC1B6Q,EAASxF,MAAMtL,UAAU0D,MACzBqN,EACgC,QAA3B,aAAkBpS,KAE3B,SAASqS,EAAW5Q,GAClB,OAAOtB,OAAOkB,UAAUuE,SAAShG,KAAK6B,GAExC,SAASoE,EAAOyM,GACd,OAAIrN,EAASqN,KAGqB,mBAAvB9H,EAAOrG,cAGgB,mBAAvBA,YAAY0B,OACd1B,YAAY0B,OAAOyM,KAEvBA,IAGDA,aAAkBC,aAGlBD,EAAOjN,QAAUiN,EAAOjN,kBAAkBlB,gBAShD,IAAIqO,EAAS3T,EAAOD,QAAU6T,EAO1BC,EAAQ,8BAEZ,SAASC,EAAQC,GACf,GAAKX,EAAKY,WAAWD,GAArB,CAGA,GAAIR,EACF,OAAOQ,EAAK5S,KAEd,IACIiM,EADM2G,EAAKhN,WACCqG,MAAMyG,GACtB,OAAOzG,GAASA,EAAM,IAyCxB,SAAS6G,EAAStR,EAAGN,GACnB,MAAiB,iBAANM,EACFA,EAAEgC,OAAStC,EAAIM,EAAIA,EAAEuD,MAAM,EAAG7D,GAE9BM,EAGX,SAASuK,EAAQgH,GACf,GAAIX,IAAuBH,EAAKY,WAAWE,GACzC,OAAOd,EAAKlG,QAAQgH,GAEtB,IAAIC,EAAUL,EAAQI,GAEtB,MAAO,aADIC,EAAU,KAAOA,EAAU,IACT,IAmB/B,SAASC,EAAKpO,EAAQqO,EAAUC,EAASC,EAAUC,GACjD,MAAM,IAAIb,EAAOc,eAAe,CAC9BH,QAASA,EACTtO,OAAQA,EACRqO,SAAUA,EACVE,SAAUA,EACVC,mBAAoBA,IAcxB,SAASZ,EAAG/R,EAAOyS,GACZzS,GAAOuS,EAAKvS,GAAO,EAAMyS,EAAS,KAAMX,EAAOC,IAoCtD,SAASc,EAAW1O,EAAQqO,EAAUM,EAAQC,GAE5C,GAAI5O,IAAWqO,EACb,OAAO,EACF,GAAIjO,EAASJ,IAAWI,EAASiO,GACtC,OAAqC,IAA9B/H,EAAQtG,EAAQqO,GAIlB,GAAIjB,EAAKyB,OAAO7O,IAAWoN,EAAKyB,OAAOR,GAC5C,OAAOrO,EAAO8O,YAAcT,EAASS,UAKhC,GAAI1B,EAAK2B,SAAS/O,IAAWoN,EAAK2B,SAASV,GAChD,OAAOrO,EAAOgP,SAAWX,EAASW,QAC3BhP,EAAO2F,SAAW0I,EAAS1I,QAC3B3F,EAAOiP,YAAcZ,EAASY,WAC9BjP,EAAOkP,YAAcb,EAASa,WAC9BlP,EAAOmP,aAAed,EAASc,WAIjC,GAAgB,OAAXnP,GAAqC,iBAAXA,GACb,OAAbqO,GAAyC,iBAAbA,EASjC,IAAIrN,EAAOhB,IAAWgB,EAAOqN,IACzBb,EAAUxN,KAAYwN,EAAUa,MAC9BrO,aAAkBoP,cAClBpP,aAAkBqP,cAC7B,OACoD,IAD7C/I,EAAQ,IAAIzH,WAAWmB,EAAOQ,QACtB,IAAI3B,WAAWwP,EAAS7N,SAQlC,GAAIJ,EAASJ,KAAYI,EAASiO,GACvC,OAAO,EAIP,IAAIiB,GAFJV,EAAQA,GAAS,CAAC5O,OAAQ,GAAIqO,SAAU,KAEhBrO,OAAOoC,QAAQpC,GACvC,OAAqB,IAAjBsP,GACEA,IAAgBV,EAAMP,SAASjM,QAAQiM,KAK7CO,EAAM5O,OAAO8D,KAAK9D,GAClB4O,EAAMP,SAASvK,KAAKuK,GAUxB,SAAkB9H,EAAGxE,EAAG4M,EAAQY,GAC9B,GAAIhJ,eAAiCxE,EACnC,OAAO,EAET,GAAIqL,EAAKoC,YAAYjJ,IAAM6G,EAAKoC,YAAYzN,GAC1C,OAAOwE,IAAMxE,EACf,GAAI4M,GAAUrT,OAAOmU,eAAelJ,KAAOjL,OAAOmU,eAAe1N,GAC/D,OAAO,EACT,IAAI2N,EAAUC,EAAYpJ,GACtBqJ,EAAUD,EAAY5N,GAC1B,GAAK2N,IAAYE,IAAcF,GAAWE,EACxC,OAAO,EACT,GAAIF,EAGF,OAFAnJ,EAAI+G,EAAOvS,KAAKwL,GAChBxE,EAAIuL,EAAOvS,KAAKgH,GACT2M,EAAWnI,EAAGxE,EAAG4M,GAE1B,IAEIxS,EAAKvB,EAFLiV,EAAKC,EAAWvJ,GAChBwJ,EAAKD,EAAW/N,GAIpB,GAAI8N,EAAGlR,SAAWoR,EAAGpR,OACnB,OAAO,EAKT,IAHAkR,EAAGG,OACHD,EAAGC,OAEEpV,EAAIiV,EAAGlR,OAAS,EAAG/D,GAAK,EAAGA,IAC9B,GAAIiV,EAAGjV,KAAOmV,EAAGnV,GACf,OAAO,EAIX,IAAKA,EAAIiV,EAAGlR,OAAS,EAAG/D,GAAK,EAAGA,IAE9B,GADAuB,EAAM0T,EAAGjV,IACJ8T,EAAWnI,EAAEpK,GAAM4F,EAAE5F,GAAMwS,EAAQY,GACtC,OAAO,EAEX,OAAO,EA/CEU,CAASjQ,EAAQqO,EAAUM,EAAQC,IApC1C,OAAOD,EAAS3O,IAAWqO,EAAWrO,GAAUqO,EAwCpD,SAASsB,EAAYrT,GACnB,MAAiD,sBAA1ChB,OAAOkB,UAAUuE,SAAShG,KAAKuB,GAgFxC,SAAS4T,EAAkBlQ,EAAQqO,GACjC,IAAKrO,IAAWqO,EACd,OAAO,EAGT,GAAgD,mBAA5C/S,OAAOkB,UAAUuE,SAAShG,KAAKsT,GACjC,OAAOA,EAAS8B,KAAKnQ,GAGvB,IACE,GAAIA,aAAkBqO,EACpB,OAAO,EAET,MAAOvI,IAIT,OAAI5G,MAAMkR,cAAc/B,KAIa,IAA9BA,EAAStT,KAAK,GAAIiF,GAa3B,SAASqQ,EAAQC,EAAaC,EAAOlC,EAAUC,GAC7C,IAAItO,EAEJ,GAAqB,mBAAVuQ,EACT,MAAM,IAAIlR,UAAU,uCAGE,iBAAbgP,IACTC,EAAUD,EACVA,EAAW,MAGbrO,EAtBF,SAAmBuQ,GACjB,IAAIC,EACJ,IACED,IACA,MAAOzK,GACP0K,EAAQ1K,EAEV,OAAO0K,EAeEC,CAAUF,GAEnBjC,GAAWD,GAAYA,EAASlT,KAAO,KAAOkT,EAASlT,KAAO,KAAO,MAC1DmT,EAAU,IAAMA,EAAU,KAEjCgC,IAAgBtQ,GAClBoO,EAAKpO,EAAQqO,EAAU,6BAA+BC,GAGxD,IAAIoC,EAAyC,iBAAZpC,EAE7BqC,GAAyBL,GAAetQ,IAAWqO,EASvD,KAV2BiC,GAAelD,EAAKwD,QAAQ5Q,IAInD0Q,GACAR,EAAkBlQ,EAAQqO,IAC1BsC,IACFvC,EAAKpO,EAAQqO,EAAU,yBAA2BC,GAG/CgC,GAAetQ,GAAUqO,IACzB6B,EAAkBlQ,EAAQqO,KAAgBiC,GAAetQ,EAC5D,MAAMA,EAvVV2N,EAAOc,eAAiB,SAAwBoC,GAsDhD,IAAoBC,EArDlB7R,KAAK9D,KAAO,iBACZ8D,KAAKe,OAAS6Q,EAAQ7Q,OACtBf,KAAKoP,SAAWwC,EAAQxC,SACxBpP,KAAKsP,SAAWsC,EAAQtC,SACpBsC,EAAQvC,SACVrP,KAAKqP,QAAUuC,EAAQvC,QACvBrP,KAAK8R,kBAAmB,IAExB9R,KAAKqP,QA8CAL,EAAS/G,GADE4J,EA7CU7R,MA8CCe,QAAS,KAAO,IACtC8Q,EAAKvC,SAAW,IAChBN,EAAS/G,EAAQ4J,EAAKzC,UAAW,KA/CtCpP,KAAK8R,kBAAmB,GAE1B,IAAIvC,EAAqBqC,EAAQrC,oBAAsBJ,EACvD,GAAIlP,MAAM8R,kBACR9R,MAAM8R,kBAAkB/R,KAAMuP,OACzB,CAEL,IAAIyC,EAAM,IAAI/R,MACd,GAAI+R,EAAIC,MAAO,CACb,IAAIjJ,EAAMgJ,EAAIC,MAGVC,EAAUrD,EAAQU,GAClB4C,EAAMnJ,EAAI7F,QAAQ,KAAO+O,GAC7B,GAAIC,GAAO,EAAG,CAGZ,IAAIC,EAAYpJ,EAAI7F,QAAQ,KAAMgP,EAAM,GACxCnJ,EAAMA,EAAIqJ,UAAUD,EAAY,GAGlCpS,KAAKiS,MAAQjJ,KAMnBmF,EAAKmE,SAAS5D,EAAOc,eAAgBvP,OA6CrCyO,EAAOS,KAAOA,EAYdT,EAAOC,GAAKA,EAMZD,EAAO6D,MAAQ,SAAexR,EAAQqO,EAAUC,GAC1CtO,GAAUqO,GAAUD,EAAKpO,EAAQqO,EAAUC,EAAS,KAAMX,EAAO6D,QAMvE7D,EAAO8D,SAAW,SAAkBzR,EAAQqO,EAAUC,GAChDtO,GAAUqO,GACZD,EAAKpO,EAAQqO,EAAUC,EAAS,KAAMX,EAAO8D,WAOjD9D,EAAO+D,UAAY,SAAmB1R,EAAQqO,EAAUC,GACjDI,EAAW1O,EAAQqO,GAAU,IAChCD,EAAKpO,EAAQqO,EAAUC,EAAS,YAAaX,EAAO+D,YAIxD/D,EAAOgE,gBAAkB,SAAyB3R,EAAQqO,EAAUC,GAC7DI,EAAW1O,EAAQqO,GAAU,IAChCD,EAAKpO,EAAQqO,EAAUC,EAAS,kBAAmBX,EAAOgE,kBAuH9DhE,EAAOiE,aAAe,SAAsB5R,EAAQqO,EAAUC,GACxDI,EAAW1O,EAAQqO,GAAU,IAC/BD,EAAKpO,EAAQqO,EAAUC,EAAS,eAAgBX,EAAOiE,eAI3DjE,EAAOkE,mBACP,SAASA,EAAmB7R,EAAQqO,EAAUC,GACxCI,EAAW1O,EAAQqO,GAAU,IAC/BD,EAAKpO,EAAQqO,EAAUC,EAAS,qBAAsBuD,IAQ1DlE,EAAOmE,YAAc,SAAqB9R,EAAQqO,EAAUC,GACtDtO,IAAWqO,GACbD,EAAKpO,EAAQqO,EAAUC,EAAS,MAAOX,EAAOmE,cAOlDnE,EAAOoE,eAAiB,SAAwB/R,EAAQqO,EAAUC,GAC5DtO,IAAWqO,GACbD,EAAKpO,EAAQqO,EAAUC,EAAS,MAAOX,EAAOoE,iBA+ElDpE,EAAOqE,OAAS,SAASzB,EAAmBC,EAAmBlC,GAC7D+B,GAAQ,EAAME,EAAOC,EAAOlC,IAI9BX,EAAOsE,aAAe,SAAS1B,EAAmBC,EAAmBlC,GACnE+B,GAAQ,EAAOE,EAAOC,EAAOlC,IAG/BX,EAAOuE,QAAU,SAASjB,GAAO,GAAIA,EAAK,MAAMA,GAMhDtD,EAAOgB,OAASxB,EAHhB,SAASwB,EAAO9S,EAAOyS,GAChBzS,GAAOuS,EAAKvS,GAAO,EAAMyS,EAAS,KAAMK,IAEVhB,EAAQ,CAC3C6D,MAAO7D,EAAOmE,YACdJ,UAAW/D,EAAOgE,gBAClBF,SAAU9D,EAAOoE,eACjBH,aAAcjE,EAAOkE,qBAEvBlE,EAAOgB,OAAOA,OAAShB,EAAOgB,OAE9B,IAAImB,EAAaxU,OAAO6W,MAAQ,SAAUvV,GACxC,IAAIuV,EAAO,GACX,IAAK,IAAIhW,KAAOS,EACVyQ,EAAOtS,KAAK6B,EAAKT,IAAMgW,EAAKrO,KAAK3H,GAEvC,OAAOgW,K,8CClfT,IAAIC,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIG,EAAQ,EAYRvV,EAAc,WAKhB,SAASA,EAAYwV,EAAM7W,IAnB7B,SAAyB8W,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAoB5GyT,CAAgB7T,KAAM7B,GAEtB6B,KAAK2T,KAAOA,EACZ3T,KAAKlD,KAAOA,GAAQ4W,EACpB1T,KAAK8T,OAASH,GAA2B,MAAnBA,EAAKI,OAAO,GAAa/T,KAAKgU,2BAA2BL,GAAQ3T,KAAKiU,gBAAgBN,GAgQ9G,OAxPAR,EAAahV,EAAa,CAAC,CACzBjB,IAAK,SACLN,MAAO,SAAgB+W,GACrB,OAAOA,EAAK5G,QAAQ,KAAM,MAAMA,QAAQ,MAAO,QAOhD,CACD7P,IAAK,WACLN,MAAO,SAAkB+W,GACvB,OAAOA,EAAK5G,QAAQ,MAAO,KAAKA,QAAQ,MAAO,OAOhD,CACD7P,IAAK,kBAULN,MAAO,SAAyB+W,GAC9B,GAAoB,iBAATA,EACT,MAAM,IAAI1T,MAAM,iCAGlB,GAAa,KAAT0T,EACF,MAAO,GAGT,GAAuB,MAAnBA,EAAKI,OAAO,GACd,MAAM,IAAI9T,MAAM,wBAGlB,MAAa,MAAT0T,EACK,CAAC,IAGHA,EAAKpP,OAAO,GAAG2P,MAAM,KAAKC,IAAInU,KAAKoU,YAU3C,CACDlX,IAAK,eACLN,MAAO,WACL,MAAO,IAAMoD,KAAK8T,OAAOK,IAAInU,KAAKqU,QAAQjM,KAAK,OAOhD,CACDlL,IAAK,6BACLN,MAAO,SAAoC+W,GACzC,GAAoB,iBAATA,EACT,MAAM,IAAI1T,MAAM,iCAGlB,GAAuB,MAAnB0T,EAAKI,OAAO,GACd,MAAM,IAAI9T,MAAM,gDAGlB,OAAOD,KAAKiU,gBAAgBK,mBAAmBX,EAAKpP,OAAO,OAU5D,CACDrH,IAAK,0BACLN,MAAO,WACL,IAAI2X,EAAQvU,KAMZ,MAAO,KAJKA,KAAK8T,OAAOK,IAAI,SAAUK,GACpC,OAAOC,mBAAmBF,EAAMF,OAAOG,MACtCpM,KAAK,OAaT,CACDlL,IAAK,MACLN,MAAO,SAAamT,GAIlB,IAHA,IAAI2E,EAAU3E,EACV+D,EAAS9T,KAAK8T,OAETnY,EAAI,EAAGA,EAAImY,EAAOpU,OAAQ/D,IAAK,CACtC,IAAK+Y,QAAkCjU,IAAvBiU,EAAQZ,EAAOnY,IAAmB,CAChD,GAAIqE,KAAKlD,OAAS4W,EAChB,OAEA,MAAM,IAAIzT,MAAM,kCAIpByU,EAAUA,EAAQZ,EAAOnY,IAG3B,OAAO+Y,IAaR,CACDxX,IAAK,MACLN,MAAO,SAAayL,EAAQzL,GAK1B,IAJA,IAAIkX,EAAS9T,KAAK8T,OACdY,EAAUrM,EAGL1M,EAAI,EAAGA,EAAImY,EAAOpU,OAAQ/D,IAAK,CACtC,IAAI6Y,EAAQV,EAAOnY,GAGnB,GAAIA,IAAMmY,EAAOpU,OAAS,EACV,MAAV8U,EACFE,EAAQ7P,KAAKjI,GACJiM,MAAMzJ,QAAQsV,GACvBA,EAAQC,OAAOH,EAAO,EAAG5X,QACN6D,IAAV7D,IACT8X,EAAQF,GAAS5X,QAId,GAAK8X,EAAQF,GAkBlBE,EAAUA,EAAQF,QAjBlB,OAAQxU,KAAKlD,MACX,KAAK4W,EACH,MAAM,IAAIzT,MAAM,kCAElB,KAnME,EAoMAyU,EAAUA,EAAQF,GAASlQ,SAASkQ,GAAS,GAAK,GAClD,MAEF,KAtMC,EAuMC,OAEF,QACE,MAAM,IAAIvU,MAAM,4BAmBzB,CACD/C,IAAK,UACLN,MAAO,SAAiByL,EAAQzL,GAI9B,IAHA,IAAIkX,EAAS9T,KAAK8T,OACdY,EAAUrM,EAEL1M,EAAI,EAAGA,EAAImY,EAAOpU,OAAQ/D,IAAK,CACtC,IAAI6Y,EAAQV,EAAOnY,GAEfA,IAAMmY,EAAOpU,OAAS,EACxBgV,EAAQF,GAAS5X,EAIjB8X,EAHUA,EAAQF,GAGRE,EAAQF,GAFRE,EAAQF,GAASlQ,SAASkQ,GAAS,GAAK,MAavD,CACDtX,IAAK,SACLN,MAAO,SAAgByL,GAIrB,IAHA,IAAIyL,EAAS9T,KAAK8T,OACdY,EAAUrM,EAEL1M,EAAI,EAAGA,EAAImY,EAAOpU,OAAQ/D,IAAK,CACtC,IAAI6Y,EAAQV,EAAOnY,GAEnB,QAAgB8E,IAAZiU,QAA4CjU,IAAnBiU,EAAQF,GACnC,OACK,GAAI3L,MAAMzJ,QAAQsV,GAEvB,YADAA,EAAQC,OAAOH,EAAO,GAEb7Y,IAAMmY,EAAOpU,OAAS,UACxBgV,EAAQF,GAGjBE,EAAUA,EAAQF,OAKpB,CAAC,CACHtX,IAAK,QACLN,MAAO,SAAe+W,GACpB,OAAO,IAAIxV,EAAYwV,OAIpBxV,EA1QS,GAkRlBpD,EAAOD,QAAUqD,G,6BCtSjB,IAAIgV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAUH,EAAQ,GAAxB,IACIqB,EAAsB,EAAQ,IAG9BC,EADW,EAAQ,IACUA,kBAQ7BtW,EAAM,WACR,SAASA,KArBX,SAAyBqV,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAsB5GyT,CAAgB7T,KAAMzB,GA0FxB,OAvFA4U,EAAa5U,EAAK,KAAM,CAAC,CACvBrB,IAAK,OAeLN,MAAO,SAAciR,EAAK3Q,EAAKwE,GAE7B,IAAIoT,EAAsBF,EAAoBG,UAAU,OAAQlH,GAGhE,OAAIiH,aAA+B7U,MAC1B+U,QAAQC,OAAO,IAAIJ,EAAkBhH,IAYvCiH,EAAoBI,KAAKhY,EAAKwE,KAiBtC,CACDxE,IAAK,SACLN,MAAO,SAAgBiR,EAAK3Q,EAAKiY,EAAWzT,GAC1C,IAAIoT,EAAsBF,EAAoBG,UAAU,SAAUlH,GAElE,OAAIiH,aAA+B7U,MAC1B+U,QAAQC,OAAO,IAAIJ,EAAkBhH,IAOvCiH,EAAoBM,OAAOlY,EAAKiY,EAAWzT,KAenD,CACDxE,IAAK,YACLN,MAAO,SAAmBM,GAExB,OAD0B0X,EAAoBG,UAAU,YAAa7X,EAAI2Q,KAC9CwH,UAAUnY,OAIlCqB,EA5FC,GAoGVxD,EAAOD,QAAUyD,G,cCrEjBxD,EAAOD,QAhDP,MAWE,cAAe4G,GACZ,IAAI4T,EAAQ,GAMZ,OAJAjZ,OAAO6W,KAAKxR,GAAM6T,QAAQ,SAAUrY,GAClCoY,EAAMzQ,KAAK4P,mBAAmBvX,GAAO,IAAMuX,mBAAmB/S,EAAKxE,OAG9DoY,EAAMlN,KAAK,KAYrB,cAAe1G,GACb,IAAI/D,EAAM,GAUV,OARA+D,EAAKwS,MAAM,KAAKqB,QAAQ,SAAUjY,GAChC,IAAIkY,EAAOlY,EAAS4W,MAAM,KACtBhX,EAAMoX,mBAAmBkB,EAAK,IAC9BhU,EAAM8S,mBAAmBkB,EAAK,IAElC7X,EAAIT,GAAOsE,IAGN7D,K,6BCVX5C,EAAOD,QAdP,SAAsBuU,EAAU,eAC9B,OAAQoG,IACN,GAAIA,EAASC,QAAU,KAAOD,EAASC,OAAS,IAC9C,OAAOD,EAGT,IAAIE,KAAkBtG,MAAYoG,EAASC,UAAUD,EAASG,aAC1DrE,EAAQ,IAAItR,MAAM0V,GAGtB,MAFApE,EAAMkE,SAAWA,EACjBlE,EAAMsE,WAAaJ,EAASC,OACtBnE,K,6BChCVxW,EAAOD,QAAUE,EAAQ,K,6BCAzBqB,OAAOC,eAAexB,EAAS,aAAc,CAC3C8B,OAAO,IAET9B,EAAQgb,QAAUhb,EAAQib,MAAQjb,EAAQkb,SAAWlb,EAAQmb,aAAU,EACvE,IAAIzB,EAAQ,6DAERyB,EAAU,SAAiBtR,GAC7B,MAAsB,iBAARA,GAAoB6P,EAAMtD,KAAKvM,IAG/C7J,EAAQmb,QAAUA,EAClB,IAAID,EAAWC,EACfnb,EAAQkb,SAAWA,EAMnBlb,EAAQib,MAJI,SAAepR,GACzB,UAAWA,EAAIoI,QAAQ,KAAM,WAS/BjS,EAAQgb,QAJM,SAAiBnR,GAC7B,OAAOA,EAAIJ,OAAO,EAAGI,EAAIjF,OAAS,GAAGqN,QAAQ,OAAQ,O,iBCvBvD,YAGA,MAAM2B,EAAS1T,EAAQ,IACjBkb,EAAQlb,EAAQ,IAChB,IAAEmb,GAAQnb,EAAQ,GAClBob,EAAUF,EAAME,QAAUF,EAAME,QAAU1P,EAAO0P,SACjD,aAACpY,GAAgBhD,EAAQ,IACzB,OAACyD,GAAUzD,EAAQ,GACnBqb,EAAwBrb,EAAQ,IAChCsb,EAAyBtb,EAAQ,IACjCub,EAAqBvb,EAAQ,IAC7Bwb,EAAcxb,EAAQ,IACtByb,EAAiBzb,EAAQ,IAgD/B,MAAM0b,UAAqB1Y,EAKzB,oBACE,OAAOuY,EAYT,YAAa7U,GACX,IAAIiV,EAAK,IAAID,EAAahV,GACtBkV,EAAaD,EAAGE,WAGpB,IAAKD,EAAWE,MACd,OAAO9B,QAAQC,OAAO,IAAIhV,MAAM8W,KAAKC,UAAUJ,KAGjD,IAAIK,EAAON,EAAGO,SAASD,KAGvB,OAAKA,EAKExY,EAAO0Y,WAAWF,GAAMG,KAAKH,IAClCN,EAAGO,SAASD,KAAOA,EACZN,IANAA,EAAGM,OAAOG,KAAK,IAAMT,GAoBhC,gBAAiBU,EAAQC,EAAc1F,GACrC,IAAI+E,EAAK,IAAID,EAAa,CACxBQ,SAAU,CAAEK,IAAKF,GACjBG,SAAUnb,OAAOob,OAAO,GAAI7F,EAAQ4F,UACpCE,MAAO9F,EAAQ8F,QAGjB,OAAO1C,QAAQ2C,UACZP,KAAK,IAAMT,EAAGiB,YACdR,KAAK,IAAMT,EAAGM,QACdG,KAAK,IAAMT,EAAGkB,SAASP,IACvBF,KAAK,IAAMT,GAShBiB,WACE,IACE,IAAIP,EAASrX,KAAKkX,SAASK,IAE3B7I,EAAO2I,EAAQ,2CAEf,IAAIE,EAAM,IAAIpB,EAAIkB,GAGlB,OAFAE,EAAIO,SAAW,mCAER5B,EAAMqB,EAAIzV,YACdsV,KAAKZ,EAAY,wCACjBY,KAAK3B,GACGA,EAASsC,OAAOX,KAAKW,GAAQ/X,KAAKkX,SAASc,cAAgBD,IAGtE,MAAOxG,GACP,OAAOyD,QAAQC,OAAO1D,IAY1BsG,SAAUjG,GACR,IACE,IAAIoG,EAAgBhY,KAAKkX,SAASc,cAElCtJ,EAAOsJ,EAAe,4CACtBtJ,EAAOsJ,EAAcC,sBAAuB,0DAE5C,IAAIC,EAAMF,EAAcC,sBACpBE,EAAS,OACTC,EAAU,IAAIhC,EAAQ,CAAE,eAAgB,qBACxCiC,EAASrY,KAAKwX,SAASK,SACvBS,EAAOvB,KAAKC,UAAU3a,OAAOob,OAAO,GAAIY,EAAQzG,IAEpD,OAAOsE,EAAMgC,EAAK,CAACC,SAAQC,UAASE,SACjClB,KAAKZ,EAAY,6BACjBY,KAAK3B,GACGA,EAASsC,OAAOX,KAAKW,GAAQ/X,KAAKsX,aAAeS,IAG5D,MAAOxG,GACP,OAAOyD,QAAQC,OAAO1D,IAI1BgH,YACE,OAAOxB,KAAKC,UAAUhX,MASxBiX,OACE,IACE,IAAIe,EAAgBhY,KAAKkX,SAASc,cAElCtJ,EAAOsJ,EAAe,4CACtBtJ,EAAOsJ,EAAcQ,SAAU,6CAE/B,IAAIN,EAAMF,EAAcQ,SAExB,OAAOtC,EAAMgC,GACVd,KAAKZ,EAAY,kCACjBY,KAAK3B,GACGA,EACJsC,OACAX,KAAKW,GAAQtZ,EAAO0Y,WAAWY,IAC/BX,KAAKH,GAAQjX,KAAKkX,SAASD,KAAOA,IAGzC,MAAO1F,GACP,OAAOyD,QAAQC,OAAO1D,IAa1BkH,cAAe7G,EAAS8G,GACtB,OAAOrC,EAAsBpZ,OAAO+C,KAAM4R,EAAS8G,GAAW1Y,KAAK0X,OAWrEiB,iBAAkBlD,EAAUiD,EAAU1Y,KAAK0X,OACzC,IAAI9F,EAGFA,EADE6D,EAAStN,MAAM,kBACP,CAAEwO,GAAI3W,KAAM4Y,SAAUnD,EAAUiD,WAEhC,CAAE/B,GAAI3W,KAAMsY,KAAM7C,EAAUiD,WAGxC,MAAMG,EAAe,IAAIvC,EAAuB1E,GAEhD,OAAO0E,EAAuBqC,iBAAiBE,GASjDC,WACE,IACE,IAAId,EAAgBhY,KAAKkX,SAASc,cAElCtJ,EAAOsJ,EAAe,4CACtBtJ,EAAOsJ,EAAce,kBAAmB,sDAExC,IAAIb,EAAMF,EAAce,kBACpBC,EAAehZ,KAAK0X,MAAMsB,aAE9BtK,EAAOsK,EAAc,yBAErB,IAAIZ,EAAU,IAAIhC,EAAQ,CACxB,eAAgB,mBAChB,wBAA2B4C,MAG7B,OAAO9C,EAAMgC,EAAK,CAACE,YAChBhB,KAAKZ,EAAY,4BACjBY,KAAK3B,GAAYA,EAASsC,QAE7B,MAAOxG,GACP,OAAOyD,QAAQC,OAAO1D,IA6D1B0H,cAAerH,EAAU,IACvB,MAAM,cAAEsH,EAAF,yBAAiBC,EAAjB,MAA2CC,GAAUxH,EAC3D,IAAIoG,EAMJ,GAJAtJ,EAAO1O,KAAKkX,SAAU,2CACtBc,EAAgBhY,KAAKkX,SAASc,cAC9BtJ,EAAOsJ,EAAe,4CAEjBA,EAAcqB,qBAGjB,OAFAC,QAAQC,IAAK,+BACRvB,EAAcX,0CACZ,KAGT,GAAI8B,IAA6BD,EAC/B,MAAM,IAAIjZ,MAAM,iEAGlB,MAAMoY,EAAS,GAEXa,IACFb,EAAOa,cAAgBA,GAErBC,IACFd,EAAOc,yBAA2BA,GAEhCC,IACFf,EAAOe,MAAQA,GAGjB,MAAM7B,EAAM,IAAIpB,EAAI6B,EAAcqB,sBAGlC,OAFA9B,EAAIiC,OAAS/C,EAAegD,OAAOpB,GAE5Bd,EAAImC,KAabC,SACE,IAAI3B,EACJ,IACEtJ,EAAO1O,KAAKkX,SAAU,4CACtBc,EAAgBhY,KAAKkX,SAASc,cAC9BtJ,EAAOsJ,EAAe,4CACtBtJ,EAAOsJ,EAAcqB,qBACnB,yDACF,MAAO9H,GACP,OAAOyD,QAAQC,OAAO1D,GAGxB,IAAKyG,EAAcqB,qBAEjB,OADArZ,KAAK4Z,eACE5E,QAAQ2C,aAAQlX,GAGzB,IAAIyX,EAAMF,EAAcqB,qBAGxB,OAAOnD,EAAMgC,EAAK,CAACC,OAFN,MAEc0B,YAAa,YACrCzC,KAAKZ,EAAY,sBACjBY,KAAK,IAAMpX,KAAK4Z,gBAiBrBA,eACE,IAAIlB,EAAU1Y,KAAK0X,MAEdgB,UAEEA,EAAQoB,GASjBC,YAAa7B,EAAK8B,GAChB,OAAOC,SAASC,SAAShC,EAAK8B,IAIlC,MAAMF,EAAsB,0BAE5BpD,EAAaoD,oBAAsBA,EAEnC/e,EAAOD,QAAU4b,I,8CCvbjB,IAAIvD,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAI4G,EAAkB,uFAClBC,EAAa,8CACbC,EAAe,oHACfC,EAAc,4EACdC,EAAc,qpCACdC,EAAkB,uFAMlB1c,EAAU,WACZ,SAASA,KAdX,SAAyB8V,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAe5GyT,CAAgB7T,KAAMlC,GAoGxB,OAjGAqV,EAAarV,EAAS,CAAC,CACrBZ,IAAK,WAkBLN,MAAO,SAAkBV,EAAMue,GAE7B,GAAoB,iBAATve,EACT,MAAM,IAAI+D,MAAM,gCAQlB,MAJuB,iBAAZwa,IACTA,EAAU,IAAIC,OAAOD,IAGhBza,KAAK9D,GAAQue,IAcrB,CACDvd,IAAK,UACLN,MAAO,SAAiBV,GACtB,IAAIye,EAAS3a,KAAK9D,GAElB,IAAKye,EACH,MAAM,IAAI1a,MAAM,+BAGlB,OAAO0a,IAcR,CACDzd,IAAK,OACLN,MAAO,SAAcV,EAAMU,GAEzB,OADaoD,KAAK2X,QAAQzb,GACZgV,KAAKtU,MAEnB,CAAC,CACHM,IAAK,aAWLN,MAAO,WACL,IAAIge,EAAU,IAAI9c,EAOlB,OANA8c,EAAQ/C,SAAS,YAAasC,GAC9BS,EAAQ/C,SAAS,MAAOuC,GACxBQ,EAAQ/C,SAAS,QAASwC,GAC1BO,EAAQ/C,SAAS,OAAQyC,GACzBM,EAAQ/C,SAAS,OAAQ0C,GACzBK,EAAQ/C,SAAS,WAAY2C,GACtBI,MAIJ9c,EAtGK,GA8Gd/C,EAAOD,QAAUgD,EAAQ+c,c,6BCjIzB,IAAIC,EAA4B,mBAAXpe,QAAoD,iBAApBA,OAAOqe,SAAwB,SAAUpd,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAyB,mBAAXjB,QAAyBiB,EAAIqd,cAAgBte,QAAUiB,IAAQjB,OAAOa,UAAY,gBAAkBI,GAElQwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIxV,EAAc,WAKhB,SAASA,EAAYkd,EAAQrJ,IAP/B,SAAyBgC,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAQ5GyT,CAAgB7T,KAAMjC,GAEtB1B,OAAOob,OAAOzX,KAAM4R,GAAW,IAC/B5R,KAAKpF,KAAOoF,KAAKpF,MAAQoF,KAEzBA,KAAKpF,KAAKsgB,MAAQlb,KAAKpF,KAAKsgB,OAAS,EAEjClb,KAAKmb,MAAQnb,KAAKpF,KAAKsgB,QACzBlb,KAAKpF,KAAKsgB,MAAQlb,KAAKmb,OAGzBnb,KAAKmb,MAAQnb,KAAKmb,OAAS,EAC3Bnb,KAAKib,OAASA,EA4RhB,OApRA9H,EAAapV,EAAa,CAAC,CACzBb,IAAK,UAMLN,MAAO,WACL,IAAIhC,EAAOoF,KAAKpF,KAIZwgB,GAHQpb,KAAKkb,MACLlb,KAAKmb,MAEE,IACf7C,EAAO,GAgBX,GAbAA,GAAQtY,KAAK1B,UACbga,GAAQtY,KAAKuN,aAEb+K,GAAQtY,KAAK4N,QAKb0K,GAAQtY,KAAKqb,SACb/C,GAAQtY,KAAKsb,OAIT1gB,IAASoF,KAAM,CACjB,IAAK,IAAIrE,EAAI,EAAGA,GAAKqE,KAAKpF,KAAKsgB,MAAOvf,IACpCyf,GAAgBpb,KAAKub,YAAY5f,GAGnC,MAAO,2KAA6Kyf,EAAe,aAAe9C,EAAO,WAG3N,OAAOA,IAOR,CACDpb,IAAK,cACLN,MAAO,SAAqBue,GAC1B,MAAO,qBAAuBA,EAAQ,qBAAuBA,EAAQ,oBAAsBA,EAAQ,WAOpG,CACDje,IAAK,UACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OACdE,EAAQnb,KAAKmb,MACbje,EAAM8C,KAAK9C,IACXse,EAAQxb,KAAKwb,MACb5e,EAAQqe,EAAO3c,QAEfgT,EAAQ,GAmBZ,OAjBI2J,EAAOzd,eAAe,aAEpBN,IACFoU,GAAS,qBAAuB6J,EAAQ,KAAQje,EAAM,QAAW6Z,KAAKC,UAAUpa,GAAS,cAGvF4e,IACFlK,GAAS,qBAAuB6J,EAAQ,IAAMK,EAAQ,OAASzE,KAAKC,UAAUpa,GAAS,cAGrFue,EAAQ,IACV7J,GAAS,oBAAsB6J,EAAQ,gBAGzC7J,EAAQ,0DAA4DA,EAAQ,uBAGvEA,IAOR,CACDpU,IAAK,SACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OAEdE,GADOnb,KAAKpF,KACJoF,KAAKmb,OACbje,EAAM8C,KAAK9C,IACXqQ,EAAa0N,EAAO1N,WACpBkO,EAAuBR,EAAOQ,qBAC9B7N,EAAQqN,EAAOrN,MACf8N,EAAkBT,EAAOS,gBAEzBpK,EAAQ,GAmBZ,OAdIpU,GAAQqQ,GAAekO,GAAyB7N,GAAU8N,IAG5DpK,GAAS,mBAAqB6J,EAAQ,KAAQje,EAAM,cAAiBie,EAAQ,KAAQje,EAAM,aAGvFie,EAAQ,IACV7J,GAAS,oBAAsB6J,EAAQ,gBAIzC7J,EAAQ,uBAAyB6J,EAAQ,oBAAuBje,EAAM,oBAAuBoU,EAAQ,uBAGhGA,IAOR,CACDpU,IAAK,OACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OAEdE,GADOnb,KAAKpF,KACJoF,KAAKmb,OACbK,EAAQxb,KAAKwb,MACbjO,EAAa0N,EAAO1N,WACpBkO,EAAuBR,EAAOQ,qBAC9B7N,EAAQqN,EAAOrN,MACf8N,EAAkBT,EAAOS,gBAEzBpK,EAAQ,GAaZ,OAXIkK,GAAUjO,GAAekO,GAAyB7N,GAAU8N,IAE9DpK,GAAS,mBAAqB6J,EAAQ,IAAMK,EAAQ,aAAeL,EAAQ,IAAMK,EAAQ,YAErFL,EAAQ,IACV7J,GAAS,oBAAsB6J,EAAQ,gBAGzC7J,EAAQ,iBAAmBkK,EAAQ,wBAA0BlK,EAAQ,uBAGhEA,IAOR,CACDpU,IAAK,aACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OACdrgB,EAAOoF,KAAKpF,KACZugB,EAAQnb,KAAKmb,MACbje,EAAM8C,KAAK9C,IACXse,EAAQxb,KAAKwb,MACbjO,EAAa0N,EAAO1N,WAEpB+D,EAAQ,GA2BZ,OAzBI/D,IACFlR,OAAO6W,KAAK3F,GAAYgI,QAAQ,SAAUrY,GACxC,IACIye,EAAc,IAAI5d,EADNwP,EAAWrQ,GACkB,CAAEA,IAAKA,EAAKtC,KAAMA,EAAMugB,MAAOA,EAAQ,IAEpF7J,GAASqK,EAAYC,YAInBhhB,IAASoF,KACXsR,EAAQ,qSAA6SA,EAAQ,2BAKzTkK,IACFlK,EAAQ,qBAAuBkK,EAAQ,YAAcL,EAAQ,2BAA6BA,EAAQ,IAAMK,EAAQ,6CAAiDL,EAAQ,GAAK,YAAcA,EAAQ,IAAMK,EAAQ,gCAAkCL,EAAQ,GAAK,6BAA+BK,EAAQ,YAAcL,EAAQ,2BAA6BA,EAAQ,IAAMK,EAAQ,6CAAiDL,EAAQ,GAAK,8BAAgCK,EAAQ,YAAcL,EAAQ,uCAAyCA,EAAQ,GAAK,yEAA2EA,EAAQ,GAAK,YAAcA,EAAQ,IAAMK,EAAQ,uCAAyClK,EAAQ,+BAAiC6J,EAAQ,GAAK,kCAAoCA,EAAQ,IAAMK,EAAQ,cAAgBL,EAAQ,GAAK,0BAA4BA,EAAQ,oEAAsEA,EAAQ,IAAMK,EAAQ,aAAeL,EAAQ,IAAMK,EAAQ,yBAA2BL,EAAQ,iCAG3hCje,IACFoU,EAAQ,mCAAqC6J,EAAQ,KAAQje,EAAM,+CAAoDie,EAAQ,KAAQje,EAAM,0DAA6Die,EAAQ,KAAQje,EAAM,mCAAsCie,EAAQ,oBAAuBje,EAAM,iCAAoCie,EAAQ,GAAK,YAAcA,EAAQ,KAAQje,EAAM,iCAAoCie,EAAQ,GAAK,oCAAsCA,EAAQ,oBAAuBje,EAAM,yCAA4Cie,EAAQ,KAAQje,EAAM,+CAAoDie,EAAQ,KAAQje,EAAM,yDAA4Die,EAAQ,KAAQje,EAAM,kCAAqCie,EAAQ,GAAK,oCAAsCA,EAAQ,oBAAuBje,EAAM,kCAAqCie,EAAQ,GAAK,yEAA2EA,EAAQ,GAAK,YAAcA,EAAQ,KAAQje,EAAM,6BAAgCie,EAAQ,GAAK,wCAA0C7J,EAAQ,+BAAiC6J,EAAQ,GAAK,kCAAoCA,EAAQ,KAAQje,EAAM,eAAkBie,EAAQ,GAAK,0BAA4BA,EAAQ,oEAAsEA,EAAQ,KAAQje,EAAM,cAAiBie,EAAQ,KAAQje,EAAM,0BAA6Bie,EAAQ,mCAKt7C7J,IAOR,CACDpU,IAAK,uBACLN,MAAO,cAMN,CACDM,IAAK,QACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OACdrgB,EAAOoF,KAAKpF,KACZugB,EAAQnb,KAAKmb,MACbje,EAAM8C,KAAK9C,IAEX0Q,GADQ5N,KAAKwb,MACLP,EAAOrN,OAEf0D,EAAQ,GAEZ,GAAI1D,EAAO,CAET,GAAI/E,MAAMzJ,QAAQwO,SASX,GAAsE,iBAAhD,IAAVA,EAAwB,YAAckN,EAAQlN,KAAkC,OAAVA,EAAgB,CACvG,IAAIiO,EAAS,KAAOV,EAAQ,GAG5B7J,GAAS,iCAAmC6J,EAAQ,GAAK,6CAA+CA,EAAQ,GAAK,+bAAicU,EAAS,SAAWA,EAAS,WAAaA,EAAS,sBAFvlB,IAAI9d,EAAY6P,EAAO,CAAE4N,MAAOK,EAAQjhB,KAAMA,EAAMugB,MAAOA,EAAQ,IAEwjBS,UAAY,0BAKzpBtK,EADE1W,IAASoF,KACH,uNAA2NsR,EAAQ,0BAInO,uCAAyC6J,EAAQ,KAAQje,EAAM,iBAAoBie,EAAQ,oBAAuBje,EAAM,+BAAkCie,EAAQ,GAAK,YAAcA,EAAQ,KAAQje,EAAM,+BAAkCie,EAAQ,GAAK,kCAAoCA,EAAQ,oBAAuBje,EAAM,8BAAiCie,EAAQ,KAAQje,EAAM,gCAAmCie,EAAQ,GAAK,oCAAsCA,EAAQ,oBAAuBje,EAAM,kCAAqCie,EAAQ,GAAK,uEAAyEA,EAAQ,GAAK,YAAcA,EAAQ,KAAQje,EAAM,2BAA8Bie,EAAQ,GAAK,oCAAsC7J,EAAQ,6BAA+B6J,EAAQ,GAAK,gCAAkCA,EAAQ,KAAQje,EAAM,eAAkBie,EAAQ,GAAK,wBAA0BA,EAAQ,8DAAgEA,EAAQ,KAAQje,EAAM,cAAiBie,EAAQ,KAAQje,EAAM,wBAA2Bie,EAAQ,4BAI3kC,OAAO7J,IAOR,CACDpU,IAAK,kBACLN,MAAO,eACL,CAAC,CACHM,IAAK,UACLN,MAAO,SAAiBqe,GACtB,IACI3J,EADc,IAAIvT,EAAYkd,GACVW,UAGxB,IACE,OAAO,IAAIvO,SAAS,SAAU,SAAU,UAAWiE,GACnD,MAAOzK,GACPyS,QAAQC,IAAI1S,EAAGA,EAAEoL,YAKhBlU,EA9SS,GAiTlBhD,EAAOD,QAAUiD,G,6BCtTjB,IAAI+c,EAA4B,mBAAXpe,QAAoD,iBAApBA,OAAOqe,SAAwB,SAAUpd,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAyB,mBAAXjB,QAAyBiB,EAAIqd,cAAgBte,QAAUiB,IAAQjB,OAAOa,UAAY,gBAAkBI,GAElQwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIpV,EAAc,EAAQ,IAYtB2d,EAAa,CAAC,MAAO,SAAU,UAAW,OAAQ,OAAQ,QAU1D5d,EAAY,WAOd,SAASA,EAAU6d,IA/BrB,SAAyBnI,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAgC5GyT,CAAgB7T,KAAM9B,GAEtB8B,KAAK+b,IAAMA,GAAO,GAuKpB,OAzJA5I,EAAajV,EAAW,CAAC,CACvBhB,IAAK,QACLN,MAAO,SAAeyL,GACpB,IAAIkM,EAAQvU,KAEZA,KAAK+b,IAAIxG,QAAQ,SAAUyG,GACzB,IAAIC,EAAKD,EAAUC,GAEnB,IAAKA,EACH,MAAM,IAAIhc,MAAM,wCAGlB,IAAgC,IAA5B6b,EAAW3Y,QAAQ8Y,GACrB,MAAM,IAAIhc,MAAM,wCAGlB,IAAK+b,EAAUE,KACb,MAAM,IAAIjc,MAAM,0CAGlBsU,EAAM0H,GAAID,EAAW3T,OAWxB,CACDnL,IAAK,MACLN,MAAO,SAAaqf,EAAI5T,GACtB,QAAiB5H,IAAbwb,EAAGrf,MACL,MAAM,IAAIqD,MAAM,+CAGJ,IAAI9B,EAAY8d,EAAGC,KA7E1B,GA8ECC,IAAI9T,EAAQ4T,EAAGrf,SAUxB,CACDM,IAAK,SACLN,MAAO,SAAgBqf,EAAI5T,GACX,IAAIlK,EAAY8d,EAAGC,MACzBE,OAAO/T,KAUhB,CACDnL,IAAK,UACLN,MAAO,SAAiBqf,EAAI5T,GAC1B,QAAiB5H,IAAbwb,EAAGrf,MACL,MAAM,IAAIqD,MAAM,mDAGJ,IAAI9B,EAAY8d,EAAGC,MACzBnP,QAAQ1E,EAAQ4T,EAAGrf,SAU5B,CACDM,IAAK,OACLN,MAAO,SAAcqf,EAAI5T,GACvB,QAAgB5H,IAAZwb,EAAG9b,KACL,MAAM,IAAIF,MAAM,+CAGlB,GAAIgc,EAAGC,KAAK/T,MAAM,IAAIuS,OAAO,IAAMuB,EAAG9b,OACpC,MAAM,IAAIF,MAAM,+CAGlB,IAAIoc,EAAU,IAAIle,EAAY8d,EAAGC,MAC7B/b,EAAO,IAAIhC,EAAY8d,EAAG9b,MAC1BvD,EAAQuD,EAAK3D,IAAI6L,GAErBlI,EAAKic,OAAO/T,GACZgU,EAAQF,IAAI9T,EAAQzL,KAUrB,CACDM,IAAK,OACLN,MAAO,SAAcqf,EAAI5T,GACvB,QAAgB5H,IAAZwb,EAAG9b,KACL,MAAM,IAAIF,MAAM,+CAGlB,IAAIoc,EAAU,IAAIle,EAAY8d,EAAGC,MAE7Btf,EADO,IAAIuB,EAAY8d,EAAG9b,MACb3D,IAAI6L,GAErBgU,EAAQF,IAAI9T,EAAQzL,KAUrB,CACDM,IAAK,OACLN,MAAO,SAAcqf,EAAI5T,GACvB,QAAiB5H,IAAbwb,EAAGrf,MACL,MAAM,IAAIqD,MAAM,gDAGlB,IACIrD,EADU,IAAIuB,EAAY8d,EAAGC,MACb1f,IAAI6L,GAUpB,GARIyS,EAAQmB,EAAGrf,OAQXA,IAAUqf,EAAGrf,MACf,MAAM,IAAIqD,MAAM,yCAMnB/B,EAjLO,GAyLhBnD,EAAOD,QAAUoD,G,6BCrNjB,IAAI4c,EAA4B,mBAAXpe,QAAoD,iBAApBA,OAAOqe,SAAwB,SAAUpd,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAyB,mBAAXjB,QAAyBiB,EAAIqd,cAAgBte,QAAUiB,IAAQjB,OAAOa,UAAY,gBAAkBI,GAElQwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIqH,EAAU,EAAQ,IAOlB0B,EAAa,EAQbje,EAAY,WA2Cd,SAASA,EAAU4c,GACjB,IAAIrJ,EAAU7J,UAAUrI,OAAS,QAAsBe,IAAjBsH,UAAU,GAAmBA,UAAU,GAAK,IA7DtF,SAAyB6L,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCA+D5GyT,CAAgB7T,KAAM3B,GAGtB2B,KAAKib,OAASA,EAGd5e,OAAOob,OAAOzX,KAAM4R,GAGf5R,KAAKuc,UACRvc,KAAKuc,QAAU,KAII,IAAjBvc,KAAKhF,UACPgF,KAAKhF,SAAU,GAymCnB,OArqCAmY,EAAa9U,EAAW,KAAM,CAAC,CAC7BnB,IAAK,UAYLN,MAAO,SAAiBqe,GACtB,IAEI3C,EAAO,kZAFK,IAAIja,EAAU4c,GAE2YW,UAAY,gGAErb,OAAO,IAAIvO,SAAS,OAAQiL,KAS7B,CACDpb,IAAK,UACLV,IAAK,WACH,OAAO8f,QAkDXnJ,EAAa9U,EAAW,CAAC,CACvBnB,IAAK,UACLN,MAAO,WACL,IAAI0U,EAAQ,GAwBZ,OAtBItR,KAAKhF,UACPsW,GAAStR,KAAKwc,YAIhBlL,GAAStR,KAAKyB,OAKd6P,GAAStR,KAAKM,QACdgR,GAAStR,KAAKyc,SACdnL,GAAStR,KAAK3C,SACdiU,GAAStR,KAAKY,SAGd0Q,GAAStR,KAAKyN,OACd6D,GAAStR,KAAK0c,QACdpL,GAAStR,KAAK2c,QACdrL,GAAStR,KAAK4c,MACdtL,GAAStR,KAAK6c,UASf,CACD3f,IAAK,OACLN,MAAO,WACL,MAAO,0EAOR,CACDM,IAAK,MACLN,MAAO,WACL,MAAO,+HAcR,CACDM,IAAK,OACLN,MAAO,WACL,IAAI6E,EAAOzB,KAAKib,OAAOxZ,KACnB8a,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAER7P,IAaF6P,GAAS,cAAgBiL,EAAU,qDAZvB1T,MAAMzJ,QAAQqC,GAAQA,EAAO,CAACA,IACnB0S,IAAI,SAAU1S,GAEnC,MAAa,UAATA,EAAyB,wBAChB,YAATA,EAA2B,6BAClB,YAATA,EAA2B,2BAClB,SAATA,EAAwB,iBACf,WAATA,EAA0B,4BACjB,WAATA,EAA0B,wEACjB,WAATA,EAA0B,iCAA9B,IACC2G,KAAK,QAE8F,iJAGxG,OAAOkJ,IA4CR,CACDpU,IAAK,QACLN,MAAO,WACL,IACIkgB,EAAc9c,KAAK8c,YADR,CAAC,kBAAmB,QAAS,WAAY,WAAY,gBAEhExL,EAAQ,GAMZ,OAJIwL,EAAYpd,OAAS,IACvB4R,GAAS,gGAAkGwL,EAAc,qBAGpHxL,IAcR,CACDpU,IAAK,SACLN,MAAO,WACL,IACIkgB,EAAc9c,KAAK8c,YADR,CAAC,UAAW,UAAW,eAElCxL,EAAQ,GAMZ,OAJIwL,EAAYpd,OAAS,IACvB4R,GAAS,sGAA0GwL,EAAc,qBAG5HxL,IAcR,CACDpU,IAAK,SACLN,MAAO,WACL,IACIkgB,EAAc9c,KAAK8c,YADR,CAAC,gBAAiB,gBAAiB,uBAAwB,aAAc,oBAAqB,eAAgB,qBAAsB,yBAE/IxL,EAAQ,GAMZ,OAJIwL,EAAYpd,OAAS,IACvB4R,GAAS,iJAAqJwL,EAAc,qBAGvKxL,IAcR,CACDpU,IAAK,SACLN,MAAO,WACL,IACIkgB,EAAc9c,KAAK8c,YADR,CAAC,YAAa,YAAa,UAAW,WAEjDxL,EAAQ,GAMZ,OAJIwL,EAAYpd,OAAS,IACvB4R,GAAS,sGAA0GwL,EAAc,qBAG5HxL,IAeR,CACDpU,IAAK,cACLN,MAAO,SAAqBmgB,GAC1B,IAAIxI,EAAQvU,KAERib,EAASjb,KAAKib,OAEd3J,EAAQ,GAUZ,OARkBjV,OAAO6W,KAAK+H,GAAQ+B,OAAO,SAAU9f,GACrD,OAAkC,IAA3B6f,EAAS5Z,QAAQjG,KAGdqY,QAAQ,SAAU0H,GAC5B3L,GAASiD,EAAM0I,OAGV3L,IAcR,CACDpU,IAAK,OACLN,MAAO,WACL,IAAIsgB,EAAald,KAAKib,OAAOxN,KACzB8O,EAAUvc,KAAKuc,QAEfY,EAAa,CAAC,uBACd7L,EAAQ,GAkCZ,OAhCI4L,IACFA,EAAW3H,QAAQ,SAAU3Y,GAC3B,YAAyB,IAAVA,EAAwB,YAAcke,EAAQle,IAC3D,IAAK,UAIL,IAAK,SACHugB,EAAWtY,KAAK,aAAejI,GAC/B,MAEF,IAAK,SACHugB,EAAWtY,KAAK,cAAgBjI,EAAQ,KACxC,MAEF,IAAK,SACW,OAAVA,EACFugB,EAAWtY,KAAK,kBAEhBsY,EAAWtY,KAAK,IAAOkS,KAAKC,UAAUpa,GAAS,+BAEjD,MAEF,QACE,MAAM,IAAIqD,MAAM,8CAKtBqR,GAAS,mCAAqCiL,EAAU,gCAAkCY,EAAW/U,KAAK,QAAU,wLAG/GkJ,IAeR,CACDpU,IAAK,QACLN,MAAO,WACL,IAAI8f,EAAQ1c,KAAKib,OAAOyB,MACpBH,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAaZ,OAXIzI,MAAMzJ,QAAQsd,KAChBpL,GAAS,iHAEToL,EAAMnH,QAAQ,SAAU6H,GACtB,IAAIC,EAAY,IAAIhf,EAAU+e,EAAW,CAAEb,QAASA,IACpDjL,GAAS,4DAA8D+L,EAAUzB,UAAY,6GAG/FtK,GAAS,2JAGJA,IAeR,CACDpU,IAAK,QACLN,MAAO,WACL,IAAI+f,EAAQ3c,KAAKib,OAAO0B,MACpBJ,EAAUvc,KAAKuc,QAEfjL,EAAQ,GASZ,OAPIzI,MAAMzJ,QAAQud,IAChBA,EAAMpH,QAAQ,SAAU6H,GACtB,IAAIC,EAAY,IAAIhf,EAAU+e,EAAW,CAAEb,QAASA,IACpDjL,GAAS,aAAe+L,EAAUzB,UAAY,eAI3CtK,IAeR,CACDpU,IAAK,QACLN,MAAO,WACL,IAAIigB,EAAQ7c,KAAKib,OAAO4B,MACpBN,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAaZ,OAXIzI,MAAMzJ,QAAQyd,KAChBvL,GAAS,sCAAwCiL,EAAU,oIAE3DM,EAAMtH,QAAQ,SAAU6H,GACtB,IAAIC,EAAY,IAAIhf,EAAU+e,EAAW,CAAEb,QAASA,IACpDjL,GAAS,4DAA8D+L,EAAUzB,UAAY,+GAG/FtK,GAAS,mWAGJA,IAcR,CACDpU,IAAK,MACLN,MAAO,WACL,IAAIggB,EAAM5c,KAAKib,OAAO2B,IAClBL,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAEsD,iBAA9C,IAARsL,EAAsB,YAAc9B,EAAQ8B,KAA8B,OAARA,GAAiB/T,MAAMzJ,QAAQwd,KAI3GtL,GAAS,6PAFO,IAAIjT,EADJue,EACyB,CAAEL,QAASA,IAE8NX,UAAY,keAGhS,OAAOtK,IAeR,CACDpU,IAAK,aACLN,MAAO,WACL,IAAIqe,EAASjb,KAAKib,OACdsB,EAAUvc,KAAKuc,QACfhP,EAAa0N,EAAO1N,WACpBiP,EAAWvB,EAAOuB,SAElBlL,EAAQtR,KAAK6E,OA0BjB,OAvBA2X,EAAW3T,MAAMzJ,QAAQod,GAAYA,EAAW,GAEgC,iBAArD,IAAfjP,EAA6B,YAAcuN,EAAQvN,KAC7DlR,OAAO6W,KAAK3F,GAAYgI,QAAQ,SAAUrY,GACxC,IAAIkgB,EAAY7P,EAAWrQ,GACvBogB,GAAwC,IAA3Bd,EAASrZ,QAAQjG,GAO9B0Z,EAAa,IAAIvY,EAAU+e,EAAW,CAAEb,QAH9B,CAACA,EAASrf,GAAK8f,OAAO,SAAUO,GAC5C,QAASA,IACRnV,KAAK,KACsDpN,QAASsiB,IAGvEhM,GAAS,gCAAmCpU,EAAM,eAElDoU,GAASsF,EAAWgF,YAIxBtK,GAAStR,KAAKwd,QAkBf,CACDtgB,IAAK,kBACLN,MAAO,WACL,MAAO,qEAAuEoD,KAAK6E,OAAS,8GAAgH7E,KAAKyd,qBAAuB,aAAezd,KAAK0d,wBAA0B,sBAAwB1d,KAAKwd,MAAQ,WAa5T,CACDtgB,IAAK,qBACLN,MAAO,WACL,IAAI+gB,EAAoB3d,KAAKib,OAAO0C,kBAEhCrM,EAAQ,GAUZ,MAR8F,iBAA5D,IAAtBqM,EAAoC,YAAc7C,EAAQ6C,KACpEthB,OAAO6W,KAAKyK,GAAmBpI,QAAQ,SAAUkF,GAC/C,IACI4C,EAAY,IAAIhf,EADJsf,EAAkBlD,IAElCnJ,GAAS,8BAAiCmJ,EAAU,kDAAqD4C,EAAUzB,UAAY,4BAI5HtK,IAcR,CACDpU,IAAK,wBACLN,MAAO,WACL,IAAIghB,EAAU5d,KAAKib,OACf1N,EAAaqQ,EAAQrQ,WACrBkO,EAAuBmC,EAAQnC,qBAC/Bc,EAAUvc,KAAKuc,QAGfjL,EAAQ,GAGR6L,EAAa,CAAC,oBAQlB,GALA9gB,OAAO6W,KAAK3F,GAAc,IAAIgI,QAAQ,SAAUrY,GAC9CigB,EAAWtY,KAAK,YAAe3H,EAAM,OAI6D,iBAA/D,IAAzBue,EAAuC,YAAcX,EAAQW,IAAqC,CAC5G,IACI4B,EAAY,IAAIhf,EADJod,EACyB,CAAEc,QAASA,EAAU,YAC9DjL,GAAS,4DAA8D6L,EAAW/U,KAAK,QAAU,kBAAoBiV,EAAUzB,UAAY,sBAQ7I,OAJ6B,IAAzBH,IACFnK,GAAS,4EAA8E6L,EAAW/U,KAAK,QAAU,iMAG5GkJ,IAcR,CACDpU,IAAK,oBACLN,MAAO,WACL,IAAI0U,EAAQ,GAOZ,OALKtR,KAAK6d,wBACR7d,KAAK6d,uBAAwB,EAC7BvM,GAAStR,KAAK8d,mBAGTxM,IAcR,CACDpU,IAAK,uBACLN,MAAO,WACL,IAAI0U,EAAQ,GAOZ,OALKtR,KAAK6d,wBACR7d,KAAK6d,uBAAwB,EAC7BvM,GAAStR,KAAK8d,mBAGTxM,IAcR,CACDpU,IAAK,gBACLN,MAAO,WACL,IAAImhB,EAAgB/d,KAAKib,OAAO8C,cAIhC,MAAO,gBAHO/d,KAAKuc,QAGgB,4DAA8DwB,EAAgB,2KAclH,CACD7gB,IAAK,gBACLN,MAAO,WACL,IAAIohB,EAAgBhe,KAAKib,OAAO+C,cAIhC,MAAO,gBAHOhe,KAAKuc,QAGgB,4DAA8DyB,EAAgB,4KAsBlH,CACD9gB,IAAK,eACLN,MAAO,WACL,IAAIqhB,EAAeje,KAAKib,OAAOgD,aAC3B1B,EAAUvc,KAAKuc,QAGfjL,EAAQtR,KAAK6E,OAwBjB,MAtBoF,iBAAvD,IAAjBoZ,EAA+B,YAAcnD,EAAQmD,KAC/D5hB,OAAO6W,KAAK+K,GAAc1I,QAAQ,SAAUrY,GAC1C,IAAIghB,EAAaD,EAAa/gB,GAC1BigB,EAAa,GAEjB,GAAItU,MAAMzJ,QAAQ8e,GAChBA,EAAW3I,QAAQ,SAAU+F,GAC3B6B,EAAWtY,KAAK,cAAiByW,EAAO,sBAG1ChK,GAAS,gCAAmCpU,EAAM,wBAA2BigB,EAAW/U,KAAK,QAAU,4MAClG,GAAgF,iBAArD,IAAf8V,EAA6B,YAAcpD,EAAQoD,IAA2B,CAC/F,IACIb,EAAY,IAAIhf,EADJ6f,EACyB,CAAE3B,QAASA,IAEpDjL,GAAS,gCAAmCpU,EAAM,sCAAyCmgB,EAAUzB,UAAY,iCAKvHtK,GAAStR,KAAKwd,QAgBf,CACDtgB,IAAK,WACLN,MAAO,WACYoD,KAAKib,OAAO1N,WAA7B,IAGI+D,EAAQ,GAIZ,OAFAA,GAAS,uBAJKtR,KAAKuc,QAIyB,2LAuB7C,CACDrf,IAAK,kBACLN,MAAO,WACL,IAAIuhB,EAAWne,KAAKib,OAChBrN,EAAQuQ,EAASvQ,MACjB8N,EAAkByC,EAASzC,gBAG3BpK,GAFUtR,KAAKuc,QAEP,IAMZ,IAJwB,IAApBb,GAA6B7S,MAAMzJ,QAAQwO,KAC7C0D,GAAS,yEAA4E1D,EAAMlO,OAAS,wLAGZ,iBAA1D,IAApBgc,EAAkC,YAAcZ,EAAQY,KAAsD,OAApBA,GAA4B7S,MAAMzJ,QAAQwO,GAAQ,CACtJ,IACIyP,EAAY,IAAIhf,EADJqd,GAEZ0C,EAAU/f,EAAU+f,QAExB9M,GAAS,0CAA4CtR,KAAK6E,OAAS,yBAA2BuZ,EAAU,MAAQxQ,EAAMlO,OAAS,MAAQ0e,EAAU,0BAA4BA,EAAU,uCAAyCA,EAAU,gBAAkBf,EAAUzB,UAAY,0BAA4B5b,KAAKwd,MAAQ,WAG7T,OAAOlM,IAkCR,CACDpU,IAAK,QACLN,MAAO,WACL,IAAIgR,EAAQ5N,KAAKib,OAAOrN,MACpB2O,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAGZ,GAAIzI,MAAMzJ,QAAQwO,GAChB0D,GAAStR,KAAK6E,OAEd+I,EAAM2H,QAAQ,SAAU+F,EAAME,GAC5B,IACI6B,EAAY,IAAIhf,EADJid,EACyB,CAAEiB,QAASA,EAAU,IAAMf,EAAQ,MAE5ElK,GAAS,wBAA0BkK,EAAQ,iCAAmCA,EAAQ,gBAAkB6B,EAAUzB,UAAY,eAGhItK,GAAStR,KAAKwd,WAGT,GAAsE,iBAAhD,IAAV5P,EAAwB,YAAckN,EAAQlN,KAAkC,OAAVA,EAAgB,CACvG,IACIyP,EAAY,IAAIhf,EADJuP,GAEZwQ,EAAU/f,EAAU+f,QAExB9M,GAAS,+BAAiCtR,KAAK6E,OAAS,yBAA2BuZ,EAAU,UAAYA,EAAU,yBAA2BA,EAAU,wEAA0EA,EAAU,gBAAkBf,EAAUzB,UAAY,0BAA4B5b,KAAKwd,MAAQ,WAG/T,OAAOlM,IAcR,CACDpU,IAAK,WACLN,MAAO,WACL,IAAIyhB,EAAWre,KAAKib,OAAOoD,SAI3B,MAAO,gBAHOre,KAAKuc,QAGgB,0CAA4C8B,EAAW,sKAc3F,CACDnhB,IAAK,WACLN,MAAO,WACL,IAAI0hB,EAAWte,KAAKib,OAAOqD,SAI3B,MAAO,gBAHOte,KAAKuc,QAGgB,0CAA4C+B,EAAW,uKAkB3F,CACDphB,IAAK,cACLN,MAAO,WACL,IAAI2hB,EAAcve,KAAKib,OAAOsD,YAC1BhC,EAAUvc,KAAKuc,QAEfjL,EAAQ,GAMZ,OAJoB,IAAhBiN,IACFjN,GAAS,yBAA2BiL,EAAU,8UAGzCjL,IAgBR,CACDpU,IAAK,YACLN,MAAO,WACL,IAAI4hB,EAAYxe,KAAKib,OAAOuD,UAI5B,MAAO,gBAHOxe,KAAKuc,QAGgB,+DAAiEiC,EAAY,8JAgBjH,CACDthB,IAAK,YACLN,MAAO,WACL,IAAI6hB,EAAYze,KAAKib,OAAOwD,UAI5B,MAAO,gBAHOze,KAAKuc,QAGgB,+DAAiEkC,EAAY,6JAcjH,CACDvhB,IAAK,UACLN,MAAO,WACL,IAAI6d,EAAUza,KAAKib,OAAOR,QACtB8B,EAAUvc,KAAKuc,QAGnB,GAAI9B,EACF,MAAO,kBAAoB8B,EAAU,6DAAgE9B,EAAU,uMAmBlH,CACDvd,IAAK,SACLN,MAAO,WACL,IAAI+d,EAAS3a,KAAKib,OAAON,OACrB4B,EAAUvc,KAAKuc,QAEfmC,EAAU9D,EAAQjD,QAAQgD,GAE9B,GAAI+D,EACF,MAAO,cAAgBnC,EAAU,4CAA8CmC,EAAU,kHAAsH/D,EAAS,4CAmB3N,CACDzd,IAAK,UACLN,MAAO,WACL,IAAI+hB,EAAW3e,KAAKib,OAChB2D,EAAUD,EAASC,QACnBC,EAAmBF,EAASE,iBAKhC,MAAO,gBAJO7e,KAAKuc,QAIgB,0CAFC,IAArBsC,EAA4B,KAAO,KAEsC,IAAMD,EAAU,4JAkBzG,CACD1hB,IAAK,UACLN,MAAO,WACL,IAAIkiB,EAAW9e,KAAKib,OAChB8D,EAAUD,EAASC,QACnBC,EAAmBF,EAASE,iBAKhC,MAAO,gBAJOhf,KAAKuc,QAIgB,0CAFC,IAArByC,EAA4B,KAAO,KAEsC,IAAMD,EAAU,4JAczG,CACD7hB,IAAK,aACLN,MAAO,WACL,IAAIqiB,EAAajf,KAAKib,OAAOgE,WAEzB3N,EAAQ,GAEZ,GAA0B,iBAAf2N,EAAyB,CAClC,IACIC,EADSD,EAAWnd,WAAWpC,OACXuf,EAAWE,QAAQ,GAAGzf,OAAS,EACnD6K,EAAM2U,EAAW,EAAI1Z,KAAK+E,IAAI,GAAI2U,GAAY,EASlD5N,GAAS,kBANL4N,EAAW,EACD,YAAc3U,EAAM,OAAS0U,EAAa1U,EAAM,SAEhD,WAAa0U,EAAa,UAGA,0IAA+IA,EAAa,qCAGtM,OAAO3N,MAIJjT,EAtqCO,GA8qChBtD,EAAOD,QAAUuD,G,8BC1sCjB,YAEA,IAAI+gB,EAAc1Y,EAAO0Y,YAAc1Y,EAAO0Y,YAC5C,EAAQ,IAAiBA,YAC3BrkB,EAAOD,QAAUskB,I,8CCOjB,IAAIvK,EAAoB,SAAUwK,GAGhC,SAASxK,EAAkBhH,IAZ7B,SAAyB+F,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAa5GyT,CAAgB7T,KAAM6U,GAEtB,IAAIN,EAbR,SAAoC1C,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EAalNyjB,CAA2Bvf,MAAO6U,EAAkBhV,WAAaxD,OAAOmU,eAAeqE,IAAoB/Y,KAAKkE,OAG5H,OADAuU,EAAMlF,QAAUxB,EAAM,gCACf0G,EAGT,OAjBF,SAAmBiL,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAM/dE,CAAU9K,EAYV5U,OADO4U,EAZe,GAoBxB9Z,EAAOD,QAAU+Z,G,6BC7BjB9Z,EAAOD,QAAU,CACf8kB,UAAW,EAAQ,IACnB/K,kBAAmB,EAAQ,M,6BCO7B,IAAI+K,EAAY,SAAUP,GAGxB,SAASO,EAAUvQ,GAGjB,OAfJ,SAAyBuE,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAa5GyT,CAAgB7T,KAAM4f,GAX1B,SAAoC/N,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EAavNyjB,CAA2Bvf,MAAO4f,EAAU/f,WAAaxD,OAAOmU,eAAeoP,IAAY9jB,KAAKkE,KAAMqP,IAG/G,OAdF,SAAmBmQ,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAM/dE,CAAUC,EASV3f,OADO2f,EATO,GAiBhB7kB,EAAOD,QAAU8kB,G,6BCrBjB,IAAIzM,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAQnB,IACIvV,EADW,EAAQ,GACKA,aAExBc,EAAY,EAAQ,GACpBP,EAAM,EAAQ,IAMdC,EAAM,SAAUqhB,GAGlB,SAASrhB,IAGP,OAtBJ,SAAyBoV,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAoB5GyT,CAAgB7T,KAAMxB,GAlB1B,SAAoCqT,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EAoBvNyjB,CAA2Bvf,MAAOxB,EAAIqB,WAAaxD,OAAOmU,eAAehS,IAAM6H,MAAMrG,KAAM+H,YA4BpG,OA9CF,SAAmByX,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAa/dE,CAAUnhB,EAkCVR,GA1BAmV,EAAa3U,EAAK,KAAM,CAAC,CACvBtB,IAAK,YASLN,MAAO,SAAmBkjB,GACxB,OAAOvhB,EAAI8W,UAAUyK,KAEtB,CACD5iB,IAAK,SAMLV,IAAK,WACH,OAAOsC,MAIJN,EAlCC,GA0CVzD,EAAOD,QAAU0D,G,6BC7DjB,IAQIO,EAAe,IAAIX,EARR,EAAQ,GACGA,YAOQ,CAChCqD,KAAM,SACN8L,WAAY,CACV2F,KAAM,CACJzR,KAAM,QACNmM,MAVU,EAAQ,OAkBxB7S,EAAOD,QAAUiE,G,6BCtBjB,IAAIH,EAAkB,EAAQ,IAC1BI,EAAqB,EAAQ,IAC7BH,EAAmB,EAAQ,IAgB3BI,EAAY,IAAIb,EAdL,EAAQ,GACGA,YAaK,CAC7BqD,KAAM,SACN8L,WAAY,CAKV9L,KAAM,CACJA,KAAM,SACNgM,KAAM,CAAC,MAAO,QAMhBsS,SAAU,CACRte,KAAM,SAMRue,OAAQnhB,EAKRohB,UAAWphB,EAKXqhB,YAAarhB,EAKbshB,GAAIvhB,EAKJwhB,IAAKxhB,EAKLyhB,WAAYzhB,EAKZ0hB,IAAK1hB,EAKL2hB,WAAY,CACV9e,KAAM,QACNmM,MAAO,CACLnM,KAAM,SACN8L,WAAY,CACVyS,OAAQnhB,EACR2hB,cAAe5hB,KAQrB6hB,QAASzhB,EAKT0hB,WAAY,CACVjf,KAAM,QACNmM,MAAO,CACLnM,KAAM,SACN8L,WAAY,CACV0S,UAAWphB,EACXmhB,OAAQnhB,EACRsW,UAAWvW,EACX1B,IAAK,CAAEuE,KAAM,aAQnB0T,UAAWvW,EAKX+hB,SAAU,CACRlf,KAAM,UACNnD,SAAS,GAMXpB,IAAK,CACHuE,KAAM,UAMRmf,cAAe,CACbnf,KAAM,SACNgM,KAAM,CAAC,UAAW,OAAQ,aAC1BnP,QAAS,cAQfvD,EAAOD,QAAUmE,G,6BC7IjB,IAQIL,EAAkB,IAAIR,EARX,EAAQ,GACGA,YAOW,CACnCqD,KAAM,SACNkZ,OAAQ,cAMV5f,EAAOD,QAAU8D,G,6BChBjB,IA8BII,EAAqB,IAAIZ,EA9Bd,EAAQ,GACGA,YA6Bc,CACtCmP,WAAY,CA+BVsT,IAAK,CACHpf,KAAM,SACNkZ,OAAQ,eAmBV/O,IAAK,CACHnK,KAAM,SACNkZ,OAAQ,eAuBVmG,IAAK,CACHrf,KAAM,CAAC,QAAS,UAChBkZ,OAAQ,cACR/M,MAAO,CACL+M,OAAQ,gBAsBZoG,IAAK,CACHtf,KAAM,SACNkZ,OAAQ,eAmBVqG,IAAK,CACHvf,KAAM,SACNkZ,OAAQ,eAgBVsG,IAAK,CACHxf,KAAM,SACNkZ,OAAQ,eAoBVuG,IAAK,CACHzf,KAAM,aAQZ1G,EAAOD,QAAUkE,G,6BC5MD,EAAQ,GAAxB,IAqBIH,EAAmB,IAAIT,EAnBZ,EAAQ,GACGA,YAkBY,CACpCqD,KAAM,SACN8L,WAAY,CAuEV4T,IAAK,CACH1f,KAAM,UAiER2f,IAAK,CACH3f,KAAM,SACNgM,KAAM,CAAC,QA8CTI,IAAK,CACHpM,KAAM,SACNkZ,OAAQ,eAiCV0G,IAAK,CACH5f,KAAM,SACNkZ,OAAQ,OA0DV7M,IAAK,CACHrM,KAAM,UAuCRsM,IAAK,CACHtM,KAAM,SACNkZ,OAAQ,OAqCV3M,IAAK,CACHvM,KAAM,QACNmM,MAAO,CACLnM,KAAM,SACNkZ,OAAQ,WA+BZ1M,IAAK,CACHxM,KAAM,SACNkZ,OAAQ,aAmFV2G,KAAM,CACJ7f,KAAM,QACNmM,MAAO,CACLnM,KAAM,UAER4c,SAAU,GA4BZkD,IAAK,CACH9f,KAAM,SACNkZ,OAAQ,eA2BV6G,IAAK,CACH/f,KAAM,aAQZ1G,EAAOD,QAAU+D,G,6BChkBjB,IAAI4iB,EAAgb,SAAUpe,EAAK1H,GAAK,GAAIkN,MAAMzJ,QAAQiE,GAAQ,OAAOA,EAAY,GAAI3G,OAAOqe,YAAY1e,OAAOgH,GAAQ,OAAxf,SAAuBA,EAAK1H,GAAK,IAAImN,EAAO,GAAQ4Y,GAAK,EAAUC,GAAK,EAAWC,OAAKnhB,EAAW,IAAM,IAAK,IAAiCohB,EAA7BC,EAAKze,EAAI3G,OAAOqe,cAAmB2G,GAAMG,EAAKC,EAAGC,QAAQC,QAAoBlZ,EAAKjE,KAAKgd,EAAGjlB,QAAYjB,GAAKmN,EAAKpJ,SAAW/D,GAA3D+lB,GAAK,IAAoE,MAAO1P,GAAO2P,GAAK,EAAMC,EAAK5P,EAAO,QAAU,KAAW0P,GAAMI,EAAW,QAAGA,EAAW,SAAO,QAAU,GAAIH,EAAI,MAAMC,GAAQ,OAAO9Y,EAA6HmZ,CAAc5e,EAAK1H,GAAa,MAAM,IAAIyE,UAAU,yDAEllB+S,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAOnB,IAAI2O,EAAY,EAAQ,GACpB3jB,EAAM,EAAQ,IAGdqhB,EADW,EAAQ,IACEA,UAOrBjhB,EAAM,WACR,SAASA,KAjBX,SAAyBiV,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAkB5GyT,CAAgB7T,KAAMrB,GA6FxB,OA1FAwU,EAAaxU,EAAK,KAAM,CAAC,CACvBzB,IAAK,OAYLN,MAAO,SAAc4X,GACnB,IAAIiM,EAAUyB,EAAUnL,KAAKC,UAAUxC,EAAMiM,UAG7C,GAA4B,YAAxBjM,EAAMoM,cAA6B,CACrC,IAAI1jB,EAAMsX,EAAMtX,IACZ2Q,EAAM2G,EAAMwL,OAAOnS,IAGnBnM,EADSwgB,EAAUnL,KAAKC,UAAUxC,EAAMwL,SACxB,IAAMS,EAE1B,OAAOliB,EAAI2W,KAAKrH,EAAK3Q,EAAKwE,GAAM0V,KAAK,SAAUjC,GAC7C,OAAOzT,EAAO,IAAMyT,IAUxB,OALIX,EAAMoM,cAGNpM,EAAMoM,cAEH5L,QAAQC,OAAO,IAAI2K,EAAU,gCAOrC,CACD1iB,IAAK,SACLN,MAAO,SAAgBulB,GAEjBA,EAAIzB,WAIR,IAAIxjB,EAAMilB,EAAIjlB,IACViY,EAAYgN,EAAIhN,UAChBtH,EAAMsU,EAAInC,OAAOnS,IAIrB,GAAIsU,EAAIhN,UAAW,CACjB,IAAIiN,EAAgBX,EAAeU,EAAIpC,SAAU,GAI7Cre,EAHS0gB,EAAc,GAGP,IAFNA,EAAc,GAI5B,MAAY,SAARvU,EACKmH,QAAQC,OAAO,IAAI2K,EAAU,gDAG/BrhB,EAAI6W,OAAOvH,EAAK3Q,EAAKiY,EAAWzT,GAAM0V,KAAK,SAAUuJ,GAE1D,OADAwB,EAAIxB,SAAWA,EACRA,IAIX,GAAY,SAAR9S,EAAgB,CAClB,IAAK3Q,IAAQiY,EAGX,OAFAgN,EAAIxB,UAAW,EAER3L,QAAQ2C,SAAQ,GAGzB,GAAIza,EACF,OAAO8X,QAAQC,OAAO,IAAI2K,EAAU,oDAKxC,OAAO5K,QAAQC,OAAO,IAAI2K,EAAU,6BAIjCjhB,EA/FC,GAuGV5D,EAAOD,QAAU6D,G,6BCtGjB,IAOI0jB,EAPAC,EAAuB,iBAAZC,QAAuBA,QAAU,KAC5CC,EAAeF,GAAwB,mBAAZA,EAAEjc,MAC7Bic,EAAEjc,MACF,SAAsBgC,EAAQoa,EAAUC,GACxC,OAAOrV,SAAS9P,UAAU8I,MAAMvK,KAAKuM,EAAQoa,EAAUC,IAKzDL,EADEC,GAA0B,mBAAdA,EAAEK,QACCL,EAAEK,QACVtmB,OAAOumB,sBACC,SAAwBva,GACvC,OAAOhM,OAAOwmB,oBAAoBxa,GAC/BZ,OAAOpL,OAAOumB,sBAAsBva,KAGxB,SAAwBA,GACvC,OAAOhM,OAAOwmB,oBAAoBxa,IAQtC,IAAIya,EAAc5e,OAAOjB,OAAS,SAAqBrG,GACrD,OAAOA,GAAUA,GAGnB,SAASmmB,IACPA,EAAaC,KAAKlnB,KAAKkE,MAEzBjF,EAAOD,QAAUioB,EAGjBA,EAAaA,aAAeA,EAE5BA,EAAaxlB,UAAU0lB,aAAUxiB,EACjCsiB,EAAaxlB,UAAU2lB,aAAe,EACtCH,EAAaxlB,UAAU4lB,mBAAgB1iB,EAIvC,IAAI2iB,EAAsB,GAoC1B,SAASC,EAAiB5jB,GACxB,YAA2BgB,IAAvBhB,EAAK0jB,cACAJ,EAAaK,oBACf3jB,EAAK0jB,cAmDd,SAASG,EAAajb,EAAQ5G,EAAM8hB,EAAUC,GAC5C,IAAIznB,EACA0nB,EACAC,EAnHsBC,EAqH1B,GAAwB,mBAAbJ,EACT,MAAM,IAAInjB,UAAU,0EAA4EmjB,GAqBlG,QAjBe9iB,KADfgjB,EAASpb,EAAO4a,UAEdQ,EAASpb,EAAO4a,QAAU5mB,OAAOY,OAAO,MACxCoL,EAAO6a,aAAe,SAIKziB,IAAvBgjB,EAAOG,cACTvb,EAAOwb,KAAK,cAAepiB,EACf8hB,EAASA,SAAWA,EAASA,SAAWA,GAIpDE,EAASpb,EAAO4a,SAElBS,EAAWD,EAAOhiB,SAGHhB,IAAbijB,EAEFA,EAAWD,EAAOhiB,GAAQ8hB,IACxBlb,EAAO6a,kBAeT,GAbwB,mBAAbQ,EAETA,EAAWD,EAAOhiB,GAChB+hB,EAAU,CAACD,EAAUG,GAAY,CAACA,EAAUH,GAErCC,EACTE,EAASI,QAAQP,GAEjBG,EAAS7e,KAAK0e,IAIhBxnB,EAAIsnB,EAAiBhb,IACb,GAAKqb,EAAShkB,OAAS3D,IAAM2nB,EAASK,OAAQ,CACpDL,EAASK,QAAS,EAGlB,IAAIC,EAAI,IAAI/jB,MAAM,+CACEyjB,EAAShkB,OAAS,IAAM+D,OAAOhC,GAAQ,qEAG3DuiB,EAAE9nB,KAAO,8BACT8nB,EAAEC,QAAU5b,EACZ2b,EAAEviB,KAAOA,EACTuiB,EAAEE,MAAQR,EAAShkB,OAxKGikB,EAyKHK,EAxKnB1K,SAAWA,QAAQ6K,MAAM7K,QAAQ6K,KAAKR,GA4K1C,OAAOtb,EAwBT,SAAS+b,EAAU/b,EAAQ5G,EAAM8hB,GAC/B,IAAInK,EAAQ,CAAEiL,OAAO,EAAOC,YAAQ7jB,EAAW4H,OAAQA,EAAQ5G,KAAMA,EAAM8hB,SAAUA,GACjFgB,EAZN,WAEE,IADA,IAAI7B,EAAO,GACF/mB,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IAAK+mB,EAAK7d,KAAKkD,UAAUpM,IAC1DqE,KAAKqkB,QACRrkB,KAAKqI,OAAOmc,eAAexkB,KAAKyB,KAAMzB,KAAKskB,QAC3CtkB,KAAKqkB,OAAQ,EACb7B,EAAaxiB,KAAKujB,SAAUvjB,KAAKqI,OAAQqa,KAMjBvlB,KAAKic,GAG/B,OAFAmL,EAAQhB,SAAWA,EACnBnK,EAAMkL,OAASC,EACRA,EAgIT,SAASE,EAAWpc,EAAQ5G,EAAMijB,GAChC,IAAIjB,EAASpb,EAAO4a,QAEpB,QAAexiB,IAAXgjB,EACF,MAAO,GAET,IAAIkB,EAAalB,EAAOhiB,GACxB,YAAmBhB,IAAfkkB,EACK,GAEiB,mBAAfA,EACFD,EAAS,CAACC,EAAWpB,UAAYoB,GAAc,CAACA,GAElDD,EAsDT,SAAyBrhB,GAEvB,IADA,IAAI0F,EAAM,IAAIF,MAAMxF,EAAI3D,QACf/D,EAAI,EAAGA,EAAIoN,EAAIrJ,SAAU/D,EAChCoN,EAAIpN,GAAK0H,EAAI1H,GAAG4nB,UAAYlgB,EAAI1H,GAElC,OAAOoN,EA1DL6b,CAAgBD,GAAcE,EAAWF,EAAYA,EAAWjlB,QAoBpE,SAASolB,EAAcrjB,GACrB,IAAIgiB,EAASzjB,KAAKijB,QAElB,QAAexiB,IAAXgjB,EAAsB,CACxB,IAAIkB,EAAalB,EAAOhiB,GAExB,GAA0B,mBAAfkjB,EACT,OAAO,EACF,QAAmBlkB,IAAfkkB,EACT,OAAOA,EAAWjlB,OAItB,OAAO,EAOT,SAASmlB,EAAWxhB,EAAKjG,GAEvB,IADA,IAAIkE,EAAO,IAAIuH,MAAMzL,GACZzB,EAAI,EAAGA,EAAIyB,IAAKzB,EACvB2F,EAAK3F,GAAK0H,EAAI1H,GAChB,OAAO2F,EA5WTjF,OAAOC,eAAeymB,EAAc,sBAAuB,CACzDxmB,YAAY,EACZC,IAAK,WACH,OAAO4mB,GAET5W,IAAK,SAAS1M,GACZ,GAAmB,iBAARA,GAAoBA,EAAM,GAAKgjB,EAAYhjB,GACpD,MAAM,IAAIH,WAAW,kGAAoGG,EAAM,KAEjIsjB,EAAsBtjB,KAI1BijB,EAAaC,KAAO,gBAEGviB,IAAjBT,KAAKijB,SACLjjB,KAAKijB,UAAY5mB,OAAOmU,eAAexQ,MAAMijB,UAC/CjjB,KAAKijB,QAAU5mB,OAAOY,OAAO,MAC7B+C,KAAKkjB,aAAe,GAGtBljB,KAAKmjB,cAAgBnjB,KAAKmjB,oBAAiB1iB,GAK7CsiB,EAAaxlB,UAAUwnB,gBAAkB,SAAyB3nB,GAChE,GAAiB,iBAANA,GAAkBA,EAAI,GAAK0lB,EAAY1lB,GAChD,MAAM,IAAIuC,WAAW,gFAAkFvC,EAAI,KAG7G,OADA4C,KAAKmjB,cAAgB/lB,EACd4C,MAST+iB,EAAaxlB,UAAUynB,gBAAkB,WACvC,OAAO3B,EAAiBrjB,OAG1B+iB,EAAaxlB,UAAUsmB,KAAO,SAAcpiB,GAE1C,IADA,IAAIihB,EAAO,GACF/mB,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IAAK+mB,EAAK7d,KAAKkD,UAAUpM,IAC/D,IAAIspB,EAAoB,UAATxjB,EAEXgiB,EAASzjB,KAAKijB,QAClB,QAAexiB,IAAXgjB,EACFwB,EAAWA,QAA4BxkB,IAAjBgjB,EAAOlS,WAC1B,IAAK0T,EACR,OAAO,EAGT,GAAIA,EAAS,CACX,IAAIC,EAGJ,GAFIxC,EAAKhjB,OAAS,IAChBwlB,EAAKxC,EAAK,IACRwC,aAAcjlB,MAGhB,MAAMilB,EAGR,IAAIlT,EAAM,IAAI/R,MAAM,oBAAsBilB,EAAK,KAAOA,EAAG7V,QAAU,IAAM,KAEzE,MADA2C,EAAImT,QAAUD,EACRlT,EAGR,IAAIoT,EAAU3B,EAAOhiB,GAErB,QAAgBhB,IAAZ2kB,EACF,OAAO,EAET,GAAuB,mBAAZA,EACT5C,EAAa4C,EAASplB,KAAM0iB,OAE5B,KAAIthB,EAAMgkB,EAAQ1lB,OACd2lB,EAAYR,EAAWO,EAAShkB,GACpC,IAASzF,EAAI,EAAGA,EAAIyF,IAAOzF,EACzB6mB,EAAa6C,EAAU1pB,GAAIqE,KAAM0iB,GAGrC,OAAO,GAmETK,EAAaxlB,UAAU+nB,YAAc,SAAqB7jB,EAAM8hB,GAC9D,OAAOD,EAAatjB,KAAMyB,EAAM8hB,GAAU,IAG5CR,EAAaxlB,UAAUgoB,GAAKxC,EAAaxlB,UAAU+nB,YAEnDvC,EAAaxlB,UAAUioB,gBACnB,SAAyB/jB,EAAM8hB,GAC7B,OAAOD,EAAatjB,KAAMyB,EAAM8hB,GAAU,IAqBhDR,EAAaxlB,UAAUkoB,KAAO,SAAchkB,EAAM8hB,GAChD,GAAwB,mBAAbA,EACT,MAAM,IAAInjB,UAAU,0EAA4EmjB,GAGlG,OADAvjB,KAAKulB,GAAG9jB,EAAM2iB,EAAUpkB,KAAMyB,EAAM8hB,IAC7BvjB,MAGT+iB,EAAaxlB,UAAUmoB,oBACnB,SAA6BjkB,EAAM8hB,GACjC,GAAwB,mBAAbA,EACT,MAAM,IAAInjB,UAAU,0EAA4EmjB,GAGlG,OADAvjB,KAAKwlB,gBAAgB/jB,EAAM2iB,EAAUpkB,KAAMyB,EAAM8hB,IAC1CvjB,MAIb+iB,EAAaxlB,UAAUinB,eACnB,SAAwB/iB,EAAM8hB,GAC5B,IAAI7b,EAAM+b,EAAQkC,EAAUhqB,EAAGiqB,EAE/B,GAAwB,mBAAbrC,EACT,MAAM,IAAInjB,UAAU,0EAA4EmjB,GAIlG,QAAe9iB,KADfgjB,EAASzjB,KAAKijB,SAEZ,OAAOjjB,KAGT,QAAaS,KADbiH,EAAO+b,EAAOhiB,IAEZ,OAAOzB,KAET,GAAI0H,IAAS6b,GAAY7b,EAAK6b,WAAaA,EACb,KAAtBvjB,KAAKkjB,aACTljB,KAAKijB,QAAU5mB,OAAOY,OAAO,cAEtBwmB,EAAOhiB,GACVgiB,EAAOe,gBACTxkB,KAAK6jB,KAAK,iBAAkBpiB,EAAMiG,EAAK6b,UAAYA,SAElD,GAAoB,mBAAT7b,EAAqB,CAGrC,IAFAie,GAAY,EAEPhqB,EAAI+L,EAAKhI,OAAS,EAAG/D,GAAK,EAAGA,IAChC,GAAI+L,EAAK/L,KAAO4nB,GAAY7b,EAAK/L,GAAG4nB,WAAaA,EAAU,CACzDqC,EAAmBle,EAAK/L,GAAG4nB,SAC3BoC,EAAWhqB,EACX,MAIJ,GAAIgqB,EAAW,EACb,OAAO3lB,KAEQ,IAAb2lB,EACFje,EAAKme,QAiIf,SAAmBne,EAAM8T,GACvB,KAAOA,EAAQ,EAAI9T,EAAKhI,OAAQ8b,IAC9B9T,EAAK8T,GAAS9T,EAAK8T,EAAQ,GAC7B9T,EAAK8V,MAlIGsI,CAAUpe,EAAMie,GAGE,IAAhBje,EAAKhI,SACP+jB,EAAOhiB,GAAQiG,EAAK,SAEQjH,IAA1BgjB,EAAOe,gBACTxkB,KAAK6jB,KAAK,iBAAkBpiB,EAAMmkB,GAAoBrC,GAG1D,OAAOvjB,MAGb+iB,EAAaxlB,UAAUwoB,IAAMhD,EAAaxlB,UAAUinB,eAEpDzB,EAAaxlB,UAAUyoB,mBACnB,SAA4BvkB,GAC1B,IAAI4jB,EAAW5B,EAAQ9nB,EAGvB,QAAe8E,KADfgjB,EAASzjB,KAAKijB,SAEZ,OAAOjjB,KAGT,QAA8BS,IAA1BgjB,EAAOe,eAUT,OATyB,IAArBzc,UAAUrI,QACZM,KAAKijB,QAAU5mB,OAAOY,OAAO,MAC7B+C,KAAKkjB,aAAe,QACMziB,IAAjBgjB,EAAOhiB,KACY,KAAtBzB,KAAKkjB,aACTljB,KAAKijB,QAAU5mB,OAAOY,OAAO,aAEtBwmB,EAAOhiB,IAEXzB,KAIT,GAAyB,IAArB+H,UAAUrI,OAAc,CAC1B,IACIxC,EADAgW,EAAO7W,OAAO6W,KAAKuQ,GAEvB,IAAK9nB,EAAI,EAAGA,EAAIuX,EAAKxT,SAAU/D,EAEjB,oBADZuB,EAAMgW,EAAKvX,KAEXqE,KAAKgmB,mBAAmB9oB,GAK1B,OAHA8C,KAAKgmB,mBAAmB,kBACxBhmB,KAAKijB,QAAU5mB,OAAOY,OAAO,MAC7B+C,KAAKkjB,aAAe,EACbljB,KAKT,GAAyB,mBAFzBqlB,EAAY5B,EAAOhiB,IAGjBzB,KAAKwkB,eAAe/iB,EAAM4jB,QACrB,QAAkB5kB,IAAd4kB,EAET,IAAK1pB,EAAI0pB,EAAU3lB,OAAS,EAAG/D,GAAK,EAAGA,IACrCqE,KAAKwkB,eAAe/iB,EAAM4jB,EAAU1pB,IAIxC,OAAOqE,MAoBb+iB,EAAaxlB,UAAU8nB,UAAY,SAAmB5jB,GACpD,OAAOgjB,EAAWzkB,KAAMyB,GAAM,IAGhCshB,EAAaxlB,UAAU0oB,aAAe,SAAsBxkB,GAC1D,OAAOgjB,EAAWzkB,KAAMyB,GAAM,IAGhCshB,EAAa+B,cAAgB,SAASb,EAASxiB,GAC7C,MAAqC,mBAA1BwiB,EAAQa,cACVb,EAAQa,cAAcrjB,GAEtBqjB,EAAchpB,KAAKmoB,EAASxiB,IAIvCshB,EAAaxlB,UAAUunB,cAAgBA,EAiBvC/B,EAAaxlB,UAAU2oB,WAAa,WAClC,OAAOlmB,KAAKkjB,aAAe,EAAIb,EAAeriB,KAAKijB,SAAW,K,gBCzahE,IAAIkD,EAA+B,EAAQ,IAqB3CprB,EAAOD,QAnBP,SAAkCiV,EAAQqW,GACxC,GAAc,MAAVrW,EAAgB,MAAO,GAC3B,IACI7S,EAAKvB,EADL0M,EAAS8d,EAA6BpW,EAAQqW,GAGlD,GAAI/pB,OAAOumB,sBAAuB,CAChC,IAAIyD,EAAmBhqB,OAAOumB,sBAAsB7S,GAEpD,IAAKpU,EAAI,EAAGA,EAAI0qB,EAAiB3mB,OAAQ/D,IACvCuB,EAAMmpB,EAAiB1qB,GACnByqB,EAASjjB,QAAQjG,IAAQ,GACxBb,OAAOkB,UAAU+oB,qBAAqBxqB,KAAKiU,EAAQ7S,KACxDmL,EAAOnL,GAAO6S,EAAO7S,IAIzB,OAAOmL,I,6BChBThM,OAAOC,eAAexB,EAAS,aAAc,CAC3C8B,OAAO,IAETP,OAAOC,eAAexB,EAAS,SAAU,CACvCyB,YAAY,EACZC,IAAK,WACH,OAAO+pB,EAAQjoB,WAGnBjC,OAAOC,eAAexB,EAAS,QAAS,CACtCyB,YAAY,EACZC,IAAK,WACH,OAAOgqB,EAAOloB,WAIlB,IAAIioB,EAAUE,EAAuB,EAAQ,KAEzCD,EAASC,EAAuB,EAAQ,KAE5C,SAASA,EAAuB9oB,GAAO,OAAOA,GAAOA,EAAIZ,WAAaY,EAAM,CAAEW,QAASX,K,6BCpBvF,IAAIwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAQnB,IACI4C,EADWnb,EAAQ,GACJmb,IAEfuQ,EAAY1rB,EAAQ,GACpB0D,EAAMgoB,EAAUhoB,IAChBF,EAAMkoB,EAAUloB,IAIhByb,EAAW,SAAU0M,GAGvB,SAAS1M,IAGP,OArBJ,SAAyBrG,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAmB5GyT,CAAgB7T,KAAMia,GAjB1B,SAAoCpI,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EAmBvNyjB,CAA2Bvf,MAAOia,EAASpa,WAAaxD,OAAOmU,eAAeyJ,IAAW5T,MAAMrG,KAAM+H,YAuF9G,OAxGF,SAAmByX,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAY/dE,CAAU1F,EA6FVvb,GArFAyU,EAAa8G,EAAU,KAAM,CAAC,CAC5B/c,IAAK,WAYLN,MAAO,SAAkBgqB,EAAmBlO,GAC1C,IAAKkO,EACH,MAAM,IAAI3mB,MAAM,uDAGlB,IAAKyY,EAAQmO,WACX,MAAM,IAAI5mB,MAAM,+CAGlB,IAAKyY,EAAQoO,cAAcC,SACzB,MAAM,IAAI9mB,MAAM,4CAGlB,IAAI6f,EAAM/I,KAAKiQ,MAAMtO,EAAQmO,YAE7B,OAAOroB,EAAI6W,UAAUyK,GAAK1I,KAAK,SAAU6P,GACvC,IAAIrV,EAAU,CACZkP,IAAK,IAAI3K,EAAIyQ,GAAmBM,OAChChqB,IAAK+pB,EACLpG,IAAKnI,EAAQoO,cAAcK,UAC3BJ,SAAUrO,EAAQoO,cAAcC,UAGlC,OAAO9M,EAASmN,MAAMxV,KACrBwF,KAAK,SAAU+K,GAChB,OAAOA,EAAI1I,aAuBd,CACDvc,IAAK,QACLN,MAAO,SAAegV,GACpB,IAAIkP,EAAMlP,EAAQkP,IACdD,EAAMjP,EAAQiP,IACd3jB,EAAM0U,EAAQ1U,IAGd2Q,EAAM3Q,EAAI2Q,IACVoT,EAAMrP,EAAQqP,KAAOzb,KAAK6F,MAAMgc,KAAKC,MAAQ,KAUjD,OAFU,IAAIrN,EAAS,CAAE+F,OAHZ,CAAEnS,IAAKA,GAGqB4S,QAF3B,CAAEI,IAAKA,EAAKC,IAAKA,EAAKC,IAH1BE,GAFArP,EAAQ1J,KAlFF,MAuF8B+Y,IAAKA,EAAK8F,SAAUnV,EAAQmV,SAAUQ,WAAY,OAErCrqB,IAAKA,EAAIsqB,WAAa,CAAExK,QAAQ,QAMxF/C,EA7FM,GAgGflf,EAAOD,QAAUmf,G,cCpGjBlf,EAAOD,QAfP,SAAuCiV,EAAQqW,GAC7C,GAAc,MAAVrW,EAAgB,MAAO,GAC3B,IAEI7S,EAAKvB,EAFL0M,EAAS,GACTof,EAAaprB,OAAO6W,KAAKnD,GAG7B,IAAKpU,EAAI,EAAGA,EAAI8rB,EAAW/nB,OAAQ/D,IACjCuB,EAAMuqB,EAAW9rB,GACbyqB,EAASjjB,QAAQjG,IAAQ,IAC7BmL,EAAOnL,GAAO6S,EAAO7S,IAGvB,OAAOmL,I,6BCVThM,OAAOC,eAAexB,EAAS,aAAc,CAC3C8B,OAAO,IAET9B,EAAQwD,aAAU,EAElB,IAAIopB,EAAQ,EAAQ,IAEpB,SAASC,EAAmBtkB,GAAO,OAMnC,SAA4BA,GAAO,GAAIwF,MAAMzJ,QAAQiE,GAAM,CAAE,IAAK,IAAI1H,EAAI,EAAGisB,EAAO,IAAI/e,MAAMxF,EAAI3D,QAAS/D,EAAI0H,EAAI3D,OAAQ/D,IAAOisB,EAAKjsB,GAAK0H,EAAI1H,GAAM,OAAOisB,GANnHC,CAAmBxkB,IAI7D,SAA0BykB,GAAQ,GAAIprB,OAAOqe,YAAY1e,OAAOyrB,IAAkD,uBAAzCzrB,OAAOkB,UAAUuE,SAAShG,KAAKgsB,GAAgC,OAAOjf,MAAM1I,KAAK2nB,GAJrFC,CAAiB1kB,IAEtF,WAAgC,MAAM,IAAIjD,UAAU,mDAF0C4nB,GAQ9F,SAASvG,EAAepe,EAAK1H,GAAK,OAMlC,SAAyB0H,GAAO,GAAIwF,MAAMzJ,QAAQiE,GAAM,OAAOA,EANtB4kB,CAAgB5kB,IAIzD,SAA+BA,EAAK1H,GAAK,IAAImN,EAAO,GAAQ4Y,GAAK,EAAUC,GAAK,EAAWC,OAAKnhB,EAAW,IAAM,IAAK,IAAiCohB,EAA7BC,EAAKze,EAAI3G,OAAOqe,cAAmB2G,GAAMG,EAAKC,EAAGC,QAAQC,QAAoBlZ,EAAKjE,KAAKgd,EAAGjlB,QAAYjB,GAAKmN,EAAKpJ,SAAW/D,GAA3D+lB,GAAK,IAAoE,MAAO1P,GAAO2P,GAAK,EAAMC,EAAK5P,EAAO,QAAU,IAAW0P,GAAsB,MAAhBI,EAAW,QAAWA,EAAW,SAAO,QAAU,GAAIH,EAAI,MAAMC,GAAQ,OAAO9Y,EAJjVof,CAAsB7kB,EAAK1H,IAE5F,WAA8B,MAAM,IAAIyE,UAAU,wDAFgD+nB,GAQlG,IAMIC,EAAQ,SAAe/P,GACzB,OAAOA,EAAOgQ,OAAO,SAAUC,EAAMC,GACnC,IAAIC,EAAQ/G,EAAe8G,EAAM,GAC7BrrB,EAAMsrB,EAAM,GACZC,EAASD,EAAM,GAEfE,EAZE,SAAaxrB,GACrB,OAAO,SAAUN,GACf,SAAUM,KAAON,KAAU,EAAI8qB,EAAMzR,SAASrZ,IAAS,EAAI8qB,EAAM3R,OAAOnZ,GAASA,KAUjE+rB,CAAIzrB,GAEpB,KAAK,EAAIwqB,EAAMzR,SAAS/Y,GACtB,MAAM,IAAIkD,UAGZ,OAAIyI,MAAMzJ,QAAQqpB,GACTd,EAAmBW,GAAM7gB,OAAOkgB,EAAmBc,EAAOtU,IAAIuU,KAGhEf,EAAmBW,GAAM7gB,OAAO,CAACihB,EAAUD,MACjD,KAgCL3tB,EAAQwD,QAhBO,SAAkBsqB,EAAQpU,EAAO6D,GAC9C,IAAI1a,EAAwB,iBAAXirB,EAAsB,CACrCA,SACApU,QACA6D,UACEuQ,EAEJ,GAAmB,iBAARjrB,EACT,MAAM,IAAIyC,UACL,KAAK,EAAIsnB,EAAM1R,UAAUrY,EAAIirB,QAClC,MAAM,IAAIxoB,UAAU,mBAGtB,MAAO,CAACzC,EAAIirB,QAAQnhB,OAAOkgB,OAAwC,IAAdhqB,EAAI6W,MAAwB,CAAC7W,EAAI6W,OAAS,IAAKmT,OAAyC,IAAfhqB,EAAI0a,OA1BpH,SAASwQ,EAAUxQ,EAAQzG,GACzC,GAAI/I,MAAMzJ,QAAQiZ,GAChB,OAAO+P,EAAM/P,GACR,GAAsB,iBAAXA,EAAqB,CACrC,IAAIyQ,EAAUzQ,EACd,OAAOwQ,EAAUxsB,OAAO6W,KAAKmF,GAAQlE,IAAI,SAAUjX,GACjD,MAAO,CAACA,EAAK4rB,EAAQ5rB,MACnB0U,GAGN,MAAM,IAAIxR,UAgBiJyoB,CAAUlrB,EAAI0a,QAAU,KAAKjQ,KAAK,O,6BC3E/L/L,OAAOC,eAAexB,EAAS,aAAc,CAC3C8B,OAAO,IAET9B,EAAQwD,aAAU,EAElB,IAAIopB,EAAQ,EAAQ,IAGhBpP,EAAO,sIAEPvD,EAAY,SAAmBuT,EAAMS,GAEvC,IAAIC,EAAyB,MAAnBD,EAAKhV,OAAO,IAAa,EAAI2T,EAAM5R,SAASiT,GAAQA,EAAKjc,OAEnE,OAAIjE,MAAMzJ,QAAQkpB,GACTA,EAAK7gB,OAAOuhB,GACM,iBAATV,EACT,CAACA,EAAMU,GAGTA,GA2CTluB,EAAQwD,QAfO,SAAkBqG,GAC/B,GAAmB,iBAARA,EACT,MAAM,IAAIvE,UAAU,kCAGtB,IAAIiC,EAAQsC,EAAIxB,QAAQ,KACpBylB,EAASjkB,EAAIJ,OAAO,EAAGlC,GAE3B,KAAK,EAAIqlB,EAAM1R,UAAU4S,GACvB,MAAM,IAAIxoB,4BAA4BwoB,KAGxC,OArCoB,SAAyBA,EAAQhoB,GAIrD,IAHA,IAAI4T,EAAQ,KACR6D,EAAS,KAEA,CACX,IAAI3S,EAAM4S,EAAK2Q,KAAKroB,GAEpB,GAAY,OAAR8E,EACF,MAGEA,EAAI,GACN2S,EAAO3S,EAAI,IAAMqP,EAAUsD,EAAO3S,EAAI,IAAKA,EAAI,IAE/C8O,EAAQO,EAAUP,EAAO9O,EAAI,IAIjC,MAAO,CACLkjB,SACAvQ,SACA7D,SAgBK0U,CAAgBN,EAAQjkB,EAAIJ,OAAOlC,M;;;;;ECtD5C,IAAIugB,EAAwBvmB,OAAOumB,sBAC/BplB,EAAiBnB,OAAOkB,UAAUC,eAClC2rB,EAAmB9sB,OAAOkB,UAAU+oB,qBAExC,SAAS8C,EAAS5nB,GACjB,GAAIA,QACH,MAAM,IAAIpB,UAAU,yDAGrB,OAAO/D,OAAOmF,GA+CfzG,EAAOD,QA5CP,WACC,IACC,IAAKuB,OAAOob,OACX,OAAO,EAMR,IAAI4R,EAAQ,IAAI5lB,OAAO,OAEvB,GADA4lB,EAAM,GAAK,KACkC,MAAzChtB,OAAOwmB,oBAAoBwG,GAAO,GACrC,OAAO,EAKR,IADA,IAAIC,EAAQ,GACH3tB,EAAI,EAAGA,EAAI,GAAIA,IACvB2tB,EAAM,IAAM7lB,OAAO2C,aAAazK,IAAMA,EAKvC,GAAwB,eAHXU,OAAOwmB,oBAAoByG,GAAOnV,IAAI,SAAU/W,GAC5D,OAAOksB,EAAMlsB,KAEHgL,KAAK,IACf,OAAO,EAIR,IAAImhB,EAAQ,GAIZ,MAHA,uBAAuBrV,MAAM,IAAIqB,QAAQ,SAAUiU,GAClDD,EAAMC,GAAUA,IAGf,yBADEntB,OAAO6W,KAAK7W,OAAOob,OAAO,GAAI8R,IAAQnhB,KAAK,IAM9C,MAAO4J,GAER,OAAO,GAIQyX,GAAoBptB,OAAOob,OAAS,SAAUpP,EAAQ0H,GAKtE,IAJA,IAAI5P,EAEAupB,EADAC,EAAKP,EAAS/gB,GAGT3K,EAAI,EAAGA,EAAIqK,UAAUrI,OAAQhC,IAAK,CAG1C,IAAK,IAAIR,KAFTiD,EAAO9D,OAAO0L,UAAUrK,IAGnBF,EAAe1B,KAAKqE,EAAMjD,KAC7BysB,EAAGzsB,GAAOiD,EAAKjD,IAIjB,GAAI0lB,EAAuB,CAC1B8G,EAAU9G,EAAsBziB,GAChC,IAAK,IAAIxE,EAAI,EAAGA,EAAI+tB,EAAQhqB,OAAQ/D,IAC/BwtB,EAAiBrtB,KAAKqE,EAAMupB,EAAQ/tB,MACvCguB,EAAGD,EAAQ/tB,IAAMwE,EAAKupB,EAAQ/tB,MAMlC,OAAOguB,I,iBCxFR,YAqBA,IAAIC,EAA4BvtB,OAAOutB,2BACrC,SAAmCjsB,GAGjC,IAFA,IAAIuV,EAAO7W,OAAO6W,KAAKvV,GACnBksB,EAAc,GACTluB,EAAI,EAAGA,EAAIuX,EAAKxT,OAAQ/D,IAC/BkuB,EAAY3W,EAAKvX,IAAMU,OAAOytB,yBAAyBnsB,EAAKuV,EAAKvX,IAEnE,OAAOkuB,GAGPE,EAAe,WACnBjvB,EAAQ6f,OAAS,SAASqP,GACxB,IAAKC,EAASD,GAAI,CAEhB,IADA,IAAIE,EAAU,GACLvuB,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IACpCuuB,EAAQrlB,KAAKoD,EAAQF,UAAUpM,KAEjC,OAAOuuB,EAAQ9hB,KAAK,KAGlBzM,EAAI,EAmBR,IAnBA,IACI+mB,EAAO3a,UACP3G,EAAMshB,EAAKhjB,OACXiF,EAAMlB,OAAOumB,GAAGjd,QAAQgd,EAAc,SAASxiB,GACjD,GAAU,OAANA,EAAY,MAAO,IACvB,GAAI5L,GAAKyF,EAAK,OAAOmG,EACrB,OAAQA,GACN,IAAK,KAAM,OAAO9D,OAAOif,EAAK/mB,MAC9B,IAAK,KAAM,OAAOuI,OAAOwe,EAAK/mB,MAC9B,IAAK,KACH,IACE,OAAOob,KAAKC,UAAU0L,EAAK/mB,MAC3B,MAAOwuB,GACP,MAAO,aAEX,QACE,OAAO5iB,KAGJA,EAAImb,EAAK/mB,GAAIA,EAAIyF,EAAKmG,EAAImb,IAAO/mB,GACpCyuB,EAAO7iB,KAAO8iB,EAAS9iB,GACzB5C,GAAO,IAAM4C,EAEb5C,GAAO,IAAMsD,EAAQV,GAGzB,OAAO5C,GAOT7J,EAAQwvB,UAAY,SAASC,EAAIC,GAC/B,QAAuB,IAAZC,IAAqD,IAA1BA,EAAQC,cAC5C,OAAOH,EAIT,QAAuB,IAAZE,EACT,OAAO,WACL,OAAO3vB,EAAQwvB,UAAUC,EAAIC,GAAKnkB,MAAMrG,KAAM+H,YAIlD,IAAIgc,GAAS,EAeb,OAdA,WACE,IAAKA,EAAQ,CACX,GAAI0G,EAAQE,iBACV,MAAM,IAAI1qB,MAAMuqB,GACPC,EAAQG,iBACjBtR,QAAQuR,MAAML,GAEdlR,QAAQ/H,MAAMiZ,GAEhBzG,GAAS,EAEX,OAAOwG,EAAGlkB,MAAMrG,KAAM+H,aAO1B,IACI+iB,EADAC,EAAS,GA6Bb,SAAS9iB,EAAQtK,EAAKqtB,GAEpB,IAAIC,EAAM,CACRC,KAAM,GACNC,QAASC,GAkBX,OAfIrjB,UAAUrI,QAAU,IAAGurB,EAAI/P,MAAQnT,UAAU,IAC7CA,UAAUrI,QAAU,IAAGurB,EAAII,OAAStjB,UAAU,IAC9CujB,EAAUN,GAEZC,EAAIM,WAAaP,EACRA,GAETlwB,EAAQ0wB,QAAQP,EAAKD,GAGnBS,EAAYR,EAAIM,cAAaN,EAAIM,YAAa,GAC9CE,EAAYR,EAAI/P,SAAQ+P,EAAI/P,MAAQ,GACpCuQ,EAAYR,EAAII,UAASJ,EAAII,QAAS,GACtCI,EAAYR,EAAIS,iBAAgBT,EAAIS,eAAgB,GACpDT,EAAII,SAAQJ,EAAIE,QAAUQ,GACvBC,EAAYX,EAAKttB,EAAKstB,EAAI/P,OAoCnC,SAASyQ,EAAiBhnB,EAAKknB,GAC7B,IAAIC,EAAQ7jB,EAAQ8jB,OAAOF,GAE3B,OAAIC,EACK,KAAY7jB,EAAQojB,OAAOS,GAAO,GAAK,IAAMnnB,EAC7C,KAAYsD,EAAQojB,OAAOS,GAAO,GAAK,IAEvCnnB,EAKX,SAASymB,EAAezmB,EAAKknB,GAC3B,OAAOlnB,EAeT,SAASinB,EAAYX,EAAKruB,EAAOovB,GAG/B,GAAIf,EAAIS,eACJ9uB,GACAmS,EAAWnS,EAAMqL,UAEjBrL,EAAMqL,UAAYnN,EAAQmN,WAExBrL,EAAMoe,aAAepe,EAAMoe,YAAYzd,YAAcX,GAAQ,CACjE,IAAImM,EAAMnM,EAAMqL,QAAQ+jB,EAAcf,GAItC,OAHKhB,EAASlhB,KACZA,EAAM6iB,EAAYX,EAAKliB,EAAKijB,IAEvBjjB,EAIT,IAAIkjB,EA+FN,SAAyBhB,EAAKruB,GAC5B,GAAI6uB,EAAY7uB,GACd,OAAOquB,EAAIE,QAAQ,YAAa,aAClC,GAAIlB,EAASrtB,GAAQ,CACnB,IAAIsvB,EAAS,IAAOnV,KAAKC,UAAUpa,GAAOmQ,QAAQ,SAAU,IAClBA,QAAQ,KAAM,OACdA,QAAQ,OAAQ,KAAO,IACjE,OAAOke,EAAIE,QAAQe,EAAQ,UAE7B,GAAIC,EAASvvB,GACX,OAAOquB,EAAIE,QAAQ,GAAKvuB,EAAO,UACjC,GAAI0uB,EAAU1uB,GACZ,OAAOquB,EAAIE,QAAQ,GAAKvuB,EAAO,WAEjC,GAAIwtB,EAAOxtB,GACT,OAAOquB,EAAIE,QAAQ,OAAQ,QA9GbiB,CAAgBnB,EAAKruB,GACrC,GAAIqvB,EACF,OAAOA,EAIT,IAAI/Y,EAAO7W,OAAO6W,KAAKtW,GACnByvB,EApCN,SAAqB/rB,GACnB,IAAIgsB,EAAO,GAMX,OAJAhsB,EAAMiV,QAAQ,SAAS/T,EAAK2Q,GAC1Bma,EAAK9qB,IAAO,IAGP8qB,EA6BWC,CAAYrZ,GAQ9B,GANI+X,EAAIM,aACNrY,EAAO7W,OAAOwmB,oBAAoBjmB,IAKhC+U,EAAQ/U,KACJsW,EAAK/P,QAAQ,YAAc,GAAK+P,EAAK/P,QAAQ,gBAAkB,GACrE,OAAOqpB,EAAY5vB,GAIrB,GAAoB,IAAhBsW,EAAKxT,OAAc,CACrB,GAAIqP,EAAWnS,GAAQ,CACrB,IAAIV,EAAOU,EAAMV,KAAO,KAAOU,EAAMV,KAAO,GAC5C,OAAO+uB,EAAIE,QAAQ,YAAcjvB,EAAO,IAAK,WAE/C,GAAI4T,EAASlT,GACX,OAAOquB,EAAIE,QAAQzQ,OAAOnd,UAAUuE,SAAShG,KAAKc,GAAQ,UAE5D,GAAIgT,EAAOhT,GACT,OAAOquB,EAAIE,QAAQ9D,KAAK9pB,UAAUuE,SAAShG,KAAKc,GAAQ,QAE1D,GAAI+U,EAAQ/U,GACV,OAAO4vB,EAAY5vB,GAIvB,IA2CI6vB,EA3CAC,EAAO,GAAIpsB,GAAQ,EAAOqsB,EAAS,CAAC,IAAK,MAGzCvtB,EAAQxC,KACV0D,GAAQ,EACRqsB,EAAS,CAAC,IAAK,MAIb5d,EAAWnS,MAEb8vB,EAAO,cADC9vB,EAAMV,KAAO,KAAOU,EAAMV,KAAO,IACf,KAkB5B,OAdI4T,EAASlT,KACX8vB,EAAO,IAAMhS,OAAOnd,UAAUuE,SAAShG,KAAKc,IAI1CgT,EAAOhT,KACT8vB,EAAO,IAAMrF,KAAK9pB,UAAUqvB,YAAY9wB,KAAKc,IAI3C+U,EAAQ/U,KACV8vB,EAAO,IAAMF,EAAY5vB,IAGP,IAAhBsW,EAAKxT,QAAkBY,GAAyB,GAAhB1D,EAAM8C,OAItCssB,EAAe,EACblc,EAASlT,GACJquB,EAAIE,QAAQzQ,OAAOnd,UAAUuE,SAAShG,KAAKc,GAAQ,UAEnDquB,EAAIE,QAAQ,WAAY,YAInCF,EAAIC,KAAKrmB,KAAKjI,GAIZ6vB,EADEnsB,EAsCN,SAAqB2qB,EAAKruB,EAAOovB,EAAcK,EAAanZ,GAE1D,IADA,IAAIuZ,EAAS,GACJ9wB,EAAI,EAAGC,EAAIgB,EAAM8C,OAAQ/D,EAAIC,IAAKD,EACrC6B,EAAeZ,EAAO6G,OAAO9H,IAC/B8wB,EAAO5nB,KAAKgoB,EAAe5B,EAAKruB,EAAOovB,EAAcK,EACjD5oB,OAAO9H,IAAI,IAEf8wB,EAAO5nB,KAAK,IAShB,OANAqO,EAAKqC,QAAQ,SAASrY,GACfA,EAAIiL,MAAM,UACbskB,EAAO5nB,KAAKgoB,EAAe5B,EAAKruB,EAAOovB,EAAcK,EACjDnvB,GAAK,MAGNuvB,EArDIK,CAAY7B,EAAKruB,EAAOovB,EAAcK,EAAanZ,GAEnDA,EAAKiB,IAAI,SAASjX,GACzB,OAAO2vB,EAAe5B,EAAKruB,EAAOovB,EAAcK,EAAanvB,EAAKoD,KAItE2qB,EAAIC,KAAK1N,MA6GX,SAA8BiP,EAAQC,EAAMC,GAQ1C,GANaF,EAAOpE,OAAO,SAASC,EAAMU,GAGxC,OAFA+D,EACI/D,EAAI7lB,QAAQ,OAAS,GAAG4pB,EACrBzE,EAAOU,EAAIjc,QAAQ,kBAAmB,IAAIrN,OAAS,GACzD,GAEU,GACX,OAAOitB,EAAO,IACG,KAATD,EAAc,GAAKA,EAAO,OAC3B,IACAD,EAAOrkB,KAAK,SACZ,IACAukB,EAAO,GAGhB,OAAOA,EAAO,GAAKD,EAAO,IAAMD,EAAOrkB,KAAK,MAAQ,IAAMukB,EAAO,GA5H1DK,CAAqBP,EAAQC,EAAMC,IAxBjCA,EAAO,GAAKD,EAAOC,EAAO,GA+CrC,SAASH,EAAY5vB,GACnB,MAAO,IAAMqD,MAAM1C,UAAUuE,SAAShG,KAAKc,GAAS,IAwBtD,SAASiwB,EAAe5B,EAAKruB,EAAOovB,EAAcK,EAAanvB,EAAKoD,GAClE,IAAIpE,EAAMyI,EAAKsoB,EAsCf,IArCAA,EAAO5wB,OAAOytB,yBAAyBltB,EAAOM,IAAQ,CAAEN,MAAOA,EAAMM,KAC5DV,IAELmI,EADEsoB,EAAKzgB,IACDye,EAAIE,QAAQ,kBAAmB,WAE/BF,EAAIE,QAAQ,WAAY,WAG5B8B,EAAKzgB,MACP7H,EAAMsmB,EAAIE,QAAQ,WAAY,YAG7B3tB,EAAe6uB,EAAanvB,KAC/BhB,EAAO,IAAMgB,EAAM,KAEhByH,IACCsmB,EAAIC,KAAK/nB,QAAQ8pB,EAAKrwB,OAAS,GAE/B+H,EADEylB,EAAO4B,GACHJ,EAAYX,EAAKgC,EAAKrwB,MAAO,MAE7BgvB,EAAYX,EAAKgC,EAAKrwB,MAAOovB,EAAe,IAE5C7oB,QAAQ,OAAS,IAErBwB,EADErE,EACIqE,EAAIuP,MAAM,MAAMC,IAAI,SAAS+Y,GACjC,MAAO,KAAOA,IACb9kB,KAAK,MAAM7D,OAAO,GAEf,KAAOI,EAAIuP,MAAM,MAAMC,IAAI,SAAS+Y,GACxC,MAAO,MAAQA,IACd9kB,KAAK,OAIZzD,EAAMsmB,EAAIE,QAAQ,aAAc,YAGhCM,EAAYvvB,GAAO,CACrB,GAAIoE,GAASpD,EAAIiL,MAAM,SACrB,OAAOxD,GAETzI,EAAO6a,KAAKC,UAAU,GAAK9Z,IAClBiL,MAAM,iCACbjM,EAAOA,EAAKqI,OAAO,EAAGrI,EAAKwD,OAAS,GACpCxD,EAAO+uB,EAAIE,QAAQjvB,EAAM,UAEzBA,EAAOA,EAAK6Q,QAAQ,KAAM,OACdA,QAAQ,OAAQ,KAChBA,QAAQ,WAAY,KAChC7Q,EAAO+uB,EAAIE,QAAQjvB,EAAM,WAI7B,OAAOA,EAAO,KAAOyI,EA2BvB,SAASvF,EAAQ+tB,GACf,OAAOtkB,MAAMzJ,QAAQ+tB,GAIvB,SAAS7B,EAAUxrB,GACjB,MAAsB,kBAARA,EAIhB,SAASsqB,EAAOtqB,GACd,OAAe,OAARA,EAST,SAASqsB,EAASrsB,GAChB,MAAsB,iBAARA,EAIhB,SAASmqB,EAASnqB,GAChB,MAAsB,iBAARA,EAShB,SAAS2rB,EAAY3rB,GACnB,YAAe,IAARA,EAIT,SAASgQ,EAASsd,GAChB,OAAO/C,EAAS+C,IAA8B,oBAAvBC,EAAeD,GAIxC,SAAS/C,EAASvqB,GAChB,MAAsB,iBAARA,GAA4B,OAARA,EAIpC,SAAS8P,EAAO3T,GACd,OAAOouB,EAASpuB,IAA4B,kBAAtBoxB,EAAepxB,GAIvC,SAAS0V,EAAQ9K,GACf,OAAOwjB,EAASxjB,KACW,mBAAtBwmB,EAAexmB,IAA2BA,aAAa5G,OAI9D,SAAS8O,EAAWjP,GAClB,MAAsB,mBAARA,EAgBhB,SAASutB,EAAejxB,GACtB,OAAOC,OAAOkB,UAAUuE,SAAShG,KAAKM,GAIxC,SAASkxB,EAAIlwB,GACX,OAAOA,EAAI,GAAK,IAAMA,EAAE0E,SAAS,IAAM1E,EAAE0E,SAAS,IApbpDhH,EAAQyyB,SAAW,SAAS/gB,GAI1B,GAHIif,EAAYX,KACdA,EAAeL,EAAQ+C,IAAIC,YAAc,IAC3CjhB,EAAMA,EAAIkhB,eACL3C,EAAOve,GACV,GAAI,IAAIkO,OAAO,MAAQlO,EAAM,MAAO,KAAK0E,KAAK4Z,GAAe,CAC3D,IAAI6C,EAAMlD,EAAQkD,IAClB5C,EAAOve,GAAO,WACZ,IAAIge,EAAM1vB,EAAQ6f,OAAOtU,MAAMvL,EAASiN,WACxCuR,QAAQ/H,MAAM,YAAa/E,EAAKmhB,EAAKnD,SAGvCO,EAAOve,GAAO,aAGlB,OAAOue,EAAOve,IAoChB1R,EAAQmN,QAAUA,EAIlBA,EAAQojB,OAAS,CACf,KAAS,CAAC,EAAG,IACb,OAAW,CAAC,EAAG,IACf,UAAc,CAAC,EAAG,IAClB,QAAY,CAAC,EAAG,IAChB,MAAU,CAAC,GAAI,IACf,KAAS,CAAC,GAAI,IACd,MAAU,CAAC,GAAI,IACf,KAAS,CAAC,GAAI,IACd,KAAS,CAAC,GAAI,IACd,MAAU,CAAC,GAAI,IACf,QAAY,CAAC,GAAI,IACjB,IAAQ,CAAC,GAAI,IACb,OAAW,CAAC,GAAI,KAIlBpjB,EAAQ8jB,OAAS,CACf,QAAW,OACX,OAAU,SACV,QAAW,SACX,UAAa,OACb,KAAQ,OACR,OAAU,QACV,KAAQ,UAER,OAAU,OAkRZjxB,EAAQsE,QAAUA,EAKlBtE,EAAQwwB,UAAYA,EAKpBxwB,EAAQsvB,OAASA,EAKjBtvB,EAAQ8yB,kBAHR,SAA2B9tB,GACzB,OAAc,MAAPA,GAOThF,EAAQqxB,SAAWA,EAKnBrxB,EAAQmvB,SAAWA,EAKnBnvB,EAAQ+yB,SAHR,SAAkB/tB,GAChB,MAAsB,iBAARA,GAOhBhF,EAAQ2wB,YAAcA,EAKtB3wB,EAAQgV,SAAWA,EAKnBhV,EAAQuvB,SAAWA,EAKnBvvB,EAAQ8U,OAASA,EAMjB9U,EAAQ6W,QAAUA,EAKlB7W,EAAQiU,WAAaA,EAUrBjU,EAAQyV,YARR,SAAqBzQ,GACnB,OAAe,OAARA,GACe,kBAARA,GACQ,iBAARA,GACQ,iBAARA,GACQ,iBAARA,QACQ,IAARA,GAIhBhF,EAAQqG,SAAW,EAAQ,IAY3B,IAAI2sB,EAAS,CAAC,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MACxD,MAAO,MAAO,OAG5B,SAASC,IACP,IAAI9xB,EAAI,IAAIorB,KACR2G,EAAO,CAACV,EAAIrxB,EAAEgyB,YACNX,EAAIrxB,EAAEiyB,cACNZ,EAAIrxB,EAAEkyB,eAAe/lB,KAAK,KACtC,MAAO,CAACnM,EAAEmyB,UAAWN,EAAO7xB,EAAEoyB,YAAaL,GAAM5lB,KAAK,KAqCxD,SAAS5K,EAAeG,EAAK2wB,GAC3B,OAAOjyB,OAAOkB,UAAUC,eAAe1B,KAAK6B,EAAK2wB,GAjCnDxzB,EAAQye,IAAM,WACZD,QAAQC,IAAI,UAAWwU,IAAajzB,EAAQ6f,OAAOtU,MAAMvL,EAASiN,aAiBpEjN,EAAQwX,SAAW,EAAQ,IAE3BxX,EAAQ0wB,QAAU,SAAStE,EAAQ/K,GAEjC,IAAKA,IAAQkO,EAASlO,GAAM,OAAO+K,EAInC,IAFA,IAAIhU,EAAO7W,OAAO6W,KAAKiJ,GACnBxgB,EAAIuX,EAAKxT,OACN/D,KACLurB,EAAOhU,EAAKvX,IAAMwgB,EAAIjJ,EAAKvX,IAE7B,OAAOurB,GAOT,IAAIqH,EAA6C,oBAAX7xB,OAAyBA,OAAO,8BAA2B+D,EA0DjG,SAAS+tB,EAAsBC,EAAQC,GAKrC,IAAKD,EAAQ,CACX,IAAIE,EAAY,IAAI1uB,MAAM,2CAC1B0uB,EAAUF,OAASA,EACnBA,EAASE,EAEX,OAAOD,EAAGD,GAlEZ3zB,EAAQ8zB,UAAY,SAAmBC,GACrC,GAAwB,mBAAbA,EACT,MAAM,IAAIzuB,UAAU,oDAEtB,GAAImuB,GAA4BM,EAASN,GAA2B,CAClE,IAAIhE,EACJ,GAAkB,mBADdA,EAAKsE,EAASN,IAEhB,MAAM,IAAInuB,UAAU,iEAKtB,OAHA/D,OAAOC,eAAeiuB,EAAIgE,EAA0B,CAClD3xB,MAAO2tB,EAAIhuB,YAAY,EAAOsB,UAAU,EAAOD,cAAc,IAExD2sB,EAGT,SAASA,IAQP,IAPA,IAAIuE,EAAgBC,EAChBC,EAAU,IAAIha,QAAQ,SAAU2C,EAAS1C,GAC3C6Z,EAAiBnX,EACjBoX,EAAgB9Z,IAGdyN,EAAO,GACF/mB,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IACpC+mB,EAAK7d,KAAKkD,UAAUpM,IAEtB+mB,EAAK7d,KAAK,SAAUmN,EAAKpV,GACnBoV,EACF+c,EAAc/c,GAEd8c,EAAelyB,KAInB,IACEiyB,EAASxoB,MAAMrG,KAAM0iB,GACrB,MAAO1Q,GACP+c,EAAc/c,GAGhB,OAAOgd,EAQT,OALA3yB,OAAOqjB,eAAe6K,EAAIluB,OAAOmU,eAAeqe,IAE5CN,GAA0BlyB,OAAOC,eAAeiuB,EAAIgE,EAA0B,CAChF3xB,MAAO2tB,EAAIhuB,YAAY,EAAOsB,UAAU,EAAOD,cAAc,IAExDvB,OAAO+W,iBACZmX,EACAX,EAA0BiF,KAI9B/zB,EAAQ8zB,UAAUK,OAASV,EAiD3BzzB,EAAQo0B,YAlCR,SAAqBL,GACnB,GAAwB,mBAAbA,EACT,MAAM,IAAIzuB,UAAU,oDAMtB,SAAS+uB,IAEP,IADA,IAAIzM,EAAO,GACF/mB,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IACpC+mB,EAAK7d,KAAKkD,UAAUpM,IAGtB,IAAIyzB,EAAU1M,EAAKlF,MACnB,GAAuB,mBAAZ4R,EACT,MAAM,IAAIhvB,UAAU,8CAEtB,IAAIyR,EAAO7R,KACP0uB,EAAK,WACP,OAAOU,EAAQ/oB,MAAMwL,EAAM9J,YAI7B8mB,EAASxoB,MAAMrG,KAAM0iB,GAClBtL,KAAK,SAASrO,GAAO0hB,EAAQ4E,SAASX,EAAI,KAAM3lB,IAC3C,SAASumB,GAAO7E,EAAQ4E,SAASb,EAAuBc,EAAKZ,KAMvE,OAHAryB,OAAOqjB,eAAeyP,EAAe9yB,OAAOmU,eAAeqe,IAC3DxyB,OAAO+W,iBAAiB+b,EACAvF,EAA0BiF,IAC3CM,K,gCC3rBT,IAOII,EACAC,EARA/E,EAAU1vB,EAAOD,QAAU,GAU/B,SAAS20B,IACL,MAAM,IAAIxvB,MAAM,mCAEpB,SAASyvB,IACL,MAAM,IAAIzvB,MAAM,qCAsBpB,SAAS0vB,EAAWC,GAChB,GAAIL,IAAqBM,WAErB,OAAOA,WAAWD,EAAK,GAG3B,IAAKL,IAAqBE,IAAqBF,IAAqBM,WAEhE,OADAN,EAAmBM,WACZA,WAAWD,EAAK,GAE3B,IAEI,OAAOL,EAAiBK,EAAK,GAC/B,MAAM/oB,GACJ,IAEI,OAAO0oB,EAAiBzzB,KAAK,KAAM8zB,EAAK,GAC1C,MAAM/oB,GAEJ,OAAO0oB,EAAiBzzB,KAAKkE,KAAM4vB,EAAK,MAvCnD,WACG,IAEQL,EADsB,mBAAfM,WACYA,WAEAJ,EAEzB,MAAO5oB,GACL0oB,EAAmBE,EAEvB,IAEQD,EADwB,mBAAjBM,aACcA,aAEAJ,EAE3B,MAAO7oB,GACL2oB,EAAqBE,GAjB7B,GAwEA,IAEIK,EAFAC,EAAQ,GACRC,GAAW,EAEXC,GAAc,EAElB,SAASC,IACAF,GAAaF,IAGlBE,GAAW,EACPF,EAAarwB,OACbswB,EAAQD,EAAatoB,OAAOuoB,GAE5BE,GAAc,EAEdF,EAAMtwB,QACN0wB,KAIR,SAASA,IACL,IAAIH,EAAJ,CAGA,IAAII,EAAUV,EAAWQ,GACzBF,GAAW,EAGX,IADA,IAAI7uB,EAAM4uB,EAAMtwB,OACV0B,GAAK,CAGP,IAFA2uB,EAAeC,EACfA,EAAQ,KACCE,EAAa9uB,GACd2uB,GACAA,EAAaG,GAAYI,MAGjCJ,GAAc,EACd9uB,EAAM4uB,EAAMtwB,OAEhBqwB,EAAe,KACfE,GAAW,EAnEf,SAAyBM,GACrB,GAAIf,IAAuBM,aAEvB,OAAOA,aAAaS,GAGxB,IAAKf,IAAuBE,IAAwBF,IAAuBM,aAEvE,OADAN,EAAqBM,aACdA,aAAaS,GAExB,IAEWf,EAAmBe,GAC5B,MAAO1pB,GACL,IAEI,OAAO2oB,EAAmB1zB,KAAK,KAAMy0B,GACvC,MAAO1pB,GAGL,OAAO2oB,EAAmB1zB,KAAKkE,KAAMuwB,KAgD7CC,CAAgBH,IAiBpB,SAASI,EAAKb,EAAKtvB,GACfN,KAAK4vB,IAAMA,EACX5vB,KAAKM,MAAQA,EAYjB,SAASowB,KA5BTjG,EAAQ4E,SAAW,SAAUO,GACzB,IAAIlN,EAAO,IAAI7Z,MAAMd,UAAUrI,OAAS,GACxC,GAAIqI,UAAUrI,OAAS,EACnB,IAAK,IAAI/D,EAAI,EAAGA,EAAIoM,UAAUrI,OAAQ/D,IAClC+mB,EAAK/mB,EAAI,GAAKoM,UAAUpM,GAGhCq0B,EAAMnrB,KAAK,IAAI4rB,EAAKb,EAAKlN,IACJ,IAAjBsN,EAAMtwB,QAAiBuwB,GACvBN,EAAWS,IASnBK,EAAKlzB,UAAU+yB,IAAM,WACjBtwB,KAAK4vB,IAAIvpB,MAAM,KAAMrG,KAAKM,QAE9BmqB,EAAQkG,MAAQ,UAChBlG,EAAQmG,SAAU,EAClBnG,EAAQ+C,IAAM,GACd/C,EAAQoG,KAAO,GACfpG,EAAQqG,QAAU,GAClBrG,EAAQsG,SAAW,GAInBtG,EAAQlF,GAAKmL,EACbjG,EAAQnF,YAAcoL,EACtBjG,EAAQhF,KAAOiL,EACfjG,EAAQ1E,IAAM2K,EACdjG,EAAQjG,eAAiBkM,EACzBjG,EAAQzE,mBAAqB0K,EAC7BjG,EAAQ5G,KAAO6M,EACfjG,EAAQjF,gBAAkBkL,EAC1BjG,EAAQ/E,oBAAsBgL,EAE9BjG,EAAQpF,UAAY,SAAUnpB,GAAQ,MAAO,IAE7CuuB,EAAQuG,QAAU,SAAU90B,GACxB,MAAM,IAAI+D,MAAM,qCAGpBwqB,EAAQwG,IAAM,WAAc,MAAO,KACnCxG,EAAQyG,MAAQ,SAAUluB,GACtB,MAAM,IAAI/C,MAAM,mCAEpBwqB,EAAQ0G,MAAQ,WAAa,OAAO,I,cCvLpCp2B,EAAOD,QAAU,SAAkBgF,GACjC,OAAOA,GAAsB,iBAARA,GACI,mBAAbA,EAAIwB,MACS,mBAAbxB,EAAIoH,MACc,mBAAlBpH,EAAIoK,Y,cCJW,mBAAlB7N,OAAOY,OAEhBlC,EAAOD,QAAU,SAAkBs2B,EAAMC,GACvCD,EAAKE,OAASD,EACdD,EAAK7zB,UAAYlB,OAAOY,OAAOo0B,EAAU9zB,UAAW,CAClDyd,YAAa,CACXpe,MAAOw0B,EACP70B,YAAY,EACZsB,UAAU,EACVD,cAAc,MAMpB7C,EAAOD,QAAU,SAAkBs2B,EAAMC,GACvCD,EAAKE,OAASD,EACd,IAAIE,EAAW,aACfA,EAASh0B,UAAY8zB,EAAU9zB,UAC/B6zB,EAAK7zB,UAAY,IAAIg0B,EACrBH,EAAK7zB,UAAUyd,YAAcoW,I,6BCbjC,IAAIje,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIrV,EAAY,EAAQ,IAUpBF,EAAe,WAqBjB,SAASA,IACP,IAAI0D,EAAOqG,UAAUrI,OAAS,QAAsBe,IAAjBsH,UAAU,GAAmBA,UAAU,GAAK,GAC3E6J,EAAU7J,UAAUrI,OAAS,QAAsBe,IAAjBsH,UAAU,GAAmBA,UAAU,GAAK,IAnCtF,SAAyB6L,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAqC5GyT,CAAgB7T,KAAMhC,GAEtBgC,KAAK6a,WAAWnZ,EAAMkQ,GA2HxB,OArJAuB,EAAanV,EAAc,KAAM,CAAC,CAChCd,IAAK,SAMLV,IAAK,WACH,MAAM,IAAIyD,MAAM,gEA6BpBkT,EAAanV,EAAc,CAAC,CAC1Bd,IAAK,aACLN,MAAO,WACL,IAAI8E,EAAOqG,UAAUrI,OAAS,QAAsBe,IAAjBsH,UAAU,GAAmBA,UAAU,GAAK,GAC3E6J,EAAU7J,UAAUrI,OAAS,QAAsBe,IAAjBsH,UAAU,GAAmBA,UAAU,GAAK,GAC9EkT,EAASjb,KAAKgb,YAAYC,OAE9BA,EAAOJ,WAAW7a,KAAM0B,EAAMkQ,KAU/B,CACD1U,IAAK,WACLN,MAAO,SAAkB40B,GACvB,IAAIvW,EAASjb,KAAKgb,YAAYC,OAE9B,OAAQuW,GAAavW,GAAQpE,SAAS7W,QASvC,CACD9C,IAAK,QACLN,MAAO,SAAemf,GACpB,IAAI0V,EAAQ,IAAIvzB,EAAU6d,GAC1B0V,EAAMprB,MAAMrG,QAOb,CACD9C,IAAK,SACLN,MAAO,cA+BN,CACDM,IAAK,UACLN,MAAO,SAAiB80B,GACtB,OAAOA,EAAQC,QAAQ3xB,SAUvB,CAAC,CACH9C,IAAK,YACLN,MAAO,SAAmBS,GACxB,OAAO0Z,KAAKC,UAAU3Z,KAUvB,CACDH,IAAK,cACLN,MAAO,SAAqB8E,GAC1B,IACE,OAAOqV,KAAKiQ,MAAMtlB,GAClB,MAAOmF,GACP,MAAM,IAAI5G,MAAM,6BAKfjC,EAtJU,GA8JnBjD,EAAOD,QAAUkD,G,6BC5KjB,IAAImV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAIpV,EAAc,EAAQ,IAKtByzB,EAAU,EAUV3zB,EAAc,WAQhB,SAASA,EAAYyzB,GACnB,IAAInd,EAAQvU,MA1BhB,SAAyB4T,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCA4B5GyT,CAAgB7T,KAAM/B,GAEtB5B,OAAOC,eAAe0D,KAAM,UAAW,CACrCzD,YAAY,EACZK,MAAO,IAAIi1B,MAGbx1B,OAAO6W,KAAKwe,GAASnc,QAAQ,SAAUrY,GACrC,IAAIN,EAAQ80B,EAAQx0B,GACpBqX,EAAMmd,QAAQllB,IAAI,IAAIrO,EAAYjB,EAAK00B,GAAU,IAAIzzB,EAAYvB,EAAOg1B,MAwC5E,OA1BAze,EAAalV,EAAa,CAAC,CACzBf,IAAK,MACLN,MAAO,SAAayL,EAAQ0H,GAC1B/P,KAAK0xB,QAAQnc,QAAQ,SAAUuc,EAAOC,GACpCA,EAAK5V,IAAI9T,EAAQypB,EAAMt1B,IAAIuT,QAa9B,CACD7S,IAAK,UACLN,MAAO,SAAiBmT,EAAQ1H,GAC9BrI,KAAK0xB,QAAQnc,QAAQ,SAAUuc,EAAOC,GACpCD,EAAM3V,IAAI9T,EAAQ0pB,EAAKv1B,IAAIuT,UAK1B9R,EA5DS,GAoElBlD,EAAOD,QAAUmD,G,6BCvFjB,IAAI6c,EAA4B,mBAAXpe,QAAoD,iBAApBA,OAAOqe,SAAwB,SAAUpd,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAyB,mBAAXjB,QAAyBiB,EAAIqd,cAAgBte,QAAUiB,IAAQjB,OAAOa,UAAY,gBAAkBI,GAElQwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAEnB,SAASye,EAAgBr0B,EAAKT,EAAKN,GAAiK,OAApJM,KAAOS,EAAOtB,OAAOC,eAAeqB,EAAKT,EAAK,CAAEN,MAAOA,EAAOL,YAAY,EAAMqB,cAAc,EAAMC,UAAU,IAAkBF,EAAIT,GAAON,EAAgBe,EAI3M,IAAII,EAAc,EAAQ,IACtBM,EAAY,EAAQ,IAUpBD,EAAa,WAOf,SAASA,EAAW6c,IApBtB,SAAyBrH,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAqB5GyT,CAAgB7T,KAAM5B,GAGtB/B,OAAOob,OAAOzX,KAAMib,GAGpB5e,OAAO+W,iBAAiBpT,KAAM,CAC5B6a,WAAY,CACVte,YAAY,EACZ01B,WAAW,EACXr1B,MAAOmB,EAAY6d,QAAQX,IAE7BpE,SAAU,CACRta,YAAY,EACZ01B,WAAW,EACXr1B,MAAOyB,EAAUud,QAAQX,MAqD/B,OA9BA9H,EAAa/U,EAAY,CAAC,CACxBlB,IAAK,SACLN,MAAO,SAAgBqe,GACrB,SAASoP,EAAS3oB,GAChB,OAAOA,GAAwE,iBAA/C,IAATA,EAAuB,YAAcoZ,EAAQpZ,KAAgC,OAATA,IAAkBmH,MAAMzJ,QAAQsC,GAsB7H,OAAO,IAAItD,EAnBX,SAAS8zB,EAAS7pB,EAAQ0H,GACxB,IAAIoiB,EAAS91B,OAAOob,OAAO,GAAIpP,GAc/B,OAbIgiB,EAAShiB,IAAWgiB,EAASta,IAC/B1T,OAAO6W,KAAKnD,GAAQwF,QAAQ,SAAUrY,GAChCmtB,EAASta,EAAO7S,KACZA,KAAOmL,EAGX8pB,EAAOj1B,GAAOg1B,EAAS7pB,EAAOnL,GAAM6S,EAAO7S,IAG7Cb,OAAOob,OAAO0a,EAAQH,EAAgB,GAAI90B,EAAK6S,EAAO7S,OAIrDi1B,EAGQD,CAASlyB,KAAMib,QAK7B7c,EA5EQ,GAoFjBrD,EAAOD,QAAUsD,G,8BC9GjB,YACA/B,OAAOC,eAAexB,EAAS,aAAc,CAAE8B,OAAO,IACtD,IAAIw1B,EAAe,EAAQ,IAC3B,SAAS3Y,EAAO4Y,EAAOxxB,GAEnB,YADiB,IAAbA,IAAuBA,EAAW,QAClCvB,EAAO6B,SAASkxB,GACTC,EAAWD,EAAMvwB,SAAS,WAE9BwwB,EAAWhzB,EAAOa,KAAKkyB,EAAOxxB,GAAUiB,SAAS,WAO5D,SAASywB,EAASrQ,GAEd,OADAA,EAAYA,EAAUpgB,WACfswB,EAAa9zB,QAAQ4jB,GACvBnV,QAAQ,MAAO,KACfA,QAAQ,KAAM,KAEvB,SAASulB,EAAWpzB,GAChB,OAAOA,EACF6N,QAAQ,KAAM,IACdA,QAAQ,MAAO,KACfA,QAAQ,MAAO,KAKxB,IAAImV,EAAYzI,EAChByI,EAAUzI,OAASA,EACnByI,EAAUsQ,OArBV,SAAgBtQ,EAAWrhB,GAEvB,YADiB,IAAbA,IAAuBA,EAAW,QAC/BvB,EAAOa,KAAKoyB,EAASrQ,GAAY,UAAUpgB,SAASjB,IAoB/DqhB,EAAUqQ,SAAWA,EACrBrQ,EAAUoQ,WAAaA,EACvBpQ,EAAUuQ,SARV,SAAkBvQ,GACd,OAAO5iB,EAAOa,KAAKoyB,EAASrQ,GAAY,WAQ5CpnB,EAAQwD,QAAU4jB,I,qDClClBpnB,EAAQ0F,WAuCR,SAAqBkyB,GACnB,IAAIC,EAAOC,EAAQF,GACfG,EAAWF,EAAK,GAChBG,EAAkBH,EAAK,GAC3B,OAAuC,GAA9BE,EAAWC,GAAuB,EAAKA,GA1ClDh4B,EAAQ+R,YAiDR,SAAsB6lB,GACpB,IAAIK,EAcAp3B,EAbAg3B,EAAOC,EAAQF,GACfG,EAAWF,EAAK,GAChBG,EAAkBH,EAAK,GAEvBtvB,EAAM,IAAI2vB,EAVhB,SAAsBN,EAAKG,EAAUC,GACnC,OAAuC,GAA9BD,EAAWC,GAAuB,EAAKA,EAS9BG,CAAYP,EAAKG,EAAUC,IAEzCI,EAAU,EAGV9xB,EAAM0xB,EAAkB,EACxBD,EAAW,EACXA,EAGJ,IAAKl3B,EAAI,EAAGA,EAAIyF,EAAKzF,GAAK,EACxBo3B,EACGI,EAAUT,EAAI5tB,WAAWnJ,KAAO,GAChCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,KAAO,GACpCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,KAAO,EACrCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,IAC/B0H,EAAI6vB,KAAcH,GAAO,GAAM,IAC/B1vB,EAAI6vB,KAAcH,GAAO,EAAK,IAC9B1vB,EAAI6vB,KAAmB,IAANH,EAGK,IAApBD,IACFC,EACGI,EAAUT,EAAI5tB,WAAWnJ,KAAO,EAChCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,KAAO,EACvC0H,EAAI6vB,KAAmB,IAANH,GAGK,IAApBD,IACFC,EACGI,EAAUT,EAAI5tB,WAAWnJ,KAAO,GAChCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,KAAO,EACpCw3B,EAAUT,EAAI5tB,WAAWnJ,EAAI,KAAO,EACvC0H,EAAI6vB,KAAcH,GAAO,EAAK,IAC9B1vB,EAAI6vB,KAAmB,IAANH,GAGnB,OAAO1vB,GA3FTvI,EAAQyK,cAkHR,SAAwB6tB,GAQtB,IAPA,IAAIL,EACA3xB,EAAMgyB,EAAM1zB,OACZ2zB,EAAajyB,EAAM,EACnBkyB,EAAQ,GAIH33B,EAAI,EAAG43B,EAAOnyB,EAAMiyB,EAAY13B,EAAI43B,EAAM53B,GAH9B,MAInB23B,EAAMzuB,KAAK2uB,EACTJ,EAAOz3B,EAAIA,EALM,MAKgB43B,EAAOA,EAAQ53B,EAL/B,QAUF,IAAf03B,GACFN,EAAMK,EAAMhyB,EAAM,GAClBkyB,EAAMzuB,KACJ4uB,EAAOV,GAAO,GACdU,EAAQV,GAAO,EAAK,IACpB,OAEsB,IAAfM,IACTN,GAAOK,EAAMhyB,EAAM,IAAM,GAAKgyB,EAAMhyB,EAAM,GAC1CkyB,EAAMzuB,KACJ4uB,EAAOV,GAAO,IACdU,EAAQV,GAAO,EAAK,IACpBU,EAAQV,GAAO,EAAK,IACpB,MAIJ,OAAOO,EAAMlrB,KAAK,KA3IpB,IALA,IAAIqrB,EAAS,GACTN,EAAY,GACZH,EAA4B,oBAAfpzB,WAA6BA,WAAaiJ,MAEvD4D,EAAO,mEACF9Q,EAAI,EAAGyF,EAAMqL,EAAK/M,OAAQ/D,EAAIyF,IAAOzF,EAC5C83B,EAAO93B,GAAK8Q,EAAK9Q,GACjBw3B,EAAU1mB,EAAK3H,WAAWnJ,IAAMA,EAQlC,SAASi3B,EAASF,GAChB,IAAItxB,EAAMsxB,EAAIhzB,OAEd,GAAI0B,EAAM,EAAI,EACZ,MAAM,IAAInB,MAAM,kDAKlB,IAAI4yB,EAAWH,EAAIvvB,QAAQ,KAO3B,OANkB,IAAd0vB,IAAiBA,EAAWzxB,GAMzB,CAACyxB,EAJcA,IAAazxB,EAC/B,EACA,EAAKyxB,EAAW,GAsEtB,SAASW,EAAaJ,EAAO/wB,EAAOC,GAGlC,IAFA,IAAIywB,EARoBW,EASpBjH,EAAS,GACJ9wB,EAAI0G,EAAO1G,EAAI2G,EAAK3G,GAAK,EAChCo3B,GACIK,EAAMz3B,IAAM,GAAM,WAClBy3B,EAAMz3B,EAAI,IAAM,EAAK,QACP,IAAfy3B,EAAMz3B,EAAI,IACb8wB,EAAO5nB,KAdF4uB,GADiBC,EAeMX,IAdT,GAAK,IACxBU,EAAOC,GAAO,GAAK,IACnBD,EAAOC,GAAO,EAAI,IAClBD,EAAa,GAANC,IAaT,OAAOjH,EAAOrkB,KAAK,IAjGrB+qB,EAAU,IAAIruB,WAAW,IAAM,GAC/BquB,EAAU,IAAIruB,WAAW,IAAM,I,cCnB/BhK,EAAQ4I,KAAO,SAAUnC,EAAQ0C,EAAQ0vB,EAAMC,EAAMC,GACnD,IAAIhtB,EAAG9K,EACH+3B,EAAiB,EAATD,EAAcD,EAAO,EAC7BG,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBE,GAAS,EACTt4B,EAAIg4B,EAAQE,EAAS,EAAK,EAC1B53B,EAAI03B,GAAQ,EAAI,EAChBj2B,EAAI6D,EAAO0C,EAAStI,GAOxB,IALAA,GAAKM,EAEL4K,EAAInJ,GAAM,IAAOu2B,GAAU,EAC3Bv2B,KAAQu2B,EACRA,GAASH,EACFG,EAAQ,EAAGptB,EAAS,IAAJA,EAAWtF,EAAO0C,EAAStI,GAAIA,GAAKM,EAAGg4B,GAAS,GAKvE,IAHAl4B,EAAI8K,GAAM,IAAOotB,GAAU,EAC3BptB,KAAQotB,EACRA,GAASL,EACFK,EAAQ,EAAGl4B,EAAS,IAAJA,EAAWwF,EAAO0C,EAAStI,GAAIA,GAAKM,EAAGg4B,GAAS,GAEvE,GAAU,IAANptB,EACFA,EAAI,EAAImtB,MACH,IAAIntB,IAAMktB,EACf,OAAOh4B,EAAIm4B,IAAsBvnB,KAAdjP,GAAK,EAAI,GAE5B3B,GAAQyJ,KAAK+E,IAAI,EAAGqpB,GACpB/sB,GAAQmtB,EAEV,OAAQt2B,GAAK,EAAI,GAAK3B,EAAIyJ,KAAK+E,IAAI,EAAG1D,EAAI+sB,IAG5C94B,EAAQkG,MAAQ,SAAUO,EAAQ3E,EAAOqH,EAAQ0vB,EAAMC,EAAMC,GAC3D,IAAIhtB,EAAG9K,EAAGC,EACN83B,EAAiB,EAATD,EAAcD,EAAO,EAC7BG,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBI,EAAe,KAATP,EAAcpuB,KAAK+E,IAAI,GAAI,IAAM/E,KAAK+E,IAAI,GAAI,IAAM,EAC1D5O,EAAIg4B,EAAO,EAAKE,EAAS,EACzB53B,EAAI03B,EAAO,GAAK,EAChBj2B,EAAId,EAAQ,GAAgB,IAAVA,GAAe,EAAIA,EAAQ,EAAK,EAAI,EAmC1D,IAjCAA,EAAQ4I,KAAK4uB,IAAIx3B,GAEbqG,MAAMrG,IAAUA,IAAU+P,KAC5B5Q,EAAIkH,MAAMrG,GAAS,EAAI,EACvBiK,EAAIktB,IAEJltB,EAAIrB,KAAK6F,MAAM7F,KAAK+T,IAAI3c,GAAS4I,KAAK6uB,KAClCz3B,GAASZ,EAAIwJ,KAAK+E,IAAI,GAAI1D,IAAM,IAClCA,IACA7K,GAAK,IAGLY,GADEiK,EAAImtB,GAAS,EACNG,EAAKn4B,EAELm4B,EAAK3uB,KAAK+E,IAAI,EAAG,EAAIypB,IAEpBh4B,GAAK,IACf6K,IACA7K,GAAK,GAGH6K,EAAImtB,GAASD,GACfh4B,EAAI,EACJ8K,EAAIktB,GACKltB,EAAImtB,GAAS,GACtBj4B,GAAMa,EAAQZ,EAAK,GAAKwJ,KAAK+E,IAAI,EAAGqpB,GACpC/sB,GAAQmtB,IAERj4B,EAAIa,EAAQ4I,KAAK+E,IAAI,EAAGypB,EAAQ,GAAKxuB,KAAK+E,IAAI,EAAGqpB,GACjD/sB,EAAI,IAID+sB,GAAQ,EAAGryB,EAAO0C,EAAStI,GAAS,IAAJI,EAAUJ,GAAKM,EAAGF,GAAK,IAAK63B,GAAQ,GAI3E,IAFA/sB,EAAKA,GAAK+sB,EAAQ73B,EAClB+3B,GAAQF,EACDE,EAAO,EAAGvyB,EAAO0C,EAAStI,GAAS,IAAJkL,EAAUlL,GAAKM,EAAG4K,GAAK,IAAKitB,GAAQ,GAE1EvyB,EAAO0C,EAAStI,EAAIM,IAAU,IAAJyB,I,cClF5B,IAAIoE,EAAW,GAAGA,SAElB/G,EAAOD,QAAU+N,MAAMzJ,SAAW,SAAUiE,GAC1C,MAA6B,kBAAtBvB,EAAShG,KAAKuH,K,8BCHvB,YACAhH,OAAOC,eAAexB,EAAS,aAAc,CAAE8B,OAAO,IAkBtD9B,EAAQwD,QAjBR,SAAmB+zB,GACf,IACIiC,EAAejC,EAAM3yB,OACrB60B,EAAOD,EAFS,EAGpB,IAAKC,EACD,OAAOlC,EAEX,IAAI1M,EAAW2O,EACXE,EAPgB,EAOYD,EAC5BE,EAAqBH,EAAeE,EACpCjzB,EAASjC,EAAOkH,MAAMiuB,GAE1B,IADAlzB,EAAOP,MAAMqxB,GACNmC,KACHjzB,EAAOP,MAAM,IAAK2kB,KAEtB,OAAOpkB,EAAOO,c,qDCZlB,IAAI4yB,EAAO,EAAQ,IACfC,EAAO,EAAQ,IACfC,EAAoB,EAAQ,IAM5BhgB,EAAsB,IALA,EAAQ,KAUlCA,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI05B,EAAK,CACnDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI05B,EAAK,CACnDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI05B,EAAK,CACnDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI25B,EAAkB,CAChE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI25B,EAAkB,CAChE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,OAAQ,IAAI25B,EAAkB,CAChE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAUV0Y,EAAoB3Z,OAAO,OAAQ,OAAQ,IAAIy5B,EAAK,KAOpD9f,EAAoB3Z,OAAO,QAAS,SAAU,IAAI05B,EAAK,CACrDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,SAAU,IAAI05B,EAAK,CACrDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,SAAU,IAAI05B,EAAK,CACrDz4B,KAAM,OACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,SAAU,IAAI25B,EAAkB,CAClE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,SAAU,IAAI25B,EAAkB,CAClE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,SAAU,IAAI25B,EAAkB,CAClE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAUV0Y,EAAoB3Z,OAAO,OAAQ,SAAU,IAAIy5B,EAAK,KAItD9f,EAAoB3Z,OAAO,QAAS,YAAa,IAAI25B,EAAkB,CACrE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,YAAa,IAAI25B,EAAkB,CACrE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAIV0Y,EAAoB3Z,OAAO,QAAS,YAAa,IAAI25B,EAAkB,CACrE14B,KAAM,oBACNowB,KAAM,CACJpwB,KAAM,cAOVnB,EAAOD,QAAU8Z,G,6BCnJjB,IAAIzB,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAOnB,IAAImhB,EAAO,WACT,SAASA,KANX,SAAyB9gB,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAO5GyT,CAAgB7T,KAAM00B,GAwBxB,OArBAvhB,EAAauhB,EAAM,CAAC,CAClBx3B,IAAK,OAKLN,MAAO,WACL,OAAOoY,QAAQ2C,QAAQ,MAOxB,CACDza,IAAK,SACLN,MAAO,gBAKF83B,EA1BE,GAkCX35B,EAAOD,QAAU45B,G,8BC3CjB,YAOA,IAAIvhB,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAI2O,EAAY,EAAQ,GACpB2S,EAAS,EAAQ,GACjBzV,EAAc,EAAQ,IAMtBuV,EAAO,WAOT,SAASA,EAAKtc,IAjBhB,SAAyBzE,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAkB5GyT,CAAgB7T,KAAM20B,GAEtB30B,KAAKqY,OAASA,EA6EhB,OA3DAlF,EAAawhB,EAAM,CAAC,CAClBz3B,IAAK,OACLN,MAAO,SAAcM,EAAKwE,GACxB,IAAIozB,EAAY90B,KAAKqY,OAMrB,OAFA3W,GAAO,IAAI0d,GAAc3F,OAAO/X,GAEzBmzB,EAAOE,OAAO7f,KAAK4f,EAAW53B,EAAKwE,GAAM0V,KAAK,SAAUjC,GAC7D,OAAO+M,EAAU5iB,EAAOa,KAAKgV,QAiBhC,CACDjY,IAAK,SACLN,MAAO,SAAgBM,EAAKiY,EAAWzT,GACrC,IAAIozB,EAAY90B,KAAKqY,OAUrB,MARyB,iBAAdlD,IACTA,EAAYvV,WAAWO,KAAK+hB,EAAUuQ,SAAStd,KAG7B,iBAATzT,IACTA,GAAO,IAAI0d,GAAc3F,OAAO/X,IAG3BmzB,EAAOE,OAAO3f,OAAO0f,EAAW53B,EAAKiY,EAAWzT,KAUxD,CACDxE,IAAK,4BACLN,MAAO,SAAmCM,GACxC,GAAIA,EAAIwC,OAASM,KAAKg1B,UACpB,MAAM,IAAI/0B,MAAM,6BAKf00B,EAvFE,GA+FX55B,EAAOD,QAAU65B,I,sCClHjB55B,EAAOD,QAAUS,G,8BCAjB,YAOA,IAAI4X,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAInB,IAAI2O,EAAY,EAAQ,GACpB2S,EAAS,EAAQ,GACjBzV,EAAc,EAAQ,IAMtBwV,EAAoB,WAOtB,SAASA,EAAkBvc,IAjB7B,SAAyBzE,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAkB5GyT,CAAgB7T,KAAM40B,GAEtB50B,KAAKqY,OAASA,EAyGhB,OAzFAlF,EAAayhB,EAAmB,CAAC,CAC/B13B,IAAK,OACLN,MAAO,SAAcM,EAAKwE,GACxB,IAAIozB,EAAY90B,KAAKqY,OAarB,OAFA3W,GAAO,IAAI0d,GAAc3F,OAAO/X,GAEzBmzB,EAAOE,OAAO7f,KAAK4f,EAAW53B,EAAKwE,GAAM0V,KAAK,SAAUjC,GAC7D,OAAO+M,EAAU5iB,EAAOa,KAAKgV,QAiBhC,CACDjY,IAAK,SACLN,MAAO,SAAgBM,EAAKiY,EAAWzT,GACrC,IAAIozB,EAAY90B,KAAKqY,OAWrB,MATyB,iBAAdlD,IACTA,EAAYvV,WAAWO,KAAK+hB,EAAUuQ,SAAStd,KAG7B,iBAATzT,IACTA,GAAO,IAAI0d,GAAc3F,OAAO/X,IAI3BmzB,EAAOE,OAAO3f,OAAO0f,EAAW53B,EAAKiY,EAAWzT,KAUxD,CACDxE,IAAK,YACLN,MAAO,SAAmBM,GACxB,IAAI4iB,EAAMzjB,OAAOob,OAAO,GAAIva,GACxB43B,EAAY90B,KAAKqY,OACjB4c,EAAS/3B,EAAa,SAAK,GAM/B,MAJgB,QAAZA,EAAIwQ,KACNunB,EAAOpwB,KAAK,UAGE,QAAZ3H,EAAIwQ,IAECsH,QAAQ2C,QAAQza,IAGrBA,EAAIyQ,UACNsnB,EAAS/3B,EAAIyQ,SAGRknB,EAAOE,OAAO1f,UAAU,MAAOyK,EAAKgV,GAAW,EAAMG,GAAQ7d,KAAK,SAAUoQ,GAMjF,OALAnrB,OAAOC,eAAewjB,EAAK,YAAa,CACtCvjB,YAAY,EACZK,MAAO4qB,IAGF1H,SAKN8U,EAnHe,GA2HxB75B,EAAOD,QAAU85B,I,qDC5IjB,IAAIzhB,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAOnB,IAAIsB,EAAoB,EAAQ,IAK5BqgB,EAAa,CAAC,OAAQ,SAAU,UAAW,UAAW,aAMtDC,EAAsB,WAKxB,SAASA,IACP,IAAI5gB,EAAQvU,MAtBhB,SAAyB4T,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAwB5GyT,CAAgB7T,KAAMm1B,GAEtBD,EAAW3f,QAAQ,SAAU0G,GAC3B1H,EAAM0H,GAAM,KAiEhB,OAxDA9I,EAAagiB,EAAqB,CAAC,CACjCj4B,IAAK,SAcLN,MAAO,SAAgBiR,EAAKoO,EAAImZ,GACHp1B,KAAKic,GACXpO,GAAOunB,IAe7B,CACDl4B,IAAK,YACLN,MAAO,SAAmBqf,EAAIpO,GAC5B,IAAIwnB,EAAuBr1B,KAAKic,GAEhC,IAAKoZ,EACH,OAAO,IAAIC,YAGb,IAAIF,EAAWC,EAAqBxnB,GAEpC,OAAKunB,GACI,IAAIvgB,EAAkBhH,MAK/B,CAAC,CACH3Q,IAAK,aACLV,IAAK,WACH,OAAO04B,MAIJC,EA5EiB,GAoF1Bp6B,EAAOD,QAAUq6B,G,6BCnGjB,IACIr3B,EADW,EAAQ,GACAA,QAOvBA,EAAQ+Z,SAAS,cAAe,IAAI6C,QACpC5c,EAAQ+Z,SAAS,cAAe,IAAI6C,QACpC5c,EAAQ+Z,SAAS,MAAO,IAAI6C,QAC5B5c,EAAQ+Z,SAAS,MAAO,IAAI6C,QAC5B5c,EAAQ+Z,SAAS,SAAU,IAAI6C,QAC/B5c,EAAQ+Z,SAAS,YAAa,IAAI6C,QAClC5c,EAAQ+Z,SAAS,YAAa,IAAI6C,S,6BCblC,IAAIvH,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAQnB,IACIvV,EADW,EAAQ,GACKA,aAExBe,EAAe,EAAQ,IACvBP,EAAM,EAAQ,IAUdC,EAAS,SAAUohB,GAGrB,SAASphB,IAGP,OA1BJ,SAAyBmV,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCAwB5GyT,CAAgB7T,KAAMvB,GAtB1B,SAAoCoT,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EAwBvNyjB,CAA2Bvf,MAAOvB,EAAOoB,WAAaxD,OAAOmU,eAAe/R,IAAS4H,MAAMrG,KAAM+H,YAkD1G,OAxEF,SAAmByX,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAiB/dE,CAAUlhB,EAwDVT,GAhDAmV,EAAa1U,EAAQ,KAAM,CAAC,CAC1BvB,IAAK,aAMLN,MAAO,SAAoBqa,GACzB,IAAIL,EAAa5W,KAAKib,OAAOpE,SAASI,GAEtC,IAAKL,EAAWE,MACd,OAAO9B,QAAQC,OAAO,IAAIhV,MAAM,mBAAqB8W,KAAKC,UAAUJ,EAAY,KAAM,KAGxF,IAAKK,EAAK/D,KACR,OAAO8B,QAAQC,OAAO,IAAIhV,MAAM,iDAGlC,IAAIs1B,OAAW,EACXC,OAAY,EAEhB,IACED,EAAW,IAAI92B,EAAOwY,GACtBue,EAAYve,EAAK/D,KAAKiB,IAAI,SAAUjX,GAClC,OAAOsB,EAAI6W,UAAUnY,KAEvB,MAAO8U,GACP,OAAOgD,QAAQC,OAAOjD,GAGxB,OAAOgD,QAAQygB,IAAID,GAAWpe,KAAK,SAAUlE,GAE3C,OADAqiB,EAASriB,KAAOA,EACTqiB,MAGV,CACDr4B,IAAK,SAMLV,IAAK,WACH,OAAOuC,MAIJN,EAxDI,GAgEb1D,EAAOD,QAAU2D,G,6BC1FjB,IAAIqc,EAA4B,mBAAXpe,QAAoD,iBAApBA,OAAOqe,SAAwB,SAAUpd,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAyB,mBAAXjB,QAAyBiB,EAAIqd,cAAgBte,QAAUiB,IAAQjB,OAAOa,UAAY,gBAAkBI,GAElQwV,EAAe,WAAc,SAASC,EAAiB/K,EAAQgL,GAAS,IAAK,IAAI1X,EAAI,EAAGA,EAAI0X,EAAM3T,OAAQ/D,IAAK,CAAE,IAAI2X,EAAaD,EAAM1X,GAAI2X,EAAW/W,WAAa+W,EAAW/W,aAAc,EAAO+W,EAAW1V,cAAe,EAAU,UAAW0V,IAAYA,EAAWzV,UAAW,GAAMxB,OAAOC,eAAe+L,EAAQiL,EAAWpW,IAAKoW,IAAiB,OAAO,SAAUC,EAAaC,EAAYC,GAAiJ,OAA9HD,GAAYJ,EAAiBG,EAAYhW,UAAWiW,GAAiBC,GAAaL,EAAiBG,EAAaE,GAAqBF,GAA7gB,GAWnB,IAAI2O,EAAY,EAAQ,GAGpBlkB,EADW,EAAQ,GACKA,aAExBiB,EAAY,EAAQ,IACpBN,EAAM,EAAQ,IACdihB,EAAY,EAAQ,IAMpBlhB,EAAM,SAAUmhB,GAGlB,SAASnhB,IAGP,OA5BJ,SAAyBkV,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInT,UAAU,qCA0B5GyT,CAAgB7T,KAAMtB,GAxB1B,SAAoCmT,EAAM/V,GAAQ,IAAK+V,EAAQ,MAAM,IAAIyN,eAAe,6DAAgE,OAAOxjB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8B+V,EAAP/V,EA0BvNyjB,CAA2Bvf,MAAOtB,EAAImB,WAAaxD,OAAOmU,eAAe9R,IAAM2H,MAAMrG,KAAM+H,YAuPpG,OA/QF,SAAmByX,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIrf,UAAU,kEAAoEqf,GAAeD,EAASjiB,UAAYlB,OAAOY,OAAOwiB,GAAcA,EAAWliB,UAAW,CAAEyd,YAAa,CAAEpe,MAAO4iB,EAAUjjB,YAAY,EAAOsB,UAAU,EAAMD,cAAc,KAAe6hB,IAAYpjB,OAAOqjB,eAAiBrjB,OAAOqjB,eAAeF,EAAUC,GAAcD,EAAS3f,UAAY4f,GAmB/dE,CAAUjhB,EA6PVV,GArPAmV,EAAazU,EAAK,CAAC,CACjBxB,IAAK,QAMLN,MAAO,WACL,QAASoD,KAAKggB,OAAOuB,MAOtB,CACDrkB,IAAK,cACLN,MAAO,SAAqBqa,GAC1B,IAAInJ,EAAM9N,KAAKggB,OAAOlS,IAClBoF,OAAO,EACP/K,OAAQ,EAkBZ,GAfIU,MAAMzJ,QAAQ6X,KAChB/D,EAAO+D,GAILA,EAAK/D,OACPA,EAAO+D,EAAK/D,MAIT+D,EAAK/D,MAAwE,iBAA/C,IAAT+D,EAAuB,YAAc6D,EAAQ7D,MACrE/D,EAAO,CAAC+D,KAIL/D,EACH,MAAM,IAAI0M,EAAU,wBAetB,SAVEzX,EADE2F,EACMoF,EAAKwiB,KAAK,SAAU5V,GAC1B,OAAOA,EAAIhS,MAAQA,IAGboF,EAAKwiB,KAAK,SAAU5V,GAC1B,MAAmB,QAAZA,EAAIpS,SAMb1N,KAAK9C,IAAMiL,EAAMqf,WACV,KAeV,CACDtqB,IAAK,SACLN,MAAO,WAEL,IAAIga,EAAa5W,KAAK6W,WAEtB,IAAKD,EAAWE,MACd,OAAO9B,QAAQC,OAAO2B,GAKxB,OAAI5W,KAAK21B,QACAC,IAAIC,QAHD71B,MAKHrB,EAAIuW,KALDlV,QAkBb,CACD9C,IAAK,SACLN,MAAO,WACL,IAAIga,EAAa5W,KAAK6W,WAEtB,OAAKD,EAAWE,MAITnY,EAAIyW,OAAOpV,MAHTgV,QAAQC,OAAO2B,MAKxB,CAAC,CACH1Z,IAAK,SAYLN,MAAO,SAAgB8E,GACrB,IACIygB,OAAM,EAEV,GAAoB,iBAATzgB,EACT,MAAM,IAAIke,EAAU,wBAItB,GAAIle,EAAKo0B,WAAW,KAAM,CACxB,IACEp0B,EAAOqV,KAAKiQ,MAAMtlB,EAAM,cACxB,MAAO6P,GACP,MAAM,IAAIqO,EAAU,6BAGlBle,EAAKgf,YAAchf,EAAK6e,WAC1B7e,EAAKkf,cAAgB,OAErBlf,EAAKkf,cAAgB,YAGvBuB,EAAM,IArBUniB,KAqBM0B,EAAM,CAAEsb,QAAQ,SAItC,IACE,IACI+C,EAAWre,EAAKwS,MAAM,KACtBxU,EAASqgB,EAASrgB,OAEtB,GAAe,IAAXA,GAA2B,IAAXA,EAClB,MAAM,IAAIO,MAAM,iBAGlB,IAAI+f,EAASjJ,KAAKiQ,MAAM9E,EAAUsQ,OAAOzS,EAAS,KAGlD,GAAe,IAAXrgB,EAAc,CAKhByiB,EAAM,IA1CMniB,KA0CU,CAAEyB,KAJb,MAIyBse,SAAUA,EAAUC,OAAQA,EAAQS,QAH1D1J,KAAKiQ,MAAM9E,EAAUsQ,OAAOzS,EAAS,KAGuC5K,UAF1E4K,EAAS,GAEuFa,cAhB9F,WAgB8H,CAAE5D,QAAQ,KAkB5J,MAAOzL,GACP,MAAM,IAAIqO,EAAU,qCAIxB,OAAOuC,IAgBR,CACDjlB,IAAK,SACLN,MAAO,SAAgBojB,EAAQS,EAASvjB,GAEtC,OADU,IAAIwB,EAAIshB,EAAQS,GACfhH,OAAOvc,KAcnB,CACDA,IAAK,SACLN,MAAO,SAAgBM,EAAKsX,GAC1B,IAAI2N,EAAMzjB,EAAI8zB,OAAOhe,GAErB,OADA2N,EAAIjlB,IAAMA,EACHilB,EAAI/M,SAASgC,KAAK,SAAUuJ,GACjC,OAAOwB,MAGV,CACDjlB,IAAK,SAMLV,IAAK,WACH,OAAOyC,MAIJP,EA7PC,GAqQV3D,EAAOD,QAAU4D,G,iBCjSjB,YAGA,MAAMgQ,EAAS1T,EAAQ,IACjBknB,EAAYlnB,EAAQ,GACpB65B,EAAS75B,EAAQ,IACjB,IAAE0D,GAAQ1D,EAAQ,GAClByb,EAAiBzb,EAAQ,KACzB,IAAEmb,GAAQnb,EAAQ,GAKxB,MAAMqb,EAgBJ,cAAeM,EAAI/E,EAAS8G,GAC1B,MAAM,SAACxB,EAAD,SAAWM,EAAX,aAAqBF,GAAgBX,EAE3C,IAAIU,EAAQ0e,EAAUC,EAAQ3d,EAE9B,OAAOrD,QAAQ2C,UACZP,KAAK,KAGJ1I,EAAOwI,EAASc,cACd,yDAEFtJ,EAAO8I,EAASye,aACd,8DAEFvnB,EAAO4I,EACL,+CAGFD,EAASH,EAASc,cAAcX,OAChC0e,EAAW7e,EAASc,cAAcke,uBAClCF,EAAS,CAAE7O,UAAW7P,EAAa6P,WACnC9O,EAAShc,OAAOob,OAAOD,EAASye,aAAcD,EAAQpkB,GAGtDlD,EAAO2I,EACL,mDAEF3I,EAAOqnB,EACL,mEAEFrnB,EAAO2J,EAAO8d,MACZ,qDAEFznB,EAAO2J,EAAO+d,cACZ,6DAEF1nB,EAAO2J,EAAO8O,UACZ,yDAEFzY,EAAO2J,EAAOge,aACZ,4DAGFhe,EAAOe,MAAQvQ,MAAM1I,KAAK00B,EAAOyB,gBAAgB,IAAI12B,WAAW,MAChEyY,EAAOke,MAAQ1tB,MAAM1I,KAAK00B,EAAOyB,gBAAgB,IAAI12B,WAAW,MAGzDoV,QAAQygB,IAAI,CACjBZ,EAAOE,OAAOyB,OAAO,CAAEt6B,KAAM,WAAa,IAAI0D,WAAWyY,EAAOe,QAChEyb,EAAOE,OAAOyB,OAAO,CAAEt6B,KAAM,WAAa,IAAI0D,WAAWyY,EAAOke,YAOnEnf,KAAKqf,IACJ,IAAIrd,EAAQ8I,EAAU5iB,EAAOa,KAAKs2B,EAAQ,KACtCF,EAAQrU,EAAU5iB,EAAOa,KAAKs2B,EAAQ,KAK1C/d,KAJarB,oBAAyB+B,KAIvBrC,KAAKC,UAAUqB,GAG9BA,EAAOe,MAAQA,EACff,EAAOke,MAAQA,IAGhBnf,KAAK,IAAMf,EAAsBqgB,uBAEjCtf,KAAKuf,IACJtgB,EAAsBugB,iBAAiBD,EAAate,EAAQK,KAK7DtB,KAAK,KACJ,GAAIF,EAASc,cAAc6e,4BACzB,OAAOxgB,EAAsBygB,oBAAoBze,GAE9CjB,KAAK2f,IAAmB1e,EAAS0e,MAKvC3f,KAAK,KACJ,IAAIG,EAAM,IAAIpB,EAAI4f,GAGlB,OAFAxe,EAAIiC,OAAS/C,EAAegD,OAAOpB,GAE5Bd,EAAImC,OAIjB,6BACE,OAAOmb,EAAOE,OAAOiC,YACnB,CACE96B,KAAM,oBACN+6B,cAAe,KACfC,eAAgB,IAAIt3B,WAAW,CAAC,EAAM,EAAM,IAC5C0sB,KAAM,CAAEpwB,KAAM,aAEhB,EACA,CAAC,OAAQ,WAERkb,KAAM+f,GAEEniB,QAAQygB,IAAI,CACjBZ,EAAOE,OAAOqC,UAAU,MAAOD,EAAQE,WACvCxC,EAAOE,OAAOqC,UAAU,MAAOD,EAAQG,eAG1ClgB,KAAKmgB,IACJ,IAAMC,EAAWC,GAAeF,EAEhC,MAAO,CAAEG,OAAQF,EAAWG,QAASF,KAI3C,wBAAyBd,EAAate,EAAQK,GAE5CA,EAAQ,2BAA6B3B,KAAKC,UAAU2f,EAAYgB,SAChEtf,EAAOnb,IAAMy5B,EAAYe,OAG3B,2BAA4Brf,GAC1B,MAAMuf,EAAgB,CAAC,QAAS,YAAa,gBAAiB,SAExDC,EAAex7B,OAAO6W,KAAKmF,GAAQ2E,OAAO9f,IAAQ06B,EAAclvB,SAASxL,IAE/E,IAAIujB,EAAU,GAWd,OATAoX,EAAatiB,QAAQrY,IACnBujB,EAAQvjB,GAAOmb,EAAOnb,KAGF,IAAIwB,EAAI,CAC5BshB,OAAQ,CAAEnS,IAAK,QACf4S,WACC,CAAEzD,QAAQ,IAEUvD,SACpBrC,KAAK0gB,IASJ,MARgB,CACd3B,MAAO9d,EAAM,MACb8O,UAAW9O,EAAM,UACjB+d,cAAe/d,EAAM,cACrB0f,QAASD,EACT1e,MAAOf,EAAM,UAWvBtd,EAAOD,QAAUub,I,yCC9LjB,cAGA,MAAM,IAAEF,GAAQnb,EAAQ,GAClB0T,EAAS1T,EAAQ,IACjB65B,EAAS75B,EAAQ,GACjBknB,EAAYlnB,EAAQ,GACpBkb,EAAQlb,EAAQ,GAChBob,EAAUF,EAAME,QAAUF,EAAME,QAAU1P,EAAO0P,QACjDK,EAAiBzb,EAAQ,IACzBg9B,EAAUh9B,EAAQ,IAClBi9B,EAAUj9B,EAAQ,IAClBwb,EAAcxb,EAAQ,IACtBk9B,EAAYl9B,EAAQ,IAK1B,MAAMsb,EAUJ0E,aAAa,GAACrE,EAAD,SAAKiC,EAAL,KAAeN,EAAf,QAAqBI,EAArB,KAA8B5b,EAA9B,OAAoCub,EAAS,KACxDrY,KAAK2W,GAAKA,EACV3W,KAAK4Y,SAAWA,EAChB5Y,KAAKsY,KAAOA,EACZtY,KAAK0Y,QAAUA,EACf1Y,KAAKlD,KAAOA,EACZkD,KAAKqY,OAASA,EAahB,wBAAyB5C,GACvB,OAAOT,QAAQ2C,QAAQlC,GACpB2B,KAAKpX,KAAKm4B,eACV/gB,KAAKpX,KAAKo4B,eACVhhB,KAAKpX,KAAKq4B,cACVjhB,KAAKpX,KAAKs4B,oBACVlhB,KAAKpX,KAAKu4B,sBACVnhB,KAAKpX,KAAKw4B,wBACVphB,KAAKpX,KAAKy4B,2BACVrhB,KAAKpX,KAAK04B,iBACVthB,KAAK6gB,EAAQU,kBAUlB,qBAAsBljB,GACpB,IAAI,SAACmD,EAAD,KAAWN,GAAQ7C,EAGvB,GAAKmD,GAAYN,IAAWM,IAAaN,EACvC,MAAM,IAAI4f,EAAU,IAAK,yBAI3B,GAAItf,EAAU,CACZ,IAAIrB,EAAM,IAAIpB,EAAIyC,IACd,OAACY,EAAD,KAAS8S,GAAQ/U,EAErB,GAAKiC,GAAU8S,IAAW9S,IAAW8S,EACnC,MAAM,IAAI4L,EAAU,IAAK,yBAGvB1e,IACF/D,EAAS4C,OAAS5B,EAAe+b,OAAOhZ,EAAOnH,UAAU,IACzDoD,EAAS3Y,KAAO,SAGdwvB,IACF7W,EAAS4C,OAAS5B,EAAe+b,OAAOlG,EAAKja,UAAU,IACvDoD,EAAS3Y,KAAO,YAUpB,OALIwb,IACF7C,EAAS4C,OAAS5B,EAAe+b,OAAOla,GACxC7C,EAAS3Y,KAAO,aAGX2Y,EAgBT,qBAAsBA,GACpB,MAAMmjB,EAAYnjB,EAAS4C,OAAO9G,MAElC,GAAIqnB,EAAW,CACb,MAAMC,EAAc,GACpBA,EAAW,MAAYD,EACvBC,EAAW,kBAAwBpjB,EAAS4C,OAAT,kBACnCwgB,EAAW,UAAgBpjB,EAAS4C,OAAT,UAC3BwgB,EAAW,MAAYpjB,EAAS4C,OAAT,MAEvB,MAAM9G,EAAQ,IAAItR,uCAAuC24B,KAEzD,MADArnB,EAAMunB,KAAOD,EACPtnB,EAGR,OAAOkE,EAST,oBAAqBA,GACnB,IAAI,GAACkB,EAAD,OAAK0B,EAAL,QAAaK,GAAWjD,EACxB2D,EAAQf,EAAOe,MACf/B,EAASV,EAAGO,SAASc,cAAcX,OAEvC,IAAK+B,EACH,MAAM,IAAInZ,MACR,sDAGJ,IACI83B,EAAUrf,KADDrB,oBAAyB+B,KAGtC,IAAK2e,EACH,MAAM,IAAI93B,MACR,0DAIJ,OADAwV,EAASsiB,QAAUhhB,KAAKiQ,MAAM+Q,GACvBtiB,EAST,0BAA2BA,GACzB,IAAIsjB,EAAS,IAAIn5B,WAAW6V,EAASsiB,QAAQ3e,OACzC4f,EAAUvjB,EAAS4C,OAAOe,MAE9B,OAAOyb,EAAOE,OAAOyB,OAAO,CAAEt6B,KAAM,WAAa68B,GAAQ3hB,KAAKof,IAC5D,GAAIwC,IAAY9W,EAAU5iB,EAAOa,KAAKq2B,IACpC,MAAM,IAAIv2B,MACR,0DAGJ,OAAOwV,IAUX,4BAA6BA,GAC3B,GAAuC,SAAnCA,EAASsiB,QAAQ3B,eAA8C,UAAlB3gB,EAAS3Y,KACxD,MAAM,IAAImD,MAAM,yBAGlB,OAAOwV,EAST,8BAA+BA,GAC7B,IAAI,QAACsiB,EAAD,OAAU1f,GAAU5C,EACpBwjB,EAAiBlB,EAAQ3B,cAAcliB,MAAM,KAqBjD,OAnBI+kB,EAAevwB,SAAS,SAC1BgG,EAAO2J,EAAO5L,KACZ,yDAIAwsB,EAAevwB,SAAS,aAC1BgG,EAAO2J,EAAO0O,SACZ,+CAGAkS,EAAevwB,SAAS,WAC1BgG,EAAO2J,EAAOW,aACZ,mDAEFtK,EAAO2J,EAAOkP,WACZ,kDAGG9R,EAST,iCAAkCA,GAChC,IAAI,GAACkB,EAAD,OAAK0B,EAAL,QAAa0f,GAAWtiB,EACxBhJ,EAAO4L,EAAO5L,KAGlB,IAAKA,GAAqC,SAA7BsrB,EAAO,cAClB,OAAO/iB,QAAQ2C,QAAQlC,GAGzB,IAAI,SAACyB,EAAD,aAAWI,GAAgBX,EAC3BuiB,EAAK5hB,EAAY,UACjB6hB,EAAS7hB,EAAY,cAGzB,IAAK6hB,EACD,OAAOnkB,QAAQC,OAAO,IAAIhV,MACxB,sFAKN,IAAI81B,EAAW7e,EAASc,cAAcohB,eAIlChhB,EAAU,IAAIhC,EAAQ,CACxB,eAAgB,sCAIdijB,EAAe,CACjB,WAAc,qBACd,KAAQ5sB,EACR,aAAgBsrB,EAAO,cAIrBuB,EAAahiB,EAAY,4BACxB,sBAGL,GAAmB,wBAAfgiB,EAAsC,CACxC,IAAIzf,EAAc,IAAIva,KAAU45B,KAAMC,KAAUr3B,SAAS,UACzDsW,EAAQ5L,IAAI,yBAA0BqN,KAIrB,uBAAfyf,IACFD,EAAY,UAAgBH,EAC5BG,EAAY,cAAoBF,GAGlC,IAAI7gB,EAAO7B,EAAegD,OAAO4f,GAQjC,OAAOnjB,EAAM6f,EAAU,CAAC5d,OAtCX,OAsCmBC,UAASE,SACtClB,KAAKZ,EAAY,wCACjBY,KAAKmiB,GAAiBA,EAAcxhB,QACpCX,KAAKmiB,IACJ7qB,EAAO6qB,EAAa,aAClB,0CAEF7qB,EAAO6qB,EAAa,WAClB,wCAEF7qB,EAAO6qB,EAAa,SAClB,sCAKF9jB,EAAS4C,OAAShc,OAAOob,OAAOhC,EAAS4C,OAAQkhB,GAC1C9jB,IAWb,uBAAwBA,GAEtB,OAAKA,EAAS4C,OAAO0O,SAId/R,QAAQ2C,QAAQlC,GACpB2B,KAAKd,EAAuBkjB,gBAC5BpiB,KAAKd,EAAuBmjB,eAC5BriB,KAAKd,EAAuBojB,gBAC5BtiB,KAAKd,EAAuBqjB,kBAC5BviB,KAAKd,EAAuBsjB,aAC5BxiB,KAAKd,EAAuBujB,iBAC5BziB,KAAKd,EAAuBwjB,iBAC5B1iB,KAAKd,EAAuByjB,aAC5B3iB,KAAKd,EAAuB0jB,aAC5B5iB,KAAKd,EAAuB2jB,kBAC5B7iB,KAAKd,EAAuB4jB,yBAC5B9iB,KAAKd,EAAuB6jB,+BAftBnlB,QAAQ2C,QAAQlC,GAwB3B,sBAAuBA,GAErB,OAAOT,QAAQ2C,QAAQlC,GAezB,qBAAsBA,GACpB,IAAI0M,EAAM1M,EAAS4C,OAAO0O,SAE1B,IACEtR,EAAS2kB,QAAUpC,EAAQxF,OAAOrQ,GAClC,MAAOkY,GACP,MAAM9oB,EAAQ,IAAI2mB,EAAU,IAAK,2BAGjC,MAFA3mB,EAAM+oB,MAAQD,EACd9oB,EAAMunB,KAAO,CAAE/R,SAAU5E,GACnB5Q,EAGR,OAAOkE,EAUT,sBAAuBA,GACrB,IAAIuC,EAAgBvC,EAASkB,GAAGO,SAASc,cAIzC,GAHcvC,EAAS2kB,QAAQ3Z,QAGnBI,MAAQ7I,EAAcX,OAChC,MAAM,IAAIpX,MAAM,kCAGlB,OAAOwV,EAST,wBAAyBA,GACvB,IAAI6B,EAAe7B,EAASkB,GAAGW,cAC3B,IAACwJ,EAAD,IAAMyZ,GAAO9kB,EAAS2kB,QAAQ3Z,QAGlC,GAAmB,iBAARK,GAAoBA,IAAQxJ,EAAY,UACjD,MAAM,IAAIrX,MAAM,oCAIlB,GAAI4I,MAAMzJ,QAAQ0hB,KAASA,EAAIpY,SAAS4O,EAAY,WAClD,MAAM,IAAIrX,MAAM,oCAIlB,GAAI4I,MAAMzJ,QAAQ0hB,KAASyZ,EACzB,MAAM,IAAIt6B,MAAM,iCAIlB,GAAIs6B,GAAOA,IAAQjjB,EAAY,UAC7B,MAAM,IAAIrX,MAAM,qCAGlB,OAAOwV,EAUT,mBAAoBA,GAClB,IAAIkB,EAAKlB,EAASkB,GACdO,EAAWP,EAAGO,SACdkjB,EAAU3kB,EAAS2kB,QAEvB,OAAOplB,QAAQ2C,QAAQT,EAASD,MAE7BG,KAAKH,GAAQA,GAAcN,EAAGM,QAE9BG,KAAKH,IACJ,GAAImjB,EAAQR,YAAY3iB,GACtB,OAAOjC,QAAQ2C,QAAQlC,GAEvB,MAAM,IAAIxV,MAAM,6CAWxB,uBAAwBwV,GACtB,IAAI5H,EAAM4H,EAAS2kB,QAAQpa,OAAOnS,IAE9B2sB,EADe/kB,EAASkB,GAAGW,aACK,8BAAoC,QAGxE,GAAIzJ,IAAQ2sB,EACV,MAAM,IAAIv6B,6CAC+Bu6B,KAG3C,OAAO/kB,EAAS2kB,QAAQhlB,SAASgC,KAAKuJ,IACpC,IAAKA,EACH,MAAM,IAAI1gB,MAAM,8BAGlB,OAAOwV,IAUX,uBAAwBA,GAItB,GAHUA,EAAS2kB,QAAQ3Z,QAAQM,KAGxBvb,KAAK6F,MAAMgc,KAAKC,MAAQ,KACjC,MAAM,IAAIrnB,MAAM,oBAGlB,OAAOwV,EAST,mBAAoBA,GAClB,IAAIsjB,EAAS,IAAIn5B,WAAW6V,EAASsiB,QAAQxB,OACzCA,EAAQ9gB,EAAS2kB,QAAQ3Z,QAAQ8V,MAErC,IAAKA,EACH,MAAM,IAAIt2B,MAAM,6BAGlB,OAAO40B,EAAOE,OAAOyB,OAAO,CAAEt6B,KAAM,WAAa68B,GAAQ3hB,KAAKof,IAC5D,GAAID,IAAUrU,EAAU5iB,EAAOa,KAAKq2B,IAClC,MAAM,IAAIv2B,MAAM,iCAGlB,OAAOwV,IAUX,mBAAoBA,GAElB,OAAOA,EAST,wBAAyBA,GAEvB,OAAOA,EAST,+BAAgCA,GAE9B,OAAOA,EAST,qCAAsCA,GAEpC,OAAOA,GAOX1a,EAAOD,QAAUwb,I,6CC1jBjB,MAAM,IAAC5X,GAAO1D,EAAQ,GAChBy/B,EAAgBz/B,EAAQ,IAkB9BD,EAAOD,QAbP,cAAsB4D,EAKpB,oBACE,OAAO+7B,K,gBCZX,MAAM,UAACx7B,GAAajE,EAAQ,GAKtBy/B,EAAgBx7B,EAAUy7B,OAAO,CACrCntB,WAAY,CASVyS,OAAQ,GAORS,QAAS,CACPlT,WAAY,CAUVsT,IAAK,CAAEpf,KAAM,SAAUkZ,OAAQ,OAY/B/O,IAAK,CAAEnK,KAAM,SAAUgd,UAAW,KAkDlCkc,UAAW,CAAEl5B,KAAM,UAAWkZ,OAAQ,eAiBtC4b,MAAO,CAAE90B,KAAM,UAsBfm5B,IAAK,CAAEn5B,KAAM,UAabo5B,IAAK,CAAEp5B,KAAM,QAASmM,MAAO,CAAEnM,KAAM,WAYrC84B,IAAK,CAAE94B,KAAM,SAAUkZ,OAAQ,gBAMjC6B,SAAU,CAAC,MAAO,MAAO,MAAO,MAAO,WAQ7CzhB,EAAOD,QAAU2/B,G,6BC9KjB,MAAMvkB,EAAQlb,EAAQ,GAChBwb,EAAcxb,EAAQ,IACtBif,EAAWjf,EAAQ,IAEzB,MAAMi9B,EAqBJjd,YAAapJ,GACX5R,KAAK86B,eAAiBlpB,EAAQkpB,gBAAkB,eAEhD96B,KAAKqX,OAASzF,EAAQyF,OAEtBrX,KAAK8mB,cAAgBlV,EAAQkV,eAAiB,GAE9C9mB,KAAK6mB,WAAajV,EAAQiV,WAE1B7mB,KAAK+6B,SAAWnpB,EAAQmpB,SACxB/6B,KAAKg7B,aAAeppB,EAAQopB,aAG9B,YAAappB,GACX,OAAO,IAAIqmB,EAAQrmB,GAQrB,wBAAyB6D,GACvB,MAAMiB,EAAe1b,EAAQ,IAE7B,IAAI+/B,EAAWtlB,EAAS2kB,SAAW3kB,EAAS2kB,QAAQ3Z,SAAW,IAE3D,GAAE9J,GAAOlB,EAET6B,EAAeX,EAAGW,aAQlB1F,EAAU,CACZkpB,gBARkBnkB,EAAGa,SAASye,cAAgB,IAEd,iBAChCtf,EAAGa,SAASyjB,SAAW,YAAc,eAMrCpU,WAJepR,EAASiD,QAAQhC,EAAaoD,qBAK7CzC,OAAQ0jB,EAASla,IACjBka,WACAjU,cAAe,CACbK,UAAW7P,EAAY,UACvB0B,aAAcvD,EAAS4C,OAAT,aACd0O,SAAUtR,EAAS4C,OAAT,SACV6iB,cAAezlB,EAAS4C,OAAT,gBAInB,OAAO4f,EAAQ93B,KAAKyR,GAQtB,YASE,MAAO,CAAC2F,EAAK3F,IACJoD,QAAQ2C,UAEZP,KAAK,IACApX,KAAKm7B,iBACAn7B,KAAKo7B,qBAAqB7jB,EAAK3F,GAE/BsE,EAAMqB,EAAK3F,IAIrBwF,KAAKZ,EAAY,kCAWxB6kB,eAAgB9jB,GACd,OAAQvX,KAAK86B,gBACX,IAAK,YACH,OAAO7gB,EAASC,SAAS3C,EAAKvX,MAEhC,QACE,OAAOgV,QAAQ2C,QAAQ3X,KAAK8mB,cAAc9mB,KAAK86B,kBASrDK,iBACE,OAAQn7B,KAAK86B,gBACX,IAAK,YACH,QAAS96B,KAAK8mB,cAAL,SAEX,QACE,QAAS9mB,KAAK8mB,cAAc9mB,KAAK86B,iBAYvCM,qBAAsB7jB,EAAK3F,EAAU,IAGnC,OAFAA,EAAQwG,QAAUxG,EAAQwG,SAAW,GAE9BpY,KAAKq7B,eAAe9jB,GAExBH,KAAK5C,IACJ5C,EAAQwG,QAAQ0O,wBAA0BtS,IAEnC0B,EAAMqB,EAAK3F,MAK1B7W,EAAOD,QAAUm9B,G,6BChKjB,MAAM,IAAE9hB,GAAQnb,EAAQ,IAClB,IAAC0D,EAAD,IAAMF,GAAOxD,EAAQ,GAErBsgC,EAAkB,KAExB,MAAMrhB,UAAiBvb,EAWrB,gBAAiBkoB,EAAmBlO,GAClC,IAAKkO,EACH,MAAM,IAAI3mB,MAAM,uDAGlB,IAAKyY,EAAQmO,WACX,MAAM,IAAI5mB,MAAM,+CAGlB,IAAKyY,EAAQoO,cAAcC,SACzB,MAAM,IAAI9mB,MAAM,4CAGlB,IAAI6f,EAAM/I,KAAKiQ,MAAMtO,EAAQmO,YAE7B,OAAOroB,EAAI6W,UAAUyK,GAClB1I,KAAK6P,IACJ,IAAIrV,EAAU,CACZkP,IAAM,IAAI3K,EAAIyQ,GAAoBM,OAClChqB,IAAK+pB,EACLpG,IAAKnI,EAAQoO,cAAcK,UAC3BJ,SAAUrO,EAAQoO,cAAcC,UAGlC,OAAO9M,EAASmN,MAAMxV,KAEvBwF,KAAK+K,GACGA,EAAI1I,UAsBjB,aAAc7H,GACZ,IAAI,IAAEkP,EAAF,IAAOD,EAAP,IAAY3jB,GAAQ0U,EAEpB/D,EAAM3Q,EAAI2Q,IACVoT,EAAMrP,EAAQqP,KAAOzb,KAAK6F,MAAMgc,KAAKC,MAAQ,KAK7CtH,EAAS,CAAEnS,OACX4S,EAAU,CAAEI,MAAKC,MAAKC,IAHhBE,GAFArP,EAAQ1J,KAAOozB,GAKMra,MAAK8F,SAAUnV,EAAQmV,SAAUQ,WAAY,OAI5E,OAFU,IAAItN,EAAS,CAAE+F,SAAQS,UAASvjB,IAAKA,EAAIsqB,WAAa,CAAExK,QAAQ,KAM9EjiB,EAAOD,QAAUmf,G,gBCrFjBnf,EAAUC,EAAOD,QAAUo9B,EAC3B,IAAIqD,EAAgB,EAAQ,IACxBC,EAAsB,EAAQ,IAC9BC,EAAsB3gC,EAE1B,SAASo9B,EAAUzrB,EAAM+d,EAAKnX,GAE5B,GADmB,iBAAR5G,IAAkBA,EAAOgvB,EAAoBhvB,IACrC,iBAARA,EAAkB,MAAM,IAAIrM,UAAU,yBAC/B,iBAAPoqB,GAA0B,MAAPA,IAAenX,EAAQmX,EAAKA,EAAM,MAChE+Q,EAAcz/B,KAAKkE,KAAMwqB,GAAOgR,EAAoB/uB,GAAO4G,GAC3DrT,KAAKyM,KAAOA,EA6Bd,IAAK,IAAIA,KA1BTyrB,EAAU36B,UAAYlB,OAAOY,OAAOs+B,EAAch+B,UAAW,CAC3Dyd,YAAa,CAACpe,MAAOs7B,EAAWt6B,cAAc,EAAMC,UAAU,KAIhEq6B,EAAU36B,UAAUrB,KAAO,YAE3BG,OAAO+W,iBAAiB8kB,EAAU36B,UAAW,CAC3CsY,WAAY6lB,EAAM,QAClBC,cAAeD,EAAM,WAErBhmB,OAAQ,CACN9X,cAAc,EACdpB,IAAK,WAAa,OAAOwD,KAAKyM,MAC9BD,IAAK,SAAS5P,GACZP,OAAOC,eAAe0D,KAAM,SAAU,CACpCpD,MAAOA,EAAOgB,cAAc,EAAMrB,YAAY,EAAMsB,UAAU,QAMtEq6B,EAAU36B,UAAUuE,SAAW,WAC7B,OAAO9B,KAAK9D,KAAO,KAAO8D,KAAKyM,KAAO,IAAMzM,KAAKqP,SAGlCmsB,EAAqB,CAEpC1gC,EADW0gC,EAAoB/uB,GAClBM,QAAQ,IAAK,IAAIA,QAAQ,QAAS,KAAK2gB,gBAAkBjhB,EAGxE,SAASivB,EAAMx/B,GACb,MAAO,CACL0B,cAAc,EACdpB,IAAK,WAAa,OAAOwD,KAAK9D,IAC9BsQ,IAAK,SAAS5P,GAAS,OAAOoD,KAAK9D,GAAQU,M,cChD/C,IAAIg/B,EAAMv/B,OAAOmB,eACbq+B,EAAQx/B,OAAOmU,eACfqa,EAAQ5qB,MAAM8R,kBAGlB,SAASwpB,EAAc/Q,EAAKnX,GAO1B,GALImX,GAAqB,iBAAPA,GAAiBnX,EAAQmX,EAAKA,OAAM/pB,GACjDT,KAAKqP,QAAUmb,EAIhBnX,EAAO,IAAK,IAAInW,KAAOmW,EAAOrT,KAAK9C,GAAOmW,EAAMnW,GAC/C0+B,EAAI9/B,KAAKkE,KAAM,UAClBA,KAAK9D,KAAO0/B,EAAI9/B,KAAK+/B,EAAM77B,MAAO,QAASA,KAAK9D,KAAO8D,KAAKgb,YAAY9e,OAEtE2uB,GAAW,UAAW7qB,MAAO6qB,EAAM7qB,KAAMA,KAAKgb,aAbpDjgB,EAAOD,QAAUygC,EAgBjBA,EAAch+B,UAAYlB,OAAOY,OAAOgD,MAAM1C,UAAW,CACvDyd,YAAa,CAACpe,MAAO2+B,EAAe39B,cAAc,EAAMC,UAAU,KAIpE09B,EAAch+B,UAAUrB,KAAO,iB,ugDCrB/B,MAAM,WAACkC,GAAcpD,EAAQ,GAUvBub,EAAqB,IAAInY,EAAW,CACxCqD,KAAM,SACN8L,WAAY,CAQV2J,SAAU,CACRzV,KAAM,SACN8L,WAAY,CACVrR,KAAM,CAAEuF,KAAM,UACd8V,IAAK,CAAE9V,KAAM,SAAUkZ,OAAQ,OAM/B3C,cAAe,GACff,KAAM,IAERuF,SAAU,CAAC,QAabhF,SAAU,CACR/V,KAAM,SACN8L,WAAY,CAKV0tB,SAAU,CACRx5B,KAAM,UACNnD,SAAS,GAMX23B,aAAc,CACZx0B,KAAM,SACN8L,WAAY,CACV8oB,aAAc,CACZ50B,KAAM,SACNkZ,OAAQ,OAEVyb,cAAe,CACb30B,KAAM,SACNnD,QAAS,iBACTmP,KAAM,CACJ,OACA,QACA,iBACA,wBAGJquB,QAAS,CACPr6B,KAAM,SACNnD,QAAS,OACTmP,KAAM,CACJ,OACA,UAGJ0oB,MAAO,CACL10B,KAAM,CAAC,SAAU,SACjBnD,QAAS,CAAC,aAQhBuZ,SAAU,KAWdP,aAAc,GAKdI,MAAO,CACLjW,KAAM,SACNnD,QAAS,OAQfvD,EAAOD,QAAUyb,G,8EC1HjB,SAASwlB,IACP,MAAyB,oBAAX5gC,OACVA,OAAO6gC,SACP,CAAEtiB,KAAM,uBAAwB5B,SAAU,IAAKoP,OAAQ,eAGtD,MAAM+U,EAAa,IAAcF,IAAcriB,KAEzCwiB,EAAqB,IAChCH,IAAc7U,OAAS6U,IAAcjkB,SAE1BqkB,EAAc5kB,IACzBwkB,IAAcriB,KAAOnC,GAGV6kB,EAAY7kB,GAAwB,IAAIpB,IAAIoB,GAAK2P,OAEjDmV,EAAe9kB,IACP,iBAARA,IACTA,EAAM,QAASA,EAAMA,EAAIA,IAAMA,EAAIzV,YAE9B,IAAIqU,IAAIoB,EAAK0kB,KAAcn6B,YCC9Bw6B,EAAY,oBAKX,MAAMC,EAMXvhB,YAAYwhB,EAAsBC,EAAsBC,GAAiB,kIACvE18B,KAAK28B,cAAgBH,EACrBx8B,KAAK48B,cAAgBH,EACrBz8B,KAAK68B,SAAWH,EAChB18B,KAAK88B,iBAAmBC,GAAS/8B,KAAKg9B,eAAeD,GAGvD,wBAAqD,IAAhC,KAAEr7B,EAAF,OAAQwlB,GAAwB,EAEnD,GAAIA,IAAWlnB,KAAK48B,cAKlB,YAJAtjB,QAAQ6K,KACN,4CAAqCnkB,KAAK48B,cAA1C,kDACwC1V,EADxC,MAOJ,MAAM+V,EAAMv7B,GAASA,EAAW46B,GAChC,GAAIW,GAAOA,EAAI9kB,OAAQ,CACrB,MAAM,GAAE+gB,EAAF,OAAM/gB,EAAN,KAAcuK,GAAUua,EACxBl0B,QAAY/I,KAAK68B,SAAS1kB,KAAWuK,GAC3C1iB,KAAK28B,cAAcO,YACjB,CAAE,CAACZ,GAAY,CAAEpD,KAAInwB,QACrB/I,KAAK48B,gBAKXv6B,QACElH,OAAOgiC,iBAAiB,UAAWn9B,KAAK88B,kBAG1CM,OACEjiC,OAAOkiC,oBAAoB,UAAWr9B,KAAK88B,mBCnExC,MAAMR,EAAY,oBAUZgB,EAAiB,KAG5B,OAoCK,SAAsBC,GAC3B,MAAO,CACLC,QAAUtgC,GACD8X,QAAQ2C,QAAQ4lB,EAAQC,QAAQtgC,IAGzCugC,QAAS,CAACvgC,EAAasE,IACdwT,QAAQ2C,QAAQ4lB,EAAQE,QAAQvgC,EAAKsE,IAG9Ck8B,WAAaxgC,GACJ8X,QAAQ2C,QAAQ4lB,EAAQG,WAAWxgC,KA/CvCygC,CADa,oBAAXxiC,QAA0B,iBAAkBA,OACfA,OAAOyiC,aAAeC,MAMvDC,eAAeC,EAAQrmB,GAC5B,IAAIsmB,EACAt8B,EACJ,IACEs8B,QAAmBtmB,EAAM8lB,QAAQlB,GACjC56B,EAAOqV,KAAKiQ,MAAMgX,GAAc,MAChC,MAAOn3B,GACPyS,QAAQ6K,KAAK,8BAA+B6Z,GAC5C1kB,QAAQ/H,MAAM1K,GACdnF,EAAO,GAET,OAAOA,EAMFo8B,eAAeG,EACpBvmB,EACAwmB,GAEA,MACMC,EAAUD,QADUH,EAAQrmB,IAGlC,aADMA,EAAM+lB,QAAQnB,EAAWvlB,KAAKC,UAAUmnB,IACvCA,EAsBF,MAAMN,EAAa,KACxB,MAAMnmB,EAAQ,GACd,MAAO,CACL8lB,QAAUtgC,QACkB,IAAfwa,EAAMxa,GAA6B,KACvCwa,EAAMxa,GAEfugC,QAAS,CAACvgC,EAAasE,KACrBkW,EAAMxa,GAAOsE,GAEfk8B,WAAaxgC,WACJwa,EAAMxa,M,2iBC/DZ4gC,eAAeM,EAAWb,GAE/B,aADmBQ,EAAQR,IACf7kB,SAAW,K,0mBCNlBolB,eAAeO,EACpBC,EACA1sB,GAEA,IACE,MAAM+E,QAoEHmnB,eACLQ,EACA1sB,GAIA,IAAI+E,QAAW4nB,EAAY3sB,EAAQ2rB,SAEhC5mB,GACDA,EAAGO,SAASK,MAAQ+mB,GACnB3nB,EAAGW,aAAaknB,cAAc91B,SAASkJ,EAAQ6sB,eAGhD9nB,QA6BJ,SAAoB2nB,EAAatT,GAC/B,MAAM,QAAEuS,EAAF,YAAWkB,GAAgBzT,EAG3B0T,EAAiB,GACvBriC,OAAOysB,QAAQkC,GACZhO,OAAQ,IAAD,IAAE9f,EAAKitB,GAAP,SAAcjtB,EAAI44B,WAAW,iBACpCvgB,QACE,IAAD,IAAErY,EAAKN,GAAP,SACG8hC,EAAexhC,EAAI6P,QAAQ,cAAe,iBAAmBnQ,IAGpE,MAAM+hC,EAAuB,CAC3BC,SAAU5T,EAAK6T,QACfC,SAAU9T,EAAK8T,SACfC,YAAa/T,EAAKgU,YAGd1nB,EAAe,GACnBD,OAAQinB,EACRW,YAAa,CAAC,YACdT,cAAe,CAACC,GAChBS,eAAgB,CApBG,kBAqBnB/I,MAAO,kBACJuI,EANa,GAObC,GAGC/sB,EAAU,CACd4F,SAAU,CACRye,aAAc,CACZI,aAAcoI,EACdrI,cA9Be,mBAiCnB1e,MAAO6lB,GAGT,OAAO7mB,IAAamB,SAASymB,EAAKhnB,EAAc1F,GAnEnCutB,CAAWb,EAAK1sB,SAiB/BksB,eACEP,EACAe,EACA3nB,GAMA,aAJMsnB,EAAcV,EAAS77B,GAAQ,KAChCA,EAD4B,CAE/B09B,SAAUzoB,KAELA,EAzBC0oB,CAAQztB,EAAQ2rB,QAASe,EAAK3nB,IAEtC,OAAOA,EApFY2oB,CAAgBhB,EAAK1sB,GAEtC,aA+JJksB,eAAmCpmB,SAC3BumB,EAAcvmB,EAAOhW,GAAQ,KAC9BA,EAD0B,CAE7B69B,gBAAiBpkC,OAAO6gC,SAAS1P,QAnK3BkT,CAAoB5tB,EAAQ2rB,SAsJtCO,eACEnnB,EADF,GAGiB,IADf,YAAE8nB,EAAF,QAAelB,GACA,EACf,MAAM77B,QAAaq8B,EAAQR,GACrBhmB,QAAYZ,EAAG8B,cAAc,CAAE4d,aAAcoI,GAAe/8B,GAElE,aADMu8B,EAAcV,EAAS,IAAM77B,GAC5By6B,EAAW5kB,GA5JTkoB,CAAgB9oB,EAAI/E,GAC3B,MAAOI,GAGP,OAFAsH,QAAQ6K,KAAK,oCACb7K,QAAQ/H,MAAMS,GACP,MAIJ8rB,eAAe4B,IAEQ,IAD5BnC,EAC4B,uDADJD,IAExB,IAEE,MAAM3mB,QAAW4nB,EAAYhB,GAC7B,IAAK5mB,EACH,OAAO,KAIT,MAAMY,EAAM0kB,IACZ,IAAK,uBAAuB/qB,KAAKqG,GAC/B,OAAO,KAETpc,OAAO6gC,SAAS1P,KAAO,SA+I3BwR,eAAsCpmB,SAC9BumB,EAAcvmB,EAAQ,IAAsC,IAAtC,gBAAE6nB,EAAkB,IAAkB,EAAX79B,EAAW,2BAEhE,OADAvG,OAAO6gC,SAAS1P,KAAOiT,EAChB79B,IAjJDi+B,CAAuBpC,GAG7B,MAAMqC,QAAkB7B,EAAQR,GAC1B7kB,QAAgB/B,EAAGgC,iBAAiBpB,EAAKqoB,GAC/C,OAAKlnB,EAGL,KACKA,EADL,CAEEmnB,MAAOnnB,EAAQqiB,SAASnvB,IACxB0yB,IAAK5lB,EAAQrB,SALN,KAOT,MAAOrF,GAGP,OAFAsH,QAAQ6K,KAAK,sCACb7K,QAAQ/H,MAAMS,GACP,MA6CX8rB,eAAeS,EAAYhB,GACzB,MAAM77B,QAAaq8B,EAAQR,IACrB,SAAE6B,GAAa19B,EACrB,OAAI09B,GACFA,EAAS1nB,MAAQ6lB,EACV7mB,IAAavW,KAAKi/B,IAElB,KAwGJtB,eAAe1C,EACpB1iB,EACAxC,EACAmc,EACAzgB,GAGA,MAAMwG,EAAU,GACV0nB,EAAcluB,EAAUA,EAAQwG,QAAUia,EAAMja,QACtD,GAAI0nB,EAAa,CACf,MAAMhX,EAC2B,mBAAxBgX,EAAYhX,QACfgX,EAAYhX,UACZzsB,OAAOysB,QAAQgX,GACrB,IAAK,MAAO5jC,EAAMU,KAAUksB,EAC1B1Q,EAAQlc,GAAQU,EAKpB,MAAMq+B,QAAiBhhB,IAASC,SAASmiB,EAAYhK,GAAQ3Z,GAE7D,OADAN,EAAQ0O,cAAR,iBAAkCmU,GAC3B/kB,EAAMmc,EAAD,KAAazgB,EAAb,CAAsBiI,YAAa,UAAWzB,a,2iBCzMrD,SAAS2nB,EACdxC,GAEA,OAAOO,UACL,GD2JG,SAAsBkC,GAC3B,GAAoB,MAAhBA,EAAKtqB,OACP,OAAO,EAET,MAAMuqB,EAAgBD,EAAK5nB,QAAQ5b,IAAI,oBACvC,IAAKyjC,EACH,OAAO,EAET,MAAMC,EAAOpZ,QAAoBmZ,GACjC,MACkB,WAAhBC,EAAKtX,QACLsX,EAAK7nB,QACiB,iBAAtB6nB,EAAK7nB,OAAO8d,MCvKRgK,CAAuBH,GAAO,CAChC,MAAM,KAAEI,GAAS,IAAIjqB,IAAI6pB,EAAKzoB,WAjB7B,SAAkBgmB,GACvB,OAAOO,MAAO,IAA0B,IAA1B,IAAEvmB,EAAF,aAAO8oB,GAAmB,QAChCpC,EAAcV,EAAS77B,GAAQ,KAChCA,EAD4B,CAE/B4+B,MAAO,KACF5+B,EAAK4+B,MADL,CAEH,CAAC/oB,GAAM,CAAE8oB,sBAYLE,CAAShD,EAATgD,CAAkB,CAAEhpB,IAAK6oB,EAAMC,cAAc,MCHzDvC,eAAe0C,EACbjD,EACAlL,GAEA,MAAMoO,QD/BD,SAAiBlD,GACtB,OAAOO,UACL,MAAM,KAAEsC,GAAS,IAAIjqB,IAAIoB,GACnBmB,QAAgB0lB,EAAWb,GACjC,GAAI7kB,GAAW0nB,IAAS,IAAIjqB,IAAIuC,EAAQ4lB,KAAK8B,KAC3C,MAAO,CAAE7oB,IAAK6oB,EAAMC,cAAc,GAEpC,MAAM,MAAEC,SAAgBvC,EAAQR,GAChC,OAAO+C,GAASA,EAAMF,ICuBEM,CAAQnD,EAARmD,CAAiBrE,EAAYhK,IACvD,OAAsB,MAAfoO,GAAuBA,EAAYJ,aC5BrC,SAASM,EACdjpB,EACAkpB,EACAhvB,GAEA,OAAO,IAAIoD,QAAQ,CAAC2C,EAAS1C,KAC3B,MAAM4rB,EAAc,IAAItE,EACtBqE,EACAxE,EAASxqB,EAAQkvB,UAAY,IAU5B,SACLppB,EADK,EAGLqpB,GACA,IAFA,SAAED,EAAF,YAAYrC,GAEZ,EACA,OAAOX,eAAO3lB,GAAmC,2BAAhBuK,EAAgB,iCAAhBA,EAAgB,kBAC/C,OAAQvK,GAEN,IAAK,eACH,OAAOhd,OAAO6gC,SAAS9U,OAGzB,IAAK,kBACH,OAAOxP,EAAM8lB,WAAW9a,GAC1B,IAAK,kBACH,OAAOhL,EAAM+lB,WAAW/a,GAC1B,IAAK,qBACH,OAAOhL,EAAMgmB,cAAchb,GAG7B,IAAK,kBACH,MAAO,CAAEoe,WAAUrC,eACrB,IAAK,eACHsC,KAAkBre,KAhCpBse,CAAatpB,EAAO9F,EAAU8G,IAC5BmoB,EAAYzD,OACZzlB,EAAQe,MAGZmoB,EAAYx+B,U,2iBCjBhB,MAAM4+B,EAAc/qB,MAWL,MAAMgrB,UAAwBne,IAAa,qEAGxD7M,MAAMmc,EAAoBzgB,GAExB,OADA5R,KAAK6jB,KAAK,UAAWwY,EAAYhK,IFnB9ByL,eACLP,EACArnB,EACAmc,EACAzgB,GAGA,MAAM8G,QAAgB0lB,EAAWb,GACjC,IAAK7kB,EACH,OAAOxC,EAAMmc,EAAOzgB,GAItB,SAAU4uB,EAAuBjD,EAASlL,GACxC,OAAO+I,EAAqB1iB,EAASxC,EAAOmc,EAAOzgB,GAIrD,IAAIouB,QAAa9pB,EAAMmc,EAAOzgB,GAS9B,OANoB,MAAhBouB,EAAKtqB,eACDqqB,EAAuBxC,EAAvBwC,CAAgCC,SAC5BQ,EAAuBjD,EAASlL,KACxC2N,EAAO5E,EAAqB1iB,EAASxC,EAAOmc,EAAOzgB,KAGhDouB,EEPEmB,CAAW7D,IAAkB2D,EAAa5O,EAAOzgB,GAG1DysB,MAAMC,EAAa1sB,GAEjB,OAAOuuB,EAAgB7B,EADvB1sB,EAAU,KAAKwvB,EAAoBlF,KAA5B,GAAsDtqB,IAI/D,iBAAiBA,GACfA,EAAU,KAAKwvB,IAAR,GAAkCxvB,GACpC,UAAUV,KAAKU,EAAQkvB,YAC1BlvB,EAAQkvB,SAAW,IAAI3qB,IACrBvE,EAAQkvB,UAAY,2BACpB3lC,OAAO6gC,UACPl6B,YAEC8P,EAAQ6sB,cACX7sB,EAAQ6sB,YAAc7sB,EAAQkvB,UAEhC,MAAMF,EDzCH,SAAsBE,GAC3B,MAEM/O,EAAO52B,OAAOkmC,SAAWlmC,OAAOmmC,WAFxB,KAE8C,EACtDC,EAAMpmC,OAAOqmC,SAAWrmC,OAAOsmC,YAFtB,KAE8C,EACvDC,EAAW,SAAH,OAJA,IAIA,mBAHC,IAGD,iBAA2C3P,EAA3C,gBAAuDwP,GACrE,OAAOpmC,OAAOwmC,KAAKb,EAAU,oBAAqBY,GCmClCE,CAAahwB,EAAQkvB,UAC7BpoB,QAAgBioB,EAAc/uB,EAAQ2rB,QAASqD,EAAOhvB,GAG5D,OAFA5R,KAAK6jB,KAAK,QAASnL,GACnB1Y,KAAK6jB,KAAK,UAAWnL,GACdA,EAGT,uBAEqB,IADnB6kB,EACmB,uDADKD,IAGpB5kB,EAAU1Y,KAAK6hC,uBAA0BzD,EAAWb,GAGxD,IAAK7kB,EAAS,CAEZ,IACE1Y,KAAK6hC,gBAAkB1B,EAAyB5C,GAChD7kB,QAAgB1Y,KAAK6hC,gBACrB,MAAO7vB,GACPsH,QAAQ/H,MAAMS,GAIZ0G,ULnDH,SACL6kB,GAEA,OAAOO,UAEL,aADmBG,EAAcV,EAAS77B,GAAQ,EAAJ,GAAUA,EAAV,CAAgBgX,cAClDA,SK+CFopB,CAAYvE,EAAZuE,CAAqBppB,GAC3B1Y,KAAK6jB,KAAK,QAASnL,GACnB1Y,KAAK6jB,KAAK,UAAWnL,WAEhB1Y,KAAK6hC,gBAEd,OAAOnpB,EAGT,mBAAmBqpB,GAEjBA,QAAe/hC,KAAK0/B,kBACpB1/B,KAAKulB,GAAG,UAAWwc,GAGrBC,iBAAiBD,GACf/hC,KAAKwkB,eAAe,UAAWud,GAGjC,eAAsE,IAAzDxE,EAAyD,uDAAjCD,IAEnC,SADsBc,EAAWb,GACpB,CACX,UJhCCO,eACLP,EACArnB,GAEA,MAAMS,QAAW4nB,EAAYhB,GAC7B,GAAI5mB,EACF,UAEQA,EAAGgD,SAET,UACQzD,EAAM,4BAA6B,CAAE2D,YAAa,YACxD,MAAOhT,KAGT,MAAOmL,GACPsH,QAAQ6K,KAAK,+CACb7K,QAAQ/H,MAAMS,IIgBNmuB,CAAiB5C,EAAS0D,GAChCjhC,KAAK6jB,KAAK,UACV7jB,KAAK6jB,KAAK,UAAW,MACrB,MAAO7R,GACPsH,QAAQ6K,KAAK,sBACb7K,QAAQ/H,MAAMS,SLvEf8rB,eAA4BP,SAC3BU,EAAcV,EAAS77B,GAAQ,EAAJ,GAAUA,EAAV,CAAgBgX,QAAS,QKwEhDkB,CAAa2jB,KAKzB,SAAS6D,EAAoB7pB,GAC3B,MAAO,CACLknB,YAAalnB,EAAMA,EAAIrD,MAAM,KAAK,GAAK,GACvC4sB,SAAU,GACVvD,QAASD,KC7Gb,MAAM4C,EAAO,IAAIgB,EACFhB,YAYf,GARA7jC,OAAOwmB,oBAAoBqe,EAAgB3jC,WAAWgY,QAAQjY,IAC5D,MAAMV,EAAQsjC,EAAK5iC,GACE,mBAAVV,IACTsjC,EAAK5iC,GAAYV,EAAMO,KAAK+iC,MAKV,oBAAX/kC,OACT,GAAI,oBAAqBA,OACvBme,QAAQ6K,KAAK,+DACR,CACL,IAAIJ,GAAS,EACb1nB,OAAOC,eAAenB,OAAQ,kBAAmB,CAC/CoB,YAAY,EACZC,IAAK,KACEunB,IACHA,GAAS,EACTzK,QAAQ6K,KAAK,+CACb7K,QAAQ6K,KAAK,0CAER+b,S","file":"solid-auth-client.bundle.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"window\"), require(\"fetch\"), require(\"crypto\"), require(\"TextEncoder\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"window\", \"fetch\", \"crypto\", \"TextEncoder\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"auth\"] = factory(require(\"window\"), require(\"fetch\"), require(\"crypto\"), require(\"TextEncoder\"));\n\telse\n\t\troot[\"solid\"] = root[\"solid\"] || {}, root[\"solid\"][\"auth\"] = factory(root[\"window\"], root[\"fetch\"], root[\"crypto\"], root[\"TextEncoder\"]);\n})(window, function(__WEBPACK_EXTERNAL_MODULE__6__, __WEBPACK_EXTERNAL_MODULE__7__, __WEBPACK_EXTERNAL_MODULE__8__, __WEBPACK_EXTERNAL_MODULE__56__) {\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 = 72);\n","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","'use strict';\n\nmodule.exports = {\n  Formats: require('./Formats'),\n  Initializer: require('./Initializer'),\n  JSONDocument: require('./JSONDocument'),\n  JSONMapping: require('./JSONMapping'),\n  JSONPatch: require('./JSONPatch'),\n  JSONPointer: require('./JSONPointer'),\n  JSONSchema: require('./JSONSchema'),\n  Validator: require('./Validator')\n};","module.exports = require('./dist/base64url').default;\nmodule.exports.default = module.exports;\n","'use strict';\n\n/**\n * @module JSON Object Signing and Encryption (JOSE)\n */\nvar JWA = require('./jose/JWA');\nvar JWK = require('./jose/JWK');\nvar JWKSet = require('./jose/JWKSet');\nvar JWT = require('./jose/JWT');\nvar JWS = require('./jose/JWS');\nvar Base64URLSchema = require('./schemas/Base64URLSchema');\nvar JOSEHeaderSchema = require('./schemas/JOSEHeaderSchema');\nvar JWKSchema = require('./schemas/JWKSchema');\nvar JWKSetSchema = require('./schemas/JWKSetSchema');\nvar JWTClaimsSetSchema = require('./schemas/JWTClaimsSetSchema');\nvar JWTSchema = require('./schemas/JWTSchema');\n\n/**\n * Export\n */\nmodule.exports = {\n  JWA: JWA,\n  JWK: JWK,\n  JWKSet: JWKSet,\n  JWT: JWT,\n  JWS: JWS,\n  Base64URLSchema: Base64URLSchema,\n  JOSEHeaderSchema: JOSEHeaderSchema,\n  JWKSchema: JWKSchema,\n  JWKSetSchema: JWKSetSchema,\n  JWTClaimsSetSchema: JWTClaimsSetSchema,\n  JWTSchema: JWTSchema\n};","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <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","module.exports = __WEBPACK_EXTERNAL_MODULE__6__;","module.exports = __WEBPACK_EXTERNAL_MODULE__7__;","module.exports = __WEBPACK_EXTERNAL_MODULE__8__;","'use strict';\n\n/**\n * Dependencies\n * @ignore\n */\n\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\nvar _require2 = require('../formats'),\n    BASE64_REGEXP = _require2.BASE64_REGEXP;\n\n/**\n * JWK Schema\n */\n\n\nvar JWKSchema = new JSONSchema({\n  type: 'object',\n  properties: {\n\n    kty: {\n      type: 'string',\n      //format: 'case-sensitive',\n      enum: ['RSA', 'EC', 'oct'] // other values MAY be used\n    },\n\n    use: {\n      type: 'string',\n      //format: 'case-sensitive',\n      enum: ['sig', 'enc'] // other values MAY be used\n    },\n\n    key_ops: {\n      type: 'array',\n      //format: 'case-sensitive',\n      items: {\n        enum: ['sign', 'verify', 'encrypt', 'decrypt', 'wrapKey', 'unwrapKey', 'deriveKey', 'deriveBits'] // other values MAY be used\n      }\n    },\n\n    alg: {\n      type: 'string',\n      //format: 'case-sensitive',\n      enum: ['HS256', 'HS384', 'HS512', 'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'PS256', 'PS384', 'PS512', 'none'] // other values MAY be used\n    },\n\n    kid: {\n      type: 'string'\n    },\n\n    x5u: {\n      type: 'string'\n      //format: 'url'\n    },\n\n    x5c: {\n      type: 'array'\n      //format: BASE64_REGEXP\n    },\n\n    x5t: {\n      type: 'string'\n      //format: BASE64_REGEXP\n    }\n\n    //'x5t#S256': {\n    //  type: 'string',\n    //  //format: BASE64_REGEXP\n    //}\n  }\n});\n\n/**\n * Export\n */\nmodule.exports = JWKSchema;","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\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) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","'use strict';\n\n/**\n * Mode enumeration\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar THROW = 0;\nvar RECOVER = 1;\nvar SILENT = 2;\n\n/**\n * JSONPointer\n *\n * @class\n * Implements RFC 6901: JavaScript Object Notation (JSON) Pointer\n * https://tools.ietf.org/html/rfc6901\n */\n\nvar JSONPointer = function () {\n\n  /**\n   * Constructor\n   */\n  function JSONPointer(expr, mode) {\n    _classCallCheck(this, JSONPointer);\n\n    this.expr = expr;\n    this.mode = mode || THROW;\n    this.tokens = expr && expr.charAt(0) === '#' ? this.parseURIFragmentIdentifier(expr) : this.parseJSONString(expr);\n  }\n\n  /**\n   * Escape\n   */\n\n\n  _createClass(JSONPointer, [{\n    key: 'escape',\n    value: function escape(expr) {\n      return expr.replace(/~/g, '~0').replace(/\\//g, '~1');\n    }\n\n    /**\n     * Unescape\n     */\n\n  }, {\n    key: 'unescape',\n    value: function unescape(expr) {\n      return expr.replace(/~1/g, '/').replace(/~0/g, '~');\n    }\n\n    /**\n     * Parse\n     */\n\n  }, {\n    key: 'parseJSONString',\n\n\n    /**\n     * Parse JSON String\n     *\n     * @description Parse an expression into a list of tokens\n     * @param {string} expr\n     * @returns {Array}\n     */\n    value: function parseJSONString(expr) {\n      if (typeof expr !== 'string') {\n        throw new Error('JSON Pointer must be a string');\n      }\n\n      if (expr === '') {\n        return [];\n      }\n\n      if (expr.charAt(0) !== '/') {\n        throw new Error('Invalid JSON Pointer');\n      }\n\n      if (expr === '/') {\n        return [''];\n      }\n\n      return expr.substr(1).split('/').map(this.unescape);\n    }\n\n    /**\n     * To JSON String\n     *\n     * @description Render a JSON string representation of a pointer\n     * @returns {string}\n     */\n\n  }, {\n    key: 'toJSONString',\n    value: function toJSONString() {\n      return '/' + this.tokens.map(this.escape).join('/');\n    }\n\n    /**\n     * Parse URI Fragment Identifer\n     */\n\n  }, {\n    key: 'parseURIFragmentIdentifier',\n    value: function parseURIFragmentIdentifier(expr) {\n      if (typeof expr !== 'string') {\n        throw new Error('JSON Pointer must be a string');\n      }\n\n      if (expr.charAt(0) !== '#') {\n        throw new Error('Invalid JSON Pointer URI Fragment Identifier');\n      }\n\n      return this.parseJSONString(decodeURIComponent(expr.substr(1)));\n    }\n\n    /**\n     * To URI Fragment Identifier\n     *\n     * @description Render a URI Fragment Identifier representation of a pointer\n     * @returns {string}\n     */\n\n  }, {\n    key: 'toURIFragmentIdentifier',\n    value: function toURIFragmentIdentifier() {\n      var _this = this;\n\n      var value = this.tokens.map(function (token) {\n        return encodeURIComponent(_this.escape(token));\n      }).join('/');\n\n      return '#/' + value;\n    }\n\n    /**\n     * Get\n     *\n     * @description Get a value from the source object referenced by the pointer\n     * @param {Object} source\n     * @returns {*}\n     */\n\n  }, {\n    key: 'get',\n    value: function get(source) {\n      var current = source;\n      var tokens = this.tokens;\n\n      for (var i = 0; i < tokens.length; i++) {\n        if (!current || current[tokens[i]] === undefined) {\n          if (this.mode !== THROW) {\n            return undefined;\n          } else {\n            throw new Error('Invalid JSON Pointer reference');\n          }\n        }\n\n        current = current[tokens[i]];\n      }\n\n      return current;\n    }\n\n    /**\n     * Add\n     *\n     * @description Set a value on a target object referenced by the pointer. Put\n     * will insert an array element. To change an existing array elemnent, use\n     * `pointer.set()`\n     * @param {Object} target\n     * @param {*} value\n     */\n\n  }, {\n    key: 'add',\n    value: function add(target, value) {\n      var tokens = this.tokens;\n      var current = target;\n\n      // iterate through the tokens\n      for (var i = 0; i < tokens.length; i++) {\n        var token = tokens[i];\n\n        // set the property on the target location\n        if (i === tokens.length - 1) {\n          if (token === '-') {\n            current.push(value);\n          } else if (Array.isArray(current)) {\n            current.splice(token, 0, value);\n          } else if (value !== undefined) {\n            current[token] = value;\n          }\n\n          // handle missing target location based on \"mode\"\n        } else if (!current[token]) {\n          switch (this.mode) {\n            case THROW:\n              throw new Error('Invalid JSON Pointer reference');\n\n            case RECOVER:\n              current = current[token] = parseInt(token) ? [] : {};\n              break;\n\n            case SILENT:\n              return;\n\n            default:\n              throw new Error('Invalid pointer mode');\n          }\n\n          // reference the next object in the path\n        } else {\n          current = current[token];\n        }\n      }\n    }\n\n    /**\n     * Replace\n     *\n     * @description Set a value on a target object referenced by the pointer. Set will\n     * overwrite an existing array element at the target location.\n     * @param {Object} target\n     * @param {*} value\n     */\n\n  }, {\n    key: 'replace',\n    value: function replace(target, value) {\n      var tokens = this.tokens;\n      var current = target;\n\n      for (var i = 0; i < tokens.length; i++) {\n        var token = tokens[i];\n\n        if (i === tokens.length - 1) {\n          current[token] = value;\n        } else if (!current[token]) {\n          current = current[token] = parseInt(token) ? [] : {};\n        } else {\n          current = current[token];\n        }\n      }\n    }\n\n    /**\n     * Del\n     *\n     * - if this is an array it should splice the value out\n     */\n\n  }, {\n    key: 'remove',\n    value: function remove(target) {\n      var tokens = this.tokens;\n      var current = target;\n\n      for (var i = 0; i < tokens.length; i++) {\n        var token = tokens[i];\n\n        if (current === undefined || current[token] === undefined) {\n          return undefined;\n        } else if (Array.isArray(current)) {\n          current.splice(token, 1);\n          return undefined;\n        } else if (i === tokens.length - 1) {\n          delete current[token];\n        }\n\n        current = current[token];\n      }\n\n      // delete from the target\n    }\n  }], [{\n    key: 'parse',\n    value: function parse(expr) {\n      return new JSONPointer(expr);\n    }\n  }]);\n\n  return JSONPointer;\n}();\n\n/**\n * Exports\n */\n\n\nmodule.exports = JSONPointer;","'use strict';\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Dependencies\n *\n * TODO\n * - switch between Node.js webcrypto package and browser implementation\n */\nvar base64url = require('base64url');\nvar supportedAlgorithms = require('../algorithms');\n\nvar _require = require('../errors'),\n    NotSupportedError = _require.NotSupportedError;\n\n/**\n * JWA\n * https://tools.ietf.org/html/rfc7518\n */\n\n\nvar JWA = function () {\n  function JWA() {\n    _classCallCheck(this, JWA);\n  }\n\n  _createClass(JWA, null, [{\n    key: 'sign',\n\n\n    /**\n     * Sign\n     *\n     * @description\n     * Create a digital signature.\n     *\n     * @param {string} alg\n     * @param {CryptoKey} key\n     * @param {string|Buffer} data\n     *\n     * @return {Promise}\n     */\n    value: function sign(alg, key, data) {\n      // normalize the algorithm\n      var normalizedAlgorithm = supportedAlgorithms.normalize('sign', alg);\n\n      // validate algorithm is supported\n      if (normalizedAlgorithm instanceof Error) {\n        return Promise.reject(new NotSupportedError(alg));\n      }\n\n      // validate type of key\n      // TODO\n      //  - is the key suitable for the algorithm?\n      //  - does that get validated in webcrypto?\n      //if (key instanceof CryptoKey) {\n      //  return Promise.reject(new InvalidKeyError())\n      //}\n\n      // sign the data\n      return normalizedAlgorithm.sign(key, data);\n    }\n\n    /**\n     * Verify\n     *\n     * @description\n     * Verify a digital signature.\n     *\n     * @param {string} alg\n     * @param {CryptoKey} privateKey\n     * @param {string|Buffer} signature\n     * @param {string|Buffer} data\n     *\n     * @return {Promise}\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify(alg, key, signature, data) {\n      var normalizedAlgorithm = supportedAlgorithms.normalize('verify', alg);\n\n      if (normalizedAlgorithm instanceof Error) {\n        return Promise.reject(new NotSupportedError(alg));\n      }\n\n      // TODO\n      // validate publicKey\n\n      // verify the signature\n      return normalizedAlgorithm.verify(key, signature, data);\n    }\n\n    /**\n     * Encrypt\n     */\n\n    /**\n     * Decrypt\n     */\n\n    /**\n     * Import\n     */\n\n  }, {\n    key: 'importKey',\n    value: function importKey(key) {\n      var normalizedAlgorithm = supportedAlgorithms.normalize('importKey', key.alg);\n      return normalizedAlgorithm.importKey(key);\n    }\n  }]);\n\n  return JWA;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = JWA;","/**\n * Dependencies\n */\n\n/**\n * FormUrlEncoded\n */\nclass FormUrlEncoded {\n\n  /**\n   * Encode\n   *\n   * @description\n   * Represent an object as x-www-form-urlencoded string.\n   *\n   * @param {Object} data\n   * @returns {string}\n   */\n  static encode (data) {\n     let pairs = []\n\n     Object.keys(data).forEach(function (key) {\n       pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key]))\n     })\n\n     return pairs.join('&')\n  }\n\n  /**\n   * Decode\n   *\n   * @description\n   * Parse a x-www-form-urlencoded into an object.\n   *\n   * @param {string} data\n   * @returns {Object}\n   */\n  static decode (data) {\n    let obj = {}\n\n    data.split('&').forEach(function (property) {\n      let pair = property.split('=')\n      let key = decodeURIComponent(pair[0])\n      let val = decodeURIComponent(pair[1])\n\n      obj[key] = val\n    })\n\n    return obj\n  }\n}\n\n/**\n * Export\n */\nmodule.exports = FormUrlEncoded\n","'use strict'\n\n/**\n * Throws an error when a fetch response status code indicates a 400 or 500\n * HTTP error. (The whatwg fetch api does not normally reject on http error\n * responses).\n *\n * Usage:\n *\n * ```\n * return fetch(url)\n *   .then(onHttpError('Error while fetching resource')\n *   .catch(err => console.log(err))\n *\n * // -> 'Error while fetching resource: 404 Not Found' error\n * // if a 404 response is encountered\n * ```\n *\n * @param [message] {string} Optional error message to clarify context\n *\n * @throws {Error} For http status codes > 300\n *\n * @return {Object} fetch response object (passed through if no error)\n */\nfunction onHttpError (message = 'fetch error') {\n  return (response) => {\n    if (response.status >= 200 && response.status < 300) {\n      return response\n    }\n\n    let errorMessage = `${message}: ${response.status} ${response.statusText}`\n    let error = new Error(errorMessage)\n    error.response = response\n    error.statusCode = response.status\n    throw error\n  }\n}\n\nmodule.exports = onHttpError\n","'use strict'\n\nmodule.exports = require('./RelyingParty')\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.unquote = exports.quote = exports.isScheme = exports.isToken = void 0;\nvar token = /^[^\\u0000-\\u001F\\u007F()<>@,;:\\\\\"/?={}\\[\\]\\u0020\\u0009]+$/;\n\nvar isToken = function isToken(str) {\n  return typeof str === 'string' && token.test(str);\n};\n\nexports.isToken = isToken;\nvar isScheme = isToken;\nexports.isScheme = isScheme;\n\nvar quote = function quote(str) {\n  return `\"${str.replace(/\"/g, '\\\\\"')}\"`;\n};\n\nexports.quote = quote;\n\nvar unquote = function unquote(str) {\n  return str.substr(1, str.length - 2).replace(/\\\\\"/g, '\"');\n};\n\nexports.unquote = unquote;\n//# sourceMappingURL=util.js.map","/**\n * Dependencies\n */\nconst assert = require('assert')\nconst fetch = require('node-fetch')\nconst { URL } = require('whatwg-url')\nconst Headers = fetch.Headers ? fetch.Headers : global.Headers\nconst {JSONDocument} = require('@trust/json-document')\nconst {JWKSet} = require('@solid/jose')\nconst AuthenticationRequest = require('./AuthenticationRequest')\nconst AuthenticationResponse = require('./AuthenticationResponse')\nconst RelyingPartySchema = require('./RelyingPartySchema')\nconst onHttpError = require('./onHttpError')\nconst FormUrlEncoded = require('./FormUrlEncoded')\n\n/**\n * RelyingParty\n *\n * @class\n * Client interface for OpenID Connect Relying Party.\n *\n * @example\n *  let client = RelyingParty({\n *    provider: {\n *      name: 'Anvil Research, Inc.',\n *      url: 'https://forge.anvil.io'\n *      // configuration\n *      // jwks\n *    },\n *    defaults: {\n *      popToken: false,\n *      authenticate: {\n *        response_type: 'code',\n *        display: 'popup',\n *        scope: 'openid profile email'\n *      },\n *      register: {\n *        client_name: 'Example',\n *        client_uri: 'https://example.com',\n *        logo_uri: 'https://example.com/assets/logo.png',\n *        redirect_uris: ['https://app.example.com/callback'],\n *        response_types: ['code', 'code id_token token'],\n *        grant_types: ['authorization_code'],\n *        default_max_age: 7200,\n *        post_logout_redirect_uris: ['https://app.example.com']\n *      },\n *    },\n *    registration: {\n *      // if you have it saved somewhere\n *    },\n *    store: localStorage || req.session\n *  })\n *\n *  client.discover() => Promise\n *  client.jwks() => Promise\n *  client.authenticate()\n *  client.authenticateUri()\n *  client.validateResponse(uri) => Promise\n *  client.userinfo() => Promise\n *  client.logout()\n */\nclass RelyingParty extends JSONDocument {\n\n  /**\n   * Schema\n   */\n  static get schema () {\n    return RelyingPartySchema\n  }\n\n  /**\n   * from\n   *\n   * @description\n   * Create a RelyingParty instance from a previously registered client.\n   *\n   * @param {Object} data\n   * @returns {Promise<RelyingParty>}\n   */\n  static from (data) {\n    let rp = new RelyingParty(data)\n    let validation = rp.validate()\n\n    // schema validation\n    if (!validation.valid) {\n      return Promise.reject(new Error(JSON.stringify(validation)))\n    }\n\n    let jwks = rp.provider.jwks\n\n    // request the JWK Set if missing\n    if (!jwks) {\n      return rp.jwks().then(() => rp)\n    }\n\n    // otherwise import the JWK Set to webcrypto\n    return JWKSet.importKeys(jwks).then(jwks => {\n      rp.provider.jwks = jwks\n      return rp\n    })\n  }\n\n  /**\n   * register\n   *\n   * @param issuer {string} Provider URL\n   * @param registration {Object} Client dynamic registration options\n   * @param options {Object}\n   * @param options.defaults\n   * @param [options.store] {Session|Storage}\n   * @returns {Promise<RelyingParty>} RelyingParty instance, registered.\n   */\n  static register (issuer, registration, options) {\n    let rp = new RelyingParty({\n      provider: { url: issuer },\n      defaults: Object.assign({}, options.defaults),\n      store: options.store\n    })\n\n    return Promise.resolve()\n      .then(() => rp.discover())\n      .then(() => rp.jwks())\n      .then(() => rp.register(registration))\n      .then(() => rp)\n  }\n\n  /**\n   * Discover\n   *\n   * @description Fetches the issuer's OpenID Configuration.\n   * @returns {Promise<Object>} Resolves with the provider configuration response\n   */\n  discover () {\n    try {\n      let issuer = this.provider.url\n\n      assert(issuer, 'RelyingParty provider must define \"url\"')\n\n      let url = new URL(issuer)\n      url.pathname = '.well-known/openid-configuration'\n\n      return fetch(url.toString())\n        .then(onHttpError('Error fetching openid configuration'))\n        .then(response => {\n          return response.json().then(json => this.provider.configuration = json)\n        })\n\n    } catch (error) {\n      return Promise.reject(error)\n    }\n  }\n\n  /**\n   * Register\n   *\n   * @description Register's a client with provider as a Relying Party\n   *\n   * @param options {Object}\n   * @returns {Promise<Object>} Resolves with the registration response object\n   */\n  register (options) {\n    try {\n      let configuration = this.provider.configuration\n\n      assert(configuration, 'OpenID Configuration is not initialized.')\n      assert(configuration.registration_endpoint, 'OpenID Configuration is missing registration_endpoint.')\n\n      let uri = configuration.registration_endpoint\n      let method = 'post'\n      let headers = new Headers({ 'Content-Type': 'application/json' })\n      let params = this.defaults.register\n      let body = JSON.stringify(Object.assign({}, params, options))\n\n      return fetch(uri, {method, headers, body})\n        .then(onHttpError('Error registering client'))\n        .then(response => {\n          return response.json().then(json => this.registration = json)\n        })\n\n    } catch (error) {\n      return Promise.reject(error)\n    }\n  }\n\n  serialize () {\n    return JSON.stringify(this)\n  }\n\n  /**\n   * jwks\n   *\n   * @description Promises the issuer's JWK Set.\n   * @returns {Promise}\n   */\n  jwks () {\n    try {\n      let configuration = this.provider.configuration\n\n      assert(configuration, 'OpenID Configuration is not initialized.')\n      assert(configuration.jwks_uri, 'OpenID Configuration is missing jwks_uri.')\n\n      let uri = configuration.jwks_uri\n\n      return fetch(uri)\n        .then(onHttpError('Error resolving provider keys'))\n        .then(response => {\n          return response\n            .json()\n            .then(json => JWKSet.importKeys(json))\n            .then(jwks => this.provider.jwks = jwks)\n        })\n\n    } catch (error) {\n      return Promise.reject(error)\n    }\n  }\n\n  /**\n   * createRequest\n   *\n   * @param options {Object} Authn request options hashmap\n   * @param options.redirect_uri {string}\n   * @param options.response_type {string} e.g. 'code' or 'id_token token'\n   * @param session {Session|Storage} req.session or localStorage\n   * @returns {Promise<string>} Authn request URL\n   */\n  createRequest (options, session) {\n    return AuthenticationRequest.create(this, options, session || this.store)\n  }\n\n  /**\n   * Validate Response\n   *\n   * @param response {string} req.query or req.body.text\n   * @param session {Session|Storage} req.session or localStorage or similar\n   *\n   * @returns {Promise<Session>}\n   */\n  validateResponse (response, session = this.store) {\n    let options\n\n    if (response.match(/^http(s?):\\/\\//)) {\n      options = { rp: this, redirect: response, session }\n    } else {\n      options = { rp: this, body: response, session }\n    }\n\n    const authResponse = new AuthenticationResponse(options)\n\n    return AuthenticationResponse.validateResponse(authResponse)\n  }\n\n  /**\n   * userinfo\n   *\n   * @description Promises the authenticated user's claims.\n   * @returns {Promise}\n   */\n  userinfo () {\n    try {\n      let configuration = this.provider.configuration\n\n      assert(configuration, 'OpenID Configuration is not initialized.')\n      assert(configuration.userinfo_endpoint, 'OpenID Configuration is missing userinfo_endpoint.')\n\n      let uri = configuration.userinfo_endpoint\n      let access_token = this.store.access_token\n\n      assert(access_token, 'Missing access token.')\n\n      let headers = new Headers({\n        'Content-Type': 'application/json',\n        'Authorization': `Bearer ${access_token}`\n      })\n\n      return fetch(uri, {headers})\n        .then(onHttpError('Error fetching userinfo'))\n        .then(response => response.json())\n\n    } catch (error) {\n      return Promise.reject(error)\n    }\n  }\n\n  /**\n   * logoutRequest\n   *\n   * Composes and returns the logout request URI, based on the OP's\n   * `end_session_endpoint`, with appropriate parameters.\n   *\n   * Note: Calling client code has the responsibility to clear the local\n   * session state (for example, by calling `rp.clearSession()`). In addition,\n   * some IdPs (such as Google) may not provide an `end_session_endpoint`,\n   * in which case, this method will return null.\n   *\n   * @see https://openid.net/specs/openid-connect-session-1_0.html#RPLogout\n   *\n   * @throws {Error} If provider config is not initialized\n   *\n   * @throws {Error} If `post_logout_redirect_uri` was provided without a\n   *   corresponding `id_token_hint`\n   *\n   * @param [options={}] {object}\n   *\n   * @param [options.id_token_hint] {string} RECOMMENDED.\n   *   Previously issued ID Token passed to the logout endpoint as\n   *   a hint about the End-User's current authenticated session with the\n   *   Client. This is used as an indication of the identity of the End-User\n   *   that the RP is requesting be logged out by the OP. The OP *need not* be\n   *   listed as an audience of the ID Token when it is used as an\n   *   `id_token_hint` value.\n   *\n   * @param [options.post_logout_redirect_uri] {string} OPTIONAL. URL to which\n   *   the RP is requesting that the End-User's User Agent be redirected after\n   *   a logout has been performed. The value MUST have been previously\n   *   registered with the OP, either using the `post_logout_redirect_uris`\n   *   Registration parameter or via another mechanism. If supplied, the OP\n   *   SHOULD honor this request following the logout.\n   *\n   *   Note: The requirement to validate the uri for previous registration means\n   *   that, in practice, the `id_token_hint` is REQUIRED if\n   *   `post_logout_redirect_uri` is used. Otherwise, the OP has no way to get\n   *   the `client_id` to load the saved client registration, to validate the\n   *   uri. The only way it can get it is by decoding the `id_token_hint`.\n   *\n   * @param [options.state] {string} OPTIONAL. Opaque value used by the RP to\n   *   maintain state between the logout request and the callback to the\n   *   endpoint specified by the `post_logout_redirect_uri` query parameter. If\n   *   included in the logout request, the OP passes this value back to the RP\n   *   using the `state` query parameter when redirecting the User Agent back to\n   *   the RP.\n   *\n   * TODO: In the future, consider adding `response_mode` param, for the OP to\n   *   determine how to return the `state` back the RP.\n   *   @see http://openid.net/specs/oauth-v2-multiple-response-types-1_0.html#ResponseModes\n   *\n   * TODO: Handle special cases for popular providers (Google, MSFT)\n   *\n   * @returns {string|null} Logout uri (or null if no end_session_endpoint was\n   *   provided in the IdP config)\n   */\n  logoutRequest (options = {}) {\n    const { id_token_hint, post_logout_redirect_uri, state } = options\n    let configuration\n\n    assert(this.provider, 'OpenID Configuration is not initialized')\n    configuration = this.provider.configuration\n    assert(configuration, 'OpenID Configuration is not initialized')\n\n    if (!configuration.end_session_endpoint) {\n      console.log(`OpenId Configuration for ` +\n        `${configuration.issuer} is missing end_session_endpoint`)\n      return null\n    }\n\n    if (post_logout_redirect_uri && !id_token_hint) {\n      throw new Error('id_token_hint is required when using post_logout_redirect_uri')\n    }\n\n    const params = {}\n\n    if (id_token_hint) {\n      params.id_token_hint = id_token_hint\n    }\n    if (post_logout_redirect_uri) {\n      params.post_logout_redirect_uri = post_logout_redirect_uri\n    }\n    if (state) {\n      params.state = state\n    }\n\n    const url = new URL(configuration.end_session_endpoint)\n    url.search = FormUrlEncoded.encode(params)\n\n    return url.href\n  }\n\n  /**\n   * Logout\n   *\n   * @deprecated\n   *\n   * TODO: Add deprecation warnings, then remove. Client code should\n   *   use `logoutRequest()` instead\n   *\n   * @returns {Promise}\n   */\n  logout () {\n    let configuration\n    try {\n      assert(this.provider, 'OpenID Configuration is not initialized.')\n      configuration = this.provider.configuration\n      assert(configuration, 'OpenID Configuration is not initialized.')\n      assert(configuration.end_session_endpoint,\n        'OpenID Configuration is missing end_session_endpoint.')\n    } catch (error) {\n      return Promise.reject(error)\n    }\n\n    if (!configuration.end_session_endpoint) {\n      this.clearSession()\n      return Promise.resolve(undefined)\n    }\n\n    let uri = configuration.end_session_endpoint\n    let method = 'get'\n\n    return fetch(uri, {method, credentials: 'include'})\n      .then(onHttpError('Error logging out'))\n      .then(() => this.clearSession())\n\n    // TODO: Validate `frontchannel_logout_uri` if necessary\n    /**\n     * frontchannel_logout_uri - OPTIONAL. RP URL that will cause the RP to log\n     * itself out when rendered in an iframe by the OP.\n     *\n     * An `iss` (issuer) query parameter and a `sid`\n     * (session ID) query parameter MAY be included by the OP to enable the RP\n     * to validate the request and to determine which of the potentially\n     * multiple sessions is to be logged out. If a sid (session ID) query\n     * parameter is included, an iss (issuer) query parameter MUST also be\n     * included.\n     * @see https://openid.net/specs/openid-connect-frontchannel-1_0.html#RPLogout\n     */\n  }\n\n  clearSession () {\n    let session = this.store\n\n    if (!session) { return }\n\n    delete session[SESSION_PRIVATE_KEY]\n  }\n\n  /**\n   * @param uri {string} Target Resource Server URI\n   * @param idToken {IDToken} ID Token to be embedded in the PoP token\n   *\n   * @returns {Promise<PoPToken>}\n   */\n  popTokenFor (uri, idToken) {\n    return PoPToken.issueFor(uri, idToken)\n  }\n}\n\nconst SESSION_PRIVATE_KEY = 'oidc.session.privateKey'\n\nRelyingParty.SESSION_PRIVATE_KEY = SESSION_PRIVATE_KEY\n\nmodule.exports = RelyingParty\n","'use strict';\n\n/**\n * JSON Schema Formats\n *\n * TODO\n * Is there a good way to express these over multiple lines with comments\n * for easier debugging and auditing?\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar DATETIME_REGEXP = /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s][0-2]\\d:[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:z|[+-]\\d\\d:\\d\\d)$/i;\nvar URI_REGEXP = /^(?:[a-z][a-z0-9+-.]*)?(?:\\:|\\/)\\/?[^\\s]*$/i;\nvar EMAIL_REGEXP = /^[a-z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;\nvar IPV4_REGEXP = /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/;\nvar IPV6_REGEXP = /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i;\nvar HOSTNAME_REGEXP = /^[a-z](?:(?:[-0-9a-z]{0,61})?[0-9a-z])?(\\.[a-z](?:(?:[-0-9a-z]{0,61})?[0-9a-z])?)*$/i;\n\n/**\n * Formats\n */\n\nvar Formats = function () {\n  function Formats() {\n    _classCallCheck(this, Formats);\n  }\n\n  _createClass(Formats, [{\n    key: 'register',\n\n\n    /**\n     * Register\n     *\n     * @description\n     * Register a new mapping from named format to RegExp instance\n     *\n     * TODO\n     * We can do some extra validation of the RegExp to\n     * ensure it's the acceptable subset of RegExps allowed\n     * by JSON Schema.\n     *\n     * @param {string} name\n     * @param {RegExp} pattern\n     * @returns {RegExp}\n     */\n    value: function register(name, pattern) {\n      // verify name is a string\n      if (typeof name !== 'string') {\n        throw new Error('Format name must be a string');\n      }\n\n      // cast a string to RegExp\n      if (typeof pattern === 'string') {\n        pattern = new RegExp(pattern);\n      }\n\n      return this[name] = pattern;\n    }\n\n    /**\n     * Resolve\n     *\n     * @description\n     * Given a format name, return the corresponding registered validation. In the\n     * event a format is not registered, throw an error.\n     *\n     * @param {string} name\n     * @returns {RegExp}\n     */\n\n  }, {\n    key: 'resolve',\n    value: function resolve(name) {\n      var format = this[name];\n\n      if (!format) {\n        throw new Error('Unknown JSON Schema format.');\n      }\n\n      return format;\n    }\n\n    /**\n     * Test\n     *\n     * @description\n     * Test that a value conforms to a format.\n     *\n     * @param {string} name\n     * @param {string} value\n     * @returns {Boolean}\n     */\n\n  }, {\n    key: 'test',\n    value: function test(name, value) {\n      var format = this.resolve(name);\n      return format.test(value);\n    }\n  }], [{\n    key: 'initialize',\n\n\n    /**\n     * Initialize\n     *\n     * @description\n     * Create a new Formats instance and register default formats\n     *\n     * @returns {Formats}\n     */\n    value: function initialize() {\n      var formats = new Formats();\n      formats.register('date-time', DATETIME_REGEXP);\n      formats.register('uri', URI_REGEXP);\n      formats.register('email', EMAIL_REGEXP);\n      formats.register('ipv4', IPV4_REGEXP);\n      formats.register('ipv6', IPV6_REGEXP);\n      formats.register('hostname', HOSTNAME_REGEXP);\n      return formats;\n    }\n  }]);\n\n  return Formats;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = Formats.initialize();","'use strict';\n\n/**\n * Initializer\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Initializer = function () {\n\n  /**\n   * constructor\n   */\n  function Initializer(schema, options) {\n    _classCallCheck(this, Initializer);\n\n    Object.assign(this, options || {});\n    this.root = this.root || this;\n\n    this.root.depth = this.root.depth || 1;\n\n    if (this.level > this.root.depth) {\n      this.root.depth = this.level;\n    }\n\n    this.level = this.level || 0;\n    this.schema = schema;\n  }\n\n  /**\n   * compile (static)\n   */\n\n\n  _createClass(Initializer, [{\n    key: 'compile',\n\n\n    /**\n     * compile\n     */\n    value: function compile() {\n      var root = this.root,\n          depth = this.depth,\n          level = this.level;\n\n      var declarations = '';\n      var body = '';\n\n      // traverse the schema and generate code\n      body += this.default();\n      body += this.properties();\n      //body += this.additionalProperties()\n      body += this.items();\n      //body += this.additionalItems()\n\n\n      // value\n      body += this.member();\n      body += this.item();\n\n      // after traversing the schema\n      // generate the variable declarations\n      if (root === this) {\n        for (var i = 1; i <= this.root.depth; i++) {\n          declarations += this.declaration(i);\n        }\n\n        return '\\n        options = options || {}\\n\\n        if (options.filter === false) {\\n          Object.assign(target, JSON.parse(JSON.stringify(source)))\\n        }\\n\\n        ' + declarations + '\\n        ' + body + '\\n      ';\n      }\n\n      return body;\n    }\n\n    /**\n     * declaration\n     */\n\n  }, {\n    key: 'declaration',\n    value: function declaration(level) {\n      return '\\n      var target' + level + '\\n      var source' + level + '\\n      var count' + level + '\\n    ';\n    }\n\n    /**\n     * default\n     */\n\n  }, {\n    key: 'default',\n    value: function _default() {\n      var schema = this.schema,\n          level = this.level,\n          key = this.key,\n          index = this.index;\n      var value = schema.default; // rename default to value because it's a keyword and syntax highlighter breaks\n\n      var block = '';\n\n      if (schema.hasOwnProperty('default')) {\n\n        if (key) {\n          block += '\\n          target' + level + '[\\'' + key + '\\'] = ' + JSON.stringify(value) + '\\n        ';\n        }\n\n        if (index) {\n          block += '\\n          target' + level + '[' + index + '] = ' + JSON.stringify(value) + '\\n        ';\n        }\n\n        if (level > 1) {\n          block += '\\n          count' + level + '++\\n        ';\n        }\n\n        block = '\\n        if (options.defaults !== false) {\\n          ' + block + '\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * member\n     */\n\n  }, {\n    key: 'member',\n    value: function member() {\n      var schema = this.schema,\n          root = this.root,\n          level = this.level,\n          key = this.key;\n      var properties = schema.properties,\n          additionalProperties = schema.additionalProperties,\n          items = schema.items,\n          additionalItems = schema.additionalItems;\n\n      var block = '';\n\n      // `key` tells us to treat this subschema as an object member vs an array item\n      // and the absence of the other values here indicates we are dealing with a\n      // primitive value\n      if (key && !properties && !additionalProperties && !items && !additionalItems) {\n\n        // first generate the assignment statement\n        block += '\\n        target' + level + '[\\'' + key + '\\'] = source' + level + '[\\'' + key + '\\']\\n      ';\n\n        // for nested container objects, add the counter incrementing statement\n        if (level > 1) {\n          block += '\\n          count' + level + '++\\n        ';\n        }\n\n        // wrap the foregoing in a check for presence on the source\n        block = '\\n        if (source' + level + '.hasOwnProperty(\\'' + key + '\\')) {\\n          ' + block + '\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * item\n     */\n\n  }, {\n    key: 'item',\n    value: function item() {\n      var schema = this.schema,\n          root = this.root,\n          level = this.level,\n          index = this.index;\n      var properties = schema.properties,\n          additionalProperties = schema.additionalProperties,\n          items = schema.items,\n          additionalItems = schema.additionalItems;\n\n      var block = '';\n\n      if (index && !properties && !additionalProperties && !items && !additionalItems) {\n\n        block += '\\n        target' + level + '[' + index + '] = source' + level + '[' + index + ']\\n      ';\n\n        if (level > 1) {\n          block += '\\n          count' + level + '++\\n        ';\n        }\n\n        block = '\\n        if (' + index + ' < len) {\\n          ' + block + '\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * properties\n     */\n\n  }, {\n    key: 'properties',\n    value: function properties() {\n      var schema = this.schema,\n          root = this.root,\n          level = this.level,\n          key = this.key,\n          index = this.index;\n      var properties = schema.properties;\n\n      var block = '';\n\n      if (properties) {\n        Object.keys(properties).forEach(function (key) {\n          var subschema = properties[key];\n          var initializer = new Initializer(subschema, { key: key, root: root, level: level + 1 });\n\n          block += initializer.compile();\n        });\n\n        // root-level properties boilerplate\n        if (root === this) {\n          block = '\\n          if (typeof source === \\'object\\' && source !== null && !Array.isArray(source)) {\\n            if (typeof target !== \\'object\\') {\\n              throw new Error(\\'?\\')\\n            }\\n\\n            source1 = source\\n            target1 = target\\n            count1 = 0\\n\\n            ' + block + '\\n          }\\n        ';\n\n          // nested properties boilerplate\n        } else {\n\n          if (index) {\n            block = '\\n            if (' + index + ' < source' + level + '.length || typeof source' + level + '[' + index + '] === \\'object\\') {\\n\\n              source' + (level + 1) + ' = source' + level + '[' + index + '] || {}\\n              count' + (level + 1) + ' = 0\\n\\n              if (' + index + ' < target' + level + '.length || typeof target' + level + '[' + index + '] !== \\'object\\') {\\n                target' + (level + 1) + ' = {}\\n                if (' + index + ' < source' + level + '.length) {\\n                  count' + (level + 1) + '++\\n                }\\n              } else {\\n                target' + (level + 1) + ' = target' + level + '[' + index + ']\\n              }\\n\\n              ' + block + '\\n\\n              if (count' + (level + 1) + ' > 0) {\\n                target' + level + '[' + index + '] = target' + (level + 1) + '\\n                count' + level + '++\\n              }\\n\\n            } else {\\n              target' + level + '[' + index + '] = source' + level + '[' + index + ']\\n              count' + level + '++\\n            }\\n          ';\n          }\n\n          if (key) {\n            block = '\\n            if ((typeof source' + level + '[\\'' + key + '\\'] === \\'object\\'\\n                  && source' + level + '[\\'' + key + '\\'] !== null\\n                  && !Array.isArray(source' + level + '[\\'' + key + '\\']))\\n                || !source' + level + '.hasOwnProperty(\\'' + key + '\\')) {\\n\\n              source' + (level + 1) + ' = source' + level + '[\\'' + key + '\\'] || {}\\n              count' + (level + 1) + ' = 0\\n\\n              if (!target' + level + '.hasOwnProperty(\\'' + key + '\\')\\n                  || typeof target' + level + '[\\'' + key + '\\'] !== \\'object\\'\\n                  || target' + level + '[\\'' + key + '\\'] === null\\n                  || Array.isArray(target' + level + '[\\'' + key + '\\'])) {\\n                target' + (level + 1) + ' = {}\\n                if (source' + level + '.hasOwnProperty(\\'' + key + '\\')) {\\n                  count' + (level + 1) + '++\\n                }\\n              } else {\\n                target' + (level + 1) + ' = target' + level + '[\\'' + key + '\\']\\n                count' + (level + 1) + '++\\n              }\\n\\n              ' + block + '\\n\\n              if (count' + (level + 1) + ' > 0) {\\n                target' + level + '[\\'' + key + '\\'] = target' + (level + 1) + '\\n                count' + level + '++\\n              }\\n\\n            } else {\\n              target' + level + '[\\'' + key + '\\'] = source' + level + '[\\'' + key + '\\']\\n              count' + level + '++\\n            }\\n          ';\n          }\n        }\n      }\n\n      return block;\n    }\n\n    /**\n     *\n     */\n\n  }, {\n    key: 'additionalProperties',\n    value: function additionalProperties() {}\n\n    /**\n     * items\n     */\n\n  }, {\n    key: 'items',\n    value: function items() {\n      var schema = this.schema,\n          root = this.root,\n          level = this.level,\n          key = this.key,\n          index = this.index;\n      var items = schema.items;\n\n      var block = '';\n\n      if (items) {\n\n        if (Array.isArray(items)) {\n          // TODO\n          //\n          //\n          //\n          //\n          //\n          // ...\n\n        } else if ((typeof items === 'undefined' ? 'undefined' : _typeof(items)) === 'object' && items !== null) {\n          var _index = 'i' + (level + 1);\n          var initializer = new Initializer(items, { index: _index, root: root, level: level + 1 });\n\n          block += '\\n          var sLen = source' + (level + 1) + '.length || 0\\n          var tLen = target' + (level + 1) + '.length || 0\\n          var len = 0\\n\\n          if (sLen > len) { len = sLen }\\n          // THIS IS WRONG, CAUSED SIMPLE ARRAY INIT TO FAIL (OVERWRITE\\n          // EXISTING TARGET VALUES WITH UNDEFINED WHEN SOURCE IS SHORTER THAN\\n          // TARGET). LEAVING HERE UNTIL WE FINISH TESTING AND SEE WHY IT MIGHT\\n          // HAVE BEEN HERE IN THE FIRST PLACE.\\n          //\\n          // if (tLen > len) { len = tLen }\\n\\n          for (var ' + _index + ' = 0; ' + _index + ' < len; ' + _index + '++) {\\n            ' + initializer.compile() + '\\n          }\\n        ';\n        }\n\n        // root-level properties boilerplate\n        if (root === this) {\n          block = '\\n          if (Array.isArray(source)) {\\n            if (!Array.isArray(target)) {\\n              throw new Error(\\'?\\')\\n            }\\n\\n            source1 = source\\n            target1 = target\\n\\n            ' + block + '\\n          }\\n        ';\n\n          // nested properties boilerplate\n        } else {\n          block = '\\n          if (Array.isArray(source' + level + '[\\'' + key + '\\']) || !source' + level + '.hasOwnProperty(\\'' + key + '\\')) {\\n\\n            source' + (level + 1) + ' = source' + level + '[\\'' + key + '\\'] || []\\n            count' + (level + 1) + ' = 0\\n\\n            if (!target' + level + '.hasOwnProperty(\\'' + key + '\\') || !Array.isArray(target' + level + '[\\'' + key + '\\'])) {\\n              target' + (level + 1) + ' = []\\n                if (source' + level + '.hasOwnProperty(\\'' + key + '\\')) {\\n                  count' + (level + 1) + '++\\n                }\\n\\n            } else {\\n              target' + (level + 1) + ' = target' + level + '[\\'' + key + '\\']\\n              count' + (level + 1) + '++\\n            }\\n\\n            ' + block + '\\n\\n            if (count' + (level + 1) + ' > 0) {\\n              target' + level + '[\\'' + key + '\\'] = target' + (level + 1) + '\\n              count' + level + '++\\n            }\\n\\n          } else {\\n            target' + level + '[\\'' + key + '\\'] = source' + level + '[\\'' + key + '\\']\\n            count' + level + '++\\n          }\\n        ';\n        }\n      }\n\n      return block;\n    }\n\n    /**\n     *\n     */\n\n  }, {\n    key: 'additionalItems',\n    value: function additionalItems() {}\n  }], [{\n    key: 'compile',\n    value: function compile(schema) {\n      var initializer = new Initializer(schema);\n      var block = initializer.compile();\n\n      //console.log(beautify(block))\n      try {\n        return new Function('target', 'source', 'options', block);\n      } catch (e) {\n        console.log(e, e.stack);\n      }\n    }\n  }]);\n\n  return Initializer;\n}();\n\nmodule.exports = Initializer;","'use strict';\n\n/**\n * Module dependencies\n * @ignore\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar JSONPointer = require('./JSONPointer');\n\n/**\n * Modes\n */\nvar THROW = 0;\nvar RECOVER = 1;\nvar SILENT = 2;\n\n/**\n * Operations list\n */\nvar OPERATIONS = ['add', 'remove', 'replace', 'move', 'copy', 'test'];\n\n/**\n * Patch\n *\n * @class\n * Implements RFC 6902: JavaScript Object Notation (JSON) Patch\n * https://tools.ietf.org/html/rfc6902\n */\n\nvar JSONPatch = function () {\n\n  /**\n   * Constructor\n   *\n   * @param {Array} ops\n   */\n  function JSONPatch(ops) {\n    _classCallCheck(this, JSONPatch);\n\n    this.ops = ops || [];\n  }\n\n  /**\n   * Apply\n   *\n   * @todo handle errors/roll back\n   * @todo protect properties that are private in the schema\n   * @todo map JSON Pointers real property names\n   *\n   * @param {Object} target\n   */\n\n\n  _createClass(JSONPatch, [{\n    key: 'apply',\n    value: function apply(target) {\n      var _this = this;\n\n      this.ops.forEach(function (operation) {\n        var op = operation.op;\n\n        if (!op) {\n          throw new Error('Missing \"op\" in JSON Patch operation');\n        }\n\n        if (OPERATIONS.indexOf(op) === -1) {\n          throw new Error('Invalid \"op\" in JSON Patch operation');\n        }\n\n        if (!operation.path) {\n          throw new Error('Missing \"path\" in JSON Patch operation');\n        }\n\n        _this[op](operation, target);\n      });\n    }\n\n    /**\n     * Add\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'add',\n    value: function add(op, target) {\n      if (op.value === undefined) {\n        throw new Error('Missing \"value\" in JSON Patch add operation');\n      }\n\n      var pointer = new JSONPointer(op.path, SILENT);\n      pointer.add(target, op.value);\n    }\n\n    /**\n     * Remove\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'remove',\n    value: function remove(op, target) {\n      var pointer = new JSONPointer(op.path);\n      pointer.remove(target);\n    }\n\n    /**\n     * Replace\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'replace',\n    value: function replace(op, target) {\n      if (op.value === undefined) {\n        throw new Error('Missing \"value\" in JSON Patch replace operation');\n      }\n\n      var pointer = new JSONPointer(op.path);\n      pointer.replace(target, op.value);\n    }\n\n    /**\n     * Move\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'move',\n    value: function move(op, target) {\n      if (op.from === undefined) {\n        throw new Error('Missing \"from\" in JSON Patch move operation');\n      }\n\n      if (op.path.match(new RegExp('^' + op.from))) {\n        throw new Error('Invalid \"from\" in JSON Patch move operation');\n      }\n\n      var pointer = new JSONPointer(op.path);\n      var from = new JSONPointer(op.from);\n      var value = from.get(target);\n\n      from.remove(target);\n      pointer.add(target, value);\n    }\n\n    /**\n     * Copy\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'copy',\n    value: function copy(op, target) {\n      if (op.from === undefined) {\n        throw new Error('Missing \"from\" in JSON Patch copy operation');\n      }\n\n      var pointer = new JSONPointer(op.path);\n      var from = new JSONPointer(op.from);\n      var value = from.get(target);\n\n      pointer.add(target, value);\n    }\n\n    /**\n     * Test\n     *\n     * @param {Object} op\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'test',\n    value: function test(op, target) {\n      if (op.value === undefined) {\n        throw new Error('Missing \"value\" in JSON Patch test operation');\n      }\n\n      var pointer = new JSONPointer(op.path);\n      var value = pointer.get(target);\n\n      switch (_typeof(op.value)) {\n        //case 'string':\n        //case 'number':\n        //case 'boolean':\n        //  if (value !== op.value) {\n        //    throw new Error('Mismatching JSON Patch test value')\n        //  }\n        default:\n          if (value !== op.value) {\n            throw new Error('Mismatching JSON Patch test value');\n          }\n      }\n    }\n  }]);\n\n  return JSONPatch;\n}();\n\n/**\n * Exports\n */\n\n\nmodule.exports = JSONPatch;","'use strict';\n\n/**\n * Module dependencies\n * @ignore\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar formats = require('./Formats');\n\n/**\n * For variable iterator counter\n *\n * @type {number}\n */\nvar indexCount = 0;\n\n/**\n * Validator\n *\n * Compile an object describing a JSON Schema into a validation function.\n */\n\nvar Validator = function () {\n  _createClass(Validator, null, [{\n    key: 'compile',\n\n\n    /**\n     * Compile (static)\n     *\n     * @description\n     * Compile an object describing a JSON Schema into a validation function.\n     *\n     * @param {Object} schema\n     * @returns {Function}\n     */\n    value: function compile(schema) {\n      var validator = new Validator(schema);\n\n      var body = '\\n      // \"cursor\"\\n      let value = data\\n      let container\\n      let stack = []\\n      let top = -1\\n\\n      // error state\\n      let valid = true\\n      let errors = []\\n\\n      // complex schema state\\n      let initialValidity\\n      let anyValid\\n      let notValid\\n      let countOfValid\\n      let initialErrorCount\\n      let accumulatedErrorCount\\n\\n      // validation code\\n      ' + validator.compile() + '\\n\\n      // validation result\\n      return {\\n        valid,\\n        errors\\n      }\\n    ';\n\n      return new Function('data', body);\n    }\n\n    /**\n     * Return current iterator index counter and increase value\n     *\n     * @returns {number}\n     */\n\n  }, {\n    key: 'counter',\n    get: function get() {\n      return indexCount++;\n    }\n\n    /**\n     * Constructor\n     *\n     * @param {Object} schema - object representation of a schema\n     * @param {string} options - compilation options\n     */\n\n  }]);\n\n  function Validator(schema) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    _classCallCheck(this, Validator);\n\n    // assign schema to this\n    this.schema = schema;\n\n    // assign all options to this\n    Object.assign(this, options);\n\n    // ensure address is defined\n    if (!this.address) {\n      this.address = '';\n    }\n\n    // ensure require is boolean\n    if (this.require !== true) {\n      this.require = false;\n    }\n  }\n\n  /**\n   * Compile\n   *\n   * @description\n   * The instance compile method is \"dumb\". It only sequences invocation of\n   * more specific compilation methods. It generates code to\n   *\n   *  - read a value from input\n   *  - validate type(s) of input\n   *  - validate constraints described by various schema keywords\n   *\n   * Conditional logic related to code generation is pushed downsteam to\n   * type-specific methods.\n   */\n\n\n  _createClass(Validator, [{\n    key: 'compile',\n    value: function compile() {\n      var block = '';\n\n      if (this.require) {\n        block += this.required();\n      }\n\n      // type validation\n      block += this.type();\n\n      // type specific validation generators\n      // null and boolean are covered by this.type()\n      // integer should be covered by number and this.type()\n      block += this.array();\n      block += this.number();\n      block += this.object();\n      block += this.string();\n\n      // non-type-specific validation generators\n      block += this.enum();\n      block += this.anyOf();\n      block += this.allOf();\n      block += this.not();\n      block += this.oneOf();\n\n      return block;\n    }\n\n    /**\n     * push\n     */\n\n  }, {\n    key: 'push',\n    value: function push() {\n      return '\\n      stack.push(value)\\n      container = value\\n      top++\\n    ';\n    }\n\n    /**\n     * pop\n     */\n\n  }, {\n    key: 'pop',\n    value: function pop() {\n      return '\\n      if (stack.length > 1) {\\n        top--\\n        stack.pop()\\n      }\\n\\n      value = container = stack[top]\\n    ';\n    }\n\n    /**\n     * type\n     *\n     * @description\n     * > An instance matches successfully if its primitive type is one of the\n     * > types defined by keyword. Recall: \"number\" includes \"integer\".\n     * > JSON Schema Validation Section 5.5.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'type',\n    value: function type() {\n      var type = this.schema.type,\n          address = this.address;\n\n      var block = '';\n\n      if (type) {\n        var types = Array.isArray(type) ? type : [type];\n        var conditions = types.map(function (type) {\n          // TODO: can we make a mapping object for this to clean it up?\n          if (type === 'array') return '!Array.isArray(value)';\n          if (type === 'boolean') return 'typeof value !== \\'boolean\\'';\n          if (type === 'integer') return '!Number.isInteger(value)';\n          if (type === 'null') return 'value !== null';\n          if (type === 'number') return 'typeof value !== \\'number\\'';\n          if (type === 'object') return '(typeof value !== \\'object\\' || Array.isArray(value) || value === null)';\n          if (type === 'string') return 'typeof value !== \\'string\\'';\n        }).join(' && ');\n\n        block += '\\n      // ' + address + ' type checking\\n      if (value !== undefined && ' + conditions + ') {\\n        valid = false\\n        errors.push({\\n          keyword: \\'type\\',\\n          message: \\'invalid type\\'\\n        })\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * Type-specific validations\n     *\n     * Type checking is optional in JSON Schema, and a schema can allow\n     * multiple types. Generated code needs to apply type-specific validations\n     * only to appropriate values, and ignore everything else. Type validation\n     * itself is handled separately from other validation keywords.\n     *\n     * The methods `array`, `number`, `object`, `string` generate type-specific\n     * validation code blocks, wrapped in a conditional such that they will\n     * only be applied to values of that type.\n     *\n     * For example, the `number` method, given the schema\n     *\n     *     { minimum: 3 }\n     *\n     * will generate\n     *\n     *     if (typeof value === 'number') {\n     *       if (value < 3) {\n     *         valid = false\n     *         errors.push({ message: '...' })\n     *       }\n     *     }\n     *\n     * Integer values are also numbers, and are validated the same as numbers\n     * other than the type validation itself. Therefore no `integer` method is\n     * needed.\n     */\n\n    /**\n     * array\n     *\n     * @description\n     * Invoke methods for array-specific keywords and wrap resulting code in\n     * type-checking conditional so that any resulting validations are only\n     * applied to array values.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'array',\n    value: function array() {\n      var keywords = ['additionalItems', 'items', 'minItems', 'maxItems', 'uniqueItems'];\n      var validations = this.validations(keywords);\n      var block = '';\n\n      if (validations.length > 0) {\n        block += '\\n      /**\\n       * Array validations\\n       */\\n      if (Array.isArray(value)) {\\n      ' + validations + '\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * number\n     *\n     * @description\n     * Invoke methods for number-specific keywords and wrap resulting code in\n     * type-checking conditional so that any resulting validations are only\n     * applied to number values.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'number',\n    value: function number() {\n      var keywords = ['minimum', 'maximum', 'multipleOf'];\n      var validations = this.validations(keywords);\n      var block = '';\n\n      if (validations.length > 0) {\n        block += '\\n      /**\\n       * Number validations\\n       */\\n      if (typeof value === \\'number\\') {\\n      ' + validations + '\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * object\n     *\n     * @description\n     * Invoke methods for object-specific keywords and wrap resulting code in\n     * type-checking conditional so that any resulting validations are only\n     * applied to object values.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'object',\n    value: function object() {\n      var keywords = ['maxProperties', 'minProperties', 'additionalProperties', 'properties', 'patternProperties', 'dependencies', 'schemaDependencies', 'propertyDependencies'];\n      var validations = this.validations(keywords);\n      var block = '';\n\n      if (validations.length > 0) {\n        block += '\\n      /**\\n       * Object validations\\n       */\\n      if (typeof value === \\'object\\' && value !== null && !Array.isArray(value)) {\\n      ' + validations + '\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * string\n     *\n     * @description\n     * Invoke methods for string-specific keywords and wrap resulting code in\n     * type-checking conditional so that any resulting validations are only\n     * applied to string values.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'string',\n    value: function string() {\n      var keywords = ['maxLength', 'minLength', 'pattern', 'format'];\n      var validations = this.validations(keywords);\n      var block = '';\n\n      if (validations.length > 0) {\n        block += '\\n      /**\\n       * String validations\\n       */\\n      if (typeof value === \\'string\\') {\\n      ' + validations + '\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * validations\n     *\n     * @description\n     * Iterate over an array of keywords and invoke code generator methods\n     * for each. Concatenate the results together and return. Used by \"type\"\n     * methods such as this.array() and this.string()\n     *\n     * @param {Array} keywords\n     * @returns {string}\n     */\n\n  }, {\n    key: 'validations',\n    value: function validations(keywords) {\n      var _this = this;\n\n      var schema = this.schema;\n\n      var block = '';\n\n      var constraints = Object.keys(schema).filter(function (key) {\n        return keywords.indexOf(key) !== -1;\n      });\n\n      constraints.forEach(function (keyword) {\n        block += _this[keyword]();\n      });\n\n      return block;\n    }\n\n    /**\n     * enum\n     *\n     * @description\n     * > An instance validates successfully against this keyword if its value\n     * > is equal to one of the elements in this keyword's array value.\n     * > JSON Schema Validation Section 5.5.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'enum',\n    value: function _enum() {\n      var enumerated = this.schema.enum,\n          address = this.address;\n\n      var conditions = ['value !== undefined'];\n      var block = '';\n\n      if (enumerated) {\n        enumerated.forEach(function (value) {\n          switch (typeof value === 'undefined' ? 'undefined' : _typeof(value)) {\n            case 'boolean':\n              conditions.push('value !== ' + value);\n              break;\n\n            case 'number':\n              conditions.push('value !== ' + value);\n              break;\n\n            case 'string':\n              conditions.push('value !== \"' + value + '\"');\n              break;\n\n            case 'object':\n              if (value === null) {\n                conditions.push('value !== null');\n              } else {\n                conditions.push('\\'' + JSON.stringify(value) + '\\' !== JSON.stringify(value)');\n              }\n              break;\n\n            default:\n              throw new Error('Things are not well in the land of enum');\n\n          }\n        });\n\n        block += '\\n      /**\\n       * Validate \"' + address + '\" enum\\n       */\\n      if (' + conditions.join(' && ') + ') {\\n        valid = false\\n        errors.push({\\n          keyword: \\'enum\\',\\n          message: JSON.stringify(value) + \\' is not an enumerated value\\'\\n        })\\n      }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * anyOf\n     *\n     * @description\n     * > An instance validates successfully against this keyword if it\n     * > validates successfully against at least one schema defined by this\n     * > keyword's value.\n     * > JSON Schema Validation Section 5.5.4\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'anyOf',\n    value: function anyOf() {\n      var anyOf = this.schema.anyOf,\n          address = this.address;\n\n      var block = '';\n\n      if (Array.isArray(anyOf)) {\n        block += '\\n        initialValidity = valid\\n        initialErrorCount = errors.length\\n        anyValid = false\\n      ';\n\n        anyOf.forEach(function (subschema) {\n          var validator = new Validator(subschema, { address: address });\n          block += '\\n        accumulatedErrorCount = errors.length\\n        ' + validator.compile() + '\\n        if (accumulatedErrorCount === errors.length) {\\n          anyValid = true\\n        }\\n        ';\n        });\n\n        block += '\\n          if (anyValid === true) {\\n            valid = initialValidity\\n            errors = errors.slice(0, initialErrorCount)\\n          }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * allOf\n     *\n     * @description\n     * > An instance validates successfully against this keyword if it\n     * > validates successfully against all schemas defined by this keyword's\n     * > value.\n     * > JSON Schema Validation Section 5.5.3\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'allOf',\n    value: function allOf() {\n      var allOf = this.schema.allOf,\n          address = this.address;\n\n      var block = '';\n\n      if (Array.isArray(allOf)) {\n        allOf.forEach(function (subschema) {\n          var validator = new Validator(subschema, { address: address });\n          block += '\\n        ' + validator.compile() + '\\n        ';\n        });\n      }\n\n      return block;\n    }\n\n    /**\n     * oneOf\n     *\n     * @description\n     * > An instance validates successfully against this keyword if it\n     * > validates successfully against exactly one schema defined by this\n     * > keyword's value.\n     * > JSON Schema Validation Section 5.5.5\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'oneOf',\n    value: function oneOf() {\n      var oneOf = this.schema.oneOf,\n          address = this.address;\n\n      var block = '';\n\n      if (Array.isArray(oneOf)) {\n        block += '\\n        /**\\n         * Validate ' + address + ' oneOf\\n         */\\n        initialValidity = valid\\n        initialErrorCount = errors.length\\n        countOfValid = 0\\n      ';\n\n        oneOf.forEach(function (subschema) {\n          var validator = new Validator(subschema, { address: address });\n          block += '\\n        accumulatedErrorCount = errors.length\\n        ' + validator.compile() + '\\n        if (accumulatedErrorCount === errors.length) {\\n          countOfValid += 1\\n        }\\n        ';\n        });\n\n        block += '\\n          if (countOfValid === 1) {\\n            valid = initialValidity\\n            errors = errors.slice(0, initialErrorCount)\\n          } else {\\n            valid = false\\n            errors.push({\\n              keyword: \\'oneOf\\',\\n              message: \\'what is a reasonable error message for this case?\\'\\n            })\\n          }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * not\n     *\n     * @description\n     * > An instance is valid against this keyword if it fails to validate\n     * > successfully against the schema defined by this keyword.\n     * > JSON Schema Validation Section 5.5.6\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'not',\n    value: function not() {\n      var not = this.schema.not,\n          address = this.address;\n\n      var block = '';\n\n      if ((typeof not === 'undefined' ? 'undefined' : _typeof(not)) === 'object' && not !== null && !Array.isArray(not)) {\n        var subschema = not;\n        var validator = new Validator(subschema, { address: address });\n\n        block += '\\n        /**\\n         * NOT\\n         */\\n        if (value !== undefined) {\\n          initialValidity = valid\\n          initialErrorCount = errors.length\\n          notValid = true\\n\\n          accumulatedErrorCount = errors.length\\n\\n          ' + validator.compile() + '\\n\\n          if (accumulatedErrorCount === errors.length) {\\n            notValid = false\\n          }\\n\\n          if (notValid === true) {\\n            valid = initialValidity\\n            errors = errors.slice(0, initialErrorCount)\\n          } else {\\n            valid = false\\n            errors = errors.slice(0, initialErrorCount)\\n            errors.push({\\n              keyword: \\'not\\',\\n              message: \\'hmm...\\'\\n            })\\n          }\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * properties\n     *\n     * @description\n     * Iterate over the `properties` schema property if it is an object. For each\n     * key, initialize a new Validator for the subschema represented by the property\n     * value and invoke compile. Append the result of compiling each subschema to\n     * the block of code being generated.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'properties',\n    value: function properties() {\n      var schema = this.schema,\n          address = this.address;\n      var properties = schema.properties,\n          required = schema.required;\n\n      var block = this.push();\n\n      // ensure the value of \"required\" schema property is an array\n      required = Array.isArray(required) ? required : [];\n\n      if ((typeof properties === 'undefined' ? 'undefined' : _typeof(properties)) === 'object') {\n        Object.keys(properties).forEach(function (key) {\n          var subschema = properties[key];\n          var isRequired = required.indexOf(key) !== -1;\n          // TODO\n          // how should we be calculating these things? should be json pointer?\n          // needs a separate function\n          var pointer = [address, key].filter(function (segment) {\n            return !!segment;\n          }).join('.');\n          var validation = new Validator(subschema, { address: pointer, require: isRequired });\n\n          // read the value\n          block += '\\n        value = container[\\'' + key + '\\']\\n        ';\n\n          block += validation.compile();\n        });\n      }\n\n      block += this.pop();\n\n      return block;\n    }\n\n    /**\n     * Other Properties\n     *\n     * @description\n     * This method is not for a keyword. It wraps validations for\n     * patternProperties and additionalProperties in a single iteration over\n     * an object-type value's properties.\n     *\n     * It should only be invoked once for a given subschema.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'otherProperties',\n    value: function otherProperties() {\n      return '\\n      /**\\n       * Validate Other Properties\\n       */\\n      ' + this.push() + '\\n\\n      for (let key in container) {\\n        value = container[key]\\n        matched = false\\n\\n        ' + this.patternValidations() + '\\n        ' + this.additionalValidations() + '\\n      }\\n\\n      ' + this.pop() + '\\n    ';\n    }\n\n    /**\n     * Pattern Validations\n     *\n     * @description\n     * Generate validation code from a subschema for properties matching a\n     * regular expression.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'patternValidations',\n    value: function patternValidations() {\n      var patternProperties = this.schema.patternProperties;\n\n      var block = '';\n\n      if ((typeof patternProperties === 'undefined' ? 'undefined' : _typeof(patternProperties)) === 'object') {\n        Object.keys(patternProperties).forEach(function (pattern) {\n          var subschema = patternProperties[pattern];\n          var validator = new Validator(subschema);\n          block += '\\n          if (key.match(\\'' + pattern + '\\')) {\\n            matched = true\\n            ' + validator.compile() + '\\n          }\\n        ';\n        });\n      }\n\n      return block;\n    }\n\n    /**\n     * Additional Validations\n     *\n     * @description\n     * Generate validation code, either from a subschema for properties not\n     * defined in the schema, or to disallow properties not defined in the\n     * schema.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'additionalValidations',\n    value: function additionalValidations() {\n      var _schema = this.schema,\n          properties = _schema.properties,\n          additionalProperties = _schema.additionalProperties,\n          address = this.address;\n\n      var validations = '';\n      var block = '';\n\n      // catch additional unmatched properties\n      var conditions = ['matched !== true'];\n\n      // ignore defined properties\n      Object.keys(properties || {}).forEach(function (key) {\n        conditions.push('key !== \\'' + key + '\\'');\n      });\n\n      // validate additional properties\n      if ((typeof additionalProperties === 'undefined' ? 'undefined' : _typeof(additionalProperties)) === 'object') {\n        var subschema = additionalProperties;\n        var validator = new Validator(subschema, { address: address + '[APKey]' });\n        block += '\\n        // validate additional properties\\n        if (' + conditions.join(' && ') + ') {\\n          ' + validator.compile() + '\\n        }\\n      ';\n      }\n\n      // error for additional properties\n      if (additionalProperties === false) {\n        block += '\\n        // validate non-presence of additional properties\\n        if (' + conditions.join(' && ') + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'additionalProperties\\',\\n            message: key + \\' is not a defined property\\'\\n          })\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * patternProperties\n     *\n     * @description\n     * Generate validation code for properties matching a pattern\n     * defined by the property name (key), which must be a string\n     * representing a valid regular expression.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'patternProperties',\n    value: function patternProperties() {\n      var block = '';\n\n      if (!this.otherPropertiesCalled) {\n        this.otherPropertiesCalled = true;\n        block += this.otherProperties();\n      }\n\n      return block;\n    }\n\n    /**\n     * additionalProperties\n     *\n     * @description\n     * Generate validation code for additional properties not defined\n     * in the schema, or disallow additional properties if the value of\n     * `additionalProperties` in the schema is `false`.\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'additionalProperties',\n    value: function additionalProperties() {\n      var block = '';\n\n      if (!this.otherPropertiesCalled) {\n        this.otherPropertiesCalled = true;\n        block += this.otherProperties();\n      }\n\n      return block;\n    }\n\n    /**\n     * minProperties\n     *\n     * @description\n     * > An object instance is valid against \"minProperties\" if its number of\n     * > properties is greater than, or equal to, the value of this keyword.\n     * > JSON Schema Validation Section 5.4.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'minProperties',\n    value: function minProperties() {\n      var minProperties = this.schema.minProperties,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' min properties\\n        if (Object.keys(value).length < ' + minProperties + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'minProperties\\',\\n            message: \\'too few properties\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * maxProperties\n     *\n     * @description\n     * > An object instance is valid against \"maxProperties\" if its number of\n     * > properties is less than, or equal to, the value of this keyword.\n     * > JSON Schema Validation Section 5.4.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'maxProperties',\n    value: function maxProperties() {\n      var maxProperties = this.schema.maxProperties,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' max properties\\n        if (Object.keys(value).length > ' + maxProperties + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'maxProperties\\',\\n            message: \\'too many properties\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * Dependencies\n     *\n     * @description\n     * > For all (name, schema) pair of schema dependencies, if the instance has\n     * > a property by this name, then it must also validate successfully against\n     * > the schema.\n     * >\n     * > Note that this is the instance itself which must validate successfully,\n     * > not the value associated with the property name.\n     * >\n     * > For each (name, propertyset) pair of property dependencies, if the\n     * > instance has a property by this name, then it must also have properties\n     * > with the same names as propertyset.\n     * > JSON Schema Validation Section 5.4.5.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'dependencies',\n    value: function dependencies() {\n      var dependencies = this.schema.dependencies,\n          address = this.address;\n\n\n      var block = this.push();\n\n      if ((typeof dependencies === 'undefined' ? 'undefined' : _typeof(dependencies)) === 'object') {\n        Object.keys(dependencies).forEach(function (key) {\n          var dependency = dependencies[key];\n          var conditions = [];\n\n          if (Array.isArray(dependency)) {\n            dependency.forEach(function (item) {\n              conditions.push('container[\\'' + item + '\\'] === undefined');\n            });\n\n            block += '\\n            if (container[\\'' + key + '\\'] !== undefined && (' + conditions.join(' || ') + ')) {\\n              valid = false\\n              errors.push({\\n                keyword: \\'dependencies\\',\\n                message: \\'unmet dependencies\\'\\n              })\\n            }\\n          ';\n          } else if ((typeof dependency === 'undefined' ? 'undefined' : _typeof(dependency)) === 'object') {\n            var subschema = dependency;\n            var validator = new Validator(subschema, { address: address });\n\n            block += '\\n            if (container[\\'' + key + '\\'] !== undefined) {\\n              ' + validator.compile() + '\\n            }\\n          ';\n          }\n        });\n      }\n\n      block += this.pop();\n\n      return block;\n    }\n\n    /**\n     * Required\n     *\n     * @description\n     * > An object instance is valid against this keyword if its property set\n     * > contains all elements in this keyword's array value.\n     * > JSON Schema Validation Section 5.4.3\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'required',\n    value: function required() {\n      var properties = this.schema.properties,\n          address = this.address;\n\n      var block = '';\n\n      block += '\\n      // validate ' + address + ' presence\\n      if (value === undefined) {\\n        valid = false\\n        errors.push({\\n          keyword: \\'required\\',\\n          message: \\'is required\\'\\n        })\\n      }\\n    ';\n\n      return block;\n    }\n\n    /**\n     * additionalItems\n     *\n     * @description\n     * > Successful validation of an array instance with regards to these two\n     * > keywords is determined as follows: if \"items\" is not present, or its\n     * > value is an object, validation of the instance always succeeds,\n     * > regardless of the value of \"additionalItems\"; if the value of\n     * > \"additionalItems\" is boolean value true or an object, validation of\n     * > the instance always succeeds; if the value of \"additionalItems\" is\n     * > boolean value false and the value of \"items\" is an array, the\n     * > instance is valid if its size is less than, or equal to, the size\n     * > of \"items\".\n     * > JSON Schema Validation Section 5.3.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'additionalItems',\n    value: function additionalItems() {\n      var _schema2 = this.schema,\n          items = _schema2.items,\n          additionalItems = _schema2.additionalItems,\n          address = this.address;\n\n      var block = '';\n\n      if (additionalItems === false && Array.isArray(items)) {\n        block += '\\n        // don\\'t allow additional items\\n        if (value.length > ' + items.length + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'additionalItems\\',\\n            message: \\'additional items not allowed\\'\\n          })\\n        }\\n      ';\n      }\n\n      if ((typeof additionalItems === 'undefined' ? 'undefined' : _typeof(additionalItems)) === 'object' && additionalItems !== null && Array.isArray(items)) {\n        var subschema = additionalItems;\n        var validator = new Validator(subschema);\n        var counter = Validator.counter;\n\n        block += '\\n        // additional items\\n        ' + this.push() + '\\n\\n        for (var i' + counter + ' = ' + items.length + '; i' + counter + ' <= container.length; i' + counter + '++) {\\n          value = container[i' + counter + ']\\n          ' + validator.compile() + '\\n        }\\n\\n        ' + this.pop() + '\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * Items\n     *\n     * @description\n     * > Successful validation of an array instance with regards to these two\n     * > keywords is determined as follows: if \"items\" is not present, or its\n     * > value is an object, validation of the instance always succeeds,\n     * > regardless of the value of \"additionalItems\"; if the value of\n     * > \"additionalItems\" is boolean value true or an object, validation of\n     * > the instance always succeeds; if the value of \"additionalItems\" is\n     * > boolean value false and the value of \"items\" is an array, the\n     * > instance is valid if its size is less than, or equal to, the size\n     * > of \"items\".\n     * > JSON Schema Validation Section 5.3.1\n     *\n     * Code to generate\n     *\n     *     // this outer conditional is generated by this.array()\n     *     if (Array.isArray(value) {\n     *       let parent = value\n     *       for (let i = 0; i < parent.length; i++) {\n     *         value = parent[i]\n     *         // other validation code depending on value here\n     *       }\n     *       value = parent\n     *     }\n     *\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'items',\n    value: function items() {\n      var items = this.schema.items,\n          address = this.address;\n\n      var block = '';\n\n      // if items is an array\n      if (Array.isArray(items)) {\n        block += this.push();\n\n        items.forEach(function (item, index) {\n          var subschema = item;\n          var validator = new Validator(subschema, { address: address + '[' + index + ']' });\n\n          block += '\\n          // item #' + index + '\\n          value = container[' + index + ']\\n          ' + validator.compile() + '\\n        ';\n        });\n\n        block += this.pop();\n\n        // if items is an object\n      } else if ((typeof items === 'undefined' ? 'undefined' : _typeof(items)) === 'object' && items !== null) {\n        var subschema = items;\n        var validator = new Validator(subschema);\n        var counter = Validator.counter;\n\n        block += '\\n        // items\\n        ' + this.push() + '\\n\\n        for (var i' + counter + ' = 0; i' + counter + ' < container.length; i' + counter + '++) {\\n          // read array element\\n          value = container[i' + counter + ']\\n          ' + validator.compile() + '\\n        }\\n\\n        ' + this.pop() + '\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * minItems\n     *\n     * @description\n     * > An array instance is valid against \"minItems\" if its size is greater\n     * > than, or equal to, the value of this keyword.\n     * > JSON Schema Validation Section 5.3.3\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'minItems',\n    value: function minItems() {\n      var minItems = this.schema.minItems,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' min items\\n        if (value.length < ' + minItems + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'minItems\\',\\n            message: \\'too few properties\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * maxItems\n     *\n     * @description\n     * > An array instance is valid against \"maxItems\" if its size is less\n     * > than, or equal to, the value of this keyword.\n     * > JSON Schema Validation Section 5.3.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'maxItems',\n    value: function maxItems() {\n      var maxItems = this.schema.maxItems,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' max items\\n        if (value.length > ' + maxItems + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'maxItems\\',\\n            message: \\'too many properties\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * uniqueItems\n     *\n     * @description\n     * > If this keyword has boolean value false, the instance validates\n     * > successfully. If it has boolean value true, the instance validates\n     * > successfully if all of its elements are unique.\n     * > JSON Schema Validation Section 5.3.4\n     *\n     * TODO\n     * optimize\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'uniqueItems',\n    value: function uniqueItems() {\n      var uniqueItems = this.schema.uniqueItems,\n          address = this.address;\n\n      var block = '';\n\n      if (uniqueItems === true) {\n        block += '\\n        // validate ' + address + ' unique items\\n        let values = value.map(v => JSON.stringify(v)) // TODO: optimize\\n        let set = new Set(values)\\n        if (values.length !== set.size) {\\n          valid = false\\n          errors.push({\\n            keyword: \\'uniqueItems\\',\\n            message: \\'items must be unique\\'\\n          })\\n        }\\n      ';\n      }\n\n      return block;\n    }\n\n    /**\n     * minLength\n     *\n     * @description\n     * > A string instance is valid against this keyword if its length is\n     * > greater than, or equal to, the value of this keyword. The length of\n     * > a string instance is defined as the number of its characters as\n     * > defined by RFC 4627 [RFC4627].\n     * > JSON Schema Validation Section 5.2.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'minLength',\n    value: function minLength() {\n      var minLength = this.schema.minLength,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' validate minLength\\n        if (Array.from(value).length < ' + minLength + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'minLength\\',\\n            message: \\'too short\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * maxLength\n     *\n     * @description\n     * > A string instance is valid against this keyword if its length is less\n     * > than, or equal to, the value of this keyword. The length of a string\n     * > instance is defined as the number of its characters as defined by\n     * > RFC 4627 [RFC4627].\n     * > JSON Schema Validation Section 5.2.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'maxLength',\n    value: function maxLength() {\n      var maxLength = this.schema.maxLength,\n          address = this.address;\n\n\n      return '\\n        // ' + address + ' validate maxLength\\n        if (Array.from(value).length > ' + maxLength + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'maxLength\\',\\n            message: \\'too long\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * Pattern\n     *\n     * @description\n     * > A string instance is considered valid if the regular expression\n     * > matches the instance successfully.\n     * > JSON Schema Validation Section 5.2.3\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'pattern',\n    value: function pattern() {\n      var pattern = this.schema.pattern,\n          address = this.address;\n\n\n      if (pattern) {\n        return '\\n          // ' + address + ' validate pattern\\n          if (!value.match(new RegExp(\\'' + pattern + '\\'))) {\\n            valid = false\\n            errors.push({\\n              keyword: \\'pattern\\',\\n              message: \\'does not match the required pattern\\'\\n            })\\n          }\\n      ';\n      }\n    }\n\n    /**\n     * Format\n     *\n     * @description\n     * > Structural validation alone may be insufficient to validate that\n     * > an instance meets all the requirements of an application. The\n     * > \"format\" keyword is defined to allow interoperable semantic\n     * > validation for a fixed subset of values which are accurately\n     * > described by authoritative resources, be they RFCs or other\n     * > external specifications.\n     * > JSON Schema Validation Section 7.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'format',\n    value: function format() {\n      var format = this.schema.format,\n          address = this.address;\n\n      var matcher = formats.resolve(format);\n\n      if (matcher) {\n        return '\\n      // ' + address + ' validate format\\n      if (!value.match(' + matcher + ')) {\\n        valid = false\\n        errors.push({\\n          keyword: \\'format\\',\\n          message: \\'is not \"' + format + '\" format\\'\\n        })\\n      }\\n      ';\n      }\n    }\n\n    /**\n     * Minimum\n     *\n     * @description\n     * > Successful validation depends on the presence and value of\n     * > \"exclusiveMinimum\": if \"exclusiveMinimum\" is not present, or has\n     * > boolean value false, then the instance is valid if it is greater\n     * > than, or equal to, the value of \"minimum\"; if \"exclusiveMinimum\" is\n     * > present and has boolean value true, the instance is valid if it is\n     * > strictly greater than the value of \"minimum\".\n     * > JSON Schema Validation Section 5.1.3\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'minimum',\n    value: function minimum() {\n      var _schema3 = this.schema,\n          minimum = _schema3.minimum,\n          exclusiveMinimum = _schema3.exclusiveMinimum,\n          address = this.address;\n\n      var operator = exclusiveMinimum === true ? '<=' : '<';\n\n      return '\\n        // ' + address + ' validate minimum\\n        if (value ' + operator + ' ' + minimum + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'minimum\\',\\n            message: \\'too small\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * Maximum\n     *\n     * @description\n     * > Successful validation depends on the presence and value of\n     * > \"exclusiveMaximum\": if \"exclusiveMaximum\" is not present, or has\n     * > boolean value false, then the instance is valid if it is lower than,\n     * > or equal to, the value of \"maximum\"; if \"exclusiveMaximum\" has\n     * > boolean value true, the instance is valid if it is strictly lower\n     * > than the value of \"maximum\".\n     * > JSON Schema Validation Section 5.1.2\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'maximum',\n    value: function maximum() {\n      var _schema4 = this.schema,\n          maximum = _schema4.maximum,\n          exclusiveMaximum = _schema4.exclusiveMaximum,\n          address = this.address;\n\n      var operator = exclusiveMaximum === true ? '>=' : '>';\n\n      return '\\n        // ' + address + ' validate maximum\\n        if (value ' + operator + ' ' + maximum + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'maximum\\',\\n            message: \\'too large\\'\\n          })\\n        }\\n    ';\n    }\n\n    /**\n     * multipleOf\n     *\n     * @description\n     * > A numeric instance is valid against \"multipleOf\" if the result of\n     * > the division of the instance by this keyword's value is an integer.\n     * > JSON Schema Validation Section 5.1.1\n     *\n     * @returns {string}\n     */\n\n  }, {\n    key: 'multipleOf',\n    value: function multipleOf() {\n      var multipleOf = this.schema.multipleOf;\n\n      var block = '';\n\n      if (typeof multipleOf === 'number') {\n        var length = multipleOf.toString().length;\n        var decimals = length - multipleOf.toFixed(0).length - 1;\n        var pow = decimals > 0 ? Math.pow(10, decimals) : 1;\n        var condition = void 0;\n\n        if (decimals > 0) {\n          condition = '(value * ' + pow + ') % ' + multipleOf * pow + ' !== 0';\n        } else {\n          condition = 'value % ' + multipleOf + ' !== 0';\n        }\n\n        block += '\\n        if (' + condition + ') {\\n          valid = false\\n          errors.push({\\n            keyword: \\'multipleOf\\',\\n            message: \\'must be a multiple of ' + multipleOf + '\\'\\n          })\\n        }\\n      ';\n      }\n\n      return block;\n    }\n  }]);\n\n  return Validator;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = Validator;","'use strict';\n\nvar TextEncoder = global.TextEncoder ? global.TextEncoder // browser\n: require('text-encoding').TextEncoder; // node shim\nmodule.exports = TextEncoder;","\"use strict\";\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * NotSupportedError\n */\nvar NotSupportedError = function (_Error) {\n  _inherits(NotSupportedError, _Error);\n\n  function NotSupportedError(alg) {\n    _classCallCheck(this, NotSupportedError);\n\n    var _this = _possibleConstructorReturn(this, (NotSupportedError.__proto__ || Object.getPrototypeOf(NotSupportedError)).call(this));\n\n    _this.message = alg + \" is not a supported algorithm\";\n    return _this;\n  }\n\n  return NotSupportedError;\n}(Error);\n\n/**\n * Export\n */\n\n\nmodule.exports = NotSupportedError;","'use strict';\n\nmodule.exports = {\n  DataError: require('./DataError'),\n  NotSupportedError: require('./NotSupportedError')\n};","\"use strict\";\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * DataError\n */\nvar DataError = function (_Error) {\n  _inherits(DataError, _Error);\n\n  function DataError(message) {\n    _classCallCheck(this, DataError);\n\n    return _possibleConstructorReturn(this, (DataError.__proto__ || Object.getPrototypeOf(DataError)).call(this, message));\n  }\n\n  return DataError;\n}(Error);\n\n/**\n * Export\n */\n\n\nmodule.exports = DataError;","'use strict';\n\n/**\n * Dependencies\n * @ignore\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _require = require('@trust/json-document'),\n    JSONDocument = _require.JSONDocument;\n\nvar JWKSchema = require('../schemas/JWKSchema');\nvar JWA = require('./JWA');\n\n/**\n * JWK Class\n */\n\nvar JWK = function (_JSONDocument) {\n  _inherits(JWK, _JSONDocument);\n\n  function JWK() {\n    _classCallCheck(this, JWK);\n\n    return _possibleConstructorReturn(this, (JWK.__proto__ || Object.getPrototypeOf(JWK)).apply(this, arguments));\n  }\n\n  _createClass(JWK, null, [{\n    key: 'importKey',\n\n\n    /**\n     * importKey\n     *\n     * TODO:\n     * - should this be on JWA?\n     */\n    value: function importKey(jwk) {\n      return JWA.importKey(jwk);\n    }\n  }, {\n    key: 'schema',\n\n\n    /**\n     * Schema\n     */\n    get: function get() {\n      return JWKSchema;\n    }\n  }]);\n\n  return JWK;\n}(JSONDocument);\n\n/**\n * Export\n */\n\n\nmodule.exports = JWK;","'use strict';\n\n/**\n * Dependencies\n */\n\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\nvar JWKSchema = require('./JWKSchema');\n\n/**\n * JWKSetSchema\n */\nvar JWKSetSchema = new JSONSchema({\n  type: 'object',\n  properties: {\n    keys: {\n      type: 'array',\n      items: JWKSchema\n    }\n  }\n});\n\n/**\n * Export\n */\nmodule.exports = JWKSetSchema;","'use strict';\n\n/**\n * Dependencies\n */\nvar Base64URLSchema = require('./Base64URLSchema');\nvar JWTClaimsSetSchema = require('./JWTClaimsSetSchema');\nvar JOSEHeaderSchema = require('./JOSEHeaderSchema');\n\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\n/**\n * JWTSchema\n *\n * @description\n * This schema represents all the things a deserialized JWT can be, i.e.,\n * either a JWS or JWE, and any serialization of them. Validation of well-\n * formedness for a given serialization is accomplished at the time of\n * encoding.\n */\n\n\nvar JWTSchema = new JSONSchema({\n  type: 'object',\n  properties: {\n\n    /**\n     * type\n     */\n    type: {\n      type: 'string',\n      enum: ['JWS', 'JWE']\n    },\n\n    /**\n     * segments\n     */\n    segments: {\n      type: 'array'\n    },\n\n    /**\n     * header\n     */\n    header: JOSEHeaderSchema,\n\n    /**\n     * protected\n     */\n    protected: JOSEHeaderSchema,\n\n    /**\n     * unprotected\n     */\n    unprotected: JOSEHeaderSchema,\n\n    /**\n     * iv\n     */\n    iv: Base64URLSchema,\n\n    /**\n     * aad\n     */\n    aad: Base64URLSchema,\n\n    /**\n     * ciphertext\n     */\n    ciphertext: Base64URLSchema,\n\n    /**\n     * tag\n     */\n    tag: Base64URLSchema,\n\n    /**\n     * recipients\n     */\n    recipients: {\n      type: 'array',\n      items: {\n        type: 'object',\n        properties: {\n          header: JOSEHeaderSchema,\n          encrypted_key: Base64URLSchema\n        }\n      }\n    },\n\n    /**\n     * payload\n     */\n    payload: JWTClaimsSetSchema,\n\n    /**\n     * signatures\n     */\n    signatures: {\n      type: 'array',\n      items: {\n        type: 'object',\n        properties: {\n          protected: JOSEHeaderSchema,\n          header: JOSEHeaderSchema,\n          signature: Base64URLSchema,\n          key: { type: 'object' }\n        }\n      }\n    },\n\n    /**\n     * signature\n     */\n    signature: Base64URLSchema,\n\n    /**\n     * verified\n     */\n    verified: {\n      type: 'boolean',\n      default: false\n    },\n\n    /**\n     * key\n     */\n    key: {\n      type: 'object'\n    },\n\n    /**\n     * serialization\n     */\n    serialization: {\n      type: 'string',\n      enum: ['compact', 'json', 'flattened'],\n      default: 'compact'\n    }\n  }\n});\n\n/**\n * Export\n */\nmodule.exports = JWTSchema;","'use strict';\n\n/**\n * Dependencies\n */\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\n/**\n * Base64URLSchema\n */\n\n\nvar Base64URLSchema = new JSONSchema({\n  type: 'string',\n  format: 'base64url'\n});\n\n/**\n * Export\n */\nmodule.exports = Base64URLSchema;","'use strict';\n\n/**\n * Dependencies\n */\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\n/**\n * JWTClaimsSetSchema\n *\n * JSON Web Token (JWT)\n * https://tools.ietf.org/html/rfc7519#section-4\n *\n * 4.  JWT Claims\n *\n *   The JWT Claims Set represents a JSON object whose members are the\n *   claims conveyed by the JWT.  The Claim Names within a JWT Claims Set\n *   MUST be unique; JWT parsers MUST either reject JWTs with duplicate\n *   Claim Names or use a JSON parser that returns only the lexically last\n *   duplicate member name, as specified in Section 15.12 (\"The JSON\n *   Object\") of ECMAScript 5.1 [ECMAScript].\n *\n *   The set of claims that a JWT must contain to be considered valid is\n *   context dependent and is outside the scope of this specification.\n *   Specific applications of JWTs will require implementations to\n *   understand and process some claims in particular ways.  However, in\n *   the absence of such requirements, all claims that are not understood\n *   by implementations MUST be ignored.\n *\n *   There are three classes of JWT Claim Names: Registered Claim Names,\n *   Public Claim Names, and Private Claim Names.\n */\n\n\nvar JWTClaimsSetSchema = new JSONSchema({\n  properties: {\n\n    /**\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1\n     *\n     * 4.1.  Registered Claim Names\n     *\n     *   The following Claim Names are registered in the IANA \"JSON Web Token\n     *   Claims\" registry established by Section 10.1.  None of the claims\n     *   defined below are intended to be mandatory to use or implement in all\n     *   cases, but rather they provide a starting point for a set of useful,\n     *   interoperable claims.  Applications using JWTs should define which\n     *   specific claims they use and when they are required or optional.  All\n     *   the names are short because a core goal of JWTs is for the\n     *   representation to be compact.\n     */\n\n    /**\n     * iss\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.1\n     *\n     * 4.1.1.  \"iss\" (Issuer) Claim\n     *\n     *   The \"iss\" (issuer) claim identifies the principal that issued the\n     *   JWT.  The processing of this claim is generally application specific.\n     *   The \"iss\" value is a case-sensitive string containing a StringOrURI\n     *   value.  Use of this claim is OPTIONAL.\n     */\n    iss: {\n      type: 'string',\n      format: 'StringOrURI'\n    },\n\n    /**\n     * sub\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.2\n     *\n     * 4.1.2.  \"sub\" (Subject) Claim\n     *\n     *   The \"sub\" (subject) claim identifies the principal that is the\n     *   subject of the JWT.  The claims in a JWT are normally statements\n     *   about the subject.  The subject value MUST either be scoped to be\n     *   locally unique in the context of the issuer or be globally unique.\n     *   The processing of this claim is generally application specific.  The\n     *   \"sub\" value is a case-sensitive string containing a StringOrURI\n     *   value.  Use of this claim is OPTIONAL.\n     */\n    sub: {\n      type: 'string',\n      format: 'StringOrURI'\n    },\n\n    /**\n     * aud\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.3\n     *\n     * 4.1.3.  \"aud\" (Audience) Claim\n     *\n     *   The \"aud\" (audience) claim identifies the recipients that the JWT is\n     *   intended for.  Each principal intended to process the JWT MUST\n     *   identify itself with a value in the audience claim.  If the principal\n     *   processing the claim does not identify itself with a value in the\n     *   \"aud\" claim when this claim is present, then the JWT MUST be\n     *   rejected.  In the general case, the \"aud\" value is an array of case-\n     *   sensitive strings, each containing a StringOrURI value.  In the\n     *   special case when the JWT has one audience, the \"aud\" value MAY be a\n     *   single case-sensitive string containing a StringOrURI value.  The\n     *   interpretation of audience values is generally application specific.\n     *   Use of this claim is OPTIONAL.\n     */\n    aud: {\n      type: ['array', 'string'],\n      format: 'StringOrURI',\n      items: {\n        format: 'StringOrURI'\n      }\n    },\n\n    /**\n     * exp\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.4\n     *\n     * 4.1.4.  \"exp\" (Expiration Time) Claim\n     *\n     *   The \"exp\" (expiration time) claim identifies the expiration time on\n     *   or after which the JWT MUST NOT be accepted for processing.  The\n     *   processing of the \"exp\" claim requires that the current date/time\n     *   MUST be before the expiration date/time listed in the \"exp\" claim.\n     *\n     *   Implementers MAY provide for some small leeway, usually no more than\n     *   a few minutes, to account for clock skew.  Its value MUST be a number\n     *   containing a NumericDate value.  Use of this claim is OPTIONAL.\n     *\n     */\n    exp: {\n      type: 'number',\n      format: 'NumericDate'\n    },\n\n    /**\n     * nbf\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.5\n     *\n     * 4.1.5.  \"nbf\" (Not Before) Claim\n     *\n     *   The \"nbf\" (not before) claim identifies the time before which the JWT\n     *   MUST NOT be accepted for processing.  The processing of the \"nbf\"\n     *   claim requires that the current date/time MUST be after or equal to\n     *   the not-before date/time listed in the \"nbf\" claim.  Implementers MAY\n     *   provide for some small leeway, usually no more than a few minutes, to\n     *   account for clock skew.  Its value MUST be a number containing a\n     *   NumericDate value.  Use of this claim is OPTIONAL.\n     */\n    nbf: {\n      type: 'number',\n      format: 'NumericDate'\n    },\n\n    /**\n     * iat\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.6\n     *\n     * 4.1.6.  \"iat\" (Issued At) Claim\n     *\n     *   The \"iat\" (issued at) claim identifies the time at which the JWT was\n     *   issued.  This claim can be used to determine the age of the JWT.  Its\n     *   value MUST be a number containing a NumericDate value.  Use of this\n     *   claim is OPTIONAL.\n     */\n    iat: {\n      type: 'number',\n      format: 'NumericDate'\n    },\n\n    /**\n     * jti\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-4.1.7\n     *\n     * 4.1.7.  \"jti\" (JWT ID) Claim\n     *\n     *   The \"jti\" (JWT ID) claim provides a unique identifier for the JWT.\n     *   The identifier value MUST be assigned in a manner that ensures that\n     *   there is a negligible probability that the same value will be\n     *   accidentally assigned to a different data object; if the application\n     *   uses multiple issuers, collisions MUST be prevented among values\n     *   produced by different issuers as well.  The \"jti\" claim can be used\n     *   to prevent the JWT from being replayed.  The \"jti\" value is a case-\n     *   sensitive string.  Use of this claim is OPTIONAL.\n     */\n    jti: {\n      type: 'string'\n    }\n  }\n});\n\n/**\n * Export\n */\nmodule.exports = JWTClaimsSetSchema;","'use strict';\n\n/**\n * Dependencies\n */\nvar JWKSchema = require('./JWKSchema');\n\nvar _require = require('@trust/json-document'),\n    JSONSchema = _require.JSONSchema;\n\n/**\n * JOSEHeaderSchema\n *\n * JSON Web Token (JWT)\n * https://tools.ietf.org/html/rfc7519#section-5\n *\n * 5.  JOSE Header\n *\n *   For a JWT object, the members of the JSON object represented by the\n *   JOSE Header describe the cryptographic operations applied to the JWT\n *   and optionally, additional properties of the JWT.  Depending upon\n *   whether the JWT is a JWS or JWE, the corresponding rules for the JOSE\n *   Header values apply.\n */\n\n\nvar JOSEHeaderSchema = new JSONSchema({\n  type: 'object',\n  properties: {\n\n    /**\n     * typ\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-5.1\n     *\n     * 5.1.  \"typ\" (Type) Header Parameter\n     *\n     *   The \"typ\" (type) Header Parameter defined by [JWS] and [JWE] is used\n     *   by JWT applications to declare the media type [IANA.MediaTypes] of\n     *   this complete JWT.  This is intended for use by the JWT application\n     *   when values that are not JWTs could also be present in an application\n     *   data structure that can contain a JWT object; the application can use\n     *   this value to disambiguate among the different kinds of objects that\n     *   might be present.  It will typically not be used by applications when\n     *   it is already known that the object is a JWT.  This parameter is\n     *   ignored by JWT implementations; any processing of this parameter is\n     *   performed by the JWT application.  If present, it is RECOMMENDED that\n     *   its value be \"JWT\" to indicate that this object is a JWT.  While\n     *   media type names are not case sensitive, it is RECOMMENDED that \"JWT\"\n     *   always be spelled using uppercase characters for compatibility with\n     *   legacy implementations.  Use of this Header Parameter is OPTIONAL.\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.9\n     *\n     * 4.1.9.  \"typ\" (Type) Header Parameter\n     *\n     *   The \"typ\" (type) Header Parameter is used by JWS applications to\n     *   declare the media type [IANA.MediaTypes] of this complete JWS.  This\n     *   is intended for use by the application when more than one kind of\n     *   object could be present in an application data structure that can\n     *   contain a JWS; the application can use this value to disambiguate\n     *   among the different kinds of objects that might be present.  It will\n     *   typically not be used by applications when the kind of object is\n     *   already known.  This parameter is ignored by JWS implementations; any\n     *   processing of this parameter is performed by the JWS application.\n     *   Use of this Header Parameter is OPTIONAL.\n     *\n     *   Per RFC 2045 [RFC2045], all media type values, subtype values, and\n     *   parameter names are case insensitive.  However, parameter values are\n     *   case sensitive unless otherwise specified for the specific parameter.\n     *\n     *   To keep messages compact in common situations, it is RECOMMENDED that\n     *   producers omit an \"application/\" prefix of a media type value in a\n     *   \"typ\" Header Parameter when no other '/' appears in the media type\n     *   value.  A recipient using the media type value MUST treat it as if\n     *   \"application/\" were prepended to any \"typ\" value not containing a\n     *   '/'.  For instance, a \"typ\" value of \"example\" SHOULD be used to\n     *   represent the \"application/example\" media type, whereas the media\n     *   type \"application/example;part=\"1/2\"\" cannot be shortened to\n     *   \"example;part=\"1/2\"\".\n     *\n     *   The \"typ\" value \"JOSE\" can be used by applications to indicate that\n     *   this object is a JWS or JWE using the JWS Compact Serialization or\n     *   the JWE Compact Serialization.  The \"typ\" value \"JOSE+JSON\" can be\n     *   used by applications to indicate that this object is a JWS or JWE\n     *   using the JWS JSON Serialization or the JWE JSON Serialization.\n     *   Other type values can also be used by applications.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.11\n     *\n     * 4.1.11.  \"typ\" (Type) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"typ\" Header Parameter defined in Section 4.1.9 of [JWS], except\n     *   that the type is that of this complete JWE.\n     */\n    typ: {\n      type: 'string'\n    },\n\n    /**\n     * cty\n     *\n     * JSON Web Token (JWT)\n     * https://tools.ietf.org/html/rfc7519#section-5.2\n     *\n     * 5.2.  \"cty\" (Content Type) Header Parameter\n     *\n     *   The \"cty\" (content type) Header Parameter defined by [JWS] and [JWE]\n     *   is used by this specification to convey structural information about\n     *   the JWT.\n     *\n     *   In the normal case in which nested signing or encryption operations\n     *   are not employed, the use of this Header Parameter is NOT\n     *   RECOMMENDED.  In the case that nested signing or encryption is\n     *   employed, this Header Parameter MUST be present; in this case, the\n     *   value MUST be \"JWT\", to indicate that a Nested JWT is carried in this\n     *   JWT.  While media type names are not case sensitive, it is\n     *   RECOMMENDED that \"JWT\" always be spelled using uppercase characters\n     *   for compatibility with legacy implementations.  See Appendix A.2 for\n     *   an example of a Nested JWT.\n     *\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.10\n     *\n     * 4.1.10.  \"cty\" (Content Type) Header Parameter\n     *\n     *   The \"cty\" (content type) Header Parameter is used by JWS applications\n     *   to declare the media type [IANA.MediaTypes] of the secured content\n     *   (the payload).  This is intended for use by the application when more\n     *   than one kind of object could be present in the JWS Payload; the\n     *   application can use this value to disambiguate among the different\n     *   kinds of objects that might be present.  It will typically not be\n     *   used by applications when the kind of object is already known.  This\n     *   parameter is ignored by JWS implementations; any processing of this\n     *   parameter is performed by the JWS application.  Use of this Header\n     *   Parameter is OPTIONAL.\n     *\n     *   Per RFC 2045 [RFC2045], all media type values, subtype values, and\n     *   parameter names are case insensitive.  However, parameter values are\n     *   case sensitive unless otherwise specified for the specific parameter.\n     *\n     *   To keep messages compact in common situations, it is RECOMMENDED that\n     *   producers omit an \"application/\" prefix of a media type value in a\n     *   \"cty\" Header Parameter when no other '/' appears in the media type\n     *   value.  A recipient using the media type value MUST treat it as if\n     *   \"application/\" were prepended to any \"cty\" value not containing a\n     *   '/'.  For instance, a \"cty\" value of \"example\" SHOULD be used to\n     *   represent the \"application/example\" media type, whereas the media\n     *   type \"application/example;part=\"1/2\"\" cannot be shortened to\n     *   \"example;part=\"1/2\"\".\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.12\n     *\n     * 4.1.12.  \"cty\" (Content Type) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"cty\" Header Parameter defined in Section 4.1.10 of [JWS], except\n     *   that the type is that of the secured content (the plaintext).\n     */\n    cty: {\n      type: 'string',\n      enum: ['JWT']\n    },\n\n    /**\n     * alg\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.1\n     *\n     * 4.1.1.  \"alg\" (Algorithm) Header Parameter\n     *\n     *   The \"alg\" (algorithm) Header Parameter identifies the cryptographic\n     *   algorithm used to secure the JWS.  The JWS Signature value is not\n     *   valid if the \"alg\" value does not represent a supported algorithm or\n     *   if there is not a key for use with that algorithm associated with the\n     *   party that digitally signed or MACed the content.  \"alg\" values\n     *   should either be registered in the IANA \"JSON Web Signature and\n     *   Encryption Algorithms\" registry established by [JWA] or be a value\n     *   that contains a Collision-Resistant Name.  The \"alg\" value is a case-\n     *   sensitive ASCII string containing a StringOrURI value.  This Header\n     *   Parameter MUST be present and MUST be understood and processed by\n     *   implementations.\n     *\n     *   A list of defined \"alg\" values for this use can be found in the IANA\n     *   \"JSON Web Signature and Encryption Algorithms\" registry established\n     *   by [JWA]; the initial contents of this registry are the values\n     *   defined in Section 3.1 of [JWA].\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.1\n     *\n     * 4.1.1.  \"alg\" (Algorithm) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"alg\" Header Parameter defined in Section 4.1.1 of [JWS], except\n     *   that the Header Parameter identifies the cryptographic algorithm used\n     *   to encrypt or determine the value of the CEK.  The encrypted content\n     *   is not usable if the \"alg\" value does not represent a supported\n     *   algorithm, or if the recipient does not have a key that can be used\n     *   with that algorithm.\n     *\n     *   A list of defined \"alg\" values for this use can be found in the IANA\n     *   \"JSON Web Signature and Encryption Algorithms\" registry established\n     *   by [JWA]; the initial contents of this registry are the values\n     *   defined in Section 4.1 of [JWA].\n     */\n    alg: {\n      type: 'string',\n      format: 'StringOrURI'\n    },\n\n    /**\n     * jku\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.2\n     *\n     * 4.1.2.  \"jku\" (JWK Set URL) Header Parameter (JWS)\n     *\n     *   The \"jku\" (JWK Set URL) Header Parameter is a URI [RFC3986] that\n     *   refers to a resource for a set of JSON-encoded public keys, one of\n     *   which corresponds to the key used to digitally sign the JWS.  The\n     *   keys MUST be encoded as a JWK Set [JWK].  The protocol used to\n     *   acquire the resource MUST provide integrity protection; an HTTP GET\n     *   request to retrieve the JWK Set MUST use Transport Layer Security\n     *   (TLS) [RFC2818] [RFC5246]; and the identity of the server MUST be\n     *   validated, as per Section 6 of RFC 6125 [RFC6125].  Also, see\n     *   Section 8 on TLS requirements.  Use of this Header Parameter is\n     *   OPTIONAL.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.4\n     *\n     * 4.1.4.  \"jku\" (JWK Set URL) Header Parameter (JWE)\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"jku\" Header Parameter defined in Section 4.1.2 of [JWS], except\n     *   that the JWK Set resource contains the public key to which the JWE\n     *   was encrypted; this can be used to determine the private key needed\n     *   to decrypt the JWE.\n     */\n    jku: {\n      type: 'string',\n      format: 'URI'\n    },\n\n    /**\n     * jwk\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.3\n     *\n     * 4.1.3.  \"jwk\" (JSON Web Key) Header Parameter\n     *\n     *   The \"jwk\" (JSON Web Key) Header Parameter is the public key that\n     *   corresponds to the key used to digitally sign the JWS.  This key is\n     *   represented as a JSON Web Key [JWK].  Use of this Header Parameter is\n     *   OPTIONAL.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.5\n     *\n     * 4.1.5.  \"jwk\" (JSON Web Key) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"jwk\" Header Parameter defined in Section 4.1.3 of [JWS], except\n     *   that the key is the public key to which the JWE was encrypted; this\n     *   can be used to determine the private key needed to decrypt the JWE.\n     */\n    //jwk: JWKSchema,\n\n    /**\n     * kid\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.4\n     *\n     * 4.1.4.  \"kid\" (Key ID) Header Parameter\n     *\n     *   The \"kid\" (key ID) Header Parameter is a hint indicating which key\n     *   was used to secure the JWS.  This parameter allows originators to\n     *   explicitly signal a change of key to recipients.  The structure of\n     *   the \"kid\" value is unspecified.  Its value MUST be a case-sensitive\n     *   string.  Use of this Header Parameter is OPTIONAL.\n     *\n     *   When used with a JWK, the \"kid\" value is used to match a JWK \"kid\"\n     *   parameter value.\n     *\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.6\n     *\n     * 4.1.6.  \"kid\" (Key ID) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"kid\" Header Parameter defined in Section 4.1.4 of [JWS], except\n     *   that the key hint references the public key to which the JWE was\n     *   encrypted; this can be used to determine the private key needed to\n     *   decrypt the JWE.  This parameter allows originators to explicitly\n     *   signal a change of key to JWE recipients.\n     */\n    kid: {\n      type: 'string'\n    },\n\n    /**\n     * x5u\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.5\n     *\n     * 4.1.5.  \"x5u\" (X.509 URL) Header Parameter\n     *\n     *   The \"x5u\" (X.509 URL) Header Parameter is a URI [RFC3986] that refers\n     *   to a resource for the X.509 public key certificate or certificate\n     *   chain [RFC5280] corresponding to the key used to digitally sign the\n     *   JWS.  The identified resource MUST provide a representation of the\n     *   certificate or certificate chain that conforms to RFC 5280 [RFC5280]\n     *   in PEM-encoded form, with each certificate delimited as specified in\n     *   Section 6.1 of RFC 4945 [RFC4945].  The certificate containing the\n     *   public key corresponding to the key used to digitally sign the JWS\n     *   MUST be the first certificate.  This MAY be followed by additional\n     *   certificates, with each subsequent certificate being the one used to\n     *   certify the previous one.  The protocol used to acquire the resource\n     *   MUST provide integrity protection; an HTTP GET request to retrieve\n     *   the certificate MUST use TLS [RFC2818] [RFC5246]; and the identity of\n     *   the server MUST be validated, as per Section 6 of RFC 6125 [RFC6125].\n     *   Also, see Section 8 on TLS requirements.  Use of this Header\n     *   Parameter is OPTIONAL.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.7\n     *\n     * 4.1.7.  \"x5u\" (X.509 URL) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"x5u\" Header Parameter defined in Section 4.1.5 of [JWS], except\n     *   that the X.509 public key certificate or certificate chain [RFC5280]\n     *   contains the public key to which the JWE was encrypted; this can be\n     *   used to determine the private key needed to decrypt the JWE.\n     */\n    x5u: {\n      type: 'string',\n      format: 'URI'\n    },\n\n    /**\n     * x5c\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.6\n     *\n     * 4.1.6.  \"x5c\" (X.509 Certificate Chain) Header Parameter\n     *\n     *   The \"x5c\" (X.509 certificate chain) Header Parameter contains the\n     *   X.509 public key certificate or certificate chain [RFC5280]\n     *   corresponding to the key used to digitally sign the JWS.  The\n     *   certificate or certificate chain is represented as a JSON array of\n     *   certificate value strings.  Each string in the array is a\n     *   base64-encoded (Section 4 of [RFC4648] -- not base64url-encoded) DER\n     *   [ITU.X690.2008] PKIX certificate value.  The certificate containing\n     *   the public key corresponding to the key used to digitally sign the\n     *   JWS MUST be the first certificate.  This MAY be followed by\n     *   additional certificates, with each subsequent certificate being the\n     *   one used to certify the previous one.  The recipient MUST validate\n     *   the certificate chain according to RFC 5280 [RFC5280] and consider\n     *   the certificate or certificate chain to be invalid if any validation\n     *   failure occurs.  Use of this Header Parameter is OPTIONAL.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.8\n     *\n     * 4.1.8.  \"x5c\" (X.509 Certificate Chain) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"x5c\" Header Parameter defined in Section 4.1.6 of [JWS], except\n     *   that the X.509 public key certificate or certificate chain [RFC5280]\n     *   contains the public key to which the JWE was encrypted; this can be\n     *   used to determine the private key needed to decrypt the JWE.\n     */\n    x5c: {\n      type: 'array',\n      items: {\n        type: 'string',\n        format: 'base64'\n      }\n    },\n\n    /**\n     * x5t\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.7\n     *\n     * 4.1.7.  \"x5t\" (X.509 Certificate SHA-1 Thumbprint) Header Parameter\n     *\n     *   The \"x5t\" (X.509 certificate SHA-1 thumbprint) Header Parameter is a\n     *   base64url-encoded SHA-1 thumbprint (a.k.a. digest) of the DER\n     *   encoding of the X.509 certificate [RFC5280] corresponding to the key\n     *   used to digitally sign the JWS.  Note that certificate thumbprints\n     *   are also sometimes known as certificate fingerprints.  Use of this\n     *   Header Parameter is OPTIONAL.\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.9\n     *\n     * 4.1.9.  \"x5t\" (X.509 Certificate SHA-1 Thumbprint) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"x5t\" Header Parameter defined in Section 4.1.7 of [JWS], except\n     *   that the certificate referenced by the thumbprint contains the public\n     *   key to which the JWE was encrypted; this can be used to determine the\n     *   private key needed to decrypt the JWE.  Note that certificate\n     *   thumbprints are also sometimes known as certificate fingerprints.\n     */\n    x5t: {\n      type: 'string',\n      format: 'base64url'\n    },\n\n    /**\n     * x5t#S256\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.8\n     *\n     * 4.1.8.  \"x5t#S256\" (X.509 Certificate SHA-256 Thumbprint) Header\n     *         Parameter\n     *\n     *   The \"x5t#S256\" (X.509 certificate SHA-256 thumbprint) Header\n     *   Parameter is a base64url-encoded SHA-256 thumbprint (a.k.a. digest)\n     *   of the DER encoding of the X.509 certificate [RFC5280] corresponding\n     *   to the key used to digitally sign the JWS.  Note that certificate\n     *   thumbprints are also sometimes known as certificate fingerprints.\n     *   Use of this Header Parameter is OPTIONAL.\n     *\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.10\n     *\n     * 4.1.10.  \"x5t#S256\" (X.509 Certificate SHA-256 Thumbprint) Header\n     *          Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"x5t#S256\" Header Parameter defined in Section 4.1.8 of [JWS],\n     *   except that the certificate referenced by the thumbprint contains the\n     *   public key to which the JWE was encrypted; this can be used to\n     *   determine the private key needed to decrypt the JWE.  Note that\n     *   certificate thumbprints are also sometimes known as certificate\n     *   fingerprints.\n     */\n    //'x5t#S256': {\n    //  type: 'string',\n    //  format: 'base64url'\n    //},\n\n    /**\n     * crit\n     *\n     * JSON Web Signature (JWS)\n     * https://tools.ietf.org/html/rfc7515#section-4.1.11\n     *\n     * 4.1.11.  \"crit\" (Critical) Header Parameter\n     *\n     *   The \"crit\" (critical) Header Parameter indicates that extensions to\n     *   this specification and/or [JWA] are being used that MUST be\n     *   understood and processed.  Its value is an array listing the Header\n     *   Parameter names present in the JOSE Header that use those extensions.\n     *   If any of the listed extension Header Parameters are not understood\n     *   and supported by the recipient, then the JWS is invalid.  Producers\n     *   MUST NOT include Header Parameter names defined by this specification\n     *   or [JWA] for use with JWS, duplicate names, or names that do not\n     *   occur as Header Parameter names within the JOSE Header in the \"crit\"\n     *   list.  Producers MUST NOT use the empty list \"[]\" as the \"crit\"\n     *   value.  Recipients MAY consider the JWS to be invalid if the critical\n     *   list contains any Header Parameter names defined by this\n     *   specification or [JWA] for use with JWS or if any other constraints\n     *   on its use are violated.  When used, this Header Parameter MUST be\n     *   integrity protected; therefore, it MUST occur only within the JWS\n     *   Protected Header.  Use of this Header Parameter is OPTIONAL.  This\n     *   Header Parameter MUST be understood and processed by implementations.\n     *\n     *   An example use, along with a hypothetical \"exp\" (expiration time)\n     *   field is:\n     *\n     *     {\"alg\":\"ES256\",\n     *     \"crit\":[\"exp\"],\n     *     \"exp\":1363284000\n     *     }\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.13\n     *\n     *   4.1.13.  \"crit\" (Critical) Header Parameter\n     *\n     *   This parameter has the same meaning, syntax, and processing rules as\n     *   the \"crit\" Header Parameter defined in Section 4.1.11 of [JWS],\n     *   except that Header Parameters for a JWE are being referred to, rather\n     *   than Header Parameters for a JWS.\n     */\n    crit: {\n      type: 'array',\n      items: {\n        type: 'string'\n      },\n      minItems: 1\n    },\n\n    /**\n     * enc\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.2\n     *\n     * 4.1.2.  \"enc\" (Encryption Algorithm) Header Parameter\n     *\n     *   The \"enc\" (encryption algorithm) Header Parameter identifies the\n     *   content encryption algorithm used to perform authenticated encryption\n     *   on the plaintext to produce the ciphertext and the Authentication\n     *   Tag.  This algorithm MUST be an AEAD algorithm with a specified key\n     *   length.  The encrypted content is not usable if the \"enc\" value does\n     *   not represent a supported algorithm.  \"enc\" values should either be\n     *   registered in the IANA \"JSON Web Signature and Encryption Algorithms\"\n     *   registry established by [JWA] or be a value that contains a\n     *   Collision-Resistant Name.  The \"enc\" value is a case-sensitive ASCII\n     *   string containing a StringOrURI value.  This Header Parameter MUST be\n     *   present and MUST be understood and processed by implementations.\n     *\n     *   A list of defined \"enc\" values for this use can be found in the IANA\n     *   \"JSON Web Signature and Encryption Algorithms\" registry established\n     *   by [JWA]; the initial contents of this registry are the values\n     *   defined in Section 5.1 of [JWA].\n     */\n    enc: {\n      type: 'string',\n      format: 'StringOrURI'\n    },\n\n    /**\n     * zip\n     *\n     * JSON Web Encryption (JWE)\n     * https://tools.ietf.org/html/rfc7516#section-4.1.3\n     *\n     * 4.1.3.  \"zip\" (Compression Algorithm) Header Parameter\n     *\n     *   The \"zip\" (compression algorithm) applied to the plaintext before\n     *   encryption, if any.  The \"zip\" value defined by this specification\n     *   is:\n     *\n     *   o  \"DEF\" - Compression with the DEFLATE [RFC1951] algorithm\n     *\n     *   Other values MAY be used.  Compression algorithm values can be\n     *   registered in the IANA \"JSON Web Encryption Compression Algorithms\"\n     *   registry established by [JWA].  The \"zip\" value is a case-sensitive\n     *   string.  If no \"zip\" parameter is present, no compression is applied\n     *   to the plaintext before encryption.  When used, this Header Parameter\n     *   MUST be integrity protected; therefore, it MUST occur only within the\n     *   JWE Protected Header.  Use of this Header Parameter is OPTIONAL.\n     *   This Header Parameter MUST be understood and processed by\n     *   implementations.\n     */\n    zip: {\n      type: 'string'\n    }\n  }\n});\n\n/**\n * Export\n */\nmodule.exports = JOSEHeaderSchema;","'use strict';\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Dependencies\n */\nvar base64url = require('base64url');\nvar JWA = require('./JWA');\n\nvar _require = require('../errors'),\n    DataError = _require.DataError;\n\n/**\n * JWS\n */\n\n\nvar JWS = function () {\n  function JWS() {\n    _classCallCheck(this, JWS);\n  }\n\n  _createClass(JWS, null, [{\n    key: 'sign',\n\n\n    /**\n     * sign\n     *\n     * @description\n     * Encode a JWT instance\n     *\n     * @param {Object} token\n     * @returns {Promise}\n     */\n    value: function sign(token) {\n      var payload = base64url(JSON.stringify(token.payload));\n\n      // compact serialization\n      if (token.serialization === 'compact') {\n        var key = token.key,\n            alg = token.header.alg;\n\n        var header = base64url(JSON.stringify(token.header));\n        var data = header + '.' + payload;\n\n        return JWA.sign(alg, key, data).then(function (signature) {\n          return data + '.' + signature;\n        });\n      }\n\n      // JSON serialization\n      if (token.serialization === 'json') {}\n\n      // Flattened serialization\n      if (token.serialization === 'flattened') {}\n\n      return Promise.reject(new DataError('Unsupported serialization'));\n    }\n\n    /**\n     * verify\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify(jwt) {\n      // multiple signatures\n      if (jwt.signatures) {\n        // ...\n      }\n\n      var key = jwt.key,\n          signature = jwt.signature,\n          alg = jwt.header.alg;\n\n      // one signature\n\n      if (jwt.signature) {\n        var _jwt$segments = _slicedToArray(jwt.segments, 2),\n            header = _jwt$segments[0],\n            payload = _jwt$segments[1];\n\n        var data = header + '.' + payload;\n\n        if (alg === 'none') {\n          return Promise.reject(new DataError('Signature provided to verify with alg: none'));\n        }\n\n        return JWA.verify(alg, key, signature, data).then(function (verified) {\n          jwt.verified = verified;\n          return verified;\n        });\n      }\n\n      if (alg === 'none') {\n        if (!key && !signature) {\n          jwt.verified = true;\n\n          return Promise.resolve(true);\n        }\n\n        if (key) {\n          return Promise.reject(new DataError('Key provided to verify signature with alg: none'));\n        }\n      }\n\n      // no signatures to verify\n      return Promise.reject(new DataError('Missing signature(s)'));\n    }\n  }]);\n\n  return JWS;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = JWS;","// 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;\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\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  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\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  var args = [];\n  for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    ReflectApply(this.listener, this.target, args);\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  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\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      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\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","var objectWithoutPropertiesLoose = require(\"./objectWithoutPropertiesLoose\");\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\nmodule.exports = _objectWithoutProperties;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"format\", {\n  enumerable: true,\n  get: function get() {\n    return _format.default;\n  }\n});\nObject.defineProperty(exports, \"parse\", {\n  enumerable: true,\n  get: function get() {\n    return _parse.default;\n  }\n});\n\nvar _format = _interopRequireDefault(require(\"./format\"));\n\nvar _parse = _interopRequireDefault(require(\"./parse\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n//# sourceMappingURL=index.js.map","'use strict';\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _require = require('whatwg-url'),\n    URL = _require.URL;\n\nvar _require2 = require('@solid/jose'),\n    JWT = _require2.JWT,\n    JWK = _require2.JWK;\n\nvar DEFAULT_MAX_AGE = 3600; // Default token expiration, in seconds\n\nvar PoPToken = function (_JWT) {\n  _inherits(PoPToken, _JWT);\n\n  function PoPToken() {\n    _classCallCheck(this, PoPToken);\n\n    return _possibleConstructorReturn(this, (PoPToken.__proto__ || Object.getPrototypeOf(PoPToken)).apply(this, arguments));\n  }\n\n  _createClass(PoPToken, null, [{\n    key: 'issueFor',\n\n    /**\n     * @param resourceServerUri {string} RS URI for which this token is intended\n     *\n     * @param session {Session}\n     * @param session.sessionKey {string}\n     * @param session.authorization.client_id {string}\n     * @param session.authorization.id_token {string}\n     *\n     * @returns {Promise<string>} PoPToken, encoded as compact JWT\n     */\n    value: function issueFor(resourceServerUri, session) {\n      if (!resourceServerUri) {\n        throw new Error('Cannot issue PoPToken - missing resource server URI');\n      }\n\n      if (!session.sessionKey) {\n        throw new Error('Cannot issue PoPToken - missing session key');\n      }\n\n      if (!session.authorization.id_token) {\n        throw new Error('Cannot issue PoPToken - missing id token');\n      }\n\n      var jwk = JSON.parse(session.sessionKey);\n\n      return JWK.importKey(jwk).then(function (importedSessionJwk) {\n        var options = {\n          aud: new URL(resourceServerUri).origin,\n          key: importedSessionJwk,\n          iss: session.authorization.client_id,\n          id_token: session.authorization.id_token\n        };\n\n        return PoPToken.issue(options);\n      }).then(function (jwt) {\n        return jwt.encode();\n      });\n    }\n\n    /**\n     * issue\n     *\n     * @param options {Object}\n     * @param options.iss {string} Token issuer (RP client_id)\n     * @param options.aud {string|Array<string>} Audience for the token\n     *   (such as the Resource Server url)\n     * @param options.key {JWK} Proof of Possession (private) signing key, see\n     *   https://tools.ietf.org/html/rfc7800#section-3.1\n     *\n     * @param options.id_token {string} JWT compact encoded ID Token\n     *\n     * Optional:\n     * @param [options.iat] {number} Issued at timestamp (in seconds)\n     * @param [options.max] {number} Max token lifetime in seconds\n     *\n     * @returns {PoPToken} Proof of Possession Token (JWT instance)\n     */\n\n  }, {\n    key: 'issue',\n    value: function issue(options) {\n      var aud = options.aud,\n          iss = options.iss,\n          key = options.key;\n\n\n      var alg = key.alg;\n      var iat = options.iat || Math.floor(Date.now() / 1000);\n      var max = options.max || DEFAULT_MAX_AGE;\n\n      var exp = iat + max; // token expiration\n\n      var header = { alg: alg };\n      var payload = { iss: iss, aud: aud, exp: exp, iat: iat, id_token: options.id_token, token_type: 'pop' };\n\n      var jwt = new PoPToken({ header: header, payload: payload, key: key.cryptoKey }, { filter: false });\n\n      return jwt;\n    }\n  }]);\n\n  return PoPToken;\n}(JWT);\n\nmodule.exports = PoPToken;","function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _util = require(\"./util\");\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nvar xxx = function xxx(key) {\n  return function (value) {\n    return `${key}=${value && !(0, _util.isToken)(value) ? (0, _util.quote)(value) : value}`;\n  };\n};\n\nvar build = function build(params) {\n  return params.reduce(function (prev, _ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        key = _ref2[0],\n        values = _ref2[1];\n\n    var transform = xxx(key);\n\n    if (!(0, _util.isToken)(key)) {\n      throw new TypeError();\n    }\n\n    if (Array.isArray(values)) {\n      return _toConsumableArray(prev).concat(_toConsumableArray(values.map(transform)));\n    }\n\n    return _toConsumableArray(prev).concat([transform(values)]);\n  }, []);\n};\n\nvar challenge = function challenge(params, options) {\n  if (Array.isArray(params)) {\n    return build(params);\n  } else if (typeof params === 'object') {\n    var entries = params;\n    return challenge(Object.keys(params).map(function (key) {\n      return [key, entries[key]];\n    }), options);\n  }\n\n  throw new TypeError();\n};\n\nvar _default = function _default(scheme, token, params) {\n  var obj = typeof scheme === 'string' ? {\n    scheme,\n    token,\n    params\n  } : scheme;\n\n  if (typeof obj !== 'object') {\n    throw new TypeError();\n  } else if (!(0, _util.isScheme)(obj.scheme)) {\n    throw new TypeError('Invalid scheme.');\n  }\n\n  return [obj.scheme].concat(_toConsumableArray(typeof obj.token !== 'undefined' ? [obj.token] : []), _toConsumableArray(typeof obj.params !== 'undefined' ? challenge(obj.params) : [])).join(' ');\n};\n\nexports.default = _default;\n//# sourceMappingURL=format.js.map","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _util = require(\"./util\");\n\n// lol dis\nvar body = /((?:[a-zA-Z0-9._~+\\/-]+=*(?:\\s+|$))|[^\\u0000-\\u001F\\u007F()<>@,;:\\\\\"/?={}\\[\\]\\u0020\\u0009]+)(?:=([^\\\\\"=\\s,]+|\"(?:[^\"\\\\]|\\\\.)*\"))?/g; // eslint-disable-line\n\nvar normalize = function normalize(prev, _cur) {\n  // Fixup quoted strings and tokens with spaces around them\n  var cur = _cur.charAt(0) === '\"' ? (0, _util.unquote)(_cur) : _cur.trim(); // Marshal\n\n  if (Array.isArray(prev)) {\n    return prev.concat(cur);\n  } else if (typeof prev === 'string') {\n    return [prev, cur];\n  }\n\n  return cur;\n};\n\nvar parseProperties = function parseProperties(scheme, string) {\n  var token = null;\n  var params = {}; // eslint-disable-next-line no-constant-condition\n\n  while (true) {\n    var res = body.exec(string);\n\n    if (res === null) {\n      break;\n    }\n\n    if (res[2]) {\n      params[res[1]] = normalize(params[res[1]], res[2]);\n    } else {\n      token = normalize(token, res[1]);\n    }\n  }\n\n  return {\n    scheme,\n    params,\n    token\n  };\n};\n\nvar _default = function _default(str) {\n  if (typeof str !== 'string') {\n    throw new TypeError('Header value must be a string.');\n  }\n\n  var start = str.indexOf(' ');\n  var scheme = str.substr(0, start);\n\n  if (!(0, _util.isScheme)(scheme)) {\n    throw new TypeError(`Invalid scheme ${scheme}`);\n  }\n\n  return parseProperties(scheme, str.substr(start));\n};\n\nexports.default = _default;\n//# sourceMappingURL=parse.js.map","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\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\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","'use strict';\n\n/**\n * Module dependencies\n * @ignore\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar JSONPatch = require('./JSONPatch');\n\n/**\n * JSONDocument\n *\n * @class\n * JSONDocument is a high level interface that binds together all other features of\n * this package and provides the principle method of data modeling.\n */\n\nvar JSONDocument = function () {\n  _createClass(JSONDocument, null, [{\n    key: 'schema',\n\n\n    /**\n     * Schema\n     */\n    get: function get() {\n      throw new Error('Schema must be defined by classes extending JSONDocument');\n    }\n\n    /**\n     * Constructor\n     *\n     * @param {Object} data\n     * @param {Object} options\n     */\n\n  }]);\n\n  function JSONDocument() {\n    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    _classCallCheck(this, JSONDocument);\n\n    this.initialize(data, options);\n  }\n\n  /**\n   * Initialize\n   *\n   * @param {Object} data\n   * @param {Object} options\n   */\n\n\n  _createClass(JSONDocument, [{\n    key: 'initialize',\n    value: function initialize() {\n      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var schema = this.constructor.schema;\n\n      schema.initialize(this, data, options);\n    }\n\n    /**\n     * Validate\n     *\n     * @param {JSONSchema} alternate - OPTIONAL alternate schema\n     * @returns {Object}\n     */\n\n  }, {\n    key: 'validate',\n    value: function validate(alternate) {\n      var schema = this.constructor.schema;\n\n      return (alternate || schema).validate(this);\n    }\n\n    /**\n     * Patch\n     *\n     * @param {Array} ops\n     */\n\n  }, {\n    key: 'patch',\n    value: function patch(ops) {\n      var patch = new JSONPatch(ops);\n      patch.apply(this);\n    }\n\n    /**\n     * Select\n     */\n\n  }, {\n    key: 'select',\n    value: function select() {}\n\n    /**\n     * Project\n     *\n     * @description\n     * Given a mapping, return an object projected from the current instance.\n     *\n     * @example\n     * let schema = new JSONSchema({\n     *   properties: {\n     *     foo: { type: 'Array' }\n     *   }\n     * })\n     *\n     * let mapping = new JSONMapping({\n     *   '/foo/0': '/bar/baz'\n     * })\n     *\n     * class FooTracker extends JSONDocument {\n     *   static get schema () { return schema }\n     * }\n     *\n     * let instance = new FooTracker({ foo: ['qux'] })\n     * instance.project(mapping)\n     * // => { bar: { baz: 'qux' } }\n     *\n     * @param {JSONMapping} mapping\n     * @return {Object}\n     */\n\n  }, {\n    key: 'project',\n    value: function project(mapping) {\n      return mapping.project(this);\n    }\n\n    /**\n     * Serialize\n     *\n     * @param {Object} object\n     * @returns {string}\n     */\n\n  }], [{\n    key: 'serialize',\n    value: function serialize(object) {\n      return JSON.stringify(object);\n    }\n\n    /**\n     * Deserialize\n     *\n     * @param {string} data\n     * @return {*}\n     */\n\n  }, {\n    key: 'deserialize',\n    value: function deserialize(data) {\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        throw new Error('Failed to parse JSON');\n      }\n    }\n  }]);\n\n  return JSONDocument;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = JSONDocument;","'use strict';\n\n/**\n * Module dependencies\n * @ignore\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar JSONPointer = require('./JSONPointer');\n\n/**\n * JSONPointer mode\n */\nvar RECOVER = 1;\n\n/**\n * JSONMapping\n *\n * @class\n * Defines a means to declaratively translate between object\n * representations using JSON Pointer syntax.\n */\n\nvar JSONMapping = function () {\n\n  /**\n   * Constructor\n   *\n   * @description Translate pointers from JSON Strings into Pointer objects\n   * @param {Object} mapping\n   */\n  function JSONMapping(mapping) {\n    var _this = this;\n\n    _classCallCheck(this, JSONMapping);\n\n    Object.defineProperty(this, 'mapping', {\n      enumerable: false,\n      value: new Map()\n    });\n\n    Object.keys(mapping).forEach(function (key) {\n      var value = mapping[key];\n      _this.mapping.set(new JSONPointer(key, RECOVER), new JSONPointer(value, RECOVER));\n    });\n  }\n\n  /**\n   * Map\n   *\n   * @description Assign values from source to target by reading the mapping\n   * from right to left.\n   * @param {Object} target\n   * @param {Object} source\n   */\n\n\n  _createClass(JSONMapping, [{\n    key: 'map',\n    value: function map(target, source) {\n      this.mapping.forEach(function (right, left) {\n        left.add(target, right.get(source));\n      });\n    }\n\n    /**\n     * Project\n     *\n     * @description Assign values from source to target by reading the mapping\n     * from left to right.\n     * @param {Object} source\n     * @param {Object} target\n     */\n\n  }, {\n    key: 'project',\n    value: function project(source, target) {\n      this.mapping.forEach(function (right, left) {\n        right.add(target, left.get(source));\n      });\n    }\n  }]);\n\n  return JSONMapping;\n}();\n\n/**\n * Exports\n */\n\n\nmodule.exports = JSONMapping;","'use strict';\n\n/**\n * Module dependencies\n * @ignore\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Initializer = require('./Initializer');\nvar Validator = require('./Validator');\n\n/**\n * JSONSchema\n *\n * @class\n * Compiles JSON Schema documents to an object with object initialization\n * and validation methods.\n */\n\nvar JSONSchema = function () {\n\n  /**\n   * Constructor\n   *\n   * @param {Object} schema\n   */\n  function JSONSchema(schema) {\n    _classCallCheck(this, JSONSchema);\n\n    // TODO: optionally parse JSON string?\n    Object.assign(this, schema);\n\n    // add schema-derived initialize and validate methods\n    Object.defineProperties(this, {\n      initialize: {\n        enumerable: false,\n        writeable: false,\n        value: Initializer.compile(schema)\n      },\n      validate: {\n        enumerable: false,\n        writeable: false,\n        value: Validator.compile(schema)\n      }\n    });\n  }\n\n  /**\n   * Extend\n   *\n   * @description\n   * ...\n   * Dear future,\n   *\n   * This function was meticulously plagiarized from some curious amalgam of\n   * stackoverflow posts whilst dozing off at my keyboard, too deprived of REM-\n   * sleep to recurse unassisted. If it sucks, you have only yourself to blame.\n   *\n   * Goodnight.\n   *\n   * @param {Object} schema\n   * @returns {JSONSchema}\n   */\n\n\n  _createClass(JSONSchema, [{\n    key: 'extend',\n    value: function extend(schema) {\n      function isObject(data) {\n        return data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && data !== null && !Array.isArray(data);\n      }\n\n      function extender(target, source) {\n        var result = Object.assign({}, target);\n        if (isObject(target) && isObject(source)) {\n          Object.keys(source).forEach(function (key) {\n            if (isObject(source[key])) {\n              if (!(key in target)) {\n                Object.assign(result, _defineProperty({}, key, source[key]));\n              } else {\n                result[key] = extender(target[key], source[key]);\n              }\n            } else {\n              Object.assign(result, _defineProperty({}, key, source[key]));\n            }\n          });\n        }\n        return result;\n      }\n\n      var descriptor = extender(this, schema);\n      return new JSONSchema(descriptor);\n    }\n  }]);\n\n  return JSONSchema;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = JSONSchema;","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar pad_string_1 = require(\"./pad-string\");\nfunction encode(input, encoding) {\n    if (encoding === void 0) { encoding = \"utf8\"; }\n    if (Buffer.isBuffer(input)) {\n        return fromBase64(input.toString(\"base64\"));\n    }\n    return fromBase64(Buffer.from(input, encoding).toString(\"base64\"));\n}\n;\nfunction decode(base64url, encoding) {\n    if (encoding === void 0) { encoding = \"utf8\"; }\n    return Buffer.from(toBase64(base64url), \"base64\").toString(encoding);\n}\nfunction toBase64(base64url) {\n    base64url = base64url.toString();\n    return pad_string_1.default(base64url)\n        .replace(/\\-/g, \"+\")\n        .replace(/_/g, \"/\");\n}\nfunction fromBase64(base64) {\n    return base64\n        .replace(/=/g, \"\")\n        .replace(/\\+/g, \"-\")\n        .replace(/\\//g, \"_\");\n}\nfunction toBuffer(base64url) {\n    return Buffer.from(toBase64(base64url), \"base64\");\n}\nvar base64url = encode;\nbase64url.encode = encode;\nbase64url.decode = decode;\nbase64url.toBase64 = toBase64;\nbase64url.fromBase64 = fromBase64;\nbase64url.toBuffer = toBuffer;\nexports.default = base64url;\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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction padString(input) {\n    var segmentLength = 4;\n    var stringLength = input.length;\n    var diff = stringLength % segmentLength;\n    if (!diff) {\n        return input;\n    }\n    var position = stringLength;\n    var padLength = segmentLength - diff;\n    var paddedStringLength = stringLength + padLength;\n    var buffer = Buffer.alloc(paddedStringLength);\n    buffer.write(input);\n    while (padLength--) {\n        buffer.write(\"=\", position++);\n    }\n    return buffer.toString();\n}\nexports.default = padString;\n","'use strict';\n\n/**\n * Local dependencies\n */\nvar None = require('./NONE');\nvar HMAC = require('./HMAC');\nvar RSASSA_PKCS1_v1_5 = require('./RSASSA-PKCS1-v1_5');\nvar SupportedAlgorithms = require('./SupportedAlgorithms');\n\n/**\n * Register Supported Algorithms\n */\nvar supportedAlgorithms = new SupportedAlgorithms();\n\n/**\n * Sign\n */\nsupportedAlgorithms.define('HS256', 'sign', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-256'\n  }\n}));\n\nsupportedAlgorithms.define('HS384', 'sign', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-384'\n  }\n}));\n\nsupportedAlgorithms.define('HS512', 'sign', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-512'\n  }\n}));\n\nsupportedAlgorithms.define('RS256', 'sign', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-256'\n  }\n}));\n\nsupportedAlgorithms.define('RS384', 'sign', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-384'\n  }\n}));\n\nsupportedAlgorithms.define('RS512', 'sign', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-512'\n  }\n}));\n//supportedAlgorithms.define('ES256', 'sign', {})\n//supportedAlgorithms.define('ES384', 'sign', {})\n//supportedAlgorithms.define('ES512', 'sign', {})\n//supportedAlgorithms.define('PS256', 'sign', {})\n//supportedAlgorithms.define('PS384', 'sign', {})\n//supportedAlgorithms.define('PS512', 'sign', {})\n\nsupportedAlgorithms.define('none', 'sign', new None({\n  // nothing goes here\n}));\n\n/**\n * Verify\n */\nsupportedAlgorithms.define('HS256', 'verify', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-256'\n  }\n}));\n\nsupportedAlgorithms.define('HS384', 'verify', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-384'\n  }\n}));\n\nsupportedAlgorithms.define('HS512', 'verify', new HMAC({\n  name: 'HMAC',\n  hash: {\n    name: 'SHA-512'\n  }\n}));\n\nsupportedAlgorithms.define('RS256', 'verify', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-256'\n  }\n}));\n\nsupportedAlgorithms.define('RS384', 'verify', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-384'\n  }\n}));\n\nsupportedAlgorithms.define('RS512', 'verify', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-512'\n  }\n}));\n//supportedAlgorithms.define('ES256', 'verify', {})\n//supportedAlgorithms.define('ES384', 'verify', {})\n//supportedAlgorithms.define('ES512', 'verify', {})\n//supportedAlgorithms.define('PS256', 'verify', {})\n//supportedAlgorithms.define('PS384', 'verify', {})\n//supportedAlgorithms.define('PS512', 'verify', {})\n\nsupportedAlgorithms.define('none', 'verify', new None({\n  // nothing goes here\n}));\n\nsupportedAlgorithms.define('RS256', 'importKey', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-256'\n  }\n}));\n\nsupportedAlgorithms.define('RS384', 'importKey', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-384'\n  }\n}));\n\nsupportedAlgorithms.define('RS512', 'importKey', new RSASSA_PKCS1_v1_5({\n  name: 'RSASSA-PKCS1-v1_5',\n  hash: {\n    name: 'SHA-512'\n  }\n}));\n\n/**\n * Export\n */\nmodule.exports = supportedAlgorithms;","'use strict';\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * None\n */\nvar None = function () {\n  function None() {\n    _classCallCheck(this, None);\n  }\n\n  _createClass(None, [{\n    key: 'sign',\n\n    /**\n     * sign\n     */\n    value: function sign() {\n      return Promise.resolve('');\n    }\n\n    /**\n     * verify\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify() {\n      // this will never get called. but you looked.\n    }\n  }]);\n\n  return None;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = None;","'use strict';\n\n/**\n * Dependencies\n * @ignore\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar base64url = require('base64url');\nvar crypto = require('@trust/webcrypto');\nvar TextEncoder = require('../text-encoder');\n\n/**\n * HMAC with SHA-2 Functions\n */\n\nvar HMAC = function () {\n\n  /**\n   * Constructor\n   *\n   * @param {string} bitlength\n   */\n  function HMAC(params) {\n    _classCallCheck(this, HMAC);\n\n    this.params = params;\n  }\n\n  /**\n   * Sign\n   *\n   * @description\n   * Generate a hash-based message authentication code for a\n   * given input and key. Enforce the key length is equal to\n   * or greater than the bitlength.\n   *\n   * @param {CryptoKey} key\n   * @param {string} data\n   *\n   * @returns {string}\n   */\n\n\n  _createClass(HMAC, [{\n    key: 'sign',\n    value: function sign(key, data) {\n      var algorithm = this.params;\n\n      // TODO: validate key length\n\n      data = new TextEncoder().encode(data);\n\n      return crypto.subtle.sign(algorithm, key, data).then(function (signature) {\n        return base64url(Buffer.from(signature));\n      });\n    }\n\n    /**\n     * Verify\n     *\n     * @description\n     * Verify a digital signature for a given input and private key.\n     *\n     * @param {CryptoKey} key\n     * @param {string} signature\n     * @param {string} data\n     *\n     * @returns {Boolean}\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify(key, signature, data) {\n      var algorithm = this.params;\n\n      if (typeof signature === 'string') {\n        signature = Uint8Array.from(base64url.toBuffer(signature));\n      }\n\n      if (typeof data === 'string') {\n        data = new TextEncoder().encode(data);\n      }\n\n      return crypto.subtle.verify(algorithm, key, signature, data);\n    }\n\n    /**\n     * Assert Sufficient Key Length\n     *\n     * @description Assert that the key length is sufficient\n     * @param {string} key\n     */\n\n  }, {\n    key: 'assertSufficientKeyLength',\n    value: function assertSufficientKeyLength(key) {\n      if (key.length < this.bitlength) {\n        throw new Error('The key is too short.');\n      }\n    }\n  }]);\n\n  return HMAC;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = HMAC;","module.exports = __WEBPACK_EXTERNAL_MODULE__56__;","'use strict';\n\n/**\n * Dependencies\n * @ignore\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar base64url = require('base64url');\nvar crypto = require('@trust/webcrypto');\nvar TextEncoder = require('../text-encoder');\n\n/**\n * RSASSA-PKCS1-v1_5\n */\n\nvar RSASSA_PKCS1_v1_5 = function () {\n\n  /**\n   * constructor\n   *\n   * @param {string} bitlength\n   */\n  function RSASSA_PKCS1_v1_5(params) {\n    _classCallCheck(this, RSASSA_PKCS1_v1_5);\n\n    this.params = params;\n  }\n\n  /**\n   * sign\n   *\n   * @description\n   * Generate a digital signature for a given input and private key.\n   *\n   * @param {CryptoKey} key\n   * @param {BufferSource} data\n   *\n   * @returns {Promise}\n   */\n\n\n  _createClass(RSASSA_PKCS1_v1_5, [{\n    key: 'sign',\n    value: function sign(key, data) {\n      var algorithm = this.params;\n\n      // TODO\n      //if (!this.sufficientKeySize()) {\n      //  return Promise.reject(\n      //    new Error(\n      //      'A key size of 2048 bits or larger must be used with RSASSA-PKCS1-v1_5'\n      //    )\n      //  )\n      //}\n\n      data = new TextEncoder().encode(data);\n\n      return crypto.subtle.sign(algorithm, key, data).then(function (signature) {\n        return base64url(Buffer.from(signature));\n      });\n    }\n\n    /**\n     * verify\n     *\n     * @description\n     * Verify a digital signature for a given input and private key.\n     *\n     * @param {CryptoKey} key\n     * @param {BufferSource} signature\n     * @param {BufferSource} data\n     *\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify(key, signature, data) {\n      var algorithm = this.params;\n\n      if (typeof signature === 'string') {\n        signature = Uint8Array.from(base64url.toBuffer(signature));\n      }\n\n      if (typeof data === 'string') {\n        data = new TextEncoder().encode(data);\n      }\n      // ...\n\n      return crypto.subtle.verify(algorithm, key, signature, data);\n    }\n\n    /**\n     * importKey\n     *\n     * @param {JWK} key\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'importKey',\n    value: function importKey(key) {\n      var jwk = Object.assign({}, key);\n      var algorithm = this.params;\n      var usages = key['key_ops'] || [];\n\n      if (key.use === 'sig') {\n        usages.push('verify');\n      }\n\n      if (key.use === 'enc') {\n        // TODO: handle encryption keys\n        return Promise.resolve(key);\n      }\n\n      if (key.key_ops) {\n        usages = key.key_ops;\n      }\n\n      return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages).then(function (cryptoKey) {\n        Object.defineProperty(jwk, 'cryptoKey', {\n          enumerable: false,\n          value: cryptoKey\n        });\n\n        return jwk;\n      });\n    }\n  }]);\n\n  return RSASSA_PKCS1_v1_5;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = RSASSA_PKCS1_v1_5;","'use strict';\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Dependencies\n */\nvar NotSupportedError = require('../errors/NotSupportedError');\n\n/**\n * Operations\n */\nvar operations = ['sign', 'verify', 'encrypt', 'decrypt', 'importKey'];\n\n/**\n * SupportedAlgorithms\n */\n\nvar SupportedAlgorithms = function () {\n\n  /**\n   * constructor\n   */\n  function SupportedAlgorithms() {\n    var _this = this;\n\n    _classCallCheck(this, SupportedAlgorithms);\n\n    operations.forEach(function (op) {\n      _this[op] = {};\n    });\n  }\n\n  /**\n   * Supported Operations\n   */\n\n\n  _createClass(SupportedAlgorithms, [{\n    key: 'define',\n\n\n    /**\n     * define\n     *\n     * @description\n     * Register Web Crypto API algorithm parameter for an algorithm\n     * and operation.\n     *\n     * @param {string} alg\n     * @param {string} op\n     * @param {Object} argument\n     */\n    value: function define(alg, op, argument) {\n      var registeredAlgorithms = this[op];\n      registeredAlgorithms[alg] = argument;\n    }\n\n    /**\n     * normalize\n     *\n     * @description\n     * Map JWA alg name to Web Crypto API algorithm parameter\n     *\n     * @param {string} op\n     * @param {Object} alg\n     *\n     * @returns {Object}\n     */\n\n  }, {\n    key: 'normalize',\n    value: function normalize(op, alg) {\n      var registeredAlgorithms = this[op];\n\n      if (!registeredAlgorithms) {\n        return new SyntaxError(); // what kind of error should this be?\n      }\n\n      var argument = registeredAlgorithms[alg];\n\n      if (!argument) {\n        return new NotSupportedError(alg);\n      }\n\n      return argument;\n    }\n  }], [{\n    key: 'operations',\n    get: function get() {\n      return operations;\n    }\n  }]);\n\n  return SupportedAlgorithms;\n}();\n\n/**\n * Export\n */\n\n\nmodule.exports = SupportedAlgorithms;","'use strict';\n\n/**\n * Package dependencies\n */\nvar _require = require('@trust/json-document'),\n    Formats = _require.Formats;\n\n/**\n * Format extensions\n */\n\n\nFormats.register('StringOrURI', new RegExp());\nFormats.register('NumericDate', new RegExp());\nFormats.register('URI', new RegExp());\nFormats.register('url', new RegExp());\nFormats.register('base64', new RegExp());\nFormats.register('base64url', new RegExp());\nFormats.register('MediaType', new RegExp());","'use strict';\n\n/**\n * Dependencies\n */\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _require = require('@trust/json-document'),\n    JSONDocument = _require.JSONDocument;\n\nvar JWKSetSchema = require('../schemas/JWKSetSchema');\nvar JWK = require('./JWK');\n\n/**\n * JWKSet\n *\n * @class\n * JWKSet represents a JSON Web Key Set as described in Section 5 of RFC 7517:\n * https://tools.ietf.org/html/rfc7517#section-5\n */\n\nvar JWKSet = function (_JSONDocument) {\n  _inherits(JWKSet, _JSONDocument);\n\n  function JWKSet() {\n    _classCallCheck(this, JWKSet);\n\n    return _possibleConstructorReturn(this, (JWKSet.__proto__ || Object.getPrototypeOf(JWKSet)).apply(this, arguments));\n  }\n\n  _createClass(JWKSet, null, [{\n    key: 'importKeys',\n\n\n    /**\n     * importKeys\n     */\n    value: function importKeys(jwks) {\n      var validation = this.schema.validate(jwks);\n\n      if (!validation.valid) {\n        return Promise.reject(new Error('Invalid JWKSet: ' + JSON.stringify(validation, null, 2)));\n      }\n\n      if (!jwks.keys) {\n        return Promise.reject(new Error('Cannot import JWKSet: keys property is empty'));\n      }\n\n      var imported = void 0,\n          importing = void 0;\n\n      try {\n        imported = new JWKSet(jwks);\n        importing = jwks.keys.map(function (key) {\n          return JWK.importKey(key);\n        });\n      } catch (err) {\n        return Promise.reject(err);\n      }\n\n      return Promise.all(importing).then(function (keys) {\n        imported.keys = keys;\n        return imported;\n      });\n    }\n  }, {\n    key: 'schema',\n\n\n    /**\n     * schema\n     */\n    get: function get() {\n      return JWKSetSchema;\n    }\n  }]);\n\n  return JWKSet;\n}(JSONDocument);\n\n/**\n * Export\n */\n\n\nmodule.exports = JWKSet;","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Dependencies\n */\nvar base64url = require('base64url');\n\nvar _require = require('@trust/json-document'),\n    JSONDocument = _require.JSONDocument;\n\nvar JWTSchema = require('../schemas/JWTSchema');\nvar JWS = require('./JWS');\nvar DataError = require('../errors/DataError');\n\n/**\n * JWT\n */\n\nvar JWT = function (_JSONDocument) {\n  _inherits(JWT, _JSONDocument);\n\n  function JWT() {\n    _classCallCheck(this, JWT);\n\n    return _possibleConstructorReturn(this, (JWT.__proto__ || Object.getPrototypeOf(JWT)).apply(this, arguments));\n  }\n\n  _createClass(JWT, [{\n    key: 'isJWE',\n\n\n    /**\n     * isJWE\n     */\n    value: function isJWE() {\n      return !!this.header.enc;\n    }\n\n    /**\n     * resolveKeys\n     */\n\n  }, {\n    key: 'resolveKeys',\n    value: function resolveKeys(jwks) {\n      var kid = this.header.kid;\n      var keys = void 0,\n          match = void 0;\n\n      // treat an array as the \"keys\" property of a JWK Set\n      if (Array.isArray(jwks)) {\n        keys = jwks;\n      }\n\n      // presence of keys indicates object is a JWK Set\n      if (jwks.keys) {\n        keys = jwks.keys;\n      }\n\n      // wrap a plain object they is not a JWK Set in Array\n      if (!jwks.keys && (typeof jwks === 'undefined' ? 'undefined' : _typeof(jwks)) === 'object') {\n        keys = [jwks];\n      }\n\n      // ensure there are keys to search\n      if (!keys) {\n        throw new DataError('Invalid JWK argument');\n      }\n\n      // match by \"kid\" or \"use\" header\n      if (kid) {\n        match = keys.find(function (jwk) {\n          return jwk.kid === kid;\n        });\n      } else {\n        match = keys.find(function (jwk) {\n          return jwk.use === 'sig';\n        });\n      }\n\n      // assign matching key to JWT and return a boolean\n      if (match) {\n        this.key = match.cryptoKey;\n        return true;\n      } else {\n        return false;\n      }\n    }\n\n    /**\n     * encode\n     *\n     * @description\n     * Encode a JWT instance\n     *\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'encode',\n    value: function encode() {\n      // validate\n      var validation = this.validate();\n\n      if (!validation.valid) {\n        return Promise.reject(validation);\n      }\n\n      var token = this;\n\n      if (this.isJWE()) {\n        return JWE.encrypt(token);\n      } else {\n        return JWS.sign(token);\n      }\n    }\n\n    /**\n     * verify\n     *\n     * @description\n     * Verify a decoded JWT instance\n     *\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify() {\n      var validation = this.validate();\n\n      if (!validation.valid) {\n        return Promise.reject(validation);\n      }\n\n      return JWS.verify(this);\n    }\n  }], [{\n    key: 'decode',\n\n\n    /**\n     * decode\n     *\n     * @description\n     * Decode a JSON Web Token\n     *\n     * @param {string} data\n     * @returns {JWT}\n     */\n    value: function decode(data) {\n      var ExtendedJWT = this;\n      var jwt = void 0;\n\n      if (typeof data !== 'string') {\n        throw new DataError('JWT must be a string');\n      }\n\n      // JSON of Flattened JSON Serialization\n      if (data.startsWith('{')) {\n        try {\n          data = JSON.parse(data, function () {});\n        } catch (error) {\n          throw new DataError('Invalid JWT serialization');\n        }\n\n        if (data.signatures || data.recipients) {\n          data.serialization = 'json';\n        } else {\n          data.serialization = 'flattened';\n        }\n\n        jwt = new ExtendedJWT(data, { filter: false });\n\n        // Compact Serialization\n      } else {\n        try {\n          var serialization = 'compact';\n          var segments = data.split('.');\n          var length = segments.length;\n\n          if (length !== 3 && length !== 5) {\n            throw new Error('Malformed JWT');\n          }\n\n          var header = JSON.parse(base64url.decode(segments[0]));\n\n          // JSON Web Signature\n          if (length === 3) {\n            var type = 'JWS';\n            var payload = JSON.parse(base64url.decode(segments[1]));\n            var signature = segments[2];\n\n            jwt = new ExtendedJWT({ type: type, segments: segments, header: header, payload: payload, signature: signature, serialization: serialization }, { filter: false });\n          }\n\n          // JSON Web Encryption\n          if (length === 5) {\n            //let type = 'JWE'\n            //let [protected, encryption_key, iv, ciphertext, tag] = segments\n\n            //jwt = new ExtendedJWT({\n            //  type,\n            //  protected: base64url.decode(JSON.parse(protected)),\n            //  encryption_key,\n            //  iv,\n            //  ciphertext,\n            //  tag,\n            //  serialization\n            //})\n          }\n        } catch (error) {\n          throw new DataError('Invalid JWT compact serialization');\n        }\n      }\n\n      return jwt;\n    }\n\n    /**\n     * encode\n     *\n     * @description\n     * Encode a JSON Web Token\n     *\n     * @param {Object} header\n     * @param {Object} payload\n     * @param {CryptoKey} key\n     *\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'encode',\n    value: function encode(header, payload, key) {\n      var jwt = new JWT(header, payload);\n      return jwt.encode(key);\n    }\n\n    /**\n     * verify\n     *\n     * @description\n     *\n     * @param {CryptoKey} key\n     * @param {string} token\n     *\n     * @returns {Promise}\n     */\n\n  }, {\n    key: 'verify',\n    value: function verify(key, token) {\n      var jwt = JWT.decode(token);\n      jwt.key = key;\n      return jwt.verify().then(function (verified) {\n        return jwt;\n      });\n    }\n  }, {\n    key: 'schema',\n\n\n    /**\n     * schema\n     */\n    get: function get() {\n      return JWTSchema;\n    }\n  }]);\n\n  return JWT;\n}(JSONDocument);\n\n/**\n * Export\n */\n\n\nmodule.exports = JWT;","/**\n * Dependencies\n */\nconst assert = require('assert')\nconst base64url = require('base64url')\nconst crypto = require('@trust/webcrypto')\nconst { JWT } = require('@solid/jose')\nconst FormUrlEncoded = require('./FormUrlEncoded')\nconst { URL } = require('whatwg-url')\n\n/**\n * Authentication Request\n */\nclass AuthenticationRequest {\n  /**\n   * create\n   *\n   * @description\n   * Create a new authentication request with generated state and nonce,\n   * validate presence of required parameters, serialize the request data and\n   * persist it to the session, and return a promise for an authentication\n   * request URI.\n   *\n   * @param {RelyingParty} rp – instance of RelyingParty\n   * @param {Object} options - optional request parameters\n   * @param {Object} session – reference to localStorage or other session object\n   *\n   * @returns {Promise}\n   */\n  static create (rp, options, session) {\n    const {provider, defaults, registration} = rp\n\n    let issuer, endpoint, client, params\n\n    return Promise.resolve()\n      .then(() => {\n        // validate presence of OP configuration, RP client registration,\n        // and default parameters\n        assert(provider.configuration,\n          'RelyingParty provider OpenID Configuration is missing')\n\n        assert(defaults.authenticate,\n          'RelyingParty default authentication parameters are missing')\n\n        assert(registration,\n          'RelyingParty client registration is missing')\n\n        // define basic elements of the request\n        issuer = provider.configuration.issuer\n        endpoint = provider.configuration.authorization_endpoint\n        client = { client_id: registration.client_id}\n        params = Object.assign(defaults.authenticate, client, options)\n\n        // validate presence of required configuration and parameters\n        assert(issuer,\n          'Missing issuer in provider OpenID Configuration')\n\n        assert(endpoint,\n          'Missing authorization_endpoint in provider OpenID Configuration')\n\n        assert(params.scope,\n          'Missing scope parameter in authentication request')\n\n        assert(params.response_type,\n          'Missing response_type parameter in authentication request')\n\n        assert(params.client_id,\n          'Missing client_id parameter in authentication request')\n\n        assert(params.redirect_uri,\n          'Missing redirect_uri parameter in authentication request')\n\n        // generate state and nonce random octets\n        params.state = Array.from(crypto.getRandomValues(new Uint8Array(16)))\n        params.nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)))\n\n        // hash the state and nonce parameter values\n        return Promise.all([\n          crypto.subtle.digest({ name: 'SHA-256' }, new Uint8Array(params.state)),\n          crypto.subtle.digest({ name: 'SHA-256' }, new Uint8Array(params.nonce))\n        ])\n      })\n\n      // serialize the request with original values, store in session by\n      // encoded state param, and replace state/nonce octets with encoded\n      // digests\n      .then(digests => {\n        let state = base64url(Buffer.from(digests[0]))\n        let nonce = base64url(Buffer.from(digests[1]))\n        let key = `${issuer}/requestHistory/${state}`\n\n        // store the request params for response validation\n        // with serialized octet values for state and nonce\n        session[key] = JSON.stringify(params)\n\n        // replace state and nonce octets with base64url encoded digests\n        params.state = state\n        params.nonce = nonce\n      })\n\n      .then(() => AuthenticationRequest.generateSessionKeys())\n\n      .then(sessionKeys => {\n        AuthenticationRequest.storeSessionKeys(sessionKeys, params, session)\n      })\n\n      // optionally encode a JWT with the request parameters\n      // and replace params with `{ request: <jwt> }\n      .then(() => {\n        if (provider.configuration.request_parameter_supported) {\n          return AuthenticationRequest.encodeRequestParams(params)\n\n            .then(encodedParams => { params = encodedParams })\n        }\n      })\n\n      // render the request URI and terminate the algorithm\n      .then(() => {\n        let url = new URL(endpoint)\n        url.search = FormUrlEncoded.encode(params)\n\n        return url.href\n      })\n  }\n\n  static generateSessionKeys () {\n    return crypto.subtle.generateKey(\n      {\n        name: \"RSASSA-PKCS1-v1_5\",\n        modulusLength: 2048,\n        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\n        hash: { name: \"SHA-256\" },\n      },\n      true,\n      [\"sign\", \"verify\"]\n    )\n      .then((keyPair) => {\n        // returns a keypair object\n        return Promise.all([\n          crypto.subtle.exportKey('jwk', keyPair.publicKey),\n          crypto.subtle.exportKey('jwk', keyPair.privateKey)\n        ])\n      })\n      .then(jwkPair => {\n        let [ publicJwk, privateJwk ] = jwkPair\n\n        return { public: publicJwk, private: privateJwk }\n      })\n  }\n\n  static storeSessionKeys (sessionKeys, params, session) {\n    // store the private one in session, public one goes into params\n    session['oidc.session.privateKey'] = JSON.stringify(sessionKeys.private)\n    params.key = sessionKeys.public\n  }\n\n  static encodeRequestParams (params) {\n    const excludeParams = ['scope', 'client_id', 'response_type', 'state']\n\n    const keysToEncode = Object.keys(params).filter(key => !excludeParams.includes(key))\n\n    let payload = {}\n\n    keysToEncode.forEach(key => {\n      payload[key] = params[key]\n    })\n\n    let requestParamJwt = new JWT({\n      header: { alg: 'none' },\n      payload\n    }, { filter: false })\n\n    return requestParamJwt.encode()\n      .then(requestParamCompact => {\n        let newParams = {\n          scope: params['scope'],\n          client_id: params['client_id'],\n          response_type: params['response_type'],\n          request: requestParamCompact,\n          state: params['state']\n        }\n\n        return newParams\n      })\n  }\n}\n\n/**\n * Export\n */\nmodule.exports = AuthenticationRequest\n","/**\n * Dependencies\n */\nconst { URL } = require('whatwg-url')\nconst assert = require('assert')\nconst crypto = require('@trust/webcrypto')\nconst base64url = require('base64url')\nconst fetch = require('node-fetch')\nconst Headers = fetch.Headers ? fetch.Headers : global.Headers\nconst FormUrlEncoded = require('./FormUrlEncoded')\nconst IDToken = require('./IDToken')\nconst Session = require('./Session')\nconst onHttpError = require('./onHttpError')\nconst HttpError = require('standard-http-error')\n\n/**\n * AuthenticationResponse\n */\nclass AuthenticationResponse {\n  /**\n   * @param rp {RelyingParty}\n   * @param [redirect] {string} req.query\n   * @param [body] {string} req.body.text\n   * @param session {Session|Storage} req.session or localStorage or similar\n   * @param params {object} hashmap\n   * @param mode {string} 'query'/'fragment'/'form_post',\n   *   determined in `parseResponse()`\n   */\n  constructor ({rp, redirect, body, session, mode, params = {}}) {\n    this.rp = rp\n    this.redirect = redirect\n    this.body = body\n    this.session = session\n    this.mode = mode\n    this.params = params\n  }\n\n  /**\n   * validateResponse\n   *\n   * @description\n   * Authentication response validation.\n   *\n   * @param {string|Object} response\n   *\n   * @returns {Promise<Session>}\n   */\n  static validateResponse (response) {\n    return Promise.resolve(response)\n      .then(this.parseResponse)\n      .then(this.errorResponse)\n      .then(this.matchRequest)\n      .then(this.validateStateParam)\n      .then(this.validateResponseMode)\n      .then(this.validateResponseParams)\n      .then(this.exchangeAuthorizationCode)\n      .then(this.validateIDToken)\n      .then(Session.fromAuthResponse)\n  }\n\n  /**\n   * parseResponse\n   *\n   * @param {object} response\n   *\n   * @returns {object}\n   */\n  static parseResponse (response) {\n    let {redirect, body} = response\n\n    // response must be either a redirect uri or request body, but not both\n    if ((redirect && body) || (!redirect && !body)) {\n      throw new HttpError(400, 'Invalid response mode')\n    }\n\n    // parse redirect uri\n    if (redirect) {\n      let url = new URL(redirect)\n      let {search, hash} = url\n\n      if ((search && hash) || (!search && !hash)) {\n        throw new HttpError(400, 'Invalid response mode')\n      }\n\n      if (search) {\n        response.params = FormUrlEncoded.decode(search.substring(1))\n        response.mode = 'query'\n      }\n\n      if (hash) {\n        response.params = FormUrlEncoded.decode(hash.substring(1))\n        response.mode = 'fragment'\n      }\n    }\n\n    // parse request form body\n    if (body) {\n      response.params = FormUrlEncoded.decode(body)\n      response.mode = 'form_post'\n    }\n\n    return response\n  }\n\n  /**\n   * errorResponse\n   *\n   * @param {AuthenticationResponse} response\n   *\n   * @throws {Error} If response params include the OAuth2 'error' param,\n   *   throws an error based on it.\n   *\n   * @returns {AuthenticationResponse} Chainable\n   *\n   * @todo Figure out HTTP status code (typically 400, 401 or 403)\n   *   based on the OAuth2/OIDC `error` code, probably using an external library\n   */\n  static errorResponse (response) {\n    const errorCode = response.params.error\n\n    if (errorCode) {\n      const errorParams = {}\n      errorParams['error'] = errorCode\n      errorParams['error_description'] = response.params['error_description']\n      errorParams['error_uri'] = response.params['error_uri']\n      errorParams['state'] = response.params['state']\n\n      const error = new Error(`AuthenticationResponse error: ${errorCode}`)\n      error.info = errorParams\n      throw error\n    }\n\n    return response\n  }\n\n  /**\n   * matchRequest\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static matchRequest (response) {\n    let {rp, params, session} = response\n    let state = params.state\n    let issuer = rp.provider.configuration.issuer\n\n    if (!state) {\n      throw new Error(\n        'Missing state parameter in authentication response')\n    }\n\n    let key = `${issuer}/requestHistory/${state}`\n    let request = session[key]\n\n    if (!request) {\n      throw new Error(\n        'Mismatching state parameter in authentication response')\n    }\n\n    response.request = JSON.parse(request)\n    return response\n  }\n\n  /**\n   * validateStateParam\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateStateParam (response) {\n    let octets = new Uint8Array(response.request.state)\n    let encoded = response.params.state\n\n    return crypto.subtle.digest({ name: 'SHA-256' }, octets).then(digest => {\n      if (encoded !== base64url(Buffer.from(digest))) {\n        throw new Error(\n          'Mismatching state parameter in authentication response')\n      }\n\n      return response\n    })\n  }\n\n  /**\n   * validateResponseMode\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateResponseMode (response) {\n    if (response.request.response_type !== 'code' && response.mode === 'query') {\n      throw new Error('Invalid response mode')\n    }\n\n    return response\n  }\n\n  /**\n   * validateResponseParams\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateResponseParams (response) {\n    let {request, params} = response\n    let expectedParams = request.response_type.split(' ')\n\n    if (expectedParams.includes('code')) {\n      assert(params.code,\n        'Missing authorization code in authentication response')\n      // TODO assert novelty of code\n    }\n\n    if (expectedParams.includes('id_token')) {\n      assert(params.id_token,\n        'Missing id_token in authentication response')\n    }\n\n    if (expectedParams.includes('token')) {\n      assert(params.access_token,\n        'Missing access_token in authentication response')\n\n      assert(params.token_type,\n        'Missing token_type in authentication response')\n    }\n\n    return response\n  }\n\n  /**\n   * exchangeAuthorizationCode\n   *\n   * @param {Object} response\n   * @returns {Promise} response object\n   */\n  static exchangeAuthorizationCode (response) {\n    let {rp, params, request} = response\n    let code = params.code\n\n    // only exchange the authorization code when the response type is \"code\"\n    if (!code || request['response_type'] !== 'code') {\n      return Promise.resolve(response)\n    }\n\n    let {provider, registration} = rp\n    let id = registration['client_id']\n    let secret = registration['client_secret']\n\n    // verify the client is not public\n    if (!secret) {\n        return Promise.reject(new Error(\n          'Client cannot exchange authorization code because ' +\n          'it is not a confidential client'))\n    }\n\n    // initialize token request arguments\n    let endpoint = provider.configuration.token_endpoint\n    let method = 'POST'\n\n    // initialize headers\n    let headers = new Headers({\n      'Content-Type': 'application/x-www-form-urlencoded'\n    })\n\n    // initialize the token request parameters\n    let bodyContents = {\n      'grant_type': 'authorization_code',\n      'code': code,\n      'redirect_uri': request['redirect_uri']\n    }\n\n    // determine client authentication method\n    let authMethod = registration['token_endpoint_auth_method']\n      || 'client_secret_basic'\n\n    // client secret basic authentication\n    if (authMethod === 'client_secret_basic') {\n      let credentials = new Buffer(`${id}:${secret}`).toString('base64')\n      headers.set('Authorization', `Basic ${credentials}`)\n    }\n\n    // client secret post authentication\n    if (authMethod === 'client_secret_post') {\n      bodyContents['client_id'] = id\n      bodyContents['client_secret'] = secret\n    }\n\n    let body = FormUrlEncoded.encode(bodyContents)\n\n    // TODO\n    // client_secret_jwt authentication\n    // private_key_jwt\n\n    // make the token request\n\n    return fetch(endpoint, {method, headers, body})\n      .then(onHttpError('Error exchanging authorization code'))\n      .then(tokenResponse => tokenResponse.json())\n      .then(tokenResponse => {\n        assert(tokenResponse['access_token'],\n          'Missing access_token in token response')\n\n        assert(tokenResponse['token_type'],\n          'Missing token_type in token response')\n\n        assert(tokenResponse['id_token'],\n          'Missing id_token in token response')\n\n        // anything else?\n\n        // IS THIS THE RIGHT THING TO DO HERE?\n        response.params = Object.assign(response.params, tokenResponse)\n        return response\n      })\n  }\n\n\n  /**\n   * validateIDToken\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateIDToken (response) {\n    // only validate the ID Token if present in the response\n    if (!response.params.id_token) {\n      return Promise.resolve(response)\n    }\n\n    return Promise.resolve(response)\n      .then(AuthenticationResponse.decryptIDToken)\n      .then(AuthenticationResponse.decodeIDToken)\n      .then(AuthenticationResponse.validateIssuer)\n      .then(AuthenticationResponse.validateAudience)\n      .then(AuthenticationResponse.resolveKeys)\n      .then(AuthenticationResponse.verifySignature)\n      .then(AuthenticationResponse.validateExpires)\n      .then(AuthenticationResponse.verifyNonce)\n      .then(AuthenticationResponse.validateAcr)\n      .then(AuthenticationResponse.validateAuthTime)\n      .then(AuthenticationResponse.validateAccessTokenHash)\n      .then(AuthenticationResponse.validateAuthorizationCodeHash)\n  }\n\n  /**\n   * decryptIDToken\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static decryptIDToken (response) {\n    // TODO\n    return Promise.resolve(response)\n  }\n\n  /**\n   * decodeIDToken\n   *\n   * Note: If the `id_token` is not present in params, this method does not\n   * get called (short-circuited in `validateIDToken()`).\n   *\n   * @param response {AuthenticationResponse}\n   * @param response.params {object}\n   * @param [response.params.id_token] {string} IDToken encoded as a JWT\n   *\n   * @returns {AuthenticationResponse} Chainable\n   */\n  static decodeIDToken (response) {\n    let jwt = response.params.id_token\n\n    try {\n      response.decoded = IDToken.decode(jwt)\n    } catch (decodeError) {\n      const error = new HttpError(400, 'Error decoding ID Token')\n      error.cause = decodeError\n      error.info = { id_token: jwt }\n      throw error\n    }\n\n    return response\n  }\n\n\n  /**\n   * validateIssuer\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateIssuer (response) {\n    let configuration = response.rp.provider.configuration\n    let payload = response.decoded.payload\n\n    // validate issuer of token matches this relying party's provider\n    if (payload.iss !== configuration.issuer) {\n      throw new Error('Mismatching issuer in ID Token')\n    }\n\n    return response\n  }\n\n  /**\n   * validateAudience\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateAudience (response) {\n    let registration = response.rp.registration\n    let {aud, azp} = response.decoded.payload\n\n    // validate audience includes this relying party\n    if (typeof aud === 'string' && aud !== registration['client_id']) {\n      throw new Error('Mismatching audience in id_token')\n    }\n\n    // validate audience includes this relying party\n    if (Array.isArray(aud) && !aud.includes(registration['client_id'])) {\n      throw new Error('Mismatching audience in id_token')\n    }\n\n    // validate authorized party is present if required\n    if (Array.isArray(aud) && !azp) {\n      throw new Error('Missing azp claim in id_token')\n    }\n\n    // validate authorized party is this relying party\n    if (azp && azp !== registration['client_id']) {\n      throw new Error('Mismatching azp claim in id_token')\n    }\n\n    return response\n  }\n\n\n  /**\n   * resolveKeys\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static resolveKeys (response) {\n    let rp = response.rp\n    let provider = rp.provider\n    let decoded = response.decoded\n\n    return Promise.resolve(provider.jwks)\n\n      .then(jwks => jwks ? jwks : rp.jwks())\n\n      .then(jwks => {\n        if (decoded.resolveKeys(jwks)) {\n          return Promise.resolve(response)\n        } else {\n          throw new Error('Cannot resolve signing key for ID Token')\n        }\n      })\n  }\n\n  /**\n   * verifySignature\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static verifySignature (response) {\n    let alg = response.decoded.header.alg\n    let registration = response.rp.registration\n    let expectedAlgorithm = registration['id_token_signed_response_alg'] || 'RS256'\n\n    // validate signing algorithm matches expectation\n    if (alg !== expectedAlgorithm) {\n      throw new Error(\n        `Expected ID Token to be signed with ${expectedAlgorithm}`)\n    }\n\n    return response.decoded.verify().then(verified => {\n      if (!verified) {\n        throw new Error('Invalid ID Token signature')\n      }\n\n      return response\n    })\n  }\n\n  /**\n   * validateExpires\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateExpires (response) {\n    let exp = response.decoded.payload.exp\n\n    // validate expiration of token\n    if (exp <= Math.floor(Date.now() / 1000)) {\n      throw new Error('Expired ID Token')\n    }\n\n    return response\n  }\n\n  /**\n   * verifyNonce\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static verifyNonce (response) {\n    let octets = new Uint8Array(response.request.nonce)\n    let nonce = response.decoded.payload.nonce\n\n    if (!nonce) {\n      throw new Error('Missing nonce in ID Token')\n    }\n\n    return crypto.subtle.digest({ name: 'SHA-256' }, octets).then(digest => {\n      if (nonce !== base64url(Buffer.from(digest))) {\n        throw new Error('Mismatching nonce in ID Token')\n      }\n\n      return response\n    })\n  }\n\n  /**\n   * validateAcr\n   *\n   * @param {Object} response\n   * @returns {Object}\n   */\n  static validateAcr (response) {\n    // TODO\n    return response\n  }\n\n  /**\n   * validateAuthTime\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateAuthTime (response) {\n    // TODO\n    return response\n  }\n\n  /**\n   * validateAccessTokenHash\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateAccessTokenHash (response) {\n    // TODO\n    return response\n  }\n\n  /**\n   * validateAuthorizationCodeHash\n   *\n   * @param {Object} response\n   * @returns {Promise}\n   */\n  static validateAuthorizationCodeHash (response) {\n    // TODO\n    return response\n  }\n}\n\n/**\n * Export\n */\nmodule.exports = AuthenticationResponse\n","/**\n * Local dependencies\n */\nconst {JWT} = require('@solid/jose')\nconst IDTokenSchema = require('./IDTokenSchema')\n\n/**\n * IDToken\n */\nclass IDToken extends JWT {\n\n  /**\n   * Schema\n   */\n  static get schema () {\n    return IDTokenSchema\n  }\n}\n\n/**\n * Export\n */\nmodule.exports = IDToken\n","/**\n * Local dependencies\n */\nconst {JWTSchema} = require('@solid/jose')\n\n/**\n * IDToken Schema\n */\nconst IDTokenSchema = JWTSchema.extend({\n  properties: {\n\n    /**\n     * header\n     * http://openid.net/specs/openid-connect-core-1_0.html#IDToken\n     * ID Tokens SHOULD NOT use the JWS or JWE x5u, x5c, jku, or jwk Header\n     * Parameter fields. Instead, references to keys used are communicated in\n     * advance using Discovery and Registration parameters, per Section 10.\n     */\n    header: {\n      //not: { required: ['x5u', 'x5c', 'jku', 'jwk'] }\n    },\n\n    /**\n     * payload\n     */\n    payload: {\n      properties: {\n\n        /**\n         * iss\n         *\n         * REQUIRED. Issuer Identifier for the Issuer of the response.\n         * The iss value is a case sensitive URL using the https scheme\n         * that contains scheme, host, and optionally, port number and\n         * path components and no query or fragment components.\n         */\n        iss: { type: 'string', format: 'url' },\n\n        /**\n         * sub\n         *\n         * REQUIRED. Subject Identifier. A locally unique and never\n         * reassigned identifier within the Issuer for the End-User, which\n         * is intended to be consumed by the Client, e.g., 24400320 or\n         * AItOawmwtWwcT0k51BayewNvutrJUqsvl6qs7A4. It MUST NOT exceed 255\n         * ASCII characters in length. The sub value is a case sensitive\n         * string.\n         */\n        sub: { type: 'string', maxLength: 255 },\n\n        /**\n         * aud\n         *\n         * REQUIRED. Audience(s) that this ID Token is intended for. It\n         * MUST contain the OAuth 2.0 client_id of the Relying Party as an\n         * audience value. It MAY also contain identifiers for other audiences.\n         * In the general case, the aud value is an array of case sensitive\n         * strings. In the common special case when there is one audience,\n         * the aud value MAY be a single case sensitive string.\n         */\n        // inherited from JWTClaimsSetSchema\n\n        /**\n         * exp\n         *\n         * REQUIRED. Expiration time on or after which the ID Token MUST NOT\n         * be accepted for processing. The processing of this parameter\n         * requires that the current date/time MUST be before the expiration\n         * date/time listed in the value. Implementers MAY provide for some\n         * small leeway, usually no more than a few minutes, to account for\n         * clock skew. Its value is a JSON number representing the number of\n         * seconds from 1970-01-01T0:0:0Z as measured in UTC until the\n         * date/time. See RFC 3339 [RFC3339] for details regarding date/times\n         * in general and UTC in particular.\n         */\n        // inherited from JWTClaimsSetSchema\n\n        /**\n         * iat\n         *\n         * REQUIRED. Time at which the JWT was issued. Its value is a\n         * JSON number representing the number of seconds from\n         * 1970-01-01T0:0:0Z as measured in UTC until the date/time.\n         */\n        // inherited from JWTClaimsSetSchema\n\n        /**\n         * auth_time\n         *\n         * Time when the End-User authentication occurred. Its value is a\n         * JSON number representing the number of seconds from\n         * 1970-01-01T0:0:0Z as measured in UTC until the date/time. When a\n         * max_age request is made or when auth_time is requested as an\n         * Essential Claim, then this Claim is REQUIRED; otherwise, its\n         * inclusion is OPTIONAL. (The auth_time Claim semantically\n         * corresponds to the OpenID 2.0 PAPE [OpenID.PAPE] auth_time\n         * response parameter.)\n         */\n        auth_time: { type: 'integer', format: 'NumericDate' },\n\n        /**\n         * nonce\n         *\n         * String value used to associate a Client session with an ID Token,\n         * and to mitigate replay attacks. The value is passed through\n         * unmodified from the Authentication Request to the ID Token. If\n         * present in the ID Token, Clients MUST verify that the nonce Claim\n         * Value is equal to the value of the nonce parameter sent in the\n         * Authentication Request. If present in the Authentication Request,\n         * Authorization Servers MUST include a nonce Claim in the ID Token\n         * with the Claim Value being the nonce value sent in the\n         * Authentication Request. Authorization Servers SHOULD perform no\n         * other processing on nonce values used. The nonce value is a case\n         * sensitive string.\n         */\n        nonce: { type: 'string' },\n\n        /**\n         * acr\n         *\n         * OPTIONAL. Authentication Context Class Reference. String\n         * specifying an Authentication Context Class Reference value that\n         * identifies the Authentication Context Class that the authentication\n         * performed satisfied. The value \"0\" indicates the End-User\n         * authentication did not meet the requirements of ISO/IEC 29115\n         * [ISO29115] level 1. Authentication using a long-lived browser\n         * cookie, for instance, is one example where the use of \"level 0\" is\n         * appropriate. Authentications with level 0 SHOULD NOT be used to\n         * authorize access to any resource of any monetary value. (This\n         * corresponds to the OpenID 2.0 PAPE [OpenID.PAPE] nist_auth_level\n         * 0.) An absolute URI or an RFC 6711 [RFC6711] registered name\n         * SHOULD be used as the acr value; registered names MUST NOT be used\n         * with a different meaning than that which is registered. Parties\n         * using this claim will need to agree upon the meanings of the\n         * values used, which may be context-specific. The acr value is a\n         * case sensitive string.\n         */\n        acr: { type: 'string' },\n\n        /**\n         * amr\n         * OPTIONAL. Authentication Methods References. JSON array of strings\n         * that are identifiers for authentication methods used in the\n         * authentication. For instance, values might indicate that both\n         * password and OTP authentication methods were used. The definition\n         * of particular values to be used in the amr Claim is beyond the\n         * scope of this specification. Parties using this claim will need to\n         * agree upon the meanings of the values used, which may be context-\n         * specific. The amr value is an array of case sensitive strings.\n         */\n        amr: { type: 'array', items: { type: 'string' } },\n\n        /**\n         * azp\n         * OPTIONAL. Authorized party - the party to which the ID Token was\n         * issued. If present, it MUST contain the OAuth 2.0 Client ID of this\n         * party. This Claim is only needed when the ID Token has a single\n         * audience value and that audience is different than the authorized\n         * party. It MAY be included even when the authorized party is the\n         * same as the sole audience. The azp value is a case sensitive string\n         * containing a StringOrURI value.\n         */\n        azp: { type: 'string', format: 'StringOrURI' }\n      },\n\n      /**\n       * Required Claims\n       */\n      required: ['iss', 'sub', 'aud', 'exp', 'iat']\n    }\n  }\n})\n\n/**\n * Export\n */\nmodule.exports = IDTokenSchema\n","'use strict'\n\nconst fetch = require('node-fetch')\nconst onHttpError = require('./onHttpError')\nconst PoPToken = require('./PoPToken')\n\nclass Session {\n  /**\n   * @param options {Object}\n   *\n   * @param options.credentialType {string} 'access_token' or 'pop_token'\n   *\n   * @param options.issuer {string} Identity provider (issuer of ID/Access Token)\n   *\n   * @param options.authorization {object}\n   * @param options.authorization.client_id {string} OIDC/OAuth2 client id\n   * @param [options.authorization.id_token] {string} Compact-serialized id_token param\n   * @param [options.authorization.access_token] {string} Compact-serialized access_token param\n   * @param [options.authorization.refresh_token] {string} Compact-serialized refresh_token\n   *\n   * @param [options.sessionKey] {string} Serialized client session key generated\n   *   during the Authentication Request, used to issue PoPTokens\n   *\n   * @param [options.idClaims] {object} Decoded/verified ID Token JWT payload\n   *\n   * @param [options.accessClaims] {object} Decoded/verified Access Token JWT payload\n   */\n  constructor (options) {\n    this.credentialType = options.credentialType || 'access_token'\n\n    this.issuer = options.issuer\n\n    this.authorization = options.authorization || {}\n\n    this.sessionKey = options.sessionKey\n\n    this.idClaims = options.idClaims\n    this.accessClaims = options.accessClaims\n  }\n\n  static from (options) {\n    return new Session(options)\n  }\n\n  /**\n   * @param response {AuthenticationResponse}\n   *\n   * @returns {Session} RelyingParty Session object\n   */\n  static fromAuthResponse (response) {\n    const RelyingParty = require('./RelyingParty')  // import here due to circular dep\n\n    let idClaims = response.decoded && response.decoded.payload || {}\n\n    let { rp } = response\n\n    let registration = rp.registration\n    let rpAuthOptions = rp.defaults.authenticate || {}\n\n    let credentialType = rpAuthOptions['credential_type'] ||\n      rp.defaults.popToken ? 'pop_token' : 'access_token'\n\n    let sessionKey = response.session[RelyingParty.SESSION_PRIVATE_KEY]\n\n    let options = {\n      credentialType,\n      sessionKey,\n      issuer: idClaims.iss,\n      idClaims,\n      authorization: {\n        client_id: registration['client_id'],\n        access_token: response.params['access_token'],\n        id_token: response.params['id_token'],\n        refresh_token: response.params['refresh_token']\n      }\n    }\n\n    return Session.from(options)\n  }\n\n  /**\n   * Authenticated fetch() getter\n   *\n   * @returns {function}\n   */\n  get fetch () {\n    /**\n     * fetch() function signature\n     *\n     * @param url {RequestInfo|string}\n     * @param options {object}\n     *\n     * @returns {Function<Promise<Response>>}\n     */\n    return (url, options) => {\n      return Promise.resolve()\n\n        .then(() => {\n          if (this.hasCredentials()) {\n            return this.fetchWithCredentials(url, options)\n          } else {\n            return fetch(url, options)\n          }\n        })\n\n        .then(onHttpError('Error while fetching resource'))\n    }\n  }\n\n  /**\n   * bearerTokenFor\n   *\n   * @param url {string}\n   *\n   * @returns {Promise<string>}\n   */\n  bearerTokenFor (url) {\n    switch (this.credentialType) {\n      case 'pop_token':\n        return PoPToken.issueFor(url, this)\n\n      default:  // 'access_token' etc\n        return Promise.resolve(this.authorization[this.credentialType])\n    }\n  }\n\n  /**\n   * hasCredentials\n   *\n   * @returns {boolean}\n   */\n  hasCredentials () {\n    switch (this.credentialType) {\n      case 'pop_token':\n        return !!this.authorization['id_token']\n\n      default:  // 'access_token' etc\n        return !!this.authorization[this.credentialType]\n    }\n  }\n\n  /**\n   * fetchWithCredentials\n   *\n   * @param url {RequestInfo|string}\n   * @param options {object}\n   *\n   * @returns {Promise<Response>}\n   */\n  fetchWithCredentials (url, options = {}) {\n    options.headers = options.headers || {}\n\n    return this.bearerTokenFor(url)\n\n      .then(token => {\n        options.headers.authorization = `Bearer ${token}`\n\n        return fetch(url, options)\n      })\n  }\n}\n\nmodule.exports = Session\n","'use strict'\n\nconst { URL } = require('whatwg-url')\nconst {JWT, JWK} = require('@solid/jose')\n\nconst DEFAULT_MAX_AGE = 3600  // Default token expiration, in seconds\n\nclass PoPToken extends JWT {\n  /**\n   * @param resourceServerUri {string} RS URI for which this token is intended\n   *\n   * @param session {Session}\n   * @param session.sessionKey {string}\n   * @param session.authorization.client_id {string}\n   * @param session.authorization.id_token {string}\n   *\n   * @returns {Promise<string>} PoPToken, encoded as compact JWT\n   */\n  static issueFor (resourceServerUri, session) {\n    if (!resourceServerUri) {\n      throw new Error('Cannot issue PoPToken - missing resource server URI')\n    }\n\n    if (!session.sessionKey) {\n      throw new Error('Cannot issue PoPToken - missing session key')\n    }\n\n    if (!session.authorization.id_token) {\n      throw new Error('Cannot issue PoPToken - missing id token')\n    }\n\n    let jwk = JSON.parse(session.sessionKey)\n\n    return JWK.importKey(jwk)\n      .then(importedSessionJwk => {\n        let options = {\n          aud: (new URL(resourceServerUri)).origin,\n          key: importedSessionJwk,\n          iss: session.authorization.client_id,\n          id_token: session.authorization.id_token\n        }\n\n        return PoPToken.issue(options)\n      })\n      .then(jwt => {\n        return jwt.encode()\n      })\n  }\n\n  /**\n   * issue\n   *\n   * @param options {Object}\n   * @param options.iss {string} Token issuer (RP client_id)\n   * @param options.aud {string|Array<string>} Audience for the token\n   *   (such as the Resource Server url)\n   * @param options.key {JWK} Proof of Possession (private) signing key, see\n   *   https://tools.ietf.org/html/rfc7800#section-3.1\n   *\n   * @param options.id_token {string} JWT compact encoded ID Token\n   *\n   * Optional:\n   * @param [options.iat] {number} Issued at timestamp (in seconds)\n   * @param [options.max] {number} Max token lifetime in seconds\n   *\n   * @returns {PoPToken} Proof of Possession Token (JWT instance)\n   */\n  static issue (options) {\n    let { aud, iss, key } = options\n\n    let alg = key.alg\n    let iat = options.iat || Math.floor(Date.now() / 1000)\n    let max = options.max || DEFAULT_MAX_AGE\n\n    let exp = iat + max  // token expiration\n\n    let header = { alg }\n    let payload = { iss, aud, exp, iat, id_token: options.id_token, token_type: 'pop' }\n\n    let jwt = new PoPToken({ header, payload, key: key.cryptoKey }, { filter: false })\n\n    return jwt\n  }\n}\n\nmodule.exports = PoPToken\n","exports = module.exports = HttpError\nvar StandardError = require(\"standard-error\")\nvar STATUS_CODE_TO_NAME = require(\"./codes\")\nvar STATUS_NAME_TO_CODE = exports\n\nfunction HttpError(code, msg, props) {\n  if (typeof code == \"string\") code = STATUS_NAME_TO_CODE[code]\n  if (typeof code != \"number\") throw new TypeError(\"Non-numeric HTTP code\")\n  if (typeof msg == \"object\" && msg != null) { props = msg; msg = null }\n  StandardError.call(this, msg || STATUS_CODE_TO_NAME[code], props)\n  this.code = code\n}\n\nHttpError.prototype = Object.create(StandardError.prototype, {\n  constructor: {value: HttpError, configurable: true, writable: true}\n})\n\n// Set name explicitly for when the code gets minified.\nHttpError.prototype.name = \"HttpError\"\n\nObject.defineProperties(HttpError.prototype, {\n  statusCode: alias(\"code\"),\n  statusMessage: alias(\"message\"),\n\n  status: {\n    configurable: true,\n    get: function() { return this.code },\n    set: function(value) {\n      Object.defineProperty(this, \"status\", {\n        value: value, configurable: true, enumerable: true, writable: true\n      })\n    }\n  }\n})\n\nHttpError.prototype.toString = function() {\n  return this.name + \": \" + this.code + \" \" + this.message\n}\n\nfor (var code in STATUS_CODE_TO_NAME) {\n  var name = STATUS_CODE_TO_NAME[code]\n  exports[name.replace(\"'\", \"\").replace(/[- ]/g, \"_\").toUpperCase()] = +code\n}\n\nfunction alias(name) {\n  return {\n    configurable: true,\n    get: function() { return this[name] },\n    set: function(value) { return this[name] = value }\n  }\n}\n","var has = Object.hasOwnProperty\nvar proto = Object.getPrototypeOf\nvar trace = Error.captureStackTrace\nmodule.exports = StandardError\n\nfunction StandardError(msg, props) {\n  // Let all properties be enumerable for easier serialization.\n  if (msg && typeof msg == \"object\") props = msg, msg = undefined\n  else this.message = msg\n\n  // Name has to be an own property (or on the prototype a single step up) for\n  // the stack to be printed with the correct name.\n  if (props) for (var key in props) this[key] = props[key]\n  if (!has.call(this, \"name\"))\n    this.name = has.call(proto(this), \"name\")? this.name : this.constructor.name\n\n  if (trace && !(\"stack\" in this)) trace(this, this.constructor)\n}\n\nStandardError.prototype = Object.create(Error.prototype, {\n  constructor: {value: StandardError, configurable: true, writable: true}\n})\n\n// Set name explicitly for when the code gets minified.\nStandardError.prototype.name = \"StandardError\"\n","/**\n * Dependencies\n */\nconst {JSONSchema} = require('@trust/json-document')\n\n/**\n * RelyingParty Schema\n *\n * This schema initializes and verifies Relying Party client configuration.\n * RelyingParty objects can be persisted and rehydrated. By encapsulating this data in\n * it's own class, it's possible to have multiple RP configurations running\n * simultaneously.\n */\nconst RelyingPartySchema = new JSONSchema({\n  type: 'object',\n  properties: {\n\n    /**\n     * provider\n     *\n     * Information about the provider, including issuer URL, human readable name,\n     * and any configuration or provider metadata retrieved from the OP.\n     */\n    provider: {\n      type: 'object',\n      properties: {\n        name: { type: 'string' },\n        url: { type: 'string', format: 'uri' },\n        // NOTE:\n        // OpenID Configuration (discovery response) and JSON Web Keys Set for an\n        // issuer can be cached here. However the cache should not be persisted or\n        // relied upon.\n        //\n        configuration: {}, // .well-known/openid-configuration\n        jwks: {}           // /jwks\n      },\n      required: ['url']\n    },\n\n    /**\n     * defaults\n     *\n     * Default request parameters for authentication and dynamic registration requests.\n     * These values can be extended or overridden via arguments to the respective\n     * request methods.\n     *\n     * These are part of the relying party client configuration and can be serialized\n     * and persisted.\n     */\n    defaults: {\n      type: 'object',\n      properties: {\n\n        /**\n         * Use Proof of Possession token semantics for the ID Token\n         */\n        popToken: {\n          type: 'boolean',\n          default: false\n        },\n\n        /**\n         * Default authentication request parameters\n         */\n        authenticate: {\n          type: 'object',\n          properties: {\n            redirect_uri: {\n              type: 'string',\n              format: 'uri'\n            },\n            response_type: {\n              type: 'string',\n              default: 'id_token token', // browser detection\n              enum: [\n                'code',\n                'token',\n                'id_token token',\n                'id_token token code'\n              ]\n            },\n            display: {\n              type: 'string',\n              default: 'page',\n              enum: [\n                'page',\n                'popup'\n              ]\n            },\n            scope: {\n              type: ['string', 'array'],\n              default: ['openid']\n            }\n          }\n        },\n\n        /**\n         * Default client registration parameters\n         */\n        register: {}\n      }\n    },\n\n    /**\n     * registration\n     *\n     * This is the client registration response from dynamic registration. It should\n     * always reflect the client configuration on the openid provider. A client access\n     * token is stored here\n     */\n    registration: {},// ClientMetadataSchema\n\n    /**\n     * store\n     */\n    store: {\n      type: 'object',\n      default: {}\n    }\n  }\n})\n\n/**\n * Export\n */\nmodule.exports = RelyingPartySchema\n","// @flow\n/* eslint-env browser */\n\nfunction getLocation() {\n  return typeof window !== 'undefined'\n    ? window.location\n    : { href: 'https://example.org/', pathname: '/', origin: 'example.org' }\n}\n\nexport const currentUrl = (): string => getLocation().href\n\nexport const currentUrlNoParams = (): string =>\n  getLocation().origin + getLocation().pathname\n\nexport const navigateTo = (url: string) => {\n  getLocation().href = url\n}\n\nexport const originOf = (url: string): string => new URL(url).origin\n\nexport const toUrlString = (url: any): string => {\n  if (typeof url !== 'string') {\n    url = 'url' in url ? url.url : url.toString()\n  }\n  return new URL(url, currentUrl()).toString()\n}\n","// @flow\n\n/*\n  This module describes a simple IPC interface for communicating between browser windows.\n  window.postMessage() is the transport interface, and a request/response interface\n  is defined on top of it as follows:\n\n  const request = {\n    'solid-auth-client': {\n      id: 1234,\n      method: 'doSomethingPlease',\n      args: [ 'one', 'two', 'three' ]\n    }\n  }\n\n  const response = {\n    'solid-auth-client': {\n      id: 1234,\n      ret: 'the_value'\n    }\n  }\n*/\n\ntype handler = (string, ...args: any[]) => ?Promise<any>\n\nconst NAMESPACE = 'solid-auth-client'\n\n/**\n * Receives and handles remote procedure calls.\n */\nexport class Server {\n  _clientWindow: window\n  _clientOrigin: string\n  _handler: handler\n  _messageListener: MessageEvent => Promise<void>\n\n  constructor(clientWindow: window, clientOrigin: string, handle: handler) {\n    this._clientWindow = clientWindow\n    this._clientOrigin = clientOrigin\n    this._handler = handle\n    this._messageListener = event => this._handleMessage(event)\n  }\n\n  async _handleMessage({ data, origin }: MessageEvent) {\n    // Ensure we can post to the origin\n    if (origin !== this._clientOrigin) {\n      console.warn(\n        `solid-auth-client is listening to ${this._clientOrigin} ` +\n          `so ignored a message received from ${origin}.`\n      )\n      return\n    }\n\n    // Parse the request and send it to the handler\n    const req = data && (data: any)[NAMESPACE]\n    if (req && req.method) {\n      const { id, method, args } = (req: any)\n      const ret = await this._handler(method, ...args)\n      this._clientWindow.postMessage(\n        { [NAMESPACE]: { id, ret } },\n        this._clientOrigin\n      )\n    }\n  }\n\n  start() {\n    window.addEventListener('message', this._messageListener)\n  }\n\n  stop() {\n    window.removeEventListener('message', this._messageListener)\n  }\n}\n\n/**\n * Makes remote procedure calls.\n */\nexport class Client {\n  _serverWindow: window\n  _serverOrigin: string\n\n  constructor(serverWindow: window, serverOrigin: string) {\n    this._serverWindow = serverWindow\n    this._serverOrigin = serverOrigin\n  }\n\n  request(method: string, ...args: any[]): Promise<any> {\n    // Send the request as a message to the server window\n    const id = Math.random()\n    this._serverWindow.postMessage(\n      { [NAMESPACE]: { id, method, args } },\n      this._serverOrigin\n    )\n\n    // Create a promise that resolves to the request's return value\n    return new Promise((resolve, reject) => {\n      // Listen for responses to the request\n      window.addEventListener('message', responseListener)\n\n      // Cancel if the response takes too long\n      const timeout = setTimeout(() => {\n        reject(new Error('Could not connect to main window.'))\n        window.removeEventListener('message', responseListener)\n      }, 2000)\n\n      // Processes a possible response to the request\n      function responseListener({ data }) {\n        const resp = data && data[NAMESPACE]\n        if (resp && resp.id === id && resp.hasOwnProperty('ret')) {\n          resolve(resp.ret)\n          clearTimeout(timeout)\n          window.removeEventListener('message', responseListener)\n        }\n      }\n    })\n  }\n}\n","// @flow\nimport { Client } from './ipc'\n\nexport const NAMESPACE = 'solid-auth-client'\n\nexport interface AsyncStorage {\n  getItem(key: string): Promise<?string>;\n  setItem(key: string, val: string): Promise<void>;\n  removeItem(key: string): Promise<void>;\n}\n\nexport type Storage = Storage | AsyncStorage\n\nexport const defaultStorage = () => {\n  const hasLocalStorage =\n    typeof window !== 'undefined' && 'localStorage' in window\n  return asyncStorage(hasLocalStorage ? window.localStorage : memStorage())\n}\n\n/**\n * Gets the deserialized stored data\n */\nexport async function getData(store: Storage): Promise<Object> {\n  let serialized\n  let data\n  try {\n    serialized = await store.getItem(NAMESPACE)\n    data = JSON.parse(serialized || '{}')\n  } catch (e) {\n    console.warn('Could not deserialize data:', serialized)\n    console.error(e)\n    data = {}\n  }\n  return data\n}\n\n/**\n * Updates a Storage object without mutating its intermediate representation.\n */\nexport async function updateStorage(\n  store: Storage,\n  update: Object => Object\n): Promise<Object> {\n  const currentData = await getData(store)\n  const newData = update(currentData)\n  await store.setItem(NAMESPACE, JSON.stringify(newData))\n  return newData\n}\n\n/**\n * Takes a synchronous storage interface and wraps it with an async interface.\n */\nexport function asyncStorage(storage: Storage): AsyncStorage {\n  return {\n    getItem: (key: string): Promise<?string> => {\n      return Promise.resolve(storage.getItem(key))\n    },\n\n    setItem: (key: string, val: string): Promise<void> => {\n      return Promise.resolve(storage.setItem(key, val))\n    },\n\n    removeItem: (key: string): Promise<void> => {\n      return Promise.resolve(storage.removeItem(key))\n    }\n  }\n}\n\nexport const memStorage = (): Storage => {\n  const store = {}\n  return {\n    getItem: (key: string): ?string => {\n      if (typeof store[key] === 'undefined') return null\n      return store[key]\n    },\n    setItem: (key: string, val: string): void => {\n      store[key] = val\n    },\n    removeItem: (key: string): void => {\n      delete store[key]\n    }\n  }\n}\n\nexport function ipcStorage(client: Client): AsyncStorage {\n  return {\n    getItem: (key: string): Promise<?string> =>\n      client.request('storage/getItem', key),\n\n    setItem: (key: string, val: string): Promise<void> =>\n      client.request('storage/setItem', key, val),\n\n    removeItem: (key: string): Promise<void> =>\n      client.request('storage/removeItem', key)\n  }\n}\n","// @flow\n\nimport type { AsyncStorage } from './storage'\nimport { getData, updateStorage } from './storage'\n\nexport type webIdOidcSession = {\n  idp: string,\n  webId: string,\n  accessToken: string,\n  idToken: string,\n  clientId: string,\n  sessionKey: string\n}\n\nexport type Session = webIdOidcSession\n\nexport async function getSession(storage: AsyncStorage): Promise<?Session> {\n  const data = await getData(storage)\n  return data.session || null\n}\n\nexport function saveSession(\n  storage: AsyncStorage\n): (session: Session) => Promise<Session> {\n  return async session => {\n    const data = await updateStorage(storage, data => ({ ...data, session }))\n    return data.session\n  }\n}\n\nexport async function clearSession(storage: AsyncStorage): Promise<void> {\n  await updateStorage(storage, data => ({ ...data, session: null }))\n}\n","// @flow\n/* global Response */\nimport * as authorization from 'auth-header'\nimport RelyingParty from '@solid/oidc-rp'\nimport PoPToken from '@solid/oidc-rp/lib/PoPToken'\n\nimport type { loginOptions } from './solid-auth-client'\nimport { currentUrl, navigateTo, toUrlString } from './url-util'\nimport type { webIdOidcSession } from './session'\nimport type { AsyncStorage } from './storage'\nimport { defaultStorage, getData, updateStorage } from './storage'\n\nexport async function login(\n  idp: string,\n  options: loginOptions\n): Promise<?null> {\n  try {\n    const rp = await getRegisteredRp(idp, options)\n    await saveAppHashFragment(options.storage)\n    return sendAuthRequest(rp, options)\n  } catch (err) {\n    console.warn('Error logging in with WebID-OIDC')\n    console.error(err)\n    return null\n  }\n}\n\nexport async function currentSession(\n  storage: AsyncStorage = defaultStorage()\n): Promise<?webIdOidcSession> {\n  try {\n    // Obtain the Relying Party\n    const rp = await getStoredRp(storage)\n    if (!rp) {\n      return null\n    }\n\n    // Obtain and clear the OIDC URL fragment\n    const url = currentUrl()\n    if (!/#(.*&)?access_token=/.test(url)) {\n      return null\n    }\n    window.location.hash = ''\n    await restoreAppHashFragment(storage)\n\n    // Obtain a session from the Relying Party\n    const storeData = await getData(storage)\n    const session = await rp.validateResponse(url, storeData)\n    if (!session) {\n      return null\n    }\n    return {\n      ...session,\n      webId: session.idClaims.sub,\n      idp: session.issuer\n    }\n  } catch (err) {\n    console.warn('Error finding a WebID-OIDC session')\n    console.error(err)\n    return null\n  }\n}\n\nexport async function logout(\n  storage: AsyncStorage,\n  fetch: Function\n): Promise<void> {\n  const rp = await getStoredRp(storage)\n  if (rp) {\n    try {\n      // First log out from the IDP\n      await rp.logout()\n      // Then, log out from the RP\n      try {\n        await fetch('/.well-known/solid/logout', { credentials: 'include' })\n      } catch (e) {\n        // Ignore errors for when we are not on a Solid pod\n      }\n    } catch (err) {\n      console.warn('Error logging out of the WebID-OIDC session')\n      console.error(err)\n    }\n  }\n}\n\nexport async function getRegisteredRp(\n  idp: string,\n  options: loginOptions\n): Promise<RelyingParty> {\n  // To reuse a possible previous RP,\n  // it be for the same IDP and redirect URI\n  let rp = await getStoredRp(options.storage)\n  if (\n    !rp ||\n    rp.provider.url !== idp ||\n    !rp.registration.redirect_uris.includes(options.callbackUri)\n  ) {\n    // Register a new RP\n    rp = await registerRp(idp, options)\n    await storeRp(options.storage, idp, rp)\n  }\n  return rp\n}\n\nasync function getStoredRp(storage: AsyncStorage): Promise<?RelyingParty> {\n  const data = await getData(storage)\n  const { rpConfig } = data\n  if (rpConfig) {\n    rpConfig.store = storage\n    return RelyingParty.from(rpConfig)\n  } else {\n    return null\n  }\n}\n\nasync function storeRp(\n  storage: AsyncStorage,\n  idp: string,\n  rp: RelyingParty\n): Promise<RelyingParty> {\n  await updateStorage(storage, data => ({\n    ...data,\n    rpConfig: rp\n  }))\n  return rp\n}\n\nfunction registerRp(idp: string, opts: loginOptions): Promise<RelyingParty> {\n  const { storage, callbackUri } = opts\n  const responseType = 'id_token token'\n\n  const clientNameI18n = {}\n  Object.entries(opts)\n    .filter(([key, _]) => key.startsWith('clientName#'))\n    .forEach(\n      ([key, value]) =>\n        (clientNameI18n[key.replace('clientName#', 'client_name#')] = value)\n    )\n\n  const supplementaryOptions = {\n    logo_uri: opts.logoUri,\n    contacts: opts.contacts,\n    client_name: opts.clientName\n  }\n\n  const registration = {\n    issuer: idp,\n    grant_types: ['implicit'],\n    redirect_uris: [callbackUri],\n    response_types: [responseType],\n    scope: 'openid profile',\n    ...clientNameI18n,\n    ...supplementaryOptions\n  }\n\n  const options = {\n    defaults: {\n      authenticate: {\n        redirect_uri: callbackUri,\n        response_type: responseType\n      }\n    },\n    store: storage\n  }\n\n  return RelyingParty.register(idp, registration, options)\n}\n\nasync function sendAuthRequest(\n  rp: RelyingParty,\n  { callbackUri, storage }: loginOptions\n): Promise<void> {\n  const data = await getData(storage)\n  const url = await rp.createRequest({ redirect_uri: callbackUri }, data)\n  await updateStorage(storage, () => data)\n  return navigateTo(url)\n}\n\nasync function saveAppHashFragment(store: AsyncStorage): Promise<void> {\n  await updateStorage(store, data => ({\n    ...data,\n    appHashFragment: window.location.hash\n  }))\n}\n\nasync function restoreAppHashFragment(store: AsyncStorage): Promise<void> {\n  await updateStorage(store, ({ appHashFragment = '', ...data }) => {\n    window.location.hash = appHashFragment\n    return data\n  })\n}\n\n/**\n * Answers whether a HTTP response requires WebID-OIDC authentication.\n */\nexport function requiresAuth(resp: Response): boolean {\n  if (resp.status !== 401) {\n    return false\n  }\n  const wwwAuthHeader = resp.headers.get('www-authenticate')\n  if (!wwwAuthHeader) {\n    return false\n  }\n  const auth = authorization.parse(wwwAuthHeader)\n  return (\n    auth.scheme === 'Bearer' &&\n    auth.params &&\n    auth.params.scope === 'openid webid'\n  )\n}\n\n/**\n * Fetches a resource, providing the WebID-OIDC ID Token as authentication.\n * Assumes that the resource has requested those tokens in a previous response.\n */\nexport async function fetchWithCredentials(\n  session: webIdOidcSession,\n  fetch: Function,\n  input: any,\n  options?: RequestOptions\n): Promise<Response> {\n  // Create a copy of the headers\n  const headers = {}\n  const origHeaders = options ? options.headers : input.headers\n  if (origHeaders) {\n    const entries =\n      typeof origHeaders.entries === 'function'\n        ? origHeaders.entries()\n        : Object.entries(origHeaders)\n    for (const [name, value] of entries) {\n      headers[name] = value\n    }\n  }\n\n  // Add Authorization header\n  const popToken = await PoPToken.issueFor(toUrlString(input), session)\n  headers.authorization = `Bearer ${popToken}`\n  return fetch(input, { ...options, credentials: 'include', headers })\n}\n","// @flow\n/* globalRequest, Response, URL */\nimport { getSession } from './session'\nimport type { AsyncStorage } from './storage'\nimport { getData, updateStorage } from './storage'\nimport * as WebIdOidc from './webid-oidc'\n\nexport type host = {\n  url: string,\n  requiresAuth: boolean\n}\n\nexport function getHost(storage: AsyncStorage): string => Promise<?host> {\n  return async url => {\n    const { host } = new URL(url)\n    const session = await getSession(storage)\n    if (session && host === new URL(session.idp).host) {\n      return { url: host, requiresAuth: true }\n    }\n    const { hosts } = await getData(storage)\n    return hosts && hosts[host]\n  }\n}\n\nexport function saveHost(storage: AsyncStorage): host => Promise<void> {\n  return async ({ url, requiresAuth }) => {\n    await updateStorage(storage, data => ({\n      ...data,\n      hosts: {\n        ...data.hosts,\n        [url]: { requiresAuth }\n      }\n    }))\n  }\n}\n\nexport function updateHostFromResponse(\n  storage: AsyncStorage\n): Response => Promise<void> {\n  return async resp => {\n    if (WebIdOidc.requiresAuth(resp)) {\n      const { host } = new URL(resp.url)\n      await saveHost(storage)({ url: host, requiresAuth: true })\n    }\n  }\n}\n","// @flow\nimport 'isomorphic-fetch'\n\nimport { toUrlString } from './url-util'\nimport { getHost, updateHostFromResponse } from './host'\nimport { getSession } from './session'\nimport type { AsyncStorage } from './storage'\nimport { fetchWithCredentials } from './webid-oidc'\n\nexport async function authnFetch(\n  storage: AsyncStorage,\n  fetch: Function,\n  input: RequestInfo,\n  options?: RequestOptions\n): Promise<Response> {\n  // If not authenticated, perform a regular fetch\n  const session = await getSession(storage)\n  if (!session) {\n    return fetch(input, options)\n  }\n\n  // If we know the server expects credentials, send them\n  if (await shouldShareCredentials(storage, input)) {\n    return fetchWithCredentials(session, fetch, input, options)\n  }\n\n  // If we don't know for sure, try a regular fetch first\n  let resp = await fetch(input, options)\n\n  // If the server then requests credentials, send them\n  if (resp.status === 401) {\n    await updateHostFromResponse(storage)(resp)\n    if (await shouldShareCredentials(storage, input)) {\n      resp = fetchWithCredentials(session, fetch, input, options)\n    }\n  }\n  return resp\n}\n\nasync function shouldShareCredentials(\n  storage: AsyncStorage,\n  input: RequestInfo\n): Promise<boolean> {\n  const requestHost = await getHost(storage)(toUrlString(input))\n  return requestHost != null && requestHost.requiresAuth\n}\n","// @flow\nimport type { loginOptions } from './solid-auth-client'\nimport { Server } from './ipc'\nimport type { Session } from './session'\nimport type { AsyncStorage } from './storage'\nimport { originOf } from './url-util'\n\nexport function openIdpPopup(popupUri: string): window {\n  const width = 650\n  const height = 400\n  const left = window.screenX + (window.innerWidth - width) / 2\n  const top = window.screenY + (window.innerHeight - height) / 2\n  const settings = `width=${width},height=${height},left=${left},top=${top}`\n  return window.open(popupUri, 'solid-auth-client', settings)\n}\n\nexport function obtainSession(\n  store: AsyncStorage,\n  popup: window,\n  options: loginOptions\n): Promise<?Session> {\n  return new Promise((resolve, reject) => {\n    const popupServer = new Server(\n      popup,\n      originOf(options.popupUri || ''),\n      popupHandler(store, options, (session: Session) => {\n        popupServer.stop()\n        resolve(session)\n      })\n    )\n    popupServer.start()\n  })\n}\n\nexport function popupHandler(\n  store: AsyncStorage,\n  { popupUri, callbackUri }: loginOptions,\n  foundSessionCb: Session => void\n) {\n  return async (method: string, ...args: any[]) => {\n    switch (method) {\n      // Origin\n      case 'getAppOrigin':\n        return window.location.origin\n\n      // Storage\n      case 'storage/getItem':\n        return store.getItem(...args)\n      case 'storage/setItem':\n        return store.setItem(...args)\n      case 'storage/removeItem':\n        return store.removeItem(...args)\n\n      // Login\n      case 'getLoginOptions':\n        return { popupUri, callbackUri }\n      case 'foundSession':\n        foundSessionCb(...args)\n    }\n  }\n}\n","// @flow\n/* global fetch */\nimport EventEmitter from 'events'\nimport { authnFetch } from './authn-fetch'\nimport { openIdpPopup, obtainSession } from './popup'\nimport type { Session } from './session'\nimport { getSession, saveSession, clearSession } from './session'\nimport type { AsyncStorage } from './storage'\nimport { defaultStorage } from './storage'\nimport { toUrlString, currentUrlNoParams } from './url-util'\nimport * as WebIdOidc from './webid-oidc'\n\n// Store the global fetch, so the user is free to override it\nconst globalFetch = fetch\n\nexport type loginOptions = {\n  callbackUri: string,\n  clientName?: string,\n  contacts?: Array<string>,\n  logoUri?: string,\n  popupUri: string,\n  storage: AsyncStorage\n}\n\nexport default class SolidAuthClient extends EventEmitter {\n  _pendingSession: ?Promise<?Session>\n\n  fetch(input: RequestInfo, options?: RequestOptions): Promise<Response> {\n    this.emit('request', toUrlString(input))\n    return authnFetch(defaultStorage(), globalFetch, input, options)\n  }\n\n  login(idp: string, options: loginOptions): Promise<?Session> {\n    options = { ...defaultLoginOptions(currentUrlNoParams()), ...options }\n    return WebIdOidc.login(idp, options)\n  }\n\n  async popupLogin(options: loginOptions): Promise<?Session> {\n    options = { ...defaultLoginOptions(), ...options }\n    if (!/https?:/.test(options.popupUri)) {\n      options.popupUri = new URL(\n        options.popupUri || '/.well-known/solid/login',\n        window.location\n      ).toString()\n    }\n    if (!options.callbackUri) {\n      options.callbackUri = options.popupUri\n    }\n    const popup = openIdpPopup(options.popupUri)\n    const session = await obtainSession(options.storage, popup, options)\n    this.emit('login', session)\n    this.emit('session', session)\n    return session\n  }\n\n  async currentSession(\n    storage: AsyncStorage = defaultStorage()\n  ): Promise<?Session> {\n    // Try to obtain a stored or pending session\n    let session = this._pendingSession || (await getSession(storage))\n\n    // If none found, attempt to create a new session\n    if (!session) {\n      // Try to create a new OIDC session from stored tokens\n      try {\n        this._pendingSession = WebIdOidc.currentSession(storage)\n        session = await this._pendingSession\n      } catch (err) {\n        console.error(err)\n      }\n\n      // Save the new session and emit session events\n      if (session) {\n        await saveSession(storage)(session)\n        this.emit('login', session)\n        this.emit('session', session)\n      }\n      delete this._pendingSession\n    }\n    return session\n  }\n\n  async trackSession(callback: Function): Promise<void> {\n    /* eslint-disable standard/no-callback-literal */\n    callback(await this.currentSession())\n    this.on('session', callback)\n  }\n\n  stopTrackSession(callback: Function): void {\n    this.removeListener('session', callback)\n  }\n\n  async logout(storage: AsyncStorage = defaultStorage()): Promise<void> {\n    const session = await getSession(storage)\n    if (session) {\n      try {\n        await WebIdOidc.logout(storage, globalFetch)\n        this.emit('logout')\n        this.emit('session', null)\n      } catch (err) {\n        console.warn('Error logging out:')\n        console.error(err)\n      }\n      await clearSession(storage)\n    }\n  }\n}\n\nfunction defaultLoginOptions(url: ?string): loginOptions {\n  return {\n    callbackUri: url ? url.split('#')[0] : '',\n    popupUri: '',\n    storage: defaultStorage()\n  }\n}\n","import SolidAuthClient from './solid-auth-client'\n\n// Export a singleton instance of SolidAuthClient\nconst auth = new SolidAuthClient()\nexport default auth\n\n// Bind methods to instance, so they can be invoked as regular functions\n// (e.g., to pass around the fetch function)\nObject.getOwnPropertyNames(SolidAuthClient.prototype).forEach(property => {\n  const value = auth[property]\n  if (typeof value === 'function') {\n    auth[property] = value.bind(auth)\n  }\n})\n\n// Expose window.SolidAuthClient for backward compatibility\nif (typeof window !== 'undefined') {\n  if ('SolidAuthClient' in window) {\n    console.warn('Caution: multiple versions of solid-auth-client active.')\n  } else {\n    let warned = false\n    Object.defineProperty(window, 'SolidAuthClient', {\n      enumerable: true,\n      get: () => {\n        if (!warned) {\n          warned = true\n          console.warn('window.SolidAuthClient has been deprecated.')\n          console.warn('Please use window.solid.auth instead.')\n        }\n        return auth\n      }\n    })\n  }\n}\n"],"sourceRoot":""}