decocms 2.383.0 → 2.384.0

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.d.ts

@@ -0,0 +1,43 @@
+import type { DiagLogger, DiagLogFunction } from './types';
+type ConsoleMapKeys = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export declare const _originalConsoleMethods: Partial<Record<ConsoleMapKeys | 'log', typeof console.log>>;
+/**
+ * A simple Immutable Console based diagnostic logger which will output any messages to the Console.
+ * If you want to limit the amount of logging to a specific level or lower use the
+ * {@link createLogLevelDiagLogger}
+ *
+ * @since 1.0.0
+ */
+export declare class DiagConsoleLogger implements DiagLogger {
+    constructor();
+    /** Log an error scenario that was not expected and caused the requested operation to fail. */
+    error: DiagLogFunction;
+    /**
+     * Log a warning scenario to inform the developer of an issues that should be investigated.
+     * The requested operation may or may not have succeeded or completed.
+     */
+    warn: DiagLogFunction;
+    /**
+     * Log a general informational message, this should not affect functionality.
+     * This is also the default logging level so this should NOT be used for logging
+     * debugging level information.
+     */
+    info: DiagLogFunction;
+    /**
+     * Log a general debug message that can be useful for identifying a failure.
+     * Information logged at this level may include diagnostic details that would
+     * help identify a failure scenario. Useful scenarios would be to log the execution
+     * order of async operations
+     */
+    debug: DiagLogFunction;
+    /**
+     * Log a detailed (verbose) trace level logging that can be used to identify failures
+     * where debug level logging would be insufficient, this level of tracing can include
+     * input and output parameters and as such may include PII information passing through
+     * the API. As such it is recommended that this level of tracing should not be enabled
+     * in a production environment.
+     */
+    verbose: DiagLogFunction;
+}
+export {};
+//# sourceMappingURL=consoleLogger.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js

