@tickernelz/paperclip-pro-server 2026.1017.2 → 2026.1021.0

package/node_modules/@opentelemetry/api/dist/context/types.d.cts

@@ -0,0 +1,92 @@
+//#region src/context/types.d.ts
+/**
+ * @since 1.0.0
+ */
+interface Context {
+  /**
+   * Get a value from the context.
+   *
+   * @param key key which identifies a context value
+   */
+  getValue(key: symbol): unknown;
+  /**
+   * Create a new context which inherits from this context and has
+   * the given key set to the given value.
+   *
+   * @param key context key for which to set the value
+   * @param value value to set for the given key
+   */
+  setValue(key: symbol, value: unknown): Context;
+  /**
+   * Return a new context which inherits from this context but does
+   * not contain a value for the given key.
+   *
+   * @param key context key for which to clear a value
+   */
+  deleteValue(key: symbol): Context;
+}
+/**
+ * A scope token returned by {@link ContextManager.attach} that restores the previous
+ * {@link Context} when disposed. Call `token.dispose()` to restore the previous context.
+ *
+ * @since 1.10.0
+ * @experimental This API is experimental and may change in minor releases without prior notice.
+ */
+interface ContextManagementToken {
+  dispose(): void;
+}
+/**
+ * @since 1.0.0
+ */
+interface ContextManager {
+  /**
+   * Get the current active context
+   */
+  active(): Context;
+  /**
+   * Run the fn callback with object set as the current active context
+   * @param context Any object to set as the current active context
+   * @param fn A callback to be immediately run within a specific context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: Context, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+  /**
+   * Bind an object as the current context (or a specific one)
+   * @param [context] Optionally specify the context which you want to assign
+   * @param target Any object to which a context need to be set
+   */
+  bind<T>(context: Context, target: T): T;
+  /**
+   * Enable context management
+   */
+  enable(): this;
+  /**
+   * Disable context management
+   */
+  disable(): this;
+  /**
+   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose
+   * {@link ContextManagementToken.dispose} method restores the previous context.
+   *
+   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which
+   * restore context automatically. `attach` exists only to bridge callback
+   * boundaries that `with` cannot wrap. The caller is responsible for disposing
+   * the token via `token.dispose()` when the operation is complete. Support is
+   * optional and best-effort; when omitted, {@link ContextAPI.attach} logs a
+   * warning and returns a no-op token.
+   *
+   * **Caveat for async functions:** If called inside an async function before
+   * the first `await`, the context change may leak into the caller's context
+   * and remain active there. Prefer {@link with} for async code.
+   *
+   * @param context The Context to attach
+   * @returns A {@link ContextManagementToken} whose dispose() restores the previous Context
+   * @since 1.10.0
+   * @experimental This API is experimental and may change in minor releases without prior notice.
+   */
+  attach?(context: Context): ContextManagementToken;
+}
+//#endregion
+export { Context, ContextManagementToken, ContextManager };
+//# sourceMappingURL=types.d.cts.map

package/node_modules/@opentelemetry/api/dist/context/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/context/types.d.ts"],"mappings":";;;;UAGiB;;;;;;EAMb,SAAS;;;;;;;;EAQT,SAAS,aAAa,iBAAiB;;;;;;;EAOvC,YAAY,cAAc;;;;;;;;;UASb;EACb;;;;;UAKa;;;;EAIb,UAAU;;;;;;;;EAQV,KAAK,qBAAqB,cAAc,MAAM,MAAM,WAAW,IAAI,SAAS,SAAS,IAAI,GAAG,UAAU,kBAAkB,OAAO,MAAM,IAAI,WAAW;;;;;;EAMpJ,KAAK,GAAG,SAAS,SAAS,QAAQ,IAAI;;;;EAItC;;;;EAIA;;;;;;;;;;;;;;;;;;;;;EAqBA,QAAQ,SAAS,UAAU"}

package/node_modules/@opentelemetry/api/dist/context/types.d.mts

