@tickernelz/paperclip-pro-server 2026.1017.2 → 2026.1021.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":["NoopContextManager","registerGlobal","DiagAPI","getGlobal"],"sources":["../../src/api/context.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { NoopContextManager } from '../context/NoopContextManager';\nimport type {\n  Context,\n  ContextManager,\n  ContextManagementToken,\n} from '../context/types';\nimport {\n  getGlobal,\n  registerGlobal,\n  unregisterGlobal,\n} from '../internal/global-utils';\nimport { DiagAPI } from './diag';\n\nconst API_NAME = 'context';\nconst NOOP_CONTEXT_MANAGER = new NoopContextManager();\nconst NOOP_TOKEN: ContextManagementToken = Object.freeze({\n  dispose: () => {},\n});\n\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Context API\n *\n * @since 1.0.0\n */\nexport class ContextAPI {\n  private static _instance?: ContextAPI;\n\n  /**\n   * Tracks whether we have already warned that the active ContextManager does\n   * not implement attach(), so we warn at most once instead of on every call.\n   */\n  private _attachUnsupportedWarned = false;\n\n  /** Empty private constructor prevents end users from constructing a new instance of the API */\n  private constructor() {}\n\n  /** Get the singleton instance of the Context API */\n  public static getInstance(): ContextAPI {\n    if (!this._instance) {\n      this._instance = new ContextAPI();\n    }\n\n    return this._instance;\n  }\n\n  /**\n   * Set the current context manager.\n   *\n   * @returns true if the context manager was successfully registered, else false\n   */\n  public setGlobalContextManager(contextManager: ContextManager): boolean {\n    return registerGlobal(API_NAME, contextManager, DiagAPI.instance());\n  }\n\n  /**\n   * Get the currently active context\n   */\n  public active(): Context {\n    return this._getContextManager().active();\n  }\n\n  /**\n   * Execute a function with an active context\n   *\n   * @param context context to be active during function execution\n   * @param fn function to execute in a context\n   * @param thisArg optional receiver to be used for calling fn\n   * @param args optional arguments forwarded to fn\n   */\n  public with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(\n    context: Context,\n    fn: F,\n    thisArg?: ThisParameterType<F>,\n    ...args: A\n  ): ReturnType<F> {\n    return this._getContextManager().with(context, fn, thisArg, ...args);\n  }\n\n  /**\n   * Bind a context to a target function or event emitter\n   *\n   * @param context context to bind to the event emitter or function. Defaults to the currently active context\n   * @param target function or event emitter to bind\n   */\n  public bind<T>(context: Context, target: T): T {\n    return this._getContextManager().bind(context, target);\n  }\n\n  /**\n   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose\n   * {@link ContextManagementToken.dispose} restores the previous context.\n   *\n   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which\n   * restore context automatically. Use `attach` only to bridge callback\n   * boundaries that `with` cannot wrap. Call `token.dispose()` when the\n   * operation is done.\n   *\n   * **Caveat for async functions:** If called inside an async function before\n   * the first `await`, the context change may leak into the caller's context\n   * and remain active there. Prefer {@link with} for async code.\n   *\n   * Support is best-effort and varies by the active ContextManager (see\n   * {@link ContextManager.attach}); if it does not implement `attach`, this logs\n   * a warning and returns a no-op token.\n   *\n   * @param context The Context to attach\n   * @returns A {@link ContextManagementToken} whose dispose() restores the previous Context\n   * @since 1.10.0\n   * @experimental This API is experimental and may change in minor releases without prior notice.\n   */\n  public attach(context: Context): ContextManagementToken {\n    const contextManager = this._getContextManager();\n    if (contextManager.attach) {\n      return contextManager.attach(context);\n    }\n    if (!this._attachUnsupportedWarned) {\n      this._attachUnsupportedWarned = true;\n      DiagAPI.instance().warn(\n        'The current ContextManager does not implement attach(). The context will not be attached. Use a ContextManager that supports attach() (e.g. AsyncLocalStorageContextManager) or use with()/bind() instead.'\n      );\n    }\n    return NOOP_TOKEN;\n  }\n\n  private _getContextManager(): ContextManager {\n    return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;\n  }\n\n  /** Disable and remove the global context manager */\n  public disable() {\n    this._getContextManager().disable();\n    unregisterGlobal(API_NAME, DiagAPI.instance());\n  }\n}\n"],"mappings":";;;;AAkBA,MAAM,WAAW;AACjB,MAAM,uBAAuB,IAAIA,2BAAAA,mBAAmB;AACpD,MAAM,aAAqC,OAAO,OAAO,EACvD,eAAe,CAAC,EAClB,CAAC;;;;;;AAOD,IAAa,aAAb,MAAa,WAAW;;CAUtB,cAAsB;EAHtB,KAAQ,2BAA2B;CAGZ;;CAGvB,OAAc,cAA0B;EACtC,IAAI,CAAC,KAAK,WACR,KAAK,YAAY,IAAI,WAAW;EAGlC,OAAO,KAAK;CACd;;;;;;CAOA,wBAA+B,gBAAyC;EACtE,OAAOC,qBAAAA,eAAe,UAAU,gBAAgBC,aAAAA,QAAQ,SAAS,CAAC;CACpE;;;;CAKA,SAAyB;EACvB,OAAO,KAAK,mBAAmB,CAAC,CAAC,OAAO;CAC1C;;;;;;;;;CAUA,KACE,SACA,IACA,SACA,GAAG,MACY;EACf,OAAO,KAAK,mBAAmB,CAAC,CAAC,KAAK,SAAS,IAAI,SAAS,GAAG,IAAI;CACrE;;;;;;;CAQA,KAAe,SAAkB,QAAc;EAC7C,OAAO,KAAK,mBAAmB,CAAC,CAAC,KAAK,SAAS,MAAM;CACvD;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAc,SAA0C;EACtD,MAAM,iBAAiB,KAAK,mBAAmB;EAC/C,IAAI,eAAe,QACjB,OAAO,eAAe,OAAO,OAAO;EAEtC,IAAI,CAAC,KAAK,0BAA0B;GAClC,KAAK,2BAA2B;GAChC,aAAA,QAAQ,SAAS,CAAC,CAAC,KACjB,4MACF;EACF;EACA,OAAO;CACT;CAEA,qBAA6C;EAC3C,OAAOC,qBAAAA,UAAU,QAAQ,KAAK;CAChC;;CAGA,UAAiB;EACf,KAAK,mBAAmB,CAAC,CAAC,QAAQ;EAClC,qBAAA,iBAAiB,UAAUD,aAAAA,QAAQ,SAAS,CAAC;CAC/C;AACF"}

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

