{"version":3,"sources":["webpack:///./node_modules/@sentry/tracing/esm/errors.js","webpack:///./node_modules/@sentry/tracing/esm/spanstatus.js","webpack:///./node_modules/@sentry/tracing/esm/browser/backgroundtab.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getFirstHidden.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/whenInput.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getTTFB.js","webpack:///./node_modules/@sentry/tracing/esm/browser/metrics.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js","webpack:///./node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js","webpack:///./node_modules/@sentry/tracing/esm/browser/request.js","webpack:///./node_modules/@sentry/tracing/esm/browser/router.js","webpack:///./node_modules/@sentry/tracing/esm/browser/browsertracing.js","webpack:///./node_modules/@sentry/tracing/esm/integrations/express.js","webpack:///./node_modules/@sentry/tracing/esm/index.js","webpack:///./node_modules/@sentry/react/esm/errorboundary.js","webpack:///./app/javascript/app/apollo.js","webpack:///./app/javascript/app/index.jsx","webpack:///./app/javascript/packs/app.js","webpack:///./app/javascript/app/lib/storage.js","webpack:///./node_modules/js-cookie/src/js.cookie.js","webpack:///./node_modules/@sentry/tracing/esm/span.js","webpack:///./node_modules/@sentry/tracing/esm/transaction.js","webpack:///./app/javascript/shared/router.js","webpack:///./app/javascript/app/components/page/Fallback.jsx","webpack:///./node_modules/@sentry/tracing/esm/hubextensions.js","webpack:///./node_modules/@sentry/tracing/esm/utils.js","webpack:///./node_modules/@sentry/tracing/esm/idletransaction.js"],"names":["registerErrorInstrumentation","callback","errorCallback","type","activeTransaction","log","InternalError","setStatus","SpanStatus","fromHttpCode","httpStatus","Ok","Unauthenticated","PermissionDenied","NotFound","AlreadyExists","FailedPrecondition","ResourceExhausted","InvalidArgument","Unimplemented","Unavailable","DeadlineExceeded","UnknownError","global","firstHiddenTime","inputPromise","bindReporter","metric","po","observeAllUpdates","prevValue","isFinal","disconnect","value","document","visibilityState","delta","undefined","name","entries","id","Date","now","Math","floor","random","observe","PerformanceObserver","supportedEntryTypes","includes","l","getEntries","map","buffered","e","isUnloading","listenersAdded","onPageHide","event","persisted","onHidden","cb","once","addEventListener","_a","timeStamp","capture","Infinity","onReport","reportAllChanges","report","firstHidden","entryHandler","entry","startTime","push","onFinal","takeRecords","Promise","r","passive","then","navigationEntry","performance","getEntriesByType","timing","entryType","key","max","navigationStart","getNavigationEntryFromPerformanceTiming","responseStart","error","readyState","setTimeout","MetricsInstrumentation","this","_measurements","_performanceCursor","mark","_trackCLS","_trackLCP","_trackFID","_trackTTFB","prototype","addPerformanceEntries","transaction","_this","logger","entryScriptSrc","entryScriptStartTimestamp","tracingInitMarkStartTime","timeOrigin","i","scripts","length","dataset","src","slice","forEach","duration","op","startTimestamp","addPerformanceNavigationTiming","_startChild","description","endTimestamp","responseEnd","requestStart","addRequest","addNavigationSpans","measureStartTimestamp","measureEndTimestamp","addMeasureSpans","shouldRecord","resourceName","replace","window","location","origin","initiatorType","data","transferSize","encodedBodySize","decodedBodySize","addResourceSpans","indexOf","_trackNavigator","timeOrigin_1","oldValue","normalizedValue","setMeasurements","hadRecentInput","pop","navigator","connection","effectiveType","setTag","isMeasurementValue","rtt","downlink","deviceMemory","String","hardwareConcurrency","processingStart","perfMetrics","onFirstInputDelay","target","cancelable","requestTime","eventEnd","end","start","ctx","startChild","isFinite","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","registerRequestInstrumentation","_options","shouldCreateSpanForRequest","urlMap","defaultShouldCreateSpan","url","origins","some","shouldCreateSpan","spans","handlerData","currentClientOptions","getClient","getOptions","fetchData","__span","span","response","setHttpStatus","status","finish","method","spanId","request","args","options","headers","is","Request","append","toTraceparent","Array","isArray","fetchCallback","xhr","__sentry_xhr__","__sentry_own_request__","__sentry_xhr_span_id__","status_code","setRequestHeader","_","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","idleTimeout","markBackgroundTransactions","maxTransactionDuration","routingInstrumentation","startTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","href","pathname","to","from","warn","BrowserTracing","_metrics","_emitOptionsWarning","setupOnce","getCurrentHub","_getCurrentHub","context","_createRouteTransaction","hidden","Cancelled","beforeNavigate","parentContextFromHeader","header","metaName","el","querySelector","getAttribute","getHeaderContext","expandedContext","trimEnd","modifiedContext","finalContext","sampled","hub","idleTransaction","registerBeforeFinishCallback","maxDuration","diff","adjustTransactionDuration","Express","_app","app","_methods","methods","patchMiddleware","instrumentMiddlewares","routeMiddlewares","wrap","fn","arity","req","res","__sentry_transaction","addExpressReqToTransaction","span_1","apply","arguments","next","call","err","Error","route","path","setData","originalUrl","baseUrl","query","wrapUseArgs","arg","a","originalAppCallback","Integrations","INITIAL_STATE","componentStack","eventId","_super","ErrorBoundary","state","resetErrorBoundary","onReset","props","setState","componentDidCatch","_b","beforeCapture","onError","showDialog","dialogOptions","scope","contexts","react","componentDidMount","onMount","componentWillUnmount","onUnmount","render","fallback","resetError","children","cache","InMemoryCache","uri","credentials","client","ApolloClient","Sentry","dsn","integrations","tracesSampleRate","history","createBrowserHistory","listen","page_path","search","gtag","HomePage","React","lazy","retry","ApplyPage","PrivacyPolicyPage","TermsOfServicePage","CheckHumanPage","CheckWhoPage","CheckResumePage","CheckRemotePage","CheckDevicePage","CheckBrowserPage","CheckNetworkPage","CheckSystemPage","CheckMicrophonePage","CheckMediaPage","CheckScriptPage","CheckWhyPage","CheckUnitPricePage","CheckCopyPastePage","CheckListeningPage","CheckEducationLevelPage","CheckWorkAuthorizationPage","CheckCompletePage","AssessmentShowPage","NotFoundPage","AssessmentHumanPage","AssessmentCandidatePage","AssessmentResumePage","AssessmentQuestionPage","AssessmentCompletePage","App","Fallback","component","exact","console","writeIfNotExists","referrer","writeUrlIfParamsPresent","ReactDOM","body","appendChild","createElement","write","sessionStorage","setItem","Cookies","set","read","defaultValue","getItem","get","destroy","removeItem","remove","params","URLSearchParams","has","trim","_typeof","Symbol","iterator","obj","constructor","factory","registeredInModuleLoader","exports","module","OldCookies","api","noConflict","extend","result","attributes","decode","s","decodeURIComponent","init","converter","defaults","expires","toUTCString","JSON","stringify","test","encodeURIComponent","escape","stringifiedAttributes","attributeName","split","cookie","json","jar","cookies","parts","join","charAt","parse","getJSON","withConverter","SpanRecorder","maxlen","_maxlen","add","spanRecorder","Span","spanContext","traceId","substring","tags","parentSpanId","child","childSpan","spanStatus","isSuccess","sampledString","getTraceContext","Object","keys","parent_span_id","span_id","trace_id","toJSON","start_timestamp","timestamp","Transaction","transactionContext","_hub","_trimEnd","setName","initSpanRecorder","measurements","finishedSpans","filter","reduce","prev","current","trace","captureEvent","resolve","reject","reload","className","role","traceHeaders","getScope","getSpan","sample","samplingContext","parentSampled","givenRate","sampleRate","tracesSampler","rate","isNaN","isValidSampleRate","_experiments","maxSpans","Number","getDefaultSamplingContext","defaultSamplingContext","domain","requestType_1","IncomingMessage","members","find","member","globalObject","_startTransaction","customSamplingContext","startIdleTransaction","onScope","addExtensionMethods","carrier","__SENTRY__","extensions","TRACEPARENT_REGEXP","RegExp","hasTracingEnabled","extractTraceparentData","traceparent","matches","match","getActiveTransaction","getTransaction","msToSec","time","secToMs","DEFAULT_IDLE_TIMEOUT","IdleTransactionSpanRecorder","_pushActivity","_popActivity","transactionSpanId","IdleTransaction","_idleHub","_idleTimeout","_onScope","activities","_heartbeatTimer","_heartbeatCounter","_finished","_beforeFinishCallbacks","clearActiveTransaction","configureScope","setSpan","e_1","toISOString","_c","done","e_1_1","keepSpan","_initTimeout","_pingHeartbeat","clearTimeout","timeout","end_1","_beat","heartbeatString","_prevHeartbeatString"],"mappings":"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","file":"js/app-9aa61495183652879d14.chunk.js","sourcesContent":["import { addInstrumentationHandler, logger } from '@sentry/utils';\nimport { SpanStatus } from './spanstatus';\nimport { getActiveTransaction } from './utils';\n/**\n * Configures global error listeners\n */\n\nexport function registerErrorInstrumentation() {\n  addInstrumentationHandler({\n    callback: errorCallback,\n    type: 'error'\n  });\n  addInstrumentationHandler({\n    callback: errorCallback,\n    type: 'unhandledrejection'\n  });\n}\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\n\nfunction errorCallback() {\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    logger.log(\"[Tracing] Transaction: \" + SpanStatus.InternalError + \" -> Global error occured\");\n    activeTransaction.setStatus(SpanStatus.InternalError);\n  }\n}","/** The status of an Span. */\n// eslint-disable-next-line import/export\nexport var SpanStatus;\n\n(function (SpanStatus) {\n  /** The operation completed successfully. */\n  SpanStatus[\"Ok\"] = \"ok\";\n  /** Deadline expired before operation could complete. */\n\n  SpanStatus[\"DeadlineExceeded\"] = \"deadline_exceeded\";\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n\n  SpanStatus[\"Unauthenticated\"] = \"unauthenticated\";\n  /** 403 Forbidden */\n\n  SpanStatus[\"PermissionDenied\"] = \"permission_denied\";\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n\n  SpanStatus[\"NotFound\"] = \"not_found\";\n  /** 429 Too Many Requests */\n\n  SpanStatus[\"ResourceExhausted\"] = \"resource_exhausted\";\n  /** Client specified an invalid argument. 4xx. */\n\n  SpanStatus[\"InvalidArgument\"] = \"invalid_argument\";\n  /** 501 Not Implemented */\n\n  SpanStatus[\"Unimplemented\"] = \"unimplemented\";\n  /** 503 Service Unavailable */\n\n  SpanStatus[\"Unavailable\"] = \"unavailable\";\n  /** Other/generic 5xx. */\n\n  SpanStatus[\"InternalError\"] = \"internal_error\";\n  /** Unknown. Any non-standard HTTP status code. */\n\n  SpanStatus[\"UnknownError\"] = \"unknown_error\";\n  /** The operation was cancelled (typically by the user). */\n\n  SpanStatus[\"Cancelled\"] = \"cancelled\";\n  /** Already exists (409) */\n\n  SpanStatus[\"AlreadyExists\"] = \"already_exists\";\n  /** Operation was rejected because the system is not in a state required for the operation's */\n\n  SpanStatus[\"FailedPrecondition\"] = \"failed_precondition\";\n  /** The operation was aborted, typically due to a concurrency issue. */\n\n  SpanStatus[\"Aborted\"] = \"aborted\";\n  /** Operation was attempted past the valid range. */\n\n  SpanStatus[\"OutOfRange\"] = \"out_of_range\";\n  /** Unrecoverable data loss or corruption */\n\n  SpanStatus[\"DataLoss\"] = \"data_loss\";\n})(SpanStatus || (SpanStatus = {})); // eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n\n\n(function (SpanStatus) {\n  /**\n   * Converts a HTTP status code into a {@link SpanStatus}.\n   *\n   * @param httpStatus The HTTP response status code.\n   * @returns The span status or {@link SpanStatus.UnknownError}.\n   */\n  function fromHttpCode(httpStatus) {\n    if (httpStatus < 400) {\n      return SpanStatus.Ok;\n    }\n\n    if (httpStatus >= 400 && httpStatus < 500) {\n      switch (httpStatus) {\n        case 401:\n          return SpanStatus.Unauthenticated;\n\n        case 403:\n          return SpanStatus.PermissionDenied;\n\n        case 404:\n          return SpanStatus.NotFound;\n\n        case 409:\n          return SpanStatus.AlreadyExists;\n\n        case 413:\n          return SpanStatus.FailedPrecondition;\n\n        case 429:\n          return SpanStatus.ResourceExhausted;\n\n        default:\n          return SpanStatus.InvalidArgument;\n      }\n    }\n\n    if (httpStatus >= 500 && httpStatus < 600) {\n      switch (httpStatus) {\n        case 501:\n          return SpanStatus.Unimplemented;\n\n        case 503:\n          return SpanStatus.Unavailable;\n\n        case 504:\n          return SpanStatus.DeadlineExceeded;\n\n        default:\n          return SpanStatus.InternalError;\n      }\n    }\n\n    return SpanStatus.UnknownError;\n  }\n\n  SpanStatus.fromHttpCode = fromHttpCode;\n})(SpanStatus || (SpanStatus = {}));","import { getGlobalObject, logger } from '@sentry/utils';\nimport { SpanStatus } from '../spanstatus';\nimport { getActiveTransaction } from '../utils';\nvar global = getGlobalObject();\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\n\nexport function registerBackgroundTabDetection() {\n  if (global && global.document) {\n    global.document.addEventListener('visibilitychange', function () {\n      var activeTransaction = getActiveTransaction();\n\n      if (global.document.hidden && activeTransaction) {\n        logger.log(\"[Tracing] Transaction: \" + SpanStatus.Cancelled + \" -> since tab moved to the background, op: \" + activeTransaction.op); // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(SpanStatus.Cancelled);\n        }\n\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { onHidden } from './onHidden';\nvar firstHiddenTime;\nexport var getFirstHidden = function getFirstHidden() {\n  if (firstHiddenTime === undefined) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = document.visibilityState === 'hidden' ? 0 : Infinity; // Update the time if/when the document becomes hidden.\n\n    onHidden(function (_a) {\n      var timeStamp = _a.timeStamp;\n      return firstHiddenTime = timeStamp;\n    }, true);\n  }\n\n  return {\n    get timeStamp() {\n      return firstHiddenTime;\n    }\n\n  };\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar inputPromise;\nexport var whenInput = function whenInput() {\n  if (!inputPromise) {\n    inputPromise = new Promise(function (r) {\n      return ['scroll', 'keydown', 'pointerdown'].map(function (type) {\n        addEventListener(type, r, {\n          once: true,\n          passive: true,\n          capture: true\n        });\n      });\n    });\n  }\n\n  return inputPromise;\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var bindReporter = function bindReporter(callback, metric, po, observeAllUpdates) {\n  var prevValue;\n  return function () {\n    if (po && metric.isFinal) {\n      po.disconnect();\n    }\n\n    if (metric.value >= 0) {\n      if (observeAllUpdates || metric.isFinal || document.visibilityState === 'hidden') {\n        metric.delta = metric.value - (prevValue || 0); // Report the metric if there's a non-zero delta, if the metric is\n        // final, or if no previous value exists (which can happen in the case\n        // of the document becoming hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n\n        if (metric.delta || metric.isFinal || prevValue === undefined) {\n          callback(metric);\n          prevValue = metric.value;\n        }\n      }\n    }\n  };\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { generateUniqueID } from './generateUniqueID';\nexport var initMetric = function initMetric(name, value) {\n  if (value === void 0) {\n    value = -1;\n  }\n\n  return {\n    name: name,\n    value: value,\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n    isFinal: false\n  };\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 27-char string by combining the current\n * timestamp with a 13-digit random number.\n * @return {string}\n */\nexport var generateUniqueID = function generateUniqueID() {\n  return Date.now() + \"-\" + (Math.floor(Math.random() * (9e12 - 1)) + 1e12);\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nexport var observe = function observe(type, callback) {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      var po = new PerformanceObserver(function (l) {\n        return l.getEntries().map(callback);\n      });\n      po.observe({\n        type: type,\n        buffered: true\n      });\n      return po;\n    }\n  } catch (e) {// Do nothing.\n  }\n\n  return;\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar isUnloading = false;\nvar listenersAdded = false;\n\nvar onPageHide = function onPageHide(event) {\n  isUnloading = !event.persisted;\n};\n\nvar addListeners = function addListeners() {\n  addEventListener('pagehide', onPageHide); // `beforeunload` is needed to fix this bug:\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=987409\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n\n  addEventListener('beforeunload', function () {});\n};\n\nexport var onHidden = function onHidden(cb, once) {\n  if (once === void 0) {\n    once = false;\n  }\n\n  if (!listenersAdded) {\n    addListeners();\n    listenersAdded = true;\n  }\n\n  addEventListener('visibilitychange', function (_a) {\n    var timeStamp = _a.timeStamp;\n\n    if (document.visibilityState === 'hidden') {\n      cb({\n        timeStamp: timeStamp,\n        isUnloading: isUnloading\n      });\n    }\n  }, {\n    capture: true,\n    once: once\n  });\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { bindReporter } from './lib/bindReporter';\nimport { getFirstHidden } from './lib/getFirstHidden';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { whenInput } from './lib/whenInput';\nexport var getLCP = function getLCP(onReport, reportAllChanges) {\n  if (reportAllChanges === void 0) {\n    reportAllChanges = false;\n  }\n\n  var metric = initMetric('LCP');\n  var firstHidden = getFirstHidden();\n  var report;\n\n  var entryHandler = function entryHandler(entry) {\n    // The startTime attribute returns the value of the renderTime if it is not 0,\n    // and the value of the loadTime otherwise.\n    var value = entry.startTime; // If the page was hidden prior to paint time of the entry,\n    // ignore it and mark the metric as final, otherwise add the entry.\n\n    if (value < firstHidden.timeStamp) {\n      metric.value = value;\n      metric.entries.push(entry);\n    } else {\n      metric.isFinal = true;\n    }\n\n    report();\n  };\n\n  var po = observe('largest-contentful-paint', entryHandler);\n\n  if (po) {\n    report = bindReporter(onReport, metric, po, reportAllChanges);\n\n    var onFinal = function onFinal() {\n      if (!metric.isFinal) {\n        po.takeRecords().map(entryHandler);\n        metric.isFinal = true;\n        report();\n      }\n    };\n\n    void whenInput().then(onFinal);\n    onHidden(onFinal, true);\n  }\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { getGlobalObject } from '@sentry/utils';\nimport { initMetric } from './lib/initMetric';\nvar global = getGlobalObject();\n\nvar afterLoad = function afterLoad(callback) {\n  if (document.readyState === 'complete') {\n    // Queue a task so the callback runs after `loadEventEnd`.\n    setTimeout(callback, 0);\n  } else {\n    // Use `pageshow` so the callback runs after `loadEventEnd`.\n    addEventListener('pageshow', callback);\n  }\n};\n\nvar getNavigationEntryFromPerformanceTiming = function getNavigationEntryFromPerformanceTiming() {\n  // Really annoying that TypeScript errors when using `PerformanceTiming`.\n  // Note: browsers that do not support navigation entries will fall back to using performance.timing\n  // (with the timestamps converted from epoch time to DOMHighResTimeStamp).\n  // eslint-disable-next-line deprecation/deprecation\n  var timing = global.performance.timing;\n  var navigationEntry = {\n    entryType: 'navigation',\n    startTime: 0\n  };\n\n  for (var key in timing) {\n    if (key !== 'navigationStart' && key !== 'toJSON') {\n      navigationEntry[key] = Math.max(timing[key] - timing.navigationStart, 0);\n    }\n  }\n\n  return navigationEntry;\n};\n\nexport var getTTFB = function getTTFB(onReport) {\n  var metric = initMetric('TTFB');\n  afterLoad(function () {\n    try {\n      // Use the NavigationTiming L2 entry if available.\n      var navigationEntry = global.performance.getEntriesByType('navigation')[0] || getNavigationEntryFromPerformanceTiming();\n      metric.value = metric.delta = navigationEntry.responseStart;\n      metric.entries = [navigationEntry];\n      metric.isFinal = true;\n      onReport(metric);\n    } catch (error) {// Do nothing.\n    }\n  });\n};","import { __assign, __rest } from \"tslib\";\nimport { browserPerformanceTimeOrigin, getGlobalObject, logger } from '@sentry/utils';\nimport { msToSec } from '../utils';\nimport { getCLS } from './web-vitals/getCLS';\nimport { getFID } from './web-vitals/getFID';\nimport { getLCP } from './web-vitals/getLCP';\nimport { getTTFB } from './web-vitals/getTTFB';\nimport { getFirstHidden } from './web-vitals/lib/getFirstHidden';\nvar global = getGlobalObject();\n/** Class tracking metrics  */\n\nvar MetricsInstrumentation =\n/** @class */\nfunction () {\n  function MetricsInstrumentation() {\n    this._measurements = {};\n    this._performanceCursor = 0;\n\n    if (global && global.performance) {\n      if (global.performance.mark) {\n        global.performance.mark('sentry-tracing-init');\n      }\n\n      this._trackCLS();\n\n      this._trackLCP();\n\n      this._trackFID();\n\n      this._trackTTFB();\n    }\n  }\n  /** Add performance related spans to a transaction */\n\n\n  MetricsInstrumentation.prototype.addPerformanceEntries = function (transaction) {\n    var _this = this;\n\n    if (!global || !global.performance || !global.performance.getEntries || !browserPerformanceTimeOrigin) {\n      // Gatekeeper if performance API not available\n      return;\n    }\n\n    logger.log('[Tracing] Adding & adjusting spans using Performance API');\n    var timeOrigin = msToSec(browserPerformanceTimeOrigin);\n    var entryScriptSrc;\n\n    if (global.document) {\n      // eslint-disable-next-line @typescript-eslint/prefer-for-of\n      for (var i = 0; i < document.scripts.length; i++) {\n        // We go through all scripts on the page and look for 'data-entry'\n        // We remember the name and measure the time between this script finished loading and\n        // our mark 'sentry-tracing-init'\n        if (document.scripts[i].dataset.entry === 'true') {\n          entryScriptSrc = document.scripts[i].src;\n          break;\n        }\n      }\n    }\n\n    var entryScriptStartTimestamp;\n    var tracingInitMarkStartTime;\n    global.performance.getEntries().slice(this._performanceCursor).forEach(function (entry) {\n      var startTime = msToSec(entry.startTime);\n      var duration = msToSec(entry.duration);\n\n      if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n        return;\n      }\n\n      switch (entry.entryType) {\n        case 'navigation':\n          addNavigationSpans(transaction, entry, timeOrigin);\n          break;\n\n        case 'mark':\n        case 'paint':\n        case 'measure':\n          {\n            var startTimestamp = addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n            if (tracingInitMarkStartTime === undefined && entry.name === 'sentry-tracing-init') {\n              tracingInitMarkStartTime = startTimestamp;\n            } // capture web vitals\n\n\n            var firstHidden = getFirstHidden(); // Only report if the page wasn't hidden prior to the web vital.\n\n            var shouldRecord = entry.startTime < firstHidden.timeStamp;\n\n            if (entry.name === 'first-paint' && shouldRecord) {\n              logger.log('[Measurements] Adding FP');\n              _this._measurements['fp'] = {\n                value: entry.startTime\n              };\n              _this._measurements['mark.fp'] = {\n                value: startTimestamp\n              };\n            }\n\n            if (entry.name === 'first-contentful-paint' && shouldRecord) {\n              logger.log('[Measurements] Adding FCP');\n              _this._measurements['fcp'] = {\n                value: entry.startTime\n              };\n              _this._measurements['mark.fcp'] = {\n                value: startTimestamp\n              };\n            }\n\n            break;\n          }\n\n        case 'resource':\n          {\n            var resourceName = entry.name.replace(window.location.origin, '');\n            var endTimestamp = addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin); // We remember the entry script end time to calculate the difference to the first init mark\n\n            if (entryScriptStartTimestamp === undefined && (entryScriptSrc || '').indexOf(resourceName) > -1) {\n              entryScriptStartTimestamp = endTimestamp;\n            }\n\n            break;\n          }\n\n        default: // Ignore other entry types.\n\n      }\n    });\n\n    if (entryScriptStartTimestamp !== undefined && tracingInitMarkStartTime !== undefined) {\n      _startChild(transaction, {\n        description: 'evaluation',\n        endTimestamp: tracingInitMarkStartTime,\n        op: 'script',\n        startTimestamp: entryScriptStartTimestamp\n      });\n    }\n\n    this._performanceCursor = Math.max(performance.getEntries().length - 1, 0);\n\n    this._trackNavigator(transaction); // Measurements are only available for pageload transactions\n\n\n    if (transaction.op === 'pageload') {\n      // normalize applicable web vital values to be relative to transaction.startTimestamp\n      var timeOrigin_1 = msToSec(performance.timeOrigin);\n      ['fcp', 'fp', 'lcp', 'ttfb'].forEach(function (name) {\n        if (!_this._measurements[name] || timeOrigin_1 >= transaction.startTimestamp) {\n          return;\n        } // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n        // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n        // to be adjusted to be relative to transaction.startTimestamp.\n\n\n        var oldValue = _this._measurements[name].value;\n        var measurementTimestamp = timeOrigin_1 + msToSec(oldValue); // normalizedValue should be in milliseconds\n\n        var normalizedValue = (measurementTimestamp - transaction.startTimestamp) * 1000;\n        var delta = normalizedValue - oldValue;\n        logger.log(\"[Measurements] Normalized \" + name + \" from \" + _this._measurements[name].value + \" to \" + normalizedValue + \" (\" + delta + \")\");\n        _this._measurements[name].value = normalizedValue;\n      });\n\n      if (this._measurements['mark.fid'] && this._measurements['fid']) {\n        // create span for FID\n        _startChild(transaction, {\n          description: 'first input delay',\n          endTimestamp: this._measurements['mark.fid'].value + msToSec(this._measurements['fid'].value),\n          op: 'web.vitals',\n          startTimestamp: this._measurements['mark.fid'].value\n        });\n      }\n\n      transaction.setMeasurements(this._measurements);\n    }\n  };\n  /** Starts tracking the Cumulative Layout Shift on the current page. */\n\n\n  MetricsInstrumentation.prototype._trackCLS = function () {\n    var _this = this;\n\n    getCLS(function (metric) {\n      var entry = metric.entries.pop();\n\n      if (!entry) {\n        return;\n      }\n\n      logger.log('[Measurements] Adding CLS');\n      _this._measurements['cls'] = {\n        value: metric.value\n      };\n    });\n  };\n  /**\n   * Capture the information of the user agent.\n   */\n\n\n  MetricsInstrumentation.prototype._trackNavigator = function (transaction) {\n    var navigator = global.navigator;\n\n    if (!navigator) {\n      return;\n    } // track network connectivity\n\n\n    var connection = navigator.connection;\n\n    if (connection) {\n      if (connection.effectiveType) {\n        transaction.setTag('effectiveConnectionType', connection.effectiveType);\n      }\n\n      if (connection.type) {\n        transaction.setTag('connectionType', connection.type);\n      }\n\n      if (isMeasurementValue(connection.rtt)) {\n        this._measurements['connection.rtt'] = {\n          value: connection.rtt\n        };\n      }\n\n      if (isMeasurementValue(connection.downlink)) {\n        this._measurements['connection.downlink'] = {\n          value: connection.downlink\n        };\n      }\n    }\n\n    if (isMeasurementValue(navigator.deviceMemory)) {\n      transaction.setTag('deviceMemory', String(navigator.deviceMemory));\n    }\n\n    if (isMeasurementValue(navigator.hardwareConcurrency)) {\n      transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n    }\n  };\n  /** Starts tracking the Largest Contentful Paint on the current page. */\n\n\n  MetricsInstrumentation.prototype._trackLCP = function () {\n    var _this = this;\n\n    getLCP(function (metric) {\n      var entry = metric.entries.pop();\n\n      if (!entry) {\n        return;\n      }\n\n      var timeOrigin = msToSec(performance.timeOrigin);\n      var startTime = msToSec(entry.startTime);\n      logger.log('[Measurements] Adding LCP');\n      _this._measurements['lcp'] = {\n        value: metric.value\n      };\n      _this._measurements['mark.lcp'] = {\n        value: timeOrigin + startTime\n      };\n    });\n  };\n  /** Starts tracking the First Input Delay on the current page. */\n\n\n  MetricsInstrumentation.prototype._trackFID = function () {\n    var _this = this;\n\n    getFID(function (metric) {\n      var entry = metric.entries.pop();\n\n      if (!entry) {\n        return;\n      }\n\n      var timeOrigin = msToSec(performance.timeOrigin);\n      var startTime = msToSec(entry.startTime);\n      logger.log('[Measurements] Adding FID');\n      _this._measurements['fid'] = {\n        value: metric.value\n      };\n      _this._measurements['mark.fid'] = {\n        value: timeOrigin + startTime\n      };\n    });\n  };\n  /** Starts tracking the Time to First Byte on the current page. */\n\n\n  MetricsInstrumentation.prototype._trackTTFB = function () {\n    var _this = this;\n\n    getTTFB(function (metric) {\n      var _a;\n\n      var entry = metric.entries.pop();\n\n      if (!entry) {\n        return;\n      }\n\n      logger.log('[Measurements] Adding TTFB');\n      _this._measurements['ttfb'] = {\n        value: metric.value\n      }; // Capture the time spent making the request and receiving the first byte of the response\n\n      var requestTime = metric.value - (_a = metric.entries[0], _a !== null && _a !== void 0 ? _a : entry).requestStart;\n      _this._measurements['ttfb.requestTime'] = {\n        value: requestTime\n      };\n    });\n  };\n\n  return MetricsInstrumentation;\n}();\n\nexport { MetricsInstrumentation };\n/** Instrument navigation entries */\n\nfunction addNavigationSpans(transaction, entry, timeOrigin) {\n  addPerformanceNavigationTiming(transaction, entry, 'unloadEvent', timeOrigin);\n  addPerformanceNavigationTiming(transaction, entry, 'redirect', timeOrigin);\n  addPerformanceNavigationTiming(transaction, entry, 'domContentLoadedEvent', timeOrigin);\n  addPerformanceNavigationTiming(transaction, entry, 'loadEvent', timeOrigin);\n  addPerformanceNavigationTiming(transaction, entry, 'connect', timeOrigin);\n  addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'connectEnd');\n  addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'domainLookupStart');\n  addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin);\n  addRequest(transaction, entry, timeOrigin);\n}\n/** Create measure related spans */\n\n\nfunction addMeasureSpans(transaction, entry, startTime, duration, timeOrigin) {\n  var measureStartTimestamp = timeOrigin + startTime;\n  var measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType,\n    startTimestamp: measureStartTimestamp\n  });\n\n  return measureStartTimestamp;\n}\n/** Create resource related spans */\n\n\nexport function addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return undefined;\n  }\n\n  var data = {};\n\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  var startTimestamp = timeOrigin + startTime;\n  var endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp: endTimestamp,\n    op: entry.initiatorType ? \"resource.\" + entry.initiatorType : 'resource',\n    startTimestamp: startTimestamp,\n    data: data\n  });\n\n  return endTimestamp;\n}\n/** Create performance navigation related spans */\n\nfunction addPerformanceNavigationTiming(transaction, entry, event, timeOrigin, eventEnd) {\n  var end = eventEnd ? entry[eventEnd] : entry[event + \"End\"];\n  var start = entry[event + \"Start\"];\n\n  if (!start || !end) {\n    return;\n  }\n\n  _startChild(transaction, {\n    description: event,\n    endTimestamp: timeOrigin + msToSec(end),\n    op: 'browser',\n    startTimestamp: timeOrigin + msToSec(start)\n  });\n}\n/** Create request and response related spans */\n\n\nfunction addRequest(transaction, entry, timeOrigin) {\n  _startChild(transaction, {\n    description: 'request',\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd),\n    op: 'browser',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart)\n  });\n\n  _startChild(transaction, {\n    description: 'response',\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd),\n    op: 'browser',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart)\n  });\n}\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\n\n\nexport function _startChild(transaction, _a) {\n  var startTimestamp = _a.startTimestamp,\n      ctx = __rest(_a, [\"startTimestamp\"]);\n\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild(__assign({\n    startTimestamp: startTimestamp\n  }, ctx));\n}\n/**\n * Checks if a given value is a valid measurement value.\n */\n\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { bindReporter } from './lib/bindReporter';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nexport var getCLS = function getCLS(onReport, reportAllChanges) {\n  if (reportAllChanges === void 0) {\n    reportAllChanges = false;\n  }\n\n  var metric = initMetric('CLS', 0);\n  var report;\n\n  var entryHandler = function entryHandler(entry) {\n    // Only count layout shifts without recent user input.\n    if (!entry.hadRecentInput) {\n      metric.value += entry.value;\n      metric.entries.push(entry);\n      report();\n    }\n  };\n\n  var po = observe('layout-shift', entryHandler);\n\n  if (po) {\n    report = bindReporter(onReport, metric, po, reportAllChanges);\n    onHidden(function (_a) {\n      var isUnloading = _a.isUnloading;\n      po.takeRecords().map(entryHandler);\n\n      if (isUnloading) {\n        metric.isFinal = true;\n      }\n\n      report();\n    });\n  }\n};","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { bindReporter } from './lib/bindReporter';\nimport { getFirstHidden } from './lib/getFirstHidden';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nexport var getFID = function getFID(onReport) {\n  var metric = initMetric('FID');\n  var firstHidden = getFirstHidden();\n\n  var entryHandler = function entryHandler(entry) {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (entry.startTime < firstHidden.timeStamp) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      metric.isFinal = true;\n      report();\n    }\n  };\n\n  var po = observe('first-input', entryHandler);\n  var report = bindReporter(onReport, metric, po);\n\n  if (po) {\n    onHidden(function () {\n      po.takeRecords().map(entryHandler);\n      po.disconnect();\n    }, true);\n  } else {\n    if (window.perfMetrics && window.perfMetrics.onFirstInputDelay) {\n      window.perfMetrics.onFirstInputDelay(function (value, event) {\n        // Only report if the page wasn't hidden prior to the first input.\n        if (event.timeStamp < firstHidden.timeStamp) {\n          metric.value = value;\n          metric.isFinal = true;\n          metric.entries = [{\n            entryType: 'first-input',\n            name: event.type,\n            target: event.target,\n            cancelable: event.cancelable,\n            startTime: event.timeStamp,\n            processingStart: event.timeStamp + value\n          }];\n          report();\n        }\n      });\n    }\n  }\n};","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\nimport { addInstrumentationHandler, isInstanceOf, isMatchingPattern } from '@sentry/utils';\nimport { getActiveTransaction, hasTracingEnabled } from '../utils';\nexport var DEFAULT_TRACING_ORIGINS = ['localhost', /^\\//];\nexport var defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  tracingOrigins: DEFAULT_TRACING_ORIGINS\n};\n/** Registers span creators for xhr and fetch requests  */\n\nexport function registerRequestInstrumentation(_options) {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  var _a = __assign(__assign({}, defaultRequestInstrumentationOptions), _options),\n      traceFetch = _a.traceFetch,\n      traceXHR = _a.traceXHR,\n      tracingOrigins = _a.tracingOrigins,\n      shouldCreateSpanForRequest = _a.shouldCreateSpanForRequest; // We should cache url -> decision so that we don't have to compute\n  // regexp everytime we create a request.\n\n\n  var urlMap = {};\n\n  var defaultShouldCreateSpan = function defaultShouldCreateSpan(url) {\n    if (urlMap[url]) {\n      return urlMap[url];\n    }\n\n    var origins = tracingOrigins;\n    urlMap[url] = origins.some(function (origin) {\n      return isMatchingPattern(url, origin);\n    }) && !isMatchingPattern(url, 'sentry_key');\n    return urlMap[url];\n  }; // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves\n  // That's why we filter out already unwanted Spans from tracingOrigins\n\n\n  var shouldCreateSpan = defaultShouldCreateSpan;\n\n  if (typeof shouldCreateSpanForRequest === 'function') {\n    shouldCreateSpan = function shouldCreateSpan(url) {\n      return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);\n    };\n  }\n\n  var spans = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler({\n      callback: function callback(handlerData) {\n        fetchCallback(handlerData, shouldCreateSpan, spans);\n      },\n      type: 'fetch'\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler({\n      callback: function callback(handlerData) {\n        xhrCallback(handlerData, shouldCreateSpan, spans);\n      },\n      type: 'xhr'\n    });\n  }\n}\n/**\n * Create and track fetch request spans\n */\n\nexport function fetchCallback(handlerData, shouldCreateSpan, spans) {\n  var _a;\n\n  var currentClientOptions = (_a = getCurrentHub().getClient()) === null || _a === void 0 ? void 0 : _a.getOptions();\n\n  if (!(currentClientOptions && hasTracingEnabled(currentClientOptions)) || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp && handlerData.fetchData.__span) {\n    var span = spans[handlerData.fetchData.__span];\n\n    if (span) {\n      var response = handlerData.response;\n\n      if (response) {\n        // TODO (kmclb) remove this once types PR goes through\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        span.setHttpStatus(response.status);\n      }\n\n      span.finish(); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n      delete spans[handlerData.fetchData.__span];\n    }\n\n    return;\n  }\n\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    var span = activeTransaction.startChild({\n      data: __assign(__assign({}, handlerData.fetchData), {\n        type: 'fetch'\n      }),\n      description: handlerData.fetchData.method + \" \" + handlerData.fetchData.url,\n      op: 'http'\n    });\n    handlerData.fetchData.__span = span.spanId;\n    spans[span.spanId] = span;\n    var request = handlerData.args[0] = handlerData.args[0]; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n    var options = handlerData.args[1] = handlerData.args[1] || {};\n    var headers = options.headers;\n\n    if (isInstanceOf(request, Request)) {\n      headers = request.headers;\n    }\n\n    if (headers) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (typeof headers.append === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        headers.append('sentry-trace', span.toTraceparent());\n      } else if (Array.isArray(headers)) {\n        headers = __spread(headers, [['sentry-trace', span.toTraceparent()]]);\n      } else {\n        headers = __assign(__assign({}, headers), {\n          'sentry-trace': span.toTraceparent()\n        });\n      }\n    } else {\n      headers = {\n        'sentry-trace': span.toTraceparent()\n      };\n    }\n\n    options.headers = headers;\n  }\n}\n/**\n * Create and track xhr request spans\n */\n\nexport function xhrCallback(handlerData, shouldCreateSpan, spans) {\n  var _a;\n\n  var currentClientOptions = (_a = getCurrentHub().getClient()) === null || _a === void 0 ? void 0 : _a.getOptions();\n\n  if (!(currentClientOptions && hasTracingEnabled(currentClientOptions)) || !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url)) || handlerData.xhr.__sentry_own_request__) {\n    return;\n  }\n\n  var xhr = handlerData.xhr.__sentry_xhr__; // check first if the request has finished and is tracked by an existing span which should now end\n\n  if (handlerData.endTimestamp && handlerData.xhr.__sentry_xhr_span_id__) {\n    var span = spans[handlerData.xhr.__sentry_xhr_span_id__];\n\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish(); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n      delete spans[handlerData.xhr.__sentry_xhr_span_id__];\n    }\n\n    return;\n  } // if not, create a new span to track it\n\n\n  var activeTransaction = getActiveTransaction();\n\n  if (activeTransaction) {\n    var span = activeTransaction.startChild({\n      data: __assign(__assign({}, xhr.data), {\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url\n      }),\n      description: xhr.method + \" \" + xhr.url,\n      op: 'http'\n    });\n    handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n    if (handlerData.xhr.setRequestHeader) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n      } catch (_) {// Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}","import { addInstrumentationHandler, getGlobalObject, logger } from '@sentry/utils';\nvar global = getGlobalObject();\n/**\n * Default function implementing pageload and navigation transactions\n */\n\nexport function defaultRoutingInstrumentation(startTransaction, startTransactionOnPageLoad, startTransactionOnLocationChange) {\n  if (startTransactionOnPageLoad === void 0) {\n    startTransactionOnPageLoad = true;\n  }\n\n  if (startTransactionOnLocationChange === void 0) {\n    startTransactionOnLocationChange = true;\n  }\n\n  if (!global || !global.location) {\n    logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  var startingUrl = global.location.href;\n  var activeTransaction;\n\n  if (startTransactionOnPageLoad) {\n    activeTransaction = startTransaction({\n      name: global.location.pathname,\n      op: 'pageload'\n    });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler({\n      callback: function callback(_a) {\n        var to = _a.to,\n            from = _a.from;\n        /**\n         * This early return is there to account for some cases where a navigation transaction starts right after\n         * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n         * create an uneccessary navigation transaction.\n         *\n         * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n         * only be caused in certain development environments where the usage of a hot module reloader is causing\n         * errors.\n         */\n\n        if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n          startingUrl = undefined;\n          return;\n        }\n\n        if (from !== to) {\n          startingUrl = undefined;\n\n          if (activeTransaction) {\n            logger.log(\"[Tracing] Finishing current transaction with op: \" + activeTransaction.op); // If there's an open transaction on the scope, we need to finish it before creating an new one.\n\n            activeTransaction.finish();\n          }\n\n          activeTransaction = startTransaction({\n            name: global.location.pathname,\n            op: 'navigation'\n          });\n        }\n      },\n      type: 'history'\n    });\n  }\n}","import { __assign } from \"tslib\";\nimport { logger } from '@sentry/utils';\nimport { startIdleTransaction } from '../hubextensions';\nimport { DEFAULT_IDLE_TIMEOUT } from '../idletransaction';\nimport { SpanStatus } from '../spanstatus';\nimport { extractTraceparentData, secToMs } from '../utils';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { MetricsInstrumentation } from './metrics';\nimport { defaultRequestInstrumentationOptions, registerRequestInstrumentation } from './request';\nimport { defaultRoutingInstrumentation } from './router';\nexport var DEFAULT_MAX_TRANSACTION_DURATION_SECONDS = 600;\n\nvar DEFAULT_BROWSER_TRACING_OPTIONS = __assign({\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  markBackgroundTransactions: true,\n  maxTransactionDuration: DEFAULT_MAX_TRANSACTION_DURATION_SECONDS,\n  routingInstrumentation: defaultRoutingInstrumentation,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true\n}, defaultRequestInstrumentationOptions);\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\n\n\nvar BrowserTracing =\n/** @class */\nfunction () {\n  function BrowserTracing(_options) {\n    /**\n     * @inheritDoc\n     */\n    this.name = BrowserTracing.id;\n    this._metrics = new MetricsInstrumentation();\n    this._emitOptionsWarning = false;\n    var tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins; // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances\n\n    if (_options && _options.tracingOrigins && Array.isArray(_options.tracingOrigins) && _options.tracingOrigins.length !== 0) {\n      tracingOrigins = _options.tracingOrigins;\n    } else {\n      this._emitOptionsWarning = true;\n    }\n\n    this.options = __assign(__assign(__assign({}, DEFAULT_BROWSER_TRACING_OPTIONS), _options), {\n      tracingOrigins: tracingOrigins\n    });\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  BrowserTracing.prototype.setupOnce = function (_, getCurrentHub) {\n    var _this = this;\n\n    this._getCurrentHub = getCurrentHub;\n\n    if (this._emitOptionsWarning) {\n      logger.warn('[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.');\n      logger.warn(\"[Tracing] We added a reasonable default for you: \" + defaultRequestInstrumentationOptions.tracingOrigins);\n    } // eslint-disable-next-line @typescript-eslint/unbound-method\n\n\n    var _a = this.options,\n        routingInstrumentation = _a.routingInstrumentation,\n        startTransactionOnLocationChange = _a.startTransactionOnLocationChange,\n        startTransactionOnPageLoad = _a.startTransactionOnPageLoad,\n        markBackgroundTransactions = _a.markBackgroundTransactions,\n        traceFetch = _a.traceFetch,\n        traceXHR = _a.traceXHR,\n        tracingOrigins = _a.tracingOrigins,\n        shouldCreateSpanForRequest = _a.shouldCreateSpanForRequest;\n    routingInstrumentation(function (context) {\n      return _this._createRouteTransaction(context);\n    }, startTransactionOnPageLoad, startTransactionOnLocationChange);\n\n    if (markBackgroundTransactions) {\n      registerBackgroundTabDetection();\n    }\n\n    registerRequestInstrumentation({\n      traceFetch: traceFetch,\n      traceXHR: traceXHR,\n      tracingOrigins: tracingOrigins,\n      shouldCreateSpanForRequest: shouldCreateSpanForRequest\n    });\n  };\n  /** Create routing idle transaction. */\n\n\n  BrowserTracing.prototype._createRouteTransaction = function (context) {\n    var _this = this;\n\n    if (!this._getCurrentHub) {\n      logger.warn(\"[Tracing] Did not create \" + context.op + \" transaction because _getCurrentHub is invalid.\");\n      return undefined;\n    } // eslint-disable-next-line @typescript-eslint/unbound-method\n\n\n    var _a = this.options,\n        beforeNavigate = _a.beforeNavigate,\n        idleTimeout = _a.idleTimeout,\n        maxTransactionDuration = _a.maxTransactionDuration;\n    var parentContextFromHeader = context.op === 'pageload' ? getHeaderContext() : undefined;\n\n    var expandedContext = __assign(__assign(__assign({}, context), parentContextFromHeader), {\n      trimEnd: true\n    });\n\n    var modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext; // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n    // from being sent to Sentry).\n\n    var finalContext = modifiedContext === undefined ? __assign(__assign({}, expandedContext), {\n      sampled: false\n    }) : modifiedContext;\n\n    if (finalContext.sampled === false) {\n      logger.log(\"[Tracing] Will not send \" + finalContext.op + \" transaction because of beforeNavigate.\");\n    }\n\n    var hub = this._getCurrentHub();\n\n    var idleTransaction = startIdleTransaction(hub, finalContext, idleTimeout, true);\n    logger.log(\"[Tracing] Starting \" + finalContext.op + \" transaction on scope\");\n    idleTransaction.registerBeforeFinishCallback(function (transaction, endTimestamp) {\n      _this._metrics.addPerformanceEntries(transaction);\n\n      adjustTransactionDuration(secToMs(maxTransactionDuration), transaction, endTimestamp);\n    });\n    return idleTransaction;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BrowserTracing.id = 'BrowserTracing';\n  return BrowserTracing;\n}();\n\nexport { BrowserTracing };\n/**\n * Gets transaction context from a sentry-trace meta.\n *\n * @returns Transaction context data from the header or undefined if there's no header or the header is malformed\n */\n\nexport function getHeaderContext() {\n  var header = getMetaContent('sentry-trace');\n\n  if (header) {\n    return extractTraceparentData(header);\n  }\n\n  return undefined;\n}\n/** Returns the value of a meta tag */\n\nexport function getMetaContent(metaName) {\n  var el = document.querySelector(\"meta[name=\" + metaName + \"]\");\n  return el ? el.getAttribute('content') : null;\n}\n/** Adjusts transaction value based on max transaction duration */\n\nfunction adjustTransactionDuration(maxDuration, transaction, endTimestamp) {\n  var diff = endTimestamp - transaction.startTimestamp;\n  var isOutdatedTransaction = endTimestamp && (diff > maxDuration || diff < 0);\n\n  if (isOutdatedTransaction) {\n    transaction.setStatus(SpanStatus.DeadlineExceeded);\n    transaction.setTag('maxTransactionDurationExceeded', 'true');\n  }\n}","import { logger } from '@sentry/utils';\n/**\n * Express integration\n *\n * Provides an request and error handler for Express framework\n * as well as tracing capabilities\n */\n\nvar Express =\n/** @class */\nfunction () {\n  /**\n   * @inheritDoc\n   */\n  function Express(options) {\n    if (options === void 0) {\n      options = {};\n    }\n    /**\n     * @inheritDoc\n     */\n\n\n    this.name = Express.id;\n    this._app = options.app;\n    this._methods = options.methods;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  Express.prototype.setupOnce = function () {\n    if (!this._app) {\n      logger.error('ExpressIntegration is missing an Express instance');\n      return;\n    }\n\n    instrumentMiddlewares(this._app);\n    routeMiddlewares(this._app, this._methods);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Express.id = 'Express';\n  return Express;\n}();\n\nexport { Express };\n/**\n * Wraps original middleware function in a tracing call, which stores the info about the call as a span,\n * and finishes it once the middleware is done invoking.\n *\n * Express middlewares have 3 various forms, thus we have to take care of all of them:\n * // sync\n * app.use(function (req, res) { ... })\n * // async\n * app.use(function (req, res, next) { ... })\n * // error handler\n * app.use(function (err, req, res, next) { ... })\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\n\nfunction wrap(fn) {\n  var arity = fn.length;\n\n  switch (arity) {\n    case 2:\n      {\n        return function (req, res) {\n          var transaction = res.__sentry_transaction;\n          addExpressReqToTransaction(transaction, req);\n\n          if (transaction) {\n            var span_1 = transaction.startChild({\n              description: fn.name,\n              op: 'middleware'\n            });\n            res.once('finish', function () {\n              span_1.finish();\n            });\n          } // eslint-disable-next-line prefer-rest-params\n\n\n          return fn.apply(this, arguments);\n        };\n      }\n\n    case 3:\n      {\n        return function (req, res, next) {\n          var transaction = res.__sentry_transaction;\n          addExpressReqToTransaction(transaction, req);\n          var span = transaction && transaction.startChild({\n            description: fn.name,\n            op: 'middleware'\n          });\n          fn.call(this, req, res, function () {\n            if (span) {\n              span.finish();\n            } // eslint-disable-next-line prefer-rest-params\n\n\n            return next.apply(this, arguments);\n          });\n        };\n      }\n\n    case 4:\n      {\n        return function (err, req, res, next) {\n          var transaction = res.__sentry_transaction;\n          addExpressReqToTransaction(transaction, req);\n          var span = transaction && transaction.startChild({\n            description: fn.name,\n            op: 'middleware'\n          });\n          fn.call(this, err, req, res, function () {\n            if (span) {\n              span.finish();\n            } // eslint-disable-next-line prefer-rest-params\n\n\n            return next.apply(this, arguments);\n          });\n        };\n      }\n\n    default:\n      {\n        throw new Error(\"Express middleware takes 2-4 arguments. Got: \" + arity);\n      }\n  }\n}\n/**\n * Set parameterized as transaction name e.g.: `GET /users/:id`\n * Also adds more context data on the transaction from the request\n */\n\n\nfunction addExpressReqToTransaction(transaction, req) {\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  if (transaction) {\n    if (req.route && req.route.path) {\n      transaction.name = req.method + \" \" + req.route.path;\n    }\n\n    transaction.setData('url', req.originalUrl);\n    transaction.setData('baseUrl', req.baseUrl);\n    transaction.setData('query', req.query);\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n}\n/**\n * Takes all the function arguments passed to the original `app.use` call\n * and wraps every function, as well as array of functions with a call to our `wrap` method.\n * We have to take care of the arrays as well as iterate over all of the arguments,\n * as `app.use` can accept middlewares in few various forms.\n *\n * app.use([<path>], <fn>)\n * app.use([<path>], <fn>, ...<fn>)\n * app.use([<path>], ...<fn>[])\n */\n\n\nfunction wrapUseArgs(args) {\n  return Array.from(args).map(function (arg) {\n    if (typeof arg === 'function') {\n      return wrap(arg);\n    }\n\n    if (Array.isArray(arg)) {\n      return arg.map(function (a) {\n        if (typeof a === 'function') {\n          return wrap(a);\n        }\n\n        return a;\n      });\n    }\n\n    return arg;\n  });\n}\n/**\n * Patches original App to utilize our tracing functionality\n */\n\n\nfunction patchMiddleware(app, method) {\n  var originalAppCallback = app[method];\n\n  app[method] = function () {\n    // eslint-disable-next-line prefer-rest-params\n    return originalAppCallback.apply(this, wrapUseArgs(arguments));\n  };\n\n  return app;\n}\n/**\n * Patches original app.use\n */\n\n\nfunction instrumentMiddlewares(app) {\n  patchMiddleware(app, 'use');\n}\n/**\n * Patches original app.METHOD\n */\n\n\nfunction routeMiddlewares(app, methods) {\n  if (methods === void 0) {\n    methods = [];\n  }\n\n  methods.forEach(function (method) {\n    patchMiddleware(app, method);\n  });\n}","import { __assign } from \"tslib\";\nimport { BrowserTracing } from './browser';\nimport { addExtensionMethods } from './hubextensions';\nimport * as TracingIntegrations from './integrations';\n\nvar Integrations = __assign(__assign({}, TracingIntegrations), {\n  BrowserTracing: BrowserTracing\n});\n\nexport { Integrations };\nexport { Span } from './span';\nexport { Transaction } from './transaction';\nexport { SpanStatus } from './spanstatus'; // We are patching the global object with our hub extension methods\n\naddExtensionMethods();\nexport { addExtensionMethods };\nexport { extractTraceparentData, getActiveTransaction, hasTracingEnabled, stripUrlQueryAndFragment } from './utils';","import { __assign, __extends } from \"tslib\";\nimport { captureException, showReportDialog, withScope } from '@sentry/browser';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\nexport var UNKNOWN_COMPONENT = 'unknown';\nvar INITIAL_STATE = {\n  componentStack: null,\n  error: null,\n  eventId: null\n};\n/**\n * A ErrorBoundary component that logs errors to Sentry.\n * Requires React >= 16\n */\n\nvar ErrorBoundary =\n/** @class */\nfunction (_super) {\n  __extends(ErrorBoundary, _super);\n\n  function ErrorBoundary() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n\n    _this.state = INITIAL_STATE;\n\n    _this.resetErrorBoundary = function () {\n      var onReset = _this.props.onReset;\n      var _a = _this.state,\n          error = _a.error,\n          componentStack = _a.componentStack,\n          eventId = _a.eventId;\n\n      if (onReset) {\n        onReset(error, componentStack, eventId);\n      }\n\n      _this.setState(INITIAL_STATE);\n    };\n\n    return _this;\n  }\n\n  ErrorBoundary.prototype.componentDidCatch = function (error, _a) {\n    var _this = this;\n\n    var componentStack = _a.componentStack;\n    var _b = this.props,\n        beforeCapture = _b.beforeCapture,\n        onError = _b.onError,\n        showDialog = _b.showDialog,\n        dialogOptions = _b.dialogOptions;\n    withScope(function (scope) {\n      if (beforeCapture) {\n        beforeCapture(scope, error, componentStack);\n      }\n\n      var eventId = captureException(error, {\n        contexts: {\n          react: {\n            componentStack: componentStack\n          }\n        }\n      });\n\n      if (onError) {\n        onError(error, componentStack, eventId);\n      }\n\n      if (showDialog) {\n        showReportDialog(__assign(__assign({}, dialogOptions), {\n          eventId: eventId\n        }));\n      } // componentDidCatch is used over getDerivedStateFromError\n      // so that componentStack is accessible through state.\n\n\n      _this.setState({\n        error: error,\n        componentStack: componentStack,\n        eventId: eventId\n      });\n    });\n  };\n\n  ErrorBoundary.prototype.componentDidMount = function () {\n    var onMount = this.props.onMount;\n\n    if (onMount) {\n      onMount();\n    }\n  };\n\n  ErrorBoundary.prototype.componentWillUnmount = function () {\n    var _a = this.state,\n        error = _a.error,\n        componentStack = _a.componentStack,\n        eventId = _a.eventId;\n    var onUnmount = this.props.onUnmount;\n\n    if (onUnmount) {\n      onUnmount(error, componentStack, eventId);\n    }\n  };\n\n  ErrorBoundary.prototype.render = function () {\n    var fallback = this.props.fallback;\n    var _a = this.state,\n        error = _a.error,\n        componentStack = _a.componentStack,\n        eventId = _a.eventId;\n\n    if (error) {\n      if ( /*#__PURE__*/React.isValidElement(fallback)) {\n        return fallback;\n      }\n\n      if (typeof fallback === 'function') {\n        return fallback({\n          error: error,\n          componentStack: componentStack,\n          resetError: this.resetErrorBoundary,\n          eventId: eventId\n        });\n      } // Fail gracefully if no fallback provided\n\n\n      return null;\n    }\n\n    return this.props.children;\n  };\n\n  return ErrorBoundary;\n}(React.Component); // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction withErrorBoundary(WrappedComponent, errorBoundaryOptions) {\n  var componentDisplayName = WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;\n\n  var Wrapped = function Wrapped(props) {\n    return /*#__PURE__*/React.createElement(ErrorBoundary, __assign({}, errorBoundaryOptions), /*#__PURE__*/React.createElement(WrappedComponent, __assign({}, props)));\n  };\n\n  Wrapped.displayName = \"errorBoundary(\" + componentDisplayName + \")\"; // Copy over static methods from Wrapped component to Profiler HOC\n  // See: https://reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\n\n  hoistNonReactStatics(Wrapped, WrappedComponent);\n  return Wrapped;\n}\n\nexport { ErrorBoundary, withErrorBoundary };","import { ApolloClient, InMemoryCache } from '@apollo/client'\n\nconst cache = new InMemoryCache()\nconst csrfToken = document.querySelector('meta[name=csrf-token]')?.getAttribute('content')\nconst options = {\n  uri: '/graphql',\n  credentials: 'same-origin',\n  headers: {\n    'X-CSRF-Token': csrfToken\n  },\n  cache\n}\n\nconst client = new ApolloClient(options)\n\nexport default client\n","import React, { Suspense } from 'react'\nimport * as Sentry from '@sentry/react'\nimport { Integrations } from '@sentry/tracing'\nimport { ApolloProvider } from '@apollo/client'\nimport {\n  Router,\n  Switch,\n  Route,\n} from 'react-router-dom'\nimport { createBrowserHistory } from 'history'\nimport client from './apollo'\nimport { retry } from 'shared/router'\nimport Fallback from 'app/components/page/Fallback'\n\nSentry.init({\n  dsn: \"https://006e8645eca74558a83ab7c1afbe671d@o427415.ingest.sentry.io/5371428\",\n  integrations: [\n    new Integrations.BrowserTracing(),\n  ],\n  // We recommend adjusting this value in production, or using tracesSampler\n  // for finer control\n  tracesSampleRate: 1.0,\n  // debug: true,\n  // beforeSend(event, hint) {\n  //   // Check if it is an exception, and if so, show the report dialog\n  //   if (event.exception) {\n  //     Sentry.showReportDialog({ eventId: event.event_id });\n  //   }\n  //   return event;\n  // }\n});\n\nconst history = createBrowserHistory()\nhistory.listen((location) => {\n  const page_path = location.pathname + location.search\n  if (window.gtag) {\n    gtag('config', 'UA-174013500-1', { page_path });\n  }\n})\n\nconst HomePage = React.lazy(() => retry(() => import('app/pages/HomePage')))\nconst ApplyPage = React.lazy(() => retry(() => import('app/pages/ApplyPage')))\nconst PrivacyPolicyPage = React.lazy(() => retry(() => import('app/pages/PrivacyPolicyPage')))\nconst TermsOfServicePage = React.lazy(() => retry(() => import('app/pages/TermsOfServicePage')))\nconst CheckHumanPage = React.lazy(() => retry(() => import('app/pages/check/HumanPage')))\nconst CheckWhoPage = React.lazy(() => retry(() => import('app/pages/check/WhoPage')))\nconst CheckResumePage = React.lazy(() => retry(() => import('app/pages/check/ResumePage')))\nconst CheckRemotePage = React.lazy(() => retry(() => import('app/pages/check/RemotePage')))\nconst CheckDevicePage = React.lazy(() => retry(() => import('app/pages/check/DevicePage')))\nconst CheckBrowserPage = React.lazy(() => retry(() => import('app/pages/check/BrowserPage')))\nconst CheckNetworkPage = React.lazy(() => retry(() => import('app/pages/check/NetworkPage')))\nconst CheckSystemPage = React.lazy(() => retry(() => import('app/pages/check/SystemPage')))\n// const CheckAudioPage = React.lazy(() => retry(() => import('app/pages/check/AudioPage')))\nconst CheckMicrophonePage = React.lazy(() => retry(() => import('app/pages/check/MicrophonePage')))\nconst CheckMediaPage = React.lazy(() => retry(() => import('app/pages/check/MediaPage')))\nconst CheckScriptPage = React.lazy(() => retry(() => import('app/pages/check/ScriptPage')))\nconst CheckWhyPage = React.lazy(() => retry(() => import('app/pages/check/WhyPage')))\nconst CheckUnitPricePage = React.lazy(() => retry(() => import('app/pages/check/UnitPricePage')))\nconst CheckCopyPastePage = React.lazy(() => retry(() => import('app/pages/check/CopyPastePage')))\nconst CheckListeningPage = React.lazy(() => retry(() => import('app/pages/check/ListeningPage')))\nconst CheckEducationLevelPage = React.lazy(() => retry(() => import('app/pages/check/EducationLevelPage')))\nconst CheckWorkAuthorizationPage = React.lazy(() => retry(() => import('app/pages/check/WorkAuthorizationPage')))\nconst CheckCompletePage = React.lazy(() => retry(() => import('app/pages/check/CompletePage')))\nconst AssessmentShowPage = React.lazy(() => retry(() => import('app/pages/assessments/ShowPage')))\nconst NotFoundPage = React.lazy(() => retry(() => import('app/pages/NotFoundPage')))\n\nconst AssessmentHumanPage = React.lazy(() => retry(() => import('app/pages/assessment/HumanPage')))\nconst AssessmentCandidatePage = React.lazy(() => retry(() => import('app/pages/assessment/CandidatePage')))\nconst AssessmentResumePage = React.lazy(() => retry(() => import('app/pages/assessment/ResumePage')))\nconst AssessmentQuestionPage = React.lazy(() => retry(() => import('app/pages/assessment/QuestionPage')))\nconst AssessmentCompletePage = React.lazy(() => retry(() => import('app/pages/assessment/CompletePage')))\n\nconst App = () => (\n  <Sentry.ErrorBoundary fallback={\"An error has occurred\"} showDialog>\n    <ApolloProvider client={client}>\n      <Router history={history}>\n        <Suspense fallback={<Fallback/>}>\n          <Switch>\n            <Route path=\"/assessment/human\" component={AssessmentHumanPage}/>\n            <Route path=\"/assessment/candidate\" component={AssessmentCandidatePage}/>\n            <Route path=\"/assessment/resume\" component={AssessmentResumePage}/>\n            <Route path=\"/assessment/question/:position\" component={AssessmentQuestionPage}/>\n            <Route path=\"/assessment/complete\" component={AssessmentCompletePage}/>\n\n            <Route path=\"/check/human\" component={CheckHumanPage}/>\n            <Route path=\"/check/who\" component={CheckWhoPage}/>\n            <Route path=\"/check/resume*\" component={CheckResumePage}/>\n            <Route path=\"/check/remote*\" component={CheckRemotePage}/>\n            <Route path=\"/check/device*\" component={CheckDevicePage}/>\n            <Route path=\"/check/browser*\" component={CheckBrowserPage}/>\n            <Route path=\"/check/network*\" component={CheckNetworkPage}/>\n            <Route path=\"/check/system*\" component={CheckSystemPage}/>\n            {/* <Route path=\"/check/audio*\" component={CheckAudioPage}/> */}\n            <Route path=\"/check/microphone*\" component={CheckMicrophonePage}/>\n            <Route path=\"/check/media*\" component={CheckMediaPage}/>\n            <Route path=\"/check/script*\" component={CheckScriptPage}/>\n            <Route path=\"/check/why*\" component={CheckWhyPage}/>\n            <Route path=\"/check/unit_price*\" component={CheckUnitPricePage}/>\n            <Route path=\"/check/copy_paste*\" component={CheckCopyPastePage}/>\n            <Route path=\"/check/listening*\" component={CheckListeningPage}/>\n            <Route path=\"/check/education_level*\" component={CheckEducationLevelPage}/>\n            <Route path=\"/check/work_authorization*\" component={CheckWorkAuthorizationPage}/>\n            <Route path=\"/check/complete\" component={CheckCompletePage}/>\n            <Route path=\"/assessments/:id\" component={AssessmentShowPage}/>\n            <Route path=\"/apply\" component={ApplyPage}/>\n            <Route path=\"/privacy\" component={PrivacyPolicyPage}/>\n            <Route path=\"/terms\" component={TermsOfServicePage}/>\n            <Route path=\"/\" exact component={HomePage} />\n            <Route component={NotFoundPage} />\n          </Switch>\n        </Suspense>\n      </Router>\n    </ApolloProvider>\n  </Sentry.ErrorBoundary>\n)\n\nexport default App\n","import React from 'react'\nimport ReactDOM from 'react-dom'\nimport * as Sentry from '@sentry/react'\nimport { Integrations } from '@sentry/tracing'\n// import Bugsnag from '@bugsnag/js'\n// import BugsnagPluginReact from '@bugsnag/plugin-react'\nimport App from '../app'\nimport { writeIfNotExists, writeUrlIfParamsPresent } from '../app/lib/storage'\n\nimport '../app/styles/index.scss'\n\nconsole.log('~~~ PerfectJob ~~~')\nSentry.init({\n  dsn: \"https://25e45f265886436bbcf3843793614f26@o253822.ingest.sentry.io/5450694\",\n  integrations: [\n    new Integrations.BrowserTracing(),\n  ],\n\n  // We recommend adjusting this value in production, or using tracesSampler\n  // for finer control\n  tracesSampleRate: 1.0,\n})\n\n\n// Bugsnag.start({\n//   appType: 'client',\n//   appVersion: process.env.SOURCE_VERSION,\n//   apiKey: 'e64ac2cbbcb52c019cb8cfcf9f772585',\n//   plugins: [new BugsnagPluginReact()],\n//   // releaseStage: process.env.NODE_ENV\n//   enabledReleaseStages: [ 'production', 'staging' ],\n// })\n// const ErrorBoundary = Bugsnag.getPlugin('react').createErrorBoundary(React)\n\n// TRACKING - RUNS ONCE ON PAGE LOAD\nwriteIfNotExists('lurl', window.location.href)\nwriteIfNotExists('rurl', window.document.referrer)\nwriteUrlIfParamsPresent('aurl')\n\ndocument.addEventListener('DOMContentLoaded', () => {\n  ReactDOM.render(\n    // <ErrorBoundary><App /></ErrorBoundary>,\n    <App />,\n    document.body.appendChild(document.createElement('div')),\n  )\n})\n","import Cookies from 'js-cookie'\n\nexport const write = (key, value) => {\n  try {\n    sessionStorage.setItem(key, value || '')\n  } catch (e) {\n    // Session Storage Failed: Fallback to Cookies\n    Cookies.set(key, value || '')\n  }\n}\n\nexport const read = (key, defaultValue) => {\n  let value = undefined\n  try {\n    value = sessionStorage.getItem(key)\n  } catch (e) {\n    // Session Storage Failed: Fallback to Cookies\n    value = Cookies.get(key)\n  }\n  if (value && value.length > 0) {\n    return value\n  }\n  return defaultValue\n}\n\nexport const destroy = (key) => {\n  try {\n    window.sessionStorage.removeItem(key)\n  } catch (e) {\n    Cookies.remove(key)\n  }\n}\n\nexport const writeIfNotExists = (key, value) => {\n  if (!read(key)) {\n    write(key, value)\n  }\n}\n\nexport const writeUrlIfParamsPresent = (key) => {\n  const params = new URLSearchParams(window.location.search)\n  const hasParams = (params.has('o') && (params.get('o') || '').trim().length > 0) ||\n    (params.has('j') && (params.get('j') || '').trim().length > 0) ||\n    (params.has('jc') && (params.get('jc') || '').trim().length > 0)\n  if (hasParams) {\n    write(key, window.location.href)\n  }\n}\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*!\n * JavaScript Cookie v2.2.1\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;\n\n(function (factory) {\n  var registeredInModuleLoader;\n\n  if (typeof define === 'function' && define.amd) {\n    define(factory);\n    registeredInModuleLoader = true;\n  }\n\n  if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object') {\n    module.exports = factory();\n    registeredInModuleLoader = true;\n  }\n\n  if (!registeredInModuleLoader) {\n    var OldCookies = window.Cookies;\n    var api = window.Cookies = factory();\n\n    api.noConflict = function () {\n      window.Cookies = OldCookies;\n      return api;\n    };\n  }\n})(function () {\n  function extend() {\n    var i = 0;\n    var result = {};\n\n    for (; i < arguments.length; i++) {\n      var attributes = arguments[i];\n\n      for (var key in attributes) {\n        result[key] = attributes[key];\n      }\n    }\n\n    return result;\n  }\n\n  function decode(s) {\n    return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);\n  }\n\n  function init(converter) {\n    function api() {}\n\n    function set(key, value, attributes) {\n      if (typeof document === 'undefined') {\n        return;\n      }\n\n      attributes = extend({\n        path: '/'\n      }, api.defaults, attributes);\n\n      if (typeof attributes.expires === 'number') {\n        attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5);\n      } // We're using \"expires\" because \"max-age\" is not supported by IE\n\n\n      attributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n      try {\n        var result = JSON.stringify(value);\n\n        if (/^[\\{\\[]/.test(result)) {\n          value = result;\n        }\n      } catch (e) {}\n\n      value = converter.write ? converter.write(value, key) : encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n      key = encodeURIComponent(String(key)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[\\(\\)]/g, escape);\n      var stringifiedAttributes = '';\n\n      for (var attributeName in attributes) {\n        if (!attributes[attributeName]) {\n          continue;\n        }\n\n        stringifiedAttributes += '; ' + attributeName;\n\n        if (attributes[attributeName] === true) {\n          continue;\n        } // Considers RFC 6265 section 5.2:\n        // ...\n        // 3.  If the remaining unparsed-attributes contains a %x3B (\";\")\n        //     character:\n        // Consume the characters of the unparsed-attributes up to,\n        // not including, the first %x3B (\";\") character.\n        // ...\n\n\n        stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];\n      }\n\n      return document.cookie = key + '=' + value + stringifiedAttributes;\n    }\n\n    function get(key, json) {\n      if (typeof document === 'undefined') {\n        return;\n      }\n\n      var jar = {}; // To prevent the for loop in the first place assign an empty array\n      // in case there are no cookies at all.\n\n      var cookies = document.cookie ? document.cookie.split('; ') : [];\n      var i = 0;\n\n      for (; i < cookies.length; i++) {\n        var parts = cookies[i].split('=');\n        var cookie = parts.slice(1).join('=');\n\n        if (!json && cookie.charAt(0) === '\"') {\n          cookie = cookie.slice(1, -1);\n        }\n\n        try {\n          var name = decode(parts[0]);\n          cookie = (converter.read || converter)(cookie, name) || decode(cookie);\n\n          if (json) {\n            try {\n              cookie = JSON.parse(cookie);\n            } catch (e) {}\n          }\n\n          jar[name] = cookie;\n\n          if (key === name) {\n            break;\n          }\n        } catch (e) {}\n      }\n\n      return key ? jar[key] : jar;\n    }\n\n    api.set = set;\n\n    api.get = function (key) {\n      return get(key, false\n      /* read as raw */\n      );\n    };\n\n    api.getJSON = function (key) {\n      return get(key, true\n      /* read as json */\n      );\n    };\n\n    api.remove = function (key, attributes) {\n      set(key, '', extend(attributes, {\n        expires: -1\n      }));\n    };\n\n    api.defaults = {};\n    api.withConverter = init;\n    return api;\n  }\n\n  return init(function () {});\n});","import { __assign } from \"tslib\";\nimport { dropUndefinedKeys, timestampWithMs, uuid4 } from '@sentry/utils';\nimport { SpanStatus } from './spanstatus';\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\n\nvar SpanRecorder =\n/** @class */\nfunction () {\n  function SpanRecorder(maxlen) {\n    if (maxlen === void 0) {\n      maxlen = 1000;\n    }\n\n    this.spans = [];\n    this._maxlen = maxlen;\n  }\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n\n\n  SpanRecorder.prototype.add = function (span) {\n    if (this.spans.length > this._maxlen) {\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  };\n\n  return SpanRecorder;\n}();\n\nexport { SpanRecorder };\n/**\n * Span contains all data about a span\n */\n\nvar Span =\n/** @class */\nfunction () {\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  function Span(spanContext) {\n    /**\n     * @inheritDoc\n     */\n    this.traceId = uuid4();\n    /**\n     * @inheritDoc\n     */\n\n    this.spanId = uuid4().substring(16);\n    /**\n     * Timestamp in seconds when the span was created.\n     */\n\n    this.startTimestamp = timestampWithMs();\n    /**\n     * @inheritDoc\n     */\n\n    this.tags = {};\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n    this.data = {};\n\n    if (!spanContext) {\n      return this;\n    }\n\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    } // We want to include booleans as well here\n\n\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n  }\n  /**\n   * @inheritDoc\n   * @deprecated\n   */\n\n\n  Span.prototype.child = function (spanContext) {\n    return this.startChild(spanContext);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.startChild = function (spanContext) {\n    var childSpan = new Span(__assign(__assign({}, spanContext), {\n      parentSpanId: this.spanId,\n      sampled: this.sampled,\n      traceId: this.traceId\n    }));\n    childSpan.spanRecorder = this.spanRecorder;\n\n    if (childSpan.spanRecorder) {\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    childSpan.transaction = this.transaction;\n    return childSpan;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.setTag = function (key, value) {\n    var _a;\n\n    this.tags = __assign(__assign({}, this.tags), (_a = {}, _a[key] = value, _a));\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n\n  Span.prototype.setData = function (key, value) {\n    var _a;\n\n    this.data = __assign(__assign({}, this.data), (_a = {}, _a[key] = value, _a));\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.setStatus = function (value) {\n    this.status = value;\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.setHttpStatus = function (httpStatus) {\n    this.setTag('http.status_code', String(httpStatus));\n    var spanStatus = SpanStatus.fromHttpCode(httpStatus);\n\n    if (spanStatus !== SpanStatus.UnknownError) {\n      this.setStatus(spanStatus);\n    }\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.isSuccess = function () {\n    return this.status === SpanStatus.Ok;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.finish = function (endTimestamp) {\n    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.toTraceparent = function () {\n    var sampledString = '';\n\n    if (this.sampled !== undefined) {\n      sampledString = this.sampled ? '-1' : '-0';\n    }\n\n    return this.traceId + \"-\" + this.spanId + sampledString;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.getTraceContext = function () {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      trace_id: this.traceId\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.toJSON = function () {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      start_timestamp: this.startTimestamp,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this.endTimestamp,\n      trace_id: this.traceId\n    });\n  };\n\n  return Span;\n}();\n\nexport { Span };","import { __assign, __extends } from \"tslib\";\nimport { getCurrentHub, Hub } from '@sentry/hub';\nimport { isInstanceOf, logger } from '@sentry/utils';\nimport { Span as SpanClass, SpanRecorder } from './span';\n/** JSDoc */\n\nvar Transaction =\n/** @class */\nfunction (_super) {\n  __extends(Transaction, _super);\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n\n\n  function Transaction(transactionContext, hub) {\n    var _this = _super.call(this, transactionContext) || this;\n\n    _this._measurements = {};\n    /**\n     * The reference to the current hub.\n     */\n\n    _this._hub = getCurrentHub();\n\n    if (isInstanceOf(hub, Hub)) {\n      _this._hub = hub;\n    }\n\n    _this.name = transactionContext.name ? transactionContext.name : '';\n    _this._trimEnd = transactionContext.trimEnd; // this is because transactions are also spans, and spans have a transaction pointer\n\n    _this.transaction = _this;\n    return _this;\n  }\n  /**\n   * JSDoc\n   */\n\n\n  Transaction.prototype.setName = function (name) {\n    this.name = name;\n  };\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n\n\n  Transaction.prototype.initSpanRecorder = function (maxlen) {\n    if (maxlen === void 0) {\n      maxlen = 1000;\n    }\n\n    if (!this.spanRecorder) {\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n\n    this.spanRecorder.add(this);\n  };\n  /**\n   * Set observed measurements for this transaction.\n   * @hidden\n   */\n\n\n  Transaction.prototype.setMeasurements = function (measurements) {\n    this._measurements = __assign({}, measurements);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Transaction.prototype.finish = function (endTimestamp) {\n    var _this = this; // This transaction is already finished, so we should not flush it again.\n\n\n    if (this.endTimestamp !== undefined) {\n      return undefined;\n    }\n\n    if (!this.name) {\n      logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this.name = '<unlabeled transaction>';\n    } // just sets the end timestamp\n\n\n    _super.prototype.finish.call(this, endTimestamp);\n\n    if (this.sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n      return undefined;\n    }\n\n    var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(function (s) {\n      return s !== _this && s.endTimestamp;\n    }) : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      this.endTimestamp = finishedSpans.reduce(function (prev, current) {\n        if (prev.endTimestamp && current.endTimestamp) {\n          return prev.endTimestamp > current.endTimestamp ? prev : current;\n        }\n\n        return prev;\n      }).endTimestamp;\n    }\n\n    var transaction = {\n      contexts: {\n        trace: this.getTraceContext()\n      },\n      spans: finishedSpans,\n      start_timestamp: this.startTimestamp,\n      tags: this.tags,\n      timestamp: this.endTimestamp,\n      transaction: this.name,\n      type: 'transaction'\n    };\n    var hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      logger.log('[Measurements] Adding measurements to transaction', JSON.stringify(this._measurements, undefined, 2));\n      transaction.measurements = this._measurements;\n    }\n\n    return this._hub.captureEvent(transaction);\n  };\n\n  return Transaction;\n}(SpanClass);\n\nexport { Transaction };","import { read, write, destroy } from 'app/lib/storage'\n\n// Automatically Refresh the page if a script fails to load, which should resolve\n// the issue, but its also risky...as it could go into a refresh loop. The right \n// way to handle this is probably with service workers, but its much more complex.\n// const retry = (fn) => new Promise((resolve, reject) => fn().then(resolve).catch(() => window.location.reload()))\nexport const retry = (fn) => {\n  return new Promise((resolve, reject) => {\n    fn().then((...args) => {\n      destroy('retried')\n      resolve(...args)\n    }).catch((e) => {\n      if (read('retried')) {\n        reject(e)\n      } else {\n        write('retried', '1')\n        window.location.reload()\n      }\n    })\n  })\n}\n","const Fallback = () => (\n  <div id=\"jsPreloader\" className=\"page-preloader\">\n    <div className=\"page-preloader-content-centered\">\n      <div className=\"spinner-grow text-primary\" role=\"status\">\n        <span className=\"sr-only\">Loading...</span>\n      </div>\n    </div>\n  </div>\n)\n\nexport default Fallback\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport { __assign } from \"tslib\";\nimport { getActiveDomain, getMainCarrier } from '@sentry/hub';\nimport { dynamicRequire, extractNodeRequestData, getGlobalObject, isInstanceOf, isNodeEnv, logger } from '@sentry/utils';\nimport { registerErrorInstrumentation } from './errors';\nimport { IdleTransaction } from './idletransaction';\nimport { Transaction } from './transaction';\nimport { hasTracingEnabled } from './utils';\n/** Returns all trace headers that are currently on the top scope. */\n\nfunction traceHeaders() {\n  var scope = this.getScope();\n\n  if (scope) {\n    var span = scope.getSpan();\n\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent()\n      };\n    }\n  }\n\n  return {};\n}\n/**\n * Implements sampling inheritance and falls back to user-provided static rate if no parent decision is available.\n *\n * @param parentSampled: The parent transaction's sampling decision, if any.\n * @param givenRate: The rate to use if no parental decision is available.\n *\n * @returns The parent's sampling decision (if one exists), or the provided static rate\n */\n\n\nfunction _inheritOrUseGivenRate(parentSampled, givenRate) {\n  return parentSampled !== undefined ? parentSampled : givenRate;\n}\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param hub: The hub off of which to read config options\n * @param transaction: The transaction needing a sampling decision\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\n\n\nfunction sample(hub, transaction, samplingContext) {\n  var _a;\n\n  var client = hub.getClient();\n  var options = client && client.getOptions() || {}; // nothing to do if there's no client or if tracing is disabled\n\n  if (!client || !hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  } // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n\n\n  if (transaction.sampled !== undefined) {\n    return transaction;\n  } // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n\n\n  var sampleRate = typeof options.tracesSampler === 'function' ? options.tracesSampler(samplingContext) : _inheritOrUseGivenRate(samplingContext.parentSampled, options.tracesSampleRate); // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n\n  if (!isValidSampleRate(sampleRate)) {\n    logger.warn(\"[Tracing] Discarding transaction because of invalid sample rate.\");\n    transaction.sampled = false;\n    return transaction;\n  } // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n\n\n  if (!sampleRate) {\n    logger.log(\"[Tracing] Discarding transaction because \" + (typeof options.tracesSampler === 'function' ? 'tracesSampler returned 0 or false' : 'tracesSampleRate is set to 0'));\n    transaction.sampled = false;\n    return transaction;\n  } // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n\n\n  transaction.sampled = Math.random() < sampleRate; // if we're not going to keep it, we're done\n\n  if (!transaction.sampled) {\n    logger.log(\"[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = \" + Number(sampleRate) + \")\");\n    return transaction;\n  } // at this point we know we're keeping the transaction, whether because of an inherited decision or because it got\n  // lucky with the dice roll\n\n\n  transaction.initSpanRecorder((_a = options._experiments) === null || _a === void 0 ? void 0 : _a.maxSpans);\n  logger.log(\"[Tracing] starting \" + transaction.op + \" transaction - \" + transaction.name);\n  return transaction;\n}\n/**\n * Gets the correct context to pass to the tracesSampler, based on the environment (i.e., which SDK is being used)\n *\n * @returns The default sample context\n */\n\n\nfunction getDefaultSamplingContext(transactionContext) {\n  // promote parent sampling decision (if any) for easy access\n  var parentSampled = transactionContext.parentSampled;\n  var defaultSamplingContext = {\n    transactionContext: transactionContext,\n    parentSampled: parentSampled\n  };\n\n  if (isNodeEnv()) {\n    var domain = getActiveDomain();\n\n    if (domain) {\n      // for all node servers that we currently support, we store the incoming request object (which is an instance of\n      // http.IncomingMessage) on the domain\n      // the domain members are stored as an array, so our only way to find the request is to iterate through the array\n      // and compare types\n      var nodeHttpModule = dynamicRequire(module, 'http'); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n      var requestType_1 = nodeHttpModule.IncomingMessage;\n      var request = domain.members.find(function (member) {\n        return isInstanceOf(member, requestType_1);\n      });\n\n      if (request) {\n        defaultSamplingContext.request = extractNodeRequestData(request);\n      }\n    }\n  } // we must be in browser-js (or some derivative thereof)\n  else {\n      // we use `getGlobalObject()` rather than `window` since service workers also have a `location` property on `self`\n      var globalObject = getGlobalObject();\n\n      if ('location' in globalObject) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n        defaultSamplingContext.location = __assign({}, globalObject.location);\n      }\n    }\n\n  return defaultSamplingContext;\n}\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\n\n\nfunction isValidSampleRate(rate) {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    logger.warn(\"[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got \" + JSON.stringify(rate) + \" of type \" + JSON.stringify(_typeof(rate)) + \".\");\n    return false;\n  } // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n\n\n  if (rate < 0 || rate > 1) {\n    logger.warn(\"[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got \" + rate + \".\");\n    return false;\n  }\n\n  return true;\n}\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\n\n\nfunction _startTransaction(transactionContext, customSamplingContext) {\n  var transaction = new Transaction(transactionContext, this);\n  return sample(this, transaction, __assign(__assign({}, getDefaultSamplingContext(transactionContext)), customSamplingContext));\n}\n/**\n * Create new idle transaction.\n */\n\n\nexport function startIdleTransaction(hub, transactionContext, idleTimeout, onScope) {\n  var transaction = new IdleTransaction(transactionContext, hub, idleTimeout, onScope);\n  return sample(hub, transaction, getDefaultSamplingContext(transactionContext));\n}\n/**\n * @private\n */\n\nexport function _addTracingExtensions() {\n  var carrier = getMainCarrier();\n\n  if (carrier.__SENTRY__) {\n    carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n\n    if (!carrier.__SENTRY__.extensions.startTransaction) {\n      carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n    }\n\n    if (!carrier.__SENTRY__.extensions.traceHeaders) {\n      carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n    }\n  }\n}\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\n\nexport function addExtensionMethods() {\n  _addTracingExtensions(); // If an error happens globally, we should make sure transaction status is set to error.\n\n\n  registerErrorInstrumentation();\n}","import { getCurrentHub } from '@sentry/hub';\nexport var TRACEPARENT_REGEXP = new RegExp('^[ \\\\t]*' + // whitespace\n'([0-9a-f]{32})?' + // trace_id\n'-?([0-9a-f]{16})?' + // span_id\n'-?([01])?' + // sampled\n'[ \\\\t]*$');\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\n\nexport function hasTracingEnabled(options) {\n  return 'tracesSampleRate' in options || 'tracesSampler' in options;\n}\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\n\nexport function extractTraceparentData(traceparent) {\n  var matches = traceparent.match(TRACEPARENT_REGEXP);\n\n  if (matches) {\n    var parentSampled = void 0;\n\n    if (matches[3] === '1') {\n      parentSampled = true;\n    } else if (matches[3] === '0') {\n      parentSampled = false;\n    }\n\n    return {\n      traceId: matches[1],\n      parentSampled: parentSampled,\n      parentSpanId: matches[2]\n    };\n  }\n\n  return undefined;\n}\n/** Grabs active transaction off scope, if any */\n\nexport function getActiveTransaction(hub) {\n  if (hub === void 0) {\n    hub = getCurrentHub();\n  }\n\n  var _a, _b;\n\n  return (_b = (_a = hub) === null || _a === void 0 ? void 0 : _a.getScope()) === null || _b === void 0 ? void 0 : _b.getTransaction();\n}\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\n\nexport function msToSec(time) {\n  return time / 1000;\n}\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\n\nexport function secToMs(time) {\n  return time * 1000;\n} // so it can be used in manual instrumentation without necessitating a hard dependency on @sentry/utils\n\nexport { stripUrlQueryAndFragment } from '@sentry/utils';","import { __extends, __values } from \"tslib\";\nimport { logger, timestampWithMs } from '@sentry/utils';\nimport { SpanRecorder } from './span';\nimport { SpanStatus } from './spanstatus';\nimport { Transaction } from './transaction';\nexport var DEFAULT_IDLE_TIMEOUT = 1000;\n/**\n * @inheritDoc\n */\n\nvar IdleTransactionSpanRecorder =\n/** @class */\nfunction (_super) {\n  __extends(IdleTransactionSpanRecorder, _super);\n\n  function IdleTransactionSpanRecorder(_pushActivity, _popActivity, transactionSpanId, maxlen) {\n    if (transactionSpanId === void 0) {\n      transactionSpanId = '';\n    }\n\n    var _this = _super.call(this, maxlen) || this;\n\n    _this._pushActivity = _pushActivity;\n    _this._popActivity = _popActivity;\n    _this.transactionSpanId = transactionSpanId;\n    return _this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  IdleTransactionSpanRecorder.prototype.add = function (span) {\n    var _this = this; // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n\n\n    if (span.spanId !== this.transactionSpanId) {\n      // We patch span.finish() to pop an activity after setting an endTimestamp.\n      span.finish = function (endTimestamp) {\n        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n\n        _this._popActivity(span.spanId);\n      }; // We should only push new activities if the span does not have an end timestamp.\n\n\n      if (span.endTimestamp === undefined) {\n        this._pushActivity(span.spanId);\n      }\n    }\n\n    _super.prototype.add.call(this, span);\n  };\n\n  return IdleTransactionSpanRecorder;\n}(SpanRecorder);\n\nexport { IdleTransactionSpanRecorder };\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\n\nvar IdleTransaction =\n/** @class */\nfunction (_super) {\n  __extends(IdleTransaction, _super);\n\n  function IdleTransaction(transactionContext, _idleHub, // The time to wait in ms until the idle transaction will be finished. Default: 1000\n  _idleTimeout, // If an idle transaction should be put itself on and off the scope automatically.\n  _onScope) {\n    if (_idleTimeout === void 0) {\n      _idleTimeout = DEFAULT_IDLE_TIMEOUT;\n    }\n\n    if (_onScope === void 0) {\n      _onScope = false;\n    }\n\n    var _this = _super.call(this, transactionContext, _idleHub) || this;\n\n    _this._idleHub = _idleHub;\n    _this._idleTimeout = _idleTimeout;\n    _this._onScope = _onScope; // Activities store a list of active spans\n\n    _this.activities = {}; // Stores reference to the timeout that calls _beat().\n\n    _this._heartbeatTimer = 0; // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n\n    _this._heartbeatCounter = 0; // We should not use heartbeat if we finished a transaction\n\n    _this._finished = false;\n    _this._beforeFinishCallbacks = [];\n\n    if (_idleHub && _onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub); // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n\n      logger.log(\"Setting idle transaction on scope. Span ID: \" + _this.spanId);\n\n      _idleHub.configureScope(function (scope) {\n        return scope.setSpan(_this);\n      });\n    }\n\n    return _this;\n  }\n  /** {@inheritDoc} */\n\n\n  IdleTransaction.prototype.finish = function (endTimestamp) {\n    var e_1, _a;\n\n    var _this = this;\n\n    if (endTimestamp === void 0) {\n      endTimestamp = timestampWithMs();\n    }\n\n    this._finished = true;\n    this.activities = {};\n\n    if (this.spanRecorder) {\n      logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n      try {\n        for (var _b = __values(this._beforeFinishCallbacks), _c = _b.next(); !_c.done; _c = _b.next()) {\n          var callback = _c.value;\n          callback(this, endTimestamp);\n        }\n      } catch (e_1_1) {\n        e_1 = {\n          error: e_1_1\n        };\n      } finally {\n        try {\n          if (_c && !_c.done && (_a = _b[\"return\"])) _a.call(_b);\n        } finally {\n          if (e_1) throw e_1.error;\n        }\n      }\n\n      this.spanRecorder.spans = this.spanRecorder.spans.filter(function (span) {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanId === _this.spanId) {\n          return true;\n        } // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n\n\n        if (!span.endTimestamp) {\n          span.endTimestamp = endTimestamp;\n          span.setStatus(SpanStatus.Cancelled);\n          logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        var keepSpan = span.startTimestamp < endTimestamp;\n\n        if (!keepSpan) {\n          logger.log('[Tracing] discarding Span since it happened after Transaction was finished', JSON.stringify(span, undefined, 2));\n        }\n\n        return keepSpan;\n      }); // this._onScope is true if the transaction was previously on the scope.\n\n      if (this._onScope) {\n        clearActiveTransaction(this._idleHub);\n      }\n\n      logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    return _super.prototype.finish.call(this, endTimestamp);\n  };\n  /**\n   * Register a callback function that gets excecuted before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n\n\n  IdleTransaction.prototype.registerBeforeFinishCallback = function (callback) {\n    this._beforeFinishCallbacks.push(callback);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  IdleTransaction.prototype.initSpanRecorder = function (maxlen) {\n    var _this = this;\n\n    if (!this.spanRecorder) {\n      this._initTimeout = setTimeout(function () {\n        if (!_this._finished) {\n          _this.finish();\n        }\n      }, this._idleTimeout);\n\n      var pushActivity = function pushActivity(id) {\n        if (_this._finished) {\n          return;\n        }\n\n        _this._pushActivity(id);\n      };\n\n      var popActivity = function popActivity(id) {\n        if (_this._finished) {\n          return;\n        }\n\n        _this._popActivity(id);\n      };\n\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen); // Start heartbeat so that transactions do not run forever.\n\n      logger.log('Starting heartbeat');\n\n      this._pingHeartbeat();\n    }\n\n    this.spanRecorder.add(this);\n  };\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n\n\n  IdleTransaction.prototype._pushActivity = function (spanId) {\n    if (this._initTimeout) {\n      clearTimeout(this._initTimeout);\n      this._initTimeout = undefined;\n    }\n\n    logger.log(\"[Tracing] pushActivity: \" + spanId);\n    this.activities[spanId] = true;\n    logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  };\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n\n\n  IdleTransaction.prototype._popActivity = function (spanId) {\n    var _this = this;\n\n    if (this.activities[spanId]) {\n      logger.log(\"[Tracing] popActivity \" + spanId); // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n\n      delete this.activities[spanId];\n      logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      var timeout = this._idleTimeout; // We need to add the timeout here to have the real endtimestamp of the transaction\n      // Remember timestampWithMs is in seconds, timeout is in ms\n\n      var end_1 = timestampWithMs() + timeout / 1000;\n      setTimeout(function () {\n        if (!_this._finished) {\n          _this.finish(end_1);\n        }\n      }, timeout);\n    }\n  };\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n\n\n  IdleTransaction.prototype._beat = function () {\n    clearTimeout(this._heartbeatTimer); // We should not be running heartbeat if the idle transaction is finished.\n\n    if (this._finished) {\n      return;\n    }\n\n    var keys = Object.keys(this.activities);\n    var heartbeatString = keys.length ? keys.reduce(function (prev, current) {\n      return prev + current;\n    }) : '';\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter += 1;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      logger.log(\"[Tracing] Transaction finished because of no change for 3 heart beats\");\n      this.setStatus(SpanStatus.DeadlineExceeded);\n      this.setTag('heartbeat', 'failed');\n      this.finish();\n    } else {\n      this._pingHeartbeat();\n    }\n  };\n  /**\n   * Pings the heartbeat\n   */\n\n\n  IdleTransaction.prototype._pingHeartbeat = function () {\n    var _this = this;\n\n    logger.log(\"pinging Heartbeat -> current counter: \" + this._heartbeatCounter);\n    this._heartbeatTimer = setTimeout(function () {\n      _this._beat();\n    }, 5000);\n  };\n\n  return IdleTransaction;\n}(Transaction);\n\nexport { IdleTransaction };\n/**\n * Reset active transaction on scope\n */\n\nfunction clearActiveTransaction(hub) {\n  if (hub) {\n    var scope = hub.getScope();\n\n    if (scope) {\n      var transaction = scope.getTransaction();\n\n      if (transaction) {\n        scope.setSpan(undefined);\n      }\n    }\n  }\n}"],"sourceRoot":""}