@@ -0,0 +1,92 @@
+//#region src/context/types.d.ts
+/**
+ * @since 1.0.0
+ */
+interface Context {
+  /**
+   * Get a value from the context.
+   *
+   * @param key key which identifies a context value
+   */
+  getValue(key: symbol): unknown;
+  /**
+   * Create a new context which inherits from this context and has
+   * the given key set to the given value.
+   *
+   * @param key context key for which to set the value
+   * @param value value to set for the given key
+   */
+  setValue(key: symbol, value: unknown): Context;
+  /**
+   * Return a new context which inherits from this context but does
+   * not contain a value for the given key.
+   *
+   * @param key context key for which to clear a value
+   */
+  deleteValue(key: symbol): Context;
+}
+/**
+ * A scope token returned by {@link ContextManager.attach} that restores the previous
+ * {@link Context} when disposed. Call `token.dispose()` to restore the previous context.
+ *
+ * @since 1.10.0
+ * @experimental This API is experimental and may change in minor releases without prior notice.
+ */
+interface ContextManagementToken {
+  dispose(): void;
+}
+/**
+ * @since 1.0.0
+ */
+interface ContextManager {
+  /**
+   * Get the current active context
+   */
+  active(): Context;
+  /**
+   * Run the fn callback with object set as the current active context
+   * @param context Any object to set as the current active context
+   * @param fn A callback to be immediately run within a specific context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: Context, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+  /**
+   * Bind an object as the current context (or a specific one)
+   * @param [context] Optionally specify the context which you want to assign
+   * @param target Any object to which a context need to be set
+   */
+  bind<T>(context: Context, target: T): T;
+  /**
+   * Enable context management
+   */
+  enable(): this;
+  /**
+   * Disable context management
+   */
+  disable(): this;
+  /**
+   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose
+   * {@link ContextManagementToken.dispose} method restores the previous context.
+   *
+   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which
+   * restore context automatically. `attach` exists only to bridge callback
+   * boundaries that `with` cannot wrap. The caller is responsible for disposing
+   * the token via `token.dispose()` when the operation is complete. Support is
+   * optional and best-effort; when omitted, {@link ContextAPI.attach} logs a
+   * warning and returns a no-op token.
+   *
+   * **Caveat for async functions:** If called inside an async function before
+   * the first `await`, the context change may leak into the caller's context
+   * and remain active there. Prefer {@link with} for async code.
+   *
+   * @param context The Context to attach
+   * @returns A {@link ContextManagementToken} whose dispose() restores the previous Context
+   * @since 1.10.0
+   * @experimental This API is experimental and may change in minor releases without prior notice.
+   */
+  attach?(context: Context): ContextManagementToken;
+}
+//#endregion
+export { Context, ContextManagementToken, ContextManager };
+//# sourceMappingURL=types.d.mts.map

package/node_modules/@opentelemetry/api/dist/context/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/context/types.d.ts"],"mappings":";;;;UAGiB;;;;;;EAMb,SAAS;;;;;;;;EAQT,SAAS,aAAa,iBAAiB;;;;;;;EAOvC,YAAY,cAAc;;;;;;;;;UASb;EACb;;;;;UAKa;;;;EAIb,UAAU;;;;;;;;EAQV,KAAK,qBAAqB,cAAc,MAAM,MAAM,WAAW,IAAI,SAAS,SAAS,IAAI,GAAG,UAAU,kBAAkB,OAAO,MAAM,IAAI,WAAW;;;;;;EAMpJ,KAAK,GAAG,SAAS,SAAS,QAAQ,IAAI;;;;EAItC;;;;EAIA;;;;;;;;;;;;;;;;;;;;;EAqBA,QAAQ,SAAS,UAAU"}

package/node_modules/@opentelemetry/api/dist/context-api.cjs

@@ -0,0 +1,10 @@
+//#region src/context-api.ts
+/**
+* Entrypoint for context API
+* @since 1.0.0
+*/
+const context = require("./api/context.cjs").ContextAPI.getInstance();
+//#endregion
+exports.context = context;
+
+//# sourceMappingURL=context-api.cjs.map

package/node_modules/@opentelemetry/api/dist/context-api.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-api.cjs","names":["ContextAPI"],"sources":["../src/context-api.ts"],"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 { ContextAPI } from './api/context';\n/**\n * Entrypoint for context API\n * @since 1.0.0\n */\nexport const context = ContextAPI.getInstance();\n"],"mappings":";;;;;AAYA,MAAa,qCAAUA,CAAAA,CAAAA,WAAW,YAAY"}

