npm - @banumeow/n8n-nodes-oci-generativeai-agent - Versions diffs - 0.1.4 → 0.1.6 - Mend

@banumeow/n8n-nodes-oci-generativeai-agent 0.1.4 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1993) hide show

package/node_modules/oci-common/node_modules/opossum/dist/opossum.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["webpack://circuitBreaker/webpack/universalModuleDefinition","webpack://circuitBreaker/webpack/bootstrap","webpack://circuitBreaker/./index.js","webpack://circuitBreaker/./lib/circuit.js","webpack://circuitBreaker/./lib/semaphore.js","webpack://circuitBreaker/./lib/status.js","webpack://circuitBreaker/./node_modules/assert/assert.js","webpack://circuitBreaker/./node_modules/console-browserify/index.js","webpack://circuitBreaker/./node_modules/events/events.js","webpack://circuitBreaker/./node_modules/object-assign/index.js","webpack://circuitBreaker/./node_modules/process/browser.js","webpack://circuitBreaker/./node_modules/util/node_modules/inherits/inherits_browser.js","webpack://circuitBreaker/./node_modules/util/support/isBufferBrowser.js","webpack://circuitBreaker/./node_modules/util/util.js","webpack://circuitBreaker/(webpack)/buildin/global.js"],"names":["module","exports","require","EventEmitter","Status","Semaphore","STATE","Symbol","OPEN","CLOSED","HALF_OPEN","PENDING_CLOSE","SHUTDOWN","FALLBACK_FUNCTION","STATUS","NAME","GROUP","CACHE","WeakMap","ENABLED","WARMING_UP","VOLUME_THRESHOLD","OUR_ERROR","RESET_TIMEOUT","WARMUP_TIMEOUT","deprecation","CircuitBreaker","error","action","options","timeout","resetTimeout","errorThresholdPercentage","rollingCountTimeout","rollingCountBuckets","rollingPercentilesEnabled","capacity","Number","isInteger","MAX_SAFE_INTEGER","errorFilter","_","semaphore","volumeThreshold","allowWarmUp","name","nextName","group","enabled","timer","setTimeout","unref","Promise","resolve","maxFailures","console","increment","property","result","runTime","on","open","close","_startTimer","circuit","emit","halfOpen","cache","set","undefined","clearTimeout","disable","removeAllListeners","status","shutdown","func","fb","fire","apply","arguments","args","call","concat","context","isShutdown","err","buildError","reject","rest","Array","prototype","slice","get","then","closed","pendingClose","fallback","timeoutError","latencyStartTime","Date","now","test","latency","release","handleError","promise","latencyEndTime","interval","TypeError","isNaN","check","e","setInterval","stats","fail","warmUp","fires","errorRate","failures","msg","code","Error","replace","c","r","Math","random","v","toString","count","resolvers","counter","sem","take","Object","defineProperty","enumerable","push","shift","length","WINDOW","BUCKETS","TIMEOUT","PERCENTILES","BUCKET_INTERVAL","SNAPSHOT_INTERVAL","i","bucket","bucketInterval","floor","nextBucket","latencyRunTime","latencyTimes","isCircuitBreakerOpen","clearInterval","totals","reduce","acc","val","keys","forEach","key","sort","a","b","latencyMean","percentile","percentiles","calculatePercentile","window","pop","unshift","fallbacks","successes","rejects","timeouts","cacheHits","cacheMisses","semaphoreRejections","arr","idx","ceil"],"mappings":"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OnBC,aAAS,EAAE,CAPQ;AAQnBC,eAAW,EAAE,CARM;AASnBC,uBAAmB,EAAE,CATF;AAUnBX,eAAW,EAAE,EAVM;AAWnBf,gBAAY,EAAE;AAXK,GAAL;AAAA,CAAhB;;AAcA,SAASgB,mBAAT,CAA8BF,UAA9B,EAA0Ca,GAA1C,EAA+C;AAC7C,MAAIb,UAAU,KAAK,CAAnB,EAAsB;AACpB,WAAOa,GAAG,CAAC,CAAD,CAAH,IAAU,CAAjB;AACD;;AACD,MAAMC,GAAG,GAAGvD,IAAI,CAACwD,IAAL,CAAUf,UAAU,GAAGa,GAAG,CAACxC,MAA3B,CAAZ;AACA,SAAOwC,GAAG,CAACC,GAAG,GAAG,CAAP,CAAH,IAAgB,CAAvB;AACD;;AAEDpL,MAAM,CAACC,OAAP,GAAiBA,OAAO,GAAGG,MAA3B,C;;;;;;;;;;;;ACpMA,8CAAa;;AAEb,mBAAmB,mBAAO,CAAC,4DAAe;;AAE1C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,WAAW,mBAAO,CAAC,0CAAO;AAC1B;AACA;AACA;AACA,0BAA0B;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,8BAA8B;AAC9B;AACA,mDAAmD;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,gDAAgD;;AAEhD;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH,sBAAsB;;AAEtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA;AACA;AACA,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;;AAEA,yBAAyB;AACzB;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,gCAAgC,oBAAoB;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACzfA;AACA,WAAW,mBAAO,CAAC,yCAAM;AACzB,aAAa,mBAAO,CAAC,+CAAQ;AAC7B,gBAAgB;;AAEhB;AACA;AACA;;AAEA;AACA;AACA,CAAC;AACD;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,eAAe,sBAAsB;AACrC;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,sBAAsB;AACvC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA,cAAc;AACd;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,mBAAmB,SAAS;AAC5B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA,iCAAiC,QAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,OAAO;AACP;AACA,sCAAsC,QAAQ;AAC9C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;;AAEA;AACA,QAAQ,yBAAyB;AACjC;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;;;;;;;;;;;;;;AC7bA;AACA;AACA;AACA;AACA;;AAEa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH,kCAAkC;AAClC;AACA;AACA;;AAEA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,gBAAgB,sBAAsB;AACtC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,oBAAoB;AACtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;ACzFA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;ACvLtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA,C;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,uBAAuB,SAAS;AAChC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA,mBAAmB,qBAAW;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA,GAAG;;AAEH;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4CAA4C,KAAK;;AAEjD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;;AAEA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA,mCAAmC,OAAO;AAC1C;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;;AAGA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,mBAAmB,mBAAO,CAAC,0EAAoB;;AAE/C;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA,WAAW,SAAS;AACpB;AACA,mBAAmB,mBAAO,CAAC,+EAAU;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,mBAAmB,sBAAsB;AACzC;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,kCAAkC;AAC7D,2BAA2B,mDAAmD;AAC9E;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC9rBA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C","file":"opossum.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"circuitBreaker\"] = factory();\n\telse\n\t\troot[\"circuitBreaker\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./index.js\");\n","'use strict';\n\nmodule.exports = exports = require('./lib/circuit');\n","'use strict';\n\nconst EventEmitter = require('events');\nconst Status = require('./status');\nconst Semaphore = require('./semaphore');\n\nconst STATE = Symbol('state');\nconst OPEN = Symbol('open');\nconst CLOSED = Symbol('closed');\nconst HALF_OPEN = Symbol('half-open');\nconst PENDING_CLOSE = Symbol('pending-close');\nconst SHUTDOWN = Symbol('shutdown');\nconst FALLBACK_FUNCTION = Symbol('fallback');\nconst STATUS = Symbol('status');\nconst NAME = Symbol('name');\nconst GROUP = Symbol('group');\nconst CACHE = new WeakMap();\nconst ENABLED = Symbol('Enabled');\nconst WARMING_UP = Symbol('warming-up');\nconst VOLUME_THRESHOLD = Symbol('volume-threshold');\nconst OUR_ERROR = Symbol('our-error');\nconst RESET_TIMEOUT = Symbol('reset-timeout');\nconst WARMUP_TIMEOUT = Symbol('warmup-timeout');\nconst deprecation = `options.maxFailures is deprecated. \\\nPlease use options.errorThresholdPercentage`;\n\n/**\n * Constructs a {@link CircuitBreaker}.\n *\n * @class CircuitBreaker\n * @extends EventEmitter\n * @param {Function} action The action to fire for this {@link CircuitBreaker}\n * @param {Object} options Options for the {@link CircuitBreaker}\n * @param {Number} options.timeout The time in milliseconds that action should\n * be allowed to execute before timing out. Timeout can be disabled by setting\n * this to `false`. Default 10000 (10 seconds)\n * @param {Number} options.maxFailures (Deprecated) The number of times the\n * circuit can fail before opening. Default 10.\n * @param {Number} options.resetTimeout The time in milliseconds to wait before\n * setting the breaker to `halfOpen` state, and trying the action again.\n * Default: 30000 (30 seconds)\n * @param {Number} options.rollingCountTimeout Sets the duration of the\n * statistical rolling window, in milliseconds. This is how long Opossum keeps\n * metrics for the circuit breaker to use and for publishing. Default: 10000\n * @param {Number} options.rollingCountBuckets Sets the number of buckets the\n * rolling statistical window is divided into. So, if\n * options.rollingCountTimeout is 10000, and options.rollingCountBuckets is 10,\n * then the statistical window will be 1000 1 second snapshots in the\n * statistical window. Default: 10\n * @param {String} options.name the circuit name to use when reporting stats.\n * Default: the name of the function this circuit controls.\n * @param {boolean} options.rollingPercentilesEnabled This property indicates\n * whether execution latencies should be tracked and calculated as percentiles.\n * If they are disabled, all summary statistics (mean, percentiles) are\n * returned as -1. Default: false\n * @param {Number} options.capacity the number of concurrent requests allowed.\n * If the number currently executing function calls is equal to\n * options.capacity, further calls to `fire()` are rejected until at least one\n * of the current requests completes. Default: `Number.MAX_SAFE_INTEGER`.\n * @param {Number} options.errorThresholdPercentage the error percentage at\n * which to open the circuit and start short-circuiting requests to fallback.\n * Default: 50\n * @param {boolean} options.enabled whether this circuit is enabled upon\n * construction. Default: true\n * @param {boolean} options.allowWarmUp determines whether to allow failures\n * without opening the circuit during a brief warmup period (this is the\n * `rollingCountTimeout` property). Default: false\n * allow before enabling the circuit. This can help in situations where no\n * matter what your `errorThresholdPercentage` is, if the first execution\n * times out or fails, the circuit immediately opens.\n * @param {Number} options.volumeThreshold the minimum number of requests within\n * the rolling statistical window that must exist before the circuit breaker\n * can open. This is similar to `options.allowWarmUp` in that no matter how many\n * failures there are, if the number of requests within the statistical window\n * does not exceed this threshold, the circuit will remain closed. Default: 0\n * @param {Function} options.errorFilter an optional function that will be\n * called when the circuit's function fails (returns a rejected Promise). If\n * this function returns truthy, the circuit's failPure statistics will not be\n * incremented. This is useful, for example, when you don't want HTTP 404 to\n * trip the circuit, but still want to handle it as a failure case.\n * @param {boolean} options.cache whether the return value of the first\n * successful execution of the circuit's function will be cached. Once a value\n * has been cached that value will be returned for every subsequent execution:\n * the cache can be cleared using `clearCache`. (The metrics `cacheHit` and\n * `cacheMiss` reflect cache activity.) Default: false\n *\n *\n * @fires CircuitBreaker#halfOpen\n * @fires CircuitBreaker#close\n * @fires CircuitBreaker#open\n * @fires CircuitBreaker#fire\n * @fires CircuitBreaker#cacheHit\n * @fires CircuitBreaker#cacheMiss\n * @fires CircuitBreaker#reject\n * @fires CircuitBreaker#timeout\n * @fires CircuitBreaker#success\n * @fires CircuitBreaker#semaphoreLocked\n * @fires CircuitBreaker#healthCheckFailed\n * @fires CircuitBreaker#fallback\n * @fires CircuitBreaker#failure\n */\nclass CircuitBreaker extends EventEmitter {\n /**\n * Returns true if the provided error was generated here. It will be false\n * if the error came from the action itself.\n * @param {Error} error The Error to check.\n * @returns {Boolean} true if the error was generated here\n */\n static isOurError (error) {\n return !!error[OUR_ERROR];\n }\n\n constructor (action, options = {}) {\n super();\n this.options = options;\n this.options.timeout =\n options.timeout === false ? false : options.timeout || 10000;\n this.options.resetTimeout = options.resetTimeout || 30000;\n this.options.errorThresholdPercentage =\n options.errorThresholdPercentage || 50;\n this.options.rollingCountTimeout = options.rollingCountTimeout || 10000;\n this.options.rollingCountBuckets = options.rollingCountBuckets || 10;\n this.options.rollingPercentilesEnabled =\n options.rollingPercentilesEnabled !== false;\n this.options.capacity = Number.isInteger(options.capacity)\n ? options.capacity : Number.MAX_SAFE_INTEGER;\n this.options.errorFilter = options.errorFilter || (_ => false);\n\n this.semaphore = new Semaphore(this.options.capacity);\n\n this[VOLUME_THRESHOLD] = Number.isInteger(options.volumeThreshold)\n ? options.volumeThreshold : 0;\n this[WARMING_UP] = options.allowWarmUp === true;\n this[STATUS] = new Status(this.options);\n this[STATE] = CLOSED;\n this[FALLBACK_FUNCTION] = null;\n this[PENDING_CLOSE] = false;\n this[NAME] = options.name || action.name || nextName();\n this[GROUP] = options.group || this[NAME];\n this[ENABLED] = options.enabled !== false;\n\n if (this[WARMING_UP]) {\n const timer = this[WARMUP_TIMEOUT] = setTimeout(\n _ => (this[WARMING_UP] = false),\n this.options.rollingCountTimeout\n );\n if (typeof timer.unref === 'function') {\n timer.unref();\n }\n }\n\n if (typeof action !== 'function') {\n this.action = _ => Promise.resolve(action);\n } else this.action = action;\n\n if (options.maxFailures) console.error(deprecation);\n\n const increment = property =>\n (result, runTime) => this[STATUS].increment(property, runTime);\n\n this.on('success', increment('successes'));\n this.on('failure', increment('failures'));\n this.on('fallback', increment('fallbacks'));\n this.on('timeout', increment('timeouts'));\n this.on('fire', increment('fires'));\n this.on('reject', increment('rejects'));\n this.on('cacheHit', increment('cacheHits'));\n this.on('cacheMiss', increment('cacheMisses'));\n this.on('open', _ => this[STATUS].open());\n this.on('close', _ => this[STATUS].close());\n this.on('semaphoreLocked', increment('semaphoreRejections'));\n\n /**\n * @param {CircuitBreaker} circuit This current circuit\n * @returns {function(): void} A bound reset callback\n * @private\n */\n function _startTimer (circuit) {\n return _ => {\n const timer = circuit[RESET_TIMEOUT] = setTimeout(() => {\n circuit[STATE] = HALF_OPEN;\n circuit[PENDING_CLOSE] = true;\n /**\n * Emitted after `options.resetTimeout` has elapsed, allowing for\n * a single attempt to call the service again. If that attempt is\n * successful, the circuit will be closed. Otherwise it remains open.\n *\n * @event CircuitBreaker#halfOpen\n * @type {Number} how long the circuit remained open\n */\n circuit.emit('halfOpen', circuit.options.resetTimeout);\n }, circuit.options.resetTimeout);\n if (typeof timer.unref === 'function') {\n timer.unref();\n }\n };\n }\n\n this.on('open', _startTimer(this));\n this.on('success', _ => {\n if (this.halfOpen) {\n this.close();\n }\n });\n if (this.options.cache) {\n CACHE.set(this, undefined);\n }\n }\n\n /**\n * Closes the breaker, allowing the action to execute again\n * @fires CircuitBreaker#close\n * @returns {void}\n */\n close () {\n if (this[STATE] !== CLOSED) {\n if (this[RESET_TIMEOUT]) {\n clearTimeout(this[RESET_TIMEOUT]);\n }\n this[STATE] = CLOSED;\n this[PENDING_CLOSE] = false;\n /**\n * Emitted when the breaker is reset allowing the action to execute again\n * @event CircuitBreaker#close\n */\n this.emit('close');\n }\n }\n\n /**\n * Opens the breaker. Each time the breaker is fired while the circuit is\n * opened, a failed Promise is returned, or if any fallback function\n * has been provided, it is invoked.\n *\n * If the breaker is already open this call does nothing.\n * @fires CircuitBreaker#open\n * @returns {void}\n */\n open () {\n if (this[STATE] !== OPEN) {\n this[STATE] = OPEN;\n this[PENDING_CLOSE] = false;\n /**\n * Emitted when the breaker opens because the action has\n * failed more than `options.maxFailures` number of times.\n * @event CircuitBreaker#open\n */\n this.emit('open');\n }\n }\n\n /**\n * Shuts down this circuit breaker. All subsequent calls to the\n * circuit will fail, returning a rejected promise.\n * @returns {void}\n */\n shutdown () {\n this.disable();\n this.removeAllListeners();\n if (this[RESET_TIMEOUT]) {\n clearTimeout(this[RESET_TIMEOUT]);\n }\n if (this[WARMUP_TIMEOUT]) {\n clearTimeout(this[WARMUP_TIMEOUT]);\n }\n this.status.shutdown();\n this[STATE] = SHUTDOWN;\n /**\n * Emitted when the circuit breaker has been shut down.\n * @event CircuitBreaker#shutdown\n */\n this.emit('shutdown');\n }\n\n /**\n * Determines if the circuit has been shutdown.\n * @type {Boolean}\n */\n get isShutdown () {\n return this[STATE] === SHUTDOWN;\n }\n\n /**\n * Gets the name of this circuit\n * @type {String}\n */\n get name () {\n return this[NAME];\n }\n\n /**\n * Gets the name of this circuit group\n * @type {String}\n */\n get group () {\n return this[GROUP];\n }\n\n /**\n * Gets whether this circuit is in the `pendingClosed` state\n * @type {Boolean}\n */\n get pendingClose () {\n return this[PENDING_CLOSE];\n }\n\n /**\n * True if the circuit is currently closed. False otherwise.\n * @type {Boolean}\n */\n get closed () {\n return this[STATE] === CLOSED;\n }\n\n /**\n * True if the circuit is currently opened. False otherwise.\n * @type {Boolean}\n */\n get opened () {\n return this[STATE] === OPEN;\n }\n\n /**\n * True if the circuit is currently half opened. False otherwise.\n * @type {Boolean}\n */\n get halfOpen () {\n return this[STATE] === HALF_OPEN;\n }\n\n /**\n * The current {@link Status} of this {@link CircuitBreaker}\n * @type {Status}\n */\n get status () {\n return this[STATUS];\n }\n\n /**\n * Get the current stats for the circuit.\n * @see Status#stats\n * @type {Object}\n */\n get stats () {\n return this[STATUS].stats;\n }\n\n /**\n * Gets whether the circuit is enabled or not\n * @type {Boolean}\n */\n get enabled () {\n return this[ENABLED];\n }\n\n /**\n * Gets whether the circuit is currently in warm up phase\n * @type {Boolean}\n */\n get warmUp () {\n return this[WARMING_UP];\n }\n\n /**\n * Gets the volume threshold for this circuit\n * @type {Boolean}\n */\n get volumeThreshold () {\n return this[VOLUME_THRESHOLD];\n }\n\n /**\n * Provide a fallback function for this {@link CircuitBreaker}. This\n * function will be executed when the circuit is `fire`d and fails.\n * It will always be preceded by a `failure` event, and `breaker.fire` returns\n * a rejected Promise.\n * @param {Function | CircuitBreaker} func the fallback function to execute\n * when the breaker has opened or when a timeout or error occurs.\n * @return {CircuitBreaker} this\n */\n fallback (func) {\n let fb = func;\n if (func instanceof CircuitBreaker) {\n fb = function () {\n return func.fire.apply(func, arguments);\n };\n }\n this[FALLBACK_FUNCTION] = fb;\n return this;\n }\n\n /**\n * Execute the action for this circuit. If the action fails or times out, the\n * returned promise will be rejected. If the action succeeds, the promise will\n * resolve with the resolved value from action. If a fallback function was\n * provided, it will be invoked in the event of any failure or timeout.\n *\n * Any parameters passed to this function will be proxied to the circuit\n * function.\n *\n * @return {Promise<any>} promise resolves with the circuit function's return\n * value on success or is rejected on failure of the action. Use isOurError()\n * to determine if a rejection was a result of the circuit breaker or the\n * action.\n *\n * @fires CircuitBreaker#failure\n * @fires CircuitBreaker#fallback\n * @fires CircuitBreaker#fire\n * @fires CircuitBreaker#reject\n * @fires CircuitBreaker#success\n * @fires CircuitBreaker#timeout\n * @fires CircuitBreaker#semaphoreLocked\n */\n fire (...args) {\n return this.call.apply(this, [this.action].concat(args));\n }\n\n /**\n * Execute the action for this circuit using `context` as `this`.\n * If the action fails or times out, the\n * returned promise will be rejected. If the action succeeds, the promise will\n * resolve with the resolved value from action. If a fallback function was\n * provided, it will be invoked in the event of any failure or timeout.\n *\n * Any parameters in addition to `context will be passed to the\n * circuit function.\n *\n * @param {any} context the `this` context used for function execution\n * @param {any} rest the arguments passed to the action\n *\n * @return {Promise<any>} promise resolves with the circuit function's return\n * value on success or is rejected on failure of the action.\n *\n * @fires CircuitBreaker#failure\n * @fires CircuitBreaker#fallback\n * @fires CircuitBreaker#fire\n * @fires CircuitBreaker#reject\n * @fires CircuitBreaker#success\n * @fires CircuitBreaker#timeout\n * @fires CircuitBreaker#semaphoreLocked\n */\n call (context, ...rest) {\n if (this.isShutdown) {\n const err = buildError('The circuit has been shutdown.', 'ESHUTDOWN');\n return Promise.reject(err);\n }\n const args = Array.prototype.slice.call(rest);\n\n /**\n * Emitted when the circuit breaker action is executed\n * @event CircuitBreaker#fire\n * @type {any} the arguments passed to the fired function\n */\n this.emit('fire', args);\n\n if (CACHE.get(this) !== undefined) {\n /**\n * Emitted when the circuit breaker is using the cache\n * and finds a value.\n * @event CircuitBreaker#cacheHit\n */\n this.emit('cacheHit');\n return CACHE.get(this);\n } else if (this.options.cache) {\n /**\n * Emitted when the circuit breaker does not find a value in\n * the cache, but the cache option is enabled.\n * @event CircuitBreaker#cacheMiss\n */\n this.emit('cacheMiss');\n }\n\n if (!this[ENABLED]) {\n const result = this.action.apply(context, args);\n return (typeof result.then === 'function')\n ? result\n : Promise.resolve(result);\n }\n\n if (!this.closed && !this.pendingClose) {\n /**\n * Emitted when the circuit breaker is open and failing fast\n * @event CircuitBreaker#reject\n * @type {Error}\n */\n const error = buildError('Breaker is open', 'EOPENBREAKER');\n\n this.emit('reject', error);\n\n return fallback(this, error, args) ||\n Promise.reject(error);\n }\n this[PENDING_CLOSE] = false;\n\n let timeout;\n let timeoutError = false;\n return new Promise((resolve, reject) => {\n const latencyStartTime = Date.now();\n if (this.semaphore.test()) {\n if (this.options.timeout) {\n timeout = setTimeout(\n () => {\n timeoutError = true;\n const error = buildError(\n `Timed out after ${this.options.timeout}ms`, 'ETIMEDOUT'\n );\n const latency = Date.now() - latencyStartTime;\n this.semaphore.release();\n /**\n * Emitted when the circuit breaker action takes longer than\n * `options.timeout`\n * @event CircuitBreaker#timeout\n * @type {Error}\n */\n this.emit('timeout', error, latency, args);\n handleError(error, this, timeout, args, latency, resolve, reject);\n }, this.options.timeout);\n }\n\n try {\n const result = this.action.apply(context, args);\n const promise = (typeof result.then === 'function')\n ? result\n : Promise.resolve(result);\n\n promise.then(result => {\n if (!timeoutError) {\n clearTimeout(timeout);\n /**\n * Emitted when the circuit breaker action succeeds\n * @event CircuitBreaker#success\n * @type {any} the return value from the circuit\n */\n this.emit('success', result, (Date.now() - latencyStartTime));\n this.semaphore.release();\n resolve(result);\n if (this.options.cache) {\n CACHE.set(this, promise);\n }\n }\n })\n .catch(error => {\n if (!timeoutError) {\n this.semaphore.release();\n const latencyEndTime = Date.now() - latencyStartTime;\n handleError(\n error, this, timeout, args, latencyEndTime, resolve, reject);\n }\n });\n } catch (error) {\n this.semaphore.release();\n const latency = Date.now() - latencyStartTime;\n handleError(error, this, timeout, args, latency, resolve, reject);\n }\n } else {\n const latency = Date.now() - latencyStartTime;\n const err = buildError('Semaphore locked', 'ESEMLOCKED');\n /**\n * Emitted when the rate limit has been reached and there\n * are no more locks to be obtained.\n * @event CircuitBreaker#semaphoreLocked\n * @type {Error}\n */\n this.emit('semaphoreLocked', err, latency);\n handleError(err, this, timeout, args, latency, resolve, reject);\n }\n });\n }\n\n /**\n * Clears the cache of this {@link CircuitBreaker}\n * @returns {void}\n */\n clearCache () {\n CACHE.set(this, undefined);\n }\n\n /**\n * Provide a health check function to be called periodically. The function\n * should return a Promise. If the promise is rejected the circuit will open.\n * This is in addition to the existing circuit behavior as defined by\n * `options.errorThresholdPercentage` in the constructor. For example, if the\n * health check function provided here always returns a resolved promise, the\n * circuit can still trip and open if there are failures exceeding the\n * configured threshold. The health check function is executed within the\n * circuit breaker's execution context, so `this` within the function is the\n * circuit breaker itself.\n *\n * @param {Function} func a health check function which returns a promise.\n * @param {Number} [interval] the amount of time between calls to the health\n * check function. Default: 5000 (5 seconds)\n *\n * @returns {void}\n *\n * @fires CircuitBreaker#healthCheckFailed\n * @throws {TypeError} if `interval` is supplied but not a number\n */\n healthCheck (func, interval) {\n interval = interval || 5000;\n if (typeof func !== 'function') {\n throw new TypeError('Health check function must be a function');\n }\n if (isNaN(interval)) {\n throw new TypeError('Health check interval must be a number');\n }\n\n const check = _ => {\n func.apply(this).catch(e => {\n /**\n * Emitted with the user-supplied health check function\n * returns a rejected promise.\n * @event CircuitBreaker#healthCheckFailed\n * @type {Error}\n */\n this.emit('healthCheckFailed', e);\n this.open();\n });\n };\n\n const timer = setInterval(check, interval);\n if (typeof timer.unref === 'function') {\n timer.unref();\n }\n\n check();\n }\n\n /**\n * Enables this circuit. If the circuit is the disabled\n * state, it will be re-enabled. If not, this is essentially\n * a noop.\n * @returns {void}\n */\n enable () {\n this[ENABLED] = true;\n }\n\n /**\n * Disables this circuit, causing all calls to the circuit's function\n * to be executed without circuit or fallback protection.\n * @returns {void}\n */\n disable () {\n this[ENABLED] = false;\n }\n}\n\nfunction handleError (error, circuit, timeout, args, latency, resolve, reject) {\n clearTimeout(timeout);\n\n if (circuit.options.errorFilter(error)) {\n circuit.emit('success', error, latency);\n } else {\n fail(circuit, error, args, latency);\n }\n\n const fb = fallback(circuit, error, args);\n if (fb) resolve(fb);\n else reject(error);\n}\n\nfunction fallback (circuit, err, args) {\n if (circuit[FALLBACK_FUNCTION]) {\n const result =\n circuit[FALLBACK_FUNCTION]\n .apply(circuit[FALLBACK_FUNCTION], [...args, err]);\n /**\n * Emitted when the circuit breaker executes a fallback function\n * @event CircuitBreaker#fallback\n * @type {any} the return value of the fallback function\n */\n circuit.emit('fallback', result, err);\n if (result instanceof Promise) return result;\n return Promise.resolve(result);\n }\n}\n\nfunction fail (circuit, err, args, latency) {\n /**\n * Emitted when the circuit breaker action fails\n * @event CircuitBreaker#failure\n * @type {Error}\n */\n circuit.emit('failure', err, latency, args);\n if (circuit.warmUp) return;\n\n // check stats to see if the circuit should be opened\n const stats = circuit.stats;\n if ((stats.fires < circuit.volumeThreshold) && !circuit.halfOpen) return;\n const errorRate = stats.failures / stats.fires * 100;\n if (errorRate > circuit.options.errorThresholdPercentage ||\n stats.failures >= circuit.options.maxFailures ||\n circuit.halfOpen) {\n circuit.open();\n }\n}\n\nfunction buildError (msg, code) {\n const error = new Error(msg);\n error.code = code;\n error[OUR_ERROR] = true;\n return error;\n}\n\n// http://stackoverflow.com/a/2117523\nconst nextName = () =>\n 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n const r = Math.random() * 16 | 0;\n const v = c === 'x' ? r : (r & 0x3 | 0x8);\n return v.toString(16);\n });\n\nmodule.exports = exports = CircuitBreaker;\n","'use strict';\n\nmodule.exports = exports = semaphore;\n\nfunction semaphore (count) {\n const resolvers = [];\n let counter = count;\n\n const sem = {\n take,\n release,\n test\n };\n\n Object.defineProperty(sem, 'count', {\n get: _ => counter,\n enumerable: true\n });\n\n return sem;\n\n function take (timeout) {\n if (counter > 0) {\n --counter;\n return Promise.resolve(release);\n }\n return new Promise((resolve, reject) => {\n resolvers.push(_ => {\n --counter;\n resolve(release);\n });\n if (timeout) {\n setTimeout(_ => {\n resolvers.shift();\n const err = new Error(`Timed out after ${timeout}ms`);\n err.code = 'ETIMEDOUT';\n reject(err);\n }, timeout);\n }\n });\n }\n\n function release () {\n counter++;\n if (resolvers.length > 0) {\n resolvers.shift()();\n }\n }\n\n function test () {\n if (counter < 1) return false;\n return take() && true;\n }\n}\n","'use strict';\n\nconst WINDOW = Symbol('window');\nconst BUCKETS = Symbol('buckets');\nconst TIMEOUT = Symbol('timeout');\nconst PERCENTILES = Symbol('percentiles');\nconst BUCKET_INTERVAL = Symbol('bucket-interval');\nconst SNAPSHOT_INTERVAL = Symbol('snapshot-interval');\n\nconst EventEmitter = require('events').EventEmitter;\n\n/**\n * Tracks execution status for a given {@link CircuitBreaker}.\n * A Status instance is created for every {@link CircuitBreaker}\n * and does not typically need to be created by a user.\n *\n * A Status instance will listen for all events on the {@link CircuitBreaker}\n * and track them in a rolling statistical window. The window duration is\n * determined by the `rollingCountTimeout` option provided to the\n * {@link CircuitBreaker}. The window consists of an array of Objects,\n * each representing the counts for a {@link CircuitBreaker}'s events.\n *\n * The array's length is determined by the {@link CircuitBreaker}'s\n * `rollingCountBuckets` option. The duration of each slice of the window\n * is determined by dividing the `rollingCountTimeout` by\n * `rollingCountBuckets`.\n *\n * @class Status\n * @extends EventEmitter\n * @param {Object} options for the status window\n * @param {Number} options.rollingCountBuckets number of buckets in the window\n * @param {Number} options.rollingCountTimeout the duration of the window\n * @param {Boolean} options.rollingPercentilesEnabled whether to calculate\n * percentiles\n * @example\n * // Creates a 1 second window consisting of ten time slices,\n * // each 100ms long.\n * const circuit = circuitBreaker(fs.readFile,\n * { rollingCountBuckets: 10, rollingCountTimeout: 1000});\n *\n * // get the cumulative statistics for the last second\n * circuit.status.stats;\n *\n * // get the array of 10, 1 second time slices for the last second\n * circuit.status.window;\n * @fires Status#snapshot\n * @see CircuitBreaker#status\n */\nclass Status extends EventEmitter {\n constructor (options) {\n super();\n\n // Set up our statistical rolling window\n this[BUCKETS] = options.rollingCountBuckets;\n this[TIMEOUT] = options.rollingCountTimeout;\n this[WINDOW] = new Array(this[BUCKETS]);\n this[PERCENTILES] = [0.0, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.995, 1];\n\n // Default this value to true\n this.rollingPercentilesEnabled = options.rollingPercentilesEnabled;\n\n // prime the window with buckets\n for (let i = 0; i < this[BUCKETS]; i++) this[WINDOW][i] = bucket();\n\n // rotate the buckets periodically\n const bucketInterval = Math.floor(this[TIMEOUT] / this[BUCKETS]);\n this[BUCKET_INTERVAL] = setInterval(nextBucket(this[WINDOW]),\n bucketInterval);\n\n // No unref() in the browser\n if (typeof this[BUCKET_INTERVAL].unref === 'function') {\n this[BUCKET_INTERVAL].unref();\n }\n\n /**\n * Emitted at each time-slice. Listeners for this\n * event will receive a cumulative snapshot of the current status window.\n * @event Status#snapshot\n * @type {Object}\n */\n this[SNAPSHOT_INTERVAL] = setInterval(\n _ => this.emit('snapshot', this.stats),\n bucketInterval);\n if (typeof this[SNAPSHOT_INTERVAL].unref === 'function') {\n this[SNAPSHOT_INTERVAL].unref();\n }\n }\n\n /**\n * Get the cumulative stats for the current window\n * @type {Object}\n */\n get stats () {\n const totals = this[WINDOW].reduce((acc, val) => {\n if (!val) { return acc; }\n Object.keys(acc).forEach(key => {\n if (key !== 'latencyTimes' && key !== 'percentiles') {\n (acc[key] += val[key] || 0);\n }\n });\n\n if (this.rollingPercentilesEnabled) {\n acc.latencyTimes.push.apply(acc.latencyTimes, val.latencyTimes || []);\n }\n return acc;\n }, bucket());\n\n if (this.rollingPercentilesEnabled) {\n // Sort the latencyTimes\n totals.latencyTimes.sort((a, b) => a - b);\n\n // Get the mean latency\n // Mean = sum of all values in the array/length of array\n if (totals.latencyTimes.length) {\n totals.latencyMean =\n (totals\n .latencyTimes\n .reduce((a, b) => a + b, 0)) / totals.latencyTimes.length;\n } else {\n totals.latencyMean = 0;\n }\n\n // Calculate Percentiles\n this[PERCENTILES].forEach(percentile => {\n totals.percentiles[percentile] =\n calculatePercentile(percentile, totals.latencyTimes);\n });\n } else {\n totals.latencyMean = -1;\n this[PERCENTILES].forEach(percentile => {\n totals.percentiles[percentile] = -1;\n });\n }\n\n return totals;\n }\n\n /**\n * Gets the stats window as an array of time-sliced objects.\n * @type {Array}\n */\n get window () {\n return this[WINDOW].slice();\n }\n\n increment (property, latencyRunTime) {\n this[WINDOW][0][property]++;\n if (property === 'successes' ||\n property === 'failures' ||\n property === 'timeouts') {\n this[WINDOW][0].latencyTimes.push(latencyRunTime || 0);\n }\n }\n\n open () {\n this[WINDOW][0].isCircuitBreakerOpen = true;\n }\n\n close () {\n this[WINDOW][0].isCircuitBreakerOpen = false;\n }\n\n shutdown () {\n this.removeAllListeners();\n clearInterval(this[BUCKET_INTERVAL]);\n clearInterval(this[SNAPSHOT_INTERVAL]);\n }\n}\n\nconst nextBucket = window => _ => {\n window.pop();\n window.unshift(bucket());\n};\n\nconst bucket = _ => ({\n failures: 0,\n fallbacks: 0,\n successes: 0,\n rejects: 0,\n fires: 0,\n timeouts: 0,\n cacheHits: 0,\n cacheMisses: 0,\n semaphoreRejections: 0,\n percentiles: {},\n latencyTimes: []\n});\n\nfunction calculatePercentile (percentile, arr) {\n if (percentile === 0) {\n return arr[0] || 0;\n }\n const idx = Math.ceil(percentile * arr.length);\n return arr[idx - 1] || 0;\n}\n\nmodule.exports = exports = Status;\n","'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","/*global window, global*/\nvar util = require(\"util\")\nvar assert = require(\"assert\")\nfunction now() { return new Date().getTime() }\n\nvar slice = Array.prototype.slice\nvar console\nvar times = {}\n\nif (typeof global !== \"undefined\" && global.console) {\n console = global.console\n} else if (typeof window !== \"undefined\" && window.console) {\n console = window.console\n} else {\n console = {}\n}\n\nvar functions = [\n [log, \"log\"],\n [info, \"info\"],\n [warn, \"warn\"],\n [error, \"error\"],\n [time, \"time\"],\n [timeEnd, \"timeEnd\"],\n [trace, \"trace\"],\n [dir, \"dir\"],\n [consoleAssert, \"assert\"]\n]\n\nfor (var i = 0; i < functions.length; i++) {\n var tuple = functions[i]\n var f = tuple[0]\n var name = tuple[1]\n\n if (!console[name]) {\n console[name] = f\n }\n}\n\nmodule.exports = console\n\nfunction log() {}\n\nfunction info() {\n console.log.apply(console, arguments)\n}\n\nfunction warn() {\n console.log.apply(console, arguments)\n}\n\nfunction error() {\n console.warn.apply(console, arguments)\n}\n\nfunction time(label) {\n times[label] = now()\n}\n\nfunction timeEnd(label) {\n var time = times[label]\n if (!time) {\n throw new Error(\"No such label: \" + label)\n }\n\n delete times[label]\n var duration = now() - time\n console.log(label + \": \" + duration + \"ms\")\n}\n\nfunction trace() {\n var err = new Error()\n err.name = \"Trace\"\n err.message = util.format.apply(null, arguments)\n console.error(err.stack)\n}\n\nfunction dir(object) {\n console.log(util.inspect(object) + \"\\n\")\n}\n\nfunction consoleAssert(expression) {\n if (!expression) {\n var arr = slice.call(arguments, 1)\n assert.ok(false, util.format.apply(null, arr))\n }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n ? R.apply\n : function ReflectApply(target, receiver, args) {\n return Function.prototype.apply.call(target, receiver, args);\n }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target)\n .concat(Object.getOwnPropertySymbols(target));\n };\n} else {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target);\n };\n}\n\nfunction ProcessEmitWarning(warning) {\n if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n return value !== value;\n}\n\nfunction EventEmitter() {\n EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n if (typeof listener !== 'function') {\n throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n }\n defaultMaxListeners = arg;\n }\n});\n\nEventEmitter.init = function() {\n\n if (this._events === undefined ||\n this._events === Object.getPrototypeOf(this)._events) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n }\n this._maxListeners = n;\n return this;\n};\n\nfunction _getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n var args = [];\n for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n var doError = (type === 'error');\n\n var events = this._events;\n if (events !== undefined)\n doError = (doError && events.error === undefined);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n var er;\n if (args.length > 0)\n er = args[0];\n if (er instanceof Error) {\n // Note: The comments on the `throw` lines are intentional, they show\n // up in Node's output if this results in an unhandled exception.\n throw er; // Unhandled 'error' event\n }\n // At least give some kind of context to the user\n var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n err.context = er;\n throw err; // Unhandled 'error' event\n }\n\n var handler = events[type];\n\n if (handler === undefined)\n return false;\n\n if (typeof handler === 'function') {\n ReflectApply(handler, this, args);\n } else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n ReflectApply(listeners[i], this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n checkListener(listener);\n\n events = target._events;\n if (events === undefined) {\n events = target._events = Object.create(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener !== undefined) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (existing === undefined) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n // If we've already got an array, just append.\n } else if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n\n // Check for listener leak\n m = _getMaxListeners(target);\n if (m > 0 && existing.length > m && !existing.warned) {\n existing.warned = true;\n // No error code for this since it is a Warning\n // eslint-disable-next-line no-restricted-syntax\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' ' + String(type) + ' listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n ProcessEmitWarning(w);\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n if (arguments.length === 0)\n return this.listener.call(this.target);\n return this.listener.apply(this.target, arguments);\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = onceWrapper.bind(state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n checkListener(listener);\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n checkListener(listener);\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n checkListener(listener);\n\n events = this._events;\n if (events === undefined)\n return this;\n\n list = events[type];\n if (list === undefined)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else {\n spliceOne(list, position);\n }\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener !== undefined)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (events === undefined)\n return this;\n\n // not listening for removeListener, no need to emit\n if (events.removeListener === undefined) {\n if (arguments.length === 0) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n } else if (events[type] !== undefined) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = Object.keys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = Object.create(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners !== undefined) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (events === undefined)\n return [];\n\n var evlistener = events[type];\n if (evlistener === undefined)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ?\n unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events !== undefined) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener !== undefined) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction spliceOne(list, index) {\n for (; index + 1 < list.length; index++)\n list[index] = list[index + 1];\n list.pop();\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n","/*\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","// 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","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","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}","// 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","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"],"sourceRoot":""}