@@ -0,0 +1,74 @@
+import { Context, ContextManagementToken, ContextManager } from "../context/types.cjs";
+//#region src/api/context.d.ts
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Context API
+ *
+ * @since 1.0.0
+ */
+declare class ContextAPI {
+  private static _instance?;
+  /**
+   * Tracks whether we have already warned that the active ContextManager does
+   * not implement attach(), so we warn at most once instead of on every call.
+   */
+  private _attachUnsupportedWarned;
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  private constructor();
+  /** Get the singleton instance of the Context API */
+  static getInstance(): ContextAPI;
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager: ContextManager): boolean;
+  /**
+   * Get the currently active context
+   */
+  active(): Context;
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a 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 a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind<T>(context: Context, target: T): T;
+  /**
+   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose
+   * {@link ContextManagementToken.dispose} restores the previous context.
+   *
+   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which
+   * restore context automatically. Use `attach` only to bridge callback
+   * boundaries that `with` cannot wrap. Call `token.dispose()` when the
+   * operation is done.
+   *
+   * **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.
+   *
+   * Support is best-effort and varies by the active ContextManager (see
+   * {@link ContextManager.attach}); if it does not implement `attach`, this logs
+   * a warning and returns a no-op token.
+   *
+   * @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;
+  private _getContextManager;
+  /** Disable and remove the global context manager */
+  disable(): void;
+}
+//#endregion
+export { ContextAPI };
+//# sourceMappingURL=context.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":[],"sources":["../../src/api/context.d.ts"],"mappings":";;;;;;;cAMqB;iBACF;;;;;UAKP;;UAEA;;SAED,eAAe;;;;;;EAMtB,wBAAwB,gBAAgB;;;;EAIxC,UAAU;;;;;;;;;EASV,KAAK,qBAAqB,cAAc,MAAM,MAAM,WAAW,IAAI,SAAS,SAAS,IAAI,GAAG,UAAU,kBAAkB,OAAO,MAAM,IAAI,WAAW;;;;;;;EAOpJ,KAAK,GAAG,SAAS,SAAS,QAAQ,IAAI;;;;;;;;;;;;;;;;;;;;;;;EAuBtC,OAAO,SAAS,UAAU;UAClB;;EAER"}

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

@@ -0,0 +1,74 @@
+import { Context, ContextManagementToken, ContextManager } from "../context/types.mjs";
+//#region src/api/context.d.ts
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Context API
+ *
+ * @since 1.0.0
+ */
+declare class ContextAPI {
+  private static _instance?;
+  /**
+   * Tracks whether we have already warned that the active ContextManager does
+   * not implement attach(), so we warn at most once instead of on every call.
+   */
+  private _attachUnsupportedWarned;
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  private constructor();
+  /** Get the singleton instance of the Context API */
+  static getInstance(): ContextAPI;
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager: ContextManager): boolean;
+  /**
+   * Get the currently active context
+   */
+  active(): Context;
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a 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 a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind<T>(context: Context, target: T): T;
+  /**
+   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose
+   * {@link ContextManagementToken.dispose} restores the previous context.
+   *
+   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which
+   * restore context automatically. Use `attach` only to bridge callback
+   * boundaries that `with` cannot wrap. Call `token.dispose()` when the
+   * operation is done.
+   *
+   * **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.
+   *
+   * Support is best-effort and varies by the active ContextManager (see
+   * {@link ContextManager.attach}); if it does not implement `attach`, this logs
+   * a warning and returns a no-op token.
+   *
+   * @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;
+  private _getContextManager;
+  /** Disable and remove the global context manager */
+  disable(): void;
+}
+//#endregion
+export { ContextAPI };
+//# sourceMappingURL=context.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../../src/api/context.d.ts"],"mappings":";;;;;;;cAMqB;iBACF;;;;;UAKP;;UAEA;;SAED,eAAe;;;;;;EAMtB,wBAAwB,gBAAgB;;;;EAIxC,UAAU;;;;;;;;;EASV,KAAK,qBAAqB,cAAc,MAAM,MAAM,WAAW,IAAI,SAAS,SAAS,IAAI,GAAG,UAAU,kBAAkB,OAAO,MAAM,IAAI,WAAW;;;;;;;EAOpJ,KAAK,GAAG,SAAS,SAAS,QAAQ,IAAI;;;;;;;;;;;;;;;;;;;;;;;EAuBtC,OAAO,SAAS,UAAU;UAClB;;EAER"}

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