package/node_modules/@opentelemetry/api/dist/context-api.d.cts

@@ -0,0 +1,10 @@
+import { ContextAPI } from "./api/context.cjs";
+//#region src/context-api.d.ts
+/**
+ * Entrypoint for context API
+ * @since 1.0.0
+ */
+declare const context: ContextAPI;
+//#endregion
+export { context };
+//# sourceMappingURL=context-api.d.cts.map

package/node_modules/@opentelemetry/api/dist/context-api.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-api.d.cts","names":[],"sources":["../src/context-api.d.ts"],"mappings":";;;;;;cAKqB,SAAS"}

package/node_modules/@opentelemetry/api/dist/context-api.d.mts

@@ -0,0 +1,10 @@
+import { ContextAPI } from "./api/context.mjs";
+//#region src/context-api.d.ts
+/**
+ * Entrypoint for context API
+ * @since 1.0.0
+ */
+declare const context: ContextAPI;
+//#endregion
+export { context };
+//# sourceMappingURL=context-api.d.mts.map

package/node_modules/@opentelemetry/api/dist/context-api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-api.d.mts","names":[],"sources":["../src/context-api.d.ts"],"mappings":";;;;;;cAKqB,SAAS"}

package/node_modules/@opentelemetry/api/dist/context-api.mjs

@@ -0,0 +1,11 @@
+import { ContextAPI } from "./api/context.mjs";
+//#region src/context-api.ts
+/**
+* Entrypoint for context API
+* @since 1.0.0
+*/
+const context = ContextAPI.getInstance();
+//#endregion
+export { context };
+
+//# sourceMappingURL=context-api.mjs.map

package/node_modules/@opentelemetry/api/dist/context-api.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-api.mjs","names":[],"sources":["../src/context-api.ts"],"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 { ContextAPI } from './api/context';\n/**\n * Entrypoint for context API\n * @since 1.0.0\n */\nexport const context = ContextAPI.getInstance();\n"],"mappings":";;;;;;AAYA,MAAa,UAAU,WAAW,YAAY"}

package/node_modules/@opentelemetry/api/dist/diag/ComponentLogger.cjs

@@ -0,0 +1,40 @@
+const require_global_utils = require("../internal/global-utils.cjs");
+//#region src/diag/ComponentLogger.ts
+/**
+* Component Logger which is meant to be used as part of any component which
+* will add automatically additional namespace in front of the log message.
+* It will then forward all message to global diag logger
+* @example
+* const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
+* cLogger.debug('test');
+* // @opentelemetry/instrumentation-http test
+*/
+var DiagComponentLogger = class {
+	constructor(props) {
+		this._namespace = props.namespace || "DiagComponentLogger";
+	}
+	debug(...args) {
+		return logProxy("debug", this._namespace, args);
+	}
+	error(...args) {
+		return logProxy("error", this._namespace, args);
+	}
+	info(...args) {
+		return logProxy("info", this._namespace, args);
+	}
+	warn(...args) {
+		return logProxy("warn", this._namespace, args);
+	}
+	verbose(...args) {
+		return logProxy("verbose", this._namespace, args);
+	}
+};
+function logProxy(funcName, namespace, args) {
+	const logger = require_global_utils.getGlobal("diag");
+	if (!logger) return;
+	return logger[funcName](namespace, ...args);
+}
+//#endregion
+exports.DiagComponentLogger = DiagComponentLogger;
+
+//# sourceMappingURL=ComponentLogger.cjs.map