package/node_modules/oci-common/node_modules/opossum/dist/opossum.min.js ADDED Viewed

@@ -0,0 +1,13 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.circuitBreaker=t():e.circuitBreaker=t()}(window,(function(){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)n.d(r,o,function(t){return e[t]}.bind(null,o));return r},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=4)}([function(e,t,n){(function(t){var r=n(2),o=n(9);function i(){return(new Date).getTime()}var u,c=Array.prototype.slice,s={};u=void 0!==t&&t.console?t.console:"undefined"!=typeof window&&window.console?window.console:{};for(var a=[[function(){},"log"],[function(){u.log.apply(u,arguments)},"info"],[function(){u.log.apply(u,arguments)},"warn"],[function(){u.warn.apply(u,arguments)},"error"],[function(e){s[e]=i()},"time"],[function(e){var t=s[e];if(!t)throw new Error("No such label: "+e);delete s[e];var n=i()-t;u.log(e+": "+n+"ms")},"timeEnd"],[function(){var e=new Error;e.name="Trace",e.message=r.format.apply(null,arguments),u.error(e.stack)},"trace"],[function(e){u.log(r.inspect(e)+"\n")},"dir"],[function(e){if(!e){var t=c.call(arguments,1);o.ok(!1,r.format.apply(null,t))}},"assert"]],f=0;f<a.length;f++){var l=a[f],p=l[0],h=l[1];u[h]||(u[h]=p)}e.exports=u}).call(this,n(1))},function(e,t){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(e){"object"==typeof window&&(n=window)}e.exports=n},function(e,t,n){(function(e,r){var o=Object.getOwnPropertyDescriptors||function(e){for(var t=Object.keys(e),n={},r=0;r<t.length;r++)n[t[r]]=Object.getOwnPropertyDescriptor(e,t[r]);return n},i=/%[sdj%]/g;t.format=function(e){if(!g(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(s(arguments[n]));return t.join(" ")}n=1;for(var r=arguments,o=r.length,u=String(e).replace(i,(function(e){if("%%"===e)return"%";if(n>=o)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(e){return"[Circular]"}default:return e}})),c=r[n];n<o;c=r[++n])v(c)||!O(c)?u+=" "+c:u+=" "+s(c);return u},t.deprecate=function(n,o){if(void 0!==e&&!0===e.noDeprecation)return n;if(void 0===e)return function(){return t.deprecate(n,o).apply(this,arguments)};var i=!1;return function(){if(!i){if(e.throwDeprecation)throw new Error(o);e.traceDeprecation?r.trace(o):r.error(o),i=!0}return n.apply(this,arguments)}};var u,c={};function s(e,n){var r={seen:[],stylize:f};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),m(n)?r.showHidden=n:n&&t._extend(r,n),b(r.showHidden)&&(r.showHidden=!1),b(r.depth)&&(r.depth=2),b(r.colors)&&(r.colors=!1),b(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=a),l(r,e,r.depth)}function a(e,t){var n=s.styles[t];return n?"["+s.colors[n][0]+"m"+e+"["+s.colors[n][1]+"m":e}function f(e,t){return e}function l(e,n,r){if(e.customInspect&&n&&x(n.inspect)&&n.inspect!==t.inspect&&(!n.constructor||n.constructor.prototype!==n)){var o=n.inspect(r,e);return g(o)||(o=l(e,o,r)),o}var i=function(e,t){if(b(t))return e.stylize("undefined","undefined");if(g(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}if(d(t))return e.stylize(""+t,"number");if(m(t))return e.stylize(""+t,"boolean");if(v(t))return e.stylize("null","null")}(e,n);if(i)return i;var u=Object.keys(n),c=function(e){var t={};return e.forEach((function(e,n){t[e]=!0})),t}(u);if(e.showHidden&&(u=Object.getOwnPropertyNames(n)),j(n)&&(u.indexOf("message")>=0||u.indexOf("description")>=0))return p(n);if(0===u.length){if(x(n)){var s=n.name?": "+n.name:"";return e.stylize("[Function"+s+"]","special")}if(w(n))return e.stylize(RegExp.prototype.toString.call(n),"regexp");if(E(n))return e.stylize(Date.prototype.toString.call(n),"date");if(j(n))return p(n)}var a,f="",O=!1,S=["{","}"];(y(n)&&(O=!0,S=["[","]"]),x(n))&&(f=" [Function"+(n.name?": "+n.name:"")+"]");return w(n)&&(f=" "+RegExp.prototype.toString.call(n)),E(n)&&(f=" "+Date.prototype.toUTCString.call(n)),j(n)&&(f=" "+p(n)),0!==u.length||O&&0!=n.length?r<0?w(n)?e.stylize(RegExp.prototype.toString.call(n),"regexp"):e.stylize("[Object]","special"):(e.seen.push(n),a=O?function(e,t,n,r,o){for(var i=[],u=0,c=t.length;u<c;++u)_(t,String(u))?i.push(h(e,t,n,r,String(u),!0)):i.push("");return o.forEach((function(o){o.match(/^\d+$/)||i.push(h(e,t,n,r,o,!0))})),i}(e,n,r,c,u):u.map((function(t){return h(e,n,r,c,t,O)})),e.seen.pop(),function(e,t,n){if(e.reduce((function(e,t){return t.indexOf("\n")>=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0)>60)return n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+n[1];return n[0]+t+" "+e.join(", ")+" "+n[1]}(a,f,S)):S[0]+f+S[1]}function p(e){return"["+Error.prototype.toString.call(e)+"]"}function h(e,t,n,r,o,i){var u,c,s;if((s=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?c=s.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):s.set&&(c=e.stylize("[Setter]","special")),_(r,o)||(u="["+o+"]"),c||(e.seen.indexOf(s.value)<0?(c=v(n)?l(e,s.value,null):l(e,s.value,n-1)).indexOf("\n")>-1&&(c=i?c.split("\n").map((function(e){return"  "+e})).join("\n").substr(2):"\n"+c.split("\n").map((function(e){return"   "+e})).join("\n")):c=e.stylize("[Circular]","special")),b(u)){if(i&&o.match(/^\d+$/))return c;(u=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(u=u.substr(1,u.length-2),u=e.stylize(u,"name")):(u=u.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),u=e.stylize(u,"string"))}return u+": "+c}function y(e){return Array.isArray(e)}function m(e){return"boolean"==typeof e}function v(e){return null===e}function d(e){return"number"==typeof e}function g(e){return"string"==typeof e}function b(e){return void 0===e}function w(e){return O(e)&&"[object RegExp]"===S(e)}function O(e){return"object"==typeof e&&null!==e}function E(e){return O(e)&&"[object Date]"===S(e)}function j(e){return O(e)&&("[object Error]"===S(e)||e instanceof Error)}function x(e){return"function"==typeof e}function S(e){return Object.prototype.toString.call(e)}function T(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(n){if(b(u)&&(u=Object({WEB:"web"}).NODE_DEBUG||""),n=n.toUpperCase(),!c[n])if(new RegExp("\\b"+n+"\\b","i").test(u)){var o=e.pid;c[n]=function(){var e=t.format.apply(t,arguments);r.error("%s %d: %s",n,o,e)}}else c[n]=function(){};return c[n]},t.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=y,t.isBoolean=m,t.isNull=v,t.isNullOrUndefined=function(e){return null==e},t.isNumber=d,t.isString=g,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=b,t.isRegExp=w,t.isObject=O,t.isDate=E,t.isError=j,t.isFunction=x,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=n(7);var k=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function P(){var e=new Date,t=[T(e.getHours()),T(e.getMinutes()),T(e.getSeconds())].join(":");return[e.getDate(),k[e.getMonth()],t].join(" ")}function _(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){r.log("%s - %s",P(),t.format.apply(t,arguments))},t.inherits=n(8),t._extend=function(e,t){if(!t||!O(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e};var L="undefined"!=typeof Symbol?Symbol("util.promisify.custom"):void 0;function A(e,t){if(!e){var n=new Error("Promise was rejected with a falsy value");n.reason=e,e=n}return t(e)}t.promisify=function(e){if("function"!=typeof e)throw new TypeError('The "original" argument must be of type Function');if(L&&e[L]){var t;if("function"!=typeof(t=e[L]))throw new TypeError('The "util.promisify.custom" argument must be of type Function');return Object.defineProperty(t,L,{value:t,enumerable:!1,writable:!1,configurable:!0}),t}function t(){for(var t,n,r=new Promise((function(e,r){t=e,n=r})),o=[],i=0;i<arguments.length;i++)o.push(arguments[i]);o.push((function(e,r){e?n(e):t(r)}));try{e.apply(this,o)}catch(e){n(e)}return r}return Object.setPrototypeOf(t,Object.getPrototypeOf(e)),L&&Object.defineProperty(t,L,{value:t,enumerable:!1,writable:!1,configurable:!0}),Object.defineProperties(t,o(e))},t.promisify.custom=L,t.callbackify=function(t){if("function"!=typeof t)throw new TypeError('The "original" argument must be of type Function');function n(){for(var n=[],r=0;r<arguments.length;r++)n.push(arguments[r]);var o=n.pop();if("function"!=typeof o)throw new TypeError("The last argument must be of type Function");var i=this,u=function(){return o.apply(i,arguments)};t.apply(this,n).then((function(t){e.nextTick(u,null,t)}),(function(t){e.nextTick(A,t,u)}))}return Object.setPrototypeOf(n,Object.getPrototypeOf(t)),Object.defineProperties(n,o(t)),n}}).call(this,n(6),n(0))},function(e,t,n){"use strict";(function(t){var n,r="object"==typeof Reflect?Reflect:null,o=r&&"function"==typeof r.apply?r.apply:function(e,t,n){return Function.prototype.apply.call(e,t,n)};n=r&&"function"==typeof r.ownKeys?r.ownKeys:Object.getOwnPropertySymbols?function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:function(e){return Object.getOwnPropertyNames(e)};var i=Number.isNaN||function(e){return e!=e};function u(){u.init.call(this)}e.exports=u,u.EventEmitter=u,u.prototype._events=void 0,u.prototype._eventsCount=0,u.prototype._maxListeners=void 0;var c=10;function s(e){if("function"!=typeof e)throw new TypeError('The "listener" argument must be of type Function. Received type '+typeof e)}function a(e){return void 0===e._maxListeners?u.defaultMaxListeners:e._maxListeners}function f(e,n,r,o){var i,u,c,f;if(s(r),void 0===(u=e._events)?(u=e._events=Object.create(null),e._eventsCount=0):(void 0!==u.newListener&&(e.emit("newListener",n,r.listener?r.listener:r),u=e._events),c=u[n]),void 0===c)c=u[n]=r,++e._eventsCount;else if("function"==typeof c?c=u[n]=o?[r,c]:[c,r]:o?c.unshift(r):c.push(r),(i=a(e))>0&&c.length>i&&!c.warned){c.warned=!0;var l=new Error("Possible EventEmitter memory leak detected. "+c.length+" "+String(n)+" listeners added. Use emitter.setMaxListeners() to increase limit");l.name="MaxListenersExceededWarning",l.emitter=e,l.type=n,l.count=c.length,f=l,t&&t.warn&&t.warn(f)}return e}function l(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,0===arguments.length?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function p(e,t,n){var r={fired:!1,wrapFn:void 0,target:e,type:t,listener:n},o=l.bind(r);return o.listener=n,r.wrapFn=o,o}function h(e,t,n){var r=e._events;if(void 0===r)return[];var o=r[t];return void 0===o?[]:"function"==typeof o?n?[o.listener||o]:[o]:n?function(e){for(var t=new Array(e.length),n=0;n<t.length;++n)t[n]=e[n].listener||e[n];return t}(o):m(o,o.length)}function y(e){var t=this._events;if(void 0!==t){var n=t[e];if("function"==typeof n)return 1;if(void 0!==n)return n.length}return 0}function m(e,t){for(var n=new Array(t),r=0;r<t;++r)n[r]=e[r];return n}Object.defineProperty(u,"defaultMaxListeners",{enumerable:!0,get:function(){return c},set:function(e){if("number"!=typeof e||e<0||i(e))throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received '+e+".");c=e}}),u.init=function(){void 0!==this._events&&this._events!==Object.getPrototypeOf(this)._events||(this._events=Object.create(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},u.prototype.setMaxListeners=function(e){if("number"!=typeof e||e<0||i(e))throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received '+e+".");return this._maxListeners=e,this},u.prototype.getMaxListeners=function(){return a(this)},u.prototype.emit=function(e){for(var t=[],n=1;n<arguments.length;n++)t.push(arguments[n]);var r="error"===e,i=this._events;if(void 0!==i)r=r&&void 0===i.error;else if(!r)return!1;if(r){var u;if(t.length>0&&(u=t[0]),u instanceof Error)throw u;var c=new Error("Unhandled error."+(u?" ("+u.message+")":""));throw c.context=u,c}var s=i[e];if(void 0===s)return!1;if("function"==typeof s)o(s,this,t);else{var a=s.length,f=m(s,a);for(n=0;n<a;++n)o(f[n],this,t)}return!0},u.prototype.addListener=function(e,t){return f(this,e,t,!1)},u.prototype.on=u.prototype.addListener,u.prototype.prependListener=function(e,t){return f(this,e,t,!0)},u.prototype.once=function(e,t){return s(t),this.on(e,p(this,e,t)),this},u.prototype.prependOnceListener=function(e,t){return s(t),this.prependListener(e,p(this,e,t)),this},u.prototype.removeListener=function(e,t){var n,r,o,i,u;if(s(t),void 0===(r=this._events))return this;if(void 0===(n=r[e]))return this;if(n===t||n.listener===t)0==--this._eventsCount?this._events=Object.create(null):(delete r[e],r.removeListener&&this.emit("removeListener",e,n.listener||t));else if("function"!=typeof n){for(o=-1,i=n.length-1;i>=0;i--)if(n[i]===t||n[i].listener===t){u=n[i].listener,o=i;break}if(o<0)return this;0===o?n.shift():function(e,t){for(;t+1<e.length;t++)e[t]=e[t+1];e.pop()}(n,o),1===n.length&&(r[e]=n[0]),void 0!==r.removeListener&&this.emit("removeListener",e,u||t)}return this},u.prototype.off=u.prototype.removeListener,u.prototype.removeAllListeners=function(e){var t,n,r;if(void 0===(n=this._events))return this;if(void 0===n.removeListener)return 0===arguments.length?(this._events=Object.create(null),this._eventsCount=0):void 0!==n[e]&&(0==--this._eventsCount?this._events=Object.create(null):delete n[e]),this;if(0===arguments.length){var o,i=Object.keys(n);for(r=0;r<i.length;++r)"removeListener"!==(o=i[r])&&this.removeAllListeners(o);return this.removeAllListeners("removeListener"),this._events=Object.create(null),this._eventsCount=0,this}if("function"==typeof(t=n[e]))this.removeListener(e,t);else if(void 0!==t)for(r=t.length-1;r>=0;r--)this.removeListener(e,t[r]);return this},u.prototype.listeners=function(e){return h(this,e,!0)},u.prototype.rawListeners=function(e){return h(this,e,!1)},u.listenerCount=function(e,t){return"function"==typeof e.listenerCount?e.listenerCount(t):y.call(e,t)},u.prototype.listenerCount=y,u.prototype.eventNames=function(){return this._eventsCount>0?n(this._events):[]}}).call(this,n(0))},function(e,t,n){"use strict";e.exports=n(5)},function(e,t,n){"use strict";(function(t){function r(e){return function(e){if(Array.isArray(e))return o(e)}(e)||function(e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||function(e,t){if(!e)return;if("string"==typeof e)return o(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(n);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return o(e,t)}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function i(e){return(i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function c(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function s(e,t,n){return t&&c(e.prototype,t),n&&c(e,n),e}function a(e,t){return!t||"object"!==i(t)&&"function"!=typeof t?f(e):t}function f(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}function l(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],(function(){}))),!0}catch(e){return!1}}function p(e){return(p=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function h(e,t){return(h=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}var y=n(3),m=n(11),v=n(12),d=Symbol("state"),g=Symbol("open"),b=Symbol("closed"),w=Symbol("half-open"),O=Symbol("pending-close"),E=Symbol("shutdown"),j=Symbol("fallback"),x=Symbol("status"),S=Symbol("name"),T=Symbol("group"),k=new WeakMap,P=Symbol("Enabled"),_=Symbol("warming-up"),L=Symbol("volume-threshold"),A=Symbol("our-error"),D=Symbol("reset-timeout"),C=Symbol("warmup-timeout"),M="options.maxFailures is deprecated. Please use options.errorThresholdPercentage",R=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&h(e,t)}(o,e);var n,r=(n=o,function(){var e,t=p(n);if(l()){var r=p(this).constructor;e=Reflect.construct(t,arguments,r)}else e=t.apply(this,arguments);return a(this,e)});function o(e){var n,i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(u(this,o),(n=r.call(this)).options=i,n.options.timeout=!1!==i.timeout&&(i.timeout||1e4),n.options.resetTimeout=i.resetTimeout||3e4,n.options.errorThresholdPercentage=i.errorThresholdPercentage||50,n.options.rollingCountTimeout=i.rollingCountTimeout||1e4,n.options.rollingCountBuckets=i.rollingCountBuckets||10,n.options.rollingPercentilesEnabled=!1!==i.rollingPercentilesEnabled,n.options.capacity=Number.isInteger(i.capacity)?i.capacity:Number.MAX_SAFE_INTEGER,n.options.errorFilter=i.errorFilter||function(e){return!1},n.semaphore=new v(n.options.capacity),n[L]=Number.isInteger(i.volumeThreshold)?i.volumeThreshold:0,n[_]=!0===i.allowWarmUp,n[x]=new m(n.options),n[d]=b,n[j]=null,n[O]=!1,n[S]=i.name||e.name||B(),n[T]=i.group||n[S],n[P]=!1!==i.enabled,n[_]){var c=n[C]=setTimeout((function(e){return n[_]=!1}),n.options.rollingCountTimeout);"function"==typeof c.unref&&c.unref()}n.action="function"!=typeof e?function(t){return Promise.resolve(e)}:e,i.maxFailures&&t.error(M);var s=function(e){return function(t,r){return n[x].increment(e,r)}};function a(e){return function(t){var n=e[D]=setTimeout((function(){e[d]=w,e[O]=!0,e.emit("halfOpen",e.options.resetTimeout)}),e.options.resetTimeout);"function"==typeof n.unref&&n.unref()}}return n.on("success",s("successes")),n.on("failure",s("failures")),n.on("fallback",s("fallbacks")),n.on("timeout",s("timeouts")),n.on("fire",s("fires")),n.on("reject",s("rejects")),n.on("cacheHit",s("cacheHits")),n.on("cacheMiss",s("cacheMisses")),n.on("open",(function(e){return n[x].open()})),n.on("close",(function(e){return n[x].close()})),n.on("semaphoreLocked",s("semaphoreRejections")),n.on("open",a(f(n))),n.on("success",(function(e){n.halfOpen&&n.close()})),n.options.cache&&k.set(f(n),void 0),n}return s(o,null,[{key:"isOurError",value:function(e){return!!e[A]}}]),s(o,[{key:"close",value:function(){this[d]!==b&&(this[D]&&clearTimeout(this[D]),this[d]=b,this[O]=!1,this.emit("close"))}},{key:"open",value:function(){this[d]!==g&&(this[d]=g,this[O]=!1,this.emit("open"))}},{key:"shutdown",value:function(){this.disable(),this.removeAllListeners(),this[D]&&clearTimeout(this[D]),this[C]&&clearTimeout(this[C]),this.status.shutdown(),this[d]=E,this.emit("shutdown")}},{key:"fallback",value:function(e){var t=e;return e instanceof o&&(t=function(){return e.fire.apply(e,arguments)}),this[j]=t,this}},{key:"fire",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this.call.apply(this,[this.action].concat(t))}},{key:"call",value:function(e){var t=this;if(this.isShutdown){var n=N("The circuit has been shutdown.","ESHUTDOWN");return Promise.reject(n)}for(var r=arguments.length,o=new Array(r>1?r-1:0),i=1;i<r;i++)o[i-1]=arguments[i];var u,c=Array.prototype.slice.call(o);if(this.emit("fire",c),void 0!==k.get(this))return this.emit("cacheHit"),k.get(this);if(this.options.cache&&this.emit("cacheMiss"),!this[P]){var s=this.action.apply(e,c);return"function"==typeof s.then?s:Promise.resolve(s)}if(!this.closed&&!this.pendingClose){var a=N("Breaker is open","EOPENBREAKER");return this.emit("reject",a),F(this,a,c)||Promise.reject(a)}this[O]=!1;var f=!1;return new Promise((function(n,r){var o=Date.now();if(t.semaphore.test()){t.options.timeout&&(u=setTimeout((function(){f=!0;var e=N("Timed out after ".concat(t.options.timeout,"ms"),"ETIMEDOUT"),i=Date.now()-o;t.semaphore.release(),t.emit("timeout",e,i,c),q(e,t,u,c,i,n,r)}),t.options.timeout));try{var i=t.action.apply(e,c),s="function"==typeof i.then?i:Promise.resolve(i);s.then((function(e){f||(clearTimeout(u),t.emit("success",e,Date.now()-o),t.semaphore.release(),n(e),t.options.cache&&k.set(t,s))})).catch((function(e){if(!f){t.semaphore.release();var i=Date.now()-o;q(e,t,u,c,i,n,r)}}))}catch(e){t.semaphore.release();var a=Date.now()-o;q(e,t,u,c,a,n,r)}}else{var l=Date.now()-o,p=N("Semaphore locked","ESEMLOCKED");t.emit("semaphoreLocked",p,l),q(p,t,u,c,l,n,r)}}))}},{key:"clearCache",value:function(){k.set(this,void 0)}},{key:"healthCheck",value:function(e,t){var n=this;if(t=t||5e3,"function"!=typeof e)throw new TypeError("Health check function must be a function");if(isNaN(t))throw new TypeError("Health check interval must be a number");var r=function(t){e.apply(n).catch((function(e){n.emit("healthCheckFailed",e),n.open()}))},o=setInterval(r,t);"function"==typeof o.unref&&o.unref(),r()}},{key:"enable",value:function(){this[P]=!0}},{key:"disable",value:function(){this[P]=!1}},{key:"isShutdown",get:function(){return this[d]===E}},{key:"name",get:function(){return this[S]}},{key:"group",get:function(){return this[T]}},{key:"pendingClose",get:function(){return this[O]}},{key:"closed",get:function(){return this[d]===b}},{key:"opened",get:function(){return this[d]===g}},{key:"halfOpen",get:function(){return this[d]===w}},{key:"status",get:function(){return this[x]}},{key:"stats",get:function(){return this[x].stats}},{key:"enabled",get:function(){return this[P]}},{key:"warmUp",get:function(){return this[_]}},{key:"volumeThreshold",get:function(){return this[L]}}]),o}(y);function q(e,t,n,r,o,i,u){clearTimeout(n),t.options.errorFilter(e)?t.emit("success",e,o):function(e,t,n,r){if(e.emit("failure",t,r,n),e.warmUp)return;var o=e.stats;if(o.fires<e.volumeThreshold&&!e.halfOpen)return;(o.failures/o.fires*100>e.options.errorThresholdPercentage||o.failures>=e.options.maxFailures||e.halfOpen)&&e.open()}(t,e,r,o);var c=F(t,e,r);c?i(c):u(e)}function F(e,t,n){if(e[j]){var o=e[j].apply(e[j],[].concat(r(n),[t]));return e.emit("fallback",o,t),o instanceof Promise?o:Promise.resolve(o)}}function N(e,t){var n=new Error(e);return n.code=t,n[A]=!0,n}var B=function(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,(function(e){var t=16*Math.random()|0;return("x"===e?t:3&t|8).toString(16)}))};e.exports=R}).call(this,n(0))},function(e,t){var n,r,o=e.exports={};function i(){throw new Error("setTimeout has not been defined")}function u(){throw new Error("clearTimeout has not been defined")}function c(e){if(n===setTimeout)return setTimeout(e,0);if((n===i||!n)&&setTimeout)return n=setTimeout,setTimeout(e,0);try{return n(e,0)}catch(t){try{return n.call(null,e,0)}catch(t){return n.call(this,e,0)}}}!function(){try{n="function"==typeof setTimeout?setTimeout:i}catch(e){n=i}try{r="function"==typeof clearTimeout?clearTimeout:u}catch(e){r=u}}();var s,a=[],f=!1,l=-1;function p(){f&&s&&(f=!1,s.length?a=s.concat(a):l=-1,a.length&&h())}function h(){if(!f){var e=c(p);f=!0;for(var t=a.length;t;){for(s=a,a=[];++l<t;)s&&s[l].run();l=-1,t=a.length}s=null,f=!1,function(e){if(r===clearTimeout)return clearTimeout(e);if((r===u||!r)&&clearTimeout)return r=clearTimeout,clearTimeout(e);try{r(e)}catch(t){try{return r.call(null,e)}catch(t){return r.call(this,e)}}}(e)}}function y(e,t){this.fun=e,this.array=t}function m(){}o.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];a.push(new y(e,t)),1!==a.length||f||c(h)},y.prototype.run=function(){this.fun.apply(null,this.array)},o.title="browser",o.browser=!0,o.env={},o.argv=[],o.version="",o.versions={},o.on=m,o.addListener=m,o.once=m,o.off=m,o.removeListener=m,o.removeAllListeners=m,o.emit=m,o.prependListener=m,o.prependOnceListener=m,o.listeners=function(e){return[]},o.binding=function(e){throw new Error("process.binding is not supported")},o.cwd=function(){return"/"},o.chdir=function(e){throw new Error("process.chdir is not supported")},o.umask=function(){return 0}},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t){"function"==typeof Object.create?e.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},function(e,t,n){"use strict";(function(t){var r=n(10);
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */function o(e,t){if(e===t)return 0;for(var n=e.length,r=t.length,o=0,i=Math.min(n,r);o<i;++o)if(e[o]!==t[o]){n=e[o],r=t[o];break}return n<r?-1:r<n?1:0}function i(e){return t.Buffer&&"function"==typeof t.Buffer.isBuffer?t.Buffer.isBuffer(e):!(null==e||!e._isBuffer)}var u=n(2),c=Object.prototype.hasOwnProperty,s=Array.prototype.slice,a="foo"===function(){}.name;function f(e){return Object.prototype.toString.call(e)}function l(e){return!i(e)&&("function"==typeof t.ArrayBuffer&&("function"==typeof ArrayBuffer.isView?ArrayBuffer.isView(e):!!e&&(e instanceof DataView||!!(e.buffer&&e.buffer instanceof ArrayBuffer))))}var p=e.exports=g,h=/\s*function\s+([^\(\s]*)\s*/;function y(e){if(u.isFunction(e)){if(a)return e.name;var t=e.toString().match(h);return t&&t[1]}}function m(e,t){return"string"==typeof e?e.length<t?e:e.slice(0,t):e}function v(e){if(a||!u.isFunction(e))return u.inspect(e);var t=y(e);return"[Function"+(t?": "+t:"")+"]"}function d(e,t,n,r,o){throw new p.AssertionError({message:n,actual:e,expected:t,operator:r,stackStartFunction:o})}function g(e,t){e||d(e,!0,t,"==",p.ok)}function b(e,t,n,r){if(e===t)return!0;if(i(e)&&i(t))return 0===o(e,t);if(u.isDate(e)&&u.isDate(t))return e.getTime()===t.getTime();if(u.isRegExp(e)&&u.isRegExp(t))return e.source===t.source&&e.global===t.global&&e.multiline===t.multiline&&e.lastIndex===t.lastIndex&&e.ignoreCase===t.ignoreCase;if(null!==e&&"object"==typeof e||null!==t&&"object"==typeof t){if(l(e)&&l(t)&&f(e)===f(t)&&!(e instanceof Float32Array||e instanceof Float64Array))return 0===o(new Uint8Array(e.buffer),new Uint8Array(t.buffer));if(i(e)!==i(t))return!1;var c=(r=r||{actual:[],expected:[]}).actual.indexOf(e);return-1!==c&&c===r.expected.indexOf(t)||(r.actual.push(e),r.expected.push(t),function(e,t,n,r){if(null==e||null==t)return!1;if(u.isPrimitive(e)||u.isPrimitive(t))return e===t;if(n&&Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;var o=w(e),i=w(t);if(o&&!i||!o&&i)return!1;if(o)return e=s.call(e),t=s.call(t),b(e,t,n);var c,a,f=j(e),l=j(t);if(f.length!==l.length)return!1;for(f.sort(),l.sort(),a=f.length-1;a>=0;a--)if(f[a]!==l[a])return!1;for(a=f.length-1;a>=0;a--)if(c=f[a],!b(e[c],t[c],n,r))return!1;return!0}(e,t,n,r))}return n?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function O(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function E(e,t,n,r){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof n&&(r=n,n=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(n&&n.name?" ("+n.name+").":".")+(r?" "+r:"."),e&&!o&&d(o,n,"Missing expected exception"+r);var i="string"==typeof r,c=!e&&o&&!n;if((!e&&u.isError(o)&&i&&O(o,n)||c)&&d(o,n,"Got unwanted exception"+r),e&&o&&n&&!O(o,n)||!e&&o)throw o}p.AssertionError=function(e){var t;this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=m(v((t=this).actual),128)+" "+t.operator+" "+m(v(t.expected),128),this.generatedMessage=!0);var n=e.stackStartFunction||d;if(Error.captureStackTrace)Error.captureStackTrace(this,n);else{var r=new Error;if(r.stack){var o=r.stack,i=y(n),u=o.indexOf("\n"+i);if(u>=0){var c=o.indexOf("\n",u+1);o=o.substring(c+1)}this.stack=o}}},u.inherits(p.AssertionError,Error),p.fail=d,p.ok=g,p.equal=function(e,t,n){e!=t&&d(e,t,n,"==",p.equal)},p.notEqual=function(e,t,n){e==t&&d(e,t,n,"!=",p.notEqual)},p.deepEqual=function(e,t,n){b(e,t,!1)||d(e,t,n,"deepEqual",p.deepEqual)},p.deepStrictEqual=function(e,t,n){b(e,t,!0)||d(e,t,n,"deepStrictEqual",p.deepStrictEqual)},p.notDeepEqual=function(e,t,n){b(e,t,!1)&&d(e,t,n,"notDeepEqual",p.notDeepEqual)},p.notDeepStrictEqual=function e(t,n,r){b(t,n,!0)&&d(t,n,r,"notDeepStrictEqual",e)},p.strictEqual=function(e,t,n){e!==t&&d(e,t,n,"===",p.strictEqual)},p.notStrictEqual=function(e,t,n){e===t&&d(e,t,n,"!==",p.notStrictEqual)},p.throws=function(e,t,n){E(!0,e,t,n)},p.doesNotThrow=function(e,t,n){E(!1,e,t,n)},p.ifError=function(e){if(e)throw e},p.strict=r((function e(t,n){t||d(t,!0,n,"==",e)}),p,{equal:p.strictEqual,deepEqual:p.deepStrictEqual,notEqual:p.notStrictEqual,notDeepEqual:p.notDeepStrictEqual}),p.strict.strict=p.strict;var j=Object.keys||function(e){var t=[];for(var n in e)c.call(e,n)&&t.push(n);return t}}).call(this,n(1))},function(e,t,n){"use strict";
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/var r=Object.getOwnPropertySymbols,o=Object.prototype.hasOwnProperty,i=Object.prototype.propertyIsEnumerable;function u(e){if(null==e)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(e)}e.exports=function(){try{if(!Object.assign)return!1;var e=new String("abc");if(e[5]="de","5"===Object.getOwnPropertyNames(e)[0])return!1;for(var t={},n=0;n<10;n++)t["_"+String.fromCharCode(n)]=n;if("0123456789"!==Object.getOwnPropertyNames(t).map((function(e){return t[e]})).join(""))return!1;var r={};return"abcdefghijklmnopqrst".split("").forEach((function(e){r[e]=e})),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},r)).join("")}catch(e){return!1}}()?Object.assign:function(e,t){for(var n,c,s=u(e),a=1;a<arguments.length;a++){for(var f in n=Object(arguments[a]))o.call(n,f)&&(s[f]=n[f]);if(r){c=r(n);for(var l=0;l<c.length;l++)i.call(n,c[l])&&(s[c[l]]=n[c[l]])}}return s}},function(e,t,n){"use strict";function r(e){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function o(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function i(e,t){return!t||"object"!==r(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function u(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],(function(){}))),!0}catch(e){return!1}}function c(e){return(c=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function s(e,t){return(s=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}var a=Symbol("window"),f=Symbol("buckets"),l=Symbol("timeout"),p=Symbol("percentiles"),h=Symbol("bucket-interval"),y=Symbol("snapshot-interval"),m=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&s(e,t)}(b,e);var t,n,r,m,g=(t=b,function(){var e,n=c(t);if(u()){var r=c(this).constructor;e=Reflect.construct(n,arguments,r)}else e=n.apply(this,arguments);return i(this,e)});function b(e){var t;!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,b),(t=g.call(this))[f]=e.rollingCountBuckets,t[l]=e.rollingCountTimeout,t[a]=new Array(t[f]),t[p]=[0,.25,.5,.75,.9,.95,.99,.995,1],t.rollingPercentilesEnabled=e.rollingPercentilesEnabled;for(var n=0;n<t[f];n++)t[a][n]=d();var r=Math.floor(t[l]/t[f]);return t[h]=setInterval(v(t[a]),r),"function"==typeof t[h].unref&&t[h].unref(),t[y]=setInterval((function(e){return t.emit("snapshot",t.stats)}),r),"function"==typeof t[y].unref&&t[y].unref(),t}return n=b,(r=[{key:"increment",value:function(e,t){this[a][0][e]++,"successes"!==e&&"failures"!==e&&"timeouts"!==e||this[a][0].latencyTimes.push(t||0)}},{key:"open",value:function(){this[a][0].isCircuitBreakerOpen=!0}},{key:"close",value:function(){this[a][0].isCircuitBreakerOpen=!1}},{key:"shutdown",value:function(){this.removeAllListeners(),clearInterval(this[h]),clearInterval(this[y])}},{key:"stats",get:function(){var e=this,t=this[a].reduce((function(t,n){return n?(Object.keys(t).forEach((function(e){"latencyTimes"!==e&&"percentiles"!==e&&(t[e]+=n[e]||0)})),e.rollingPercentilesEnabled&&t.latencyTimes.push.apply(t.latencyTimes,n.latencyTimes||[]),t):t}),d());return this.rollingPercentilesEnabled?(t.latencyTimes.sort((function(e,t){return e-t})),t.latencyTimes.length?t.latencyMean=t.latencyTimes.reduce((function(e,t){return e+t}),0)/t.latencyTimes.length:t.latencyMean=0,this[p].forEach((function(e){t.percentiles[e]=function(e,t){if(0===e)return t[0]||0;var n=Math.ceil(e*t.length);return t[n-1]||0}(e,t.latencyTimes)}))):(t.latencyMean=-1,this[p].forEach((function(e){t.percentiles[e]=-1}))),t}},{key:"window",get:function(){return this[a].slice()}}])&&o(n.prototype,r),m&&o(n,m),b}(n(3).EventEmitter),v=function(e){return function(t){e.pop(),e.unshift(d())}},d=function(e){return{failures:0,fallbacks:0,successes:0,rejects:0,fires:0,timeouts:0,cacheHits:0,cacheMisses:0,semaphoreRejections:0,percentiles:{},latencyTimes:[]}};e.exports=m},function(e,t,n){"use strict";e.exports=function(e){var t=[],n=e,r={take:o,release:i,test:function(){return!(n<1)&&(o()&&!0)}};return Object.defineProperty(r,"count",{get:function(e){return n},enumerable:!0}),r;function o(e){return n>0?(--n,Promise.resolve(i)):new Promise((function(r,o){t.push((function(e){--n,r(i)})),e&&setTimeout((function(n){t.shift();var r=new Error("Timed out after ".concat(e,"ms"));r.code="ETIMEDOUT",o(r)}),e)}))}function i(){n++,t.length>0&&t.shift()()}}}])}));
+//# sourceMappingURL=opossum.min.map