@@ -0,0 +1,100 @@
+import { getGlobal, registerGlobal, unregisterGlobal } from "../internal/global-utils.mjs";
+import { DiagAPI } from "./diag.mjs";
+import { NoopContextManager } from "../context/NoopContextManager.mjs";
+//#region src/api/context.ts
+const API_NAME = "context";
+const NOOP_CONTEXT_MANAGER = new NoopContextManager();
+const NOOP_TOKEN = Object.freeze({ dispose: () => {} });
+/**
+* Singleton object which represents the entry point to the OpenTelemetry Context API
+*
+* @since 1.0.0
+*/
+var ContextAPI = class ContextAPI {
+	/** Empty private constructor prevents end users from constructing a new instance of the API */
+	constructor() {
+		this._attachUnsupportedWarned = false;
+	}
+	/** Get the singleton instance of the Context API */
+	static getInstance() {
+		if (!this._instance) this._instance = new ContextAPI();
+		return this._instance;
+	}
+	/**
+	* Set the current context manager.
+	*
+	* @returns true if the context manager was successfully registered, else false
+	*/
+	setGlobalContextManager(contextManager) {
+		return registerGlobal(API_NAME, contextManager, DiagAPI.instance());
+	}
+	/**
+	* Get the currently active context
+	*/
+	active() {
+		return this._getContextManager().active();
+	}
+	/**
+	* Execute a function with an active context
+	*
+	* @param context context to be active during function execution
+	* @param fn function to execute in a context
+	* @param thisArg optional receiver to be used for calling fn
+	* @param args optional arguments forwarded to fn
+	*/
+	with(context, fn, thisArg, ...args) {
+		return this._getContextManager().with(context, fn, thisArg, ...args);
+	}
+	/**
+	* Bind a context to a target function or event emitter
+	*
+	* @param context context to bind to the event emitter or function. Defaults to the currently active context
+	* @param target function or event emitter to bind
+	*/
+	bind(context, target) {
+		return this._getContextManager().bind(context, target);
+	}
+	/**
+	* Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose
+	* {@link ContextManagementToken.dispose} restores the previous context.
+	*
+	* This is a delicate, low-level API - prefer {@link with}/{@link bind}, which
+	* restore context automatically. Use `attach` only to bridge callback
+	* boundaries that `with` cannot wrap. Call `token.dispose()` when the
+	* operation is done.
+	*
+	* **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.
+	*
+	* Support is best-effort and varies by the active ContextManager (see
+	* {@link ContextManager.attach}); if it does not implement `attach`, this logs
+	* a warning and returns a no-op token.
+	*
+	* @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) {
+		const contextManager = this._getContextManager();
+		if (contextManager.attach) return contextManager.attach(context);
+		if (!this._attachUnsupportedWarned) {
+			this._attachUnsupportedWarned = true;
+			DiagAPI.instance().warn("The current ContextManager does not implement attach(). The context will not be attached. Use a ContextManager that supports attach() (e.g. AsyncLocalStorageContextManager) or use with()/bind() instead.");
+		}
+		return NOOP_TOKEN;
+	}
+	_getContextManager() {
+		return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;
+	}
+	/** Disable and remove the global context manager */
+	disable() {
+		this._getContextManager().disable();
+		unregisterGlobal(API_NAME, DiagAPI.instance());
+	}
+};
+//#endregion
+export { ContextAPI };
+
+//# sourceMappingURL=context.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../../src/api/context.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { NoopContextManager } from '../context/NoopContextManager';\nimport type {\n  Context,\n  ContextManager,\n  ContextManagementToken,\n} from '../context/types';\nimport {\n  getGlobal,\n  registerGlobal,\n  unregisterGlobal,\n} from '../internal/global-utils';\nimport { DiagAPI } from './diag';\n\nconst API_NAME = 'context';\nconst NOOP_CONTEXT_MANAGER = new NoopContextManager();\nconst NOOP_TOKEN: ContextManagementToken = Object.freeze({\n  dispose: () => {},\n});\n\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Context API\n *\n * @since 1.0.0\n */\nexport class ContextAPI {\n  private static _instance?: ContextAPI;\n\n  /**\n   * Tracks whether we have already warned that the active ContextManager does\n   * not implement attach(), so we warn at most once instead of on every call.\n   */\n  private _attachUnsupportedWarned = false;\n\n  /** Empty private constructor prevents end users from constructing a new instance of the API */\n  private constructor() {}\n\n  /** Get the singleton instance of the Context API */\n  public static getInstance(): ContextAPI {\n    if (!this._instance) {\n      this._instance = new ContextAPI();\n    }\n\n    return this._instance;\n  }\n\n  /**\n   * Set the current context manager.\n   *\n   * @returns true if the context manager was successfully registered, else false\n   */\n  public setGlobalContextManager(contextManager: ContextManager): boolean {\n    return registerGlobal(API_NAME, contextManager, DiagAPI.instance());\n  }\n\n  /**\n   * Get the currently active context\n   */\n  public active(): Context {\n    return this._getContextManager().active();\n  }\n\n  /**\n   * Execute a function with an active context\n   *\n   * @param context context to be active during function execution\n   * @param fn function to execute in a context\n   * @param thisArg optional receiver to be used for calling fn\n   * @param args optional arguments forwarded to fn\n   */\n  public with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(\n    context: Context,\n    fn: F,\n    thisArg?: ThisParameterType<F>,\n    ...args: A\n  ): ReturnType<F> {\n    return this._getContextManager().with(context, fn, thisArg, ...args);\n  }\n\n  /**\n   * Bind a context to a target function or event emitter\n   *\n   * @param context context to bind to the event emitter or function. Defaults to the currently active context\n   * @param target function or event emitter to bind\n   */\n  public bind<T>(context: Context, target: T): T {\n    return this._getContextManager().bind(context, target);\n  }\n\n  /**\n   * Imperatively sets `context` as active, returning a {@link ContextManagementToken} whose\n   * {@link ContextManagementToken.dispose} restores the previous context.\n   *\n   * This is a delicate, low-level API - prefer {@link with}/{@link bind}, which\n   * restore context automatically. Use `attach` only to bridge callback\n   * boundaries that `with` cannot wrap. Call `token.dispose()` when the\n   * operation is done.\n   *\n   * **Caveat for async functions:** If called inside an async function before\n   * the first `await`, the context change may leak into the caller's context\n   * and remain active there. Prefer {@link with} for async code.\n   *\n   * Support is best-effort and varies by the active ContextManager (see\n   * {@link ContextManager.attach}); if it does not implement `attach`, this logs\n   * a warning and returns a no-op token.\n   *\n   * @param context The Context to attach\n   * @returns A {@link ContextManagementToken} whose dispose() restores the previous Context\n   * @since 1.10.0\n   * @experimental This API is experimental and may change in minor releases without prior notice.\n   */\n  public attach(context: Context): ContextManagementToken {\n    const contextManager = this._getContextManager();\n    if (contextManager.attach) {\n      return contextManager.attach(context);\n    }\n    if (!this._attachUnsupportedWarned) {\n      this._attachUnsupportedWarned = true;\n      DiagAPI.instance().warn(\n        'The current ContextManager does not implement attach(). The context will not be attached. Use a ContextManager that supports attach() (e.g. AsyncLocalStorageContextManager) or use with()/bind() instead.'\n      );\n    }\n    return NOOP_TOKEN;\n  }\n\n  private _getContextManager(): ContextManager {\n    return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;\n  }\n\n  /** Disable and remove the global context manager */\n  public disable() {\n    this._getContextManager().disable();\n    unregisterGlobal(API_NAME, DiagAPI.instance());\n  }\n}\n"],"mappings":";;;;AAkBA,MAAM,WAAW;AACjB,MAAM,uBAAuB,IAAI,mBAAmB;AACpD,MAAM,aAAqC,OAAO,OAAO,EACvD,eAAe,CAAC,EAClB,CAAC;;;;;;AAOD,IAAa,aAAb,MAAa,WAAW;;CAUtB,cAAsB;EAHtB,KAAQ,2BAA2B;CAGZ;;CAGvB,OAAc,cAA0B;EACtC,IAAI,CAAC,KAAK,WACR,KAAK,YAAY,IAAI,WAAW;EAGlC,OAAO,KAAK;CACd;;;;;;CAOA,wBAA+B,gBAAyC;EACtE,OAAO,eAAe,UAAU,gBAAgB,QAAQ,SAAS,CAAC;CACpE;;;;CAKA,SAAyB;EACvB,OAAO,KAAK,mBAAmB,CAAC,CAAC,OAAO;CAC1C;;;;;;;;;CAUA,KACE,SACA,IACA,SACA,GAAG,MACY;EACf,OAAO,KAAK,mBAAmB,CAAC,CAAC,KAAK,SAAS,IAAI,SAAS,GAAG,IAAI;CACrE;;;;;;;CAQA,KAAe,SAAkB,QAAc;EAC7C,OAAO,KAAK,mBAAmB,CAAC,CAAC,KAAK,SAAS,MAAM;CACvD;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAc,SAA0C;EACtD,MAAM,iBAAiB,KAAK,mBAAmB;EAC/C,IAAI,eAAe,QACjB,OAAO,eAAe,OAAO,OAAO;EAEtC,IAAI,CAAC,KAAK,0BAA0B;GAClC,KAAK,2BAA2B;GAChC,QAAQ,SAAS,CAAC,CAAC,KACjB,4MACF;EACF;EACA,OAAO;CACT;CAEA,qBAA6C;EAC3C,OAAO,UAAU,QAAQ,KAAK;CAChC;;CAGA,UAAiB;EACf,KAAK,mBAAmB,CAAC,CAAC,QAAQ;EAClC,iBAAiB,UAAU,QAAQ,SAAS,CAAC;CAC/C;AACF"}

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