package/node_modules/@opentelemetry/api/dist/diag/ComponentLogger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentLogger.cjs","names":["getGlobal"],"sources":["../../src/diag/ComponentLogger.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { getGlobal } from '../internal/global-utils';\nimport type { ComponentLoggerOptions, DiagLogger } from './types';\n\n/**\n * Component Logger which is meant to be used as part of any component which\n * will add automatically additional namespace in front of the log message.\n * It will then forward all message to global diag logger\n * @example\n * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });\n * cLogger.debug('test');\n * // @opentelemetry/instrumentation-http test\n */\nexport class DiagComponentLogger implements DiagLogger {\n  private _namespace: string;\n\n  constructor(props: ComponentLoggerOptions) {\n    this._namespace = props.namespace || 'DiagComponentLogger';\n  }\n\n  public debug(...args: unknown[]): void {\n    return logProxy('debug', this._namespace, args);\n  }\n\n  public error(...args: unknown[]): void {\n    return logProxy('error', this._namespace, args);\n  }\n\n  public info(...args: unknown[]): void {\n    return logProxy('info', this._namespace, args);\n  }\n\n  public warn(...args: unknown[]): void {\n    return logProxy('warn', this._namespace, args);\n  }\n\n  public verbose(...args: unknown[]): void {\n    return logProxy('verbose', this._namespace, args);\n  }\n}\n\nfunction logProxy(\n  funcName: keyof DiagLogger,\n  namespace: string,\n  args: unknown[]\n): void {\n  const logger = getGlobal('diag');\n  // shortcut if logger not set\n  if (!logger) {\n    return;\n  }\n\n  return logger[funcName](namespace, ...args);\n}\n"],"mappings":";;;;;;;;;;;AAiBA,IAAa,sBAAb,MAAuD;CAGrD,YAAY,OAA+B;EACzC,KAAK,aAAa,MAAM,aAAa;CACvC;CAEA,MAAa,GAAG,MAAuB;EACrC,OAAO,SAAS,SAAS,KAAK,YAAY,IAAI;CAChD;CAEA,MAAa,GAAG,MAAuB;EACrC,OAAO,SAAS,SAAS,KAAK,YAAY,IAAI;CAChD;CAEA,KAAY,GAAG,MAAuB;EACpC,OAAO,SAAS,QAAQ,KAAK,YAAY,IAAI;CAC/C;CAEA,KAAY,GAAG,MAAuB;EACpC,OAAO,SAAS,QAAQ,KAAK,YAAY,IAAI;CAC/C;CAEA,QAAe,GAAG,MAAuB;EACvC,OAAO,SAAS,WAAW,KAAK,YAAY,IAAI;CAClD;AACF;AAEA,SAAS,SACP,UACA,WACA,MACM;CACN,MAAM,SAASA,qBAAAA,UAAU,MAAM;CAE/B,IAAI,CAAC,QACH;CAGF,OAAO,OAAO,SAAS,CAAC,WAAW,GAAG,IAAI;AAC5C"}

package/node_modules/@opentelemetry/api/dist/diag/ComponentLogger.mjs

@@ -0,0 +1,40 @@
+import { getGlobal } from "../internal/global-utils.mjs";
+//#region src/diag/ComponentLogger.ts
+/**
+* Component Logger which is meant to be used as part of any component which
+* will add automatically additional namespace in front of the log message.
+* It will then forward all message to global diag logger
+* @example
+* const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
+* cLogger.debug('test');
+* // @opentelemetry/instrumentation-http test
+*/
+var DiagComponentLogger = class {
+	constructor(props) {
+		this._namespace = props.namespace || "DiagComponentLogger";
+	}
+	debug(...args) {
+		return logProxy("debug", this._namespace, args);
+	}
+	error(...args) {
+		return logProxy("error", this._namespace, args);
+	}
+	info(...args) {
+		return logProxy("info", this._namespace, args);
+	}
+	warn(...args) {
+		return logProxy("warn", this._namespace, args);
+	}
+	verbose(...args) {
+		return logProxy("verbose", this._namespace, args);
+	}
+};
+function logProxy(funcName, namespace, args) {
+	const logger = getGlobal("diag");
+	if (!logger) return;
+	return logger[funcName](namespace, ...args);
+}
+//#endregion
+export { DiagComponentLogger };
+
+//# sourceMappingURL=ComponentLogger.mjs.map

package/node_modules/@opentelemetry/api/dist/diag/ComponentLogger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentLogger.mjs","names":[],"sources":["../../src/diag/ComponentLogger.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { getGlobal } from '../internal/global-utils';\nimport type { ComponentLoggerOptions, DiagLogger } from './types';\n\n/**\n * Component Logger which is meant to be used as part of any component which\n * will add automatically additional namespace in front of the log message.\n * It will then forward all message to global diag logger\n * @example\n * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });\n * cLogger.debug('test');\n * // @opentelemetry/instrumentation-http test\n */\nexport class DiagComponentLogger implements DiagLogger {\n  private _namespace: string;\n\n  constructor(props: ComponentLoggerOptions) {\n    this._namespace = props.namespace || 'DiagComponentLogger';\n  }\n\n  public debug(...args: unknown[]): void {\n    return logProxy('debug', this._namespace, args);\n  }\n\n  public error(...args: unknown[]): void {\n    return logProxy('error', this._namespace, args);\n  }\n\n  public info(...args: unknown[]): void {\n    return logProxy('info', this._namespace, args);\n  }\n\n  public warn(...args: unknown[]): void {\n    return logProxy('warn', this._namespace, args);\n  }\n\n  public verbose(...args: unknown[]): void {\n    return logProxy('verbose', this._namespace, args);\n  }\n}\n\nfunction logProxy(\n  funcName: keyof DiagLogger,\n  namespace: string,\n  args: unknown[]\n): void {\n  const logger = getGlobal('diag');\n  // shortcut if logger not set\n  if (!logger) {\n    return;\n  }\n\n  return logger[funcName](namespace, ...args);\n}\n"],"mappings":";;;;;;;;;;;AAiBA,IAAa,sBAAb,MAAuD;CAGrD,YAAY,OAA+B;EACzC,KAAK,aAAa,MAAM,aAAa;CACvC;CAEA,MAAa,GAAG,MAAuB;EACrC,OAAO,SAAS,SAAS,KAAK,YAAY,IAAI;CAChD;CAEA,MAAa,GAAG,MAAuB;EACrC,OAAO,SAAS,SAAS,KAAK,YAAY,IAAI;CAChD;CAEA,KAAY,GAAG,MAAuB;EACpC,OAAO,SAAS,QAAQ,KAAK,YAAY,IAAI;CAC/C;CAEA,KAAY,GAAG,MAAuB;EACpC,OAAO,SAAS,QAAQ,KAAK,YAAY,IAAI;CAC/C;CAEA,QAAe,GAAG,MAAuB;EACvC,OAAO,SAAS,WAAW,KAAK,YAAY,IAAI;CAClD;AACF;AAEA,SAAS,SACP,UACA,WACA,MACM;CACN,MAAM,SAAS,UAAU,MAAM;CAE/B,IAAI,CAAC,QACH;CAGF,OAAO,OAAO,SAAS,CAAC,WAAW,GAAG,IAAI;AAC5C"}

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.cjs

@@ -0,0 +1,62 @@
+//#region src/diag/consoleLogger.ts
+const consoleMap = [
+	{
+		n: "error",
+		c: "error"
+	},
+	{
+		n: "warn",
+		c: "warn"
+	},
+	{
+		n: "info",
+		c: "info"
+	},
+	{
+		n: "debug",
+		c: "debug"
+	},
+	{
+		n: "verbose",
+		c: "trace"
+	}
+];
+const _originalConsoleMethods = {};
+if (typeof console !== "undefined") {
+	for (const key of [
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace",
+		"log"
+	]) if (typeof console[key] === "function") _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
+*/
+var DiagConsoleLogger = class {
+	constructor() {
+		function _consoleFunc(funcName) {
+			return function(...args) {
+				let theFunc = _originalConsoleMethods[funcName];
+				if (typeof theFunc !== "function") theFunc = _originalConsoleMethods["log"];
+				if (typeof theFunc !== "function" && console) {
+					theFunc = console[funcName];
+					if (typeof theFunc !== "function") 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);
+	}
+};
+//#endregion
+exports.DiagConsoleLogger = DiagConsoleLogger;
+exports._originalConsoleMethods = _originalConsoleMethods;
+
+//# sourceMappingURL=consoleLogger.cjs.map

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleLogger.cjs","names":[],"sources":["../../src/diag/consoleLogger.ts"],"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"],"mappings":";AAQA,MAAM,aAA2D;CAC/D;EAAE,GAAG;EAAS,GAAG;CAAQ;CACzB;EAAE,GAAG;EAAQ,GAAG;CAAO;CACvB;EAAE,GAAG;EAAQ,GAAG;CAAO;CACvB;EAAE,GAAG;EAAS,GAAG;CAAQ;CACzB;EAAE,GAAG;EAAW,GAAG;CAAQ;AAC7B;AAKA,MAAa,0BAET,CAAC;AACL,IAAI,OAAO,YAAY,aAShB;MAAA,MAAM,OAAO;EAPhB;EACA;EACA;EACA;EACA;EACA;CAEmB,GAEnB,IAAI,OAAO,QAAQ,SAAS,YAE1B,wBAAwB,OAAO,QAAQ;AAAA;;;;;;;;AAY7C,IAAa,oBAAb,MAAqD;CACnD,cAAc;EACZ,SAAS,aAAa,UAA2C;GAC/D,OAAO,SAAU,GAAG,MAAM;IAExB,IAAI,UAAU,wBAAwB;IAEtC,IAAI,OAAO,YAAY,YACrB,UAAU,wBAAwB;IAGpC,IAAI,OAAO,YAAY,cAAc,SAAS;KAE5C,UAAU,QAAQ;KAClB,IAAI,OAAO,YAAY,YAErB,UAAU,QAAQ;IAEtB;IACA,IAAI,OAAO,YAAY,YACrB,OAAO,QAAQ,MAAM,SAAS,IAAI;GAEtC;EACF;EAEA,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KACrC,KAAK,WAAW,EAAE,CAAC,KAAK,aAAa,WAAW,EAAE,CAAC,CAAC;CAExD;AAkCF"}

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.d.cts

@@ -0,0 +1,43 @@
+import { DiagLogFunction, DiagLogger } from "./types.cjs";
+//#region src/diag/consoleLogger.d.ts
+/**
+ * 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
+ */
+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;
+}
+//#endregion
+export { DiagConsoleLogger };
+//# sourceMappingURL=consoleLogger.d.cts.map

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleLogger.d.cts","names":[],"sources":["../../src/diag/consoleLogger.d.ts"],"mappings":";;;;;;;;;cAUqB,6BAA6B;EAC9C;;EAEA,OAAO;;;;;EAKP,MAAM;;;;;;EAMN,MAAM;;;;;;;EAON,OAAO;;;;;;;;EAQP,SAAS"}

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.d.mts

@@ -0,0 +1,43 @@
+import { DiagLogFunction, DiagLogger } from "./types.mjs";
+//#region src/diag/consoleLogger.d.ts
+/**
+ * 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
+ */
+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;
+}
+//#endregion
+export { DiagConsoleLogger };
+//# sourceMappingURL=consoleLogger.d.mts.map

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleLogger.d.mts","names":[],"sources":["../../src/diag/consoleLogger.d.ts"],"mappings":";;;;;;;;;cAUqB,6BAA6B;EAC9C;;EAEA,OAAO;;;;;EAKP,MAAM;;;;;;EAMN,MAAM;;;;;;;EAON,OAAO;;;;;;;;EAQP,SAAS"}

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.mjs

@@ -0,0 +1,61 @@
+//#region src/diag/consoleLogger.ts
+const consoleMap = [
+	{
+		n: "error",
+		c: "error"
+	},
+	{
+		n: "warn",
+		c: "warn"
+	},
+	{
+		n: "info",
+		c: "info"
+	},
+	{
+		n: "debug",
+		c: "debug"
+	},
+	{
+		n: "verbose",
+		c: "trace"
+	}
+];
+const _originalConsoleMethods = {};
+if (typeof console !== "undefined") {
+	for (const key of [
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace",
+		"log"
+	]) if (typeof console[key] === "function") _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
+*/
+var DiagConsoleLogger = class {
+	constructor() {
+		function _consoleFunc(funcName) {
+			return function(...args) {
+				let theFunc = _originalConsoleMethods[funcName];
+				if (typeof theFunc !== "function") theFunc = _originalConsoleMethods["log"];
+				if (typeof theFunc !== "function" && console) {
+					theFunc = console[funcName];
+					if (typeof theFunc !== "function") 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);
+	}
+};
+//#endregion
+export { DiagConsoleLogger, _originalConsoleMethods };
+
+//# sourceMappingURL=consoleLogger.mjs.map

package/node_modules/@opentelemetry/api/dist/diag/consoleLogger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleLogger.mjs","names":[],"sources":["../../src/diag/consoleLogger.ts"],"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"],"mappings":";AAQA,MAAM,aAA2D;CAC/D;EAAE,GAAG;EAAS,GAAG;CAAQ;CACzB;EAAE,GAAG;EAAQ,GAAG;CAAO;CACvB;EAAE,GAAG;EAAQ,GAAG;CAAO;CACvB;EAAE,GAAG;EAAS,GAAG;CAAQ;CACzB;EAAE,GAAG;EAAW,GAAG;CAAQ;AAC7B;AAKA,MAAa,0BAET,CAAC;AACL,IAAI,OAAO,YAAY,aAShB;MAAA,MAAM,OAAO;EAPhB;EACA;EACA;EACA;EACA;EACA;CAEmB,GAEnB,IAAI,OAAO,QAAQ,SAAS,YAE1B,wBAAwB,OAAO,QAAQ;AAAA;;;;;;;;AAY7C,IAAa,oBAAb,MAAqD;CACnD,cAAc;EACZ,SAAS,aAAa,UAA2C;GAC/D,OAAO,SAAU,GAAG,MAAM;IAExB,IAAI,UAAU,wBAAwB;IAEtC,IAAI,OAAO,YAAY,YACrB,UAAU,wBAAwB;IAGpC,IAAI,OAAO,YAAY,cAAc,SAAS;KAE5C,UAAU,QAAQ;KAClB,IAAI,OAAO,YAAY,YAErB,UAAU,QAAQ;IAEtB;IACA,IAAI,OAAO,YAAY,YACrB,OAAO,QAAQ,MAAM,SAAS,IAAI;GAEtC;EACF;EAEA,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KACrC,KAAK,WAAW,EAAE,CAAC,KAAK,aAAa,WAAW,EAAE,CAAC,CAAC;CAExD;AAkCF"}

package/node_modules/@opentelemetry/api/dist/diag/internal/logLevelLogger.cjs

@@ -0,0 +1,23 @@
+require("../types.cjs");
+//#region src/diag/internal/logLevelLogger.ts
+function createLogLevelDiagLogger(maxLevel, logger) {
+	if (maxLevel < 0) maxLevel = 0;
+	else if (maxLevel > 9999) maxLevel = 9999;
+	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", 30),
+		warn: _filterFunc("warn", 50),
+		info: _filterFunc("info", 60),
+		debug: _filterFunc("debug", 70),
+		verbose: _filterFunc("verbose", 80)
+	};
+}
+//#endregion
+exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
+
+//# sourceMappingURL=logLevelLogger.cjs.map

package/node_modules/@opentelemetry/api/dist/diag/internal/logLevelLogger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelLogger.cjs","names":[],"sources":["../../../src/diag/internal/logLevelLogger.ts"],"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"],"mappings":";;AAQA,SAAgB,yBACd,UACA,QACY;CACZ,IAAI,WAAA,GACF,WAAA;MACK,IAAI,WAAA,MACT,WAAA;CAIF,SAAS,UAAU,CAAC;CAEpB,SAAS,YACP,UACA,UACiB;EACjB,MAAM,UAAU,OAAO;EAEvB,IAAI,OAAO,YAAY,cAAc,YAAY,UAC/C,OAAO,QAAQ,KAAK,MAAM;EAE5B,OAAO,WAAY,CAAC;CACtB;CAEA,OAAO;EACL,OAAO,YAAY,SAAA,EAA2B;EAC9C,MAAM,YAAY,QAAA,EAAyB;EAC3C,MAAM,YAAY,QAAA,EAAyB;EAC3C,OAAO,YAAY,SAAA,EAA2B;EAC9C,SAAS,YAAY,WAAA,EAA+B;CACtD;AACF"}

package/node_modules/@opentelemetry/api/dist/diag/internal/logLevelLogger.mjs

@@ -0,0 +1,23 @@
+import "../types.mjs";
+//#region src/diag/internal/logLevelLogger.ts
+function createLogLevelDiagLogger(maxLevel, logger) {
+	if (maxLevel < 0) maxLevel = 0;
+	else if (maxLevel > 9999) maxLevel = 9999;
+	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", 30),
+		warn: _filterFunc("warn", 50),
+		info: _filterFunc("info", 60),
+		debug: _filterFunc("debug", 70),
+		verbose: _filterFunc("verbose", 80)
+	};
+}
+//#endregion
+export { createLogLevelDiagLogger };
+
+//# sourceMappingURL=logLevelLogger.mjs.map