@@ -0,0 +1,69 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const consoleMap = [
+    { n: 'error', c: 'error' },
+    { n: 'warn', c: 'warn' },
+    { n: 'info', c: 'info' },
+    { n: 'debug', c: 'debug' },
+    { n: 'verbose', c: 'trace' },
+];
+// Save original console methods at module load time, before any instrumentation
+// can wrap them. This ensures DiagConsoleLogger calls the unwrapped originals.
+// Exported for testing only — not part of the public API.
+export const _originalConsoleMethods = {};
+if (typeof console !== 'undefined') {
+    const keys = [
+        'error',
+        'warn',
+        'info',
+        'debug',
+        'trace',
+        'log',
+    ];
+    for (const key of keys) {
+        // eslint-disable-next-line no-console
+        if (typeof console[key] === 'function') {
+            // eslint-disable-next-line no-console
+            _originalConsoleMethods[key] = console[key];
+        }
+    }
+}
+/**
+ * A simple Immutable Console based diagnostic logger which will output any messages to the Console.
+ * If you want to limit the amount of logging to a specific level or lower use the
+ * {@link createLogLevelDiagLogger}
+ *
+ * @since 1.0.0
+ */
+export class DiagConsoleLogger {
+    constructor() {
+        function _consoleFunc(funcName) {
+            return function (...args) {
+                // Prefer original (pre-instrumentation) methods saved at module load time.
+                let theFunc = _originalConsoleMethods[funcName];
+                // Some environments only expose the console when the F12 developer console is open
+                if (typeof theFunc !== 'function') {
+                    theFunc = _originalConsoleMethods['log'];
+                }
+                // Fall back in case console was not available at module load time but became available later.
+                if (typeof theFunc !== 'function' && console) {
+                    // eslint-disable-next-line no-console
+                    theFunc = console[funcName];
+                    if (typeof theFunc !== 'function') {
+                        // eslint-disable-next-line no-console
+                        theFunc = console.log;
+                    }
+                }
+                if (typeof theFunc === 'function') {
+                    return theFunc.apply(console, args);
+                }
+            };
+        }
+        for (let i = 0; i < consoleMap.length; i++) {
+            this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+        }
+    }
+}
+//# sourceMappingURL=consoleLogger.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleLogger.js","sourceRoot":"","sources":["../../../src/diag/consoleLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,UAAU,GAAiD;IAC/D,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE;IAC1B,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE;IACxB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE;IACxB,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE;IAC1B,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE;CAC7B,CAAC;AAEF,gFAAgF;AAChF,+EAA+E;AAC/E,0DAA0D;AAC1D,MAAM,CAAC,MAAM,uBAAuB,GAEhC,EAAE,CAAC;AACP,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE;IAClC,MAAM,IAAI,GAA+B;QACvC,OAAO;QACP,MAAM;QACN,MAAM;QACN,OAAO;QACP,OAAO;QACP,KAAK;KACN,CAAC;IACF,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;QACtB,sCAAsC;QACtC,IAAI,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,UAAU,EAAE;YACtC,sCAAsC;YACtC,uBAAuB,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;SAC7C;KACF;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,iBAAiB;IAC5B;QACE,SAAS,YAAY,CAAC,QAAwB;YAC5C,OAAO,UAAU,GAAG,IAAI;gBACtB,2EAA2E;gBAC3E,IAAI,OAAO,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;gBAChD,mFAAmF;gBACnF,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;oBACjC,OAAO,GAAG,uBAAuB,CAAC,KAAK,CAAC,CAAC;iBAC1C;gBACD,8FAA8F;gBAC9F,IAAI,OAAO,OAAO,KAAK,UAAU,IAAI,OAAO,EAAE;oBAC5C,sCAAsC;oBACtC,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAC5B,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;wBACjC,sCAAsC;wBACtC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;qBACvB;iBACF;gBACD,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;oBACjC,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;iBACrC;YACH,CAAC,CAAC;QACJ,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SACvD;IACH,CAAC;CAkCF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { DiagLogger, DiagLogFunction } from './types';\n\ntype ConsoleMapKeys = 'error' | 'warn' | 'info' | 'debug' | 'trace';\nconst consoleMap: { n: keyof DiagLogger; c: ConsoleMapKeys }[] = [\n  { n: 'error', c: 'error' },\n  { n: 'warn', c: 'warn' },\n  { n: 'info', c: 'info' },\n  { n: 'debug', c: 'debug' },\n  { n: 'verbose', c: 'trace' },\n];\n\n// Save original console methods at module load time, before any instrumentation\n// can wrap them. This ensures DiagConsoleLogger calls the unwrapped originals.\n// Exported for testing only — not part of the public API.\nexport const _originalConsoleMethods: Partial<\n  Record<ConsoleMapKeys | 'log', typeof console.log>\n> = {};\nif (typeof console !== 'undefined') {\n  const keys: (ConsoleMapKeys | 'log')[] = [\n    'error',\n    'warn',\n    'info',\n    'debug',\n    'trace',\n    'log',\n  ];\n  for (const key of keys) {\n    // eslint-disable-next-line no-console\n    if (typeof console[key] === 'function') {\n      // eslint-disable-next-line no-console\n      _originalConsoleMethods[key] = console[key];\n    }\n  }\n}\n\n/**\n * A simple Immutable Console based diagnostic logger which will output any messages to the Console.\n * If you want to limit the amount of logging to a specific level or lower use the\n * {@link createLogLevelDiagLogger}\n *\n * @since 1.0.0\n */\nexport class DiagConsoleLogger implements DiagLogger {\n  constructor() {\n    function _consoleFunc(funcName: ConsoleMapKeys): DiagLogFunction {\n      return function (...args) {\n        // Prefer original (pre-instrumentation) methods saved at module load time.\n        let theFunc = _originalConsoleMethods[funcName];\n        // Some environments only expose the console when the F12 developer console is open\n        if (typeof theFunc !== 'function') {\n          theFunc = _originalConsoleMethods['log'];\n        }\n        // Fall back in case console was not available at module load time but became available later.\n        if (typeof theFunc !== 'function' && console) {\n          // eslint-disable-next-line no-console\n          theFunc = console[funcName];\n          if (typeof theFunc !== 'function') {\n            // eslint-disable-next-line no-console\n            theFunc = console.log;\n          }\n        }\n        if (typeof theFunc === 'function') {\n          return theFunc.apply(console, args);\n        }\n      };\n    }\n\n    for (let i = 0; i < consoleMap.length; i++) {\n      this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);\n    }\n  }\n\n  /** Log an error scenario that was not expected and caused the requested operation to fail. */\n  public error!: DiagLogFunction;\n\n  /**\n   * Log a warning scenario to inform the developer of an issues that should be investigated.\n   * The requested operation may or may not have succeeded or completed.\n   */\n  public warn!: DiagLogFunction;\n\n  /**\n   * Log a general informational message, this should not affect functionality.\n   * This is also the default logging level so this should NOT be used for logging\n   * debugging level information.\n   */\n  public info!: DiagLogFunction;\n\n  /**\n   * Log a general debug message that can be useful for identifying a failure.\n   * Information logged at this level may include diagnostic details that would\n   * help identify a failure scenario. Useful scenarios would be to log the execution\n   * order of async operations\n   */\n  public debug!: DiagLogFunction;\n\n  /**\n   * Log a detailed (verbose) trace level logging that can be used to identify failures\n   * where debug level logging would be insufficient, this level of tracing can include\n   * input and output parameters and as such may include PII information passing through\n   * the API. As such it is recommended that this level of tracing should not be enabled\n   * in a production environment.\n   */\n  public verbose!: DiagLogFunction;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.d.ts