@@ -0,0 +1,68 @@
+const require_global_utils = require("../internal/global-utils.cjs");
+const require_ComponentLogger = require("../diag/ComponentLogger.cjs");
+require("../diag/types.cjs");
+const require_logLevelLogger = require("../diag/internal/logLevelLogger.cjs");
+//#region src/api/diag.ts
+const API_NAME = "diag";
+/**
+* Singleton object which represents the entry point to the OpenTelemetry internal
+* diagnostic API
+*
+* @since 1.0.0
+*/
+var DiagAPI = class DiagAPI {
+	/** Get the singleton instance of the DiagAPI API */
+	static instance() {
+		if (!this._instance) this._instance = new DiagAPI();
+		return this._instance;
+	}
+	/**
+	* Private internal constructor
+	* @private
+	*/
+	constructor() {
+		function _logProxy(funcName) {
+			return function(...args) {
+				const logger = require_global_utils.getGlobal("diag");
+				if (!logger) return;
+				return logger[funcName](...args);
+			};
+		}
+		const self = this;
+		const setLogger = (logger, optionsOrLogLevel = { logLevel: 60 }) => {
+			var _optionsOrLogLevel$lo;
+			if (logger === self) {
+				var _err$stack;
+				const err = /* @__PURE__ */ new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+				self.error((_err$stack = err.stack) !== null && _err$stack !== void 0 ? _err$stack : err.message);
+				return false;
+			}
+			if (typeof optionsOrLogLevel === "number") optionsOrLogLevel = { logLevel: optionsOrLogLevel };
+			const oldLogger = require_global_utils.getGlobal("diag");
+			const newLogger = require_logLevelLogger.createLogLevelDiagLogger((_optionsOrLogLevel$lo = optionsOrLogLevel.logLevel) !== null && _optionsOrLogLevel$lo !== void 0 ? _optionsOrLogLevel$lo : 60, logger);
+			if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+				var _Error$stack;
+				const stack = (_Error$stack = (/* @__PURE__ */ new Error()).stack) !== null && _Error$stack !== void 0 ? _Error$stack : "<failed to generate stacktrace>";
+				oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+				newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+			}
+			return require_global_utils.registerGlobal("diag", newLogger, self, true);
+		};
+		self.setLogger = setLogger;
+		self.disable = () => {
+			require_global_utils.unregisterGlobal(API_NAME, self);
+		};
+		self.createComponentLogger = (options) => {
+			return new require_ComponentLogger.DiagComponentLogger(options);
+		};
+		self.verbose = _logProxy("verbose");
+		self.debug = _logProxy("debug");
+		self.info = _logProxy("info");
+		self.warn = _logProxy("warn");
+		self.error = _logProxy("error");
+	}
+};
+//#endregion
+exports.DiagAPI = DiagAPI;
+
+//# sourceMappingURL=diag.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diag.cjs","names":["getGlobal","createLogLevelDiagLogger","registerGlobal","DiagComponentLogger"],"sources":["../../src/api/diag.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { DiagComponentLogger } from '../diag/ComponentLogger';\nimport { createLogLevelDiagLogger } from '../diag/internal/logLevelLogger';\nimport type {\n  ComponentLoggerOptions,\n  DiagLogFunction,\n  DiagLogger,\n  DiagLoggerApi,\n} from '../diag/types';\nimport { DiagLogLevel } from '../diag/types';\nimport {\n  getGlobal,\n  registerGlobal,\n  unregisterGlobal,\n} from '../internal/global-utils';\n\nconst API_NAME = 'diag';\n\n/**\n * Singleton object which represents the entry point to the OpenTelemetry internal\n * diagnostic API\n *\n * @since 1.0.0\n */\nexport class DiagAPI implements DiagLogger, DiagLoggerApi {\n  private static _instance?: DiagAPI;\n\n  /** Get the singleton instance of the DiagAPI API */\n  public static instance(): DiagAPI {\n    if (!this._instance) {\n      this._instance = new DiagAPI();\n    }\n\n    return this._instance;\n  }\n\n  /**\n   * Private internal constructor\n   * @private\n   */\n  private constructor() {\n    function _logProxy(funcName: keyof DiagLogger): DiagLogFunction {\n      return function (...args) {\n        const logger = getGlobal('diag');\n        // shortcut if logger not set\n        if (!logger) return;\n        return logger[funcName](...args);\n      };\n    }\n\n    // Using self local variable for minification purposes as 'this' cannot be minified\n    const self = this;\n\n    // DiagAPI specific functions\n\n    const setLogger: DiagLoggerApi['setLogger'] = (\n      logger,\n      optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }\n    ) => {\n      if (logger === self) {\n        // There isn't much we can do here.\n        // Logging to the console might break the user application.\n        // Try to log to self. If a logger was previously registered it will receive the log.\n        const err = new Error(\n          'Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation'\n        );\n        self.error(err.stack ?? err.message);\n        return false;\n      }\n\n      if (typeof optionsOrLogLevel === 'number') {\n        optionsOrLogLevel = {\n          logLevel: optionsOrLogLevel,\n        };\n      }\n\n      const oldLogger = getGlobal('diag');\n      const newLogger = createLogLevelDiagLogger(\n        optionsOrLogLevel.logLevel ?? DiagLogLevel.INFO,\n        logger\n      );\n      // There already is an logger registered. We'll let it know before overwriting it.\n      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {\n        const stack = new Error().stack ?? '<failed to generate stacktrace>';\n        oldLogger.warn(`Current logger will be overwritten from ${stack}`);\n        newLogger.warn(\n          `Current logger will overwrite one already registered from ${stack}`\n        );\n      }\n\n      return registerGlobal('diag', newLogger, self, true);\n    };\n\n    self.setLogger = setLogger;\n\n    self.disable = () => {\n      unregisterGlobal(API_NAME, self);\n    };\n\n    self.createComponentLogger = (options: ComponentLoggerOptions) => {\n      return new DiagComponentLogger(options);\n    };\n\n    self.verbose = _logProxy('verbose');\n    self.debug = _logProxy('debug');\n    self.info = _logProxy('info');\n    self.warn = _logProxy('warn');\n    self.error = _logProxy('error');\n  }\n\n  public setLogger!: DiagLoggerApi['setLogger'];\n  /**\n   *\n   */\n  public createComponentLogger!: (\n    options: ComponentLoggerOptions\n  ) => DiagLogger;\n\n  // DiagLogger implementation\n  public verbose!: DiagLogFunction;\n  public debug!: DiagLogFunction;\n  public info!: DiagLogFunction;\n  public warn!: DiagLogFunction;\n  public error!: DiagLogFunction;\n\n  /**\n   * Unregister the global logger and return to Noop\n   */\n  public disable!: () => void;\n}\n"],"mappings":";;;;;AAoBA,MAAM,WAAW;;;;;;;AAQjB,IAAa,UAAb,MAAa,QAA6C;;CAIxD,OAAc,WAAoB;EAChC,IAAI,CAAC,KAAK,WACR,KAAK,YAAY,IAAI,QAAQ;EAG/B,OAAO,KAAK;CACd;;;;;CAMA,cAAsB;EACpB,SAAS,UAAU,UAA6C;GAC9D,OAAO,SAAU,GAAG,MAAM;IACxB,MAAM,SAASA,qBAAAA,UAAU,MAAM;IAE/B,IAAI,CAAC,QAAQ;IACb,OAAO,OAAO,SAAS,CAAC,GAAG,IAAI;GACjC;EACF;EAGA,MAAM,OAAO;EAIb,MAAM,aACJ,QACA,oBAAoB,EAAE,UAAA,GAA4B,MAC/C;;GACH,IAAI,WAAW,MAAM;;IAInB,MAAM,sBAAM,IAAI,MACd,oIACF;IACA,KAAK,OAAA,aAAM,IAAI,WAAA,QAAA,eAAA,KAAA,IAAA,aAAS,IAAI,OAAO;IACnC,OAAO;GACT;GAEA,IAAI,OAAO,sBAAsB,UAC/B,oBAAoB,EAClB,UAAU,kBACZ;GAGF,MAAM,YAAYA,qBAAAA,UAAU,MAAM;GAClC,MAAM,YAAYC,uBAAAA,0BAAAA,wBAChB,kBAAkB,cAAA,QAAA,0BAAA,KAAA,IAAA,wBAAA,IAClB,MACF;GAEA,IAAI,aAAa,CAAC,kBAAkB,yBAAyB;;IAC3D,MAAM,SAAA,gCAAQ,IAAI,MAAM,EAAA,CAAE,WAAA,QAAA,iBAAA,KAAA,IAAA,eAAS;IACnC,UAAU,KAAK,2CAA2C,OAAO;IACjE,UAAU,KACR,6DAA6D,OAC/D;GACF;GAEA,OAAOC,qBAAAA,eAAe,QAAQ,WAAW,MAAM,IAAI;EACrD;EAEA,KAAK,YAAY;EAEjB,KAAK,gBAAgB;GACnB,qBAAA,iBAAiB,UAAU,IAAI;EACjC;EAEA,KAAK,yBAAyB,YAAoC;GAChE,OAAO,IAAIC,wBAAAA,oBAAoB,OAAO;EACxC;EAEA,KAAK,UAAU,UAAU,SAAS;EAClC,KAAK,QAAQ,UAAU,OAAO;EAC9B,KAAK,OAAO,UAAU,MAAM;EAC5B,KAAK,OAAO,UAAU,MAAM;EAC5B,KAAK,QAAQ,UAAU,OAAO;CAChC;AAqBF"}

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

