@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/server-logger.js

@@ -0,0 +1,156 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { _class_private_field_loose_base, _class_private_field_loose_key, _extends } from "../js/4101.js";
+import { getSentryClient } from "./widget/sentry.js";
+
+const isNil = __webpack_require__("11655");
+var isNil_default = /*#__PURE__*/__webpack_require__.n(isNil);
+
+
+
+
+
+var _config = /*#__PURE__*/ _class_private_field_loose_key("_config"), _widgetId = /*#__PURE__*/ _class_private_field_loose_key("_widgetId"), _visitorId = /*#__PURE__*/ _class_private_field_loose_key("_visitorId");
+class ServerLogger {
+    /**
+   * Updates the widget configuration.
+   * @param config - Widget configuration containing host and token
+   */ setConfig(config) {
+        _class_private_field_loose_base(this, _config)[_config] = config;
+    }
+    /**
+   * Sets the visitor ID for subsequent log requests.
+   * @param visitorId - The unique visitor identifier
+   */ setVisitorId(visitorId) {
+        _class_private_field_loose_base(this, _visitorId)[_visitorId] = visitorId;
+    }
+    /**
+   * Sets the widget ID for subsequent log requests.
+   * @param widgetId - The unique widget identifier
+   */ setWidgetId(widgetId) {
+        _class_private_field_loose_base(this, _widgetId)[_widgetId] = widgetId;
+    }
+    /**
+   * Constructs a full URL for a widget API resource.
+   * @param name - The resource endpoint name
+   * @param params - Optional query parameters
+   * @returns The full URL string
+   */ resourceUrl(name, params) {
+        let url = _class_private_field_loose_base(this, _config)[_config].host + "/w/1/" + _class_private_field_loose_base(this, _config)[_config].token + "/" + name;
+        if (params) {
+            const queryParams = new URLSearchParams();
+            Object.entries(params).forEach((param)=>{
+                let [key, value] = param;
+                if (!isNil_default()(value)) {
+                    queryParams.set(key, String(value));
+                }
+            });
+            url += "?" + queryParams.toString();
+        }
+        return url;
+    }
+    /**
+   * Logs an event to the server.
+   *
+   * @param params - The log parameters
+   * @param params.message - The log message or event description
+   * @param params.type - Event type: "log" (default), "sentry", or "both"
+   * @param params.extra - Additional structured data to include with the log
+   * @param params.fireAndForget - If true, errors are silently ignored.
+   *   Use this for page unload scenarios (beforeunload, pagehide, visibilitychange).
+   *
+   * @example
+   * // Normal logging with error reporting
+   * serverLog({ message: "User clicked button" });
+   *
+   * // Fire-and-forget for page unload
+   * serverLog({ message: "Page closing", fireAndForget: true });
+   */ serverLog(param) {
+        let { type = "log", message: event, extra = {}, fireAndForget = false } = param;
+        if (!_class_private_field_loose_base(this, _config)[_config].host || !_class_private_field_loose_base(this, _config)[_config].token) {
+            return;
+        }
+        this.sendEvent("visitor_events", {
+            params: {
+                wu: _class_private_field_loose_base(this, _widgetId)[_widgetId],
+                uuid: _class_private_field_loose_base(this, _visitorId)[_visitorId]
+            },
+            body: {
+                event,
+                type,
+                extra
+            }
+        }, {
+            fireAndForget
+        });
+    }
+    /**
+   * Records a telemetry trace event to the server.
+   * Used for OpenTelemetry-compatible tracing data.
+   *
+   * @param payload - The trace payload containing span data and attributes
+   */ recordTrace(payload) {
+        if (!_class_private_field_loose_base(this, _config)[_config].host || !_class_private_field_loose_base(this, _config)[_config].token) {
+            return;
+        }
+        this.sendEvent("events/trace", {
+            body: _extends({}, payload, {
+                widget_id: _class_private_field_loose_base(this, _widgetId)[_widgetId],
+                visitor_id: _class_private_field_loose_base(this, _visitorId)[_visitorId]
+            })
+        });
+    }
+    async sendEvent(path, param, param1) {
+        let { params, body } = param;
+        let { fireAndForget = false } = param1 === void 0 ? {} : param1;
+        // Using keepalive ensures requests complete even during page unload.
+        // Using credentials: 'omit' avoids CORS issues with wildcard origins.
+        // No timeout is set because: (1) fireAndForget calls don't wait for response,
+        // (2) regular calls are non-blocking logging, and (3) browser defaults apply.
+        const request = fetch(this.resourceUrl(path, params), {
+            method: "POST",
+            body: JSON.stringify(body),
+            headers: {
+                "Content-Type": "application/json"
+            },
+            keepalive: true,
+            credentials: "omit"
+        });
+        if (fireAndForget) {
+            // Intentionally silent: fireAndForget is used during page unload (beforeunload,
+            // pagehide) where we cannot wait for responses or report errors. This matches
+            // the previous sendBeacon behavior which also provided no error feedback.
+            request.catch(()=>{});
+            return;
+        }
+        try {
+            const response = await request;
+            if (!response.ok) {
+                throw new Error("Failed to send event " + path + ": " + response.status + " " + response.statusText);
+            }
+        } catch (error) {
+            var _getSentryClient;
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(error);
+        }
+    }
+    constructor(config){
+        Object.defineProperty(this, _config, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _widgetId, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _visitorId, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_loose_base(this, _config)[_config] = config;
+        _class_private_field_loose_base(this, _widgetId)[_widgetId] = undefined;
+        _class_private_field_loose_base(this, _visitorId)[_visitorId] = undefined;
+    }
+}
+const serverLogger = new ServerLogger({});
+
+var server_logger_ServerLogger = /* unused export */ undefined;
+export { serverLogger, server_logger_ServerLogger as ServerLogger };

package/widget/smart_website_config.js

@@ -0,0 +1,112 @@
+import { Trigger } from "../src/smart_website/trigger.js";
+import { sortTriggers, isDebugMode, isMatchingSelector } from "../src/smart_website/utils.js";
+import { normalizeURL, hasURLMatch } from "../src/url-utils.js";
+import { _extends } from "../js/4101.js";
+
+
+
+
+
+function transformOldTrigger(param) {
+    let { selector, api } = param;
+    return new Trigger({
+        url: "",
+        selector,
+        api,
+        global: false,
+        legacy: true
+    });
+}
+const WEBSITE_CONFIGS = "WEBSITE_CONFIGS";
+class SmartWebsiteConfig {
+    get normalizedCurrentURL() {
+        return normalizeURL(window.location.href);
+    }
+    // This is what Tracker.handleTriggers expects to use, a map from selector to bot API names
+    get triggerSelectors() {
+        return this.currentTriggerQuerySelectors;
+    }
+    get hasCurrentTriggerSelectors() {
+        return Object.keys(this.triggerSelectors).length > 0;
+    }
+    /**
+   * Prefer new triggers over old, so attempt to match on new ones first before old
+   * @param target
+   * @returns matching selector
+   */ matchingSelector(target) {
+        const selector = Object.keys(this.currentTriggerQuerySelectors).find((selector)=>isMatchingSelector(target, selector));
+        this.debugLog("Matched trigger " + selector);
+        return selector;
+    }
+    get currentTriggers() {
+        return sortTriggers(this.websiteConfigs.filter((param)=>{
+            let { url, global } = param;
+            return this.hasURLMatch(url, global);
+        }));
+    }
+    hasURLMatch(url, global) {
+        return hasURLMatch(this.normalizedCurrentURL, normalizeURL(url), global);
+    }
+    get oldTriggers() {
+        return Object.entries(this.smartCtaTriggers).reduce((acc, param)=>{
+            let [key, value] = param;
+            if (key !== WEBSITE_CONFIGS) {
+                acc.push(transformOldTrigger({
+                    selector: key,
+                    api: value
+                }));
+            }
+            return acc;
+        }, []);
+    }
+    get currentTriggerQuerySelectors() {
+        // currentTriggers is already ordered by precedence
+        const triggerQuerySelectors = this.currentTriggers.reduce((acc, param)=>{
+            let { selector, api } = param;
+            if (!acc[selector]) {
+                acc[selector] = api;
+            } else {
+                this.debugLog("Skipping duplicate trigger " + selector + " for " + api);
+            }
+            return acc;
+        }, {});
+        // Prefer new triggers over old
+        this.oldTriggers.forEach((param)=>{
+            let { selector, api } = param;
+            if (!triggerQuerySelectors[selector]) {
+                triggerQuerySelectors[selector] = api;
+            } else {
+                this.debugLog("Skipping duplicate trigger " + selector + " for " + api);
+            }
+        });
+        return triggerQuerySelectors;
+    }
+    get smartCtaTriggers() {
+        return this.config.smartCtaTriggers;
+    }
+    get websiteConfigs() {
+        if (!this.smartCtaTriggers.WEBSITE_CONFIGS || typeof this.smartCtaTriggers.WEBSITE_CONFIGS === "string") {
+            return [];
+        }
+        return this.smartCtaTriggers.WEBSITE_CONFIGS.map((config)=>new Trigger(_extends({}, config, {
+                legacy: false
+            })));
+    }
+    constructor(smartWebsiteConfig){
+        this.isDebug = false;
+        this.debugLog = (msg)=>{
+            if (this.isDebug) {
+                // eslint-disable-next-line no-console
+                console.log("[Qualified] " + msg);
+            }
+        };
+        if (document.location.search) {
+            this.isDebug = isDebugMode();
+            this.debugLog("[DEBUG MODE]");
+        }
+        this.config = smartWebsiteConfig;
+    }
+}
+/* export default */ const smart_website_config = (SmartWebsiteConfig);
+
+export default smart_website_config;

package/widget/telemetry/context.js

@@ -0,0 +1,75 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import "../utils/native_globals.js";
+
+/* provided dependency */ var context_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var context_setInterval = __webpack_require__(68034).LK;
+let currentCtx = null;
+/** Internal helper to swap to given context while fn executes. */ function withContext(ctx, fn) {
+    const oldCtx = currentCtx;
+    currentCtx = ctx;
+    try {
+        return fn();
+    } finally{
+        currentCtx = oldCtx;
+    }
+}
+/**
+ * Gets a variable from the current dynamic scope chain
+ * @param {string} name - The variable name
+ * @returns {any} - The variable value or undefined
+ */ function getCtxVar(name) {
+    let ctx = currentCtx;
+    while(ctx){
+        if (name in ctx.vars) {
+            return ctx.vars[name];
+        }
+        ctx = ctx.parent;
+    }
+    return undefined;
+}
+/**
+ * Runs a function within a new child dynamic scope with the given variables set.
+ * @param {Function} fn - The function to execute within the scope
+ * @param {Object} variables - Variables to set in the new scope
+ * @returns {any} - The result of the function
+ */ function withCtxVars(vars, fn) {
+    const newCtx = {
+        parent: currentCtx,
+        vars
+    };
+    return withContext(newCtx, fn);
+}
+/**
+ * Wrap any function that has deferred execution so that when it executes, it first restores the current context from the
+ * time wrapCallback was called.
+ * @param {Function} fn - The function to wrap
+ * @returns {Function} - A wrapped function
+ */ function wrapCallback(fn) {
+    if (!currentCtx) {
+        return fn;
+    }
+    const contextAtBind = currentCtx;
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return withContext(contextAtBind, ()=>fn.apply(this, args));
+    };
+}
+const context_wrappedSetTimeout = function wrappedSetTimeout(fn) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    return context_setTimeout(wrapCallback(fn), ...args);
+};
+const context_wrappedSetInterval = function wrappedSetInterval(fn) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    return context_setInterval(wrapCallback(fn), ...args);
+};
+
+var context_wrapCallback = /* unused export */ undefined;
+var telemetry_context_wrappedSetInterval = /* unused export */ undefined;
+var telemetry_context_wrappedSetTimeout = /* unused export */ undefined;
+export { context_wrapCallback as wrapCallback, getCtxVar, telemetry_context_wrappedSetInterval as wrappedSetInterval, telemetry_context_wrappedSetTimeout as wrappedSetTimeout, withCtxVars };