@@ -0,0 +1,4 @@
+import type { DiagLogger } from '../types';
+import { DiagLogLevel } from '../types';
+export declare function createLogLevelDiagLogger(maxLevel: DiagLogLevel, logger: DiagLogger): DiagLogger;
+//# sourceMappingURL=logLevelLogger.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DiagLogLevel } from '../types';
+export function createLogLevelDiagLogger(maxLevel, logger) {
+    if (maxLevel < DiagLogLevel.NONE) {
+        maxLevel = DiagLogLevel.NONE;
+    }
+    else if (maxLevel > DiagLogLevel.ALL) {
+        maxLevel = DiagLogLevel.ALL;
+    }
+    // In case the logger is null or undefined
+    logger = logger || {};
+    function _filterFunc(funcName, theLevel) {
+        const theFunc = logger[funcName];
+        if (typeof theFunc === 'function' && maxLevel >= theLevel) {
+            return theFunc.bind(logger);
+        }
+        return function () { };
+    }
+    return {
+        error: _filterFunc('error', DiagLogLevel.ERROR),
+        warn: _filterFunc('warn', DiagLogLevel.WARN),
+        info: _filterFunc('info', DiagLogLevel.INFO),
+        debug: _filterFunc('debug', DiagLogLevel.DEBUG),
+        verbose: _filterFunc('verbose', DiagLogLevel.VERBOSE),
+    };
+}
+//# sourceMappingURL=logLevelLogger.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelLogger.js","sourceRoot":"","sources":["../../../../src/diag/internal/logLevelLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,UAAU,wBAAwB,CACtC,QAAsB,EACtB,MAAkB;IAElB,IAAI,QAAQ,GAAG,YAAY,CAAC,IAAI,EAAE;QAChC,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC;KAC9B;SAAM,IAAI,QAAQ,GAAG,YAAY,CAAC,GAAG,EAAE;QACtC,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC;KAC7B;IAED,0CAA0C;IAC1C,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IAEtB,SAAS,WAAW,CAClB,QAA0B,EAC1B,QAAsB;QAEtB,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEjC,IAAI,OAAO,OAAO,KAAK,UAAU,IAAI,QAAQ,IAAI,QAAQ,EAAE;YACzD,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAC7B;QACD,OAAO,cAAa,CAAC,CAAC;IACxB,CAAC;IAED,OAAO;QACL,KAAK,EAAE,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;QAC/C,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC;QAC5C,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC;QAC5C,KAAK,EAAE,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;QAC/C,OAAO,EAAE,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC;KACtD,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { DiagLogFunction, DiagLogger } from '../types';\nimport { DiagLogLevel } from '../types';\n\nexport function createLogLevelDiagLogger(\n  maxLevel: DiagLogLevel,\n  logger: DiagLogger\n): DiagLogger {\n  if (maxLevel < DiagLogLevel.NONE) {\n    maxLevel = DiagLogLevel.NONE;\n  } else if (maxLevel > DiagLogLevel.ALL) {\n    maxLevel = DiagLogLevel.ALL;\n  }\n\n  // In case the logger is null or undefined\n  logger = logger || {};\n\n  function _filterFunc(\n    funcName: keyof DiagLogger,\n    theLevel: DiagLogLevel\n  ): DiagLogFunction {\n    const theFunc = logger[funcName];\n\n    if (typeof theFunc === 'function' && maxLevel >= theLevel) {\n      return theFunc.bind(logger);\n    }\n    return function () {};\n  }\n\n  return {\n    error: _filterFunc('error', DiagLogLevel.ERROR),\n    warn: _filterFunc('warn', DiagLogLevel.WARN),\n    info: _filterFunc('info', DiagLogLevel.INFO),\n    debug: _filterFunc('debug', DiagLogLevel.DEBUG),\n    verbose: _filterFunc('verbose', DiagLogLevel.VERBOSE),\n  };\n}\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/noopLogger.d.ts