@@ -0,0 +1,35 @@
+import { ComponentLoggerOptions, DiagLogFunction, DiagLogger, DiagLoggerApi } from "../diag/types.cjs";
+//#region src/api/diag.d.ts
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry internal
+ * diagnostic API
+ *
+ * @since 1.0.0
+ */
+declare class DiagAPI implements DiagLogger, DiagLoggerApi {
+  private static _instance?;
+  /** Get the singleton instance of the DiagAPI API */
+  static instance(): DiagAPI;
+  /**
+   * Private internal constructor
+   * @private
+   */
+  private constructor();
+  setLogger: DiagLoggerApi['setLogger'];
+  /**
+   *
+   */
+  createComponentLogger: (options: ComponentLoggerOptions) => DiagLogger;
+  verbose: DiagLogFunction;
+  debug: DiagLogFunction;
+  info: DiagLogFunction;
+  warn: DiagLogFunction;
+  error: DiagLogFunction;
+  /**
+   * Unregister the global logger and return to Noop
+   */
+  disable: () => void;
+}
+//#endregion
+export { DiagAPI };
+//# sourceMappingURL=diag.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diag.d.cts","names":[],"sources":["../../src/api/diag.d.ts"],"mappings":";;;;;;;;cAOqB,mBAAmB,YAAY;iBACjC;;SAER,YAAY;;;;;UAKX;EACR,WAAW;;;;EAIX,wBAAwB,SAAS,2BAA2B;EAC5D,SAAS;EACT,OAAO;EACP,MAAM;EACN,MAAM;EACN,OAAO;;;;EAIP"}

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

