// Module ID: 1164
// Function ID: 13211
// Name: TimeToInitialDisplay
// Dependencies: [57, 31, 794, 1165, 1134, 1132, 977]
// Exports: createTimeToFullDisplay, createTimeToInitialDisplay, updateInitialDisplaySpan

// Module 1164 (TimeToInitialDisplay)
import _slicedToArray from "_slicedToArray";
import result from "result";
import { useState } from "result";

let require = arg1;
class TimeToInitialDisplay {
  constructor(arg0) {
    obj = require("registerSpanErrorInstrumentation");
    activeSpan = obj.getActiveSpan();
    if (activeSpan) {
      tmp2 = WeakMap;
      flag = true;
      result = WeakMap.set(activeSpan, true);
    }
    span_id = activeSpan;
    if (activeSpan) {
      tmp4 = closure_0;
      tmp5 = closure_1;
      obj2 = require("registerSpanErrorInstrumentation");
      span_id = obj2.spanToJSON(activeSpan).span_id;
    }
    obj = { initialDisplay: global.record };
    obj.parentSpanId = span_id;
    return result.createElement(TimeToDisplay, obj, global.children);
  }
}
class TimeToFullDisplay {
  constructor(arg0) {
    obj = require("registerSpanErrorInstrumentation");
    activeSpan = obj.getActiveSpan();
    span_id = activeSpan;
    if (activeSpan) {
      tmp2 = closure_0;
      tmp3 = closure_1;
      obj2 = require("registerSpanErrorInstrumentation");
      span_id = obj2.spanToJSON(activeSpan).span_id;
    }
    obj = { fullDisplay: global.record };
    obj.parentSpanId = span_id;
    return result.createElement(TimeToDisplay, obj, global.children);
  }
}
function TimeToDisplay(initialDisplay) {
  let obj = require(1165) /* _isNativeReflectConstruct */;
  obj = { initialDisplay: initialDisplay.initialDisplay, fullDisplay: initialDisplay.fullDisplay, parentSpanId: initialDisplay.parentSpanId };
  return <>{React.createElement(obj.getRNSentryOnDrawReporter(), { initialDisplay: arg0.initialDisplay, fullDisplay: arg0.fullDisplay, parentSpanId: arg0.parentSpanId })}{arg0.children}</>;
}
function startTimeToInitialDisplaySpan(isAutoInstrumented) {
  let obj = require(794) /* registerSpanErrorInstrumentation */;
  const activeSpan = obj.getActiveSpan();
  const obj2 = require(794) /* registerSpanErrorInstrumentation */;
  if (activeSpan) {
    const spanDescendants = obj2.getSpanDescendants(activeSpan);
    const found = spanDescendants.find((arg0) => "ui.load.initial_display" === startInactiveSpanResult(outer1_1[2]).spanToJSON(arg0).op);
    const obj3 = require(794) /* registerSpanErrorInstrumentation */;
    if (found) {
      const debug2 = obj3.debug;
      debug2.log("[TimeToDisplay] Found existing ui.load.initial_display span.");
      return found;
    } else {
      const _Object = Object;
      obj = { op: "ui.load.initial_display", name: "Time To Initial Display", startTime: tmp4(794).spanToJSON(activeSpan).start_timestamp };
      const startInactiveSpanResult = obj3.startInactiveSpan(Object.assign(obj, isAutoInstrumented));
      require = startInactiveSpanResult;
      if (startInactiveSpanResult) {
        captureStartFramesForSpan(startInactiveSpanResult.spanContext().spanId).catch((arg0) => {
          const debug = startInactiveSpanResult(outer1_1[2]).debug;
          debug.log("[TimeToDisplay] Failed to capture start frames for initial display span (" + startInactiveSpanResult.spanContext().spanId + ").", arg0);
        });
        isAutoInstrumented = undefined;
        if (null != isAutoInstrumented) {
          isAutoInstrumented = isAutoInstrumented.isAutoInstrumented;
        }
        if (isAutoInstrumented) {
          const attr = startInactiveSpanResult.setAttribute(require(794) /* registerSpanErrorInstrumentation */.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, require(1134).SPAN_ORIGIN_AUTO_UI_TIME_TO_DISPLAY);
        } else {
          const result = weakMap.set(activeSpan, true);
          const attr1 = startInactiveSpanResult.setAttribute(require(794) /* registerSpanErrorInstrumentation */.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, require(1134).SPAN_ORIGIN_MANUAL_UI_TIME_TO_DISPLAY);
        }
        return startInactiveSpanResult;
      }
      const tmp4Result = tmp4(794);
    }
    tmp4 = require;
  } else {
    let debug = obj2.debug;
    debug.warn("[TimeToDisplay] No active span found to attach ui.load.initial_display to.");
  }
}
function startTimeToFullDisplaySpan(arg0) {
  if (arguments.length > 0) {
    if (undefined !== arguments[0]) {
      let first = arguments[0];
    }
    const activeSpan = found(794).getActiveSpan();
    const obj3 = found(794);
    if (activeSpan) {
      const spanDescendants = obj3.getSpanDescendants(activeSpan);
      found = spanDescendants.find((arg0) => "ui.load.initial_display" === found(startInactiveSpanResult[2]).spanToJSON(arg0).op);
      if (found) {
        const found1 = spanDescendants.find((arg0) => "ui.load.full_display" === found(startInactiveSpanResult[2]).spanToJSON(arg0).op);
        const obj4 = found(794);
        if (found1) {
          const debug3 = obj4.debug;
          debug3.log("[TimeToDisplay] Found existing ui.load.full_display span.");
          return found1;
        } else {
          const _Object = Object;
          let obj = { op: "ui.load.full_display", name: "Time To Full Display", startTime: tmp12(794).spanToJSON(found).start_timestamp };
          const startInactiveSpanResult = obj4.startInactiveSpan(Object.assign(obj, first));
          const dependencyMap = startInactiveSpanResult;
          if (startInactiveSpanResult) {
            captureStartFramesForSpan(startInactiveSpanResult.spanContext().spanId).catch((arg0) => {
              const debug = found(startInactiveSpanResult[2]).debug;
              debug.log("[TimeToDisplay] Failed to capture start frames for full display span (" + startInactiveSpanResult.spanContext().spanId + ").", arg0);
            });
            const _setTimeout = setTimeout;
            const timeout = setTimeout(() => {
              let obj = found(startInactiveSpanResult[2]);
              if (!obj.spanToJSON(startInactiveSpanResult).timestamp) {
                obj = { code: found(startInactiveSpanResult[2]).SPAN_STATUS_ERROR, message: "deadline_exceeded" };
                startInactiveSpanResult.setStatus(obj);
                const promise = outer1_17(startInactiveSpanResult);
                outer1_17(startInactiveSpanResult).then(() => {
                  const debug = found(startInactiveSpanResult[2]).debug;
                  debug.log("[TimeToDisplay] span " + outer1_1.spanContext().spanId + " updated with frame data.");
                  outer1_1.end(found(startInactiveSpanResult[2]).spanToJSON(outer1_0).timestamp);
                  const obj = found(startInactiveSpanResult[2]);
                  const result = found(startInactiveSpanResult[5]).setSpanDurationAsMeasurement("time_to_full_display", outer1_1);
                }).catch(() => {
                  const debug = found(startInactiveSpanResult[2]).debug;
                  debug.warn("[TimeToDisplay] Failed to capture end frames for full display span (" + outer1_1.spanContext().spanId + ").");
                  outer1_1.end(found(startInactiveSpanResult[2]).spanToJSON(outer1_0).timestamp);
                  const obj = found(startInactiveSpanResult[2]);
                  const result = found(startInactiveSpanResult[5]).setSpanDurationAsMeasurement("time_to_full_display", outer1_1);
                });
                let debug = found(startInactiveSpanResult[2]).debug;
                debug.warn("[TimeToDisplay] Full display span deadline_exceeded.");
                const nextPromise = outer1_17(startInactiveSpanResult).then(() => {
                  const debug = found(startInactiveSpanResult[2]).debug;
                  debug.log("[TimeToDisplay] span " + outer1_1.spanContext().spanId + " updated with frame data.");
                  outer1_1.end(found(startInactiveSpanResult[2]).spanToJSON(outer1_0).timestamp);
                  const obj = found(startInactiveSpanResult[2]);
                  const result = found(startInactiveSpanResult[5]).setSpanDurationAsMeasurement("time_to_full_display", outer1_1);
                });
              }
            }, first.timeoutMs);
            let promise = captureStartFramesForSpan(startInactiveSpanResult.spanContext().spanId);
            found(794).fill(startInactiveSpanResult, "end", (arg0) => {
              let closure_0 = arg0;
              return (arg0) => {
                clearTimeout(outer1_2);
                callback.call(outer1_1, arg0);
              };
            });
            let isAutoInstrumented;
            if (null != first) {
              isAutoInstrumented = first.isAutoInstrumented;
            }
            const setAttribute = startInactiveSpanResult.setAttribute;
            const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = found(794).SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN;
            const tmp24 = found(1134);
            if (isAutoInstrumented) {
              const attr = setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, tmp24.SPAN_ORIGIN_AUTO_UI_TIME_TO_DISPLAY);
            } else {
              const attr1 = setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, tmp24.SPAN_ORIGIN_MANUAL_UI_TIME_TO_DISPLAY);
            }
            return startInactiveSpanResult;
          }
          const tmp12Result = tmp12(794);
        }
        tmp12 = found;
      } else {
        const debug2 = found(794).debug;
        debug2.warn("[TimeToDisplay] No initial display span found to attach ui.load.full_display to.");
      }
    } else {
      let debug = obj3.debug;
      debug.warn("[TimeToDisplay] No active span found to attach ui.load.full_display to.");
    }
  }
  first = { timeoutMs: 30000 };
}
function updateFullDisplaySpan(arg0, arg1) {
  let found = arg1;
  const _require = arg0;
  let obj = _require(timestamp[2]);
  const activeSpan = obj.getActiveSpan();
  if (activeSpan) {
    if (!found) {
      const spanDescendants = _require(timestamp[2]).getSpanDescendants(activeSpan);
      found = spanDescendants.find((arg0) => "ui.load.initial_display" === callback(timestamp[2]).spanToJSON(arg0).op);
      const obj3 = _require(timestamp[2]);
    }
    timestamp = found;
    if (found) {
      timestamp = _require(timestamp[2]).spanToJSON(found).timestamp;
      const obj4 = _require(timestamp[2]);
    }
    if (timestamp) {
      obj = { isAutoInstrumented: true };
      const tmp16 = startTimeToFullDisplaySpan(obj);
      let _slicedToArray = tmp16;
      const obj6 = _require(timestamp[2]);
      if (tmp16) {
        const spanToJSONResult = obj6.spanToJSON(tmp16);
        if (spanToJSONResult.timestamp) {
          const debug4 = _require(timestamp[2]).debug;
          const _HermesInternal2 = HermesInternal;
          debug4.warn("[TimeToDisplay] " + spanToJSONResult.description + " (" + spanToJSONResult.span_id + ") span already ended.");
        } else {
          const promise = captureEndFramesAndAttachToSpan(tmp16);
          captureEndFramesAndAttachToSpan(tmp16).then(() => {
            if (timestamp > callback) {
              const debug = callback(timestamp[2]).debug;
              debug.warn("[TimeToDisplay] Using initial display end. Full display end frame timestamp is before initial display end.");
            }
            tmp16.end(timestamp > callback ? timestamp : callback);
            tmp16.setStatus({ code: callback(timestamp[2]).SPAN_STATUS_OK });
            const debug2 = callback(timestamp[2]).debug;
            debug2.log("[TimeToDisplay] span " + spanToJSONResult.description + " (" + spanToJSONResult.span_id + ") updated with end timestamp and frame data.");
            const obj = { code: callback(timestamp[2]).SPAN_STATUS_OK };
            const tmp = timestamp > callback ? timestamp : callback;
            const result = callback(timestamp[5]).setSpanDurationAsMeasurement("time_to_full_display", tmp16);
          }).catch((arg0) => {
            const debug = callback(timestamp[2]).debug;
            debug.log("[TimeToDisplay] Failed to capture frame data for full display span.", arg0);
            tmp16.end(timestamp > callback ? timestamp : callback);
            tmp16.setStatus({ code: callback(timestamp[2]).SPAN_STATUS_OK });
            const obj = { code: callback(timestamp[2]).SPAN_STATUS_OK };
            const result = callback(timestamp[5]).setSpanDurationAsMeasurement("time_to_full_display", tmp16);
          });
          const nextPromise = captureEndFramesAndAttachToSpan(tmp16).then(() => {
            if (timestamp > callback) {
              const debug = callback(timestamp[2]).debug;
              debug.warn("[TimeToDisplay] Using initial display end. Full display end frame timestamp is before initial display end.");
            }
            tmp16.end(timestamp > callback ? timestamp : callback);
            tmp16.setStatus({ code: callback(timestamp[2]).SPAN_STATUS_OK });
            const debug2 = callback(timestamp[2]).debug;
            debug2.log("[TimeToDisplay] span " + spanToJSONResult.description + " (" + spanToJSONResult.span_id + ") updated with end timestamp and frame data.");
            const obj = { code: callback(timestamp[2]).SPAN_STATUS_OK };
            const tmp = timestamp > callback ? timestamp : callback;
            const result = callback(timestamp[5]).setSpanDurationAsMeasurement("time_to_full_display", tmp16);
          });
        }
      } else {
        const debug3 = obj6.debug;
        debug3.warn("[TimeToDisplay] No TimeToFullDisplay span found or created, possibly performance is disabled.");
      }
    } else {
      let result = weakMap1.set(activeSpan, true);
      let debug2 = _require(timestamp[2]).debug;
      const _HermesInternal = HermesInternal;
      debug2.warn("[TimeToDisplay] Full display called before initial display for active span (" + activeSpan.spanContext().spanId + ").");
    }
  } else {
    let debug = _require(timestamp[2]).debug;
    debug.warn("[TimeToDisplay] No active span found to update ui.load.full_display in.");
  }
}
function createTimeToDisplay(arg0) {
  let dependencyMap;
  let require;
  ({ useFocusEffect: require, Component: dependencyMap } = arg0);
  class TimeToDisplayWrapper {
    constructor(arg0) {
      tmp = outer1_2(outer1_4(false), 2);
      record = tmp[0];
      c0 = tmp[1];
      tmp2 = c0(() => {
        callback(true);
        return () => {
          outer1_0(false);
        };
      });
      obj = {};
      tmp3 = outer1_3;
      tmp4 = Component;
      if (record) {
        record = arg0.record;
      }
      obj.record = record;
      return outer1_3.createElement(tmp4, Object.assign({}, arg0, obj));
    }
  }
  TimeToDisplayWrapper.displayName = "TimeToDisplayWrapper";
  return TimeToDisplayWrapper;
}
function captureStartFramesForSpan(spanId) {
  let closure_0 = spanId;
  return fn(this, undefined, undefined, function*() {
    if (callback(outer2_1[6]).NATIVE.enableNative) {
      const tmp2 = yield outer2_18();
      const _setTimeout = setTimeout;
      const timerId = setTimeout(() => {
        if (outer3_8.get(outer2_0)) {
          outer3_8.delete(outer2_0);
          const debug = callback(outer3_1[2]).debug;
          const _HermesInternal = HermesInternal;
          debug.log("[TimeToDisplay] Cleaned up stale frame data for span " + outer2_0 + " after timeout.");
        }
      }, 60000);
      if (!outer2_8.has(outer1_0)) {
        const obj = { startFrames: null, endFrames: null, cleanupTimeout: timerId };
        const result = outer2_8.set(outer1_0, obj);
      }
      const value = outer2_8.get(outer1_0);
      if (value) {
        value.startFrames = tmp2;
        value.cleanupTimeout = timerId;
        const debug2 = callback(outer2_1[2]).debug;
        const _HermesInternal2 = HermesInternal;
        debug2.log("[TimeToDisplay] Captured start frames for span " + outer1_0 + ".", tmp2);
      } else {
        const _clearTimeout = clearTimeout;
        clearTimeout(timerId);
        let debug = callback(outer2_1[2]).debug;
        let _HermesInternal = HermesInternal;
        debug.log("[TimeToDisplay] Span " + outer1_0 + " already ended, discarding start frames.");
      }
    }
  });
}
function captureEndFramesAndAttachToSpan(span) {
  let closure_0 = span;
  return fn(this, undefined, undefined, function*() {
    if (callback(outer2_1[6]).NATIVE.enableNative) {
      const spanId = outer1_0.spanContext().spanId;
      const value = outer2_8.get(spanId);
      let startFrames;
      if (null != value) {
        startFrames = tmp5.startFrames;
      }
      if (startFrames) {
        const tmp15 = yield outer2_18();
        tmp5.endFrames = tmp15;
        let obj = outer1_0;
        startFrames = tmp5.startFrames;
        const diff = tmp15.totalFrames - startFrames.totalFrames;
        const diff1 = tmp15.slowFrames - startFrames.slowFrames;
        const diff2 = tmp15.frozenFrames - startFrames.frozenFrames;
        if (diff <= 0) {
          if (diff1 <= 0) {
            if (diff2 <= 0) {
              const debug3 = callback(outer2_1[2]).debug;
              const _HermesInternal2 = HermesInternal;
              debug3.warn("[TimeToDisplay] Detected zero slow or frozen frames. Not adding measurements to span (" + obj.spanContext().spanId + ").");
            }
            const debug4 = callback(outer2_1[2]).debug;
            const _HermesInternal3 = HermesInternal;
            debug4.log("[TimeToDisplay] Captured and attached end frames for span " + tmp2 + ".", tmp15);
            while (true) {
              let tmp35 = value;
              if (!tmp5.cleanupTimeout) {
                break;
              } else {
                let tmp36 = globalThis;
                let _clearTimeout = clearTimeout;
                let tmp37 = value;
                let clearTimeoutResult = clearTimeout(tmp5.cleanupTimeout);
                break;
              }
              let tmp39 = outer2_8;
              let tmp40 = spanId;
              let deleteResult = outer2_8.delete(tmp2);
            }
          }
        }
        const attr = obj.setAttribute("frames.total", diff);
        const attr1 = obj.setAttribute("frames.slow", diff1);
        const attr2 = obj.setAttribute("frames.frozen", diff2);
        const debug2 = callback(outer2_1[2]).debug;
        obj = {};
        obj.spanId = obj.spanContext().spanId;
        obj = { total: diff, slow: diff1, frozen: diff2 };
        obj.frameData = obj;
        debug2.log("[TimeToDisplay] Attached frame data to span.", obj);
      } else {
        const debug = callback(outer2_1[2]).debug;
        const _HermesInternal = HermesInternal;
        debug.log("[TimeToDisplay] No start frames found for span " + tmp2 + ", skipping frame data collection.");
      }
    }
  });
}
function fetchNativeFramesWithTimeout() {
  return new Promise((arg0, arg1) => {
    let closure_0 = arg0;
    let closure_1 = arg1;
    let c2 = false;
    const timeout = setTimeout(() => {
      if (!c2) {
        c2 = true;
        callback2("Fetching native frames took too long. Dropping frames.");
      }
    }, 2000);
    const NATIVE = outer1_0(outer1_1[6]).NATIVE;
    const nativeFrames = NATIVE.fetchNativeFrames();
    nativeFrames.then((arg0) => {
      if (!c2) {
        const _clearTimeout = clearTimeout;
        clearTimeout(result);
        c2 = true;
        if (arg0) {
          callback(arg0);
        } else {
          callback2("Native frames response is null.");
        }
      }
    }).then(undefined, (arg0) => {
      if (!c2) {
        const _clearTimeout = clearTimeout;
        clearTimeout(result);
        c2 = true;
        callback2(arg0);
      }
    });
  });
}
let fn = this;
if (this) {
  fn = this.__awaiter;
}
if (!fn) {
  fn = (arg0, arg1, arg2, arg3) => {
    let _Promise = arg2;
    let closure_0 = arg0;
    let closure_1 = arg1;
    let result = arg3;
    if (!arg2) {
      _Promise = Promise;
    }
    _Promise = new _Promise((arg0, arg1) => {
      let closure_0 = arg0;
      let closure_1 = arg1;
      function fulfilled(arg0) {
        step(iter.next(arg0));
      }
      let iter = function rejected(arg0) {
        step(iter.throw(arg0));
      };
      function step(iter) {
        if (iter.done) {
          callback(iter.value);
        } else {
          (function adopt(value) {
            let tmp = value;
            let closure_0 = value;
            if (!(value instanceof fulfilled)) {
              const prototype = fulfilled.prototype;
              tmp = new fulfilled((arg0) => {
                arg0(closure_0);
              });
            }
            return tmp;
          })(iter.value).then(fulfilled, iter);
          const promise = (function adopt(value) {
            let tmp = value;
            let closure_0 = value;
            if (!(value instanceof fulfilled)) {
              const prototype = fulfilled.prototype;
              tmp = new fulfilled((arg0) => {
                arg0(closure_0);
              });
            }
            return tmp;
          })(iter.value);
        }
      }
      let items = closure_1;
      if (!closure_1) {
        items = [];
      }
      iter = iter.apply(closure_0, items);
      step(iter.next());
    });
    return _Promise;
  };
}
const weakMap = new WeakMap();
const weakMap1 = new WeakMap();
const map = new Map();