@@ -0,0 +1,8 @@
+import type { DiagLogger } from '../types';
+/**
+ * Returns a No-Op Diagnostic logger where all messages do nothing.
+ * @implements {@link DiagLogger}
+ * @returns {DiagLogger}
+ */
+export declare function createNoopDiagLogger(): DiagLogger;
+//# sourceMappingURL=noopLogger.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/noopLogger.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function noopLogFunction() { }
+/**
+ * Returns a No-Op Diagnostic logger where all messages do nothing.
+ * @implements {@link DiagLogger}
+ * @returns {DiagLogger}
+ */
+export function createNoopDiagLogger() {
+    return {
+        verbose: noopLogFunction,
+        debug: noopLogFunction,
+        info: noopLogFunction,
+        warn: noopLogFunction,
+        error: noopLogFunction,
+    };
+}
+//# sourceMappingURL=noopLogger.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/internal/noopLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noopLogger.js","sourceRoot":"","sources":["../../../../src/diag/internal/noopLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,SAAS,eAAe,KAAI,CAAC;AAE7B;;;;GAIG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,OAAO,EAAE,eAAe;QACxB,KAAK,EAAE,eAAe;QACtB,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,eAAe;KACvB,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { DiagLogger } from '../types';\n\nfunction noopLogFunction() {}\n\n/**\n * Returns a No-Op Diagnostic logger where all messages do nothing.\n * @implements {@link DiagLogger}\n * @returns {DiagLogger}\n */\nexport function createNoopDiagLogger(): DiagLogger {\n  return {\n    verbose: noopLogFunction,\n    debug: noopLogFunction,\n    info: noopLogFunction,\n    warn: noopLogFunction,\n    error: noopLogFunction,\n  };\n}\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * @since 1.0.0
+ */
+export type DiagLogFunction = (message: string, ...args: unknown[]) => void;
+/**
+ * Defines an internal diagnostic logger interface which is used to log internal diagnostic
+ * messages, you can set the default diagnostic logger via the {@link DiagAPI} setLogger function.
+ * API provided implementations include :-
+ * - a No-Op {@link createNoopDiagLogger}
+ * - a {@link DiagLogLevel} filtering wrapper {@link createLogLevelDiagLogger}
+ * - a general Console {@link DiagConsoleLogger} version.
+ *
+ * @since 1.0.0
+ */
+export interface DiagLogger {
+    /** Log an error scenario that was not expected and caused the requested operation to fail. */
+    error: DiagLogFunction;
+    /**
+     * Log a warning scenario to inform the developer of an issues that should be investigated.
+     * The requested operation may or may not have succeeded or completed.
+     */
+    warn: DiagLogFunction;
+    /**
+     * Log a general informational message, this should not affect functionality.
+     * This is also the default logging level so this should NOT be used for logging
+     * debugging level information.
+     */
+    info: DiagLogFunction;
+    /**
+     * Log a general debug message that can be useful for identifying a failure.
+     * Information logged at this level may include diagnostic details that would
+     * help identify a failure scenario.
+     * For example: Logging the order of execution of async operations.
+     */
+    debug: DiagLogFunction;
+    /**
+     * Log a detailed (verbose) trace level logging that can be used to identify failures
+     * where debug level logging would be insufficient, this level of tracing can include
+     * input and output parameters and as such may include PII information passing through
+     * the API. As such it is recommended that this level of tracing should not be enabled
+     * in a production environment.
+     */
+    verbose: DiagLogFunction;
+}
+/**
+ * Defines the available internal logging levels for the diagnostic logger, the numeric values
+ * of the levels are defined to match the original values from the initial LogLevel to avoid
+ * compatibility/migration issues for any implementation that assume the numeric ordering.
+ */
+export declare enum DiagLogLevel {
+    /** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+    NONE = 0,
+    /** Identifies an error scenario */
+    ERROR = 30,
+    /** Identifies a warning scenario */
+    WARN = 50,
+    /** General informational log message */
+    INFO = 60,
+    /** General debug log message */
+    DEBUG = 70,
+    /**
+     * Detailed trace level logging should only be used for development, should only be set
+     * in a development environment.
+     */
+    VERBOSE = 80,
+    /** Used to set the logging level to include all logging */
+    ALL = 9999
+}
+/**
+ * Defines options for ComponentLogger
+ *
+ * @since 1.0.0
+ */
+export interface ComponentLoggerOptions {
+    namespace: string;
+}
+/**
+ * @since 1.4.1
+ */
+export interface DiagLoggerOptions {
+    /**
+     * The {@link DiagLogLevel} used to filter logs sent to the logger.
+     *
+     * @defaultValue DiagLogLevel.INFO
+     */
+    logLevel?: DiagLogLevel;
+    /**
+     * Setting this value to `true` will suppress the warning message normally emitted when registering a logger when another logger is already registered.
+     */
+    suppressOverrideMessage?: boolean;
+}
+export interface DiagLoggerApi {
+    /**
+     * Set the global DiagLogger and DiagLogLevel.
+     * If a global diag logger is already set, this will override it.
+     *
+     * @param logger - The {@link DiagLogger} instance to set as the default logger.
+     * @param options - A {@link DiagLoggerOptions} object. If not provided, default values will be set.
+     * @returns `true` if the logger was successfully registered, else `false`
+     */
+    setLogger(logger: DiagLogger, options?: DiagLoggerOptions): boolean;
+    /**
+     *
+     * @param logger - The {@link DiagLogger} instance to set as the default logger.
+     * @param logLevel - The {@link DiagLogLevel} used to filter logs sent to the logger. If not provided it will default to {@link DiagLogLevel.INFO}.
+     * @returns `true` if the logger was successfully registered, else `false`
+     */
+    setLogger(logger: DiagLogger, logLevel?: DiagLogLevel): boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/types.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Defines the available internal logging levels for the diagnostic logger, the numeric values
+ * of the levels are defined to match the original values from the initial LogLevel to avoid
+ * compatibility/migration issues for any implementation that assume the numeric ordering.
+ */
+export var DiagLogLevel;
+(function (DiagLogLevel) {
+    /** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+    DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE";
+    /** Identifies an error scenario */
+    DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR";
+    /** Identifies a warning scenario */
+    DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN";
+    /** General informational log message */
+    DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO";
+    /** General debug log message */
+    DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG";
+    /**
+     * Detailed trace level logging should only be used for development, should only be set
+     * in a development environment.
+     */
+    DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE";
+    /** Used to set the logging level to include all logging */
+    DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+//# sourceMappingURL=types.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/diag/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoDH;;;;GAIG;AACH,MAAM,CAAN,IAAY,YAwBX;AAxBD,WAAY,YAAY;IACtB,uFAAuF;IACvF,+CAAQ,CAAA;IAER,mCAAmC;IACnC,kDAAU,CAAA;IAEV,oCAAoC;IACpC,gDAAS,CAAA;IAET,wCAAwC;IACxC,gDAAS,CAAA;IAET,gCAAgC;IAChC,kDAAU,CAAA;IAEV;;;OAGG;IACH,sDAAY,CAAA;IAEZ,2DAA2D;IAC3D,gDAAU,CAAA;AACZ,CAAC,EAxBW,YAAY,KAAZ,YAAY,QAwBvB","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @since 1.0.0\n */\nexport type DiagLogFunction = (message: string, ...args: unknown[]) => void;\n\n/**\n * Defines an internal diagnostic logger interface which is used to log internal diagnostic\n * messages, you can set the default diagnostic logger via the {@link DiagAPI} setLogger function.\n * API provided implementations include :-\n * - a No-Op {@link createNoopDiagLogger}\n * - a {@link DiagLogLevel} filtering wrapper {@link createLogLevelDiagLogger}\n * - a general Console {@link DiagConsoleLogger} version.\n *\n * @since 1.0.0\n */\nexport interface DiagLogger {\n  /** Log an error scenario that was not expected and caused the requested operation to fail. */\n  error: DiagLogFunction;\n\n  /**\n   * Log a warning scenario to inform the developer of an issues that should be investigated.\n   * The requested operation may or may not have succeeded or completed.\n   */\n  warn: DiagLogFunction;\n\n  /**\n   * Log a general informational message, this should not affect functionality.\n   * This is also the default logging level so this should NOT be used for logging\n   * debugging level information.\n   */\n  info: DiagLogFunction;\n\n  /**\n   * Log a general debug message that can be useful for identifying a failure.\n   * Information logged at this level may include diagnostic details that would\n   * help identify a failure scenario.\n   * For example: Logging the order of execution of async operations.\n   */\n  debug: DiagLogFunction;\n\n  /**\n   * Log a detailed (verbose) trace level logging that can be used to identify failures\n   * where debug level logging would be insufficient, this level of tracing can include\n   * input and output parameters and as such may include PII information passing through\n   * the API. As such it is recommended that this level of tracing should not be enabled\n   * in a production environment.\n   */\n  verbose: DiagLogFunction;\n}\n\n/**\n * Defines the available internal logging levels for the diagnostic logger, the numeric values\n * of the levels are defined to match the original values from the initial LogLevel to avoid\n * compatibility/migration issues for any implementation that assume the numeric ordering.\n */\nexport enum DiagLogLevel {\n  /** Diagnostic Logging level setting to disable all logging (except and forced logs) */\n  NONE = 0,\n\n  /** Identifies an error scenario */\n  ERROR = 30,\n\n  /** Identifies a warning scenario */\n  WARN = 50,\n\n  /** General informational log message */\n  INFO = 60,\n\n  /** General debug log message */\n  DEBUG = 70,\n\n  /**\n   * Detailed trace level logging should only be used for development, should only be set\n   * in a development environment.\n   */\n  VERBOSE = 80,\n\n  /** Used to set the logging level to include all logging */\n  ALL = 9999,\n}\n\n/**\n * Defines options for ComponentLogger\n *\n * @since 1.0.0\n */\nexport interface ComponentLoggerOptions {\n  namespace: string;\n}\n\n/**\n * @since 1.4.1\n */\nexport interface DiagLoggerOptions {\n  /**\n   * The {@link DiagLogLevel} used to filter logs sent to the logger.\n   *\n   * @defaultValue DiagLogLevel.INFO\n   */\n  logLevel?: DiagLogLevel;\n\n  /**\n   * Setting this value to `true` will suppress the warning message normally emitted when registering a logger when another logger is already registered.\n   */\n  suppressOverrideMessage?: boolean;\n}\n\nexport interface DiagLoggerApi {\n  /**\n   * Set the global DiagLogger and DiagLogLevel.\n   * If a global diag logger is already set, this will override it.\n   *\n   * @param logger - The {@link DiagLogger} instance to set as the default logger.\n   * @param options - A {@link DiagLoggerOptions} object. If not provided, default values will be set.\n   * @returns `true` if the logger was successfully registered, else `false`\n   */\n  setLogger(logger: DiagLogger, options?: DiagLoggerOptions): boolean;\n\n  /**\n   *\n   * @param logger - The {@link DiagLogger} instance to set as the default logger.\n   * @param logLevel - The {@link DiagLogLevel} used to filter logs sent to the logger. If not provided it will default to {@link DiagLogLevel.INFO}.\n   * @returns `true` if the logger was successfully registered, else `false`\n   */\n  setLogger(logger: DiagLogger, logLevel?: DiagLogLevel): boolean;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag-api.d.ts

@@ -0,0 +1,11 @@
+import { DiagAPI } from './api/diag';
+/**
+ * Entrypoint for Diag API.
+ * Defines Diagnostic handler used for internal diagnostic logging operations.
+ * The default provides a Noop DiagLogger implementation which may be changed via the
+ * diag.setLogger(logger: DiagLogger) function.
+ *
+ * @since 1.0.0
+ */
+export declare const diag: DiagAPI;
+//# sourceMappingURL=diag-api.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag-api.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+import { DiagAPI } from './api/diag';
+/**
+ * Entrypoint for Diag API.
+ * Defines Diagnostic handler used for internal diagnostic logging operations.
+ * The default provides a Noop DiagLogger implementation which may be changed via the
+ * diag.setLogger(logger: DiagLogger) function.
+ *
+ * @since 1.0.0
+ */
+export const diag = DiagAPI.instance();
+//# sourceMappingURL=diag-api.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/diag-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diag-api.js","sourceRoot":"","sources":["../../src/diag-api.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,sEAAsE;AACtE,qCAAqC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { DiagAPI } from './api/diag';\n/**\n * Entrypoint for Diag API.\n * Defines Diagnostic handler used for internal diagnostic logging operations.\n * The default provides a Noop DiagLogger implementation which may be changed via the\n * diag.setLogger(logger: DiagLogger) function.\n *\n * @since 1.0.0\n */\nexport const diag = DiagAPI.instance();\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Any exports here may change at any time and without warning
+ * @module @opentelemetry/api/experimental
+ */
+export { wrapTracer, SugaredTracer } from './trace/SugaredTracer';
+export type { SugaredSpanOptions } from './trace/SugaredOptions';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/index.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Any exports here may change at any time and without warning
+ * @module @opentelemetry/api/experimental
+ */
+export { wrapTracer, SugaredTracer } from './trace/SugaredTracer';
+//# sourceMappingURL=index.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/experimental/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * Any exports here may change at any time and without warning\n * @module @opentelemetry/api/experimental\n */\n\nexport { wrapTracer, SugaredTracer } from './trace/SugaredTracer';\nexport type { SugaredSpanOptions } from './trace/SugaredOptions';\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.d.ts

@@ -0,0 +1,13 @@
+import type { Span, SpanOptions } from '../../';
+/**
+ * Options needed for span creation
+ */
+export interface SugaredSpanOptions extends SpanOptions {
+    /**
+     * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function.
+     * @param e Error which triggered this exception
+     * @param span current span from context
+     */
+    onException?: (e: Error, span: Span) => void;
+}
+//# sourceMappingURL=SugaredOptions.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=SugaredOptions.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredOptions.js","sourceRoot":"","sources":["../../../../src/experimental/trace/SugaredOptions.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Span, SpanOptions } from '../../';\n\n/**\n * Options needed for span creation\n */\nexport interface SugaredSpanOptions extends SpanOptions {\n  /**\n   * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function.\n   * @param e Error which triggered this exception\n   * @param span current span from context\n   */\n  onException?: (e: Error, span: Span) => void;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.d.ts

@@ -0,0 +1,64 @@
+import type { SugaredSpanOptions } from './SugaredOptions';
+import type { Context, Span, Tracer } from '../../';
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+export declare function wrapTracer(tracer: Tracer): SugaredTracer;
+export declare class SugaredTracer implements Tracer {
+    private readonly _tracer;
+    constructor(tracer: Tracer);
+    startActiveSpan: Tracer['startActiveSpan'];
+    startSpan: Tracer['startSpan'];
+    /**
+     * Starts a new {@link Span} and calls the given function passing it the
+     * created span as first argument.
+     * Additionally, the new span gets set in context and this context is activated
+     * for the duration of the function call.
+     * The span will be closed after the function has executed.
+     * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.
+     *
+     * @param name The name of the span
+     * @param [options] SugaredSpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @param fn function called in the context of the span and receives the newly created span as an argument
+     * @returns return value of fn
+     * @example
+     *     const something = tracer.withActiveSpan('op', span => {
+     *      // do some work
+     *     });
+     * @example
+     *     const something = await tracer.withActiveSpan('op', span => {
+     *      // do some async work
+     *     });
+     */
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+    /**
+     * Starts a new {@link Span} and ends it after execution of fn without setting it on context.
+     * The span will be closed after the function has executed.
+     * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.
+     *
+     * This method does NOT modify the current Context.
+     *
+     * @param name The name of the span
+     * @param [options] SugaredSpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @param fn function called in the context of the span and receives the newly created span as an argument
+     * @returns Span The newly created span
+     * @example
+     *     const something = tracer.withSpan('op', span => {
+     *      // do some work
+     *     });
+     * @example
+     *     const something = await tracer.withSpan('op', span => {
+     *      // do some async work
+     *     });
+     */
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+}
+//# sourceMappingURL=SugaredTracer.d.ts.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js

@@ -0,0 +1,88 @@
+import { context as contextApi, SpanStatusCode } from '../../';
+const defaultOnException = (e, span) => {
+    span.recordException(e);
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+    });
+};
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+export function wrapTracer(tracer) {
+    return new SugaredTracer(tracer);
+}
+export class SugaredTracer {
+    constructor(tracer) {
+        this._tracer = tracer;
+        this.startSpan = tracer.startSpan.bind(this._tracer);
+        this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+    }
+    withActiveSpan(name, arg2, arg3, arg4) {
+        const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+        return this._tracer.startActiveSpan(name, opts, ctx, (span) => handleFn(span, opts, fn));
+    }
+    withSpan(name, arg2, arg3, arg4) {
+        const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+        const span = this._tracer.startSpan(name, opts, ctx);
+        return handleFn(span, opts, fn);
+    }
+}
+/**
+ * Massages parameters of withSpan and withActiveSpan to allow signature overwrites
+ * @param arg
+ * @param arg2
+ * @param arg3
+ */
+function massageParams(arg, arg2, arg3) {
+    let opts;
+    let ctx;
+    let fn;
+    if (!arg2 && !arg3) {
+        fn = arg;
+    }
+    else if (!arg3) {
+        opts = arg;
+        fn = arg2;
+    }
+    else {
+        opts = arg;
+        ctx = arg2;
+        fn = arg3;
+    }
+    opts = opts !== null && opts !== void 0 ? opts : {};
+    ctx = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+    return { opts, ctx, fn };
+}
+/**
+ * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling
+ * @param span
+ * @param opts
+ * @param fn
+ */
+function handleFn(span, opts, fn) {
+    var _a;
+    const onException = (_a = opts.onException) !== null && _a !== void 0 ? _a : defaultOnException;
+    const errorHandler = (e) => {
+        onException(e, span);
+        span.end();
+        throw e;
+    };
+    try {
+        const ret = fn(span);
+        // if fn is an async function, attach a recordException and spanEnd callback to the promise
+        if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === 'function') {
+            return ret.then(val => {
+                span.end();
+                return val;
+            }, errorHandler);
+        }
+        span.end();
+        return ret;
+    }
+    catch (e) {
+        // add throw to signal the compiler that this will throw in the inner scope
+        throw errorHandler(e);
+    }
+}
+//# sourceMappingURL=SugaredTracer.js.map