@@ -0,0 +1,35 @@
+import { ComponentLoggerOptions, DiagLogFunction, DiagLogger, DiagLoggerApi } from "../diag/types.mjs";
+//#region src/api/diag.d.ts
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry internal
+ * diagnostic API
+ *
+ * @since 1.0.0
+ */
+declare class DiagAPI implements DiagLogger, DiagLoggerApi {
+  private static _instance?;
+  /** Get the singleton instance of the DiagAPI API */
+  static instance(): DiagAPI;
+  /**
+   * Private internal constructor
+   * @private
+   */
+  private constructor();
+  setLogger: DiagLoggerApi['setLogger'];
+  /**
+   *
+   */
+  createComponentLogger: (options: ComponentLoggerOptions) => DiagLogger;
+  verbose: DiagLogFunction;
+  debug: DiagLogFunction;
+  info: DiagLogFunction;
+  warn: DiagLogFunction;
+  error: DiagLogFunction;
+  /**
+   * Unregister the global logger and return to Noop
+   */
+  disable: () => void;
+}
+//#endregion
+export { DiagAPI };
+//# sourceMappingURL=diag.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diag.d.mts","names":[],"sources":["../../src/api/diag.d.ts"],"mappings":";;;;;;;;cAOqB,mBAAmB,YAAY;iBACjC;;SAER,YAAY;;;;;UAKX;EACR,WAAW;;;;EAIX,wBAAwB,SAAS,2BAA2B;EAC5D,SAAS;EACT,OAAO;EACP,MAAM;EACN,MAAM;EACN,OAAO;;;;EAIP"}

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

@@ -0,0 +1,68 @@
+import { getGlobal, registerGlobal, unregisterGlobal } from "../internal/global-utils.mjs";
+import { DiagComponentLogger } from "../diag/ComponentLogger.mjs";
+import "../diag/types.mjs";
+import { createLogLevelDiagLogger } from "../diag/internal/logLevelLogger.mjs";
+//#region src/api/diag.ts
+const API_NAME = "diag";
+/**
+* Singleton object which represents the entry point to the OpenTelemetry internal
+* diagnostic API
+*
+* @since 1.0.0
+*/
+var DiagAPI = class DiagAPI {
+	/** Get the singleton instance of the DiagAPI API */
+	static instance() {
+		if (!this._instance) this._instance = new DiagAPI();
+		return this._instance;
+	}
+	/**
+	* Private internal constructor
+	* @private
+	*/
+	constructor() {
+		function _logProxy(funcName) {
+			return function(...args) {
+				const logger = getGlobal("diag");
+				if (!logger) return;
+				return logger[funcName](...args);
+			};
+		}
+		const self = this;
+		const setLogger = (logger, optionsOrLogLevel = { logLevel: 60 }) => {
+			var _optionsOrLogLevel$lo;
+			if (logger === self) {
+				var _err$stack;
+				const err = /* @__PURE__ */ new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+				self.error((_err$stack = err.stack) !== null && _err$stack !== void 0 ? _err$stack : err.message);
+				return false;
+			}
+			if (typeof optionsOrLogLevel === "number") optionsOrLogLevel = { logLevel: optionsOrLogLevel };
+			const oldLogger = getGlobal("diag");
+			const newLogger = createLogLevelDiagLogger((_optionsOrLogLevel$lo = optionsOrLogLevel.logLevel) !== null && _optionsOrLogLevel$lo !== void 0 ? _optionsOrLogLevel$lo : 60, logger);
+			if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+				var _Error$stack;
+				const stack = (_Error$stack = (/* @__PURE__ */ new Error()).stack) !== null && _Error$stack !== void 0 ? _Error$stack : "<failed to generate stacktrace>";
+				oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+				newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+			}
+			return registerGlobal("diag", newLogger, self, true);
+		};
+		self.setLogger = setLogger;
+		self.disable = () => {
+			unregisterGlobal(API_NAME, self);
+		};
+		self.createComponentLogger = (options) => {
+			return new DiagComponentLogger(options);
+		};
+		self.verbose = _logProxy("verbose");
+		self.debug = _logProxy("debug");
+		self.info = _logProxy("info");
+		self.warn = _logProxy("warn");
+		self.error = _logProxy("error");
+	}
+};
+//#endregion
+export { DiagAPI };
+
+//# sourceMappingURL=diag.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diag.mjs","names":[],"sources":["../../src/api/diag.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { DiagComponentLogger } from '../diag/ComponentLogger';\nimport { createLogLevelDiagLogger } from '../diag/internal/logLevelLogger';\nimport type {\n  ComponentLoggerOptions,\n  DiagLogFunction,\n  DiagLogger,\n  DiagLoggerApi,\n} from '../diag/types';\nimport { DiagLogLevel } from '../diag/types';\nimport {\n  getGlobal,\n  registerGlobal,\n  unregisterGlobal,\n} from '../internal/global-utils';\n\nconst API_NAME = 'diag';\n\n/**\n * Singleton object which represents the entry point to the OpenTelemetry internal\n * diagnostic API\n *\n * @since 1.0.0\n */\nexport class DiagAPI implements DiagLogger, DiagLoggerApi {\n  private static _instance?: DiagAPI;\n\n  /** Get the singleton instance of the DiagAPI API */\n  public static instance(): DiagAPI {\n    if (!this._instance) {\n      this._instance = new DiagAPI();\n    }\n\n    return this._instance;\n  }\n\n  /**\n   * Private internal constructor\n   * @private\n   */\n  private constructor() {\n    function _logProxy(funcName: keyof DiagLogger): DiagLogFunction {\n      return function (...args) {\n        const logger = getGlobal('diag');\n        // shortcut if logger not set\n        if (!logger) return;\n        return logger[funcName](...args);\n      };\n    }\n\n    // Using self local variable for minification purposes as 'this' cannot be minified\n    const self = this;\n\n    // DiagAPI specific functions\n\n    const setLogger: DiagLoggerApi['setLogger'] = (\n      logger,\n      optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }\n    ) => {\n      if (logger === self) {\n        // There isn't much we can do here.\n        // Logging to the console might break the user application.\n        // Try to log to self. If a logger was previously registered it will receive the log.\n        const err = new Error(\n          'Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation'\n        );\n        self.error(err.stack ?? err.message);\n        return false;\n      }\n\n      if (typeof optionsOrLogLevel === 'number') {\n        optionsOrLogLevel = {\n          logLevel: optionsOrLogLevel,\n        };\n      }\n\n      const oldLogger = getGlobal('diag');\n      const newLogger = createLogLevelDiagLogger(\n        optionsOrLogLevel.logLevel ?? DiagLogLevel.INFO,\n        logger\n      );\n      // There already is an logger registered. We'll let it know before overwriting it.\n      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {\n        const stack = new Error().stack ?? '<failed to generate stacktrace>';\n        oldLogger.warn(`Current logger will be overwritten from ${stack}`);\n        newLogger.warn(\n          `Current logger will overwrite one already registered from ${stack}`\n        );\n      }\n\n      return registerGlobal('diag', newLogger, self, true);\n    };\n\n    self.setLogger = setLogger;\n\n    self.disable = () => {\n      unregisterGlobal(API_NAME, self);\n    };\n\n    self.createComponentLogger = (options: ComponentLoggerOptions) => {\n      return new DiagComponentLogger(options);\n    };\n\n    self.verbose = _logProxy('verbose');\n    self.debug = _logProxy('debug');\n    self.info = _logProxy('info');\n    self.warn = _logProxy('warn');\n    self.error = _logProxy('error');\n  }\n\n  public setLogger!: DiagLoggerApi['setLogger'];\n  /**\n   *\n   */\n  public createComponentLogger!: (\n    options: ComponentLoggerOptions\n  ) => DiagLogger;\n\n  // DiagLogger implementation\n  public verbose!: DiagLogFunction;\n  public debug!: DiagLogFunction;\n  public info!: DiagLogFunction;\n  public warn!: DiagLogFunction;\n  public error!: DiagLogFunction;\n\n  /**\n   * Unregister the global logger and return to Noop\n   */\n  public disable!: () => void;\n}\n"],"mappings":";;;;;AAoBA,MAAM,WAAW;;;;;;;AAQjB,IAAa,UAAb,MAAa,QAA6C;;CAIxD,OAAc,WAAoB;EAChC,IAAI,CAAC,KAAK,WACR,KAAK,YAAY,IAAI,QAAQ;EAG/B,OAAO,KAAK;CACd;;;;;CAMA,cAAsB;EACpB,SAAS,UAAU,UAA6C;GAC9D,OAAO,SAAU,GAAG,MAAM;IACxB,MAAM,SAAS,UAAU,MAAM;IAE/B,IAAI,CAAC,QAAQ;IACb,OAAO,OAAO,SAAS,CAAC,GAAG,IAAI;GACjC;EACF;EAGA,MAAM,OAAO;EAIb,MAAM,aACJ,QACA,oBAAoB,EAAE,UAAA,GAA4B,MAC/C;;GACH,IAAI,WAAW,MAAM;;IAInB,MAAM,sBAAM,IAAI,MACd,oIACF;IACA,KAAK,OAAA,aAAM,IAAI,WAAA,QAAA,eAAA,KAAA,IAAA,aAAS,IAAI,OAAO;IACnC,OAAO;GACT;GAEA,IAAI,OAAO,sBAAsB,UAC/B,oBAAoB,EAClB,UAAU,kBACZ;GAGF,MAAM,YAAY,UAAU,MAAM;GAClC,MAAM,YAAY,0BAAA,wBAChB,kBAAkB,cAAA,QAAA,0BAAA,KAAA,IAAA,wBAAA,IAClB,MACF;GAEA,IAAI,aAAa,CAAC,kBAAkB,yBAAyB;;IAC3D,MAAM,SAAA,gCAAQ,IAAI,MAAM,EAAA,CAAE,WAAA,QAAA,iBAAA,KAAA,IAAA,eAAS;IACnC,UAAU,KAAK,2CAA2C,OAAO;IACjE,UAAU,KACR,6DAA6D,OAC/D;GACF;GAEA,OAAO,eAAe,QAAQ,WAAW,MAAM,IAAI;EACrD;EAEA,KAAK,YAAY;EAEjB,KAAK,gBAAgB;GACnB,iBAAiB,UAAU,IAAI;EACjC;EAEA,KAAK,yBAAyB,YAAoC;GAChE,OAAO,IAAI,oBAAoB,OAAO;EACxC;EAEA,KAAK,UAAU,UAAU,SAAS;EAClC,KAAK,QAAQ,UAAU,OAAO;EAC9B,KAAK,OAAO,UAAU,MAAM;EAC5B,KAAK,OAAO,UAAU,MAAM;EAC5B,KAAK,QAAQ,UAAU,OAAO;CAChC;AAqBF"}