package/widget/telemetry/index.js

@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+var telemetry_Span = /* unused export */ undefined;
+var telemetry_Spans = /* unused export */ undefined;
+var telemetry_TracingStore = /* unused export */ undefined;
+export { telemetry_Span as Span, telemetry_Spans as Spans, telemetry_TracingStore as TracingStore };
+export { PerformanceSpan, TimedSpan } from "./span.js";
+export { SpanStatusCodeEnum, Telemetry, buildTraceParent, getTelemetryCtx, telemetry, withSpan, withTelemetryCtx } from "./telemetry.js";
+export { Tracer } from "./tracer.js";
+export { isWidgetBundleResource, metrics, resolveOriginTime, widgetConsumer } from "./metrics.js";
+export { tracingStore } from "./tracing_store.js";

package/widget/telemetry/messenger_uptime.js

@@ -0,0 +1,80 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { metrics } from "./metrics.js";
+import "../utils/native_globals.js";
+
+/* provided dependency */ var messenger_uptime_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var messenger_uptime_setTimeout = __webpack_require__(68034).pS;
+
+// Availability budget for the init phase: widget.init() -> first `initState`
+// (the backend's broadcast_total_state). No `initState` within this window counts
+// as unavailable (`timeout`). This is an availability SLI ("did the messenger come
+// up"), not a latency target, so the threshold should only trip on genuinely-dead
+// sessions, not the slow tail.
+const MESSENGER_INIT_BUDGET_MS = 30000;
+/**
+ * Tracks widget init-phase availability: from `widget.init()` (armed via
+ * {@link start}) to the first `initState` ({@link resolveSuccess}). There is only
+ * ever one init per widget instance.
+ *
+ * Emits `widget.initialized` (count, tag `status`):
+ *   - `success` — `initState` arrived within the budget.
+ *   - `timeout` — the budget elapsed first (unavailable).
+ *   - `late` — `initState` arrived after a `timeout` was already emitted; the
+ *     messenger came up, just past the budget (slow backend, not a true outage).
+ *
+ * Strict availability = `success / (success + timeout)`. Genuinely-dead sessions
+ * are `timeout - late`. A visitor who leaves before any resolution self-excludes:
+ * the page tears down and the pending timer dies with it, so nothing is emitted.
+ */ class MessengerUptimeTracker {
+    emit(status) {
+        metrics.emitIncrement("widget_initialized", {
+            status
+        });
+    }
+    clearTimer() {
+        if (this.timeoutId !== null) {
+            messenger_uptime_clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    // `budgetMs` is an injection point for tests.
+    // eslint-disable-next-line no-useless-constructor
+    constructor(budgetMs = MESSENGER_INIT_BUDGET_MS){
+        this.budgetMs = budgetMs;
+        // Starts idle so a stray resolveSuccess()/dispose() before start() is a no-op.
+        this.state = "idle";
+        this.timeoutId = null;
+        /** `widget.init()`: arm the watchdog for the init attempt. */ this.start = ()=>{
+            this.clearTimer();
+            this.state = "armed";
+            this.timeoutId = messenger_uptime_setTimeout(()=>{
+                this.timeoutId = null;
+                if (this.state !== "armed") return;
+                this.state = "timedOut";
+                this.emit("timeout");
+            }, this.budgetMs);
+        };
+        /** First `initState` received: the messenger has the state it needs to render. */ this.resolveSuccess = ()=>{
+            if (this.state === "armed") {
+                this.clearTimer();
+                this.state = "idle";
+                this.emit("success");
+            } else if (this.state === "timedOut") {
+                this.state = "idle";
+                this.emit("late");
+            }
+        };
+        /**
+   * Explicit teardown: abandon the attempt without emitting. Routine visitor
+   * abandonment doesn't need this (the timer dies with the page); this covers
+   * in-page teardown so a pending timer doesn't fire, and a post-timeout `late`
+   * isn't recorded, after the widget is gone.
+   */ this.dispose = ()=>{
+            this.clearTimer();
+            this.state = "idle";
+        };
+    }
+}
+
+var messenger_uptime_MESSENGER_INIT_BUDGET_MS = /* unused export */ undefined;
+export { MessengerUptimeTracker, messenger_uptime_MESSENGER_INIT_BUDGET_MS as MESSENGER_INIT_BUDGET_MS };

package/widget/telemetry/metrics.js

@@ -0,0 +1,120 @@
+import { isDebugMode } from "../../src/smart_website/utils.js";
+import { serverLogger } from "../server-logger.js";
+import { _extends } from "../../js/4101.js";
+
+
+
+
+/**
+ * Emit a distribution (timing) metric. NaN and non-positive deltas are
+ * filtered out so they are never sent to the server.
+ */ function emitTiming(metricName, deltaMs, tags) {
+    if (Number.isNaN(deltaMs) || deltaMs <= 0) return;
+    if (isDebugMode()) {
+        // eslint-disable-next-line no-console
+        console.log("[Metrics] " + metricName + ": timing " + deltaMs + "ms", tags != null ? tags : "");
+    }
+    serverLogger.serverLog({
+        message: metricName,
+        type: "log",
+        extra: _extends({
+            method: "dist",
+            operand: deltaMs
+        }, tags ? {
+            tags
+        } : {})
+    });
+}
+/**
+ * Emit a counter increment metric.
+ */ function emitIncrement(metricName, tags) {
+    if (isDebugMode()) {
+        // eslint-disable-next-line no-console
+        console.log("[Metrics] " + metricName + ": increment", tags != null ? tags : "");
+    }
+    serverLogger.serverLog({
+        message: metricName,
+        type: "log",
+        extra: _extends({
+            method: "inc"
+        }, tags ? {
+            tags
+        } : {})
+    });
+}
+// Matches bare qualified.js (hosted) and qualified-<hash>.js (self-hosted zip).
+const WIDGET_BUNDLE_NAME = /\/qualified(-[\w-]+)?\.js/;
+/** True when a performance-resource name is our widget bundle. */ function isWidgetBundleResource(name) {
+    return WIDGET_BUNDLE_NAME.test(name);
+}
+/**
+ * Page-origin-relative ms when Qualified began loading.
+ *
+ * Hosted snippet / self-hosted zip: the `startTime` of the `qualified.js` resource entry — when
+ * the browser began downloading our script. npm: our code is inlined into the consumer's
+ * content-hashed chunk, so there is no such entry; `setup()` records `window._q_setupCalledAt`
+ * instead and we fall back to it. `null` only when neither is available.
+ *
+ * Resolved lazily at the call site (init time), not at module eval — under npm the `setup()`
+ * timestamp is written after this module is imported, so a module-eval snapshot would miss it.
+ */ function resolveOriginTime(entries) {
+    var _window__q_setupCalledAt;
+    var _resourceEntries_find;
+    // Resolved lazily, so guard `getEntriesByType` — it is absent in some non-browser hosts and,
+    // unlike the old module-eval snapshot, this now runs at init time. Missing ⇒ no resource entry
+    // ⇒ fall through to the setup() timestamp.
+    const resourceEntries = entries != null ? entries : typeof performance.getEntriesByType === "function" ? performance.getEntriesByType("resource") : [];
+    const fromResource = (_resourceEntries_find = resourceEntries.find((entry)=>isWidgetBundleResource(entry.name))) == null ? void 0 : _resourceEntries_find.startTime;
+    if (fromResource != null) return fromResource;
+    return (_window__q_setupCalledAt = window._q_setupCalledAt) != null ? _window__q_setupCalledAt : null;
+}
+/**
+ * "npm" iff the ESM `setup()` entry ran (only it sets `_q_setupCalledAt`); "hosted" otherwise
+ * (snippet + self-hosted zip). Lets dashboards segment consumers whose page-origin-relative
+ * timings mean different things — an npm consumer calls `setup()` whenever it likes, so its
+ * `script_time_to_start_ms` includes their latency and reads as a regression if mixed in.
+ */ function widgetConsumer() {
+    return window._q_setupCalledAt === undefined ? "hosted" : "npm";
+}
+/**
+ * Records the time since the page's performance origin (`performance.now()`)
+ * at the moment `log()` is invoked, then ships it as a distribution metric.
+ *
+ * The first `log()` or `skip()` call latches the instance — subsequent calls
+ * are no-ops. Use `skip()` to permanently suppress the metric without emitting
+ * (e.g. when the first opportunity to record it has passed without the
+ * required preconditions, so a later attempt would record a misleading delta).
+ */ class InitializationMetric {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(metricName){
+        this.metricName = metricName;
+        this.logged = false;
+        this.log = ()=>{
+            if (this.logged) return;
+            // Always relative to widget init; skip when there's no baseline.
+            const startTime = window._q_widgetInitializedAt;
+            if (!startTime) return;
+            const delta = performance.now() - startTime;
+            emitTiming(this.metricName, delta);
+            this.logged = true;
+        };
+        this.skip = ()=>{
+            this.logged = true;
+        };
+    }
+}
+// TODO:
+// Add DeltaMetric class
+// Add IncrementMetric class
+const multimodal = {
+    timeToInit: new InitializationMetric("multimodal_time_to_init_ms"),
+    timeToReplaceGutter: new InitializationMetric("multimodal_time_to_replace_gutter_ms")
+};
+// TODO: Add other metric domains here
+const metrics = {
+    emitTiming: emitTiming,
+    emitIncrement: emitIncrement,
+    multimodal: multimodal
+};
+
+export { isWidgetBundleResource, metrics, resolveOriginTime, widgetConsumer };

package/widget/telemetry/span.js

@@ -0,0 +1,82 @@
+import { RandomIdGenerator } from "../../vendor/open-telemetry-idgenerator.js";
+import { SpanStatusCodeEnum } from "./telemetry.js";
+
+
+
+class Span {
+    get id() {
+        return this._id;
+    }
+    get name() {
+        return this._name;
+    }
+    get parentSpanId() {
+        return this._parentSpanId;
+    }
+    get attributes() {
+        return this._attributes;
+    }
+    get status() {
+        return this._status;
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    setAttributes(attributes) {
+        if (!attributes || Object.keys(attributes).length === 0) return;
+        for (const [key, value] of Object.entries(attributes)){
+            if (value) this.setAttribute(key, value);
+        }
+    }
+    setAttribute(attribute, value) {
+        this._attributes[attribute] = value;
+    }
+    setStatus(code, message) {
+        this._status = {
+            code,
+            message
+        };
+    }
+    constructor(name, parentSpanId){
+        this._status = {
+            code: SpanStatusCodeEnum.UNSET,
+            message: ""
+        };
+        this._id = new RandomIdGenerator().generateSpanId();
+        this._name = name;
+        this._parentSpanId = parentSpanId;
+        // OpenTelemetry allows Date, epoch milliseconds or performance.now()
+        // We assume performance.now in all cases
+        this._startTime = 0;
+        this._endTime = 0;
+        this._attributes = {};
+    }
+}
+class TimedSpan extends Span {
+    end() {
+        if (this.endTime !== 0) {
+            throw new Error("end() already called on span.");
+        }
+        this._endTime = performance.now();
+    }
+    constructor(name, attributes, parentSpanId){
+        super(name, parentSpanId);
+        this.setAttributes(attributes);
+        this._startTime = performance.now();
+    }
+}
+// Used to record Performance entries that occur out-of-band
+class PerformanceSpan extends Span {
+    constructor(name, attributes, parentSpanId, startTime, endTime){
+        super(name, parentSpanId);
+        this.setAttributes(attributes);
+        this._startTime = startTime;
+        this._endTime = endTime;
+    }
+}
+
+var span_Span = /* unused export */ undefined;
+export { PerformanceSpan, TimedSpan, span_Span as Span };