export const manualInitialDisplaySpans = weakMap;
export { TimeToInitialDisplay };
export { TimeToFullDisplay };
export { startTimeToInitialDisplaySpan };
export { startTimeToFullDisplaySpan };
export const updateInitialDisplaySpan = function updateInitialDisplaySpan(arg0) {
  const _require = arg0;
  if (arguments.length > 1) {
    if (undefined !== arguments[1]) {
      let obj = arguments[1];
    }
    let activeSpan = obj.activeSpan;
    if (undefined === activeSpan) {
      activeSpan = _require(activeSpan[2]).getActiveSpan();
      let obj2 = _require(activeSpan[2]);
    }
    let span = obj.span;
    if (undefined === span) {
      span = startTimeToInitialDisplaySpan();
    }
    const obj3 = _require(activeSpan[2]);
    if (span) {
      if (activeSpan) {
        if (obj3.spanToJSON(span).parent_span_id === tmp4Result.spanToJSON(activeSpan).span_id) {
          if (obj5.spanToJSON(span).timestamp) {
            const debug4 = _require(activeSpan[2]).debug;
            let _HermesInternal = HermesInternal;
            debug4.warn("[TimeToDisplay] " + _require(activeSpan[2]).spanToJSON(span).description + " span already ended.");
            const obj6 = _require(activeSpan[2]);
          } else {
            const promise = captureEndFramesAndAttachToSpan(span);
            captureEndFramesAndAttachToSpan(span).then(() => {
              span.end(callback);
              span.setStatus({ code: callback(activeSpan[2]).SPAN_STATUS_OK });
              const debug = callback(activeSpan[2]).debug;
              const obj = { code: callback(activeSpan[2]).SPAN_STATUS_OK };
              debug.log("[TimeToDisplay] " + callback(activeSpan[2]).spanToJSON(span).description + " span updated with end timestamp and frame data.");
              if (outer1_7.has(activeSpan)) {
                outer1_7.delete(activeSpan);
                const debug2 = callback(activeSpan[2]).debug;
                const _HermesInternal = HermesInternal;
                debug2.log("[TimeToDisplay] Updating full display with initial display (" + span.spanContext().spanId + ") end.");
                outer1_14(callback, span);
              }
              const obj2 = callback(activeSpan[2]);
              const result = callback(activeSpan[5]).setSpanDurationAsMeasurementOnSpan("time_to_initial_display", span, activeSpan);
            }).catch((arg0) => {
              const debug = callback(activeSpan[2]).debug;
              debug.log("[TimeToDisplay] Failed to capture frame data for initial display span.", arg0);
              span.end(callback);
              span.setStatus({ code: callback(activeSpan[2]).SPAN_STATUS_OK });
              if (outer1_7.has(activeSpan)) {
                outer1_7.delete(activeSpan);
                const debug2 = callback(activeSpan[2]).debug;
                const _HermesInternal = HermesInternal;
                debug2.log("[TimeToDisplay] Updating full display with initial display (" + span.spanContext().spanId + ") end.");
                outer1_14(callback, span);
              }
              const obj = { code: callback(activeSpan[2]).SPAN_STATUS_OK };
              const result = callback(activeSpan[5]).setSpanDurationAsMeasurementOnSpan("time_to_initial_display", span, activeSpan);
            });
            const nextPromise = captureEndFramesAndAttachToSpan(span).then(() => {
              span.end(callback);
              span.setStatus({ code: callback(activeSpan[2]).SPAN_STATUS_OK });
              const debug = callback(activeSpan[2]).debug;
              const obj = { code: callback(activeSpan[2]).SPAN_STATUS_OK };
              debug.log("[TimeToDisplay] " + callback(activeSpan[2]).spanToJSON(span).description + " span updated with end timestamp and frame data.");
              if (outer1_7.has(activeSpan)) {
                outer1_7.delete(activeSpan);
                const debug2 = callback(activeSpan[2]).debug;
                const _HermesInternal = HermesInternal;
                debug2.log("[TimeToDisplay] Updating full display with initial display (" + span.spanContext().spanId + ") end.");
                outer1_14(callback, span);
              }
              const obj2 = callback(activeSpan[2]);
              const result = callback(activeSpan[5]).setSpanDurationAsMeasurementOnSpan("time_to_initial_display", span, activeSpan);
            });
          }
          obj5 = _require(activeSpan[2]);
        } else {
          const debug3 = _require(activeSpan[2]).debug;
          debug3.warn("[TimeToDisplay] Initial display span is not a child of current active span.");
        }
        tmp4Result = _require(activeSpan[2]);
      } else {
        let debug2 = obj3.debug;
        debug2.warn("[TimeToDisplay] No active span found to attach ui.load.initial_display to.");
      }
    } else {
      let debug = obj3.debug;
      debug.warn("[TimeToDisplay] No span found or created, possibly performance is disabled.");
    }
  }
  obj = {};
};
export const createTimeToFullDisplay = function createTimeToFullDisplay(useFocusEffect) {
  return createTimeToDisplay({ useFocusEffect: useFocusEffect.useFocusEffect, Component: TimeToFullDisplay });
};
export const createTimeToInitialDisplay = function createTimeToInitialDisplay(useFocusEffect) {
  return createTimeToDisplay({ useFocusEffect: useFocusEffect.useFocusEffect, Component: TimeToInitialDisplay });
};