package/node_modules/@opentelemetry/api/dist/api/logs.cjs

@@ -0,0 +1,59 @@
+const require_global_utils = require("../internal/global-utils.cjs");
+const require_diag = require("./diag.cjs");
+const require_ProxyLoggerProvider = require("../logs/ProxyLoggerProvider.cjs");
+//#region src/api/logs.ts
+const API_NAME = "logs";
+/**
+* Singleton object which represents the entry point to the OpenTelemetry Logs API
+*
+* @since 1.10.0
+*/
+var LogsAPI = class LogsAPI {
+	/** Empty private constructor prevents end users from constructing a new instance of the API */
+	constructor() {
+		this._proxyLoggerProvider = new require_ProxyLoggerProvider.ProxyLoggerProvider();
+	}
+	/** Get the singleton instance of the Logs API */
+	static getInstance() {
+		if (!this._instance) this._instance = new LogsAPI();
+		return this._instance;
+	}
+	setGlobalLoggerProvider(provider) {
+		const success = require_global_utils.registerGlobal(API_NAME, provider, require_diag.DiagAPI.instance());
+		if (success) this._proxyLoggerProvider._setDelegate(provider);
+		return success;
+	}
+	/**
+	* Returns the global logger provider.
+	*
+	* @returns LoggerProvider
+	*/
+	getLoggerProvider() {
+		return require_global_utils.getGlobal(API_NAME) || this._proxyLoggerProvider;
+	}
+	/**
+	* Returns a Logger, creating one if one with the given name, version,
+	* schemaUrl, and attributes is not already created.
+	*
+	* Getting a Logger may be expensive, especially when `attributes` are
+	* provided. Reuse Logger instances where possible instead of calling
+	* `getLogger()` on hot paths.
+	*
+	* @param name The name of the logger or instrumentation library.
+	* @param version The version of the logger or instrumentation library.
+	* @param options The options of the logger or instrumentation library.
+	* @returns {@link Logger}
+	*/
+	getLogger(name, version, options) {
+		return this.getLoggerProvider().getLogger(name, version, options);
+	}
+	/** Remove the global logger provider */
+	disable() {
+		require_global_utils.unregisterGlobal(API_NAME, require_diag.DiagAPI.instance());
+		this._proxyLoggerProvider = new require_ProxyLoggerProvider.ProxyLoggerProvider();
+	}
+};
+//#endregion
+exports.LogsAPI = LogsAPI;
+
+//# sourceMappingURL=logs.cjs.map