package/dist/server/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.js","sourceRoot":"","sources":["../../../../src/experimental/trace/SugaredTracer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { SugaredSpanOptions } from './SugaredOptions';\nimport type { Context, Span, Tracer } from '../../';\nimport { context as contextApi, SpanStatusCode } from '../../';\n\nconst defaultOnException = (e: Error, span: Span) => {\n  span.recordException(e);\n  span.setStatus({\n    code: SpanStatusCode.ERROR,\n  });\n};\n\n/**\n * return a new SugaredTracer created from the supplied one\n * @param tracer\n */\nexport function wrapTracer(tracer: Tracer): SugaredTracer {\n  return new SugaredTracer(tracer);\n}\n\nexport class SugaredTracer implements Tracer {\n  private readonly _tracer: Tracer;\n\n  constructor(tracer: Tracer) {\n    this._tracer = tracer;\n    this.startSpan = tracer.startSpan.bind(this._tracer);\n    this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);\n  }\n\n  startActiveSpan: Tracer['startActiveSpan'];\n  startSpan: Tracer['startSpan'];\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally, the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *     const something = tracer.withActiveSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withActiveSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: F | SugaredSpanOptions,\n    arg3?: F | Context,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    return this._tracer.startActiveSpan(name, opts, ctx, (span: Span) =>\n      handleFn(span, opts, fn)\n    ) as ReturnType<F>;\n  }\n\n  /**\n   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.\n   *\n   * This method does NOT modify the current Context.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns Span The newly created span\n   * @example\n   *     const something = tracer.withSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: SugaredSpanOptions | F,\n    arg3?: Context | F,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    const span = this._tracer.startSpan(name, opts, ctx);\n    return handleFn(span, opts, fn) as ReturnType<F>;\n  }\n}\n\n/**\n * Massages parameters of withSpan and withActiveSpan to allow signature overwrites\n * @param arg\n * @param arg2\n * @param arg3\n */\nfunction massageParams<F extends (span: Span) => ReturnType<F>>(\n  arg: F | SugaredSpanOptions,\n  arg2?: F | Context,\n  arg3?: F\n) {\n  let opts: SugaredSpanOptions | undefined;\n  let ctx: Context | undefined;\n  let fn: F;\n\n  if (!arg2 && !arg3) {\n    fn = arg as F;\n  } else if (!arg3) {\n    opts = arg as SugaredSpanOptions;\n    fn = arg2 as F;\n  } else {\n    opts = arg as SugaredSpanOptions;\n    ctx = arg2 as Context;\n    fn = arg3 as F;\n  }\n  opts = opts ?? {};\n  ctx = ctx ?? contextApi.active();\n\n  return { opts, ctx, fn };\n}\n\n/**\n * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling\n * @param span\n * @param opts\n * @param fn\n */\nfunction handleFn<F extends (span: Span) => ReturnType<F>>(\n  span: Span,\n  opts: SugaredSpanOptions,\n  fn: F\n): ReturnType<F> {\n  const onException = opts.onException ?? defaultOnException;\n  const errorHandler = (e: Error) => {\n    onException(e, span);\n    span.end();\n    throw e;\n  };\n\n  try {\n    const ret = fn(span) as Promise<ReturnType<F>>;\n    // if fn is an async function, attach a recordException and spanEnd callback to the promise\n    if (typeof ret?.then === 'function') {\n      return ret.then(val => {\n        span.end();\n        return val;\n      }, errorHandler) as ReturnType<F>;\n    }\n    span.end();\n    return ret as ReturnType<F>;\n  } catch (e) {\n    // add throw to signal the compiler that this will throw in the inner scope\n    throw errorHandler(e);\n  }\n}\n"]}