| 1 | {"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/core-js/internals/array-buffer-view-core.js","webpack:///./node_modules/core-js/internals/global.js","webpack:///./node_modules/core-js/internals/fails.js","webpack:///./node_modules/core-js/internals/well-known-symbol.js","webpack:///./node_modules/core-js/internals/has.js","webpack:///./node_modules/core-js/internals/to-length.js","webpack:///../src/index.ts","webpack:///./node_modules/core-js/internals/descriptors.js","webpack:///./node_modules/core-js/internals/is-object.js","webpack:///./node_modules/core-js/internals/object-define-property.js","webpack:///./node_modules/core-js/internals/create-non-enumerable-property.js","webpack:///./packages/dd-trace/src/platform/index.js","webpack:///./node_modules/core-js/internals/typed-array-constructor.js","webpack:///./node_modules/core-js/internals/an-object.js","webpack:///./node_modules/core-js/internals/to-object.js","webpack:///./node_modules/core-js/internals/array-iteration.js","webpack:///./node_modules/core-js/internals/to-integer.js","webpack:///./packages/dd-trace/src/log.js","webpack:///./node_modules/core-js/internals/redefine.js","webpack:///./node_modules/core-js/internals/internal-state.js","webpack:///./packages/dd-trace/src/constants.js","webpack:///./packages/dd-trace/src/id.js","webpack:///./node_modules/core-js/internals/to-indexed-object.js","webpack:///./node_modules/core-js/internals/iterators.js","webpack:///./node_modules/core-js/internals/object-set-prototype-of.js","webpack:///../src/span.ts","webpack:///./packages/dd-trace/src/opentracing/span_context.js","webpack:///./node_modules/core-js/internals/export.js","webpack:///./node_modules/core-js/internals/create-property-descriptor.js","webpack:///./node_modules/core-js/internals/indexed-object.js","webpack:///./node_modules/core-js/internals/uid.js","webpack:///./node_modules/core-js/internals/hidden-keys.js","webpack:///./node_modules/core-js/internals/path.js","webpack:///./node_modules/core-js/internals/to-absolute-index.js","webpack:///./node_modules/core-js/internals/function-bind-context.js","webpack:///./node_modules/core-js/internals/classof.js","webpack:///./node_modules/core-js/internals/an-instance.js","webpack:///./node_modules/core-js/internals/set-to-string-tag.js","webpack:///./node_modules/core-js/internals/object-create.js","webpack:///./node_modules/core-js/internals/object-get-prototype-of.js","webpack:///./node_modules/core-js/internals/species-constructor.js","webpack:///./node_modules/url-parse/index.js","webpack:///./ext/tags.js","webpack:///./node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack:///./node_modules/core-js/internals/classof-raw.js","webpack:///./node_modules/core-js/internals/require-object-coercible.js","webpack:///./node_modules/core-js/internals/to-primitive.js","webpack:///./node_modules/core-js/internals/set-global.js","webpack:///./node_modules/core-js/internals/shared-store.js","webpack:///./node_modules/core-js/internals/shared-key.js","webpack:///./node_modules/core-js/internals/is-pure.js","webpack:///./node_modules/core-js/internals/get-built-in.js","webpack:///./node_modules/core-js/internals/object-get-own-property-names.js","webpack:///./node_modules/core-js/internals/array-includes.js","webpack:///./node_modules/core-js/internals/enum-bug-keys.js","webpack:///./node_modules/core-js/internals/a-function.js","webpack:///./node_modules/core-js/internals/to-string-tag-support.js","webpack:///./node_modules/core-js/internals/define-iterator.js","webpack:///./node_modules/core-js/modules/es.object.to-string.js","webpack:///./node_modules/core-js/internals/typed-array-constructors-require-wrappers.js","webpack:///../src/noop.ts","webpack:///../src/tracer.ts","webpack:///./packages/dd-trace/src/scope/base.js","webpack:///./packages/dd-trace/src/noop/span.js","webpack:///./packages/dd-trace/src/scope/noop/scope_manager.js","webpack:///./node_modules/core-js/internals/object-property-is-enumerable.js","webpack:///./node_modules/core-js/internals/ie8-dom-define.js","webpack:///./node_modules/core-js/internals/document-create-element.js","webpack:///./node_modules/core-js/internals/inspect-source.js","webpack:///./node_modules/core-js/internals/shared.js","webpack:///./node_modules/core-js/internals/object-keys-internal.js","webpack:///./node_modules/core-js/internals/object-get-own-property-symbols.js","webpack:///./node_modules/core-js/internals/is-forced.js","webpack:///./node_modules/core-js/internals/object-keys.js","webpack:///./node_modules/core-js/internals/collection.js","webpack:///./node_modules/core-js/internals/internal-metadata.js","webpack:///./node_modules/core-js/internals/iterate.js","webpack:///./node_modules/core-js/internals/is-array-iterator-method.js","webpack:///./node_modules/core-js/internals/native-symbol.js","webpack:///./node_modules/core-js/internals/get-iterator-method.js","webpack:///./node_modules/core-js/internals/check-correctness-of-iteration.js","webpack:///./node_modules/core-js/internals/inherit-if-required.js","webpack:///./node_modules/core-js/internals/collection-strong.js","webpack:///./node_modules/core-js/internals/redefine-all.js","webpack:///./node_modules/core-js/internals/iterators-core.js","webpack:///./node_modules/core-js/internals/set-species.js","webpack:///./node_modules/core-js/modules/es.string.iterator.js","webpack:///./node_modules/core-js/modules/web.dom-collections.iterator.js","webpack:///./node_modules/core-js/modules/es.array.iterator.js","webpack:///./node_modules/core-js/internals/array-buffer-native.js","webpack:///./node_modules/core-js/internals/to-index.js","webpack:///./node_modules/core-js/internals/array-fill.js","webpack:///./node_modules/core-js/internals/to-offset.js","webpack:///./node_modules/core-js/internals/typed-array-from.js","webpack:///./node_modules/core-js/internals/array-reduce.js","webpack:///../src/span_context.ts","webpack:///../src/functions.ts","webpack:///../src/constants.ts","webpack:///../src/reference.ts","webpack:///../../src/mock_tracer/mock_context.ts","webpack:///../../src/mock_tracer/mock_span.ts","webpack:///./packages/dd-trace/src/plugins/util/http.js","webpack:///./ext/index.js","webpack:///./ext/formats.js","webpack:///./ext/priority.js","webpack:///./packages/dd-trace/src/noop/span_context.js","webpack:///./packages/dd-trace/src/scope/scope_manager.js","webpack:///./packages/dd-trace/src/tagger.js","webpack:///./packages/dd-trace/src/sampler.js","webpack:///./node_modules/limiter/lib/tokenBucket.js","webpack:///./packages/dd-trace/src/opentracing/propagation/text_map.js","webpack:///./ext/scopes.js","webpack:///./packages/dd-trace/src/util.js","webpack:///./browser.js","webpack:///./packages/dd-trace/browser.js","webpack:///./node_modules/core-js/stable/object/assign.js","webpack:///./node_modules/core-js/es/object/assign.js","webpack:///./node_modules/core-js/modules/es.object.assign.js","webpack:///./node_modules/core-js/internals/native-weak-map.js","webpack:///./node_modules/core-js/internals/copy-constructor-properties.js","webpack:///./node_modules/core-js/internals/own-keys.js","webpack:///./node_modules/core-js/internals/object-assign.js","webpack:///./node_modules/core-js/stable/set/index.js","webpack:///./node_modules/core-js/es/set/index.js","webpack:///./node_modules/core-js/modules/es.set.js","webpack:///./node_modules/core-js/internals/freezing.js","webpack:///./node_modules/core-js/internals/use-symbol-as-uid.js","webpack:///./node_modules/core-js/internals/iterator-close.js","webpack:///./node_modules/core-js/internals/a-possible-prototype.js","webpack:///./node_modules/core-js/internals/object-define-properties.js","webpack:///./node_modules/core-js/internals/html.js","webpack:///./node_modules/core-js/internals/create-iterator-constructor.js","webpack:///./node_modules/core-js/internals/correct-prototype-getter.js","webpack:///./node_modules/core-js/internals/object-to-string.js","webpack:///./node_modules/core-js/internals/string-multibyte.js","webpack:///./node_modules/core-js/internals/dom-iterables.js","webpack:///./node_modules/core-js/internals/add-to-unscopables.js","webpack:///./node_modules/core-js/stable/map/index.js","webpack:///./node_modules/core-js/es/map/index.js","webpack:///./node_modules/core-js/modules/es.map.js","webpack:///./node_modules/core-js/stable/typed-array/index.js","webpack:///./node_modules/core-js/es/typed-array/index.js","webpack:///./node_modules/core-js/modules/es.typed-array.int8-array.js","webpack:///./node_modules/core-js/internals/array-buffer.js","webpack:///./node_modules/core-js/internals/ieee754.js","webpack:///./node_modules/core-js/internals/to-positive-integer.js","webpack:///./node_modules/core-js/internals/array-species-create.js","webpack:///./node_modules/core-js/internals/is-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.uint8-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.uint8-clamped-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.int16-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.uint16-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.int32-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.uint32-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.float32-array.js","webpack:///./node_modules/core-js/modules/es.typed-array.float64-array.js","webpack:///./node_modules/core-js/es/typed-array/methods.js","webpack:///./node_modules/core-js/modules/es.typed-array.from.js","webpack:///./node_modules/core-js/modules/es.typed-array.of.js","webpack:///./node_modules/core-js/modules/es.typed-array.copy-within.js","webpack:///./node_modules/core-js/internals/array-copy-within.js","webpack:///./node_modules/core-js/modules/es.typed-array.every.js","webpack:///./node_modules/core-js/modules/es.typed-array.fill.js","webpack:///./node_modules/core-js/modules/es.typed-array.filter.js","webpack:///./node_modules/core-js/modules/es.typed-array.find.js","webpack:///./node_modules/core-js/modules/es.typed-array.find-index.js","webpack:///./node_modules/core-js/modules/es.typed-array.for-each.js","webpack:///./node_modules/core-js/modules/es.typed-array.includes.js","webpack:///./node_modules/core-js/modules/es.typed-array.index-of.js","webpack:///./node_modules/core-js/modules/es.typed-array.join.js","webpack:///./node_modules/core-js/modules/es.typed-array.last-index-of.js","webpack:///./node_modules/core-js/internals/array-last-index-of.js","webpack:///./node_modules/core-js/internals/array-method-is-strict.js","webpack:///./node_modules/core-js/internals/array-method-uses-to-length.js","webpack:///./node_modules/core-js/modules/es.typed-array.map.js","webpack:///./node_modules/core-js/modules/es.typed-array.reduce.js","webpack:///./node_modules/core-js/modules/es.typed-array.reduce-right.js","webpack:///./node_modules/core-js/modules/es.typed-array.reverse.js","webpack:///./node_modules/core-js/modules/es.typed-array.set.js","webpack:///./node_modules/core-js/modules/es.typed-array.slice.js","webpack:///./node_modules/core-js/modules/es.typed-array.some.js","webpack:///./node_modules/core-js/modules/es.typed-array.sort.js","webpack:///./node_modules/core-js/modules/es.typed-array.subarray.js","webpack:///./node_modules/core-js/modules/es.typed-array.to-locale-string.js","webpack:///./node_modules/core-js/modules/es.typed-array.to-string.js","webpack:///./node_modules/core-js/modules/es.typed-array.iterator.js","webpack:///./packages/dd-trace/src/platform/browser/index.js","webpack:///./packages/dd-trace/src/platform/browser/crypto.js","webpack:///./packages/dd-trace/src/platform/browser/now.js","webpack:///./packages/dd-trace/src/platform/browser/env.js","webpack:///./packages/dd-trace/src/platform/browser/tags.js","webpack:///./packages/dd-trace/src/platform/browser/validate.js","webpack:///./packages/dd-trace/src/platform/browser/metrics.js","webpack:///./packages/dd-trace/src/plugins/browser.js","webpack:///./packages/datadog-plugin-fetch/src/index.js","webpack:///./node_modules/requires-port/index.js","webpack:///./node_modules/querystringify/index.js","webpack:///../src/binary_carrier.ts","webpack:///../../src/ext/tags.ts","webpack:///../../src/mock_tracer/index.ts","webpack:///../../src/mock_tracer/mock_tracer.ts","webpack:///../../src/mock_tracer/mock_report.ts","webpack:///../src/global_tracer.ts","webpack:///./packages/dd-trace/src/plugins/util/tx.js","webpack:///./packages/datadog-plugin-xmlhttprequest/src/index.js","webpack:///./packages/dd-trace/src/platform/browser/startup-log.js","webpack:///./packages/dd-trace/src/platform/browser/exporter.js","webpack:///./packages/dd-trace/src/exporters/browser/index.js","webpack:///./packages/dd-trace/src/platform/browser/loader.js","webpack:///./packages/dd-trace/src/scope/zone.js","webpack:///./ext/kinds.js","webpack:///./ext/types.js","webpack:///./ext/exporters.js","webpack:///./packages/dd-trace/src/proxy.js","webpack:///./packages/dd-trace/src/noop/tracer.js","webpack:///./packages/dd-trace/src/scope/noop/scope.js","webpack:///./packages/dd-trace/src/tracer.js","webpack:///./packages/dd-trace/src/opentracing/tracer.js","webpack:///./packages/dd-trace/src/opentracing/span.js","webpack:///./packages/dd-trace/src/span_processor.js","webpack:///./packages/dd-trace/src/format.js","webpack:///./packages/dd-trace/src/priority_sampler.js","webpack:///./packages/dd-trace/src/rate_limiter.js","webpack:///./node_modules/limiter/index.js","webpack:///./node_modules/limiter/lib/rateLimiter.js","webpack:///./node_modules/limiter/lib/clock.js","webpack:///./node_modules/lodash.pick/index.js","webpack:///./packages/dd-trace/src/opentracing/propagation/http.js","webpack:///./packages/dd-trace/src/opentracing/propagation/binary.js","webpack:///./packages/dd-trace/src/opentracing/propagation/log.js","webpack:///./packages/dd-trace/src/config.js","webpack:///./node_modules/koalas/index.js","webpack:///./packages/dd-trace/src/instrumenter.js","webpack:///./node_modules/shimmer/index.js","webpack:///./packages/dd-trace/src/analytics_sampler.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","NAME","NATIVE_ARRAY_BUFFER","require","DESCRIPTORS","global","isObject","has","classof","createNonEnumerableProperty","redefine","f","getPrototypeOf","setPrototypeOf","wellKnownSymbol","uid","Int8Array","Int8ArrayPrototype","Uint8ClampedArray","Uint8ClampedArrayPrototype","TypedArray","TypedArrayPrototype","ObjectPrototype","isPrototypeOf","TO_STRING_TAG","TYPED_ARRAY_TAG","NATIVE_ARRAY_BUFFER_VIEWS","opera","TYPED_ARRAY_TAG_REQIRED","TypedArrayConstructorsList","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigIntArrayConstructorsList","BigInt64Array","BigUint64Array","isTypedArray","it","klass","Function","TypeError","this","undefined","aTypedArray","aTypedArrayConstructor","C","ARRAY","TypedArrayConstructor","exportTypedArrayMethod","KEY","forced","exportTypedArrayStaticMethod","error","isView","check","Math","globalThis","window","self","exec","shared","NATIVE_SYMBOL","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","toInteger","min","argument","__export","fails","IE8_DOM_DEFINE","anObject","toPrimitive","nativeDefineProperty","O","P","Attributes","definePropertyModule","createPropertyDescriptor","use","impl","assign","configure","config","_config","$","TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS","ArrayBufferViewCore","ArrayBufferModule","anInstance","toLength","toIndex","toOffset","getOwnPropertyNames","typedArrayFrom","forEach","setSpecies","getOwnPropertyDescriptorModule","InternalStateModule","inheritIfRequired","getInternalState","setInternalState","set","nativeGetOwnPropertyDescriptor","round","RangeError","ArrayBuffer","DataView","fromList","list","index","length","result","addGetter","isArrayBuffer","isTypedArrayIndex","target","String","wrappedGetOwnPropertyDescriptor","wrappedDefineProperty","descriptor","configurable","writable","stat","getOwnPropertyDescriptor","TYPE","wrapper","CLAMPED","BYTES","match","CONSTRUCTOR_NAME","GETTER","SETTER","NativeTypedArrayConstructor","TypedArrayConstructorPrototype","exported","addElement","that","data","view","byteOffset","setter","dummy","typedArrayOffset","$length","offset","buffer","byteLength","$len","constructor","sham","requireObjectCoercible","IndexedObject","toObject","arraySpeciesCreate","push","createMethod","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_OUT","NO_HOLES","$this","callbackfn","specificCreate","boundFunction","map","filter","some","every","find","findIndex","filterOut","ceil","floor","isNaN","NoopSpan","_default","debug","msg","console","info","warn","_logLevels","_checkLogLevel","logLevel","toLowerCase","trim","processMsg","withNoop","fn","log","_tracer","scope","activate","_noopSpan","_isLogLevelEnabled","level","_logLevel","logger","_logger","toggle","enabled","tracer","_enabled","__noopSpan","reset","func","cache","_deprecate","code","message","apply","arguments","err","stack","Error","deprecate","setGlobal","inspectSource","enforceInternalState","enforce","TEMPLATE","split","options","state","unsafe","simple","noTargetGet","source","join","NATIVE_WEAK_MAP","objectHas","sharedKey","hiddenKeys","WeakMap","store","wmget","wmhas","wmset","metadata","facade","STATE","getterFor","type","SAMPLE_RATE_METRIC_KEY","SAMPLING_PRIORITY_KEY","ANALYTICS_KEY","ORIGIN_KEY","HOSTNAME_KEY","REFERENCE_NOOP","SAMPLING_RULE_DECISION","SAMPLING_LIMIT_DECISION","SAMPLING_AGENT_DECISION","platform","zeroId","seed","crypto","getRandomValues","Array","pad","byte","toString","Identifier","radix","_isUint64BE","_buffer","str","raddix","len","pos","high","low","sign","chr","parseInt","writeUInt32BE","fromString","hi","randomUInt32","lo","pseudoRandom","size","substring","createBuffer","readInt32","mod","toNumberString","subarray","random","aPossiblePrototype","CORRECT_SETTER","test","proto","__proto__","Span","DatadogSpanContext","props","_traceId","traceId","_spanId","spanId","_parentId","parentId","_name","_isFinished","isFinished","_tags","tags","_sampling","sampling","_baggageItems","baggageItems","_traceFlags","traceFlags","sampled","_noop","noop","_trace","trace","started","finished","SpanContext","copyConstructorProperties","isForced","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","bitmap","propertyIsEnumerable","id","postfix","max","integer","aFunction","a","b","TO_STRING_TAG_SUPPORT","classofRaw","CORRECT_ARGUMENTS","tag","tryGet","callee","Constructor","TAG","activeXDocument","defineProperties","enumBugKeys","html","documentCreateElement","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObject","document","domain","ActiveXObject","iframeDocument","iframe","write","close","temp","parentWindow","NullProtoObjectViaActiveX","style","display","appendChild","src","contentWindow","open","F","Properties","CORRECT_PROTOTYPE_GETTER","SPECIES","defaultConstructor","S","required","qs","slashes","protocolre","left","RegExp","trimLeft","replace","rules","address","NaN","ignore","hash","query","lolcation","loc","location","finaldestination","protocol","Url","unescape","pathname","href","extractProtocol","rest","parser","relative","extracted","parse","instruction","instructions","slice","url","indexOf","charAt","base","path","concat","last","unshift","up","splice","resolve","port","host","hostname","username","password","auth","origin","part","pop","char","ins","stringify","SERVICE_NAME","RESOURCE_NAME","SPAN_TYPE","SPAN_KIND","SAMPLING_PRIORITY","ANALYTICS","ERROR","MANUAL_KEEP","MANUAL_DROP","MEASURED","HTTP_URL","HTTP_METHOD","HTTP_STATUS_CODE","HTTP_ROUTE","HTTP_REQUEST_HEADERS","HTTP_RESPONSE_HEADERS","ANALYTICS_SAMPLE_RATE","propertyIsEnumerableModule","toIndexedObject","input","PREFERRED_STRING","val","valueOf","keys","variable","namespace","method","internalObjectKeys","toAbsoluteIndex","IS_INCLUDES","el","fromIndex","includes","createIteratorConstructor","setToStringTag","IS_PURE","Iterators","IteratorsCore","IteratorPrototype","BUGGY_SAFARI_ITERATORS","ITERATOR","returnThis","Iterable","IteratorConstructor","next","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","values","checkCorrectnessOfIteration","iterable","Scope","emitter","wrapMethod","wrapAddListener","wrapRemoveListener","wrapRemoveAllListeners","__is_dd_emitter","_active","span","callback","_activate","e","setTag","_bindEmitter","_bindPromise","_bindFn","_unbindFn","_unbindPromise","_unbindEmitter","spanOrActive","_spanOrActive","bound","_datadog_unbound","_isEmitter","_wrapEmitter","__dd_span","__dd_scope","promise","_isPromise","wrapThen","then","active","emit","on","addListener","removeListener","onFulfilled","onRejected","args","eventName","listener","_datadog_events","events","listeners","delete","removeAllListeners","original","NoopSpanContext","parent","_noopTracer","_noopContext","_createContext","singleton","ScopeManager","finishSpanOnClose","nativePropertyIsEnumerable","NASHORN_BUG","1","V","createElement","EXISTS","functionToString","version","copyright","names","getOwnPropertySymbols","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","InternalMetadataModule","iterate","common","IS_WEAK","ADDER","NativeConstructor","NativePrototype","fixMethod","nativeMethod","getConstructor","REQUIRED","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","AS_ENTRIES","clear","setStrong","FREEZING","METADATA","isExtensible","setMetadata","objectID","weakData","meta","fastKey","getWeakData","onFreeze","isArrayIteratorMethod","getIteratorMethod","iteratorClose","Result","stopped","unboundFunction","iterator","iterFn","step","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","done","ArrayPrototype","SAFE_CLOSING","called","iteratorWithReturn","from","SKIP_CLOSING","ITERATION_SUPPORT","Wrapper","NewTarget","NewTargetPrototype","redefineAll","defineIterator","internalStateGetterFor","first","define","previous","entry","getEntry","removed","prev","add","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","iterated","kind","PrototypeOfArrayIteratorPrototype","arrayIterator","NEW_ITERATOR_PROTOTYPE","getBuiltIn","point","DOMIterables","ArrayIteratorMethods","ArrayValues","COLLECTION_NAME","Collection","CollectionPrototype","METHOD_NAME","addToUnscopables","Arguments","number","argumentsLength","end","endPos","toPositiveInteger","mapfn","mapping","iteratorMethod","IS_RIGHT","memo","right","spanContext","span_1","default","context","reference_1","Reference","_finishMs","finishTime","Date","now","MockSpan","tx","http","isPeer","peers","peer","formats","kinds","priority","types","exporters","opentracing","TEXT_MAP","FORMAT_TEXT_MAP","HTTP_HEADERS","FORMAT_HTTP_HEADERS","BINARY","FORMAT_BINARY","LOG","USER_REJECT","AUTO_REJECT","AUTO_KEEP","USER_KEEP","carrier","keyValuePairs","reduce","isArray","Sampler","rate","_rate","TokenBucket","bucketSize","tokensPerInterval","interval","parentBucket","lastDrip","removeTokens","count","process","nextTick","drip","comeBackLater","remainingTokens","Number","POSITIVE_INFINITY","waitInterval","setTimeout","tryRemoveTokens","deltaMS","dripAmount","pick","traceKey","spanKey","originKey","samplingKey","b3TraceKey","b3TraceExpr","b3SpanKey","b3SpanExpr","b3HeaderExpr","baggageExpr","logKeys","TextMapPropagator","toTraceId","toSpanId","_injectOrigin","_injectSamplingPriority","_injectBaggageItems","_injectB3","JSON","_extractSpanContext","_extractOrigin","_extractBaggageItems","_extractSamplingPriority","isInteger","experimental","b3","_extractContext","_extractDatadogContext","_extractB3Context","_isSampled","_extractGenericContext","_extractB3Headers","_extractB3SingleHeader","_extractB3MultipleHeaders","parts","ASYNC_RESOURCE","ASYNC_LOCAL_STORAGE","ASYNC_HOOKS","NOOP","isTrue","isFalse","browser","ext","ddtrace","ownKeys","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","objectKeys","nativeAssign","A","B","symbol","T","j","Set","collection","collectionStrong","init","preventExtensions","returnMethod","CONVERT_TO_STRING","second","position","charCodeAt","codeAt","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","UNSCOPABLES","Map","createTypedArrayConstructor","IEEE754","arrayFill","NativeArrayBuffer","$ArrayBuffer","$DataView","$DataViewPrototype","packIEEE754","pack","unpackIEEE754","unpack","packInt8","packInt16","packInt32","unpackInt32","packFloat32","packFloat64","isLittleEndian","intIndex","bytes","start","reverse","conversion","ArrayBufferPrototype","testView","nativeSetInt8","setInt8","getInt8","setUint8","bufferLength","getUint8","getInt16","getUint16","getInt32","getUint32","getFloat32","getFloat64","setInt16","setUint16","setInt32","setUint32","setFloat32","setFloat64","abs","pow","LN2","mantissaLength","exponent","mantissa","exponentLength","eMax","eBias","rt","nBits","originalArray","arg","$copyWithin","copyWithin","to","inc","$every","$fill","$filter","speciesConstructor","$find","predicate","$findIndex","$forEach","$includes","searchElement","$indexOf","$join","separator","$lastIndexOf","arrayMethodIsStrict","arrayMethodUsesToLength","nativeLastIndexOf","lastIndexOf","NEGATIVE_ZERO","STRICT_METHOD","USES_TO_LENGTH","ACCESSORS","thrower","argument0","argument1","$map","$reduce","$reduceRight","middle","arrayLike","$slice","$some","$sort","sort","comparefn","begin","beginIndex","BYTES_PER_ELEMENT","$toLocaleString","toLocaleString","TO_LOCALE_STRING_BUG","Uint8ArrayPrototype","arrayToString","arrayJoin","IS_NOT_ARRAY_METHOD","ArrayIterators","arrayValues","arrayKeys","arrayEntries","nativeTypedArrayIterator","CORRECT_ITER_NAME","typedArrayValues","env","validate","metrics","plugins","startupLog","exporter","Loader","engine","service","appVersion","off","getScope","profiler","msCrypto","performance","rum","DD_RUM","getInternalContext","track","finish","boolean","histogram","gauge","increment","decrement","URL","REFERENCE_CHILD_OF","createWrapFetch","fetch","_datadog_wrapper","resource","_service","getMethod","getUrl","childOf","startsWith","isFlush","_url","startSpan","references","format","_peers","headers","inject","res","status","wrap","patch","unpatch","unwrapFetch","decode","decodeURIComponent","encode","encodeURIComponent","obj","prefix","pairs","_this","MockReport","setHost","wrapPromise","wrapCallback","addTags","xhr","_datadog_url","setRequestHeader","XMLHttpRequest","_datadog_method","send","body","addEventListener","createWrapSend","unwrap","setStartupLogConfig","setStartupLogInstrumenter","setSamplingRules","BrowserExporter","clientToken","site","_queue","_flushing","_clientToken","_env","_size","_flush","spans","_traceMeta","json","navigator","sendBeacon","keepalive","req","addTag","instrumenter","_instrumenter","plugin","unload","load","instrumentation","nodule","override","Base","Zone","current","spec","properties","_datadog_span","fork","run","SERVER","CLIENT","PRODUCER","CONSUMER","HTTP","WEB","BROWSER","AGENT","BaseTracer","Tracer","NoopTracer","DatadogTracer","Config","Instrumenter","analyticsSampler","runtimeMetrics","analytics","enable","setUrl","extract","scopeManager","currentSpan","getRumData","_scopeManager","_scope","_span","_finishSpanOnClose","scopes","getScopeManager","orphanable","addError","optionsObj","lastArgId","cb","scopeBoundCb","_exporter","_enableGetRumData","traceTime","SpanProcessor","PrioritySampler","HttpPropagator","BinaryPropagator","LogPropagator","constants","REFERENCE_FOLLOWS_FROM","Exporter","_version","_logInjection","logInjection","_analytics","_debug","_internalErrors","internalErrors","_prioritySampler","sampler","_processor","_sampler","sampleRate","enableGetRumData","_propagators","reportHostname","_hostname","fields","_startSpanInternal","reference","ref","referencedContext","getParent","isSampled","operationName","startTime","sample","tagger","DatadogSpan","processor","prioritySampler","_parentTracer","_spanContext","_startTime","_getTime","_handle","resourceName","ticks","_duration","parseFloat","_erase","formattedSpans","export","seen","readInt8","isUrl","prop","addObjectTag","serialize","formatted","trace_id","span_id","parent_id","duration","formatSpan","extractError","extractTags","extractAnalytics","RateLimiter","rateLimit","_rules","_normalizeRules","_limiter","update","_getContext","rule","_findRule","_isSampledByRule","_isSampledByRateLimit","_isSampledByAgent","_getPriority","rates","samplers","_samplers","samplingPriority","allowed","isAllowed","effectiveRate","_matchRule","limiter","_rateLimit","_tokensRequested","_prevIntervalTokens","_prevTokensRequested","curIntervalStart","curIntervalTokens","tokensThisInterval","_isAllowed","getMilliseconds","fireImmediately","tokenBucket","afterTokensRemoved","tokensRemaining","getTokensRemaining","hrtime","seconds","nanoseconds","getTime","freeGlobal","freeSelf","root","thisArg","arrayPush","array","objectProto","objectToString","spreadableSymbol","isConcatSpreadable","nativeMax","isFlattenable","isObjectLike","isLength","isFunction","isArrayLike","isArrayLikeObject","isArguments","toKey","isSymbol","basePickBy","basePick","iteratee","arrayMap","baseFlatten","depth","isStrict","otherArgs","dd","coalesce","runtimeId","DD_TRACE_ANALYTICS_ENABLED","DD_PROFILING_ENABLED","DD_PROFILING_EXPORTERS","DD_PROFILING_SOURCE_MAP","DD_LOGS_INJECTION","DD_RUNTIME_METRICS_ENABLED","DD_AGENT_HOST","DD_TRACE_AGENT_PORT","DD_TRACE_AGENT_URL","DD_SERVICE","DD_ENV","DD_VERSION","DD_TRACE_STARTUP_LOGS","startupLogs","DD_TRACE_ENABLED","DD_TRACE_DEBUG","DD_TRACE_AGENT_PROTOCOL_VERSION","protocolVersion","ingestion","dogstatsd","flushInterval","trackAsyncScope","distributedTracingOriginAllowlist","distributedTracingOriginWhitelist","profiling","sourceMap","lookup","hasValue","shimmer","disabldPlugins","cleanEnv","toUpperCase","getConfig","analyticsEnabled","analyticsSampleRate","_loader","_names","_plugins","_instrumented","_disabledPlugins","_set","reload","nodules","massWrap","wrapped","getOwnPropertyDescriptors","Reflect","massUnwrap","_datadog_patched","moduleExports","shim","instrumentations","instrumented","funktion","__unwrap","disable","inherit"],"mappings":"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","file":"dd-trace.min.js","sourcesContent":[" \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 = 113);\n","'use strict';\nvar NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar classof = require('../internals/classof');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar uid = require('../internals/uid');\n\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar Uint8ClampedArray = global.Uint8ClampedArray;\nvar Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;\nvar TypedArray = Int8Array && getPrototypeOf(Int8Array);\nvar TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);\nvar ObjectPrototype = Object.prototype;\nvar isPrototypeOf = ObjectPrototype.isPrototypeOf;\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');\n// Fixing native typed arrays in Opera Presto crashes the browser, see #595\nvar NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';\nvar TYPED_ARRAY_TAG_REQIRED = false;\nvar NAME;\n\nvar TypedArrayConstructorsList = {\n Int8Array: 1,\n Uint8Array: 1,\n Uint8ClampedArray: 1,\n Int16Array: 2,\n Uint16Array: 2,\n Int32Array: 4,\n Uint32Array: 4,\n Float32Array: 4,\n Float64Array: 8\n};\n\nvar BigIntArrayConstructorsList = {\n BigInt64Array: 8,\n BigUint64Array: 8\n};\n\nvar isView = function isView(it) {\n if (!isObject(it)) return false;\n var klass = classof(it);\n return klass === 'DataView'\n || has(TypedArrayConstructorsList, klass)\n || has(BigIntArrayConstructorsList, klass);\n};\n\nvar isTypedArray = function (it) {\n if (!isObject(it)) return false;\n var klass = classof(it);\n return has(TypedArrayConstructorsList, klass)\n || has(BigIntArrayConstructorsList, klass);\n};\n\nvar aTypedArray = function (it) {\n if (isTypedArray(it)) return it;\n throw TypeError('Target is not a typed array');\n};\n\nvar aTypedArrayConstructor = function (C) {\n if (setPrototypeOf) {\n if (isPrototypeOf.call(TypedArray, C)) return C;\n } else for (var ARRAY in TypedArrayConstructorsList) if (has(TypedArrayConstructorsList, NAME)) {\n var TypedArrayConstructor = global[ARRAY];\n if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) {\n return C;\n }\n } throw TypeError('Target is not a typed array constructor');\n};\n\nvar exportTypedArrayMethod = function (KEY, property, forced) {\n if (!DESCRIPTORS) return;\n if (forced) for (var ARRAY in TypedArrayConstructorsList) {\n var TypedArrayConstructor = global[ARRAY];\n if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) {\n delete TypedArrayConstructor.prototype[KEY];\n }\n }\n if (!TypedArrayPrototype[KEY] || forced) {\n redefine(TypedArrayPrototype, KEY, forced ? property\n : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property);\n }\n};\n\nvar exportTypedArrayStaticMethod = function (KEY, property, forced) {\n var ARRAY, TypedArrayConstructor;\n if (!DESCRIPTORS) return;\n if (setPrototypeOf) {\n if (forced) for (ARRAY in TypedArrayConstructorsList) {\n TypedArrayConstructor = global[ARRAY];\n if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) {\n delete TypedArrayConstructor[KEY];\n }\n }\n if (!TypedArray[KEY] || forced) {\n // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable\n try {\n return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property);\n } catch (error) { /* empty */ }\n } else return;\n }\n for (ARRAY in TypedArrayConstructorsList) {\n TypedArrayConstructor = global[ARRAY];\n if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {\n redefine(TypedArrayConstructor, KEY, property);\n }\n }\n};\n\nfor (NAME in TypedArrayConstructorsList) {\n if (!global[NAME]) NATIVE_ARRAY_BUFFER_VIEWS = false;\n}\n\n// WebKit bug - typed arrays constructors prototype is Object.prototype\nif (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) {\n // eslint-disable-next-line no-shadow\n TypedArray = function TypedArray() {\n throw TypeError('Incorrect invocation');\n };\n if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);\n }\n}\n\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {\n TypedArrayPrototype = TypedArray.prototype;\n if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);\n }\n}\n\n// WebKit bug - one more object in Uint8ClampedArray prototype chain\nif (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {\n setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);\n}\n\nif (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) {\n TYPED_ARRAY_TAG_REQIRED = true;\n defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {\n return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;\n } });\n for (NAME in TypedArrayConstructorsList) if (global[NAME]) {\n createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);\n }\n}\n\nmodule.exports = {\n NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,\n TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG,\n aTypedArray: aTypedArray,\n aTypedArrayConstructor: aTypedArrayConstructor,\n exportTypedArrayMethod: exportTypedArrayMethod,\n exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,\n isView: isView,\n isTypedArray: isTypedArray,\n TypedArray: TypedArray,\n TypedArrayPrototype: TypedArrayPrototype\n};\n","var check = function (it) {\n return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line no-undef\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n // eslint-disable-next-line no-new-func\n (function () { return this; })() || Function('return this')();\n","module.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!has(WellKnownSymbolsStore, name)) {\n if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];\n else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","var hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = function (it, key) {\n return hasOwnProperty.call(it, key);\n};\n","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","\"use strict\";\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar binary_carrier_1 = require(\"./binary_carrier\");\nexports.BinaryCarrier = binary_carrier_1.default;\nvar Tags = require(\"./ext/tags\");\nexports.Tags = Tags;\nvar Noop = require(\"./noop\");\nvar reference_1 = require(\"./reference\");\nexports.Reference = reference_1.default;\nvar span_1 = require(\"./span\");\nexports.Span = span_1.default;\nvar span_context_1 = require(\"./span_context\");\nexports.SpanContext = span_context_1.default;\nvar tracer_1 = require(\"./tracer\");\nexports.Tracer = tracer_1.Tracer;\nvar mock_tracer_1 = require(\"./mock_tracer\");\nexports.MockTracer = mock_tracer_1.MockTracer;\n__export(require(\"./global_tracer\"));\n__export(require(\"./constants\"));\n__export(require(\"./functions\"));\n// Initialize the noops last to avoid a dependecy cycle between the classes.\nNoop.initialize();\n//# sourceMappingURL=index.js.map","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","module.exports = function (it) {\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPrimitive(P, true);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return nativeDefineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict'\n\nmodule.exports = {\n use (impl) {\n Object.assign(this, impl)\n },\n\n configure (config) {\n this._config = config\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-array-constructors-require-wrappers');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar ArrayBufferModule = require('../internals/array-buffer');\nvar anInstance = require('../internals/an-instance');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar toLength = require('../internals/to-length');\nvar toIndex = require('../internals/to-index');\nvar toOffset = require('../internals/to-offset');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar classof = require('../internals/classof');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar typedArrayFrom = require('../internals/typed-array-from');\nvar forEach = require('../internals/array-iteration').forEach;\nvar setSpecies = require('../internals/set-species');\nvar definePropertyModule = require('../internals/object-define-property');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar InternalStateModule = require('../internals/internal-state');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar nativeDefineProperty = definePropertyModule.f;\nvar nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\nvar round = Math.round;\nvar RangeError = global.RangeError;\nvar ArrayBuffer = ArrayBufferModule.ArrayBuffer;\nvar DataView = ArrayBufferModule.DataView;\nvar NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;\nvar TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG;\nvar TypedArray = ArrayBufferViewCore.TypedArray;\nvar TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype;\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar isTypedArray = ArrayBufferViewCore.isTypedArray;\nvar BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';\nvar WRONG_LENGTH = 'Wrong length';\n\nvar fromList = function (C, list) {\n var index = 0;\n var length = list.length;\n var result = new (aTypedArrayConstructor(C))(length);\n while (length > index) result[index] = list[index++];\n return result;\n};\n\nvar addGetter = function (it, key) {\n nativeDefineProperty(it, key, { get: function () {\n return getInternalState(this)[key];\n } });\n};\n\nvar isArrayBuffer = function (it) {\n var klass;\n return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer';\n};\n\nvar isTypedArrayIndex = function (target, key) {\n return isTypedArray(target)\n && typeof key != 'symbol'\n && key in target\n && String(+key) == String(key);\n};\n\nvar wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) {\n return isTypedArrayIndex(target, key = toPrimitive(key, true))\n ? createPropertyDescriptor(2, target[key])\n : nativeGetOwnPropertyDescriptor(target, key);\n};\n\nvar wrappedDefineProperty = function defineProperty(target, key, descriptor) {\n if (isTypedArrayIndex(target, key = toPrimitive(key, true))\n && isObject(descriptor)\n && has(descriptor, 'value')\n && !has(descriptor, 'get')\n && !has(descriptor, 'set')\n // TODO: add validation descriptor w/o calling accessors\n && !descriptor.configurable\n && (!has(descriptor, 'writable') || descriptor.writable)\n && (!has(descriptor, 'enumerable') || descriptor.enumerable)\n ) {\n target[key] = descriptor.value;\n return target;\n } return nativeDefineProperty(target, key, descriptor);\n};\n\nif (DESCRIPTORS) {\n if (!NATIVE_ARRAY_BUFFER_VIEWS) {\n getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor;\n definePropertyModule.f = wrappedDefineProperty;\n addGetter(TypedArrayPrototype, 'buffer');\n addGetter(TypedArrayPrototype, 'byteOffset');\n addGetter(TypedArrayPrototype, 'byteLength');\n addGetter(TypedArrayPrototype, 'length');\n }\n\n $({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {\n getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor,\n defineProperty: wrappedDefineProperty\n });\n\n module.exports = function (TYPE, wrapper, CLAMPED) {\n var BYTES = TYPE.match(/\\d+$/)[0] / 8;\n var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';\n var GETTER = 'get' + TYPE;\n var SETTER = 'set' + TYPE;\n var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME];\n var TypedArrayConstructor = NativeTypedArrayConstructor;\n var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;\n var exported = {};\n\n var getter = function (that, index) {\n var data = getInternalState(that);\n return data.view[GETTER](index * BYTES + data.byteOffset, true);\n };\n\n var setter = function (that, index, value) {\n var data = getInternalState(that);\n if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF;\n data.view[SETTER](index * BYTES + data.byteOffset, value, true);\n };\n\n var addElement = function (that, index) {\n nativeDefineProperty(that, index, {\n get: function () {\n return getter(this, index);\n },\n set: function (value) {\n return setter(this, index, value);\n },\n enumerable: true\n });\n };\n\n if (!NATIVE_ARRAY_BUFFER_VIEWS) {\n TypedArrayConstructor = wrapper(function (that, data, offset, $length) {\n anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME);\n var index = 0;\n var byteOffset = 0;\n var buffer, byteLength, length;\n if (!isObject(data)) {\n length = toIndex(data);\n byteLength = length * BYTES;\n buffer = new ArrayBuffer(byteLength);\n } else if (isArrayBuffer(data)) {\n buffer = data;\n byteOffset = toOffset(offset, BYTES);\n var $len = data.byteLength;\n if ($length === undefined) {\n if ($len % BYTES) throw RangeError(WRONG_LENGTH);\n byteLength = $len - byteOffset;\n if (byteLength < 0) throw RangeError(WRONG_LENGTH);\n } else {\n byteLength = toLength($length) * BYTES;\n if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH);\n }\n length = byteLength / BYTES;\n } else if (isTypedArray(data)) {\n return fromList(TypedArrayConstructor, data);\n } else {\n return typedArrayFrom.call(TypedArrayConstructor, data);\n }\n setInternalState(that, {\n buffer: buffer,\n byteOffset: byteOffset,\n byteLength: byteLength,\n length: length,\n view: new DataView(buffer)\n });\n while (index < length) addElement(that, index++);\n });\n\n if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);\n TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype);\n } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) {\n TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) {\n anInstance(dummy, TypedArrayConstructor, CONSTRUCTOR_NAME);\n return inheritIfRequired(function () {\n if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data));\n if (isArrayBuffer(data)) return $length !== undefined\n ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length)\n : typedArrayOffset !== undefined\n ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES))\n : new NativeTypedArrayConstructor(data);\n if (isTypedArray(data)) return fromList(TypedArrayConstructor, data);\n return typedArrayFrom.call(TypedArrayConstructor, data);\n }(), dummy, TypedArrayConstructor);\n });\n\n if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);\n forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) {\n if (!(key in TypedArrayConstructor)) {\n createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);\n }\n });\n TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;\n }\n\n if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) {\n createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);\n }\n\n if (TYPED_ARRAY_TAG) {\n createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);\n }\n\n exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;\n\n $({\n global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS\n }, exported);\n\n if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) {\n createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);\n }\n\n if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) {\n createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);\n }\n\n setSpecies(CONSTRUCTOR_NAME);\n };\n} else module.exports = function () { /* empty */ };\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n if (!isObject(it)) {\n throw TypeError(String(it) + ' is not an object');\n } return it;\n};\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return Object(requireObjectCoercible(argument));\n};\n","var bind = require('../internals/function-bind-context');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar toLength = require('../internals/to-length');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = [].push;\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterOut }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE == 1;\n var IS_FILTER = TYPE == 2;\n var IS_SOME = TYPE == 3;\n var IS_EVERY = TYPE == 4;\n var IS_FIND_INDEX = TYPE == 6;\n var IS_FILTER_OUT = TYPE == 7;\n var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var boundFunction = bind(callbackfn, that, 3);\n var length = toLength(self.length);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_OUT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push.call(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push.call(target, value); // filterOut\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterOut` method\n // https://github.com/tc39/proposal-array-filtering\n filterOut: createMethod(7)\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.es/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n","'use strict'\n\nconst NoopSpan = require('./noop/span')\n\nconst _default = {\n debug: msg => console.debug(msg), /* eslint-disable-line no-console */\n info: msg => console.info(msg), /* eslint-disable-line no-console */\n warn: msg => console.warn(msg), /* eslint-disable-line no-console */\n error: msg => console.error(msg) /* eslint-disable-line no-console */\n}\n\n// based on: https://github.com/trentm/node-bunyan#levels\nconst _logLevels = {\n 'debug': 20,\n 'info': 30,\n 'warn': 40,\n 'error': 50\n}\n\nconst _defaultLogLevel = 'debug'\n\nconst _checkLogLevel = (logLevel) => {\n if (logLevel && typeof logLevel === 'string') {\n return _logLevels[logLevel.toLowerCase().trim()] || _logLevels[_defaultLogLevel]\n }\n\n return _logLevels[_defaultLogLevel]\n}\n\nconst memoize = func => {\n const cache = {}\n const memoized = function (key) {\n if (!cache[key]) {\n cache[key] = func.apply(this, arguments)\n }\n\n return cache[key]\n }\n\n return memoized\n}\n\nfunction processMsg (msg) {\n return typeof msg === 'function' ? msg() : msg\n}\n\nfunction withNoop (fn) {\n if (!log._tracer) {\n fn()\n } else {\n log._tracer.scope().activate(log._noopSpan(), fn)\n }\n}\n\nconst log = {\n _isLogLevelEnabled (level) {\n return _logLevels[level] >= this._logLevel\n },\n\n use (logger) {\n if (logger && logger.debug instanceof Function && logger.error instanceof Function) {\n this._logger = logger\n }\n\n return this\n },\n\n toggle (enabled, logLevel, tracer) {\n this._enabled = enabled\n this._logLevel = _checkLogLevel(logLevel)\n this._tracer = tracer\n\n return this\n },\n\n _noopSpan () {\n if (!this.__noopSpan) {\n this.__noopSpan = new NoopSpan(this._tracer)\n }\n return this.__noopSpan\n },\n\n reset () {\n this._logger = _default\n this._enabled = false\n delete this._tracer\n delete this.__noopSpan\n this._deprecate = memoize((code, message) => {\n withNoop(() => this._logger.error(message))\n return this\n })\n this._logLevel = _checkLogLevel()\n\n return this\n },\n\n debug (message) {\n if (this._enabled && this._isLogLevelEnabled('debug')) {\n withNoop(() => this._logger.debug(processMsg(message)))\n }\n\n return this\n },\n\n info (message) {\n if (!this._logger.info) return this.debug(message)\n if (this._enabled && this._isLogLevelEnabled('info')) {\n withNoop(() => this._logger.info(processMsg(message)))\n }\n\n return this\n },\n\n warn (message) {\n if (!this._logger.warn) return this.debug(message)\n if (this._enabled && this._isLogLevelEnabled('warn')) {\n withNoop(() => this._logger.warn(processMsg(message)))\n }\n\n return this\n },\n\n error (err) {\n if (this._enabled && this._isLogLevelEnabled('error')) {\n if (err instanceof Function) {\n err = err()\n }\n\n if (typeof err !== 'object' || !err) {\n err = String(err)\n } else if (!err.stack) {\n err = String(err.message || err)\n }\n\n if (typeof err === 'string') {\n err = new Error(err)\n }\n\n withNoop(() => this._logger.error(err))\n }\n\n return this\n },\n\n deprecate (code, message) {\n return this._deprecate(code, message)\n }\n}\n\nlog.reset()\n\nmodule.exports = log\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n var unsafe = options ? !!options.unsafe : false;\n var simple = options ? !!options.enumerable : false;\n var noTargetGet = options ? !!options.noTargetGet : false;\n var state;\n if (typeof value == 'function') {\n if (typeof key == 'string' && !has(value, 'name')) {\n createNonEnumerableProperty(value, 'name', key);\n }\n state = enforceInternalState(value);\n if (!state.source) {\n state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n }\n }\n if (O === global) {\n if (simple) O[key] = value;\n else setGlobal(key, value);\n return;\n } else if (!unsafe) {\n delete O[key];\n } else if (!noTargetGet && O[key]) {\n simple = true;\n }\n if (simple) O[key] = value;\n else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP) {\n var store = shared.state || (shared.state = new WeakMap());\n var wmget = store.get;\n var wmhas = store.has;\n var wmset = store.set;\n set = function (it, metadata) {\n metadata.facade = it;\n wmset.call(store, it, metadata);\n return metadata;\n };\n get = function (it) {\n return wmget.call(store, it) || {};\n };\n has = function (it) {\n return wmhas.call(store, it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return objectHas(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return objectHas(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict'\n\nmodule.exports = {\n SAMPLE_RATE_METRIC_KEY: '_sample_rate',\n SAMPLING_PRIORITY_KEY: '_sampling_priority_v1',\n ANALYTICS_KEY: '_dd1.sr.eausr',\n ORIGIN_KEY: '_dd.origin',\n HOSTNAME_KEY: '_dd.hostname',\n REFERENCE_NOOP: 'noop',\n SAMPLING_RULE_DECISION: '_dd.rule_psr',\n SAMPLING_LIMIT_DECISION: '_dd.limit_psr',\n SAMPLING_AGENT_DECISION: '_dd.agent_psr'\n}\n","'use strict'\n\nconst platform = require('./platform')\n\nconst UINT_MAX = 4294967296\n\nconst zeroId = new Uint8Array(8)\n\n// Cryptographically secure local seeds to mitigate Math.random() seed reuse.\nconst seed = new Uint32Array(2)\n\nif (platform.crypto) {\n platform.crypto.getRandomValues(seed)\n}\n\nconst map = Array.prototype.map\nconst pad = byte => `${byte < 16 ? '0' : ''}${byte.toString(16)}`\n\n// Internal representation of a trace or span ID.\nclass Identifier {\n constructor (value, radix) {\n this._isUint64BE = true // msgpack-lite compatibility\n this._buffer = typeof radix === 'number'\n ? fromString(value, radix)\n : createBuffer(value)\n }\n\n toString (radix) {\n return typeof radix === 'number'\n ? toNumberString(this._buffer, radix)\n : toHexString(this._buffer)\n }\n\n toBuffer () {\n return this._buffer\n }\n\n // msgpack-lite compatibility\n toArray () {\n if (this._buffer.length === 8) {\n return this._buffer\n }\n return this._buffer.subarray(-8)\n }\n\n toJSON () {\n return this.toString()\n }\n}\n\n// Create a buffer, using an optional hexadecimal value if provided.\nfunction createBuffer (value) {\n if (value === '0') return zeroId\n if (!value) return pseudoRandom()\n\n const size = Math.ceil(value.length / 2)\n const buffer = new Uint8Array(size)\n\n for (let i = 0; i < size; i++) {\n buffer[i] = parseInt(value.substring(i * 2, i * 2 + 2), 16)\n }\n\n return buffer\n}\n\n// Convert a numerical string to a buffer using the specified radix.\nfunction fromString (str, raddix) {\n const buffer = new Uint8Array(8)\n const len = str.length\n\n let pos = 0\n let high = 0\n let low = 0\n\n if (str[0] === '-') pos++\n\n const sign = pos\n\n while (pos < len) {\n const chr = parseInt(str[pos++], raddix)\n\n if (!(chr >= 0)) break // NaN\n\n low = low * raddix + chr\n high = high * raddix + Math.floor(low / UINT_MAX)\n low %= UINT_MAX\n }\n\n if (sign) {\n high = ~high\n\n if (low) {\n low = UINT_MAX - low\n } else {\n high++\n }\n }\n\n writeUInt32BE(buffer, high, 0)\n writeUInt32BE(buffer, low, 4)\n\n return buffer\n}\n\n// Convert a buffer to a numerical string.\nfunction toNumberString (buffer, radix) {\n let high = readInt32(buffer, 0)\n let low = readInt32(buffer, 4)\n let str = ''\n\n radix = radix || 10\n\n while (1) {\n const mod = (high % radix) * UINT_MAX + low\n\n high = Math.floor(high / radix)\n low = Math.floor(mod / radix)\n str = (mod % radix).toString(radix) + str\n\n if (!high && !low) break\n }\n\n return str\n}\n\n// Convert a buffer to a hexadecimal string.\nfunction toHexString (buffer) {\n return map.call(buffer, pad).join('')\n}\n\n// Simple pseudo-random 64-bit ID generator.\nfunction pseudoRandom () {\n const buffer = new Uint8Array(8)\n\n const hi = randomUInt32(seed[0]) & 0x7FFFFFFF // only positive int64\n const lo = randomUInt32(seed[1])\n\n writeUInt32BE(buffer, hi, 0)\n writeUInt32BE(buffer, lo, 4)\n\n return buffer\n}\n\n// Generate a random unsigned 32-bit integer.\nfunction randomUInt32 (seed) {\n return seed ^ Math.floor(Math.random() * (0xFFFFFFFF + 1))\n}\n\n// Read a buffer to unsigned integer bytes.\nfunction readInt32 (buffer, offset) {\n return (buffer[offset + 0] * 16777216) +\n (buffer[offset + 1] << 16) +\n (buffer[offset + 2] << 8) +\n buffer[offset + 3]\n}\n\n// Write unsigned integer bytes to a buffer.\nfunction writeUInt32BE (buffer, value, offset) {\n buffer[3 + offset] = value & 255\n value = value >> 8\n buffer[2 + offset] = value & 255\n value = value >> 8\n buffer[1 + offset] = value & 255\n value = value >> 8\n buffer[0 + offset] = value & 255\n}\n\nmodule.exports = (value, radix) => new Identifier(value, radix)\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","module.exports = {};\n","var anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;\n setter.call(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter.call(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar noop = require(\"./noop\");\n/**\n * Span represents a logical unit of work as part of a broader Trace. Examples\n * of span might include remote procedure calls or a in-process function calls\n * to sub-components. A Trace has a single, top-level \"root\" Span that in turn\n * may have zero or more child Spans, which in turn may have children.\n */\nvar Span = /** @class */ (function () {\n function Span() {\n }\n // ---------------------------------------------------------------------- //\n // OpenTracing API methods\n // ---------------------------------------------------------------------- //\n /**\n * Returns the SpanContext object associated with this Span.\n *\n * @return {SpanContext}\n */\n Span.prototype.context = function () {\n return this._context();\n };\n /**\n * Returns the Tracer object used to create this Span.\n *\n * @return {Tracer}\n */\n Span.prototype.tracer = function () {\n return this._tracer();\n };\n /**\n * Sets the string name for the logical operation this span represents.\n *\n * @param {string} name\n */\n Span.prototype.setOperationName = function (name) {\n this._setOperationName(name);\n return this;\n };\n /**\n * Sets a key:value pair on this Span that also propagates to future\n * children of the associated Span.\n *\n * setBaggageItem() enables powerful functionality given a full-stack\n * opentracing integration (e.g., arbitrary application data from a web\n * client can make it, transparently, all the way into the depths of a\n * storage system), and with it some powerful costs: use this feature with\n * care.\n *\n * IMPORTANT NOTE #1: setBaggageItem() will only propagate baggage items to\n * *future* causal descendants of the associated Span.\n *\n * IMPORTANT NOTE #2: Use this thoughtfully and with care. Every key and\n * value is copied into every local *and remote* child of the associated\n * Span, and that can add up to a lot of network and cpu overhead.\n *\n * @param {string} key\n * @param {string} value\n */\n Span.prototype.setBaggageItem = function (key, value) {\n this._setBaggageItem(key, value);\n return this;\n };\n /**\n * Returns the value for a baggage item given its key.\n *\n * @param {string} key\n * The key for the given trace attribute.\n * @return {string}\n * String value for the given key, or undefined if the key does not\n * correspond to a set trace attribute.\n */\n Span.prototype.getBaggageItem = function (key) {\n return this._getBaggageItem(key);\n };\n /**\n * Adds a single tag to the span. See `addTags()` for details.\n *\n * @param {string} key\n * @param {any} value\n */\n Span.prototype.setTag = function (key, value) {\n var _a;\n // NOTE: the call is normalized to a call to _addTags()\n this._addTags((_a = {}, _a[key] = value, _a));\n return this;\n };\n /**\n * Adds the given key value pairs to the set of span tags.\n *\n * Multiple calls to addTags() results in the tags being the superset of\n * all calls.\n *\n * The behavior of setting the same key multiple times on the same span\n * is undefined.\n *\n * The supported type of the values is implementation-dependent.\n * Implementations are expected to safely handle all types of values but\n * may choose to ignore unrecognized / unhandle-able values (e.g. objects\n * with cyclic references, function objects).\n *\n * @return {[type]} [description]\n */\n Span.prototype.addTags = function (keyValueMap) {\n this._addTags(keyValueMap);\n return this;\n };\n /**\n * Add a log record to this Span, optionally at a user-provided timestamp.\n *\n * For example:\n *\n * span.log({\n * size: rpc.size(), // numeric value\n * URI: rpc.URI(), // string value\n * payload: rpc.payload(), // Object value\n * \"keys can be arbitrary strings\": rpc.foo(),\n * });\n *\n * span.log({\n * \"error.description\": someError.description(),\n * }, someError.timestampMillis());\n *\n * @param {object} keyValuePairs\n * An object mapping string keys to arbitrary value types. All\n * Tracer implementations should support bool, string, and numeric\n * value types, and some may also support Object values.\n * @param {number} timestamp\n * An optional parameter specifying the timestamp in milliseconds\n * since the Unix epoch. Fractional values are allowed so that\n * timestamps with sub-millisecond accuracy can be represented. If\n * not specified, the implementation is expected to use its notion\n * of the current time of the call.\n */\n Span.prototype.log = function (keyValuePairs, timestamp) {\n this._log(keyValuePairs, timestamp);\n return this;\n };\n /**\n * DEPRECATED\n */\n Span.prototype.logEvent = function (eventName, payload) {\n return this._log({ event: eventName, payload: payload });\n };\n /**\n * Sets the end timestamp and finalizes Span state.\n *\n * With the exception of calls to Span.context() (which are always allowed),\n * finish() must be the last call made to any span instance, and to do\n * otherwise leads to undefined behavior.\n *\n * @param {number} finishTime\n * Optional finish time in milliseconds as a Unix timestamp. Decimal\n * values are supported for timestamps with sub-millisecond accuracy.\n * If not specified, the current time (as defined by the\n * implementation) will be used.\n */\n Span.prototype.finish = function (finishTime) {\n this._finish(finishTime);\n // Do not return `this`. The Span generally should not be used after it\n // is finished so chaining is not desired in this context.\n };\n // ---------------------------------------------------------------------- //\n // Derived classes can choose to implement the below\n // ---------------------------------------------------------------------- //\n // By default returns a no-op SpanContext.\n Span.prototype._context = function () {\n return noop.spanContext;\n };\n // By default returns a no-op tracer.\n //\n // The base class could store the tracer that created it, but it does not\n // in order to ensure the no-op span implementation has zero members,\n // which allows V8 to aggressively optimize calls to such objects.\n Span.prototype._tracer = function () {\n return noop.tracer;\n };\n // By default does nothing\n Span.prototype._setOperationName = function (name) {\n };\n // By default does nothing\n Span.prototype._setBaggageItem = function (key, value) {\n };\n // By default does nothing\n Span.prototype._getBaggageItem = function (key) {\n return undefined;\n };\n // By default does nothing\n //\n // NOTE: both setTag() and addTags() map to this function. keyValuePairs\n // will always be an associative array.\n Span.prototype._addTags = function (keyValuePairs) {\n };\n // By default does nothing\n Span.prototype._log = function (keyValuePairs, timestamp) {\n };\n // By default does nothing\n //\n // finishTime is expected to be either a number or undefined.\n Span.prototype._finish = function (finishTime) {\n };\n return Span;\n}());\nexports.Span = Span;\nexports.default = Span;\n//# sourceMappingURL=span.js.map","'use strict'\n\nconst SpanContext = require('opentracing').SpanContext\n\nclass DatadogSpanContext extends SpanContext {\n constructor (props) {\n super()\n\n props = props || {}\n\n this._traceId = props.traceId\n this._spanId = props.spanId\n this._parentId = props.parentId || null\n this._name = props.name\n this._isFinished = props.isFinished || false\n this._tags = props.tags || {}\n this._sampling = props.sampling || {}\n this._baggageItems = props.baggageItems || {}\n this._traceFlags = props.traceFlags || {}\n this._traceFlags.sampled = this._traceFlags.sampled !== false\n this._traceFlags.debug = this._traceFlags.debug === true\n this._noop = props.noop || null\n this._trace = props.trace || {\n started: [],\n finished: []\n }\n }\n\n toTraceId () {\n return this._traceId.toString(10)\n }\n\n toSpanId () {\n return this._spanId.toString(10)\n }\n}\n\nmodule.exports = DatadogSpanContext\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || setGlobal(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.noTargetGet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty === typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n // extend global\n redefine(target, key, sourceProperty, options);\n }\n};\n","module.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins\n return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toInteger(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n aFunction(fn);\n if (that === undefined) return fn;\n switch (length) {\n case 0: return function () {\n return fn.call(that);\n };\n case 1: return function (a) {\n return fn.call(that, a);\n };\n case 2: return function (a, b) {\n return fn.call(that, a, b);\n };\n case 3: return function (a, b, c) {\n return fn.call(that, a, b, c);\n };\n }\n return function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;\n};\n","module.exports = function (it, Constructor, name) {\n if (!(it instanceof Constructor)) {\n throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');\n } return it;\n};\n","var defineProperty = require('../internals/object-define-property').f;\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n /* global ActiveXObject */\n activeXDocument = document.domain && new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n O = toObject(O);\n if (has(O, IE_PROTO)) return O[IE_PROTO];\n if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n return O.constructor.prototype;\n } return O instanceof Object ? ObjectPrototype : null;\n};\n","var anObject = require('../internals/an-object');\nvar aFunction = require('../internals/a-function');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);\n};\n","'use strict';\n\nvar required = require('requires-port')\n , qs = require('querystringify')\n , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//\n , protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\S\\s]*)/i\n , whitespace = '[\\\\x09\\\\x0A\\\\x0B\\\\x0C\\\\x0D\\\\x20\\\\xA0\\\\u1680\\\\u180E\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200A\\\\u202F\\\\u205F\\\\u3000\\\\u2028\\\\u2029\\\\uFEFF]'\n , left = new RegExp('^'+ whitespace +'+');\n\n/**\n * Trim a given string.\n *\n * @param {String} str String to trim.\n * @public\n */\nfunction trimLeft(str) {\n return (str ? str : '').toString().replace(left, '');\n}\n\n/**\n * These are the parse rules for the URL parser, it informs the parser\n * about:\n *\n * 0. The char it Needs to parse, if it's a string it should be done using\n * indexOf, RegExp using exec and NaN means set as current value.\n * 1. The property we should set when parsing this value.\n * 2. Indication if it's backwards or forward parsing, when set as number it's\n * the value of extra chars that should be split off.\n * 3. Inherit from location if non existing in the parser.\n * 4. `toLowerCase` the resulting value.\n */\nvar rules = [\n ['#', 'hash'], // Extract from the back.\n ['?', 'query'], // Extract from the back.\n function sanitize(address) { // Sanitize what is left of the address\n return address.replace('\\\\', '/');\n },\n ['/', 'pathname'], // Extract from the back.\n ['@', 'auth', 1], // Extract from the front.\n [NaN, 'host', undefined, 1, 1], // Set left over value.\n [/:(\\d+)$/, 'port', undefined, 1], // RegExp the back.\n [NaN, 'hostname', undefined, 1, 1] // Set left over.\n];\n\n/**\n * These properties should not be copied or inherited from. This is only needed\n * for all non blob URL's as a blob URL does not include a hash, only the\n * origin.\n *\n * @type {Object}\n * @private\n */\nvar ignore = { hash: 1, query: 1 };\n\n/**\n * The location object differs when your code is loaded through a normal page,\n * Worker or through a worker using a blob. And with the blobble begins the\n * trouble as the location object will contain the URL of the blob, not the\n * location of the page where our code is loaded in. The actual origin is\n * encoded in the `pathname` so we can thankfully generate a good \"default\"\n * location from it so we can generate proper relative URL's again.\n *\n * @param {Object|String} loc Optional default location object.\n * @returns {Object} lolcation object.\n * @public\n */\nfunction lolcation(loc) {\n var globalVar;\n\n if (typeof window !== 'undefined') globalVar = window;\n else if (typeof global !== 'undefined') globalVar = global;\n else if (typeof self !== 'undefined') globalVar = self;\n else globalVar = {};\n\n var location = globalVar.location || {};\n loc = loc || location;\n\n var finaldestination = {}\n , type = typeof loc\n , key;\n\n if ('blob:' === loc.protocol) {\n finaldestination = new Url(unescape(loc.pathname), {});\n } else if ('string' === type) {\n finaldestination = new Url(loc, {});\n for (key in ignore) delete finaldestination[key];\n } else if ('object' === type) {\n for (key in loc) {\n if (key in ignore) continue;\n finaldestination[key] = loc[key];\n }\n\n if (finaldestination.slashes === undefined) {\n finaldestination.slashes = slashes.test(loc.href);\n }\n }\n\n return finaldestination;\n}\n\n/**\n * @typedef ProtocolExtract\n * @type Object\n * @property {String} protocol Protocol matched in the URL, in lowercase.\n * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n * @property {String} rest Rest of the URL that is not part of the protocol.\n */\n\n/**\n * Extract protocol information from a URL with/without double slash (\"//\").\n *\n * @param {String} address URL we want to extract from.\n * @return {ProtocolExtract} Extracted information.\n * @private\n */\nfunction extractProtocol(address) {\n address = trimLeft(address);\n var match = protocolre.exec(address);\n\n return {\n protocol: match[1] ? match[1].toLowerCase() : '',\n slashes: !!match[2],\n rest: match[3]\n };\n}\n\n/**\n * Resolve a relative URL pathname against a base URL pathname.\n *\n * @param {String} relative Pathname of the relative URL.\n * @param {String} base Pathname of the base URL.\n * @return {String} Resolved pathname.\n * @private\n */\nfunction resolve(relative, base) {\n if (relative === '') return base;\n\n var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))\n , i = path.length\n , last = path[i - 1]\n , unshift = false\n , up = 0;\n\n while (i--) {\n if (path[i] === '.') {\n path.splice(i, 1);\n } else if (path[i] === '..') {\n path.splice(i, 1);\n up++;\n } else if (up) {\n if (i === 0) unshift = true;\n path.splice(i, 1);\n up--;\n }\n }\n\n if (unshift) path.unshift('');\n if (last === '.' || last === '..') path.push('');\n\n return path.join('/');\n}\n\n/**\n * The actual URL instance. Instead of returning an object we've opted-in to\n * create an actual constructor as it's much more memory efficient and\n * faster and it pleases my OCD.\n *\n * It is worth noting that we should not use `URL` as class name to prevent\n * clashes with the global URL instance that got introduced in browsers.\n *\n * @constructor\n * @param {String} address URL we want to parse.\n * @param {Object|String} [location] Location defaults for relative paths.\n * @param {Boolean|Function} [parser] Parser for the query string.\n * @private\n */\nfunction Url(address, location, parser) {\n address = trimLeft(address);\n\n if (!(this instanceof Url)) {\n return new Url(address, location, parser);\n }\n\n var relative, extracted, parse, instruction, index, key\n , instructions = rules.slice()\n , type = typeof location\n , url = this\n , i = 0;\n\n //\n // The following if statements allows this module two have compatibility with\n // 2 different API:\n //\n // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n // where the boolean indicates that the query string should also be parsed.\n //\n // 2. The `URL` interface of the browser which accepts a URL, object as\n // arguments. The supplied object will be used as default values / fall-back\n // for relative paths.\n //\n if ('object' !== type && 'string' !== type) {\n parser = location;\n location = null;\n }\n\n if (parser && 'function' !== typeof parser) parser = qs.parse;\n\n location = lolcation(location);\n\n //\n // Extract protocol information before running the instructions.\n //\n extracted = extractProtocol(address || '');\n relative = !extracted.protocol && !extracted.slashes;\n url.slashes = extracted.slashes || relative && location.slashes;\n url.protocol = extracted.protocol || location.protocol || '';\n address = extracted.rest;\n\n //\n // When the authority component is absent the URL starts with a path\n // component.\n //\n if (!extracted.slashes) instructions[3] = [/(.*)/, 'pathname'];\n\n for (; i < instructions.length; i++) {\n instruction = instructions[i];\n\n if (typeof instruction === 'function') {\n address = instruction(address);\n continue;\n }\n\n parse = instruction[0];\n key = instruction[1];\n\n if (parse !== parse) {\n url[key] = address;\n } else if ('string' === typeof parse) {\n if (~(index = address.indexOf(parse))) {\n if ('number' === typeof instruction[2]) {\n url[key] = address.slice(0, index);\n address = address.slice(index + instruction[2]);\n } else {\n url[key] = address.slice(index);\n address = address.slice(0, index);\n }\n }\n } else if ((index = parse.exec(address))) {\n url[key] = index[1];\n address = address.slice(0, index.index);\n }\n\n url[key] = url[key] || (\n relative && instruction[3] ? location[key] || '' : ''\n );\n\n //\n // Hostname, host and protocol should be lowercased so they can be used to\n // create a proper `origin`.\n //\n if (instruction[4]) url[key] = url[key].toLowerCase();\n }\n\n //\n // Also parse the supplied query string in to an object. If we're supplied\n // with a custom parser as function use that instead of the default build-in\n // parser.\n //\n if (parser) url.query = parser(url.query);\n\n //\n // If the URL is relative, resolve the pathname against the base URL.\n //\n if (\n relative\n && location.slashes\n && url.pathname.charAt(0) !== '/'\n && (url.pathname !== '' || location.pathname !== '')\n ) {\n url.pathname = resolve(url.pathname, location.pathname);\n }\n\n //\n // We should not add port numbers if they are already the default port number\n // for a given protocol. As the host also contains the port number we're going\n // override it with the hostname which contains no port number.\n //\n if (!required(url.port, url.protocol)) {\n url.host = url.hostname;\n url.port = '';\n }\n\n //\n // Parse down the `auth` for the username and password.\n //\n url.username = url.password = '';\n if (url.auth) {\n instruction = url.auth.split(':');\n url.username = instruction[0] || '';\n url.password = instruction[1] || '';\n }\n\n url.origin = url.protocol && url.host && url.protocol !== 'file:'\n ? url.protocol +'//'+ url.host\n : 'null';\n\n //\n // The href is just the compiled result.\n //\n url.href = url.toString();\n}\n\n/**\n * This is convenience method for changing properties in the URL instance to\n * insure that they all propagate correctly.\n *\n * @param {String} part Property we need to adjust.\n * @param {Mixed} value The newly assigned value.\n * @param {Boolean|Function} fn When setting the query, it will be the function\n * used to parse the query.\n * When setting the protocol, double slash will be\n * removed from the final url if it is true.\n * @returns {URL} URL instance for chaining.\n * @public\n */\nfunction set(part, value, fn) {\n var url = this;\n\n switch (part) {\n case 'query':\n if ('string' === typeof value && value.length) {\n value = (fn || qs.parse)(value);\n }\n\n url[part] = value;\n break;\n\n case 'port':\n url[part] = value;\n\n if (!required(value, url.protocol)) {\n url.host = url.hostname;\n url[part] = '';\n } else if (value) {\n url.host = url.hostname +':'+ value;\n }\n\n break;\n\n case 'hostname':\n url[part] = value;\n\n if (url.port) value += ':'+ url.port;\n url.host = value;\n break;\n\n case 'host':\n url[part] = value;\n\n if (/:\\d+$/.test(value)) {\n value = value.split(':');\n url.port = value.pop();\n url.hostname = value.join(':');\n } else {\n url.hostname = value;\n url.port = '';\n }\n\n break;\n\n case 'protocol':\n url.protocol = value.toLowerCase();\n url.slashes = !fn;\n break;\n\n case 'pathname':\n case 'hash':\n if (value) {\n var char = part === 'pathname' ? '/' : '#';\n url[part] = value.charAt(0) !== char ? char + value : value;\n } else {\n url[part] = value;\n }\n break;\n\n default:\n url[part] = value;\n }\n\n for (var i = 0; i < rules.length; i++) {\n var ins = rules[i];\n\n if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();\n }\n\n url.origin = url.protocol && url.host && url.protocol !== 'file:'\n ? url.protocol +'//'+ url.host\n : 'null';\n\n url.href = url.toString();\n\n return url;\n}\n\n/**\n * Transform the properties back in to a valid and full URL string.\n *\n * @param {Function} stringify Optional query stringify function.\n * @returns {String} Compiled version of the URL.\n * @public\n */\nfunction toString(stringify) {\n if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;\n\n var query\n , url = this\n , protocol = url.protocol;\n\n if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';\n\n var result = protocol + (url.slashes ? '//' : '');\n\n if (url.username) {\n result += url.username;\n if (url.password) result += ':'+ url.password;\n result += '@';\n }\n\n result += url.host + url.pathname;\n\n query = 'object' === typeof url.query ? stringify(url.query) : url.query;\n if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;\n\n if (url.hash) result += url.hash;\n\n return result;\n}\n\nUrl.prototype = { set: set, toString: toString };\n\n//\n// Expose the URL parser and some additional properties that might be useful for\n// others or testing.\n//\nUrl.extractProtocol = extractProtocol;\nUrl.location = lolcation;\nUrl.trimLeft = trimLeft;\nUrl.qs = qs;\n\nmodule.exports = Url;\n","'use strict'\n\nconst tags = {\n // Common\n SERVICE_NAME: 'service.name',\n RESOURCE_NAME: 'resource.name',\n SPAN_TYPE: 'span.type',\n SPAN_KIND: 'span.kind',\n SAMPLING_PRIORITY: 'sampling.priority',\n ANALYTICS: '_dd1.sr.eausr',\n ERROR: 'error',\n MANUAL_KEEP: 'manual.keep',\n MANUAL_DROP: 'manual.drop',\n MEASURED: '_dd.measured',\n\n // HTTP\n HTTP_URL: 'http.url',\n HTTP_METHOD: 'http.method',\n HTTP_STATUS_CODE: 'http.status_code',\n HTTP_ROUTE: 'http.route',\n HTTP_REQUEST_HEADERS: 'http.request.headers',\n HTTP_RESPONSE_HEADERS: 'http.response.headers'\n}\n\n// Deprecated\ntags.ANALYTICS_SAMPLE_RATE = tags.ANALYTICS\n\nmodule.exports = tags\n","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPrimitive(P, true);\n if (IE8_DOM_DEFINE) try {\n return nativeGetOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n return toString.call(it).slice(8, -1);\n};\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n if (!isObject(input)) return input;\n var fn, val;\n if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n try {\n createNonEnumerableProperty(global, key, value);\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","module.exports = false;\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = toLength(O.length);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare\n if (IS_INCLUDES && el != el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare\n if (value != value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","module.exports = function (it) {\n if (typeof it != 'function') {\n throw TypeError(String(it) + ' is not a function');\n } return it;\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n } return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array#{values, @@iterator}.name in V8 / FF\n if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return nativeIterator.call(this); };\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n }\n Iterators[NAME] = defaultIterator;\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n redefine(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n return methods;\n};\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","/* eslint-disable no-new */\nvar global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar NATIVE_ARRAY_BUFFER_VIEWS = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER_VIEWS;\n\nvar ArrayBuffer = global.ArrayBuffer;\nvar Int8Array = global.Int8Array;\n\nmodule.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () {\n Int8Array(1);\n}) || !fails(function () {\n new Int8Array(-1);\n}) || !checkCorrectnessOfIteration(function (iterable) {\n new Int8Array();\n new Int8Array(null);\n new Int8Array(1.5);\n new Int8Array(iterable);\n}, true) || fails(function () {\n // Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill\n return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1;\n});\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar span_1 = require(\"./span\");\nvar span_context_1 = require(\"./span_context\");\nvar tracer_1 = require(\"./tracer\");\nexports.tracer = null;\nexports.spanContext = null;\nexports.span = null;\n// Deferred initialization to avoid a dependency cycle where Tracer depends on\n// Span which depends on the noop tracer.\nfunction initialize() {\n exports.tracer = new tracer_1.default();\n exports.span = new span_1.default();\n exports.spanContext = new span_context_1.default();\n}\nexports.initialize = initialize;\n//# sourceMappingURL=noop.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Functions = require(\"./functions\");\nvar Noop = require(\"./noop\");\nvar span_1 = require(\"./span\");\n/**\n * Tracer is the entry-point between the instrumentation API and the tracing\n * implementation.\n *\n * The default object acts as a no-op implementation.\n *\n * Note to implementators: derived classes can choose to directly implement the\n * methods in the \"OpenTracing API methods\" section, or optionally the subset of\n * underscore-prefixed methods to pick up the argument checking and handling\n * automatically from the base class.\n */\nvar Tracer = /** @class */ (function () {\n function Tracer() {\n }\n // ---------------------------------------------------------------------- //\n // OpenTracing API methods\n // ---------------------------------------------------------------------- //\n /**\n * Starts and returns a new Span representing a logical unit of work.\n *\n * For example:\n *\n * // Start a new (parentless) root Span:\n * var parent = Tracer.startSpan('DoWork');\n *\n * // Start a new (child) Span:\n * var child = Tracer.startSpan('load-from-db', {\n * childOf: parent.context(),\n * });\n *\n * // Start a new async (FollowsFrom) Span:\n * var child = Tracer.startSpan('async-cache-write', {\n * references: [\n * opentracing.followsFrom(parent.context())\n * ],\n * });\n *\n * @param {string} name - the name of the operation (REQUIRED).\n * @param {SpanOptions} [options] - options for the newly created span.\n * @return {Span} - a new Span object.\n */\n Tracer.prototype.startSpan = function (name, options) {\n if (options === void 0) { options = {}; }\n // Convert options.childOf to fields.references as needed.\n if (options.childOf) {\n // Convert from a Span or a SpanContext into a Reference.\n var childOf = Functions.childOf(options.childOf);\n if (options.references) {\n options.references.push(childOf);\n }\n else {\n options.references = [childOf];\n }\n delete (options.childOf);\n }\n return this._startSpan(name, options);\n };\n /**\n * Injects the given SpanContext instance for cross-process propagation\n * within `carrier`. The expected type of `carrier` depends on the value of\n * `format.\n *\n * OpenTracing defines a common set of `format` values (see\n * FORMAT_TEXT_MAP, FORMAT_HTTP_HEADERS, and FORMAT_BINARY), and each has\n * an expected carrier type.\n *\n * Consider this pseudocode example:\n *\n * var clientSpan = ...;\n * ...\n * // Inject clientSpan into a text carrier.\n * var headersCarrier = {};\n * Tracer.inject(clientSpan.context(), Tracer.FORMAT_HTTP_HEADERS, headersCarrier);\n * // Incorporate the textCarrier into the outbound HTTP request header\n * // map.\n * Object.assign(outboundHTTPReq.headers, headersCarrier);\n * // ... send the httpReq\n *\n * @param {SpanContext} spanContext - the SpanContext to inject into the\n * carrier object. As a convenience, a Span instance may be passed\n * in instead (in which case its .context() is used for the\n * inject()).\n * @param {string} format - the format of the carrier.\n * @param {any} carrier - see the documentation for the chosen `format`\n * for a description of the carrier object.\n */\n Tracer.prototype.inject = function (spanContext, format, carrier) {\n // Allow the user to pass a Span instead of a SpanContext\n if (spanContext instanceof span_1.default) {\n spanContext = spanContext.context();\n }\n return this._inject(spanContext, format, carrier);\n };\n /**\n * Returns a SpanContext instance extracted from `carrier` in the given\n * `format`.\n *\n * OpenTracing defines a common set of `format` values (see\n * FORMAT_TEXT_MAP, FORMAT_HTTP_HEADERS, and FORMAT_BINARY), and each has\n * an expected carrier type.\n *\n * Consider this pseudocode example:\n *\n * // Use the inbound HTTP request's headers as a text map carrier.\n * var headersCarrier = inboundHTTPReq.headers;\n * var wireCtx = Tracer.extract(Tracer.FORMAT_HTTP_HEADERS, headersCarrier);\n * var serverSpan = Tracer.startSpan('...', { childOf : wireCtx });\n *\n * @param {string} format - the format of the carrier.\n * @param {any} carrier - the type of the carrier object is determined by\n * the format.\n * @return {SpanContext}\n * The extracted SpanContext, or null if no such SpanContext could\n * be found in `carrier`\n */\n Tracer.prototype.extract = function (format, carrier) {\n return this._extract(format, carrier);\n };\n // ---------------------------------------------------------------------- //\n // Derived classes can choose to implement the below\n // ---------------------------------------------------------------------- //\n // NOTE: the input to this method is *always* an associative array. The\n // public-facing startSpan() method normalizes the arguments so that\n // all N implementations do not need to worry about variations in the call\n // signature.\n //\n // The default behavior returns a no-op span.\n Tracer.prototype._startSpan = function (name, fields) {\n return Noop.span;\n };\n // The default behavior is a no-op.\n Tracer.prototype._inject = function (spanContext, format, carrier) {\n };\n // The default behavior is to return a no-op SpanContext.\n Tracer.prototype._extract = function (format, carrier) {\n return Noop.spanContext;\n };\n return Tracer;\n}());\nexports.Tracer = Tracer;\nexports.default = Tracer;\n//# sourceMappingURL=tracer.js.map","'use strict'\n\nclass Scope {\n active () {\n return this._active() || null\n }\n\n activate (span, callback) {\n if (typeof callback !== 'function') return callback\n\n try {\n return this._activate(span, callback)\n } catch (e) {\n if (span && typeof span.setTag === 'function') {\n span.setTag('error', e)\n }\n\n throw e\n }\n }\n\n bind (target, span) {\n target = this._bindEmitter(target, span)\n target = this._bindPromise(target, span)\n target = this._bindFn(target, span)\n\n return target\n }\n\n unbind (target) {\n target = this._unbindFn(target)\n target = this._unbindPromise(target)\n target = this._unbindEmitter(target)\n\n return target\n }\n\n _active () {\n return null\n }\n\n _activate (span, callback) {\n return callback()\n }\n\n _bindFn (fn, span) {\n if (typeof fn !== 'function') return fn\n\n const scope = this\n const spanOrActive = this._spanOrActive(span)\n\n const bound = function () {\n return scope.activate(spanOrActive, () => {\n return fn.apply(this, arguments)\n })\n }\n\n bound._datadog_unbound = fn\n\n return bound\n }\n\n _unbindFn (fn) {\n if (typeof fn !== 'function') return fn\n\n return fn._datadog_unbound || fn\n }\n\n _bindEmitter (emitter, span) {\n if (!this._isEmitter(emitter)) return emitter\n if (!emitter.__is_dd_emitter) {\n Scope._wrapEmitter(emitter)\n }\n emitter.__dd_span = span\n emitter.__dd_scope = this\n return emitter\n }\n\n // Occasionally we want to wrap a prototype rather than emitter instances,\n // so we're exposing this as a static method. This gives us a faster\n // path for binding instances of known EventEmitter subclasses.\n static _wrapEmitter (emitter) {\n wrapMethod(emitter, 'addListener', wrapAddListener)\n wrapMethod(emitter, 'prependListener', wrapAddListener)\n wrapMethod(emitter, 'on', wrapAddListener)\n wrapMethod(emitter, 'once', wrapAddListener)\n wrapMethod(emitter, 'removeListener', wrapRemoveListener)\n wrapMethod(emitter, 'off', wrapRemoveListener)\n wrapMethod(emitter, 'removeAllListeners', wrapRemoveAllListeners)\n emitter.__is_dd_emitter = true\n }\n\n _unbindEmitter (emitter) {\n if (!this._isEmitter(emitter)) return emitter\n delete emitter.__dd_scope\n delete emitter.__dd_span\n return emitter\n }\n\n _bindPromise (promise, span) {\n if (!this._isPromise(promise)) return promise\n\n wrapMethod(promise, 'then', wrapThen, this, span)\n\n return promise\n }\n\n _unbindPromise (promise) {\n if (!this._isPromise(promise)) return promise\n\n promise.then = promise.then._datadog_unbound || promise.then\n\n return promise\n }\n\n _spanOrActive (span) {\n return span !== undefined ? span : this.active()\n }\n\n _isEmitter (emitter) {\n return emitter &&\n typeof emitter.emit === 'function' &&\n typeof emitter.on === 'function' &&\n typeof emitter.addListener === 'function' &&\n typeof emitter.removeListener === 'function'\n }\n\n _isPromise (promise) {\n return promise && typeof promise.then === 'function'\n }\n}\n\nfunction wrapThen (then, scope, span) {\n return function thenWithTrace (onFulfilled, onRejected) {\n const args = new Array(arguments.length)\n\n for (let i = 0, l = args.length; i < l; i++) {\n args[i] = scope.bind(arguments[i], span)\n }\n\n return then.apply(this, args)\n }\n}\n\nfunction wrapAddListener (addListener) {\n return function addListenerWithTrace (eventName, listener) {\n if (!this.__dd_scope || !listener || listener._datadog_unbound || listener.listener) {\n return addListener.apply(this, arguments)\n }\n const scope = this.__dd_scope\n const span = this.__dd_span\n\n const bound = scope.bind(listener, scope._spanOrActive(span))\n\n this._datadog_events = this._datadog_events || {}\n\n if (!this._datadog_events[eventName]) {\n this._datadog_events[eventName] = new WeakMap()\n }\n\n const events = this._datadog_events[eventName]\n\n if (!events.has(listener)) {\n events.set(listener, [])\n }\n\n events.get(listener).push(bound)\n\n return addListener.call(this, eventName, bound)\n }\n}\n\nfunction wrapRemoveListener (removeListener) {\n return function removeListenerWithTrace (eventName, listener) {\n if (!this.__dd_scope) {\n return removeListener.apply(this, arguments)\n }\n\n const listeners = this._datadog_events && this._datadog_events[eventName]\n\n if (!listener || !listeners || !listeners.has(listener)) {\n return removeListener.apply(this, arguments)\n }\n\n for (const bound of listeners.get(listener)) {\n removeListener.call(this, eventName, bound)\n }\n\n listeners.delete(listener)\n\n return removeListener.call(this, eventName, listener)\n }\n}\n\nfunction wrapRemoveAllListeners (removeAllListeners) {\n return function removeAllListenersWithTrace (eventName) {\n if (this.__dd_scope && this._datadog_events) {\n if (eventName) {\n delete this._datadog_events[eventName]\n } else {\n delete this._datadog_events\n }\n }\n\n return removeAllListeners.call(this, eventName)\n }\n}\n\nfunction wrapMethod (target, name, wrapper, ...args) {\n if (!target[name] || target[name]._datadog_unbound) return\n\n const original = target[name]\n\n target[name] = wrapper(target[name], ...args)\n target[name]._datadog_unbound = original\n}\n\nmodule.exports = Scope\n","'use strict'\n\nconst Span = require('opentracing').Span\nconst NoopSpanContext = require('../noop/span_context')\nconst id = require('../id')\n\nclass NoopSpan extends Span {\n constructor (tracer, parent) {\n super()\n\n this._noopTracer = tracer\n this._noopContext = this._createContext(parent)\n }\n\n _context () {\n return this._noopContext\n }\n\n _tracer () {\n return this._noopTracer\n }\n\n _createContext (parent) {\n const spanId = id()\n\n if (parent) {\n return new NoopSpanContext({\n noop: this,\n traceId: parent._traceId,\n spanId,\n parentId: parent._spanId,\n baggageItems: Object.assign({}, parent._baggageItems)\n })\n } else {\n return new NoopSpanContext({\n noop: this,\n traceId: spanId,\n spanId\n })\n }\n }\n}\n\nmodule.exports = NoopSpan\n","'use strict'\n\nconst Span = require('opentracing').Span\nconst Scope = require('./scope')\n\nlet singleton = null\n\nconst span = new Span()\n\nclass ScopeManager {\n constructor () {\n if (!singleton) {\n singleton = this\n }\n\n return singleton\n }\n\n active () {\n return new Scope(span)\n }\n\n activate (span, finishSpanOnClose) {\n return new Scope(span, finishSpanOnClose)\n }\n}\n\nmodule.exports = ScopeManager\n","'use strict';\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n store.inspectSource = function (it) {\n return functionToString.call(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.8.3',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (has(O, key = names[i++])) {\n ~indexOf(result, key) || result.push(key);\n }\n return result;\n};\n","exports.f = Object.getOwnPropertySymbols;\n","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value == POLYFILL ? true\n : value == NATIVE ? false\n : typeof detection == 'function' ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var nativeMethod = NativePrototype[KEY];\n redefine(NativePrototype, KEY,\n KEY == 'add' ? function add(value) {\n nativeMethod.call(this, value === 0 ? 0 : value);\n return this;\n } : KEY == 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n } : KEY == 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);\n } : KEY == 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n nativeMethod.call(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n // eslint-disable-next-line max-len\n if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n })))) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.REQUIRED = true;\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, Constructor, CONSTRUCTOR_NAME);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","var hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar defineProperty = require('../internals/object-define-property').f;\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar isExtensible = Object.isExtensible || function () {\n return true;\n};\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + ++id, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!has(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!has(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar meta = module.exports = {\n REQUIRED: false,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var anObject = require('../internals/an-object');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar toLength = require('../internals/to-length');\nvar bind = require('../internals/function-bind-context');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (typeof iterFn != 'function') throw TypeError('Target is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = toLength(iterable.length); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && result instanceof Result) return result;\n } return new Result(false);\n }\n iterator = iterFn.call(iterable);\n }\n\n next = iterator.next;\n while (!(step = next.call(iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator);\n throw error;\n }\n if (typeof result == 'object' && result && result instanceof Result) return result;\n } return new Result(false);\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n // Chrome 38 Symbol has incorrect toString conversion\n // eslint-disable-next-line no-undef\n return !String(Symbol());\n});\n","var classof = require('../internals/classof');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (it != undefined) return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line no-throw-literal\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","var isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n typeof (NewTarget = dummy.constructor) == 'function' &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var C = wrapper(function (that, iterable) {\n anInstance(that, C, CONSTRUCTOR_NAME);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key == key) return entry;\n }\n };\n\n redefineAll(C.prototype, {\n // 23.1.3.1 Map.prototype.clear()\n // 23.2.3.2 Set.prototype.clear()\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // 23.1.3.3 Map.prototype.delete(key)\n // 23.2.3.4 Set.prototype.delete(value)\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first == entry) state.first = next;\n if (state.last == entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // 23.1.3.7 Map.prototype.has(key)\n // 23.2.3.7 Set.prototype.has(value)\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n redefineAll(C.prototype, IS_MAP ? {\n // 23.1.3.6 Map.prototype.get(key)\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // 23.1.3.9 Map.prototype.set(key, value)\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // 23.2.3.1 Set.prototype.add(value)\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineProperty(C.prototype, 'size', {\n get: function () {\n return getInternalState(this).size;\n }\n });\n return C;\n },\n setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // add .keys, .values, .entries, [@@iterator]\n // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return { value: undefined, done: true };\n }\n // return step by kind\n if (kind == 'keys') return { value: entry.key, done: false };\n if (kind == 'values') return { value: entry.value, done: false };\n return { value: [entry.key, entry.value], done: false };\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // add [@@species], 23.1.2.2, 23.2.2.2\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) redefine(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nif ((!IS_PURE || NEW_ITERATOR_PROTOTYPE) && !has(IteratorPrototype, ITERATOR)) {\n createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n var defineProperty = definePropertyModule.f;\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineProperty(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: String(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return { value: undefined, done: true };\n point = charAt(string, index);\n state.index += point.length;\n return { value: point, done: false };\n});\n","var global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nfor (var COLLECTION_NAME in DOMIterables) {\n var Collection = global[COLLECTION_NAME];\n var CollectionPrototype = Collection && Collection.prototype;\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n if (!CollectionPrototype[TO_STRING_TAG]) {\n createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);\n }\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n}\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var kind = state.kind;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return { value: undefined, done: true };\n }\n if (kind == 'keys') return { value: index, done: false };\n if (kind == 'values') return { value: target[index], done: false };\n return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined';\n","var toInteger = require('../internals/to-integer');\nvar toLength = require('../internals/to-length');\n\n// `ToIndex` abstract operation\n// https://tc39.es/ecma262/#sec-toindex\nmodule.exports = function (it) {\n if (it === undefined) return 0;\n var number = toInteger(it);\n var length = toLength(number);\n if (number !== length) throw RangeError('Wrong length or index');\n return length;\n};\n","'use strict';\nvar toObject = require('../internals/to-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar toLength = require('../internals/to-length');\n\n// `Array.prototype.fill` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.fill\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n var O = toObject(this);\n var length = toLength(O.length);\n var argumentsLength = arguments.length;\n var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);\n var end = argumentsLength > 2 ? arguments[2] : undefined;\n var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n while (endPos > index) O[index++] = value;\n return O;\n};\n","var toPositiveInteger = require('../internals/to-positive-integer');\n\nmodule.exports = function (it, BYTES) {\n var offset = toPositiveInteger(it);\n if (offset % BYTES) throw RangeError('Wrong offset');\n return offset;\n};\n","var toObject = require('../internals/to-object');\nvar toLength = require('../internals/to-length');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar bind = require('../internals/function-bind-context');\nvar aTypedArrayConstructor = require('../internals/array-buffer-view-core').aTypedArrayConstructor;\n\nmodule.exports = function from(source /* , mapfn, thisArg */) {\n var O = toObject(source);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n var iteratorMethod = getIteratorMethod(O);\n var i, length, result, step, iterator, next;\n if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) {\n iterator = iteratorMethod.call(O);\n next = iterator.next;\n O = [];\n while (!(step = next.call(iterator)).done) {\n O.push(step.value);\n }\n }\n if (mapping && argumentsLength > 2) {\n mapfn = bind(mapfn, arguments[2], 2);\n }\n length = toLength(O.length);\n result = new (aTypedArrayConstructor(this))(length);\n for (i = 0; length > i; i++) {\n result[i] = mapping ? mapfn(O[i], i) : O[i];\n }\n return result;\n};\n","var aFunction = require('../internals/a-function');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\nvar toLength = require('../internals/to-length');\n\n// `Array.prototype.{ reduce, reduceRight }` methods implementation\nvar createMethod = function (IS_RIGHT) {\n return function (that, callbackfn, argumentsLength, memo) {\n aFunction(callbackfn);\n var O = toObject(that);\n var self = IndexedObject(O);\n var length = toLength(O.length);\n var index = IS_RIGHT ? length - 1 : 0;\n var i = IS_RIGHT ? -1 : 1;\n if (argumentsLength < 2) while (true) {\n if (index in self) {\n memo = self[index];\n index += i;\n break;\n }\n index += i;\n if (IS_RIGHT ? index < 0 : length <= index) {\n throw TypeError('Reduce of empty array with no initial value');\n }\n }\n for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {\n memo = callbackfn(memo, self[index], index, O);\n }\n return memo;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.reduce` method\n // https://tc39.es/ecma262/#sec-array.prototype.reduce\n left: createMethod(false),\n // `Array.prototype.reduceRight` method\n // https://tc39.es/ecma262/#sec-array.prototype.reduceright\n right: createMethod(true)\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * SpanContext represents Span state that must propagate to descendant Spans\n * and across process boundaries.\n *\n * SpanContext is logically divided into two pieces: the user-level \"Baggage\"\n * (see setBaggageItem and getBaggageItem) that propagates across Span\n * boundaries and any Tracer-implementation-specific fields that are needed to\n * identify or otherwise contextualize the associated Span instance (e.g., a\n * <trace_id, span_id, sampled> tuple).\n */\nvar SpanContext = /** @class */ (function () {\n function SpanContext() {\n }\n // The SpanContext is entirely implementation dependent\n /**\n * Returns a string representation of the implementation internal trace ID.\n *\n * @returns {string}\n */\n SpanContext.prototype.toTraceId = function () {\n return '';\n };\n /**\n * Returns a string representation of the implementation internal span ID.\n *\n * @returns {string}\n */\n SpanContext.prototype.toSpanId = function () {\n return '';\n };\n return SpanContext;\n}());\nexports.SpanContext = SpanContext;\nexports.default = SpanContext;\n//# sourceMappingURL=span_context.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Constants = require(\"./constants\");\nvar reference_1 = require(\"./reference\");\nvar span_1 = require(\"./span\");\n/**\n * Return a new REFERENCE_CHILD_OF reference.\n *\n * @param {SpanContext} spanContext - the parent SpanContext instance to\n * reference.\n * @return a REFERENCE_CHILD_OF reference pointing to `spanContext`\n */\nfunction childOf(spanContext) {\n // Allow the user to pass a Span instead of a SpanContext\n if (spanContext instanceof span_1.default) {\n spanContext = spanContext.context();\n }\n return new reference_1.default(Constants.REFERENCE_CHILD_OF, spanContext);\n}\nexports.childOf = childOf;\n/**\n * Return a new REFERENCE_FOLLOWS_FROM reference.\n *\n * @param {SpanContext} spanContext - the parent SpanContext instance to\n * reference.\n * @return a REFERENCE_FOLLOWS_FROM reference pointing to `spanContext`\n */\nfunction followsFrom(spanContext) {\n // Allow the user to pass a Span instead of a SpanContext\n if (spanContext instanceof span_1.default) {\n spanContext = spanContext.context();\n }\n return new reference_1.default(Constants.REFERENCE_FOLLOWS_FROM, spanContext);\n}\nexports.followsFrom = followsFrom;\n//# sourceMappingURL=functions.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * The FORMAT_BINARY format represents SpanContexts in an opaque binary\n * carrier.\n *\n * Tracer.inject() will set the buffer field to an Array-like (Array,\n * ArrayBuffer, or TypedBuffer) object containing the injected binary data.\n * Any valid Object can be used as long as the buffer field of the object\n * can be set.\n *\n * Tracer.extract() will look for `carrier.buffer`, and that field is\n * expected to be an Array-like object (Array, ArrayBuffer, or\n * TypedBuffer).\n */\nexports.FORMAT_BINARY = 'binary';\n/**\n * The FORMAT_TEXT_MAP format represents SpanContexts using a\n * string->string map (backed by a Javascript Object) as a carrier.\n *\n * NOTE: Unlike FORMAT_HTTP_HEADERS, FORMAT_TEXT_MAP places no restrictions\n * on the characters used in either the keys or the values of the map\n * entries.\n *\n * The FORMAT_TEXT_MAP carrier map may contain unrelated data (e.g.,\n * arbitrary gRPC metadata); as such, the Tracer implementation should use\n * a prefix or other convention to distinguish Tracer-specific key:value\n * pairs.\n */\nexports.FORMAT_TEXT_MAP = 'text_map';\n/**\n * The FORMAT_HTTP_HEADERS format represents SpanContexts using a\n * character-restricted string->string map (backed by a Javascript Object)\n * as a carrier.\n *\n * Keys and values in the FORMAT_HTTP_HEADERS carrier must be suitable for\n * use as HTTP headers (without modification or further escaping). That is,\n * the keys have a greatly restricted character set, casing for the keys\n * may not be preserved by various intermediaries, and the values should be\n * URL-escaped.\n *\n * The FORMAT_HTTP_HEADERS carrier map may contain unrelated data (e.g.,\n * arbitrary HTTP headers); as such, the Tracer implementation should use a\n * prefix or other convention to distinguish Tracer-specific key:value\n * pairs.\n */\nexports.FORMAT_HTTP_HEADERS = 'http_headers';\n/**\n * A Span may be the \"child of\" a parent Span. In a “child of” reference,\n * the parent Span depends on the child Span in some capacity.\n *\n * See more about reference types at https://github.com/opentracing/specification\n */\nexports.REFERENCE_CHILD_OF = 'child_of';\n/**\n * Some parent Spans do not depend in any way on the result of their child\n * Spans. In these cases, we say merely that the child Span “follows from”\n * the parent Span in a causal sense.\n *\n * See more about reference types at https://github.com/opentracing/specification\n */\nexports.REFERENCE_FOLLOWS_FROM = 'follows_from';\n//# sourceMappingURL=constants.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar span_1 = require(\"./span\");\n/**\n * Reference pairs a reference type constant (e.g., REFERENCE_CHILD_OF or\n * REFERENCE_FOLLOWS_FROM) with the SpanContext it points to.\n *\n * See the exported childOf() and followsFrom() functions at the package level.\n */\nvar Reference = /** @class */ (function () {\n /**\n * Initialize a new Reference instance.\n *\n * @param {string} type - the Reference type constant (e.g.,\n * REFERENCE_CHILD_OF or REFERENCE_FOLLOWS_FROM).\n * @param {SpanContext} referencedContext - the SpanContext being referred\n * to. As a convenience, a Span instance may be passed in instead\n * (in which case its .context() is used here).\n */\n function Reference(type, referencedContext) {\n this._type = type;\n this._referencedContext = (referencedContext instanceof span_1.default ?\n referencedContext.context() :\n referencedContext);\n }\n /**\n * @return {string} The Reference type (e.g., REFERENCE_CHILD_OF or\n * REFERENCE_FOLLOWS_FROM).\n */\n Reference.prototype.type = function () {\n return this._type;\n };\n /**\n * @return {SpanContext} The SpanContext being referred to (e.g., the\n * parent in a REFERENCE_CHILD_OF Reference).\n */\n Reference.prototype.referencedContext = function () {\n return this._referencedContext;\n };\n return Reference;\n}());\nexports.default = Reference;\n//# sourceMappingURL=reference.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar opentracing = require(\"../index\");\n/**\n * OpenTracing Context implementation designed for use in\n * unit tests.\n */\nvar MockContext = /** @class */ (function (_super) {\n __extends(MockContext, _super);\n function MockContext(span) {\n var _this = _super.call(this) || this;\n // Store a reference to the span itself since this is a mock tracer\n // intended to make debugging and unit testing easier.\n _this._span = span;\n return _this;\n }\n MockContext.prototype.span = function () {\n return this._span;\n };\n return MockContext;\n}(opentracing.SpanContext));\nexports.MockContext = MockContext;\nexports.default = MockContext;\n//# sourceMappingURL=mock_context.js.map","\"use strict\";\n/* eslint-disable import/no-extraneous-dependencies */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar opentracing = require(\"../index\");\nvar mock_context_1 = require(\"./mock_context\");\n/**\n * OpenTracing Span implementation designed for use in unit tests.\n */\nvar MockSpan = /** @class */ (function (_super) {\n __extends(MockSpan, _super);\n //------------------------------------------------------------------------//\n // MockSpan-specific\n //------------------------------------------------------------------------//\n function MockSpan(tracer) {\n var _this = _super.call(this) || this;\n _this._mockTracer = tracer;\n _this._uuid = _this._generateUUID();\n _this._startMs = Date.now();\n _this._finishMs = 0;\n _this._operationName = '';\n _this._tags = {};\n _this._logs = [];\n return _this;\n }\n //------------------------------------------------------------------------//\n // OpenTracing implementation\n //------------------------------------------------------------------------//\n MockSpan.prototype._context = function () {\n return new mock_context_1.default(this);\n };\n MockSpan.prototype._setOperationName = function (name) {\n this._operationName = name;\n };\n MockSpan.prototype._addTags = function (set) {\n var keys = Object.keys(set);\n for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n var key = keys_1[_i];\n this._tags[key] = set[key];\n }\n };\n MockSpan.prototype._log = function (fields, timestamp) {\n this._logs.push({\n fields: fields,\n timestamp: timestamp\n });\n };\n MockSpan.prototype._finish = function (finishTime) {\n this._finishMs = finishTime || Date.now();\n };\n MockSpan.prototype.uuid = function () {\n return this._uuid;\n };\n MockSpan.prototype.operationName = function () {\n return this._operationName;\n };\n MockSpan.prototype.durationMs = function () {\n return this._finishMs - this._startMs;\n };\n MockSpan.prototype.tags = function () {\n return this._tags;\n };\n MockSpan.prototype.tracer = function () {\n return this._mockTracer;\n };\n MockSpan.prototype._generateUUID = function () {\n var p0 = (\"00000000\" + Math.abs((Math.random() * 0xFFFFFFFF) | 0).toString(16)).substr(-8);\n var p1 = (\"00000000\" + Math.abs((Math.random() * 0xFFFFFFFF) | 0).toString(16)).substr(-8);\n return \"\" + p0 + p1;\n };\n MockSpan.prototype.addReference = function (ref) {\n };\n /**\n * Returns a simplified object better for console.log()'ing.\n */\n MockSpan.prototype.debug = function () {\n var obj = {\n uuid: this._uuid,\n operation: this._operationName,\n millis: [this._finishMs - this._startMs, this._startMs, this._finishMs]\n };\n if (Object.keys(this._tags).length) {\n obj.tags = this._tags;\n }\n return obj;\n };\n return MockSpan;\n}(opentracing.Span));\nexports.MockSpan = MockSpan;\nexports.default = MockSpan;\n//# sourceMappingURL=mock_span.js.map","'use strict'\n\nconst tx = require('./tx')\n\nconst http = {\n isPeer (origin, peers) {\n if (!origin) return false\n\n for (const peer of peers) {\n if (origin === peer) return true\n if (peer instanceof RegExp && peer.test(origin)) return true\n }\n\n return false\n }\n}\n\nmodule.exports = Object.assign({}, tx, http)\n","'use strict'\n\nconst formats = require('./formats')\nconst kinds = require('./kinds')\nconst priority = require('./priority')\nconst tags = require('./tags')\nconst types = require('./types')\nconst exporters = require('./exporters')\n\nmodule.exports = {\n formats,\n kinds,\n priority,\n tags,\n types,\n exporters\n}\n","'use strict'\n\nconst opentracing = require('opentracing')\n\nmodule.exports = {\n TEXT_MAP: opentracing.FORMAT_TEXT_MAP,\n HTTP_HEADERS: opentracing.FORMAT_HTTP_HEADERS,\n BINARY: opentracing.FORMAT_BINARY,\n LOG: 'log'\n}\n","'use strict'\n\nmodule.exports = {\n USER_REJECT: -1,\n AUTO_REJECT: 0,\n AUTO_KEEP: 1,\n USER_KEEP: 2\n}\n","'use strict'\n\nconst DatadogSpanContext = require('../opentracing/span_context')\nconst priority = require('../../../../ext/priority')\n\nconst USER_REJECT = priority.USER_REJECT\n\nclass NoopSpanContext extends DatadogSpanContext {\n constructor (props) {\n super(props)\n\n this._traceFlags.sampled = false\n this._sampling.priority = USER_REJECT\n }\n}\n\nmodule.exports = NoopSpanContext\n","'use strict'\n\nconst ScopeManager = require('./noop/scope_manager')\n\nmodule.exports = ScopeManager\n","'use strict'\n\nconst log = require('./log')\n\nfunction add (carrier, keyValuePairs) {\n if (!carrier || !keyValuePairs) return\n\n if (typeof keyValuePairs === 'string') {\n return add(\n carrier,\n keyValuePairs\n .split(',')\n .filter(tag => tag.indexOf(':') !== -1)\n .reduce((prev, next) => {\n const tag = next.split(':')\n const key = tag[0]\n const value = tag.slice(1).join(':')\n\n prev[key] = value\n\n return prev\n }, {})\n )\n }\n\n if (Array.isArray(keyValuePairs)) {\n return keyValuePairs.forEach(tags => add(carrier, tags))\n }\n\n try {\n Object.keys(keyValuePairs).forEach(key => {\n carrier[key] = keyValuePairs[key]\n })\n } catch (e) {\n log.error(e)\n }\n}\n\nmodule.exports = { add }\n","'use strict'\n\nclass Sampler {\n constructor (rate) {\n this._rate = rate\n }\n\n rate () {\n return this._rate\n }\n\n isSampled () {\n return this._rate === 1 || Math.random() < this._rate\n }\n}\n\nmodule.exports = Sampler\n","\r\n/**\r\n * A hierarchical token bucket for rate limiting. See\r\n * http://en.wikipedia.org/wiki/Token_bucket for more information.\r\n * @author John Hurliman <jhurliman@cull.tv>\r\n *\r\n * @param {Number} bucketSize Maximum number of tokens to hold in the bucket.\r\n * Also known as the burst rate.\r\n * @param {Number} tokensPerInterval Number of tokens to drip into the bucket\r\n * over the course of one interval.\r\n * @param {String|Number} interval The interval length in milliseconds, or as\r\n * one of the following strings: 'second', 'minute', 'hour', day'.\r\n * @param {TokenBucket} parentBucket Optional. A token bucket that will act as\r\n * the parent of this bucket.\r\n */\r\nvar TokenBucket = function(bucketSize, tokensPerInterval, interval, parentBucket) {\r\n this.bucketSize = bucketSize;\r\n this.tokensPerInterval = tokensPerInterval;\r\n\r\n if (typeof interval === 'string') {\r\n switch (interval) {\r\n case 'sec': case 'second':\r\n this.interval = 1000; break;\r\n case 'min': case 'minute':\r\n this.interval = 1000 * 60; break;\r\n case 'hr': case 'hour':\r\n this.interval = 1000 * 60 * 60; break;\r\n case 'day':\r\n this.interval = 1000 * 60 * 60 * 24; break;\r\n default:\r\n throw new Error('Invaid interval ' + interval);\r\n }\r\n } else {\r\n this.interval = interval;\r\n }\r\n\r\n this.parentBucket = parentBucket;\r\n this.content = 0;\r\n this.lastDrip = +new Date();\r\n};\r\n\r\nTokenBucket.prototype = {\r\n bucketSize: 1,\r\n tokensPerInterval: 1,\r\n interval: 1000,\r\n parentBucket: null,\r\n content: 0,\r\n lastDrip: 0,\r\n\r\n /**\r\n * Remove the requested number of tokens and fire the given callback. If the\r\n * bucket (and any parent buckets) contains enough tokens this will happen\r\n * immediately. Otherwise, the removal and callback will happen when enough\r\n * tokens become available.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Function} callback(err, remainingTokens)\r\n * @returns {Boolean} True if the callback was fired immediately, otherwise\r\n * false.\r\n */\r\n removeTokens: function(count, callback) {\r\n var self = this;\r\n\r\n // Is this an infinite size bucket?\r\n if (!this.bucketSize) {\r\n process.nextTick(callback.bind(null, null, count, Number.POSITIVE_INFINITY));\r\n return true;\r\n }\r\n\r\n // Make sure the bucket can hold the requested number of tokens\r\n if (count > this.bucketSize) {\r\n process.nextTick(callback.bind(null, 'Requested tokens ' + count + ' exceeds bucket size ' +\r\n this.bucketSize, null));\r\n return false;\r\n }\r\n\r\n // Drip new tokens into this bucket\r\n this.drip();\r\n\r\n // If we don't have enough tokens in this bucket, come back later\r\n if (count > this.content)\r\n return comeBackLater();\r\n\r\n if (this.parentBucket) {\r\n // Remove the requested from the parent bucket first\r\n return this.parentBucket.removeTokens(count, function(err, remainingTokens) {\r\n if (err) return callback(err, null);\r\n\r\n // Check that we still have enough tokens in this bucket\r\n if (count > self.content)\r\n return comeBackLater();\r\n\r\n // Tokens were removed from the parent bucket, now remove them from\r\n // this bucket and fire the callback. Note that we look at the current\r\n // bucket and parent bucket's remaining tokens and return the smaller\r\n // of the two values\r\n self.content -= count;\r\n callback(null, Math.min(remainingTokens, self.content));\r\n });\r\n } else {\r\n // Remove the requested tokens from this bucket and fire the callback\r\n this.content -= count;\r\n process.nextTick(callback.bind(null, null, this.content));\r\n return true;\r\n }\r\n\r\n function comeBackLater() {\r\n // How long do we need to wait to make up the difference in tokens?\r\n var waitInterval = Math.ceil(\r\n (count - self.content) * (self.interval / self.tokensPerInterval));\r\n setTimeout(function() { self.removeTokens(count, callback); }, waitInterval);\r\n return false;\r\n }\r\n },\r\n\r\n /**\r\n * Attempt to remove the requested number of tokens and return immediately.\r\n * If the bucket (and any parent buckets) contains enough tokens this will\r\n * return true, otherwise false is returned.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Boolean} True if the tokens were successfully removed, otherwise\r\n * false.\r\n */\r\n tryRemoveTokens: function(count) {\r\n // Is this an infinite size bucket?\r\n if (!this.bucketSize)\r\n return true;\r\n\r\n // Make sure the bucket can hold the requested number of tokens\r\n if (count > this.bucketSize)\r\n return false;\r\n\r\n // Drip new tokens into this bucket\r\n this.drip();\r\n\r\n // If we don't have enough tokens in this bucket, return false\r\n if (count > this.content)\r\n return false;\r\n\r\n // Try to remove the requested tokens from the parent bucket\r\n if (this.parentBucket && !this.parentBucket.tryRemoveTokens(count))\r\n return false;\r\n\r\n // Remove the requested tokens from this bucket and return\r\n this.content -= count;\r\n return true;\r\n },\r\n\r\n /**\r\n * Add any new tokens to the bucket since the last drip.\r\n * @returns {Boolean} True if new tokens were added, otherwise false.\r\n */\r\n drip: function() {\r\n if (!this.tokensPerInterval) {\r\n this.content = this.bucketSize;\r\n return;\r\n }\r\n\r\n var now = +new Date();\r\n var deltaMS = Math.max(now - this.lastDrip, 0);\r\n this.lastDrip = now;\r\n\r\n var dripAmount = deltaMS * (this.tokensPerInterval / this.interval);\r\n this.content = Math.min(this.content + dripAmount, this.bucketSize);\r\n }\r\n};\r\n\r\nmodule.exports = TokenBucket;\r\n","'use strict'\n\nconst pick = require('lodash.pick')\nconst id = require('../../id')\nconst DatadogSpanContext = require('../span_context')\nconst NoopSpanContext = require('../../noop/span_context')\nconst log = require('../../log')\n\nconst traceKey = 'x-datadog-trace-id'\nconst spanKey = 'x-datadog-parent-id'\nconst originKey = 'x-datadog-origin'\nconst samplingKey = 'x-datadog-sampling-priority'\nconst sampleKey = 'x-datadog-sampled'\nconst baggagePrefix = 'ot-baggage-'\nconst b3TraceKey = 'x-b3-traceid'\nconst b3TraceExpr = /^([0-9a-f]{16}){1,2}$/i\nconst b3SpanKey = 'x-b3-spanid'\nconst b3SpanExpr = /^[0-9a-f]{16}$/i\nconst b3ParentKey = 'x-b3-parentspanid'\nconst b3SampledKey = 'x-b3-sampled'\nconst b3FlagsKey = 'x-b3-flags'\nconst b3HeaderKey = 'b3'\nconst b3HeaderExpr = /^(([0-9a-f]{16}){1,2}-[0-9a-f]{16}(-[01d](-[0-9a-f]{16})?)?|[01d])$/i\nconst baggageExpr = new RegExp(`^${baggagePrefix}(.+)$`)\nconst ddKeys = [traceKey, spanKey, samplingKey, originKey]\nconst b3Keys = [b3TraceKey, b3SpanKey, b3ParentKey, b3SampledKey, b3FlagsKey, b3HeaderKey]\nconst logKeys = ddKeys.concat(b3Keys)\n\nclass TextMapPropagator {\n constructor (config) {\n this._config = config\n }\n\n inject (spanContext, carrier) {\n carrier[traceKey] = spanContext.toTraceId()\n carrier[spanKey] = spanContext.toSpanId()\n carrier[sampleKey] = spanContext._traceFlags.sampled ? '1' : '0'\n\n this._injectOrigin(spanContext, carrier)\n this._injectSamplingPriority(spanContext, carrier)\n this._injectBaggageItems(spanContext, carrier)\n this._injectB3(spanContext, carrier)\n\n log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)\n }\n\n extract (carrier) {\n const spanContext = this._extractSpanContext(carrier)\n\n if (!spanContext) return spanContext\n\n this._extractOrigin(carrier, spanContext)\n this._extractBaggageItems(carrier, spanContext)\n this._extractSamplingPriority(carrier, spanContext)\n\n log.debug(() => `Extract from carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)\n\n return spanContext\n }\n\n _injectOrigin (spanContext, carrier) {\n const origin = spanContext._trace.origin\n\n if (origin) {\n carrier[originKey] = origin\n }\n }\n\n _injectSamplingPriority (spanContext, carrier) {\n const priority = spanContext._sampling.priority\n\n if (Number.isInteger(priority)) {\n carrier[samplingKey] = priority.toString()\n }\n }\n\n _injectBaggageItems (spanContext, carrier) {\n spanContext._baggageItems && Object.keys(spanContext._baggageItems).forEach(key => {\n carrier[baggagePrefix + key] = String(spanContext._baggageItems[key])\n })\n }\n\n _injectB3 (spanContext, carrier) {\n if (!this._config.experimental.b3) return\n\n carrier[b3TraceKey] = spanContext._traceId.toString('hex')\n carrier[b3SpanKey] = spanContext._spanId.toString('hex')\n carrier[b3SampledKey] = spanContext._traceFlags.sampled ? '1' : '0'\n\n if (spanContext._traceFlags.debug) {\n carrier[b3FlagsKey] = '1'\n }\n\n if (spanContext._parentId) {\n carrier[b3ParentKey] = spanContext._parentId.toString('hex')\n }\n }\n\n _extractSpanContext (carrier) {\n const context = this._extractContext(carrier)\n\n if (!context) return null\n\n if (context.traceFlags.sampled !== false) {\n return new DatadogSpanContext(context)\n } else {\n return new NoopSpanContext(context)\n }\n }\n\n _extractContext (carrier) {\n return this._extractDatadogContext(carrier) || this._extractB3Context(carrier)\n }\n\n _extractDatadogContext (carrier) {\n const sampled = this._isSampled(carrier[sampleKey])\n\n return this._extractGenericContext(carrier, traceKey, spanKey, { sampled }, 10)\n }\n\n _extractB3Context (carrier) {\n if (!this._config.experimental.b3) return null\n\n const b3 = this._extractB3Headers(carrier)\n const debug = b3[b3FlagsKey] === '1'\n const sampled = this._isSampled(b3[b3SampledKey], debug)\n\n return this._extractGenericContext(b3, b3TraceKey, b3SpanKey, { sampled, debug })\n }\n\n _extractGenericContext (carrier, traceKey, spanKey, traceFlags, radix) {\n if (carrier[traceKey] && carrier[spanKey]) {\n return {\n traceId: id(carrier[traceKey], radix),\n spanId: id(carrier[spanKey], radix),\n traceFlags\n }\n } else if (typeof traceFlags.sampled === 'boolean') {\n return {\n traceId: id(),\n spanId: null,\n traceFlags\n }\n }\n\n return null\n }\n\n _extractB3Headers (carrier) {\n if (b3HeaderExpr.test(carrier[b3HeaderKey])) {\n return this._extractB3SingleHeader(carrier)\n } else {\n return this._extractB3MultipleHeaders(carrier)\n }\n }\n\n _extractB3MultipleHeaders (carrier) {\n const b3 = {}\n\n if (b3TraceExpr.test(carrier[b3TraceKey]) && b3SpanExpr.test(carrier[b3SpanKey])) {\n b3[b3TraceKey] = carrier[b3TraceKey]\n b3[b3SpanKey] = carrier[b3SpanKey]\n }\n\n if (carrier[b3SampledKey]) {\n b3[b3SampledKey] = carrier[b3SampledKey]\n }\n\n if (carrier[b3FlagsKey]) {\n b3[b3FlagsKey] = carrier[b3FlagsKey]\n }\n\n return b3\n }\n\n _extractB3SingleHeader (carrier) {\n const parts = carrier[b3HeaderKey].split('-')\n\n if (parts[0] === 'd') {\n return {\n [b3SampledKey]: '1',\n [b3FlagsKey]: '1'\n }\n } else if (parts.length === 1) {\n return {\n [b3SampledKey]: parts[0]\n }\n } else {\n const b3 = {\n [b3TraceKey]: parts[0],\n [b3SpanKey]: parts[1],\n [b3SampledKey]: parts[2] !== '0' ? '1' : '0'\n }\n\n if (parts[2] === 'd') {\n b3[b3FlagsKey] = '1'\n }\n\n return b3\n }\n }\n\n _extractOrigin (carrier, spanContext) {\n const origin = carrier[originKey]\n\n if (typeof carrier[originKey] === 'string') {\n spanContext._trace.origin = origin\n }\n }\n\n _extractBaggageItems (carrier, spanContext) {\n Object.keys(carrier).forEach(key => {\n const match = key.match(baggageExpr)\n\n if (match) {\n spanContext._baggageItems[match[1]] = carrier[key]\n }\n })\n }\n\n _extractSamplingPriority (carrier, spanContext) {\n const priority = parseInt(carrier[samplingKey], 10)\n\n if (Number.isInteger(priority)) {\n spanContext._sampling.priority = parseInt(carrier[samplingKey], 10)\n }\n }\n\n _isSampled (sampled, debug) {\n if (debug || sampled === '1') {\n return true\n } else if (sampled === '0') {\n return false\n }\n\n return null\n }\n}\n\nmodule.exports = TextMapPropagator\n","'use strict'\n\nmodule.exports = {\n ASYNC_RESOURCE: 'async_resource',\n ASYNC_LOCAL_STORAGE: 'async_local_storage',\n ASYNC_HOOKS: 'async_hooks',\n NOOP: 'noop'\n}\n","'use strict'\n\nfunction isTrue (str) {\n str = String(str).toLowerCase()\n return str === 'true' || str === '1'\n}\n\nfunction isFalse (str) {\n str = String(str).toLowerCase()\n return str === 'false' || str === '0'\n}\n\nmodule.exports = {\n isTrue,\n isFalse\n}\n","'use strict'\n\nmodule.exports = require('./packages/dd-trace/browser')\n","'use strict'\n\nrequire('core-js/stable/object/assign') // TODO: remove dependency\nrequire('core-js/stable/set') // TODO: remove dependency\nrequire('core-js/stable/map') // TODO: remove dependency\nrequire('core-js/stable/typed-array') // TODO: remove dependency\n\nconst platform = require('./src/platform')\nconst browser = require('./src/platform/browser')\nconst ext = require('../../ext')\n\nplatform.use(browser)\n\nconst TracerProxy = require('./src/proxy')\nconst tracer = new TracerProxy()\n\nmodule.exports = tracer\nmodule.exports.default = module.exports\nmodule.exports.tracer = module.exports\n\nwindow.ddtrace = { tracer, ext }\n","var parent = require('../../es/object/assign');\n\nmodule.exports = parent;\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n assign: assign\n});\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\nvar nativeAssign = Object.assign;\nvar defineProperty = Object.defineProperty;\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !nativeAssign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line no-undef\n var symbol = Symbol();\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];\n }\n } return T;\n} : nativeAssign;\n","var parent = require('../../es/set');\n\nmodule.exports = parent;\n","require('../../modules/es.set');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Set;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.es/ecma262/#sec-set-objects\nmodule.exports = collection('Set', function (init) {\n return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","var NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n // eslint-disable-next-line no-undef\n && !Symbol.sham\n // eslint-disable-next-line no-undef\n && typeof Symbol.iterator == 'symbol';\n","var anObject = require('../internals/an-object');\n\nmodule.exports = function (iterator) {\n var returnMethod = iterator['return'];\n if (returnMethod !== undefined) {\n return anObject(returnMethod.call(iterator)).value;\n }\n};\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n if (!isObject(it) && it !== null) {\n throw TypeError(\"Can't set \" + String(it) + ' as a prototype');\n } return it;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n return O;\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","var toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.{ codePointAt, at }` methods implementation\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = String(requireObjectCoercible($this));\n var position = toInteger(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = S.charCodeAt(position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING ? S.charAt(position) : first\n : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var parent = require('../../es/map');\n\nmodule.exports = parent;\n","require('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\nmodule.exports = collection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var parent = require('../../es/typed-array');\n\nmodule.exports = parent;\n","require('../../modules/es.typed-array.int8-array');\nrequire('../../modules/es.typed-array.uint8-array');\nrequire('../../modules/es.typed-array.uint8-clamped-array');\nrequire('../../modules/es.typed-array.int16-array');\nrequire('../../modules/es.typed-array.uint16-array');\nrequire('../../modules/es.typed-array.int32-array');\nrequire('../../modules/es.typed-array.uint32-array');\nrequire('../../modules/es.typed-array.float32-array');\nrequire('../../modules/es.typed-array.float64-array');\nrequire('./methods');\n\nmodule.exports = require('../../internals/global');\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Int8Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Int8', function (init) {\n return function Int8Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","'use strict';\nvar global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefineAll = require('../internals/redefine-all');\nvar fails = require('../internals/fails');\nvar anInstance = require('../internals/an-instance');\nvar toInteger = require('../internals/to-integer');\nvar toLength = require('../internals/to-length');\nvar toIndex = require('../internals/to-index');\nvar IEEE754 = require('../internals/ieee754');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar defineProperty = require('../internals/object-define-property').f;\nvar arrayFill = require('../internals/array-fill');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar ARRAY_BUFFER = 'ArrayBuffer';\nvar DATA_VIEW = 'DataView';\nvar PROTOTYPE = 'prototype';\nvar WRONG_LENGTH = 'Wrong length';\nvar WRONG_INDEX = 'Wrong index';\nvar NativeArrayBuffer = global[ARRAY_BUFFER];\nvar $ArrayBuffer = NativeArrayBuffer;\nvar $DataView = global[DATA_VIEW];\nvar $DataViewPrototype = $DataView && $DataView[PROTOTYPE];\nvar ObjectPrototype = Object.prototype;\nvar RangeError = global.RangeError;\n\nvar packIEEE754 = IEEE754.pack;\nvar unpackIEEE754 = IEEE754.unpack;\n\nvar packInt8 = function (number) {\n return [number & 0xFF];\n};\n\nvar packInt16 = function (number) {\n return [number & 0xFF, number >> 8 & 0xFF];\n};\n\nvar packInt32 = function (number) {\n return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF];\n};\n\nvar unpackInt32 = function (buffer) {\n return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];\n};\n\nvar packFloat32 = function (number) {\n return packIEEE754(number, 23, 4);\n};\n\nvar packFloat64 = function (number) {\n return packIEEE754(number, 52, 8);\n};\n\nvar addGetter = function (Constructor, key) {\n defineProperty(Constructor[PROTOTYPE], key, { get: function () { return getInternalState(this)[key]; } });\n};\n\nvar get = function (view, count, index, isLittleEndian) {\n var intIndex = toIndex(index);\n var store = getInternalState(view);\n if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);\n var bytes = getInternalState(store.buffer).bytes;\n var start = intIndex + store.byteOffset;\n var pack = bytes.slice(start, start + count);\n return isLittleEndian ? pack : pack.reverse();\n};\n\nvar set = function (view, count, index, conversion, value, isLittleEndian) {\n var intIndex = toIndex(index);\n var store = getInternalState(view);\n if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);\n var bytes = getInternalState(store.buffer).bytes;\n var start = intIndex + store.byteOffset;\n var pack = conversion(+value);\n for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1];\n};\n\nif (!NATIVE_ARRAY_BUFFER) {\n $ArrayBuffer = function ArrayBuffer(length) {\n anInstance(this, $ArrayBuffer, ARRAY_BUFFER);\n var byteLength = toIndex(length);\n setInternalState(this, {\n bytes: arrayFill.call(new Array(byteLength), 0),\n byteLength: byteLength\n });\n if (!DESCRIPTORS) this.byteLength = byteLength;\n };\n\n $DataView = function DataView(buffer, byteOffset, byteLength) {\n anInstance(this, $DataView, DATA_VIEW);\n anInstance(buffer, $ArrayBuffer, DATA_VIEW);\n var bufferLength = getInternalState(buffer).byteLength;\n var offset = toInteger(byteOffset);\n if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset');\n byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);\n if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);\n setInternalState(this, {\n buffer: buffer,\n byteLength: byteLength,\n byteOffset: offset\n });\n if (!DESCRIPTORS) {\n this.buffer = buffer;\n this.byteLength = byteLength;\n this.byteOffset = offset;\n }\n };\n\n if (DESCRIPTORS) {\n addGetter($ArrayBuffer, 'byteLength');\n addGetter($DataView, 'buffer');\n addGetter($DataView, 'byteLength');\n addGetter($DataView, 'byteOffset');\n }\n\n redefineAll($DataView[PROTOTYPE], {\n getInt8: function getInt8(byteOffset) {\n return get(this, 1, byteOffset)[0] << 24 >> 24;\n },\n getUint8: function getUint8(byteOffset) {\n return get(this, 1, byteOffset)[0];\n },\n getInt16: function getInt16(byteOffset /* , littleEndian */) {\n var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);\n return (bytes[1] << 8 | bytes[0]) << 16 >> 16;\n },\n getUint16: function getUint16(byteOffset /* , littleEndian */) {\n var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);\n return bytes[1] << 8 | bytes[0];\n },\n getInt32: function getInt32(byteOffset /* , littleEndian */) {\n return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined));\n },\n getUint32: function getUint32(byteOffset /* , littleEndian */) {\n return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)) >>> 0;\n },\n getFloat32: function getFloat32(byteOffset /* , littleEndian */) {\n return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 23);\n },\n getFloat64: function getFloat64(byteOffset /* , littleEndian */) {\n return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 52);\n },\n setInt8: function setInt8(byteOffset, value) {\n set(this, 1, byteOffset, packInt8, value);\n },\n setUint8: function setUint8(byteOffset, value) {\n set(this, 1, byteOffset, packInt8, value);\n },\n setInt16: function setInt16(byteOffset, value /* , littleEndian */) {\n set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);\n },\n setUint16: function setUint16(byteOffset, value /* , littleEndian */) {\n set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);\n },\n setInt32: function setInt32(byteOffset, value /* , littleEndian */) {\n set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);\n },\n setUint32: function setUint32(byteOffset, value /* , littleEndian */) {\n set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);\n },\n setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {\n set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : undefined);\n },\n setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {\n set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : undefined);\n }\n });\n} else {\n if (!fails(function () {\n NativeArrayBuffer(1);\n }) || !fails(function () {\n new NativeArrayBuffer(-1); // eslint-disable-line no-new\n }) || fails(function () {\n new NativeArrayBuffer(); // eslint-disable-line no-new\n new NativeArrayBuffer(1.5); // eslint-disable-line no-new\n new NativeArrayBuffer(NaN); // eslint-disable-line no-new\n return NativeArrayBuffer.name != ARRAY_BUFFER;\n })) {\n $ArrayBuffer = function ArrayBuffer(length) {\n anInstance(this, $ArrayBuffer);\n return new NativeArrayBuffer(toIndex(length));\n };\n var ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE] = NativeArrayBuffer[PROTOTYPE];\n for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) {\n if (!((key = keys[j++]) in $ArrayBuffer)) {\n createNonEnumerableProperty($ArrayBuffer, key, NativeArrayBuffer[key]);\n }\n }\n ArrayBufferPrototype.constructor = $ArrayBuffer;\n }\n\n // WebKit bug - the same parent prototype for typed arrays and data view\n if (setPrototypeOf && getPrototypeOf($DataViewPrototype) !== ObjectPrototype) {\n setPrototypeOf($DataViewPrototype, ObjectPrototype);\n }\n\n // iOS Safari 7.x bug\n var testView = new $DataView(new $ArrayBuffer(2));\n var nativeSetInt8 = $DataViewPrototype.setInt8;\n testView.setInt8(0, 2147483648);\n testView.setInt8(1, 2147483649);\n if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll($DataViewPrototype, {\n setInt8: function setInt8(byteOffset, value) {\n nativeSetInt8.call(this, byteOffset, value << 24 >> 24);\n },\n setUint8: function setUint8(byteOffset, value) {\n nativeSetInt8.call(this, byteOffset, value << 24 >> 24);\n }\n }, { unsafe: true });\n}\n\nsetToStringTag($ArrayBuffer, ARRAY_BUFFER);\nsetToStringTag($DataView, DATA_VIEW);\n\nmodule.exports = {\n ArrayBuffer: $ArrayBuffer,\n DataView: $DataView\n};\n","// IEEE754 conversions based on https://github.com/feross/ieee754\n// eslint-disable-next-line no-shadow-restricted-names\nvar Infinity = 1 / 0;\nvar abs = Math.abs;\nvar pow = Math.pow;\nvar floor = Math.floor;\nvar log = Math.log;\nvar LN2 = Math.LN2;\n\nvar pack = function (number, mantissaLength, bytes) {\n var buffer = new Array(bytes);\n var exponentLength = bytes * 8 - mantissaLength - 1;\n var eMax = (1 << exponentLength) - 1;\n var eBias = eMax >> 1;\n var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0;\n var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0;\n var index = 0;\n var exponent, mantissa, c;\n number = abs(number);\n // eslint-disable-next-line no-self-compare\n if (number != number || number === Infinity) {\n // eslint-disable-next-line no-self-compare\n mantissa = number != number ? 1 : 0;\n exponent = eMax;\n } else {\n exponent = floor(log(number) / LN2);\n if (number * (c = pow(2, -exponent)) < 1) {\n exponent--;\n c *= 2;\n }\n if (exponent + eBias >= 1) {\n number += rt / c;\n } else {\n number += rt * pow(2, 1 - eBias);\n }\n if (number * c >= 2) {\n exponent++;\n c /= 2;\n }\n if (exponent + eBias >= eMax) {\n mantissa = 0;\n exponent = eMax;\n } else if (exponent + eBias >= 1) {\n mantissa = (number * c - 1) * pow(2, mantissaLength);\n exponent = exponent + eBias;\n } else {\n mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength);\n exponent = 0;\n }\n }\n for (; mantissaLength >= 8; buffer[index++] = mantissa & 255, mantissa /= 256, mantissaLength -= 8);\n exponent = exponent << mantissaLength | mantissa;\n exponentLength += mantissaLength;\n for (; exponentLength > 0; buffer[index++] = exponent & 255, exponent /= 256, exponentLength -= 8);\n buffer[--index] |= sign * 128;\n return buffer;\n};\n\nvar unpack = function (buffer, mantissaLength) {\n var bytes = buffer.length;\n var exponentLength = bytes * 8 - mantissaLength - 1;\n var eMax = (1 << exponentLength) - 1;\n var eBias = eMax >> 1;\n var nBits = exponentLength - 7;\n var index = bytes - 1;\n var sign = buffer[index--];\n var exponent = sign & 127;\n var mantissa;\n sign >>= 7;\n for (; nBits > 0; exponent = exponent * 256 + buffer[index], index--, nBits -= 8);\n mantissa = exponent & (1 << -nBits) - 1;\n exponent >>= -nBits;\n nBits += mantissaLength;\n for (; nBits > 0; mantissa = mantissa * 256 + buffer[index], index--, nBits -= 8);\n if (exponent === 0) {\n exponent = 1 - eBias;\n } else if (exponent === eMax) {\n return mantissa ? NaN : sign ? -Infinity : Infinity;\n } else {\n mantissa = mantissa + pow(2, mantissaLength);\n exponent = exponent - eBias;\n } return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength);\n};\n\nmodule.exports = {\n pack: pack,\n unpack: unpack\n};\n","var toInteger = require('../internals/to-integer');\n\nmodule.exports = function (it) {\n var result = toInteger(it);\n if (result < 0) throw RangeError(\"The argument can't be less than 0\");\n return result;\n};\n","var isObject = require('../internals/is-object');\nvar isArray = require('../internals/is-array');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\nmodule.exports = Array.isArray || function isArray(arg) {\n return classof(arg) == 'Array';\n};\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Uint8Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Uint8', function (init) {\n return function Uint8Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Uint8ClampedArray` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Uint8', function (init) {\n return function Uint8ClampedArray(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n}, true);\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Int16Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Int16', function (init) {\n return function Int16Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Uint16Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Uint16', function (init) {\n return function Uint16Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Int32Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Int32', function (init) {\n return function Int32Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Uint32Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Uint32', function (init) {\n return function Uint32Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Float32Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Float32', function (init) {\n return function Float32Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","var createTypedArrayConstructor = require('../internals/typed-array-constructor');\n\n// `Float64Array` constructor\n// https://tc39.es/ecma262/#sec-typedarray-objects\ncreateTypedArrayConstructor('Float64', function (init) {\n return function Float64Array(data, byteOffset, length) {\n return init(this, data, byteOffset, length);\n };\n});\n","require('../../modules/es.typed-array.from');\nrequire('../../modules/es.typed-array.of');\nrequire('../../modules/es.typed-array.copy-within');\nrequire('../../modules/es.typed-array.every');\nrequire('../../modules/es.typed-array.fill');\nrequire('../../modules/es.typed-array.filter');\nrequire('../../modules/es.typed-array.find');\nrequire('../../modules/es.typed-array.find-index');\nrequire('../../modules/es.typed-array.for-each');\nrequire('../../modules/es.typed-array.includes');\nrequire('../../modules/es.typed-array.index-of');\nrequire('../../modules/es.typed-array.join');\nrequire('../../modules/es.typed-array.last-index-of');\nrequire('../../modules/es.typed-array.map');\nrequire('../../modules/es.typed-array.reduce');\nrequire('../../modules/es.typed-array.reduce-right');\nrequire('../../modules/es.typed-array.reverse');\nrequire('../../modules/es.typed-array.set');\nrequire('../../modules/es.typed-array.slice');\nrequire('../../modules/es.typed-array.some');\nrequire('../../modules/es.typed-array.sort');\nrequire('../../modules/es.typed-array.subarray');\nrequire('../../modules/es.typed-array.to-locale-string');\nrequire('../../modules/es.typed-array.to-string');\nrequire('../../modules/es.typed-array.iterator');\nrequire('../../modules/es.object.to-string');\n","'use strict';\nvar TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-array-constructors-require-wrappers');\nvar exportTypedArrayStaticMethod = require('../internals/array-buffer-view-core').exportTypedArrayStaticMethod;\nvar typedArrayFrom = require('../internals/typed-array-from');\n\n// `%TypedArray%.from` method\n// https://tc39.es/ecma262/#sec-%typedarray%.from\nexportTypedArrayStaticMethod('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-array-constructors-require-wrappers');\n\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar exportTypedArrayStaticMethod = ArrayBufferViewCore.exportTypedArrayStaticMethod;\n\n// `%TypedArray%.of` method\n// https://tc39.es/ecma262/#sec-%typedarray%.of\nexportTypedArrayStaticMethod('of', function of(/* ...items */) {\n var index = 0;\n var length = arguments.length;\n var result = new (aTypedArrayConstructor(this))(length);\n while (length > index) result[index] = arguments[index++];\n return result;\n}, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $copyWithin = require('../internals/array-copy-within');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.copyWithin` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin\nexportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end */) {\n return $copyWithin.call(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined);\n});\n","'use strict';\nvar toObject = require('../internals/to-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar toLength = require('../internals/to-length');\n\nvar min = Math.min;\n\n// `Array.prototype.copyWithin` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.copywithin\nmodule.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {\n var O = toObject(this);\n var len = toLength(O.length);\n var to = toAbsoluteIndex(target, len);\n var from = toAbsoluteIndex(start, len);\n var end = arguments.length > 2 ? arguments[2] : undefined;\n var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);\n var inc = 1;\n if (from < to && to < from + count) {\n inc = -1;\n from += count - 1;\n to += count - 1;\n }\n while (count-- > 0) {\n if (from in O) O[to] = O[from];\n else delete O[to];\n to += inc;\n from += inc;\n } return O;\n};\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $every = require('../internals/array-iteration').every;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.every` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.every\nexportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) {\n return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $fill = require('../internals/array-fill');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.fill` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill\n// eslint-disable-next-line no-unused-vars\nexportTypedArrayMethod('fill', function fill(value /* , start, end */) {\n return $fill.apply(aTypedArray(this), arguments);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $filter = require('../internals/array-iteration').filter;\nvar speciesConstructor = require('../internals/species-constructor');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.filter` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter\nexportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) {\n var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var C = speciesConstructor(this, this.constructor);\n var index = 0;\n var length = list.length;\n var result = new (aTypedArrayConstructor(C))(length);\n while (length > index) result[index] = list[index++];\n return result;\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $find = require('../internals/array-iteration').find;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.find` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.find\nexportTypedArrayMethod('find', function find(predicate /* , thisArg */) {\n return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $findIndex = require('../internals/array-iteration').findIndex;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.findIndex` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex\nexportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */) {\n return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $forEach = require('../internals/array-iteration').forEach;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.forEach` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach\nexportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) {\n $forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $includes = require('../internals/array-includes').includes;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.includes` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes\nexportTypedArrayMethod('includes', function includes(searchElement /* , fromIndex */) {\n return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $indexOf = require('../internals/array-includes').indexOf;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.indexOf` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof\nexportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex */) {\n return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $join = [].join;\n\n// `%TypedArray%.prototype.join` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.join\n// eslint-disable-next-line no-unused-vars\nexportTypedArrayMethod('join', function join(separator) {\n return $join.apply(aTypedArray(this), arguments);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $lastIndexOf = require('../internals/array-last-index-of');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.lastIndexOf` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof\n// eslint-disable-next-line no-unused-vars\nexportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) {\n return $lastIndexOf.apply(aTypedArray(this), arguments);\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toInteger = require('../internals/to-integer');\nvar toLength = require('../internals/to-length');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\n\nvar min = Math.min;\nvar nativeLastIndexOf = [].lastIndexOf;\nvar NEGATIVE_ZERO = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0;\nvar STRICT_METHOD = arrayMethodIsStrict('lastIndexOf');\n// For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method\nvar USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { ACCESSORS: true, 1: 0 });\nvar FORCED = NEGATIVE_ZERO || !STRICT_METHOD || !USES_TO_LENGTH;\n\n// `Array.prototype.lastIndexOf` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.lastindexof\nmodule.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {\n // convert -0 to +0\n if (NEGATIVE_ZERO) return nativeLastIndexOf.apply(this, arguments) || 0;\n var O = toIndexedObject(this);\n var length = toLength(O.length);\n var index = length - 1;\n if (arguments.length > 1) index = min(index, toInteger(arguments[1]));\n if (index < 0) index = length + index;\n for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0;\n return -1;\n} : nativeLastIndexOf;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call,no-throw-literal\n method.call(null, argument || function () { throw 1; }, 1);\n });\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar has = require('../internals/has');\n\nvar defineProperty = Object.defineProperty;\nvar cache = {};\n\nvar thrower = function (it) { throw it; };\n\nmodule.exports = function (METHOD_NAME, options) {\n if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];\n if (!options) options = {};\n var method = [][METHOD_NAME];\n var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;\n var argument0 = has(options, 0) ? options[0] : thrower;\n var argument1 = has(options, 1) ? options[1] : undefined;\n\n return cache[METHOD_NAME] = !!method && !fails(function () {\n if (ACCESSORS && !DESCRIPTORS) return true;\n var O = { length: -1 };\n\n if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower });\n else O[1] = 1;\n\n method.call(O, argument0, argument1);\n });\n};\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $map = require('../internals/array-iteration').map;\nvar speciesConstructor = require('../internals/species-constructor');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.map` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.map\nexportTypedArrayMethod('map', function map(mapfn /* , thisArg */) {\n return $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) {\n return new (aTypedArrayConstructor(speciesConstructor(O, O.constructor)))(length);\n });\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $reduce = require('../internals/array-reduce').left;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.reduce` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce\nexportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */) {\n return $reduce(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $reduceRight = require('../internals/array-reduce').right;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.reduceRicht` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright\nexportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initialValue */) {\n return $reduceRight(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar floor = Math.floor;\n\n// `%TypedArray%.prototype.reverse` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse\nexportTypedArrayMethod('reverse', function reverse() {\n var that = this;\n var length = aTypedArray(that).length;\n var middle = floor(length / 2);\n var index = 0;\n var value;\n while (index < middle) {\n value = that[index];\n that[index++] = that[--length];\n that[length] = value;\n } return that;\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar toLength = require('../internals/to-length');\nvar toOffset = require('../internals/to-offset');\nvar toObject = require('../internals/to-object');\nvar fails = require('../internals/fails');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\nvar FORCED = fails(function () {\n // eslint-disable-next-line no-undef\n new Int8Array(1).set({});\n});\n\n// `%TypedArray%.prototype.set` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set\nexportTypedArrayMethod('set', function set(arrayLike /* , offset */) {\n aTypedArray(this);\n var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);\n var length = this.length;\n var src = toObject(arrayLike);\n var len = toLength(src.length);\n var index = 0;\n if (len + offset > length) throw RangeError('Wrong length');\n while (index < len) this[offset + index] = src[index++];\n}, FORCED);\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar speciesConstructor = require('../internals/species-constructor');\nvar fails = require('../internals/fails');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $slice = [].slice;\n\nvar FORCED = fails(function () {\n // eslint-disable-next-line no-undef\n new Int8Array(1).slice();\n});\n\n// `%TypedArray%.prototype.slice` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice\nexportTypedArrayMethod('slice', function slice(start, end) {\n var list = $slice.call(aTypedArray(this), start, end);\n var C = speciesConstructor(this, this.constructor);\n var index = 0;\n var length = list.length;\n var result = new (aTypedArrayConstructor(C))(length);\n while (length > index) result[index] = list[index++];\n return result;\n}, FORCED);\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $some = require('../internals/array-iteration').some;\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.some` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.some\nexportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) {\n return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $sort = [].sort;\n\n// `%TypedArray%.prototype.sort` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort\nexportTypedArrayMethod('sort', function sort(comparefn) {\n return $sort.call(aTypedArray(this), comparefn);\n});\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar speciesConstructor = require('../internals/species-constructor');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\n// `%TypedArray%.prototype.subarray` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray\nexportTypedArrayMethod('subarray', function subarray(begin, end) {\n var O = aTypedArray(this);\n var length = O.length;\n var beginIndex = toAbsoluteIndex(begin, length);\n return new (speciesConstructor(O, O.constructor))(\n O.buffer,\n O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT,\n toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex)\n );\n});\n","'use strict';\nvar global = require('../internals/global');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar fails = require('../internals/fails');\n\nvar Int8Array = global.Int8Array;\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $toLocaleString = [].toLocaleString;\nvar $slice = [].slice;\n\n// iOS Safari 6.x fails here\nvar TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () {\n $toLocaleString.call(new Int8Array(1));\n});\n\nvar FORCED = fails(function () {\n return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString();\n}) || !fails(function () {\n Int8Array.prototype.toLocaleString.call([1, 2]);\n});\n\n// `%TypedArray%.prototype.toLocaleString` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring\nexportTypedArrayMethod('toLocaleString', function toLocaleString() {\n return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments);\n}, FORCED);\n","'use strict';\nvar exportTypedArrayMethod = require('../internals/array-buffer-view-core').exportTypedArrayMethod;\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar Uint8Array = global.Uint8Array;\nvar Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {};\nvar arrayToString = [].toString;\nvar arrayJoin = [].join;\n\nif (fails(function () { arrayToString.call({}); })) {\n arrayToString = function toString() {\n return arrayJoin.call(this);\n };\n}\n\nvar IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString;\n\n// `%TypedArray%.prototype.toString` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tostring\nexportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD);\n","'use strict';\nvar global = require('../internals/global');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar ArrayIterators = require('../modules/es.array.iterator');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar Uint8Array = global.Uint8Array;\nvar arrayValues = ArrayIterators.values;\nvar arrayKeys = ArrayIterators.keys;\nvar arrayEntries = ArrayIterators.entries;\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar nativeTypedArrayIterator = Uint8Array && Uint8Array.prototype[ITERATOR];\n\nvar CORRECT_ITER_NAME = !!nativeTypedArrayIterator\n && (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined);\n\nvar typedArrayValues = function values() {\n return arrayValues.call(aTypedArray(this));\n};\n\n// `%TypedArray%.prototype.entries` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries\nexportTypedArrayMethod('entries', function entries() {\n return arrayEntries.call(aTypedArray(this));\n});\n// `%TypedArray%.prototype.keys` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys\nexportTypedArrayMethod('keys', function keys() {\n return arrayKeys.call(aTypedArray(this));\n});\n// `%TypedArray%.prototype.values` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.values\nexportTypedArrayMethod('values', typedArrayValues, !CORRECT_ITER_NAME);\n// `%TypedArray%.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator\nexportTypedArrayMethod(ITERATOR, typedArrayValues, !CORRECT_ITER_NAME);\n","'use strict'\n\nconst crypto = require('./crypto')\nconst now = require('./now')\nconst env = require('./env')\nconst tags = require('./tags')\nconst validate = require('./validate')\nconst metrics = require('./metrics')\nconst plugins = require('../../plugins/browser')\nconst startupLog = require('./startup-log')\nconst exporter = require('./exporter')\nconst Loader = require('./loader')\nconst Scope = require('../../scope/zone')\n\nconst platform = {\n _config: {},\n // TODO: determine what should be the name/version/engine\n name: () => {},\n version: () => {},\n engine: () => {},\n crypto,\n now,\n env,\n tags,\n validate,\n service: () => 'browser',\n appVersion: () => null,\n metrics,\n plugins,\n startupLog,\n hostname: () => {}, // TODO: add hostname\n on: () => {}, // TODO: add event listener\n off: () => {}, // TODO: add event listener\n Loader,\n getScope: () => Scope,\n exporter,\n profiler: () => ({\n start: () => {},\n stop: () => {}\n })\n}\n\nmodule.exports = platform\n","'use strict'\n\nmodule.exports = window.crypto || window.msCrypto\n","'use strict'\n\nmodule.exports = () => window.performance.now()\n","'use strict'\n\nmodule.exports = name => window[name]\n","'use strict'\n\nmodule.exports = () => {\n const rum = window.DD_RUM\n const context = rum && rum.getInternalContext && rum.getInternalContext()\n\n return { ...context }\n}\n","'use strict'\n\n// TODO: validate user agent\n\nfunction validate () {}\n\nmodule.exports = validate\n","'use strict'\n\n// TODO: consider implementing browser metrics\n\nlet metrics = null\n\nmodule.exports = function () {\n return metrics || (metrics = { // cache the metrics instance\n start: () => {},\n\n stop: () => {},\n\n track () {\n return {\n finish: () => {}\n }\n },\n\n boolean () {},\n\n histogram () {},\n\n count () {},\n\n gauge () {},\n\n increment () {},\n\n decrement () {}\n })\n}\n","'use strict'\n\nmodule.exports = {\n 'fetch': require('../../../datadog-plugin-fetch/src'),\n 'xmlhttprequest': require('../../../datadog-plugin-xmlhttprequest/src')\n}\n","'use strict'\n\nconst URL = require('url-parse')\nconst { Reference, REFERENCE_CHILD_OF } = require('opentracing')\nconst { REFERENCE_NOOP } = require('../../dd-trace/src/constants')\nconst tx = require('../../dd-trace/src/plugins/util/http')\n\nfunction createWrapFetch (tracer, config) {\n return function wrapFetch (fetch) {\n const fetchWithTrace = function fetchWithTrace () {\n return fetch._datadog_wrapper.apply(this, arguments)\n }\n\n fetch._datadog_wrapper = function (resource, init) {\n const service = config.service || `${tracer._service}-http-client`\n const method = getMethod(resource, init)\n const url = getUrl(resource)\n const scope = tracer.scope()\n const childOf = scope.active()\n const type = isFlush(tracer._url.href, url) ? REFERENCE_NOOP : REFERENCE_CHILD_OF\n const span = tracer.startSpan('browser.request', {\n references: [\n new Reference(type, childOf)\n ],\n tags: {\n 'span.kind': 'client',\n 'service.name': service,\n 'resource.name': method,\n 'span.type': 'http',\n 'http.method': method,\n 'http.url': url.href\n }\n })\n\n // HACK: move to backend\n span.setTag('_top_level', 1)\n\n if (type === REFERENCE_CHILD_OF) {\n init = inject(init, tracer, span, url.origin)\n }\n\n const promise = tracer.scope().bind(fetch, span).call(this, resource, init)\n\n promise.then(res => {\n span.setTag('http.status_code', res.status)\n })\n\n tx.wrap(span, promise)\n\n return promise\n }\n\n return fetchWithTrace\n }\n}\n\nfunction unwrapFetch (fetch) {\n fetch._datadog_wrapper = fetch\n}\n\nfunction getMethod (resource, init) {\n if (init && init.method) return init.method\n if (resource && resource.method) return resource.method\n\n return 'GET'\n}\n\nfunction getUrl (resource) {\n const url = typeof resource === 'object'\n ? resource.url\n : resource\n\n return new URL(url, window.location.origin)\n}\n\nfunction inject (init, tracer, span, origin) {\n const format = window.ddtrace.ext.formats.HTTP_HEADERS\n const peers = tracer._peers\n\n if (origin !== window.location.origin && !tx.isPeer(origin, peers)) {\n return init\n }\n\n init = init || {}\n init.headers = init.headers || {}\n\n if (typeof init.headers.set === 'function') {\n const headers = {}\n\n tracer.inject(span, format, headers)\n\n for (const name in headers) {\n init.headers.set(name, headers[name])\n }\n } else {\n tracer.inject(span, format, init.headers)\n }\n\n return init\n}\n\n// TODO: support staging and other environments\nfunction isFlush (href, url) {\n return (new RegExp(`^${href}/v1/input/[a-z0-9]+$`, 'i')).test(url.href) ||\n url.href.startsWith('https://rum-http-intake.logs.datadoghq.com') ||\n url.href.startsWith('https://browser-http-intake.logs.datadoghq.com')\n}\n\nmodule.exports = {\n name: 'fetch',\n patch (fetch, tracer, config) {\n return createWrapFetch(tracer, config)(fetch)\n },\n\n unpatch (fetch) {\n unwrapFetch(fetch)\n }\n}\n","'use strict';\n\n/**\n * Check if we're required to add a port number.\n *\n * @see https://url.spec.whatwg.org/#default-port\n * @param {Number|String} port Port number we need to check\n * @param {String} protocol Protocol we need to check against.\n * @returns {Boolean} Is it a default port for the given protocol\n * @api private\n */\nmodule.exports = function required(port, protocol) {\n protocol = protocol.split(':')[0];\n port = +port;\n\n if (!port) return false;\n\n switch (protocol) {\n case 'http':\n case 'ws':\n return port !== 80;\n\n case 'https':\n case 'wss':\n return port !== 443;\n\n case 'ftp':\n return port !== 21;\n\n case 'gopher':\n return port !== 70;\n\n case 'file':\n return false;\n }\n\n return port !== 0;\n};\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n , undef;\n\n/**\n * Decode a URI encoded string.\n *\n * @param {String} input The URI encoded string.\n * @returns {String|Null} The decoded string.\n * @api private\n */\nfunction decode(input) {\n try {\n return decodeURIComponent(input.replace(/\\+/g, ' '));\n } catch (e) {\n return null;\n }\n}\n\n/**\n * Attempts to encode a given input.\n *\n * @param {String} input The string that needs to be encoded.\n * @returns {String|Null} The encoded string.\n * @api private\n */\nfunction encode(input) {\n try {\n return encodeURIComponent(input);\n } catch (e) {\n return null;\n }\n}\n\n/**\n * Simple query string parser.\n *\n * @param {String} query The query string that needs to be parsed.\n * @returns {Object}\n * @api public\n */\nfunction querystring(query) {\n var parser = /([^=?#&]+)=?([^&]*)/g\n , result = {}\n , part;\n\n while (part = parser.exec(query)) {\n var key = decode(part[1])\n , value = decode(part[2]);\n\n //\n // Prevent overriding of existing properties. This ensures that build-in\n // methods like `toString` or __proto__ are not overriden by malicious\n // querystrings.\n //\n // In the case if failed decoding, we want to omit the key/value pairs\n // from the result.\n //\n if (key === null || value === null || key in result) continue;\n result[key] = value;\n }\n\n return result;\n}\n\n/**\n * Transform a query string to an object.\n *\n * @param {Object} obj Object that should be transformed.\n * @param {String} prefix Optional prefix.\n * @returns {String}\n * @api public\n */\nfunction querystringify(obj, prefix) {\n prefix = prefix || '';\n\n var pairs = []\n , value\n , key;\n\n //\n // Optionally prefix with a '?' if needed\n //\n if ('string' !== typeof prefix) prefix = '?';\n\n for (key in obj) {\n if (has.call(obj, key)) {\n value = obj[key];\n\n //\n // Edge cases where we actually want to encode the value to an empty\n // string instead of the stringified value.\n //\n if (!value && (value === null || value === undef || isNaN(value))) {\n value = '';\n }\n\n key = encode(key);\n value = encode(value);\n\n //\n // If we failed to encode the strings, we should bail out as we don't\n // want to add invalid strings to the query.\n //\n if (key === null || value === null) continue;\n pairs.push(key +'='+ value);\n }\n }\n\n return pairs.length ? prefix + pairs.join('&') : '';\n}\n\n//\n// Expose the module.\n//\nexports.stringify = querystringify;\nexports.parse = querystring;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Convenience class to use as a binary carrier.\n *\n * Any valid Object with a field named `buffer` may be used as a binary carrier;\n * this class is only one such type of object that can be used.\n */\nvar BinaryCarrier = /** @class */ (function () {\n function BinaryCarrier(buffer) {\n this.buffer = buffer;\n }\n return BinaryCarrier;\n}());\nexports.default = BinaryCarrier;\n//# sourceMappingURL=binary_carrier.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** SPAN_KIND hints at relationship between spans, e.g. client/server */\nexports.SPAN_KIND = 'span.kind';\n/** Marks a span representing the client-side of an RPC or other remote call */\nexports.SPAN_KIND_RPC_CLIENT = 'client';\n/** Marks a span representing the server-side of an RPC or other remote call */\nexports.SPAN_KIND_RPC_SERVER = 'server';\n/** Marks a span representing the producing-side within a messaging system or other remote call */\nexports.SPAN_KIND_MESSAGING_PRODUCER = 'producer';\n/** Marks a span representing the consuming-side within a messaging system or other remote call */\nexports.SPAN_KIND_MESSAGING_CONSUMER = 'consumer';\n/**\n * ERROR (boolean) true if and only if the application considers the operation\n * represented by the Span to have failed\n */\nexports.ERROR = 'error';\n/**\n * COMPONENT (string) ia s low-cardinality identifier of the module, library,\n * or package that is generating a span.\n */\nexports.COMPONENT = 'component';\n/**\n * SAMPLING_PRIORITY (number) determines the priority of sampling this Span.\n * If greater than 0, a hint to the Tracer to do its best to capture the trace.\n * If 0, a hint to the trace to not-capture the trace. If absent, the Tracer\n * should use its default sampling mechanism.\n */\nexports.SAMPLING_PRIORITY = 'sampling.priority';\n// ---------------------------------------------------------------------------\n// PEER_* tags can be emitted by either client-side of server-side to describe\n// the other side/service in a peer-to-peer communications, like an RPC call.\n// ---------------------------------------------------------------------------\n/**\n * PEER_SERVICE (string) Remote service name (for some unspecified\n * definition of \"service\"). E.g., \"elasticsearch\", \"a_custom_microservice\", \"memcache\"\n */\nexports.PEER_SERVICE = 'peer.service';\n/** PEER_HOSTNAME (string) Remote hostname. E.g., \"opentracing.io\", \"internal.dns.name\" */\nexports.PEER_HOSTNAME = 'peer.hostname';\n/**\n * PEER_ADDRESS (string) Remote \"address\", suitable for use in a\n * networking client library. This may be a \"ip:port\", a bare\n * \"hostname\", a FQDN, or even a JDBC substring like \"mysql://prod-db:3306\"\n */\nexports.PEER_ADDRESS = 'peer.address';\n/**\n * PEER_HOST_IPV4 (number) Remote IPv4 address as a .-separated tuple.\n * E.g., \"127.0.0.1\"\n */\nexports.PEER_HOST_IPV4 = 'peer.ipv4';\n// PEER_HOST_IPV6 (string) Remote IPv6 address as a string of\n// colon-separated 4-char hex tuples. E.g., \"2001:0db8:85a3:0000:0000:8a2e:0370:7334\"\nexports.PEER_HOST_IPV6 = 'peer.ipv6';\n// PEER_PORT (number) Remote port. E.g., 80\nexports.PEER_PORT = 'peer.port';\n// ---------------------------------------------------------------------------\n// HTTP tags\n// ---------------------------------------------------------------------------\n/**\n * HTTP_URL (string) URL of the request being handled in this segment of the\n * trace, in standard URI format. E.g., \"https://domain.net/path/to?resource=here\"\n */\nexports.HTTP_URL = 'http.url';\n/**\n * HTTP_METHOD (string) HTTP method of the request for the associated Span. E.g.,\n * \"GET\", \"POST\"\n */\nexports.HTTP_METHOD = 'http.method';\n/**\n * HTTP_STATUS_CODE (number) HTTP response status code for the associated Span.\n * E.g., 200, 503, 404\n */\nexports.HTTP_STATUS_CODE = 'http.status_code';\n// -------------------------------------------------------------------------\n// Messaging tags\n// -------------------------------------------------------------------------\n/**\n * MESSAGE_BUS_DESTINATION (string) An address at which messages can be exchanged.\n * E.g. A Kafka record has an associated \"topic name\" that can be extracted\n * by the instrumented producer or consumer and stored using this tag.\n */\nexports.MESSAGE_BUS_DESTINATION = 'message_bus.destination';\n// --------------------------------------------------------------------------\n// Database tags\n// --------------------------------------------------------------------------\n/**\n * DB_INSTANCE (string) Database instance name. E.g., In java, if the\n * jdbc.url=\"jdbc:mysql://127.0.0.1:3306/customers\", the instance name is \"customers\".\n */\nexports.DB_INSTANCE = 'db.instance';\n/**\n * DB_STATEMENT (string) A database statement for the given database type.\n * E.g., for db.type=\"SQL\", \"SELECT * FROM wuser_table\";\n * for db.type=\"redis\", \"SET mykey 'WuValue'\".\n */\nexports.DB_STATEMENT = 'db.statement';\n/**\n * DB_TYPE (string) Database type. For any SQL database, \"sql\". For others,\n * the lower-case database category, e.g. \"cassandra\", \"hbase\", or \"redis\".\n */\nexports.DB_TYPE = 'db.type';\n/**\n * DB_USER (string) Username for accessing database. E.g., \"readonly_user\"\n * or \"reporting_user\"\n */\nexports.DB_USER = 'db.user';\n//# sourceMappingURL=tags.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar mock_context_1 = require(\"./mock_context\");\nexports.MockContext = mock_context_1.default;\nvar mock_span_1 = require(\"./mock_span\");\nexports.MockSpan = mock_span_1.default;\nvar mock_tracer_1 = require(\"./mock_tracer\");\nexports.MockTracer = mock_tracer_1.default;\n//# sourceMappingURL=index.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// TODO: Move mock-tracer to its own NPM package once it is complete and tested.\nvar opentracing = require(\"../index\");\nvar mock_report_1 = require(\"./mock_report\");\nvar mock_span_1 = require(\"./mock_span\");\n/**\n * OpenTracing Tracer implementation designed for use in unit tests.\n */\nvar MockTracer = /** @class */ (function (_super) {\n __extends(MockTracer, _super);\n //------------------------------------------------------------------------//\n // MockTracer-specific\n //------------------------------------------------------------------------//\n function MockTracer() {\n var _this = _super.call(this) || this;\n _this._spans = [];\n return _this;\n }\n //------------------------------------------------------------------------//\n // OpenTracing implementation\n //------------------------------------------------------------------------//\n MockTracer.prototype._startSpan = function (name, fields) {\n // _allocSpan is given it's own method so that derived classes can\n // allocate any type of object they want, but not have to duplicate\n // the other common logic in startSpan().\n var span = this._allocSpan();\n span.setOperationName(name);\n this._spans.push(span);\n if (fields.references) {\n for (var _i = 0, _a = fields.references; _i < _a.length; _i++) {\n var ref = _a[_i];\n span.addReference(ref);\n }\n }\n // Capture the stack at the time the span started\n span._startStack = new Error().stack;\n return span;\n };\n MockTracer.prototype._inject = function (span, format, carrier) {\n throw new Error('NOT YET IMPLEMENTED');\n };\n MockTracer.prototype._extract = function (format, carrier) {\n throw new Error('NOT YET IMPLEMENTED');\n };\n MockTracer.prototype._allocSpan = function () {\n return new mock_span_1.default(this);\n };\n /**\n * Discard any buffered data.\n */\n MockTracer.prototype.clear = function () {\n this._spans = [];\n };\n /**\n * Return the buffered data in a format convenient for making unit test\n * assertions.\n */\n MockTracer.prototype.report = function () {\n return new mock_report_1.default(this._spans);\n };\n return MockTracer;\n}(opentracing.Tracer));\nexports.MockTracer = MockTracer;\nexports.default = MockTracer;\n//# sourceMappingURL=mock_tracer.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Index a collection of reported MockSpans in a way that's easy to run unit\n * test assertions against.\n */\nvar MockReport = /** @class */ (function () {\n function MockReport(spans) {\n var _this = this;\n this.spans = spans;\n this.spansByUUID = {};\n this.spansByTag = {};\n this.debugSpans = [];\n this.unfinishedSpans = [];\n spans.forEach(function (span) {\n if (span._finishMs === 0) {\n _this.unfinishedSpans.push(span);\n }\n _this.spansByUUID[span.uuid()] = span;\n _this.debugSpans.push(span.debug());\n var tags = span.tags();\n Object.keys(tags).forEach(function (key) {\n var val = tags[key];\n _this.spansByTag[key] = _this.spansByTag[key] || {};\n _this.spansByTag[key][val] = _this.spansByTag[key][val] || [];\n _this.spansByTag[key][val].push(span);\n });\n });\n }\n MockReport.prototype.firstSpanWithTagValue = function (key, val) {\n var m = this.spansByTag[key];\n if (!m) {\n return null;\n }\n var n = m[val];\n if (!n) {\n return null;\n }\n return n[0];\n };\n return MockReport;\n}());\nexports.MockReport = MockReport;\nexports.default = MockReport;\n//# sourceMappingURL=mock_report.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tracer_1 = require(\"./tracer\");\nvar noopTracer = new tracer_1.default();\nvar _globalTracer = null;\n// Allows direct importing/requiring of the global tracer:\n//\n// let globalTracer = require('opentracing/global');\n// OR\n// import globalTracer from 'opentracing/global';\n//\n// Acts a bridge to the global tracer that can be safely called before the\n// global tracer is initialized. The purpose of the delegation is to avoid the\n// sometimes nearly intractible initialization order problems that can arise in\n// applications with a complex set of dependencies, while also avoiding the\n// case where\nvar GlobalTracerDelegate = /** @class */ (function (_super) {\n __extends(GlobalTracerDelegate, _super);\n function GlobalTracerDelegate() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n GlobalTracerDelegate.prototype.startSpan = function () {\n var tracer = _globalTracer || noopTracer;\n return tracer.startSpan.apply(tracer, arguments);\n };\n GlobalTracerDelegate.prototype.inject = function () {\n var tracer = _globalTracer || noopTracer;\n return tracer.inject.apply(tracer, arguments);\n };\n GlobalTracerDelegate.prototype.extract = function () {\n var tracer = _globalTracer || noopTracer;\n return tracer.extract.apply(tracer, arguments);\n };\n return GlobalTracerDelegate;\n}(tracer_1.default));\nvar globalTracerDelegate = new GlobalTracerDelegate();\n/**\n * Set the global Tracer.\n *\n * The behavior is undefined if this function is called more than once.\n *\n * @param {Tracer} tracer - the Tracer implementation\n */\nfunction initGlobalTracer(tracer) {\n _globalTracer = tracer;\n}\nexports.initGlobalTracer = initGlobalTracer;\n/**\n * Returns the global tracer.\n */\nfunction globalTracer() {\n // Return the delegate. Since the global tracer is largely a convenience\n // (the user can always create their own tracers), the delegate is used to\n // give the added convenience of not needing to worry about initialization\n // order.\n return globalTracerDelegate;\n}\nexports.globalTracer = globalTracer;\n//# sourceMappingURL=global_tracer.js.map","'use strict'\n\nconst tx = {\n // Set the outgoing host.\n setHost (span, hostname, port) {\n hostname && span.setTag('out.host', hostname)\n port && span.setTag('out.port', port)\n },\n\n // Wrap a promise or a callback to also finish the span.\n wrap (span, done) {\n if (typeof done === 'function' || !done) {\n return wrapCallback(span, done)\n } else if (isPromise(done)) {\n return wrapPromise(span, done)\n }\n }\n}\n\nfunction wrapCallback (span, callback) {\n const scope = span.tracer().scope()\n const previous = scope.active()\n\n return function (err) {\n finish(span, err)\n\n if (callback) {\n return scope.activate(previous, () => callback.apply(this, arguments))\n }\n }\n}\n\nfunction wrapPromise (span, promise) {\n promise.then(\n () => finish(span),\n err => finish(span, err)\n )\n\n return promise\n}\n\nfunction finish (span, error) {\n if (error) {\n span.addTags({\n 'error.type': error.name,\n 'error.msg': error.message,\n 'error.stack': error.stack\n })\n }\n\n span.finish()\n}\n\nfunction isPromise (obj) {\n return isObject(obj) && typeof obj.then === 'function'\n}\n\nfunction isObject (obj) {\n return typeof obj === 'object' && obj !== null\n}\n\nmodule.exports = tx\n","'use strict'\n\nconst URL = require('url-parse')\nconst { Reference, REFERENCE_CHILD_OF } = require('opentracing')\nconst { REFERENCE_NOOP } = require('../../dd-trace/src/constants')\nconst tx = require('../../dd-trace/src/plugins/util/http')\n\nfunction createWrapOpen (tracer) {\n return function wrapOpen (open) {\n return function openWithTrace (method, url) {\n this._datadog_method = method\n this._datadog_url = new URL(url, window.location.origin)\n\n return open.apply(this, arguments)\n }\n }\n}\n\nfunction createWrapSend (tracer, config) {\n return function wrapSend (send) {\n return function sendWithTrace (body) {\n const service = config.service || `${tracer._service}-http-client`\n const method = this._datadog_method\n const url = this._datadog_url\n const scope = tracer.scope()\n const childOf = scope.active()\n const type = isFlush(tracer._url.href, url) ? REFERENCE_NOOP : REFERENCE_CHILD_OF\n const span = tracer.startSpan('browser.request', {\n references: [\n new Reference(type, childOf)\n ],\n tags: {\n 'span.kind': 'client',\n 'service.name': service,\n 'resource.name': method,\n 'span.type': 'http',\n 'http.method': method,\n 'http.url': url.href\n }\n })\n\n // HACK: move to backend\n span.setTag('_top_level', 1)\n\n if (type === REFERENCE_CHILD_OF) {\n inject(this, tracer, span)\n }\n\n this.addEventListener('error', e => span.setTag('error', e))\n this.addEventListener('load', () => span.setTag('http.status', this.status))\n this.addEventListener('loadend', () => span.finish())\n\n try {\n return tracer.scope().bind(send, span).apply(this, arguments)\n } catch (e) {\n span.setTag('error', e)\n span.finish()\n\n throw e\n }\n }\n }\n}\n\nfunction inject (xhr, tracer, span) {\n const format = window.ddtrace.ext.formats.HTTP_HEADERS\n const headers = {}\n const origin = xhr._datadog_url.origin\n const peers = tracer._peers\n\n if (origin !== window.location.origin && !tx.isPeer(origin, peers)) return\n\n tracer.inject(span, format, headers)\n\n for (const name in headers) {\n xhr.setRequestHeader(name, headers[name])\n }\n}\n\n// TODO: support staging and other environments\nfunction isFlush (href, url) {\n return (new RegExp(`^${href}/v1/input/[a-z0-9]+$`, 'i')).test(url.href) ||\n url.href.startsWith('https://rum-http-intake.logs.datadoghq.com') ||\n url.href.startsWith('https://browser-http-intake.logs.datadoghq.com')\n}\n\nmodule.exports = {\n name: 'XMLHttpRequest',\n patch (XMLHttpRequest, tracer, config) {\n this.wrap(XMLHttpRequest.prototype, 'open', createWrapOpen(tracer, config))\n this.wrap(XMLHttpRequest.prototype, 'send', createWrapSend(tracer, config))\n },\n\n unpatch (XMLHttpRequest) {\n this.unwrap(XMLHttpRequest.prototype, 'open')\n this.unwrap(XMLHttpRequest.prototype, 'send')\n }\n}\n","'use strict'\n\nmodule.exports = {\n startupLog: () => {},\n setStartupLogConfig: () => {},\n setStartupLogInstrumenter: () => {},\n setSamplingRules: () => {}\n}\n","'use strict'\n\nconst BrowserExporter = require('../../exporters/browser')\n\nmodule.exports = () => BrowserExporter\n","'use strict'\n\nconst URL = require('url-parse')\n\nconst MAX_SIZE = 64 * 1024 // 64kb\nconst DELIMITER = '\\r\\n'\n\n// TODO: rename and refactor to support Node\n// TODO: flush more often\n\nclass BrowserExporter {\n constructor ({ clientToken, url, site, env }) {\n this._queue = []\n this._flushing = false\n this._clientToken = clientToken\n this._env = env\n this._url = url || new URL(`https://public-trace-http-intake.logs.${site}`)\n this._size = 0\n\n window.addEventListener('beforeunload', () => this._flush())\n window.addEventListener('visibilitychange', () => this._flush())\n }\n\n export (spans) {\n const meta = this._traceMeta()\n const json = JSON.stringify({ spans, meta })\n const size = json.length + (this._queue.length > 0 ? DELIMITER.length : 0)\n\n if (this._size + size > MAX_SIZE) {\n if (this._flushing) return // drop trace to avoid multiple connections\n if (size > MAX_SIZE) return // drop trace because too large\n\n this._flush()\n }\n\n this._size += size\n this._queue.push(json)\n }\n\n setUrl (url) {\n this._url = url\n }\n\n _flush () {\n if (this._queue.length === 0) return\n\n this._flushing = true\n\n const url = `${this._url.href}/v1/input/${this._clientToken}`\n const body = this._queue.join(DELIMITER)\n\n this._queue = []\n this._size = 0\n\n send(url, body, () => {\n this._flushing = false\n })\n }\n\n _traceMeta () {\n const meta = {\n '_dd.source': 'browser'\n }\n\n addTag(meta, 'env', this._env)\n\n return meta\n }\n}\n\nfunction send (url, body, callback) {\n if (window.navigator && window.navigator.sendBeacon) {\n window.navigator.sendBeacon(url, body)\n } else if (window.fetch) {\n window.fetch(url, { body, method: 'POST', keepalive: true, mode: 'no-cors' })\n .then(callback, callback)\n } else {\n const req = new XMLHttpRequest()\n\n req.open('POST', url, true)\n req.addEventListener('loadend', callback)\n req.send(body)\n }\n}\n\nfunction addTag (meta, key, value) {\n if (!value) return\n\n meta[key] = value\n}\n\nmodule.exports = BrowserExporter\n","'use strict'\n\nclass Loader {\n constructor (instrumenter) {\n this._instrumenter = instrumenter\n }\n\n reload (plugins) {\n plugins.forEach((meta, plugin) => {\n this._instrumenter.unload(plugin)\n this._instrumenter.load(plugin, meta)\n })\n }\n\n load (instrumentation, config) {\n const nodule = window[instrumentation.name]\n const override = this._instrumenter.patch(instrumentation, nodule, config)\n\n window[instrumentation.name] = override || nodule\n }\n}\n\nmodule.exports = Loader\n","'use strict'\n\n// TODO: Zone metrics\n\nconst Base = require('./base')\nconst Zone = window.Zone\n\nlet singleton = null\n\nclass Scope extends Base {\n constructor () {\n if (singleton) return singleton\n\n super()\n\n singleton = this\n }\n\n _active () {\n if (!Zone) return null\n\n return Zone.current.get('_datadog_span')\n }\n\n _activate (span, callback) {\n if (!Zone) return callback()\n\n const spec = {\n properties: {\n _datadog_span: span\n }\n }\n\n return Zone.current.fork(spec).run(() => callback())\n }\n}\n\nmodule.exports = Scope\n","'use strict'\n\nmodule.exports = {\n SERVER: 'server',\n CLIENT: 'client',\n PRODUCER: 'producer',\n CONSUMER: 'consumer'\n}\n","'use strict'\n\nmodule.exports = {\n HTTP: 'http',\n WEB: 'web'\n}\n","'use strict'\nmodule.exports = {\n LOG: 'log',\n BROWSER: 'browser',\n AGENT: 'agent'\n}\n","'use strict'\n\nconst BaseTracer = require('opentracing').Tracer\nconst NoopTracer = require('./noop/tracer')\nconst DatadogTracer = require('./tracer')\nconst Config = require('./config')\nconst Instrumenter = require('./instrumenter')\nconst platform = require('./platform')\nconst log = require('./log')\nconst { setStartupLogInstrumenter } = platform.startupLog\nconst analyticsSampler = require('./analytics_sampler')\n\nconst noop = new NoopTracer()\n\nclass Tracer extends BaseTracer {\n constructor () {\n super()\n this._tracer = noop\n this._instrumenter = new Instrumenter(this)\n this._deprecate = method => log.deprecate(`tracer.${method}`, [\n `tracer.${method}() is deprecated.`,\n 'Please use tracer.startSpan() and tracer.scope() instead.',\n 'See: https://datadog.github.io/dd-trace-js/#manual-instrumentation.'\n ].join(' '))\n }\n\n init (options) {\n if (this._tracer === noop) {\n try {\n const config = new Config(options)\n\n log.use(config.logger)\n log.toggle(config.debug, config.logLevel, this)\n\n platform.configure(config)\n platform.profiler().start()\n\n if (config.enabled) {\n platform.validate()\n\n if (config.runtimeMetrics) {\n platform.metrics().start()\n }\n\n if (config.analytics) {\n analyticsSampler.enable()\n }\n\n this._tracer = new DatadogTracer(config)\n this._instrumenter.enable(config)\n setStartupLogInstrumenter(this._instrumenter)\n }\n } catch (e) {\n log.error(e)\n }\n }\n\n return this\n }\n\n use () {\n this._instrumenter.use.apply(this._instrumenter, arguments)\n return this\n }\n\n trace (name, options, fn) {\n if (!fn) {\n fn = options\n options = {}\n }\n\n if (typeof fn !== 'function') return\n\n options = options || {}\n\n return this._tracer.trace(name, options, fn)\n }\n\n wrap (name, options, fn) {\n if (!fn) {\n fn = options\n options = {}\n }\n\n if (typeof fn !== 'function') return fn\n\n options = options || {}\n\n return this._tracer.wrap(name, options, fn)\n }\n\n setUrl () {\n this._tracer.setUrl.apply(this._tracer, arguments)\n return this\n }\n\n startSpan () {\n return this._tracer.startSpan.apply(this._tracer, arguments)\n }\n\n inject () {\n return this._tracer.inject.apply(this._tracer, arguments)\n }\n\n extract () {\n return this._tracer.extract.apply(this._tracer, arguments)\n }\n\n scopeManager () {\n this._deprecate('scopeManager')\n return this._tracer.scopeManager.apply(this._tracer, arguments)\n }\n\n scope () {\n return this._tracer.scope.apply(this._tracer, arguments)\n }\n\n currentSpan () {\n this._deprecate('currentSpan')\n return this._tracer.currentSpan.apply(this._tracer, arguments)\n }\n\n bind (callback) {\n this._deprecate('bind')\n return callback\n }\n\n bindEmitter () {\n this._deprecate('bindEmitter')\n }\n\n getRumData () {\n return this._tracer.getRumData.apply(this._tracer, arguments)\n }\n}\n\nmodule.exports = Tracer\n","'use strict'\n\nconst Tracer = require('opentracing').Tracer\nconst Scope = require('../scope/base')\nconst Span = require('./span')\nconst platform = require('../platform')\n\nclass NoopTracer extends Tracer {\n constructor (config) {\n super(config)\n\n let ScopeManager\n\n if (platform.env('DD_CONTEXT_PROPAGATION') === 'false') {\n ScopeManager = require('../scope/noop/scope_manager')\n } else {\n ScopeManager = require('../scope/scope_manager')\n }\n\n this._scopeManager = new ScopeManager()\n this._scope = new Scope(config)\n this._span = new Span(this)\n }\n\n trace (name, options, fn) {\n return fn(this._span, () => {})\n }\n\n wrap (name, options, fn) {\n return fn\n }\n\n scopeManager () {\n return this._scopeManager\n }\n\n scope () {\n return this._scope\n }\n\n currentSpan () {\n return null\n }\n\n getRumData () {\n return ''\n }\n\n setUrl () {\n }\n\n _startSpan (name, options) {\n return this._span\n }\n}\n\nmodule.exports = NoopTracer\n","'use strict'\n\nclass Scope {\n constructor (span, finishSpanOnClose) {\n this._span = span\n this._finishSpanOnClose = finishSpanOnClose\n this.close()\n }\n\n span () {\n return this._span\n }\n\n close () {\n if (this._finishSpanOnClose) {\n this._span.finish()\n }\n }\n}\n\nmodule.exports = Scope\n","'use strict'\n\nconst Tracer = require('./opentracing/tracer')\nconst tags = require('../../../ext/tags')\nconst scopes = require('../../../ext/scopes')\nconst platform = require('./platform')\nconst { setStartupLogConfig } = platform.startupLog\n\nconst SPAN_TYPE = tags.SPAN_TYPE\nconst RESOURCE_NAME = tags.RESOURCE_NAME\nconst SERVICE_NAME = tags.SERVICE_NAME\nconst ANALYTICS = tags.ANALYTICS\nconst NOOP = scopes.NOOP\n\nclass DatadogTracer extends Tracer {\n constructor (config) {\n super(config)\n\n this._scopeManager = getScopeManager(config)\n this._scope = getScope(config)\n setStartupLogConfig(config)\n }\n\n trace (name, options, fn) {\n options = Object.assign({}, {\n childOf: this.scope().active()\n }, options)\n\n if (!options.childOf && options.orphanable === false) {\n return fn(null, () => {})\n }\n\n const span = this.startSpan(name, options)\n\n addTags(span, options)\n\n try {\n if (fn.length > 1) {\n return this.scope().activate(span, () => fn(span, err => {\n addError(span, err)\n span.finish()\n }))\n }\n\n const result = this.scope().activate(span, () => fn(span))\n\n if (result && typeof result.then === 'function') {\n result.then(\n () => span.finish(),\n err => {\n addError(span, err)\n span.finish()\n }\n )\n } else {\n span.finish()\n }\n\n return result\n } catch (e) {\n addError(span, e)\n span.finish()\n throw e\n }\n }\n\n wrap (name, options, fn) {\n const tracer = this\n\n return function () {\n let optionsObj = options\n if (typeof optionsObj === 'function' && typeof fn === 'function') {\n optionsObj = optionsObj.apply(this, arguments)\n }\n\n if (optionsObj.orphanable === false && !tracer.scope().active()) {\n return fn.apply(this, arguments)\n }\n\n const lastArgId = arguments.length - 1\n const cb = arguments[lastArgId]\n\n if (typeof cb === 'function') {\n const scopeBoundCb = tracer.scope().bind(cb)\n return tracer.trace(name, optionsObj, (span, done) => {\n arguments[lastArgId] = function (err) {\n done(err)\n return scopeBoundCb.apply(this, arguments)\n }\n\n return fn.apply(this, arguments)\n })\n } else {\n return tracer.trace(name, optionsObj, () => fn.apply(this, arguments))\n }\n }\n }\n\n setUrl (url) {\n this._exporter.setUrl(url)\n }\n\n scopeManager () {\n return this._scopeManager\n }\n\n scope () {\n return this._scope\n }\n\n currentSpan () {\n return this.scope().active()\n }\n\n getRumData () {\n if (!this._enableGetRumData) {\n return ''\n }\n const span = this.scope().active().context()\n const traceId = span.toTraceId()\n const traceTime = Date.now()\n return `\\\n<meta name=\"dd-trace-id\" content=\"${traceId}\" />\\\n<meta name=\"dd-trace-time\" content=\"${traceTime}\" />`\n }\n}\n\nfunction addError (span, error) {\n if (error && error instanceof Error) {\n span.addTags({\n 'error.type': error.name,\n 'error.msg': error.message,\n 'error.stack': error.stack\n })\n }\n}\n\nfunction addTags (span, options) {\n const tags = {}\n\n if (options.type) tags[SPAN_TYPE] = options.type\n if (options.service) tags[SERVICE_NAME] = options.service\n if (options.resource) tags[RESOURCE_NAME] = options.resource\n\n tags[ANALYTICS] = options.analytics\n\n span.addTags(tags)\n}\n\nfunction getScopeManager (config) {\n let ScopeManager\n\n if (config.scope === NOOP) {\n ScopeManager = require('./scope/noop/scope_manager')\n } else {\n ScopeManager = require('./scope/scope_manager')\n }\n\n return new ScopeManager()\n}\n\nfunction getScope (config) {\n let Scope\n\n if (config.scope === NOOP) {\n Scope = require('./scope/base')\n } else {\n Scope = platform.getScope(config.scope)\n }\n\n return new Scope(config)\n}\n\nmodule.exports = DatadogTracer\n","'use strict'\n\nconst opentracing = require('opentracing')\nconst Tracer = opentracing.Tracer\nconst Reference = opentracing.Reference\nconst Span = require('./span')\nconst SpanContext = require('./span_context')\nconst SpanProcessor = require('../span_processor')\nconst Sampler = require('../sampler')\nconst PrioritySampler = require('../priority_sampler')\nconst TextMapPropagator = require('./propagation/text_map')\nconst HttpPropagator = require('./propagation/http')\nconst BinaryPropagator = require('./propagation/binary')\nconst LogPropagator = require('./propagation/log')\nconst NoopSpan = require('../noop/span')\nconst formats = require('../../../../ext/formats')\n\nconst log = require('../log')\nconst constants = require('../constants')\nconst platform = require('../platform')\n\nconst REFERENCE_NOOP = constants.REFERENCE_NOOP\nconst REFERENCE_CHILD_OF = opentracing.REFERENCE_CHILD_OF\nconst REFERENCE_FOLLOWS_FROM = opentracing.REFERENCE_FOLLOWS_FROM\n\nclass DatadogTracer extends Tracer {\n constructor (config) {\n super()\n\n const Exporter = platform.exporter(config.experimental.exporter)\n\n this._service = config.service\n this._version = config.version\n this._env = config.env\n this._tags = config.tags\n this._logInjection = config.logInjection\n this._analytics = config.analytics\n this._debug = config.debug\n this._internalErrors = config.experimental.internalErrors\n this._prioritySampler = new PrioritySampler(config.env, config.experimental.sampler)\n this._exporter = new Exporter(config, this._prioritySampler)\n this._processor = new SpanProcessor(this._exporter, this._prioritySampler)\n this._url = this._exporter._url\n this._sampler = new Sampler(config.sampleRate)\n this._peers = config.experimental.peers\n this._enableGetRumData = config.experimental.enableGetRumData\n this._propagators = {\n [formats.TEXT_MAP]: new TextMapPropagator(config),\n [formats.HTTP_HEADERS]: new HttpPropagator(config),\n [formats.BINARY]: new BinaryPropagator(config),\n [formats.LOG]: new LogPropagator(config)\n }\n if (config.reportHostname) {\n this._hostname = platform.hostname()\n }\n }\n\n startSpan (name, fields) {\n if (fields) {\n if (fields.references) {\n return super.startSpan(name, fields)\n } else if (fields.childOf) {\n let parent = fields.childOf\n if (parent instanceof Span) {\n parent = parent.context()\n }\n if (parent instanceof SpanContext) {\n return this._startSpanInternal(name, fields, parent, REFERENCE_CHILD_OF)\n }\n }\n }\n return this._startSpanInternal(name, fields, null, null)\n }\n\n _startSpan (name, fields) {\n const reference = getParent(fields.references)\n const type = reference && reference.type()\n const parent = reference && reference.referencedContext()\n return this._startSpanInternal(name, fields, parent, type)\n }\n\n _startSpanInternal (name, fields = {}, parent, type) {\n if (parent && parent._noop) return parent._noop\n if (!isSampled(this._sampler, parent, type)) return new NoopSpan(this, parent)\n\n const tags = {\n 'service.name': this._service\n }\n\n const span = new Span(this, this._processor, this._sampler, this._prioritySampler, {\n operationName: fields.operationName || name,\n parent,\n tags,\n startTime: fields.startTime,\n hostname: this._hostname\n }, this._debug)\n\n span.addTags(this._tags)\n span.addTags(fields.tags)\n span.addTags(platform.tags())\n\n return span\n }\n\n _inject (spanContext, format, carrier) {\n try {\n this._prioritySampler.sample(spanContext)\n this._propagators[format].inject(spanContext, carrier)\n } catch (e) {\n log.error(e)\n platform.metrics().increment('datadog.tracer.node.inject.errors', true)\n }\n\n return this\n }\n\n _extract (format, carrier) {\n try {\n return this._propagators[format].extract(carrier)\n } catch (e) {\n log.error(e)\n platform.metrics().increment('datadog.tracer.node.extract.errors', true)\n return null\n }\n }\n}\n\nfunction getParent (references = []) {\n let parent = null\n\n for (let i = 0; i < references.length; i++) {\n const ref = references[i]\n\n if (!(ref instanceof Reference)) {\n log.error(() => `Expected ${ref} to be an instance of opentracing.Reference`)\n continue\n }\n\n const spanContext = ref.referencedContext()\n const type = ref.type()\n\n if (type !== REFERENCE_NOOP && spanContext && !(spanContext instanceof SpanContext)) {\n log.error(() => `Expected ${spanContext} to be an instance of SpanContext`)\n continue\n }\n\n if (type === REFERENCE_CHILD_OF || type === REFERENCE_NOOP) {\n parent = ref\n break\n } else if (type === REFERENCE_FOLLOWS_FROM) {\n if (!parent) {\n parent = ref\n }\n }\n }\n\n return parent\n}\n\nfunction isSampled (sampler, parent, type) {\n if (type === REFERENCE_NOOP) return false\n if (parent && !parent._traceFlags.sampled) return false\n if (!parent && !sampler.isSampled()) return false\n\n return true\n}\n\nmodule.exports = DatadogTracer\n","'use strict'\n\nconst opentracing = require('opentracing')\nconst Span = opentracing.Span\nconst SpanContext = require('./span_context')\nconst platform = require('../platform')\nconst constants = require('../constants')\nconst id = require('../id')\nconst tagger = require('../tagger')\n\nconst SAMPLE_RATE_METRIC_KEY = constants.SAMPLE_RATE_METRIC_KEY\n\nclass DatadogSpan extends Span {\n constructor (tracer, processor, sampler, prioritySampler, fields, debug) {\n super()\n\n const operationName = fields.operationName\n const parent = fields.parent || null\n const tags = Object.assign({\n [SAMPLE_RATE_METRIC_KEY]: sampler.rate()\n }, fields.tags)\n const hostname = fields.hostname\n\n this._parentTracer = tracer\n this._debug = debug\n this._sampler = sampler\n this._processor = processor\n this._prioritySampler = prioritySampler\n\n this._spanContext = this._createContext(parent)\n this._spanContext._name = operationName\n this._spanContext._tags = tags\n this._spanContext._hostname = hostname\n\n this._startTime = fields.startTime || this._getTime()\n\n if (debug) {\n this._handle = platform.metrics().track(this)\n }\n }\n\n toString () {\n const spanContext = this.context()\n const resourceName = spanContext._tags['resource.name']\n const resource = resourceName.length > 100\n ? `${resourceName.substring(0, 97)}...`\n : resourceName\n const json = JSON.stringify({\n traceId: spanContext._traceId,\n spanId: spanContext._spanId,\n parentId: spanContext._parentId,\n service: spanContext._tags['service.name'],\n name: spanContext._name,\n resource\n })\n\n return `Span${json}`\n }\n\n _createContext (parent) {\n let spanContext\n\n if (parent) {\n spanContext = new SpanContext({\n traceId: parent._traceId,\n spanId: id(),\n parentId: parent._spanId,\n sampling: parent._sampling,\n baggageItems: Object.assign({}, parent._baggageItems),\n trace: parent._trace\n })\n } else {\n const spanId = id()\n spanContext = new SpanContext({\n traceId: spanId,\n spanId\n })\n }\n\n spanContext._trace.started.push(this)\n spanContext._trace.startTime = spanContext._trace.startTime || Date.now()\n spanContext._trace.ticks = spanContext._trace.ticks || platform.now()\n\n return spanContext\n }\n\n _getTime () {\n const { startTime, ticks } = this._spanContext._trace\n\n return startTime + platform.now() - ticks\n }\n\n _context () {\n return this._spanContext\n }\n\n _tracer () {\n return this._parentTracer\n }\n\n _setOperationName (name) {\n this._spanContext._name = name\n }\n\n _setBaggageItem (key, value) {\n this._spanContext._baggageItems[key] = value\n }\n\n _getBaggageItem (key) {\n return this._spanContext._baggageItems[key]\n }\n\n _addTags (keyValuePairs) {\n tagger.add(this._spanContext._tags, keyValuePairs)\n }\n\n _finish (finishTime) {\n if (this._duration !== undefined) {\n return\n }\n\n finishTime = parseFloat(finishTime) || this._getTime()\n\n this._duration = finishTime - this._startTime\n this._spanContext._trace.finished.push(this)\n this._spanContext._isFinished = true\n\n if (this._debug) {\n this._handle.finish()\n }\n\n this._processor.process(this)\n }\n}\n\nmodule.exports = DatadogSpan\n","const log = require('./log')\nconst format = require('./format')\n\nclass SpanProcessor {\n constructor (exporter, prioritySampler) {\n this._exporter = exporter\n this._prioritySampler = prioritySampler\n }\n\n process (span) {\n const spanContext = span.context()\n const trace = spanContext._trace\n\n if (trace.started.length === trace.finished.length) {\n this._prioritySampler.sample(spanContext)\n\n if (spanContext._traceFlags.sampled === false) {\n log.debug(() => `Dropping trace due to user configured filtering: ${trace.started}`)\n this._erase(trace)\n return\n }\n\n const formattedSpans = trace.finished.map(format)\n this._exporter.export(formattedSpans)\n this._erase(trace)\n }\n }\n\n _erase (trace) {\n trace.finished.forEach(span => {\n span.context()._tags = {}\n })\n\n trace.started = []\n trace.finished = []\n }\n}\n\nmodule.exports = SpanProcessor\n","'use strict'\n\nconst constants = require('./constants')\nconst tags = require('../../../ext/tags')\nconst log = require('./log')\nconst id = require('./id')\n\nconst SAMPLING_PRIORITY_KEY = constants.SAMPLING_PRIORITY_KEY\nconst ANALYTICS_KEY = constants.ANALYTICS_KEY\nconst ANALYTICS = tags.ANALYTICS\nconst MEASURED = tags.MEASURED\nconst ORIGIN_KEY = constants.ORIGIN_KEY\nconst HOSTNAME_KEY = constants.HOSTNAME_KEY\n\nconst map = {\n 'service.name': 'service',\n 'span.type': 'type',\n 'resource.name': 'resource'\n}\n\nfunction format (span) {\n const formatted = formatSpan(span)\n\n extractError(formatted, span)\n extractTags(formatted, span)\n extractAnalytics(formatted, span)\n\n return formatted\n}\n\nfunction formatSpan (span) {\n const spanContext = span.context()\n\n return {\n trace_id: spanContext._traceId,\n span_id: spanContext._spanId,\n parent_id: spanContext._parentId || id('0'),\n name: serialize(spanContext._name),\n resource: serialize(spanContext._name),\n error: 0,\n meta: {},\n metrics: {},\n start: Math.round(span._startTime * 1e6),\n duration: Math.round(span._duration * 1e6)\n }\n}\n\nfunction extractTags (trace, span) {\n const context = span.context()\n const origin = context._trace.origin\n const tags = context._tags\n const hostname = context._hostname\n const priority = context._sampling.priority\n const internalErrors = span.tracer()._internalErrors\n\n for (const tag in tags) {\n switch (tag) {\n case 'service.name':\n case 'span.type':\n case 'resource.name':\n addTag(trace, {}, map[tag], tags[tag])\n break\n // HACK: remove when Datadog supports numeric status code\n case 'http.status_code':\n addTag(trace.meta, {}, tag, tags[tag] && String(tags[tag]))\n break\n case HOSTNAME_KEY:\n case ANALYTICS:\n break\n case MEASURED:\n addTag({}, trace.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)\n break\n case 'error':\n if (tags[tag] && (tags['span.kind'] !== 'internal' || internalErrors)) {\n trace.error = 1\n }\n break\n case 'error.type':\n case 'error.msg':\n case 'error.stack':\n // HACK: remove when implemented in the backend\n if (tags['span.kind'] !== 'internal' || internalErrors) {\n trace.error = 1\n }\n default: // eslint-disable-line no-fallthrough\n addTag(trace.meta, trace.metrics, tag, tags[tag])\n }\n }\n\n if (span.tracer()._service === tags['service.name']) {\n addTag(trace.meta, trace.metrics, 'language', 'javascript')\n }\n\n addTag(trace.meta, trace.metrics, SAMPLING_PRIORITY_KEY, priority)\n addTag(trace.meta, trace.metrics, ORIGIN_KEY, origin)\n addTag(trace.meta, trace.metrics, HOSTNAME_KEY, hostname)\n}\n\nfunction extractError (trace, span) {\n const error = span.context()._tags['error']\n\n if (error instanceof Error) {\n addTag(trace.meta, trace.metrics, 'error.msg', error.message)\n addTag(trace.meta, trace.metrics, 'error.type', error.name)\n addTag(trace.meta, trace.metrics, 'error.stack', error.stack)\n }\n}\n\nfunction extractAnalytics (trace, span) {\n let analytics = span.context()._tags[ANALYTICS]\n\n if (analytics === true) {\n analytics = 1\n } else {\n analytics = parseFloat(analytics)\n }\n\n if (!isNaN(analytics)) {\n trace.metrics[ANALYTICS_KEY] = Math.max(Math.min(analytics, 1), 0)\n }\n}\n\nfunction addTag (meta, metrics, key, value, seen) {\n switch (typeof value) {\n case 'string':\n meta[key] = value\n break\n case 'number':\n if (isNaN(value)) break\n metrics[key] = value\n break\n case 'undefined':\n break\n case 'object':\n if (value === null) break\n\n // Special case for Node.js Buffer and URL\n if (isNodeBuffer(value) || isUrl(value)) {\n metrics[key] = value.toString()\n break\n }\n\n if (!Array.isArray(value)) {\n addObjectTag(meta, metrics, key, value, seen)\n break\n }\n\n default: // eslint-disable-line no-fallthrough\n addTag(meta, metrics, key, serialize(value))\n }\n}\n\nfunction addObjectTag (meta, metrics, key, value, seen) {\n seen = seen || []\n\n if (~seen.indexOf(value)) {\n meta[key] = '[Circular]'\n return\n }\n\n seen.push(value)\n\n for (const prop in value) {\n addTag(meta, metrics, `${key}.${prop}`, value[prop], seen)\n }\n\n seen.pop()\n}\n\nfunction serialize (obj) {\n try {\n return obj && typeof obj.toString !== 'function' ? JSON.stringify(obj) : String(obj)\n } catch (e) {\n log.error(e)\n }\n}\n\nfunction isNodeBuffer (obj) {\n return obj.constructor && obj.constructor.name === 'Buffer' &&\n typeof obj.readInt8 === 'function' &&\n typeof obj.toString === 'function'\n}\n\nfunction isUrl (obj) {\n return obj.constructor && obj.constructor.name === 'URL' &&\n typeof obj.href === 'string' &&\n typeof obj.toString === 'function'\n}\n\nmodule.exports = format\n","'use strict'\n\nconst RateLimiter = require('./rate_limiter')\nconst Sampler = require('./sampler')\nconst ext = require('../../../ext')\nconst { setSamplingRules } = require('./platform').startupLog\n\nconst {\n SAMPLING_RULE_DECISION,\n SAMPLING_LIMIT_DECISION,\n SAMPLING_AGENT_DECISION\n} = require('./constants')\n\nconst SERVICE_NAME = ext.tags.SERVICE_NAME\nconst SAMPLING_PRIORITY = ext.tags.SAMPLING_PRIORITY\nconst MANUAL_KEEP = ext.tags.MANUAL_KEEP\nconst MANUAL_DROP = ext.tags.MANUAL_DROP\nconst USER_REJECT = ext.priority.USER_REJECT\nconst AUTO_REJECT = ext.priority.AUTO_REJECT\nconst AUTO_KEEP = ext.priority.AUTO_KEEP\nconst USER_KEEP = ext.priority.USER_KEEP\nconst DEFAULT_KEY = 'service:,env:'\n\nclass PrioritySampler {\n constructor (env, { sampleRate, rateLimit = 100, rules = [] } = {}) {\n this._env = env\n this._rules = this._normalizeRules(rules, sampleRate)\n this._limiter = new RateLimiter(rateLimit)\n\n setSamplingRules(this._rules)\n\n this.update({})\n }\n\n isSampled (span) {\n const context = this._getContext(span)\n const rule = this._findRule(context)\n\n return rule\n ? this._isSampledByRule(context, rule) && this._isSampledByRateLimit(context)\n : this._isSampledByAgent(context)\n }\n\n sample (span) {\n if (!span) return\n\n const context = this._getContext(span)\n\n if (context._sampling.priority !== undefined) return\n\n const tag = this._getPriority(context._tags)\n\n if (this.validate(tag)) {\n context._sampling.priority = tag\n return\n }\n\n context._sampling.priority = this.isSampled(span) ? AUTO_KEEP : AUTO_REJECT\n }\n\n update (rates) {\n const samplers = {}\n\n for (const key in rates) {\n const rate = rates[key]\n const sampler = new Sampler(rate)\n\n samplers[key] = sampler\n }\n\n samplers[DEFAULT_KEY] = samplers[DEFAULT_KEY] || new Sampler(AUTO_KEEP)\n\n this._samplers = samplers\n }\n\n validate (samplingPriority) {\n switch (samplingPriority) {\n case USER_REJECT:\n case USER_KEEP:\n case AUTO_REJECT:\n case AUTO_KEEP:\n return true\n default:\n return false\n }\n }\n\n _getContext (span) {\n return typeof span.context === 'function' ? span.context() : span\n }\n\n _getPriority (tags) {\n if (tags.hasOwnProperty(MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {\n return USER_KEEP\n } else if (tags.hasOwnProperty(MANUAL_DROP) && tags[MANUAL_DROP] !== false) {\n return USER_REJECT\n } else {\n const priority = parseInt(tags[SAMPLING_PRIORITY], 10)\n\n if (priority === 1 || priority === 2) {\n return USER_KEEP\n } else if (priority === 0 || priority === -1) {\n return USER_REJECT\n }\n }\n }\n\n _isSampledByRule (context, rule) {\n context._tags[SAMPLING_RULE_DECISION] = rule.sampleRate\n\n return rule.sampler.isSampled(context)\n }\n\n _isSampledByRateLimit (context) {\n const allowed = this._limiter.isAllowed()\n\n context._tags[SAMPLING_LIMIT_DECISION] = this._limiter.effectiveRate()\n\n return allowed\n }\n\n _isSampledByAgent (context) {\n const key = `service:${context._tags[SERVICE_NAME]},env:${this._env}`\n const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]\n\n context._tags[SAMPLING_AGENT_DECISION] = sampler.rate()\n\n return sampler.isSampled(context)\n }\n\n _normalizeRules (rules, sampleRate) {\n return rules\n .concat({ sampleRate })\n .map(rule => ({ ...rule, sampleRate: parseFloat(rule.sampleRate) }))\n .filter(rule => !isNaN(rule.sampleRate))\n .map(rule => ({ ...rule, sampler: new Sampler(rule.sampleRate) }))\n }\n\n _findRule (context) {\n for (let i = 0, l = this._rules.length; i < l; i++) {\n if (this._matchRule(context, this._rules[i])) return this._rules[i]\n }\n }\n\n _matchRule (context, rule) {\n const name = context._name\n const service = context._tags['service.name']\n\n if (rule.name instanceof RegExp && !rule.name.test(name)) return false\n if (rule.name && rule.name !== name) return false\n if (rule.service instanceof RegExp && !rule.service.test(service)) return false\n if (rule.service && rule.service !== service) return false\n\n return true\n }\n}\n\nmodule.exports = PrioritySampler\n","'use strict'\n\nconst limiter = require('limiter')\n\nclass RateLimiter {\n constructor (rateLimit) {\n this._rateLimit = parseInt(rateLimit)\n this._limiter = new limiter.RateLimiter(this._rateLimit, 'second')\n this._tokensRequested = 0\n this._prevIntervalTokens = 0\n this._prevTokensRequested = 0\n }\n\n isAllowed () {\n const curIntervalStart = this._limiter.curIntervalStart\n const curIntervalTokens = this._limiter.tokensThisInterval\n const allowed = this._isAllowed()\n\n if (curIntervalStart !== this._limiter.curIntervalStart) {\n this._prevIntervalTokens = curIntervalTokens\n this._prevTokensRequested = this._tokensRequested\n this._tokensRequested = 1\n } else {\n this._tokensRequested++\n }\n\n return allowed\n }\n\n effectiveRate () {\n if (this._rateLimit < 0) return 1\n if (this._rateLimit === 0) return 0\n if (this._tokensRequested === 0) return 1\n\n const allowed = this._prevIntervalTokens + this._limiter.tokensThisInterval\n const requested = this._prevTokensRequested + this._tokensRequested\n\n return allowed / requested\n }\n\n _isAllowed () {\n if (this._rateLimit < 0) return true\n if (this._rateLimit === 0) return false\n\n return this._limiter.tryRemoveTokens(1)\n }\n\n _currentWindowRate () {\n if (this._rateLimit < 0) return 1\n if (this._rateLimit === 0) return 0\n if (this._tokensRequested === 0) return 1\n\n return this._limiter.tokensThisInterval / this._tokensRequested\n }\n}\n\nmodule.exports = RateLimiter\n","\r\nexports.RateLimiter = require('./lib/rateLimiter');\r\nexports.TokenBucket = require('./lib/tokenBucket');\r\n","var TokenBucket = require('./tokenBucket');\r\nvar getMilliseconds = require('./clock');\r\n\r\n/**\r\n * A generic rate limiter. Underneath the hood, this uses a token bucket plus\r\n * an additional check to limit how many tokens we can remove each interval.\r\n * @author John Hurliman <jhurliman@jhurliman.org>\r\n *\r\n * @param {Number} tokensPerInterval Maximum number of tokens that can be\r\n * removed at any given moment and over the course of one interval.\r\n * @param {String|Number} interval The interval length in milliseconds, or as\r\n * one of the following strings: 'second', 'minute', 'hour', day'.\r\n * @param {Boolean} fireImmediately Optional. Whether or not the callback\r\n * will fire immediately when rate limiting is in effect (default is false).\r\n */\r\nvar RateLimiter = function(tokensPerInterval, interval, fireImmediately) {\r\n this.tokenBucket = new TokenBucket(tokensPerInterval, tokensPerInterval,\r\n interval, null);\r\n\r\n // Fill the token bucket to start\r\n this.tokenBucket.content = tokensPerInterval;\r\n\r\n this.curIntervalStart = getMilliseconds();\r\n this.tokensThisInterval = 0;\r\n this.fireImmediately = fireImmediately;\r\n};\r\n\r\nRateLimiter.prototype = {\r\n tokenBucket: null,\r\n curIntervalStart: 0,\r\n tokensThisInterval: 0,\r\n fireImmediately: false,\r\n\r\n /**\r\n * Remove the requested number of tokens and fire the given callback. If the\r\n * rate limiter contains enough tokens and we haven't spent too many tokens\r\n * in this interval already, this will happen immediately. Otherwise, the\r\n * removal and callback will happen when enough tokens become available.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Function} callback(err, remainingTokens)\r\n * @returns {Boolean} True if the callback was fired immediately, otherwise\r\n * false.\r\n */\r\n removeTokens: function(count, callback) {\r\n // Make sure the request isn't for more than we can handle\r\n if (count > this.tokenBucket.bucketSize) {\r\n process.nextTick(callback.bind(null, 'Requested tokens ' + count +\r\n ' exceeds maximum tokens per interval ' + this.tokenBucket.bucketSize,\r\n null));\r\n return false;\r\n }\r\n\r\n var self = this;\r\n var now = getMilliseconds();\r\n\r\n // Advance the current interval and reset the current interval token count\r\n // if needed\r\n if (now < this.curIntervalStart\r\n || now - this.curIntervalStart >= this.tokenBucket.interval) {\r\n this.curIntervalStart = now;\r\n this.tokensThisInterval = 0;\r\n }\r\n\r\n // If we don't have enough tokens left in this interval, wait until the\r\n // next interval\r\n if (count > this.tokenBucket.tokensPerInterval - this.tokensThisInterval) {\r\n if (this.fireImmediately) {\r\n process.nextTick(callback.bind(null, null, -1));\r\n } else {\r\n var waitInterval = Math.ceil(\r\n this.curIntervalStart + this.tokenBucket.interval - now);\r\n\r\n setTimeout(function() {\r\n self.tokenBucket.removeTokens(count, afterTokensRemoved);\r\n }, waitInterval);\r\n }\r\n return false;\r\n }\r\n\r\n // Remove the requested number of tokens from the token bucket\r\n return this.tokenBucket.removeTokens(count, afterTokensRemoved);\r\n\r\n function afterTokensRemoved(err, tokensRemaining) {\r\n if (err) return callback(err, null);\r\n\r\n self.tokensThisInterval += count;\r\n callback(null, tokensRemaining);\r\n }\r\n },\r\n\r\n /**\r\n * Attempt to remove the requested number of tokens and return immediately.\r\n * If the bucket (and any parent buckets) contains enough tokens and we\r\n * haven't spent too many tokens in this interval already, this will return\r\n * true. Otherwise, false is returned.\r\n * @param {Number} count The number of tokens to remove.\r\n * @param {Boolean} True if the tokens were successfully removed, otherwise\r\n * false.\r\n */\r\n tryRemoveTokens: function(count) {\r\n // Make sure the request isn't for more than we can handle\r\n if (count > this.tokenBucket.bucketSize)\r\n return false;\r\n\r\n var now = getMilliseconds();\r\n\r\n // Advance the current interval and reset the current interval token count\r\n // if needed\r\n if (now < this.curIntervalStart\r\n || now - this.curIntervalStart >= this.tokenBucket.interval) {\r\n this.curIntervalStart = now;\r\n this.tokensThisInterval = 0;\r\n }\r\n\r\n // If we don't have enough tokens left in this interval, return false\r\n if (count > this.tokenBucket.tokensPerInterval - this.tokensThisInterval)\r\n return false;\r\n\r\n // Try to remove the requested number of tokens from the token bucket\r\n var removed = this.tokenBucket.tryRemoveTokens(count);\r\n if (removed) {\r\n this.tokensThisInterval += count;\r\n }\r\n return removed;\r\n },\r\n\r\n /**\r\n * Returns the number of tokens remaining in the TokenBucket.\r\n * @returns {Number} The number of tokens remaining.\r\n */\r\n getTokensRemaining: function () {\r\n this.tokenBucket.drip();\r\n return this.tokenBucket.content;\r\n }\r\n};\r\n\r\nmodule.exports = RateLimiter;\r\n","var getMilliseconds = function() {\r\n if (typeof process !== 'undefined' && process.hrtime) {\r\n var hrtime = process.hrtime();\r\n var seconds = hrtime[0];\r\n var nanoseconds = hrtime[1];\r\n\r\n return seconds * 1e3 + Math.floor(nanoseconds / 1e6);\r\n }\r\n\r\n return new Date().getTime();\r\n}\r\n\r\nmodule.exports = getMilliseconds;\r\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n symbolTag = '[object Symbol]';\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\n/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n var index = -1,\n length = array.length;\n\n predicate || (predicate = isFlattenable);\n result || (result = []);\n\n while (++index < length) {\n var value = array[index];\n if (depth > 0 && predicate(value)) {\n if (depth > 1) {\n // Recursively flatten arrays (susceptible to call stack limits).\n baseFlatten(value, depth - 1, predicate, isStrict, result);\n } else {\n arrayPush(result, value);\n }\n } else if (!isStrict) {\n result[result.length] = value;\n }\n }\n return result;\n}\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, props) {\n object = Object(object);\n return basePickBy(object, props, function(value, key) {\n return key in object;\n });\n}\n\n/**\n * The base implementation of `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick from.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, props, predicate) {\n var index = -1,\n length = props.length,\n result = {};\n\n while (++index < length) {\n var key = props[index],\n value = object[key];\n\n if (predicate(value, key)) {\n result[key] = value;\n }\n }\n return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = array;\n return apply(func, this, otherArgs);\n };\n}\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n return isArray(value) || isArguments(value) ||\n !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [props] The property identifiers to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = baseRest(function(object, props) {\n return object == null ? {} : basePick(object, arrayMap(baseFlatten(props, 1), toKey));\n});\n\nmodule.exports = pick;\n","'use strict'\n\nconst TextMapPropagator = require('./text_map')\n\nclass HttpPropagator extends TextMapPropagator {}\n\nmodule.exports = HttpPropagator\n","'use strict'\n\nclass BinaryPropagator {\n inject (spanContext, carrier) {}\n\n extract (carrier) {\n return null\n }\n}\n\nmodule.exports = BinaryPropagator\n","'use strict'\n\nconst id = require('../../id')\nconst DatadogSpanContext = require('../span_context')\n\nclass LogPropagator {\n constructor (config) {\n this._config = config\n }\n\n inject (spanContext, carrier) {\n if (!carrier) return\n\n carrier.dd = {}\n\n if (spanContext) {\n carrier.dd.trace_id = spanContext.toTraceId()\n carrier.dd.span_id = spanContext.toSpanId()\n }\n\n if (this._config.service) carrier.dd.service = this._config.service\n if (this._config.version) carrier.dd.version = this._config.version\n if (this._config.env) carrier.dd.env = this._config.env\n }\n\n extract (carrier) {\n if (!carrier || !carrier.dd || !carrier.dd.trace_id || !carrier.dd.span_id) {\n return null\n }\n\n const spanContext = new DatadogSpanContext({\n traceId: id(carrier.dd.trace_id, 10),\n spanId: id(carrier.dd.span_id, 10)\n })\n\n return spanContext\n }\n}\n\nmodule.exports = LogPropagator\n","'use strict'\n\nconst URL = require('url-parse')\nconst platform = require('./platform')\nconst coalesce = require('koalas')\nconst scopes = require('../../../ext/scopes')\nconst tagger = require('./tagger')\nconst id = require('./id')\nconst { isTrue, isFalse } = require('./util')\n\nconst runtimeId = `${id().toString()}${id().toString()}`\n\nclass Config {\n constructor (options) {\n options = options || {}\n\n this.tags = {}\n\n tagger.add(this.tags, platform.env('DD_TAGS'))\n tagger.add(this.tags, platform.env('DD_TRACE_TAGS'))\n tagger.add(this.tags, platform.env('DD_TRACE_GLOBAL_TAGS'))\n tagger.add(this.tags, options.tags)\n\n const DD_TRACE_ANALYTICS_ENABLED = coalesce(\n options.analytics,\n platform.env('DD_TRACE_ANALYTICS_ENABLED'),\n platform.env('DD_TRACE_ANALYTICS'),\n false\n )\n // Temporary disabled\n const DD_PROFILING_ENABLED = coalesce(\n // options.profiling,\n // platform.env('DD_PROFILING_ENABLED'),\n platform.env('DD_EXPERIMENTAL_PROFILING_ENABLED'),\n false\n )\n const DD_PROFILING_EXPORTERS = coalesce(\n platform.env('DD_PROFILING_EXPORTERS'),\n 'agent'\n )\n const DD_PROFILING_SOURCE_MAP = platform.env('DD_PROFILING_SOURCE_MAP')\n const DD_LOGS_INJECTION = coalesce(\n options.logInjection,\n platform.env('DD_LOGS_INJECTION'),\n false\n )\n const DD_RUNTIME_METRICS_ENABLED = coalesce(\n options.runtimeMetrics,\n platform.env('DD_RUNTIME_METRICS_ENABLED'),\n false\n )\n const DD_AGENT_HOST = coalesce(\n options.hostname,\n platform.env('DD_AGENT_HOST'),\n platform.env('DD_TRACE_AGENT_HOSTNAME'),\n '127.0.0.1'\n )\n const DD_TRACE_AGENT_PORT = coalesce(\n options.port,\n platform.env('DD_TRACE_AGENT_PORT'),\n '8126'\n )\n const DD_TRACE_AGENT_URL = coalesce(\n options.url,\n platform.env('DD_TRACE_AGENT_URL'),\n platform.env('DD_TRACE_URL'),\n null\n )\n const DD_SERVICE = options.service ||\n platform.env('DD_SERVICE') ||\n platform.env('DD_SERVICE_NAME') ||\n this.tags.service ||\n platform.service() ||\n 'node'\n const DD_ENV = coalesce(\n options.env,\n platform.env('DD_ENV'),\n this.tags.env\n )\n const DD_VERSION = coalesce(\n options.version,\n platform.env('DD_VERSION'),\n this.tags.version,\n platform.appVersion()\n )\n const DD_TRACE_STARTUP_LOGS = coalesce(\n options.startupLogs,\n platform.env('DD_TRACE_STARTUP_LOGS'),\n true\n )\n const DD_TRACE_ENABLED = coalesce(\n options.enabled,\n platform.env('DD_TRACE_ENABLED'),\n true\n )\n const DD_TRACE_DEBUG = coalesce(\n options.debug,\n platform.env('DD_TRACE_DEBUG'),\n false\n )\n const DD_TRACE_AGENT_PROTOCOL_VERSION = coalesce(\n options.protocolVersion,\n platform.env('DD_TRACE_AGENT_PROTOCOL_VERSION'),\n '0.4'\n )\n\n const sampler = (options.experimental && options.experimental.sampler) || {}\n const ingestion = options.ingestion || {}\n const dogstatsd = coalesce(options.dogstatsd, {})\n\n Object.assign(sampler, {\n sampleRate: coalesce(ingestion.sampleRate, sampler.sampleRate, platform.env('DD_TRACE_SAMPLE_RATE')),\n rateLimit: coalesce(ingestion.rateLimit, sampler.rateLimit, platform.env('DD_TRACE_RATE_LIMIT'))\n })\n\n this.enabled = isTrue(DD_TRACE_ENABLED)\n this.debug = isTrue(DD_TRACE_DEBUG)\n this.logInjection = isTrue(DD_LOGS_INJECTION)\n this.env = DD_ENV\n this.url = DD_TRACE_AGENT_URL && new URL(DD_TRACE_AGENT_URL)\n this.site = coalesce(options.site, platform.env('DD_SITE'), 'datadoghq.com')\n this.hostname = DD_AGENT_HOST || (this.url && this.url.hostname)\n this.port = String(DD_TRACE_AGENT_PORT || (this.url && this.url.port))\n this.flushInterval = coalesce(parseInt(options.flushInterval, 10), 2000)\n this.sampleRate = coalesce(Math.min(Math.max(options.sampleRate, 0), 1), 1)\n this.logger = options.logger\n this.plugins = !!coalesce(options.plugins, true)\n this.service = DD_SERVICE\n this.version = DD_VERSION\n this.analytics = isTrue(DD_TRACE_ANALYTICS_ENABLED)\n this.dogstatsd = {\n hostname: coalesce(dogstatsd.hostname, platform.env(`DD_DOGSTATSD_HOSTNAME`), this.hostname),\n port: String(coalesce(dogstatsd.port, platform.env('DD_DOGSTATSD_PORT'), 8125))\n }\n this.runtimeMetrics = isTrue(DD_RUNTIME_METRICS_ENABLED)\n this.trackAsyncScope = options.trackAsyncScope !== false\n this.experimental = {\n b3: !(!options.experimental || !options.experimental.b3),\n runtimeId: !(!options.experimental || !options.experimental.runtimeId),\n exporter: options.experimental && options.experimental.exporter,\n peers: (options.experimental && options.experimental.distributedTracingOriginAllowlist) ||\n (options.experimental && options.experimental.distributedTracingOriginWhitelist) || [],\n enableGetRumData: (options.experimental && !!options.experimental.enableGetRumData),\n sampler,\n internalErrors: options.experimental && options.experimental.internalErrors\n }\n this.reportHostname = isTrue(coalesce(options.reportHostname, platform.env('DD_TRACE_REPORT_HOSTNAME'), false))\n this.scope = isFalse(platform.env('DD_CONTEXT_PROPAGATION'))\n ? scopes.NOOP\n : coalesce(options.scope, platform.env('DD_TRACE_SCOPE'))\n this.clientToken = coalesce(options.clientToken, platform.env('DD_CLIENT_TOKEN'))\n this.logLevel = coalesce(\n options.logLevel,\n platform.env('DD_TRACE_LOG_LEVEL'),\n 'debug'\n )\n this.profiling = {\n enabled: isTrue(DD_PROFILING_ENABLED),\n sourceMap: !isFalse(DD_PROFILING_SOURCE_MAP),\n exporters: DD_PROFILING_EXPORTERS\n }\n this.lookup = options.lookup\n this.startupLogs = isTrue(DD_TRACE_STARTUP_LOGS)\n this.protocolVersion = DD_TRACE_AGENT_PROTOCOL_VERSION\n\n tagger.add(this.tags, { service: this.service, env: this.env, version: this.version })\n\n if (this.experimental.runtimeId) {\n tagger.add(this.tags, {\n 'runtime-id': runtimeId\n })\n }\n }\n}\n\nmodule.exports = Config\n","'use strict';\n\n/**\n * Coalesce function to find the first valid value.\n * A valid value is one that is not undefined, not null and not NaN (not a number).\n * If no values are valid, then the last argument is returned.\n *\n * ```js\n * console.log(koalas(undefined, null, NaN, 'a', 'b'));\n * //=> 'a'\n *\n * console.log(koalas(undefined, null, NaN, {a: 'b'}, 'b'));\n * //=> {a: 'b'}\n *\n * console.log(koalas(undefined, null, NaN, ['a', 'b', 'c'], {a: 'b'}, 'b'));\n * //=> ['a', 'b', 'c']\n *\n * console.log(koalas(undefined, NaN, null));\n * //=> null\n * ```\n * @name koalas\n * @param {Mixed} `arguments` Pass in any amount of arguments.\n * @return {Mixed} First valid value.\n * @api public\n */\n\nfunction koalas() {\n var len = arguments.length;\n var arg;\n for (var i = 0; i < len; i++) {\n arg = arguments[i];\n if (hasValue(arg)) {\n return arg;\n }\n }\n return arg;\n}\n\n/**\n * Check to see if a value actually has a valid value:\n * - not undefined\n * - not null\n * - not NaN (not a number)\n *\n * @param {*} `val` value to check\n * @return {Boolean} returns `true` if the `val` has a valid value\n */\n\nfunction hasValue(val) {\n // eslint-disable-next-line no-self-compare\n return val != null && val === val;\n}\n\n/**\n * Expose koalas\n */\n\nmodule.exports = koalas;\n","'use strict'\n\nconst shimmer = require('shimmer')\nconst log = require('./log')\nconst platform = require('./platform')\nconst { isTrue, isFalse } = require('./util')\n\nshimmer({ logger: () => {} })\n\nconst plugins = platform.plugins\n\nconst disabldPlugins = platform.env('DD_TRACE_DISABLED_PLUGINS')\n\nconst collectDisabledPlugins = () => {\n return new Set(disabldPlugins && disabldPlugins.split(',').map(plugin => plugin.trim()))\n}\n\nfunction cleanEnv (name) {\n return platform.env(`DD_TRACE_${name.toUpperCase()}`.replace(/[^a-z0-9_]/ig, '_'))\n}\n\nfunction getConfig (name, config = {}) {\n if (!name) {\n return config\n }\n\n const enabled = cleanEnv(`${name}_ENABLED`)\n if (enabled !== undefined) {\n config.enabled = isTrue(enabled)\n }\n\n const analyticsEnabled = cleanEnv(`${name}_ANALYTICS_ENABLED`)\n const analyticsSampleRate = Math.min(Math.max(cleanEnv(`${name}_ANALYTICS_SAMPLE_RATE`), 0), 1)\n\n if (isFalse(analyticsEnabled)) {\n config.analytics = false\n } else if (!Number.isNaN(analyticsSampleRate)) {\n config.analytics = analyticsSampleRate\n } else if (isTrue(analyticsEnabled)) {\n config.analytics = true\n }\n\n return config\n}\n\nclass Instrumenter {\n constructor (tracer) {\n this._tracer = tracer\n this._loader = new platform.Loader(this)\n this._enabled = false\n this._names = new Set()\n this._plugins = new Map()\n this._instrumented = new Map()\n this._disabledPlugins = collectDisabledPlugins()\n }\n\n use (name, config) {\n if (typeof config === 'boolean') {\n config = { enabled: config }\n }\n\n config = getConfig(name, config)\n\n try {\n this._set(plugins[name.toLowerCase()], { name, config })\n } catch (e) {\n log.debug(`Could not find a plugin named \"${name}\".`)\n }\n\n if (this._enabled) {\n this._loader.reload(this._plugins)\n }\n }\n\n enable (config) {\n config = config || {}\n\n this._enabled = true\n\n if (config.plugins !== false) {\n Object.keys(plugins)\n .filter(name => !this._plugins.has(plugins[name]))\n .forEach(name => {\n this._set(plugins[name], { name, config: getConfig(name) })\n })\n }\n\n this._loader.reload(this._plugins)\n }\n\n disable () {\n for (const instrumentation of this._instrumented.keys()) {\n this.unpatch(instrumentation)\n }\n\n this._plugins.clear()\n this._enabled = false\n this._loader.reload(this._plugins)\n }\n\n wrap (nodules, names, wrapper) {\n nodules = [].concat(nodules)\n names = [].concat(names)\n\n nodules.forEach(nodule => {\n names.forEach(name => {\n if (typeof nodule[name] !== 'function') {\n throw new Error(`Expected object ${nodule} to contain method ${name}.`)\n }\n\n Object.defineProperty(nodule[name], '_datadog_patched', {\n value: true,\n configurable: true\n })\n })\n })\n\n shimmer.massWrap.call(this, nodules, names, function (original, name) {\n const wrapped = wrapper(original, name)\n const props = Object.getOwnPropertyDescriptors(original)\n const keys = Reflect.ownKeys(props)\n\n // https://github.com/othiym23/shimmer/issues/19\n for (const key of keys) {\n if (typeof key !== 'symbol' || wrapped.hasOwnProperty(key)) continue\n\n Object.defineProperty(wrapped, key, props[key])\n }\n\n return wrapped\n })\n }\n\n unwrap (nodules, names, wrapper) {\n nodules = [].concat(nodules)\n names = [].concat(names)\n\n shimmer.massUnwrap.call(this, nodules, names, wrapper)\n\n nodules.forEach(nodule => {\n names.forEach(name => {\n nodule[name] && delete nodule[name]._datadog_patched\n })\n })\n }\n\n wrapExport (moduleExports, wrapper) {\n if (typeof moduleExports !== 'function') return moduleExports\n\n const props = Object.keys(moduleExports)\n const shim = function () {\n return moduleExports._datadog_wrapper.apply(this, arguments)\n }\n\n for (const prop of props) {\n shim[prop] = moduleExports[prop]\n }\n\n moduleExports._datadog_wrapper = wrapper\n\n return shim\n }\n\n unwrapExport (moduleExports) {\n if (moduleExports && moduleExports._datadog_wrapper) {\n moduleExports._datadog_wrapper = moduleExports\n }\n\n return moduleExports\n }\n\n load (plugin, meta) {\n if (!this._enabled) return\n\n const instrumentations = [].concat(plugin)\n const enabled = meta.config.enabled !== false\n\n platform.metrics().boolean(`datadog.tracer.node.plugin.enabled.by.name`, enabled, `name:${meta.name}`)\n\n try {\n instrumentations\n .forEach(instrumentation => {\n this._loader.load(instrumentation, meta.config)\n })\n } catch (e) {\n log.error(e)\n this.unload(plugin)\n log.debug(`Error while trying to patch ${meta.name}. The plugin has been disabled.`)\n\n platform.metrics().increment(`datadog.tracer.node.plugin.errors`, true)\n }\n }\n\n unload (plugin) {\n [].concat(plugin)\n .forEach(instrumentation => {\n this.unpatch(instrumentation)\n this._instrumented.delete(instrumentation)\n })\n\n const meta = this._plugins.get(plugin)\n\n if (meta) {\n this._plugins.delete(plugin)\n\n platform.metrics().boolean(`datadog.tracer.node.plugin.enabled.by.name`, false, `name:${meta.name}`)\n }\n }\n\n patch (instrumentation, moduleExports, config) {\n let instrumented = this._instrumented.get(instrumentation)\n\n if (!instrumented) {\n this._instrumented.set(instrumentation, instrumented = new Set())\n }\n\n if (!instrumented.has(moduleExports)) {\n instrumented.add(moduleExports)\n return instrumentation.patch.call(this, moduleExports, this._tracer._tracer, config)\n }\n }\n\n unpatch (instrumentation) {\n const instrumented = this._instrumented.get(instrumentation)\n\n if (instrumented) {\n instrumented.forEach(moduleExports => {\n try {\n instrumentation.unpatch.call(this, moduleExports, this._tracer)\n } catch (e) {\n log.error(e)\n }\n })\n }\n }\n\n _set (plugin, meta) {\n if (this._disabledPlugins.has(meta.name)) {\n log.debug(`Plugin \"${meta.name}\" was disabled via configuration option.`)\n } else {\n this._plugins.set(plugin, meta)\n this.load(plugin, meta)\n }\n }\n}\n\nmodule.exports = Instrumenter\n","'use strict'\n\nfunction isFunction (funktion) {\n return typeof funktion === 'function'\n}\n\n// Default to complaining loudly when things don't go according to plan.\nvar logger = console.error.bind(console)\n\n// Sets a property on an object, preserving its enumerability.\n// This function assumes that the property is already writable.\nfunction defineProperty (obj, name, value) {\n var enumerable = !!obj[name] && obj.propertyIsEnumerable(name)\n Object.defineProperty(obj, name, {\n configurable: true,\n enumerable: enumerable,\n writable: true,\n value: value\n })\n}\n\n// Keep initialization idempotent.\nfunction shimmer (options) {\n if (options && options.logger) {\n if (!isFunction(options.logger)) logger(\"new logger isn't a function, not replacing\")\n else logger = options.logger\n }\n}\n\nfunction wrap (nodule, name, wrapper) {\n if (!nodule || !nodule[name]) {\n logger('no original function ' + name + ' to wrap')\n return\n }\n\n if (!wrapper) {\n logger('no wrapper function')\n logger((new Error()).stack)\n return\n }\n\n if (!isFunction(nodule[name]) || !isFunction(wrapper)) {\n logger('original object and wrapper must be functions')\n return\n }\n\n var original = nodule[name]\n var wrapped = wrapper(original, name)\n\n defineProperty(wrapped, '__original', original)\n defineProperty(wrapped, '__unwrap', function () {\n if (nodule[name] === wrapped) defineProperty(nodule, name, original)\n })\n defineProperty(wrapped, '__wrapped', true)\n\n defineProperty(nodule, name, wrapped)\n return wrapped\n}\n\nfunction massWrap (nodules, names, wrapper) {\n if (!nodules) {\n logger('must provide one or more modules to patch')\n logger((new Error()).stack)\n return\n } else if (!Array.isArray(nodules)) {\n nodules = [nodules]\n }\n\n if (!(names && Array.isArray(names))) {\n logger('must provide one or more functions to wrap on modules')\n return\n }\n\n nodules.forEach(function (nodule) {\n names.forEach(function (name) {\n wrap(nodule, name, wrapper)\n })\n })\n}\n\nfunction unwrap (nodule, name) {\n if (!nodule || !nodule[name]) {\n logger('no function to unwrap.')\n logger((new Error()).stack)\n return\n }\n\n if (!nodule[name].__unwrap) {\n logger('no original to unwrap to -- has ' + name + ' already been unwrapped?')\n } else {\n return nodule[name].__unwrap()\n }\n}\n\nfunction massUnwrap (nodules, names) {\n if (!nodules) {\n logger('must provide one or more modules to patch')\n logger((new Error()).stack)\n return\n } else if (!Array.isArray(nodules)) {\n nodules = [nodules]\n }\n\n if (!(names && Array.isArray(names))) {\n logger('must provide one or more functions to unwrap on modules')\n return\n }\n\n nodules.forEach(function (nodule) {\n names.forEach(function (name) {\n unwrap(nodule, name)\n })\n })\n}\n\nshimmer.wrap = wrap\nshimmer.massWrap = massWrap\nshimmer.unwrap = unwrap\nshimmer.massUnwrap = massUnwrap\n\nmodule.exports = shimmer\n","'use strict'\n\nconst ANALYTICS = require('../../../ext/tags').ANALYTICS\n\nlet enabled = false\n\nmodule.exports = {\n enable () {\n enabled = true\n },\n\n disable () {\n enabled = false\n },\n\n sample (span, rate, inherit) {\n if (typeof rate === 'object') {\n this.sample(span, rate[span.context()._name], inherit)\n } else if (rate !== undefined) {\n span.setTag(ANALYTICS, rate)\n } else if (inherit && enabled) {\n span.setTag(ANALYTICS, 1)\n }\n }\n}\n"],"sourceRoot":""} |