package/node_modules/@opentelemetry/api/dist/api/logs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.cjs","names":["ProxyLoggerProvider","registerGlobal","DiagAPI","getGlobal"],"sources":["../../src/api/logs.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {\n  getGlobal,\n  registerGlobal,\n  unregisterGlobal,\n} from '../internal/global-utils';\nimport type { LoggerProvider } from '../logs/LoggerProvider';\nimport type { Logger } from '../logs/Logger';\nimport type { LoggerOptions } from '../logs/LoggerOptions';\nimport { ProxyLoggerProvider } from '../logs/ProxyLoggerProvider';\nimport { DiagAPI } from './diag';\n\nconst API_NAME = 'logs';\n\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Logs API\n *\n * @since 1.10.0\n */\nexport class LogsAPI {\n  private static _instance?: LogsAPI;\n\n  private _proxyLoggerProvider = new ProxyLoggerProvider();\n\n  /** Empty private constructor prevents end users from constructing a new instance of the API */\n  private constructor() {}\n\n  /** Get the singleton instance of the Logs API */\n  public static getInstance(): LogsAPI {\n    if (!this._instance) {\n      this._instance = new LogsAPI();\n    }\n\n    return this._instance;\n  }\n\n  public setGlobalLoggerProvider(provider: LoggerProvider): boolean {\n    const success = registerGlobal(API_NAME, provider, DiagAPI.instance());\n    if (success) {\n      this._proxyLoggerProvider._setDelegate(provider);\n    }\n    return success;\n  }\n\n  /**\n   * Returns the global logger provider.\n   *\n   * @returns LoggerProvider\n   */\n  public getLoggerProvider(): LoggerProvider {\n    return getGlobal(API_NAME) || this._proxyLoggerProvider;\n  }\n\n  /**\n   * Returns a Logger, creating one if one with the given name, version,\n   * schemaUrl, and attributes is not already created.\n   *\n   * Getting a Logger may be expensive, especially when `attributes` are\n   * provided. Reuse Logger instances where possible instead of calling\n   * `getLogger()` on hot paths.\n   *\n   * @param name The name of the logger or instrumentation library.\n   * @param version The version of the logger or instrumentation library.\n   * @param options The options of the logger or instrumentation library.\n   * @returns {@link Logger}\n   */\n  public getLogger(\n    name: string,\n    version?: string,\n    options?: LoggerOptions\n  ): Logger {\n    return this.getLoggerProvider().getLogger(name, version, options);\n  }\n\n  /** Remove the global logger provider */\n  public disable(): void {\n    unregisterGlobal(API_NAME, DiagAPI.instance());\n    this._proxyLoggerProvider = new ProxyLoggerProvider();\n  }\n}\n"],"mappings":";;;;AAgBA,MAAM,WAAW;;;;;;AAOjB,IAAa,UAAb,MAAa,QAAQ;;CAMnB,cAAsB;EAHtB,KAAQ,uBAAuB,IAAIA,4BAAAA,oBAAoB;CAGhC;;CAGvB,OAAc,cAAuB;EACnC,IAAI,CAAC,KAAK,WACR,KAAK,YAAY,IAAI,QAAQ;EAG/B,OAAO,KAAK;CACd;CAEA,wBAA+B,UAAmC;EAChE,MAAM,UAAUC,qBAAAA,eAAe,UAAU,UAAUC,aAAAA,QAAQ,SAAS,CAAC;EACrE,IAAI,SACF,KAAK,qBAAqB,aAAa,QAAQ;EAEjD,OAAO;CACT;;;;;;CAOA,oBAA2C;EACzC,OAAOC,qBAAAA,UAAU,QAAQ,KAAK,KAAK;CACrC;;;;;;;;;;;;;;CAeA,UACE,MACA,SACA,SACQ;EACR,OAAO,KAAK,kBAAkB,CAAC,CAAC,UAAU,MAAM,SAAS,OAAO;CAClE;;CAGA,UAAuB;EACrB,qBAAA,iBAAiB,UAAUD,aAAAA,QAAQ,SAAS,CAAC;EAC7C,KAAK,uBAAuB,IAAIF,4BAAAA,oBAAoB;CACtD;AACF"}

package/node_modules/@opentelemetry/api/dist/api/logs.d.cts

@@ -0,0 +1,43 @@
+import { Logger } from "../logs/Logger.cjs";
+import { LoggerOptions } from "../logs/LoggerOptions.cjs";
+import { LoggerProvider } from "../logs/LoggerProvider.cjs";
+//#region src/api/logs.d.ts
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Logs API
+ *
+ * @since 1.10.0
+ */
+declare class LogsAPI {
+  private static _instance?;
+  private _proxyLoggerProvider;
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  private constructor();
+  /** Get the singleton instance of the Logs API */
+  static getInstance(): LogsAPI;
+  setGlobalLoggerProvider(provider: LoggerProvider): boolean;
+  /**
+   * Returns the global logger provider.
+   *
+   * @returns LoggerProvider
+   */
+  getLoggerProvider(): LoggerProvider;
+  /**
+   * Returns a Logger, creating one if one with the given name, version,
+   * schemaUrl, and attributes is not already created.
+   *
+   * Getting a Logger may be expensive, especially when `attributes` are
+   * provided. Reuse Logger instances where possible instead of calling
+   * `getLogger()` on hot paths.
+   *
+   * @param name The name of the logger or instrumentation library.
+   * @param version The version of the logger or instrumentation library.
+   * @param options The options of the logger or instrumentation library.
+   * @returns {@link Logger}
+   */
+  getLogger(name: string, version?: string, options?: LoggerOptions): Logger;
+  /** Remove the global logger provider */
+  disable(): void;
+}
+//#endregion
+export { LogsAPI };
+//# sourceMappingURL=logs.d.cts.map

package/node_modules/@opentelemetry/api/dist/api/logs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.cts","names":[],"sources":["../../src/api/logs.d.ts"],"mappings":";;;;;;;;;cAQqB;iBACF;UACP;;UAEA;;SAED,eAAe;EACtB,wBAAwB,UAAU;;;;;;EAMlC,qBAAqB;;;;;;;;;;;;;;EAcrB,UAAU,cAAc,kBAAkB,UAAU,gBAAgB;;EAEpE"}