feat: Complete zCode CLI X with Telegram bot integration

- Add full Telegram bot functionality with Z.AI API integration
- Implement 4 tools: Bash, FileEdit, WebSearch, Git
- Add 3 agents: Code Reviewer, Architect, DevOps Engineer
- Add 6 skills for common coding tasks
- Add systemd service file for 24/7 operation
- Add nginx configuration for HTTPS webhook
- Add comprehensive documentation
- Implement WebSocket server for real-time updates
- Add logging system with Winston
- Add environment validation

🤖 zCode CLI X - Agentic coder with Z.AI + Telegram integration

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/OTLPExporterBase.d.ts

@@ -0,0 +1,15 @@
+import { ExportResult } from '@opentelemetry/core';
+import { IOtlpExportDelegate } from './otlp-export-delegate';
+export declare class OTLPExporterBase<Internal> {
+    private _delegate;
+    constructor(_delegate: IOtlpExportDelegate<Internal>);
+    /**
+     * Export items.
+     * @param items
+     * @param resultCallback
+     */
+    export(items: Internal, resultCallback: (result: ExportResult) => void): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=OTLPExporterBase.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/OTLPExporterBase.js

@@ -0,0 +1,39 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTLPExporterBase = void 0;
+class OTLPExporterBase {
+    constructor(_delegate) {
+        this._delegate = _delegate;
+    }
+    /**
+     * Export items.
+     * @param items
+     * @param resultCallback
+     */
+    export(items, resultCallback) {
+        this._delegate.export(items, resultCallback);
+    }
+    forceFlush() {
+        return this._delegate.forceFlush();
+    }
+    shutdown() {
+        return this._delegate.shutdown();
+    }
+}
+exports.OTLPExporterBase = OTLPExporterBase;
+//# sourceMappingURL=OTLPExporterBase.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/OTLPExporterBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OTLPExporterBase.js","sourceRoot":"","sources":["../../src/OTLPExporterBase.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAKH,MAAa,gBAAgB;IAC3B,YAAoB,SAAwC;QAAxC,cAAS,GAAT,SAAS,CAA+B;IAAG,CAAC;IAEhE;;;;OAIG;IACH,MAAM,CACJ,KAAe,EACf,cAA8C;QAE9C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAC/C,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;IACrC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;CACF;AAtBD,4CAsBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ExportResult } from '@opentelemetry/core';\nimport { IOtlpExportDelegate } from './otlp-export-delegate';\n\nexport class OTLPExporterBase<Internal> {\n  constructor(private _delegate: IOtlpExportDelegate<Internal>) {}\n\n  /**\n   * Export items.\n   * @param items\n   * @param resultCallback\n   */\n  export(\n    items: Internal,\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    this._delegate.export(items, resultCallback);\n  }\n\n  forceFlush(): Promise<void> {\n    return this._delegate.forceFlush();\n  }\n\n  shutdown(): Promise<void> {\n    return this._delegate.shutdown();\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/bounded-queue-export-promise-handler.d.ts

@@ -0,0 +1,13 @@
+export interface IExportPromiseHandler {
+    pushPromise(promise: Promise<void>): void;
+    hasReachedLimit(): boolean;
+    awaitAll(): Promise<void>;
+}
+/**
+ * Promise queue for keeping track of export promises. Finished promises will be auto-dequeued.
+ * Allows for awaiting all promises in the queue.
+ */
+export declare function createBoundedQueueExportPromiseHandler(options: {
+    concurrencyLimit: number;
+}): IExportPromiseHandler;
+//# sourceMappingURL=bounded-queue-export-promise-handler.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/bounded-queue-export-promise-handler.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBoundedQueueExportPromiseHandler = void 0;
+class BoundedQueueExportPromiseHandler {
+    /**
+     * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+     */
+    constructor(concurrencyLimit) {
+        this._sendingPromises = [];
+        this._concurrencyLimit = concurrencyLimit;
+    }
+    pushPromise(promise) {
+        if (this.hasReachedLimit()) {
+            throw new Error('Concurrency Limit reached');
+        }
+        this._sendingPromises.push(promise);
+        const popPromise = () => {
+            const index = this._sendingPromises.indexOf(promise);
+            this._sendingPromises.splice(index, 1);
+        };
+        promise.then(popPromise, popPromise);
+    }
+    hasReachedLimit() {
+        return this._sendingPromises.length >= this._concurrencyLimit;
+    }
+    async awaitAll() {
+        await Promise.all(this._sendingPromises);
+    }
+}
+/**
+ * Promise queue for keeping track of export promises. Finished promises will be auto-dequeued.
+ * Allows for awaiting all promises in the queue.
+ */
+function createBoundedQueueExportPromiseHandler(options) {
+    return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
+}
+exports.createBoundedQueueExportPromiseHandler = createBoundedQueueExportPromiseHandler;
+//# sourceMappingURL=bounded-queue-export-promise-handler.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/bounded-queue-export-promise-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-queue-export-promise-handler.js","sourceRoot":"","sources":["../../src/bounded-queue-export-promise-handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAQH,MAAM,gCAAgC;IAIpC;;OAEG;IACH,YAAY,gBAAwB;QAL5B,qBAAgB,GAAuB,EAAE,CAAC;QAMhD,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;IAC5C,CAAC;IAEM,WAAW,CAAC,OAAsB;QACvC,IAAI,IAAI,CAAC,eAAe,EAAE,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;SAC9C;QAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,MAAM,UAAU,GAAG,GAAG,EAAE;YACtB,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACrD,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC;QACF,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACvC,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,QAAQ;QACnB,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;CACF;AAED;;;GAGG;AACH,SAAgB,sCAAsC,CAAC,OAEtD;IACC,OAAO,IAAI,gCAAgC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;AACxE,CAAC;AAJD,wFAIC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface IExportPromiseHandler {\n  pushPromise(promise: Promise<void>): void;\n  hasReachedLimit(): boolean;\n  awaitAll(): Promise<void>;\n}\n\nclass BoundedQueueExportPromiseHandler implements IExportPromiseHandler {\n  private readonly _concurrencyLimit: number;\n  private _sendingPromises: Promise<unknown>[] = [];\n\n  /**\n   * @param concurrencyLimit maximum promises allowed in a queue at the same time.\n   */\n  constructor(concurrencyLimit: number) {\n    this._concurrencyLimit = concurrencyLimit;\n  }\n\n  public pushPromise(promise: Promise<void>): void {\n    if (this.hasReachedLimit()) {\n      throw new Error('Concurrency Limit reached');\n    }\n\n    this._sendingPromises.push(promise);\n    const popPromise = () => {\n      const index = this._sendingPromises.indexOf(promise);\n      this._sendingPromises.splice(index, 1);\n    };\n    promise.then(popPromise, popPromise);\n  }\n\n  public hasReachedLimit(): boolean {\n    return this._sendingPromises.length >= this._concurrencyLimit;\n  }\n\n  public async awaitAll(): Promise<void> {\n    await Promise.all(this._sendingPromises);\n  }\n}\n\n/**\n * Promise queue for keeping track of export promises. Finished promises will be auto-dequeued.\n * Allows for awaiting all promises in the queue.\n */\nexport function createBoundedQueueExportPromiseHandler(options: {\n  concurrencyLimit: number;\n}): IExportPromiseHandler {\n  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-browser-http-options.d.ts

@@ -0,0 +1,11 @@
+import { OtlpHttpConfiguration } from './otlp-http-configuration';
+import { OTLPExporterNodeConfigBase } from './legacy-node-configuration';
+/**
+ * @deprecated this will be removed in 2.0
+ *
+ * @param config
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function convertLegacyBrowserHttpOptions(config: OTLPExporterNodeConfigBase, signalResourcePath: string, requiredHeaders: Record<string, string>): OtlpHttpConfiguration;
+//# sourceMappingURL=convert-legacy-browser-http-options.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-browser-http-options.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLegacyBrowserHttpOptions = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const otlp_http_configuration_1 = require("./otlp-http-configuration");
+const shared_configuration_1 = require("./shared-configuration");
+/**
+ * @deprecated this will be removed in 2.0
+ *
+ * @param config
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+function convertLegacyBrowserHttpOptions(config, signalResourcePath, requiredHeaders) {
+    return (0, otlp_http_configuration_1.mergeOtlpHttpConfigurationWithDefaults)({
+        url: config.url,
+        timeoutMillis: config.timeoutMillis,
+        headers: (0, shared_configuration_1.wrapStaticHeadersInFunction)(config.headers),
+        concurrencyLimit: config.concurrencyLimit,
+    }, {}, // no fallback for browser case
+    (0, otlp_http_configuration_1.getHttpConfigurationDefaults)(requiredHeaders, signalResourcePath));
+}
+exports.convertLegacyBrowserHttpOptions = convertLegacyBrowserHttpOptions;
+//# sourceMappingURL=convert-legacy-browser-http-options.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-browser-http-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-legacy-browser-http-options.js","sourceRoot":"","sources":["../../../src/configuration/convert-legacy-browser-http-options.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACH,uEAImC;AAEnC,iEAAqE;AAErE;;;;;;GAMG;AACH,SAAgB,+BAA+B,CAC7C,MAAkC,EAClC,kBAA0B,EAC1B,eAAuC;IAEvC,OAAO,IAAA,gEAAsC,EAC3C;QACE,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,OAAO,EAAE,IAAA,kDAA2B,EAAC,MAAM,CAAC,OAAO,CAAC;QACpD,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;KAC1C,EACD,EAAE,EAAE,+BAA+B;IACnC,IAAA,sDAA4B,EAAC,eAAe,EAAE,kBAAkB,CAAC,CAClE,CAAC;AACJ,CAAC;AAfD,0EAeC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  getHttpConfigurationDefaults,\n  mergeOtlpHttpConfigurationWithDefaults,\n  OtlpHttpConfiguration,\n} from './otlp-http-configuration';\nimport { OTLPExporterNodeConfigBase } from './legacy-node-configuration';\nimport { wrapStaticHeadersInFunction } from './shared-configuration';\n\n/**\n * @deprecated this will be removed in 2.0\n *\n * @param config\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function convertLegacyBrowserHttpOptions(\n  config: OTLPExporterNodeConfigBase,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): OtlpHttpConfiguration {\n  return mergeOtlpHttpConfigurationWithDefaults(\n    {\n      url: config.url,\n      timeoutMillis: config.timeoutMillis,\n      headers: wrapStaticHeadersInFunction(config.headers),\n      concurrencyLimit: config.concurrencyLimit,\n    },\n    {}, // no fallback for browser case\n    getHttpConfigurationDefaults(requiredHeaders, signalResourcePath)\n  );\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-node-http-options.d.ts

@@ -0,0 +1,11 @@
+import { OTLPExporterNodeConfigBase } from './legacy-node-configuration';
+import { OtlpHttpConfiguration } from './otlp-http-configuration';
+/**
+ * @deprecated this will be removed in 2.0
+ * @param config
+ * @param signalIdentifier
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function convertLegacyHttpOptions(config: OTLPExporterNodeConfigBase, signalIdentifier: string, signalResourcePath: string, requiredHeaders: Record<string, string>): OtlpHttpConfiguration;
+//# sourceMappingURL=convert-legacy-node-http-options.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-node-http-options.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLegacyHttpOptions = void 0;
+const otlp_http_configuration_1 = require("./otlp-http-configuration");
+const otlp_http_env_configuration_1 = require("./otlp-http-env-configuration");
+const api_1 = require("@opentelemetry/api");
+const shared_configuration_1 = require("./shared-configuration");
+function convertLegacyAgentOptions(config) {
+    // populate keepAlive for use with new settings
+    if ((config === null || config === void 0 ? void 0 : config.keepAlive) != null) {
+        if (config.httpAgentOptions != null) {
+            if (config.httpAgentOptions.keepAlive == null) {
+                // specific setting is not set, populate with non-specific setting.
+                config.httpAgentOptions.keepAlive = config.keepAlive;
+            }
+            // do nothing, use specific setting otherwise
+        }
+        else {
+            // populate specific option if AgentOptions does not exist.
+            config.httpAgentOptions = {
+                keepAlive: config.keepAlive,
+            };
+        }
+    }
+    return config.httpAgentOptions;
+}
+/**
+ * @deprecated this will be removed in 2.0
+ * @param config
+ * @param signalIdentifier
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (config.metadata) {
+        api_1.diag.warn('Metadata cannot be set when using http');
+    }
+    return (0, otlp_http_configuration_1.mergeOtlpHttpConfigurationWithDefaults)({
+        url: config.url,
+        headers: (0, shared_configuration_1.wrapStaticHeadersInFunction)(config.headers),
+        concurrencyLimit: config.concurrencyLimit,
+        timeoutMillis: config.timeoutMillis,
+        compression: config.compression,
+        agentOptions: convertLegacyAgentOptions(config),
+    }, (0, otlp_http_env_configuration_1.getHttpConfigurationFromEnvironment)(signalIdentifier, signalResourcePath), (0, otlp_http_configuration_1.getHttpConfigurationDefaults)(requiredHeaders, signalResourcePath));
+}
+exports.convertLegacyHttpOptions = convertLegacyHttpOptions;
+//# sourceMappingURL=convert-legacy-node-http-options.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/convert-legacy-node-http-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-legacy-node-http-options.js","sourceRoot":"","sources":["../../../src/configuration/convert-legacy-node-http-options.ts"],"names":[],"mappings":";;;AAgBA,uEAImC;AACnC,+EAAoF;AAGpF,4CAA0C;AAC1C,iEAAqE;AAErE,SAAS,yBAAyB,CAChC,MAAkC;IAElC,+CAA+C;IAC/C,IAAI,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,SAAS,KAAI,IAAI,EAAE;QAC7B,IAAI,MAAM,CAAC,gBAAgB,IAAI,IAAI,EAAE;YACnC,IAAI,MAAM,CAAC,gBAAgB,CAAC,SAAS,IAAI,IAAI,EAAE;gBAC7C,mEAAmE;gBACnE,MAAM,CAAC,gBAAgB,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;aACtD;YACD,6CAA6C;SAC9C;aAAM;YACL,2DAA2D;YAC3D,MAAM,CAAC,gBAAgB,GAAG;gBACxB,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B,CAAC;SACH;KACF;IAED,OAAO,MAAM,CAAC,gBAAgB,CAAC;AACjC,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,wBAAwB,CACtC,MAAkC,EAClC,gBAAwB,EACxB,kBAA0B,EAC1B,eAAuC;IAEvC,8DAA8D;IAC9D,IAAK,MAAc,CAAC,QAAQ,EAAE;QAC5B,UAAI,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;KACrD;IAED,OAAO,IAAA,gEAAsC,EAC3C;QACE,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,OAAO,EAAE,IAAA,kDAA2B,EAAC,MAAM,CAAC,OAAO,CAAC;QACpD,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,YAAY,EAAE,yBAAyB,CAAC,MAAM,CAAC;KAChD,EACD,IAAA,iEAAmC,EAAC,gBAAgB,EAAE,kBAAkB,CAAC,EACzE,IAAA,sDAA4B,EAAC,eAAe,EAAE,kBAAkB,CAAC,CAClE,CAAC;AACJ,CAAC;AAvBD,4DAuBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { OTLPExporterNodeConfigBase } from './legacy-node-configuration';\nimport {\n  getHttpConfigurationDefaults,\n  mergeOtlpHttpConfigurationWithDefaults,\n  OtlpHttpConfiguration,\n} from './otlp-http-configuration';\nimport { getHttpConfigurationFromEnvironment } from './otlp-http-env-configuration';\nimport type * as http from 'http';\nimport type * as https from 'https';\nimport { diag } from '@opentelemetry/api';\nimport { wrapStaticHeadersInFunction } from './shared-configuration';\n\nfunction convertLegacyAgentOptions(\n  config: OTLPExporterNodeConfigBase\n): http.AgentOptions | https.AgentOptions | undefined {\n  // populate keepAlive for use with new settings\n  if (config?.keepAlive != null) {\n    if (config.httpAgentOptions != null) {\n      if (config.httpAgentOptions.keepAlive == null) {\n        // specific setting is not set, populate with non-specific setting.\n        config.httpAgentOptions.keepAlive = config.keepAlive;\n      }\n      // do nothing, use specific setting otherwise\n    } else {\n      // populate specific option if AgentOptions does not exist.\n      config.httpAgentOptions = {\n        keepAlive: config.keepAlive,\n      };\n    }\n  }\n\n  return config.httpAgentOptions;\n}\n\n/**\n * @deprecated this will be removed in 2.0\n * @param config\n * @param signalIdentifier\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function convertLegacyHttpOptions(\n  config: OTLPExporterNodeConfigBase,\n  signalIdentifier: string,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): OtlpHttpConfiguration {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if ((config as any).metadata) {\n    diag.warn('Metadata cannot be set when using http');\n  }\n\n  return mergeOtlpHttpConfigurationWithDefaults(\n    {\n      url: config.url,\n      headers: wrapStaticHeadersInFunction(config.headers),\n      concurrencyLimit: config.concurrencyLimit,\n      timeoutMillis: config.timeoutMillis,\n      compression: config.compression,\n      agentOptions: convertLegacyAgentOptions(config),\n    },\n    getHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath),\n    getHttpConfigurationDefaults(requiredHeaders, signalResourcePath)\n  );\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/create-legacy-browser-delegate.d.ts

@@ -0,0 +1,12 @@
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+import { IOtlpExportDelegate } from '../otlp-export-delegate';
+import { OTLPExporterConfigBase } from './legacy-base-configuration';
+/**
+ * @deprecated
+ * @param config
+ * @param serializer
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function createLegacyOtlpBrowserExportDelegate<Internal, Response>(config: OTLPExporterConfigBase, serializer: ISerializer<Internal, Response>, signalResourcePath: string, requiredHeaders: Record<string, string>): IOtlpExportDelegate<Internal>;
+//# sourceMappingURL=create-legacy-browser-delegate.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/create-legacy-browser-delegate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLegacyOtlpBrowserExportDelegate = void 0;
+const otlp_browser_http_export_delegate_1 = require("../otlp-browser-http-export-delegate");
+const convert_legacy_browser_http_options_1 = require("./convert-legacy-browser-http-options");
+/**
+ * @deprecated
+ * @param config
+ * @param serializer
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+function createLegacyOtlpBrowserExportDelegate(config, serializer, signalResourcePath, requiredHeaders) {
+    const useXhr = !!config.headers || typeof navigator.sendBeacon !== 'function';
+    const options = (0, convert_legacy_browser_http_options_1.convertLegacyBrowserHttpOptions)(config, signalResourcePath, requiredHeaders);
+    if (useXhr) {
+        return (0, otlp_browser_http_export_delegate_1.createOtlpXhrExportDelegate)(options, serializer);
+    }
+    else {
+        return (0, otlp_browser_http_export_delegate_1.createOtlpSendBeaconExportDelegate)(options, serializer);
+    }
+}
+exports.createLegacyOtlpBrowserExportDelegate = createLegacyOtlpBrowserExportDelegate;
+//# sourceMappingURL=create-legacy-browser-delegate.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/create-legacy-browser-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-legacy-browser-delegate.js","sourceRoot":"","sources":["../../../src/configuration/create-legacy-browser-delegate.ts"],"names":[],"mappings":";;;AAgBA,4FAG8C;AAC9C,+FAAwF;AAIxF;;;;;;GAMG;AACH,SAAgB,qCAAqC,CACnD,MAA8B,EAC9B,UAA2C,EAC3C,kBAA0B,EAC1B,eAAuC;IAEvC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,OAAO,SAAS,CAAC,UAAU,KAAK,UAAU,CAAC;IAE9E,MAAM,OAAO,GAAG,IAAA,qEAA+B,EAC7C,MAAM,EACN,kBAAkB,EAClB,eAAe,CAChB,CAAC;IAEF,IAAI,MAAM,EAAE;QACV,OAAO,IAAA,+DAA2B,EAAC,OAAO,EAAE,UAAU,CAAC,CAAC;KACzD;SAAM;QACL,OAAO,IAAA,sEAAkC,EAAC,OAAO,EAAE,UAAU,CAAC,CAAC;KAChE;AACH,CAAC;AAnBD,sFAmBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ISerializer } from '@opentelemetry/otlp-transformer';\nimport {\n  createOtlpSendBeaconExportDelegate,\n  createOtlpXhrExportDelegate,\n} from '../otlp-browser-http-export-delegate';\nimport { convertLegacyBrowserHttpOptions } from './convert-legacy-browser-http-options';\nimport { IOtlpExportDelegate } from '../otlp-export-delegate';\nimport { OTLPExporterConfigBase } from './legacy-base-configuration';\n\n/**\n * @deprecated\n * @param config\n * @param serializer\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function createLegacyOtlpBrowserExportDelegate<Internal, Response>(\n  config: OTLPExporterConfigBase,\n  serializer: ISerializer<Internal, Response>,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): IOtlpExportDelegate<Internal> {\n  const useXhr = !!config.headers || typeof navigator.sendBeacon !== 'function';\n\n  const options = convertLegacyBrowserHttpOptions(\n    config,\n    signalResourcePath,\n    requiredHeaders\n  );\n\n  if (useXhr) {\n    return createOtlpXhrExportDelegate(options, serializer);\n  } else {\n    return createOtlpSendBeaconExportDelegate(options, serializer);\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-base-configuration.d.ts

@@ -0,0 +1,9 @@
+export interface OTLPExporterConfigBase {
+    headers?: Record<string, string>;
+    url?: string;
+    concurrencyLimit?: number;
+    /** Maximum time the OTLP exporter will wait for each batch export.
+     * The default value is 10000ms. */
+    timeoutMillis?: number;
+}
+//# sourceMappingURL=legacy-base-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-base-configuration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=legacy-base-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-base-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-base-configuration.js","sourceRoot":"","sources":["../../../src/configuration/legacy-base-configuration.ts"],"names":[],"mappings":"","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport interface OTLPExporterConfigBase {\n  headers?: Record<string, string>;\n  url?: string;\n  concurrencyLimit?: number;\n  /** Maximum time the OTLP exporter will wait for each batch export.\n   * The default value is 10000ms. */\n  timeoutMillis?: number;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-node-configuration.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type * as http from 'http';
+import type * as https from 'https';
+import { OTLPExporterConfigBase } from './legacy-base-configuration';
+/**
+ * Collector Exporter node base config
+ */
+export interface OTLPExporterNodeConfigBase extends OTLPExporterConfigBase {
+    keepAlive?: boolean;
+    compression?: CompressionAlgorithm;
+    httpAgentOptions?: http.AgentOptions | https.AgentOptions;
+}
+export declare enum CompressionAlgorithm {
+    NONE = "none",
+    GZIP = "gzip"
+}
+//# sourceMappingURL=legacy-node-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-node-configuration.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionAlgorithm = void 0;
+var CompressionAlgorithm;
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm["NONE"] = "none";
+    CompressionAlgorithm["GZIP"] = "gzip";
+})(CompressionAlgorithm = exports.CompressionAlgorithm || (exports.CompressionAlgorithm = {}));
+//# sourceMappingURL=legacy-node-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/legacy-node-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-node-configuration.js","sourceRoot":"","sources":["../../../src/configuration/legacy-node-configuration.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAiBH,IAAY,oBAGX;AAHD,WAAY,oBAAoB;IAC9B,qCAAa,CAAA;IACb,qCAAa,CAAA;AACf,CAAC,EAHW,oBAAoB,GAApB,4BAAoB,KAApB,4BAAoB,QAG/B","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// NOTE: do not change these imports to be actual imports, otherwise they WILL break `@opentelemetry/instrumentation-http`\nimport type * as http from 'http';\nimport type * as https from 'https';\n\nimport { OTLPExporterConfigBase } from './legacy-base-configuration';\n\n/**\n * Collector Exporter node base config\n */\nexport interface OTLPExporterNodeConfigBase extends OTLPExporterConfigBase {\n  keepAlive?: boolean;\n  compression?: CompressionAlgorithm;\n  httpAgentOptions?: http.AgentOptions | https.AgentOptions;\n}\n\nexport enum CompressionAlgorithm {\n  NONE = 'none',\n  GZIP = 'gzip',\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/otlp-http-configuration.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { OtlpSharedConfiguration } from './shared-configuration';
+import type * as http from 'http';
+import type * as https from 'https';
+export interface OtlpHttpConfiguration extends OtlpSharedConfiguration {
+    url: string;
+    headers: () => Record<string, string>;
+    agentOptions: http.AgentOptions | https.AgentOptions;
+}
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export declare function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration: Partial<OtlpHttpConfiguration>, fallbackConfiguration: Partial<OtlpHttpConfiguration>, defaultConfiguration: OtlpHttpConfiguration): OtlpHttpConfiguration;
+export declare function getHttpConfigurationDefaults(requiredHeaders: Record<string, string>, signalResourcePath: string): OtlpHttpConfiguration;
+//# sourceMappingURL=otlp-http-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/otlp-http-configuration.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpConfigurationDefaults = exports.mergeOtlpHttpConfigurationWithDefaults = void 0;
+const shared_configuration_1 = require("./shared-configuration");
+const util_1 = require("../util");
+function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+    const requiredHeaders = Object.assign({}, defaultHeaders());
+    const headers = {};
+    return () => {
+        // add fallback ones first
+        if (fallbackHeaders != null) {
+            Object.assign(headers, fallbackHeaders());
+        }
+        // override with user-provided ones
+        if (userProvidedHeaders != null) {
+            Object.assign(headers, userProvidedHeaders());
+        }
+        // override required ones.
+        return Object.assign(headers, requiredHeaders);
+    };
+}
+function validateUserProvidedUrl(url) {
+    if (url == null) {
+        return undefined;
+    }
+    try {
+        new URL(url);
+        return url;
+    }
+    catch (e) {
+        throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+    }
+}
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+    var _a, _b, _c, _d;
+    return Object.assign(Object.assign({}, (0, shared_configuration_1.mergeOtlpSharedConfigurationWithDefaults)(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration)), { headers: mergeHeaders((0, util_1.validateAndNormalizeHeaders)(userProvidedConfiguration.headers), fallbackConfiguration.headers, defaultConfiguration.headers), url: (_b = (_a = validateUserProvidedUrl(userProvidedConfiguration.url)) !== null && _a !== void 0 ? _a : fallbackConfiguration.url) !== null && _b !== void 0 ? _b : defaultConfiguration.url, agentOptions: (_d = (_c = userProvidedConfiguration.agentOptions) !== null && _c !== void 0 ? _c : fallbackConfiguration.agentOptions) !== null && _d !== void 0 ? _d : defaultConfiguration.agentOptions });
+}
+exports.mergeOtlpHttpConfigurationWithDefaults = mergeOtlpHttpConfigurationWithDefaults;
+function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+    return Object.assign(Object.assign({}, (0, shared_configuration_1.getSharedConfigurationDefaults)()), { headers: () => requiredHeaders, url: 'http://localhost:4318/' + signalResourcePath, agentOptions: { keepAlive: true } });
+}
+exports.getHttpConfigurationDefaults = getHttpConfigurationDefaults;
+//# sourceMappingURL=otlp-http-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/otlp-http-env-configuration.d.ts

@@ -0,0 +1,9 @@
+import { OtlpHttpConfiguration } from './otlp-http-configuration';
+/**
+ * Reads and returns configuration from the environment
+ *
+ * @param signalIdentifier all caps part in environment variables that identifies the signal (e.g.: METRICS, TRACES, LOGS)
+ * @param signalResourcePath signal resource path to append if necessary (e.g.: v1/metrics, v1/traces, v1/logs)
+ */
+export declare function getHttpConfigurationFromEnvironment(signalIdentifier: string, signalResourcePath: string): Partial<OtlpHttpConfiguration>;
+//# sourceMappingURL=otlp-http-env-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/otlp-http-env-configuration.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpConfigurationFromEnvironment = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const core_1 = require("@opentelemetry/core");
+const api_1 = require("@opentelemetry/api");
+const shared_env_configuration_1 = require("./shared-env-configuration");
+const shared_configuration_1 = require("./shared-configuration");
+function getStaticHeadersFromEnv(signalIdentifier) {
+    var _a, _b;
+    const signalSpecificRawHeaders = (_a = process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`]) === null || _a === void 0 ? void 0 : _a.trim();
+    const nonSignalSpecificRawHeaders = (_b = process.env['OTEL_EXPORTER_OTLP_HEADERS']) === null || _b === void 0 ? void 0 : _b.trim();
+    const signalSpecificHeaders = core_1.baggageUtils.parseKeyPairsIntoRecord(signalSpecificRawHeaders);
+    const nonSignalSpecificHeaders = core_1.baggageUtils.parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders);
+    if (Object.keys(signalSpecificHeaders).length === 0 &&
+        Object.keys(nonSignalSpecificHeaders).length === 0) {
+        return undefined;
+    }
+    // headers are combined instead of overwritten, with the specific headers taking precedence over
+    // the non-specific ones.
+    return Object.assign({}, core_1.baggageUtils.parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders), core_1.baggageUtils.parseKeyPairsIntoRecord(signalSpecificRawHeaders));
+}
+function appendRootPathToUrlIfNeeded(url) {
+    try {
+        const parsedUrl = new URL(url);
+        // This will automatically append '/' if there's no root path.
+        return parsedUrl.toString();
+    }
+    catch (_a) {
+        api_1.diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+        return undefined;
+    }
+}
+function appendResourcePathToUrl(url, path) {
+    try {
+        // just try to parse, if it fails we catch and warn.
+        new URL(url);
+    }
+    catch (_a) {
+        api_1.diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+        return undefined;
+    }
+    if (!url.endsWith('/')) {
+        url = url + '/';
+    }
+    url += path;
+    try {
+        // just try to parse, if it fails we catch and warn.
+        new URL(url);
+    }
+    catch (_b) {
+        api_1.diag.warn(`Configuration: Provided URL appended with '${path}' is not a valid URL, using 'undefined' instead of '${url}'`);
+        return undefined;
+    }
+    return url;
+}
+function getNonSpecificUrlFromEnv(signalResourcePath) {
+    var _a;
+    const envUrl = (_a = process.env.OTEL_EXPORTER_OTLP_ENDPOINT) === null || _a === void 0 ? void 0 : _a.trim();
+    if (envUrl == null || envUrl === '') {
+        return undefined;
+    }
+    return appendResourcePathToUrl(envUrl, signalResourcePath);
+}
+function getSpecificUrlFromEnv(signalIdentifier) {
+    var _a;
+    const envUrl = (_a = process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`]) === null || _a === void 0 ? void 0 : _a.trim();
+    if (envUrl == null || envUrl === '') {
+        return undefined;
+    }
+    return appendRootPathToUrlIfNeeded(envUrl);
+}
+/**
+ * Reads and returns configuration from the environment
+ *
+ * @param signalIdentifier all caps part in environment variables that identifies the signal (e.g.: METRICS, TRACES, LOGS)
+ * @param signalResourcePath signal resource path to append if necessary (e.g.: v1/metrics, v1/traces, v1/logs)
+ */
+function getHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) {
+    var _a;
+    return Object.assign(Object.assign({}, (0, shared_env_configuration_1.getSharedConfigurationFromEnvironment)(signalIdentifier)), { url: (_a = getSpecificUrlFromEnv(signalIdentifier)) !== null && _a !== void 0 ? _a : getNonSpecificUrlFromEnv(signalResourcePath), headers: (0, shared_configuration_1.wrapStaticHeadersInFunction)(getStaticHeadersFromEnv(signalIdentifier)) });
+}
+exports.getHttpConfigurationFromEnvironment = getHttpConfigurationFromEnvironment;
+//# sourceMappingURL=otlp-http-env-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-configuration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration shared across all OTLP exporters
+ *
+ * Implementation note: anything added here MUST be
+ * - platform-agnostic
+ * - signal-agnostic
+ * - transport-agnostic
+ */
+export interface OtlpSharedConfiguration {
+    timeoutMillis: number;
+    concurrencyLimit: number;
+    compression: 'gzip' | 'none';
+}
+export declare function validateTimeoutMillis(timeoutMillis: number): number;
+export declare function wrapStaticHeadersInFunction(headers: Record<string, string> | undefined): (() => Record<string, string>) | undefined;
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export declare function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration: Partial<OtlpSharedConfiguration>, fallbackConfiguration: Partial<OtlpSharedConfiguration>, defaultConfiguration: OtlpSharedConfiguration): OtlpSharedConfiguration;
+export declare function getSharedConfigurationDefaults(): OtlpSharedConfiguration;
+//# sourceMappingURL=shared-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-configuration.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedConfigurationDefaults = exports.mergeOtlpSharedConfigurationWithDefaults = exports.wrapStaticHeadersInFunction = exports.validateTimeoutMillis = void 0;
+function validateTimeoutMillis(timeoutMillis) {
+    if (!Number.isNaN(timeoutMillis) &&
+        Number.isFinite(timeoutMillis) &&
+        timeoutMillis > 0) {
+        return timeoutMillis;
+    }
+    throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
+}
+exports.validateTimeoutMillis = validateTimeoutMillis;
+function wrapStaticHeadersInFunction(headers) {
+    if (headers == null) {
+        return undefined;
+    }
+    return () => headers;
+}
+exports.wrapStaticHeadersInFunction = wrapStaticHeadersInFunction;
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        timeoutMillis: validateTimeoutMillis((_b = (_a = userProvidedConfiguration.timeoutMillis) !== null && _a !== void 0 ? _a : fallbackConfiguration.timeoutMillis) !== null && _b !== void 0 ? _b : defaultConfiguration.timeoutMillis),
+        concurrencyLimit: (_d = (_c = userProvidedConfiguration.concurrencyLimit) !== null && _c !== void 0 ? _c : fallbackConfiguration.concurrencyLimit) !== null && _d !== void 0 ? _d : defaultConfiguration.concurrencyLimit,
+        compression: (_f = (_e = userProvidedConfiguration.compression) !== null && _e !== void 0 ? _e : fallbackConfiguration.compression) !== null && _f !== void 0 ? _f : defaultConfiguration.compression,
+    };
+}
+exports.mergeOtlpSharedConfigurationWithDefaults = mergeOtlpSharedConfigurationWithDefaults;
+function getSharedConfigurationDefaults() {
+    return {
+        timeoutMillis: 10000,
+        concurrencyLimit: 30,
+        compression: 'none',
+    };
+}
+exports.getSharedConfigurationDefaults = getSharedConfigurationDefaults;
+//# sourceMappingURL=shared-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-configuration.js","sourceRoot":"","sources":["../../../src/configuration/shared-configuration.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAgBH,SAAgB,qBAAqB,CAAC,aAAqB;IACzD,IACE,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC;QAC5B,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;QAC9B,aAAa,GAAG,CAAC,EACjB;QACA,OAAO,aAAa,CAAC;KACtB;IACD,MAAM,IAAI,KAAK,CACb,qFAAqF,aAAa,IAAI,CACvG,CAAC;AACJ,CAAC;AAXD,sDAWC;AAED,SAAgB,2BAA2B,CACzC,OAA2C;IAE3C,IAAI,OAAO,IAAI,IAAI,EAAE;QACnB,OAAO,SAAS,CAAC;KAClB;IAED,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC;AACvB,CAAC;AARD,kEAQC;AAED;;;;GAIG;AACH,SAAgB,wCAAwC,CACtD,yBAA2D,EAC3D,qBAAuD,EACvD,oBAA6C;;IAE7C,OAAO;QACL,aAAa,EAAE,qBAAqB,CAClC,MAAA,MAAA,yBAAyB,CAAC,aAAa,mCACrC,qBAAqB,CAAC,aAAa,mCACnC,oBAAoB,CAAC,aAAa,CACrC;QACD,gBAAgB,EACd,MAAA,MAAA,yBAAyB,CAAC,gBAAgB,mCAC1C,qBAAqB,CAAC,gBAAgB,mCACtC,oBAAoB,CAAC,gBAAgB;QACvC,WAAW,EACT,MAAA,MAAA,yBAAyB,CAAC,WAAW,mCACrC,qBAAqB,CAAC,WAAW,mCACjC,oBAAoB,CAAC,WAAW;KACnC,CAAC;AACJ,CAAC;AApBD,4FAoBC;AAED,SAAgB,8BAA8B;IAC5C,OAAO;QACL,aAAa,EAAE,KAAK;QACpB,gBAAgB,EAAE,EAAE;QACpB,WAAW,EAAE,MAAM;KACpB,CAAC;AACJ,CAAC;AAND,wEAMC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Configuration shared across all OTLP exporters\n *\n * Implementation note: anything added here MUST be\n * - platform-agnostic\n * - signal-agnostic\n * - transport-agnostic\n */\nexport interface OtlpSharedConfiguration {\n  timeoutMillis: number;\n  concurrencyLimit: number;\n  compression: 'gzip' | 'none';\n}\n\nexport function validateTimeoutMillis(timeoutMillis: number) {\n  if (\n    !Number.isNaN(timeoutMillis) &&\n    Number.isFinite(timeoutMillis) &&\n    timeoutMillis > 0\n  ) {\n    return timeoutMillis;\n  }\n  throw new Error(\n    `Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`\n  );\n}\n\nexport function wrapStaticHeadersInFunction(\n  headers: Record<string, string> | undefined\n): (() => Record<string, string>) | undefined {\n  if (headers == null) {\n    return undefined;\n  }\n\n  return () => headers;\n}\n\n/**\n * @param userProvidedConfiguration  Configuration options provided by the user in code.\n * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.\n * @param defaultConfiguration The defaults as defined by the exporter specification\n */\nexport function mergeOtlpSharedConfigurationWithDefaults(\n  userProvidedConfiguration: Partial<OtlpSharedConfiguration>,\n  fallbackConfiguration: Partial<OtlpSharedConfiguration>,\n  defaultConfiguration: OtlpSharedConfiguration\n): OtlpSharedConfiguration {\n  return {\n    timeoutMillis: validateTimeoutMillis(\n      userProvidedConfiguration.timeoutMillis ??\n        fallbackConfiguration.timeoutMillis ??\n        defaultConfiguration.timeoutMillis\n    ),\n    concurrencyLimit:\n      userProvidedConfiguration.concurrencyLimit ??\n      fallbackConfiguration.concurrencyLimit ??\n      defaultConfiguration.concurrencyLimit,\n    compression:\n      userProvidedConfiguration.compression ??\n      fallbackConfiguration.compression ??\n      defaultConfiguration.compression,\n  };\n}\n\nexport function getSharedConfigurationDefaults(): OtlpSharedConfiguration {\n  return {\n    timeoutMillis: 10000,\n    concurrencyLimit: 30,\n    compression: 'none',\n  };\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-env-configuration.d.ts

@@ -0,0 +1,3 @@
+import { OtlpSharedConfiguration } from './shared-configuration';
+export declare function getSharedConfigurationFromEnvironment(signalIdentifier: string): Partial<OtlpSharedConfiguration>;
+//# sourceMappingURL=shared-env-configuration.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-env-configuration.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedConfigurationFromEnvironment = void 0;
+const api_1 = require("@opentelemetry/api");
+function parseAndValidateTimeoutFromEnv(timeoutEnvVar) {
+    var _a;
+    const envTimeout = (_a = process.env[timeoutEnvVar]) === null || _a === void 0 ? void 0 : _a.trim();
+    if (envTimeout != null && envTimeout !== '') {
+        const definedTimeout = Number(envTimeout);
+        if (!Number.isNaN(definedTimeout) &&
+            Number.isFinite(definedTimeout) &&
+            definedTimeout > 0) {
+            return definedTimeout;
+        }
+        api_1.diag.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`);
+    }
+    return undefined;
+}
+function getTimeoutFromEnv(signalIdentifier) {
+    const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`);
+    const nonSpecificTimeout = parseAndValidateTimeoutFromEnv('OTEL_EXPORTER_OTLP_TIMEOUT');
+    return specificTimeout !== null && specificTimeout !== void 0 ? specificTimeout : nonSpecificTimeout;
+}
+function parseAndValidateCompressionFromEnv(compressionEnvVar) {
+    var _a;
+    const compression = (_a = process.env[compressionEnvVar]) === null || _a === void 0 ? void 0 : _a.trim();
+    if (compression === '') {
+        return undefined;
+    }
+    if (compression == null || compression === 'none' || compression === 'gzip') {
+        return compression;
+    }
+    api_1.diag.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`);
+    return undefined;
+}
+function getCompressionFromEnv(signalIdentifier) {
+    const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`);
+    const nonSpecificCompression = parseAndValidateCompressionFromEnv('OTEL_EXPORTER_OTLP_COMPRESSION');
+    return specificCompression !== null && specificCompression !== void 0 ? specificCompression : nonSpecificCompression;
+}
+function getSharedConfigurationFromEnvironment(signalIdentifier) {
+    return {
+        timeoutMillis: getTimeoutFromEnv(signalIdentifier),
+        compression: getCompressionFromEnv(signalIdentifier),
+    };
+}
+exports.getSharedConfigurationFromEnvironment = getSharedConfigurationFromEnvironment;
+//# sourceMappingURL=shared-env-configuration.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/configuration/shared-env-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-env-configuration.js","sourceRoot":"","sources":["../../../src/configuration/shared-env-configuration.ts"],"names":[],"mappings":";;;AAgBA,4CAA0C;AAE1C,SAAS,8BAA8B,CACrC,aAAqB;;IAErB,MAAM,UAAU,GAAG,MAAA,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,0CAAE,IAAI,EAAE,CAAC;IACtD,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,KAAK,EAAE,EAAE;QAC3C,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1C,IACE,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC;YAC7B,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC;YAC/B,cAAc,GAAG,CAAC,EAClB;YACA,OAAO,cAAc,CAAC;SACvB;QACD,UAAI,CAAC,IAAI,CACP,kBAAkB,aAAa,wDAAwD,UAAU,GAAG,CACrG,CAAC;KACH;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,iBAAiB,CAAC,gBAAwB;IACjD,MAAM,eAAe,GAAG,8BAA8B,CACpD,sBAAsB,gBAAgB,UAAU,CACjD,CAAC;IACF,MAAM,kBAAkB,GAAG,8BAA8B,CACvD,4BAA4B,CAC7B,CAAC;IAEF,OAAO,eAAe,aAAf,eAAe,cAAf,eAAe,GAAI,kBAAkB,CAAC;AAC/C,CAAC;AAED,SAAS,kCAAkC,CACzC,iBAAyB;;IAEzB,MAAM,WAAW,GAAG,MAAA,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,0CAAE,IAAI,EAAE,CAAC;IAC3D,IAAI,WAAW,KAAK,EAAE,EAAE;QACtB,OAAO,SAAS,CAAC;KAClB;IAED,IAAI,WAAW,IAAI,IAAI,IAAI,WAAW,KAAK,MAAM,IAAI,WAAW,KAAK,MAAM,EAAE;QAC3E,OAAO,WAAW,CAAC;KACpB;IAED,UAAI,CAAC,IAAI,CACP,kBAAkB,iBAAiB,oDAAoD,WAAW,IAAI,CACvG,CAAC;IACF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,qBAAqB,CAC5B,gBAAwB;IAExB,MAAM,mBAAmB,GAAG,kCAAkC,CAC5D,sBAAsB,gBAAgB,cAAc,CACrD,CAAC;IACF,MAAM,sBAAsB,GAAG,kCAAkC,CAC/D,gCAAgC,CACjC,CAAC;IAEF,OAAO,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,sBAAsB,CAAC;AACvD,CAAC;AAED,SAAgB,qCAAqC,CACnD,gBAAwB;IAExB,OAAO;QACL,aAAa,EAAE,iBAAiB,CAAC,gBAAgB,CAAC;QAClD,WAAW,EAAE,qBAAqB,CAAC,gBAAgB,CAAC;KACrD,CAAC;AACJ,CAAC;AAPD,sFAOC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { OtlpSharedConfiguration } from './shared-configuration';\nimport { diag } from '@opentelemetry/api';\n\nfunction parseAndValidateTimeoutFromEnv(\n  timeoutEnvVar: string\n): number | undefined {\n  const envTimeout = process.env[timeoutEnvVar]?.trim();\n  if (envTimeout != null && envTimeout !== '') {\n    const definedTimeout = Number(envTimeout);\n    if (\n      !Number.isNaN(definedTimeout) &&\n      Number.isFinite(definedTimeout) &&\n      definedTimeout > 0\n    ) {\n      return definedTimeout;\n    }\n    diag.warn(\n      `Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`\n    );\n  }\n  return undefined;\n}\n\nfunction getTimeoutFromEnv(signalIdentifier: string) {\n  const specificTimeout = parseAndValidateTimeoutFromEnv(\n    `OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`\n  );\n  const nonSpecificTimeout = parseAndValidateTimeoutFromEnv(\n    'OTEL_EXPORTER_OTLP_TIMEOUT'\n  );\n\n  return specificTimeout ?? nonSpecificTimeout;\n}\n\nfunction parseAndValidateCompressionFromEnv(\n  compressionEnvVar: string\n): 'none' | 'gzip' | undefined {\n  const compression = process.env[compressionEnvVar]?.trim();\n  if (compression === '') {\n    return undefined;\n  }\n\n  if (compression == null || compression === 'none' || compression === 'gzip') {\n    return compression;\n  }\n\n  diag.warn(\n    `Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`\n  );\n  return undefined;\n}\n\nfunction getCompressionFromEnv(\n  signalIdentifier: string\n): 'none' | 'gzip' | undefined {\n  const specificCompression = parseAndValidateCompressionFromEnv(\n    `OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`\n  );\n  const nonSpecificCompression = parseAndValidateCompressionFromEnv(\n    'OTEL_EXPORTER_OTLP_COMPRESSION'\n  );\n\n  return specificCompression ?? nonSpecificCompression;\n}\n\nexport function getSharedConfigurationFromEnvironment(\n  signalIdentifier: string\n): Partial<OtlpSharedConfiguration> {\n  return {\n    timeoutMillis: getTimeoutFromEnv(signalIdentifier),\n    compression: getCompressionFromEnv(signalIdentifier),\n  };\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/export-response.d.ts

@@ -0,0 +1,14 @@
+export interface ExportResponseSuccess {
+    status: 'success';
+    data?: Uint8Array;
+}
+export interface ExportResponseFailure {
+    status: 'failure';
+    error: Error;
+}
+export interface ExportResponseRetryable {
+    status: 'retryable';
+    retryInMillis?: number;
+}
+export declare type ExportResponse = ExportResponseSuccess | ExportResponseFailure | ExportResponseRetryable;
+//# sourceMappingURL=export-response.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/export-response.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=export-response.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/export-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-response.js","sourceRoot":"","sources":["../../src/export-response.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface ExportResponseSuccess {\n  status: 'success';\n  data?: Uint8Array;\n}\n\nexport interface ExportResponseFailure {\n  status: 'failure';\n  error: Error;\n}\n\nexport interface ExportResponseRetryable {\n  status: 'retryable';\n  retryInMillis?: number;\n}\n\nexport type ExportResponse =\n  | ExportResponseSuccess\n  | ExportResponseFailure\n  | ExportResponseRetryable;\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/exporter-transport.d.ts

@@ -0,0 +1,6 @@
+import { ExportResponse } from './export-response';
+export interface IExporterTransport {
+    send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse>;
+    shutdown(): void;
+}
+//# sourceMappingURL=exporter-transport.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/exporter-transport.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=exporter-transport.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/exporter-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter-transport.js","sourceRoot":"","sources":["../../src/exporter-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ExportResponse } from './export-response';\n\nexport interface IExporterTransport {\n  send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse>;\n  shutdown(): void;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-browser-http.d.ts

@@ -0,0 +1,4 @@
+export { createOtlpXhrExportDelegate, createOtlpSendBeaconExportDelegate, } from './otlp-browser-http-export-delegate';
+export { convertLegacyBrowserHttpOptions } from './configuration/convert-legacy-browser-http-options';
+export { createLegacyOtlpBrowserExportDelegate } from './configuration/create-legacy-browser-delegate';
+//# sourceMappingURL=index-browser-http.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-browser-http.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLegacyOtlpBrowserExportDelegate = exports.convertLegacyBrowserHttpOptions = exports.createOtlpSendBeaconExportDelegate = exports.createOtlpXhrExportDelegate = void 0;
+var otlp_browser_http_export_delegate_1 = require("./otlp-browser-http-export-delegate");
+Object.defineProperty(exports, "createOtlpXhrExportDelegate", { enumerable: true, get: function () { return otlp_browser_http_export_delegate_1.createOtlpXhrExportDelegate; } });
+Object.defineProperty(exports, "createOtlpSendBeaconExportDelegate", { enumerable: true, get: function () { return otlp_browser_http_export_delegate_1.createOtlpSendBeaconExportDelegate; } });
+var convert_legacy_browser_http_options_1 = require("./configuration/convert-legacy-browser-http-options");
+Object.defineProperty(exports, "convertLegacyBrowserHttpOptions", { enumerable: true, get: function () { return convert_legacy_browser_http_options_1.convertLegacyBrowserHttpOptions; } });
+var create_legacy_browser_delegate_1 = require("./configuration/create-legacy-browser-delegate");
+Object.defineProperty(exports, "createLegacyOtlpBrowserExportDelegate", { enumerable: true, get: function () { return create_legacy_browser_delegate_1.createLegacyOtlpBrowserExportDelegate; } });
+//# sourceMappingURL=index-browser-http.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-browser-http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-browser-http.js","sourceRoot":"","sources":["../../src/index-browser-http.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,yFAG6C;AAF3C,gJAAA,2BAA2B,OAAA;AAC3B,uJAAA,kCAAkC,OAAA;AAGpC,2GAAsG;AAA7F,sJAAA,+BAA+B,OAAA;AACxC,iGAAuG;AAA9F,uJAAA,qCAAqC,OAAA","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport {\n  createOtlpXhrExportDelegate,\n  createOtlpSendBeaconExportDelegate,\n} from './otlp-browser-http-export-delegate';\n\nexport { convertLegacyBrowserHttpOptions } from './configuration/convert-legacy-browser-http-options';\nexport { createLegacyOtlpBrowserExportDelegate } from './configuration/create-legacy-browser-delegate';\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-node-http.d.ts

@@ -0,0 +1,4 @@
+export { createOtlpHttpExportDelegate } from './otlp-http-export-delegate';
+export { getSharedConfigurationFromEnvironment } from './configuration/shared-env-configuration';
+export { convertLegacyHttpOptions } from './configuration/convert-legacy-node-http-options';
+//# sourceMappingURL=index-node-http.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-node-http.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLegacyHttpOptions = exports.getSharedConfigurationFromEnvironment = exports.createOtlpHttpExportDelegate = void 0;
+var otlp_http_export_delegate_1 = require("./otlp-http-export-delegate");
+Object.defineProperty(exports, "createOtlpHttpExportDelegate", { enumerable: true, get: function () { return otlp_http_export_delegate_1.createOtlpHttpExportDelegate; } });
+var shared_env_configuration_1 = require("./configuration/shared-env-configuration");
+Object.defineProperty(exports, "getSharedConfigurationFromEnvironment", { enumerable: true, get: function () { return shared_env_configuration_1.getSharedConfigurationFromEnvironment; } });
+var convert_legacy_node_http_options_1 = require("./configuration/convert-legacy-node-http-options");
+Object.defineProperty(exports, "convertLegacyHttpOptions", { enumerable: true, get: function () { return convert_legacy_node_http_options_1.convertLegacyHttpOptions; } });
+//# sourceMappingURL=index-node-http.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index-node-http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-node-http.js","sourceRoot":"","sources":["../../src/index-node-http.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,yEAA2E;AAAlE,yIAAA,4BAA4B,OAAA;AACrC,qFAAiG;AAAxF,iJAAA,qCAAqC,OAAA;AAC9C,qGAA4F;AAAnF,4IAAA,wBAAwB,OAAA","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport { createOtlpHttpExportDelegate } from './otlp-http-export-delegate';\nexport { getSharedConfigurationFromEnvironment } from './configuration/shared-env-configuration';\nexport { convertLegacyHttpOptions } from './configuration/convert-legacy-node-http-options';\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index.d.ts

@@ -0,0 +1,10 @@
+export { OTLPExporterBase } from './OTLPExporterBase';
+export { OTLPExporterError } from './types';
+export { ExportResponse, ExportResponseFailure, ExportResponseSuccess, ExportResponseRetryable, } from './export-response';
+export { IExporterTransport } from './exporter-transport';
+export { OtlpSharedConfiguration, mergeOtlpSharedConfigurationWithDefaults, getSharedConfigurationDefaults, } from './configuration/shared-configuration';
+export { OTLPExporterNodeConfigBase, CompressionAlgorithm, } from './configuration/legacy-node-configuration';
+export { OTLPExporterConfigBase } from './configuration/legacy-base-configuration';
+export { IOtlpExportDelegate } from './otlp-export-delegate';
+export { createOtlpNetworkExportDelegate } from './otlp-network-export-delegate';
+//# sourceMappingURL=index.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtlpNetworkExportDelegate = exports.CompressionAlgorithm = exports.getSharedConfigurationDefaults = exports.mergeOtlpSharedConfigurationWithDefaults = exports.OTLPExporterError = exports.OTLPExporterBase = void 0;
+var OTLPExporterBase_1 = require("./OTLPExporterBase");
+Object.defineProperty(exports, "OTLPExporterBase", { enumerable: true, get: function () { return OTLPExporterBase_1.OTLPExporterBase; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "OTLPExporterError", { enumerable: true, get: function () { return types_1.OTLPExporterError; } });
+var shared_configuration_1 = require("./configuration/shared-configuration");
+Object.defineProperty(exports, "mergeOtlpSharedConfigurationWithDefaults", { enumerable: true, get: function () { return shared_configuration_1.mergeOtlpSharedConfigurationWithDefaults; } });
+Object.defineProperty(exports, "getSharedConfigurationDefaults", { enumerable: true, get: function () { return shared_configuration_1.getSharedConfigurationDefaults; } });
+var legacy_node_configuration_1 = require("./configuration/legacy-node-configuration");
+Object.defineProperty(exports, "CompressionAlgorithm", { enumerable: true, get: function () { return legacy_node_configuration_1.CompressionAlgorithm; } });
+var otlp_network_export_delegate_1 = require("./otlp-network-export-delegate");
+Object.defineProperty(exports, "createOtlpNetworkExportDelegate", { enumerable: true, get: function () { return otlp_network_export_delegate_1.createOtlpNetworkExportDelegate; } });
+//# sourceMappingURL=index.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,iCAA4C;AAAnC,0GAAA,iBAAiB,OAAA;AAW1B,6EAI8C;AAF5C,gJAAA,wCAAwC,OAAA;AACxC,sIAAA,8BAA8B,OAAA;AAGhC,uFAGmD;AADjD,iIAAA,oBAAoB,OAAA;AAItB,+EAAiF;AAAxE,+IAAA,+BAA+B,OAAA","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport { OTLPExporterBase } from './OTLPExporterBase';\nexport { OTLPExporterError } from './types';\n\nexport {\n  ExportResponse,\n  ExportResponseFailure,\n  ExportResponseSuccess,\n  ExportResponseRetryable,\n} from './export-response';\n\nexport { IExporterTransport } from './exporter-transport';\n\nexport {\n  OtlpSharedConfiguration,\n  mergeOtlpSharedConfigurationWithDefaults,\n  getSharedConfigurationDefaults,\n} from './configuration/shared-configuration';\n\nexport {\n  OTLPExporterNodeConfigBase,\n  CompressionAlgorithm,\n} from './configuration/legacy-node-configuration';\nexport { OTLPExporterConfigBase } from './configuration/legacy-base-configuration';\nexport { IOtlpExportDelegate } from './otlp-export-delegate';\nexport { createOtlpNetworkExportDelegate } from './otlp-network-export-delegate';\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/is-export-retryable.d.ts

@@ -0,0 +1,3 @@
+export declare function isExportRetryable(statusCode: number): boolean;
+export declare function parseRetryAfterToMills(retryAfter?: string | undefined | null): number | undefined;
+//# sourceMappingURL=is-export-retryable.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/is-export-retryable.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRetryAfterToMills = exports.isExportRetryable = void 0;
+function isExportRetryable(statusCode) {
+    const retryCodes = [429, 502, 503, 504];
+    return retryCodes.includes(statusCode);
+}
+exports.isExportRetryable = isExportRetryable;
+function parseRetryAfterToMills(retryAfter) {
+    if (retryAfter == null) {
+        return undefined;
+    }
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (Number.isInteger(seconds)) {
+        return seconds > 0 ? seconds * 1000 : -1;
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives
+    const delay = new Date(retryAfter).getTime() - Date.now();
+    if (delay >= 0) {
+        return delay;
+    }
+    return 0;
+}
+exports.parseRetryAfterToMills = parseRetryAfterToMills;
+//# sourceMappingURL=is-export-retryable.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/is-export-retryable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-export-retryable.js","sourceRoot":"","sources":["../../src/is-export-retryable.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,SAAgB,iBAAiB,CAAC,UAAkB;IAClD,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACzC,CAAC;AAHD,8CAGC;AAED,SAAgB,sBAAsB,CACpC,UAAsC;IAEtC,IAAI,UAAU,IAAI,IAAI,EAAE;QACtB,OAAO,SAAS,CAAC;KAClB;IAED,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;QAC7B,OAAO,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAC1C;IACD,mFAAmF;IACnF,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAE1D,IAAI,KAAK,IAAI,CAAC,EAAE;QACd,OAAO,KAAK,CAAC;KACd;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAlBD,wDAkBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function isExportRetryable(statusCode: number): boolean {\n  const retryCodes = [429, 502, 503, 504];\n  return retryCodes.includes(statusCode);\n}\n\nexport function parseRetryAfterToMills(\n  retryAfter?: string | undefined | null\n): number | undefined {\n  if (retryAfter == null) {\n    return undefined;\n  }\n\n  const seconds = Number.parseInt(retryAfter, 10);\n  if (Number.isInteger(seconds)) {\n    return seconds > 0 ? seconds * 1000 : -1;\n  }\n  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives\n  const delay = new Date(retryAfter).getTime() - Date.now();\n\n  if (delay >= 0) {\n    return delay;\n  }\n  return 0;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/logging-response-handler.d.ts

@@ -0,0 +1,6 @@
+import { IOtlpResponseHandler } from './response-handler';
+/**
+ * Default response handler that logs a partial success to the console.
+ */
+export declare function createLoggingPartialSuccessResponseHandler<T>(): IOtlpResponseHandler<T>;
+//# sourceMappingURL=logging-response-handler.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/logging-response-handler.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggingPartialSuccessResponseHandler = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const api_1 = require("@opentelemetry/api");
+function isPartialSuccessResponse(response) {
+    return Object.prototype.hasOwnProperty.call(response, 'partialSuccess');
+}
+/**
+ * Default response handler that logs a partial success to the console.
+ */
+function createLoggingPartialSuccessResponseHandler() {
+    return {
+        handleResponse(response) {
+            // Partial success MUST never be an empty object according the specification
+            // see https://opentelemetry.io/docs/specs/otlp/#partial-success
+            if (response == null ||
+                !isPartialSuccessResponse(response) ||
+                response.partialSuccess == null ||
+                Object.keys(response.partialSuccess).length === 0) {
+                return;
+            }
+            api_1.diag.warn('Received Partial Success response:', JSON.stringify(response.partialSuccess));
+        },
+    };
+}
+exports.createLoggingPartialSuccessResponseHandler = createLoggingPartialSuccessResponseHandler;
+//# sourceMappingURL=logging-response-handler.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/logging-response-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-response-handler.js","sourceRoot":"","sources":["../../src/logging-response-handler.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACH,4CAA0C;AAG1C,SAAS,wBAAwB,CAC/B,QAAiB;IAEjB,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;AAC1E,CAAC;AAED;;GAEG;AACH,SAAgB,0CAA0C;IAGxD,OAAO;QACL,cAAc,CAAC,QAAW;YACxB,4EAA4E;YAC5E,gEAAgE;YAChE,IACE,QAAQ,IAAI,IAAI;gBAChB,CAAC,wBAAwB,CAAC,QAAQ,CAAC;gBACnC,QAAQ,CAAC,cAAc,IAAI,IAAI;gBAC/B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,MAAM,KAAK,CAAC,EACjD;gBACA,OAAO;aACR;YACD,UAAI,CAAC,IAAI,CACP,oCAAoC,EACpC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,CACxC,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AArBD,gGAqBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { diag } from '@opentelemetry/api';\nimport { IOtlpResponseHandler } from './response-handler';\n\nfunction isPartialSuccessResponse(\n  response: unknown\n): response is { partialSuccess: never } {\n  return Object.prototype.hasOwnProperty.call(response, 'partialSuccess');\n}\n\n/**\n * Default response handler that logs a partial success to the console.\n */\nexport function createLoggingPartialSuccessResponseHandler<\n  T,\n>(): IOtlpResponseHandler<T> {\n  return {\n    handleResponse(response: T) {\n      // Partial success MUST never be an empty object according the specification\n      // see https://opentelemetry.io/docs/specs/otlp/#partial-success\n      if (\n        response == null ||\n        !isPartialSuccessResponse(response) ||\n        response.partialSuccess == null ||\n        Object.keys(response.partialSuccess).length === 0\n      ) {\n        return;\n      }\n      diag.warn(\n        'Received Partial Success response:',\n        JSON.stringify(response.partialSuccess)\n      );\n    },\n  };\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-browser-http-export-delegate.d.ts

@@ -0,0 +1,6 @@
+import { OtlpHttpConfiguration } from './configuration/otlp-http-configuration';
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+import { IOtlpExportDelegate } from './otlp-export-delegate';
+export declare function createOtlpXhrExportDelegate<Internal, Response>(options: OtlpHttpConfiguration, serializer: ISerializer<Internal, Response>): IOtlpExportDelegate<Internal>;
+export declare function createOtlpSendBeaconExportDelegate<Internal, Response>(options: OtlpHttpConfiguration, serializer: ISerializer<Internal, Response>): IOtlpExportDelegate<Internal>;
+//# sourceMappingURL=otlp-browser-http-export-delegate.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-browser-http-export-delegate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtlpSendBeaconExportDelegate = exports.createOtlpXhrExportDelegate = void 0;
+const retrying_transport_1 = require("./retrying-transport");
+const xhr_transport_1 = require("./transport/xhr-transport");
+const send_beacon_transport_1 = require("./transport/send-beacon-transport");
+const otlp_network_export_delegate_1 = require("./otlp-network-export-delegate");
+function createOtlpXhrExportDelegate(options, serializer) {
+    return (0, otlp_network_export_delegate_1.createOtlpNetworkExportDelegate)(options, serializer, (0, retrying_transport_1.createRetryingTransport)({
+        transport: (0, xhr_transport_1.createXhrTransport)(options),
+    }));
+}
+exports.createOtlpXhrExportDelegate = createOtlpXhrExportDelegate;
+function createOtlpSendBeaconExportDelegate(options, serializer) {
+    return (0, otlp_network_export_delegate_1.createOtlpNetworkExportDelegate)(options, serializer, (0, retrying_transport_1.createRetryingTransport)({
+        transport: (0, send_beacon_transport_1.createSendBeaconTransport)({
+            url: options.url,
+            blobType: options.headers()['Content-Type'],
+        }),
+    }));
+}
+exports.createOtlpSendBeaconExportDelegate = createOtlpSendBeaconExportDelegate;
+//# sourceMappingURL=otlp-browser-http-export-delegate.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-browser-http-export-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-browser-http-export-delegate.js","sourceRoot":"","sources":["../../src/otlp-browser-http-export-delegate.ts"],"names":[],"mappings":";;;AAkBA,6DAA+D;AAC/D,6DAA+D;AAC/D,6EAA8E;AAC9E,iFAAiF;AAEjF,SAAgB,2BAA2B,CACzC,OAA8B,EAC9B,UAA2C;IAE3C,OAAO,IAAA,8DAA+B,EACpC,OAAO,EACP,UAAU,EACV,IAAA,4CAAuB,EAAC;QACtB,SAAS,EAAE,IAAA,kCAAkB,EAAC,OAAO,CAAC;KACvC,CAAC,CACH,CAAC;AACJ,CAAC;AAXD,kEAWC;AAED,SAAgB,kCAAkC,CAChD,OAA8B,EAC9B,UAA2C;IAE3C,OAAO,IAAA,8DAA+B,EACpC,OAAO,EACP,UAAU,EACV,IAAA,4CAAuB,EAAC;QACtB,SAAS,EAAE,IAAA,iDAAyB,EAAC;YACnC,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,CAAC;SAC5C,CAAC;KACH,CAAC,CACH,CAAC;AACJ,CAAC;AAdD,gFAcC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { OtlpHttpConfiguration } from './configuration/otlp-http-configuration';\nimport { ISerializer } from '@opentelemetry/otlp-transformer';\nimport { IOtlpExportDelegate } from './otlp-export-delegate';\nimport { createRetryingTransport } from './retrying-transport';\nimport { createXhrTransport } from './transport/xhr-transport';\nimport { createSendBeaconTransport } from './transport/send-beacon-transport';\nimport { createOtlpNetworkExportDelegate } from './otlp-network-export-delegate';\n\nexport function createOtlpXhrExportDelegate<Internal, Response>(\n  options: OtlpHttpConfiguration,\n  serializer: ISerializer<Internal, Response>\n): IOtlpExportDelegate<Internal> {\n  return createOtlpNetworkExportDelegate(\n    options,\n    serializer,\n    createRetryingTransport({\n      transport: createXhrTransport(options),\n    })\n  );\n}\n\nexport function createOtlpSendBeaconExportDelegate<Internal, Response>(\n  options: OtlpHttpConfiguration,\n  serializer: ISerializer<Internal, Response>\n): IOtlpExportDelegate<Internal> {\n  return createOtlpNetworkExportDelegate(\n    options,\n    serializer,\n    createRetryingTransport({\n      transport: createSendBeaconTransport({\n        url: options.url,\n        blobType: options.headers()['Content-Type'],\n      }),\n    })\n  );\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-export-delegate.d.ts

@@ -0,0 +1,24 @@
+import { ExportResult } from '@opentelemetry/core';
+import { IExporterTransport } from './exporter-transport';
+import { IExportPromiseHandler } from './bounded-queue-export-promise-handler';
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+/**
+ * Internally shared export logic for OTLP.
+ */
+export interface IOtlpExportDelegate<Internal> {
+    export(internalRepresentation: Internal, resultCallback: (result: ExportResult) => void): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Creates a generic delegate for OTLP exports which only contains parts of the OTLP export that are shared across all
+ * signals.
+ */
+export declare function createOtlpExportDelegate<Internal, Response>(components: {
+    transport: IExporterTransport;
+    serializer: ISerializer<Internal, Response>;
+    promiseHandler: IExportPromiseHandler;
+}, settings: {
+    timeout: number;
+}): IOtlpExportDelegate<Internal>;
+//# sourceMappingURL=otlp-export-delegate.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-export-delegate.js

@@ -0,0 +1,109 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtlpExportDelegate = void 0;
+const core_1 = require("@opentelemetry/core");
+const types_1 = require("./types");
+const logging_response_handler_1 = require("./logging-response-handler");
+const api_1 = require("@opentelemetry/api");
+class OTLPExportDelegate {
+    constructor(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
+        this._transport = _transport;
+        this._serializer = _serializer;
+        this._responseHandler = _responseHandler;
+        this._promiseQueue = _promiseQueue;
+        this._timeout = _timeout;
+        this._diagLogger = api_1.diag.createComponentLogger({
+            namespace: 'OTLPExportDelegate',
+        });
+    }
+    export(internalRepresentation, resultCallback) {
+        this._diagLogger.debug('items to be sent', internalRepresentation);
+        // don't do any work if too many exports are in progress.
+        if (this._promiseQueue.hasReachedLimit()) {
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Concurrent export limit reached'),
+            });
+            return;
+        }
+        const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+        if (serializedRequest == null) {
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Nothing to send'),
+            });
+            return;
+        }
+        this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then(response => {
+            if (response.status === 'success') {
+                if (response.data != null) {
+                    try {
+                        this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
+                    }
+                    catch (e) {
+                        this._diagLogger.warn('Export succeeded but could not deserialize response - is the response specification compliant?', e, response.data);
+                    }
+                }
+                // No matter the response, we can consider the export still successful.
+                resultCallback({
+                    code: core_1.ExportResultCode.SUCCESS,
+                });
+                return;
+            }
+            else if (response.status === 'failure' && response.error) {
+                resultCallback({
+                    code: core_1.ExportResultCode.FAILED,
+                    error: response.error,
+                });
+                return;
+            }
+            else if (response.status === 'retryable') {
+                resultCallback({
+                    code: core_1.ExportResultCode.FAILED,
+                    error: new types_1.OTLPExporterError('Export failed with retryable status'),
+                });
+            }
+            else {
+                resultCallback({
+                    code: core_1.ExportResultCode.FAILED,
+                    error: new types_1.OTLPExporterError('Export failed with unknown error'),
+                });
+            }
+        }, reason => resultCallback({
+            code: core_1.ExportResultCode.FAILED,
+            error: reason,
+        })));
+    }
+    forceFlush() {
+        return this._promiseQueue.awaitAll();
+    }
+    async shutdown() {
+        this._diagLogger.debug('shutdown started');
+        await this.forceFlush();
+        this._transport.shutdown();
+    }
+}
+/**
+ * Creates a generic delegate for OTLP exports which only contains parts of the OTLP export that are shared across all
+ * signals.
+ */
+function createOtlpExportDelegate(components, settings) {
+    return new OTLPExportDelegate(components.transport, components.serializer, (0, logging_response_handler_1.createLoggingPartialSuccessResponseHandler)(), components.promiseHandler, settings.timeout);
+}
+exports.createOtlpExportDelegate = createOtlpExportDelegate;
+//# sourceMappingURL=otlp-export-delegate.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-http-export-delegate.d.ts

@@ -0,0 +1,5 @@
+import { IOtlpExportDelegate } from './otlp-export-delegate';
+import { OtlpHttpConfiguration } from './configuration/otlp-http-configuration';
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+export declare function createOtlpHttpExportDelegate<Internal, Response>(options: OtlpHttpConfiguration, serializer: ISerializer<Internal, Response>): IOtlpExportDelegate<Internal>;
+//# sourceMappingURL=otlp-http-export-delegate.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-http-export-delegate.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtlpHttpExportDelegate = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const otlp_export_delegate_1 = require("./otlp-export-delegate");
+const http_exporter_transport_1 = require("./transport/http-exporter-transport");
+const bounded_queue_export_promise_handler_1 = require("./bounded-queue-export-promise-handler");
+const retrying_transport_1 = require("./retrying-transport");
+function createOtlpHttpExportDelegate(options, serializer) {
+    return (0, otlp_export_delegate_1.createOtlpExportDelegate)({
+        transport: (0, retrying_transport_1.createRetryingTransport)({
+            transport: (0, http_exporter_transport_1.createHttpExporterTransport)(options),
+        }),
+        serializer: serializer,
+        promiseHandler: (0, bounded_queue_export_promise_handler_1.createBoundedQueueExportPromiseHandler)(options),
+    }, { timeout: options.timeoutMillis });
+}
+exports.createOtlpHttpExportDelegate = createOtlpHttpExportDelegate;
+//# sourceMappingURL=otlp-http-export-delegate.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-http-export-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-http-export-delegate.js","sourceRoot":"","sources":["../../src/otlp-http-export-delegate.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAGgC;AAGhC,iFAAkF;AAClF,iGAAgG;AAChG,6DAA+D;AAE/D,SAAgB,4BAA4B,CAC1C,OAA8B,EAC9B,UAA2C;IAE3C,OAAO,IAAA,+CAAwB,EAC7B;QACE,SAAS,EAAE,IAAA,4CAAuB,EAAC;YACjC,SAAS,EAAE,IAAA,qDAA2B,EAAC,OAAO,CAAC;SAChD,CAAC;QACF,UAAU,EAAE,UAAU;QACtB,cAAc,EAAE,IAAA,6EAAsC,EAAC,OAAO,CAAC;KAChE,EACD,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,CACnC,CAAC;AACJ,CAAC;AAdD,oEAcC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  createOtlpExportDelegate,\n  IOtlpExportDelegate,\n} from './otlp-export-delegate';\nimport { OtlpHttpConfiguration } from './configuration/otlp-http-configuration';\nimport { ISerializer } from '@opentelemetry/otlp-transformer';\nimport { createHttpExporterTransport } from './transport/http-exporter-transport';\nimport { createBoundedQueueExportPromiseHandler } from './bounded-queue-export-promise-handler';\nimport { createRetryingTransport } from './retrying-transport';\n\nexport function createOtlpHttpExportDelegate<Internal, Response>(\n  options: OtlpHttpConfiguration,\n  serializer: ISerializer<Internal, Response>\n): IOtlpExportDelegate<Internal> {\n  return createOtlpExportDelegate(\n    {\n      transport: createRetryingTransport({\n        transport: createHttpExporterTransport(options),\n      }),\n      serializer: serializer,\n      promiseHandler: createBoundedQueueExportPromiseHandler(options),\n    },\n    { timeout: options.timeoutMillis }\n  );\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-network-export-delegate.d.ts

@@ -0,0 +1,6 @@
+import { OtlpSharedConfiguration } from './configuration/shared-configuration';
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+import { IExporterTransport } from './exporter-transport';
+import { IOtlpExportDelegate } from './otlp-export-delegate';
+export declare function createOtlpNetworkExportDelegate<Internal, Response>(options: OtlpSharedConfiguration, serializer: ISerializer<Internal, Response>, transport: IExporterTransport): IOtlpExportDelegate<Internal>;
+//# sourceMappingURL=otlp-network-export-delegate.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-network-export-delegate.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtlpNetworkExportDelegate = void 0;
+const bounded_queue_export_promise_handler_1 = require("./bounded-queue-export-promise-handler");
+const otlp_export_delegate_1 = require("./otlp-export-delegate");
+function createOtlpNetworkExportDelegate(options, serializer, transport) {
+    return (0, otlp_export_delegate_1.createOtlpExportDelegate)({
+        transport: transport,
+        serializer,
+        promiseHandler: (0, bounded_queue_export_promise_handler_1.createBoundedQueueExportPromiseHandler)(options),
+    }, { timeout: options.timeoutMillis });
+}
+exports.createOtlpNetworkExportDelegate = createOtlpNetworkExportDelegate;
+//# sourceMappingURL=otlp-network-export-delegate.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/otlp-network-export-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-network-export-delegate.js","sourceRoot":"","sources":["../../src/otlp-network-export-delegate.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,iGAAgG;AAIhG,iEAGgC;AAEhC,SAAgB,+BAA+B,CAC7C,OAAgC,EAChC,UAA2C,EAC3C,SAA6B;IAE7B,OAAO,IAAA,+CAAwB,EAC7B;QACE,SAAS,EAAE,SAAS;QACpB,UAAU;QACV,cAAc,EAAE,IAAA,6EAAsC,EAAC,OAAO,CAAC;KAChE,EACD,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,CACnC,CAAC;AACJ,CAAC;AAbD,0EAaC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { createBoundedQueueExportPromiseHandler } from './bounded-queue-export-promise-handler';\nimport { OtlpSharedConfiguration } from './configuration/shared-configuration';\nimport { ISerializer } from '@opentelemetry/otlp-transformer';\nimport { IExporterTransport } from './exporter-transport';\nimport {\n  createOtlpExportDelegate,\n  IOtlpExportDelegate,\n} from './otlp-export-delegate';\n\nexport function createOtlpNetworkExportDelegate<Internal, Response>(\n  options: OtlpSharedConfiguration,\n  serializer: ISerializer<Internal, Response>,\n  transport: IExporterTransport\n): IOtlpExportDelegate<Internal> {\n  return createOtlpExportDelegate(\n    {\n      transport: transport,\n      serializer,\n      promiseHandler: createBoundedQueueExportPromiseHandler(options),\n    },\n    { timeout: options.timeoutMillis }\n  );\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/response-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generic export response handler. Can be implemented to handle export responses like partial success.
+ */
+export interface IOtlpResponseHandler<Response> {
+    /**
+     * Handles an OTLP export response.
+     * Implementations MUST NOT throw.
+     * @param response
+     */
+    handleResponse(response: Response): void;
+}
+//# sourceMappingURL=response-handler.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/response-handler.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=response-handler.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/response-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-handler.js","sourceRoot":"","sources":["../../src/response-handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Generic export response handler. Can be implemented to handle export responses like partial success.\n */\nexport interface IOtlpResponseHandler<Response> {\n  /**\n   * Handles an OTLP export response.\n   * Implementations MUST NOT throw.\n   * @param response\n   */\n  handleResponse(response: Response): void;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/retrying-transport.d.ts

@@ -0,0 +1,8 @@
+import { IExporterTransport } from './exporter-transport';
+/**
+ * Creates an Exporter Transport that retries on 'retryable' response.
+ */
+export declare function createRetryingTransport(options: {
+    transport: IExporterTransport;
+}): IExporterTransport;
+//# sourceMappingURL=retrying-transport.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/retrying-transport.js

@@ -0,0 +1,73 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRetryingTransport = void 0;
+const MAX_ATTEMPTS = 5;
+const INITIAL_BACKOFF = 1000;
+const MAX_BACKOFF = 5000;
+const BACKOFF_MULTIPLIER = 1.5;
+const JITTER = 0.2;
+/**
+ * Get a pseudo-random jitter that falls in the range of [-JITTER, +JITTER]
+ */
+function getJitter() {
+    return Math.random() * (2 * JITTER) - JITTER;
+}
+class RetryingTransport {
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    retry(data, timeoutMillis, inMillis) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                this._transport.send(data, timeoutMillis).then(resolve, reject);
+            }, inMillis);
+        });
+    }
+    async send(data, timeoutMillis) {
+        var _a;
+        const deadline = Date.now() + timeoutMillis;
+        let result = await this._transport.send(data, timeoutMillis);
+        let attempts = MAX_ATTEMPTS;
+        let nextBackoff = INITIAL_BACKOFF;
+        while (result.status === 'retryable' && attempts > 0) {
+            attempts--;
+            // use maximum of computed backoff and 0 to avoid negative timeouts
+            const backoff = Math.max(Math.min(nextBackoff, MAX_BACKOFF) + getJitter(), 0);
+            nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
+            const retryInMillis = (_a = result.retryInMillis) !== null && _a !== void 0 ? _a : backoff;
+            // return when expected retry time is after the export deadline.
+            const remainingTimeoutMillis = deadline - Date.now();
+            if (retryInMillis > remainingTimeoutMillis) {
+                return result;
+            }
+            result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
+        }
+        return result;
+    }
+    shutdown() {
+        return this._transport.shutdown();
+    }
+}
+/**
+ * Creates an Exporter Transport that retries on 'retryable' response.
+ */
+function createRetryingTransport(options) {
+    return new RetryingTransport(options.transport);
+}
+exports.createRetryingTransport = createRetryingTransport;
+//# sourceMappingURL=retrying-transport.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/retrying-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrying-transport.js","sourceRoot":"","sources":["../../src/retrying-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAKH,MAAM,YAAY,GAAG,CAAC,CAAC;AACvB,MAAM,eAAe,GAAG,IAAI,CAAC;AAC7B,MAAM,WAAW,GAAG,IAAI,CAAC;AACzB,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAC/B,MAAM,MAAM,GAAG,GAAG,CAAC;AAEnB;;GAEG;AACH,SAAS,SAAS;IAChB,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC;AAC/C,CAAC;AAED,MAAM,iBAAiB;IACrB,YAAoB,UAA8B;QAA9B,eAAU,GAAV,UAAU,CAAoB;IAAG,CAAC;IAE9C,KAAK,CACX,IAAgB,EAChB,aAAqB,EACrB,QAAgB;QAEhB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAClE,CAAC,EAAE,QAAQ,CAAC,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAgB,EAAE,aAAqB;;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,CAAC;QAC5C,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAC7D,IAAI,QAAQ,GAAG,YAAY,CAAC;QAC5B,IAAI,WAAW,GAAG,eAAe,CAAC;QAElC,OAAO,MAAM,CAAC,MAAM,KAAK,WAAW,IAAI,QAAQ,GAAG,CAAC,EAAE;YACpD,QAAQ,EAAE,CAAC;YAEX,mEAAmE;YACnE,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACtB,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG,SAAS,EAAE,EAChD,CAAC,CACF,CAAC;YACF,WAAW,GAAG,WAAW,GAAG,kBAAkB,CAAC;YAC/C,MAAM,aAAa,GAAG,MAAA,MAAM,CAAC,aAAa,mCAAI,OAAO,CAAC;YAEtD,gEAAgE;YAChE,MAAM,sBAAsB,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACrD,IAAI,aAAa,GAAG,sBAAsB,EAAE;gBAC1C,OAAO,MAAM,CAAC;aACf;YAED,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,sBAAsB,EAAE,aAAa,CAAC,CAAC;SACxE;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IACpC,CAAC;CACF;AAED;;GAEG;AACH,SAAgB,uBAAuB,CAAC,OAGvC;IACC,OAAO,IAAI,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAClD,CAAC;AALD,0DAKC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IExporterTransport } from './exporter-transport';\nimport { ExportResponse } from './export-response';\n\nconst MAX_ATTEMPTS = 5;\nconst INITIAL_BACKOFF = 1000;\nconst MAX_BACKOFF = 5000;\nconst BACKOFF_MULTIPLIER = 1.5;\nconst JITTER = 0.2;\n\n/**\n * Get a pseudo-random jitter that falls in the range of [-JITTER, +JITTER]\n */\nfunction getJitter() {\n  return Math.random() * (2 * JITTER) - JITTER;\n}\n\nclass RetryingTransport implements IExporterTransport {\n  constructor(private _transport: IExporterTransport) {}\n\n  private retry(\n    data: Uint8Array,\n    timeoutMillis: number,\n    inMillis: number\n  ): Promise<ExportResponse> {\n    return new Promise((resolve, reject) => {\n      setTimeout(() => {\n        this._transport.send(data, timeoutMillis).then(resolve, reject);\n      }, inMillis);\n    });\n  }\n\n  async send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse> {\n    const deadline = Date.now() + timeoutMillis;\n    let result = await this._transport.send(data, timeoutMillis);\n    let attempts = MAX_ATTEMPTS;\n    let nextBackoff = INITIAL_BACKOFF;\n\n    while (result.status === 'retryable' && attempts > 0) {\n      attempts--;\n\n      // use maximum of computed backoff and 0 to avoid negative timeouts\n      const backoff = Math.max(\n        Math.min(nextBackoff, MAX_BACKOFF) + getJitter(),\n        0\n      );\n      nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;\n      const retryInMillis = result.retryInMillis ?? backoff;\n\n      // return when expected retry time is after the export deadline.\n      const remainingTimeoutMillis = deadline - Date.now();\n      if (retryInMillis > remainingTimeoutMillis) {\n        return result;\n      }\n\n      result = await this.retry(data, remainingTimeoutMillis, retryInMillis);\n    }\n\n    return result;\n  }\n\n  shutdown() {\n    return this._transport.shutdown();\n  }\n}\n\n/**\n * Creates an Exporter Transport that retries on 'retryable' response.\n */\nexport function createRetryingTransport(options: {\n  // Underlying transport to wrap.\n  transport: IExporterTransport;\n}): IExporterTransport {\n  return new RetryingTransport(options.transport);\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-exporter-transport.d.ts

@@ -0,0 +1,4 @@
+import type { HttpRequestParameters } from './http-transport-types';
+import { IExporterTransport } from '../exporter-transport';
+export declare function createHttpExporterTransport(parameters: HttpRequestParameters): IExporterTransport;
+//# sourceMappingURL=http-exporter-transport.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-exporter-transport.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpExporterTransport = void 0;
+class HttpExporterTransport {
+    constructor(_parameters) {
+        this._parameters = _parameters;
+        this._send = null;
+        this._agent = null;
+    }
+    async send(data, timeoutMillis) {
+        if (this._send == null) {
+            // Lazy require to ensure that http/https is not required before instrumentations can wrap it.
+            const { sendWithHttp, createHttpAgent,
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+             } = require('./http-transport-utils');
+            this._agent = createHttpAgent(this._parameters.url, this._parameters.agentOptions);
+            this._send = sendWithHttp;
+        }
+        return new Promise(resolve => {
+            var _a;
+            // this will always be defined
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            (_a = this._send) === null || _a === void 0 ? void 0 : _a.call(this, this._parameters, this._agent, data, result => {
+                resolve(result);
+            }, timeoutMillis);
+        });
+    }
+    shutdown() {
+        // intentionally left empty, nothing to do.
+    }
+}
+function createHttpExporterTransport(parameters) {
+    return new HttpExporterTransport(parameters);
+}
+exports.createHttpExporterTransport = createHttpExporterTransport;
+//# sourceMappingURL=http-exporter-transport.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-exporter-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-exporter-transport.js","sourceRoot":"","sources":["../../../src/transport/http-exporter-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAcH,MAAM,qBAAqB;IAIzB,YAAoB,WAAkC;QAAlC,gBAAW,GAAX,WAAW,CAAuB;QAH9C,UAAK,GAAwB,IAAI,CAAC;QAClC,WAAM,GAAoC,IAAI,CAAC;IAEE,CAAC;IAE1D,KAAK,CAAC,IAAI,CAAC,IAAgB,EAAE,aAAqB;QAChD,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE;YACtB,8FAA8F;YAC9F,MAAM,EACJ,YAAY,EACZ,eAAe;YACf,8DAA8D;cAC/D,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;YACtC,IAAI,CAAC,MAAM,GAAG,eAAe,CAC3B,IAAI,CAAC,WAAW,CAAC,GAAG,EACpB,IAAI,CAAC,WAAW,CAAC,YAAY,CAC9B,CAAC;YACF,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;SAC3B;QAED,OAAO,IAAI,OAAO,CAAiB,OAAO,CAAC,EAAE;;YAC3C,8BAA8B;YAC9B,oEAAoE;YACpE,MAAA,IAAI,CAAC,KAAK,+CAAV,IAAI,EACF,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,MAAO,EACZ,IAAI,EACJ,MAAM,CAAC,EAAE;gBACP,OAAO,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC,EACD,aAAa,CACd,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IACD,QAAQ;QACN,2CAA2C;IAC7C,CAAC;CACF;AAED,SAAgB,2BAA2B,CACzC,UAAiC;IAEjC,OAAO,IAAI,qBAAqB,CAAC,UAAU,CAAC,CAAC;AAC/C,CAAC;AAJD,kEAIC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type {\n  HttpRequestParameters,\n  sendWithHttp,\n} from './http-transport-types';\n\n// NOTE: do not change these type imports to actual imports. Doing so WILL break `@opentelemetry/instrumentation-http`,\n// as they'd be imported before the http/https modules can be wrapped.\nimport type * as https from 'https';\nimport type * as http from 'http';\nimport { ExportResponse } from '../export-response';\nimport { IExporterTransport } from '../exporter-transport';\n\nclass HttpExporterTransport implements IExporterTransport {\n  private _send: sendWithHttp | null = null;\n  private _agent: http.Agent | https.Agent | null = null;\n\n  constructor(private _parameters: HttpRequestParameters) {}\n\n  async send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse> {\n    if (this._send == null) {\n      // Lazy require to ensure that http/https is not required before instrumentations can wrap it.\n      const {\n        sendWithHttp,\n        createHttpAgent,\n        // eslint-disable-next-line @typescript-eslint/no-var-requires\n      } = require('./http-transport-utils');\n      this._agent = createHttpAgent(\n        this._parameters.url,\n        this._parameters.agentOptions\n      );\n      this._send = sendWithHttp;\n    }\n\n    return new Promise<ExportResponse>(resolve => {\n      // this will always be defined\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      this._send?.(\n        this._parameters,\n        this._agent!,\n        data,\n        result => {\n          resolve(result);\n        },\n        timeoutMillis\n      );\n    });\n  }\n  shutdown() {\n    // intentionally left empty, nothing to do.\n  }\n}\n\nexport function createHttpExporterTransport(\n  parameters: HttpRequestParameters\n): IExporterTransport {\n  return new HttpExporterTransport(parameters);\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-transport-types.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import type * as http from 'http';
+import type * as https from 'https';
+import { ExportResponse } from '../export-response';
+export declare type sendWithHttp = (params: HttpRequestParameters, agent: http.Agent | https.Agent, data: Uint8Array, onDone: (response: ExportResponse) => void, timeoutMillis: number) => void;
+export interface HttpRequestParameters {
+    url: string;
+    headers: () => Record<string, string>;
+    compression: 'gzip' | 'none';
+    agentOptions: http.AgentOptions | https.AgentOptions;
+}
+//# sourceMappingURL=http-transport-types.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-transport-types.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=http-transport-types.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-transport-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport-types.js","sourceRoot":"","sources":["../../../src/transport/http-transport-types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type * as http from 'http';\nimport type * as https from 'https';\nimport { ExportResponse } from '../export-response';\n\nexport type sendWithHttp = (\n  params: HttpRequestParameters,\n  agent: http.Agent | https.Agent,\n  data: Uint8Array,\n  onDone: (response: ExportResponse) => void,\n  timeoutMillis: number\n) => void;\n\nexport interface HttpRequestParameters {\n  url: string;\n  headers: () => Record<string, string>;\n  compression: 'gzip' | 'none';\n  agentOptions: http.AgentOptions | https.AgentOptions;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-transport-utils.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import * as http from 'http';
+import * as https from 'https';
+import { HttpRequestParameters } from './http-transport-types';
+import { ExportResponse } from '../export-response';
+/**
+ * Sends data using http
+ * @param params
+ * @param agent
+ * @param data
+ * @param onDone
+ * @param timeoutMillis
+ */
+export declare function sendWithHttp(params: HttpRequestParameters, agent: http.Agent | https.Agent, data: Uint8Array, onDone: (response: ExportResponse) => void, timeoutMillis: number): void;
+export declare function compressAndSend(req: http.ClientRequest, compression: 'gzip' | 'none', data: Uint8Array, onError: (error: Error) => void): void;
+export declare function createHttpAgent(rawUrl: string, agentOptions: http.AgentOptions | https.AgentOptions): http.Agent;
+//# sourceMappingURL=http-transport-utils.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/http-transport-utils.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpAgent = exports.compressAndSend = exports.sendWithHttp = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const http = require("http");
+const https = require("https");
+const zlib = require("zlib");
+const stream_1 = require("stream");
+const is_export_retryable_1 = require("../is-export-retryable");
+const types_1 = require("../types");
+/**
+ * Sends data using http
+ * @param params
+ * @param agent
+ * @param data
+ * @param onDone
+ * @param timeoutMillis
+ */
+function sendWithHttp(params, agent, data, onDone, timeoutMillis) {
+    const parsedUrl = new URL(params.url);
+    const nodeVersion = Number(process.versions.node.split('.')[0]);
+    const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.pathname,
+        method: 'POST',
+        headers: Object.assign({}, params.headers()),
+        agent: agent,
+    };
+    const request = parsedUrl.protocol === 'http:' ? http.request : https.request;
+    const req = request(options, (res) => {
+        const responseData = [];
+        res.on('data', chunk => responseData.push(chunk));
+        res.on('end', () => {
+            if (res.statusCode && res.statusCode < 299) {
+                onDone({
+                    status: 'success',
+                    data: Buffer.concat(responseData),
+                });
+            }
+            else if (res.statusCode && (0, is_export_retryable_1.isExportRetryable)(res.statusCode)) {
+                onDone({
+                    status: 'retryable',
+                    retryInMillis: (0, is_export_retryable_1.parseRetryAfterToMills)(res.headers['retry-after']),
+                });
+            }
+            else {
+                const error = new types_1.OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
+                onDone({
+                    status: 'failure',
+                    error,
+                });
+            }
+        });
+    });
+    req.setTimeout(timeoutMillis, () => {
+        req.destroy();
+        onDone({
+            status: 'failure',
+            error: new Error('Request Timeout'),
+        });
+    });
+    req.on('error', (error) => {
+        onDone({
+            status: 'failure',
+            error: error,
+        });
+    });
+    const reportTimeoutErrorEvent = nodeVersion >= 14 ? 'close' : 'abort';
+    req.on(reportTimeoutErrorEvent, () => {
+        onDone({
+            status: 'failure',
+            error: new Error('Request timed out'),
+        });
+    });
+    compressAndSend(req, params.compression, data, (error) => {
+        onDone({
+            status: 'failure',
+            error,
+        });
+    });
+}
+exports.sendWithHttp = sendWithHttp;
+function compressAndSend(req, compression, data, onError) {
+    let dataStream = readableFromUint8Array(data);
+    if (compression === 'gzip') {
+        req.setHeader('Content-Encoding', 'gzip');
+        dataStream = dataStream
+            .on('error', onError)
+            .pipe(zlib.createGzip())
+            .on('error', onError);
+    }
+    dataStream.pipe(req).on('error', onError);
+}
+exports.compressAndSend = compressAndSend;
+function readableFromUint8Array(buff) {
+    const readable = new stream_1.Readable();
+    readable.push(buff);
+    readable.push(null);
+    return readable;
+}
+function createHttpAgent(rawUrl, agentOptions) {
+    const parsedUrl = new URL(rawUrl);
+    const Agent = parsedUrl.protocol === 'http:' ? http.Agent : https.Agent;
+    return new Agent(agentOptions);
+}
+exports.createHttpAgent = createHttpAgent;
+//# sourceMappingURL=http-transport-utils.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/send-beacon-transport.d.ts

@@ -0,0 +1,10 @@
+import { IExporterTransport } from '../exporter-transport';
+export interface SendBeaconParameters {
+    url: string;
+    /**
+     * for instance 'application/x-protobuf'
+     */
+    blobType: string;
+}
+export declare function createSendBeaconTransport(parameters: SendBeaconParameters): IExporterTransport;
+//# sourceMappingURL=send-beacon-transport.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/send-beacon-transport.js

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSendBeaconTransport = void 0;
+const api_1 = require("@opentelemetry/api");
+class SendBeaconTransport {
+    constructor(_params) {
+        this._params = _params;
+    }
+    send(data) {
+        return new Promise(resolve => {
+            if (navigator.sendBeacon(this._params.url, new Blob([data], { type: this._params.blobType }))) {
+                // no way to signal retry, treat everything as success
+                api_1.diag.debug('SendBeacon success');
+                resolve({
+                    status: 'success',
+                });
+            }
+            else {
+                resolve({
+                    status: 'failure',
+                    error: new Error('SendBeacon failed'),
+                });
+            }
+        });
+    }
+    shutdown() {
+        // Intentionally left empty, nothing to do.
+    }
+}
+function createSendBeaconTransport(parameters) {
+    return new SendBeaconTransport(parameters);
+}
+exports.createSendBeaconTransport = createSendBeaconTransport;
+//# sourceMappingURL=send-beacon-transport.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/send-beacon-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-beacon-transport.js","sourceRoot":"","sources":["../../../src/transport/send-beacon-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAIH,4CAA0C;AAU1C,MAAM,mBAAmB;IACvB,YAAoB,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAG,CAAC;IACrD,IAAI,CAAC,IAAgB;QACnB,OAAO,IAAI,OAAO,CAAiB,OAAO,CAAC,EAAE;YAC3C,IACE,SAAS,CAAC,UAAU,CAClB,IAAI,CAAC,OAAO,CAAC,GAAG,EAChB,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAClD,EACD;gBACA,sDAAsD;gBACtD,UAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;gBACjC,OAAO,CAAC;oBACN,MAAM,EAAE,SAAS;iBAClB,CAAC,CAAC;aACJ;iBAAM;gBACL,OAAO,CAAC;oBACN,MAAM,EAAE,SAAS;oBACjB,KAAK,EAAE,IAAI,KAAK,CAAC,mBAAmB,CAAC;iBACtC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,2CAA2C;IAC7C,CAAC;CACF;AAED,SAAgB,yBAAyB,CACvC,UAAgC;IAEhC,OAAO,IAAI,mBAAmB,CAAC,UAAU,CAAC,CAAC;AAC7C,CAAC;AAJD,8DAIC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IExporterTransport } from '../exporter-transport';\nimport { ExportResponse } from '../export-response';\nimport { diag } from '@opentelemetry/api';\n\nexport interface SendBeaconParameters {\n  url: string;\n  /**\n   * for instance 'application/x-protobuf'\n   */\n  blobType: string;\n}\n\nclass SendBeaconTransport implements IExporterTransport {\n  constructor(private _params: SendBeaconParameters) {}\n  send(data: Uint8Array): Promise<ExportResponse> {\n    return new Promise<ExportResponse>(resolve => {\n      if (\n        navigator.sendBeacon(\n          this._params.url,\n          new Blob([data], { type: this._params.blobType })\n        )\n      ) {\n        // no way to signal retry, treat everything as success\n        diag.debug('SendBeacon success');\n        resolve({\n          status: 'success',\n        });\n      } else {\n        resolve({\n          status: 'failure',\n          error: new Error('SendBeacon failed'),\n        });\n      }\n    });\n  }\n\n  shutdown(): void {\n    // Intentionally left empty, nothing to do.\n  }\n}\n\nexport function createSendBeaconTransport(\n  parameters: SendBeaconParameters\n): IExporterTransport {\n  return new SendBeaconTransport(parameters);\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/xhr-transport.d.ts

@@ -0,0 +1,11 @@
+import { IExporterTransport } from '../exporter-transport';
+export interface XhrRequestParameters {
+    url: string;
+    headers: () => Record<string, string>;
+}
+/**
+ * Creates an exporter transport that uses XHR to send the data
+ * @param parameters applied to each request made by transport
+ */
+export declare function createXhrTransport(parameters: XhrRequestParameters): IExporterTransport;
+//# sourceMappingURL=xhr-transport.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/transport/xhr-transport.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXhrTransport = void 0;
+const api_1 = require("@opentelemetry/api");
+const is_export_retryable_1 = require("../is-export-retryable");
+class XhrTransport {
+    constructor(_parameters) {
+        this._parameters = _parameters;
+    }
+    send(data, timeoutMillis) {
+        return new Promise(resolve => {
+            const xhr = new XMLHttpRequest();
+            xhr.timeout = timeoutMillis;
+            xhr.open('POST', this._parameters.url);
+            const headers = this._parameters.headers();
+            Object.entries(headers).forEach(([k, v]) => {
+                xhr.setRequestHeader(k, v);
+            });
+            xhr.ontimeout = _ => {
+                resolve({
+                    status: 'failure',
+                    error: new Error('XHR request timed out'),
+                });
+            };
+            xhr.onreadystatechange = () => {
+                if (xhr.status >= 200 && xhr.status <= 299) {
+                    api_1.diag.debug('XHR success');
+                    resolve({
+                        status: 'success',
+                    });
+                }
+                else if (xhr.status && (0, is_export_retryable_1.isExportRetryable)(xhr.status)) {
+                    resolve({
+                        status: 'retryable',
+                        retryInMillis: (0, is_export_retryable_1.parseRetryAfterToMills)(xhr.getResponseHeader('Retry-After')),
+                    });
+                }
+                else if (xhr.status !== 0) {
+                    resolve({
+                        status: 'failure',
+                        error: new Error('XHR request failed with non-retryable status'),
+                    });
+                }
+            };
+            xhr.onabort = () => {
+                resolve({
+                    status: 'failure',
+                    error: new Error('XHR request aborted'),
+                });
+            };
+            xhr.onerror = () => {
+                resolve({
+                    status: 'failure',
+                    error: new Error('XHR request errored'),
+                });
+            };
+            xhr.send(data);
+        });
+    }
+    shutdown() {
+        // Intentionally left empty, nothing to do.
+    }
+}
+/**
+ * Creates an exporter transport that uses XHR to send the data
+ * @param parameters applied to each request made by transport
+ */
+function createXhrTransport(parameters) {
+    return new XhrTransport(parameters);
+}
+exports.createXhrTransport = createXhrTransport;
+//# sourceMappingURL=xhr-transport.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Interface for handling error
+ */
+export declare class OTLPExporterError extends Error {
+    readonly code?: number;
+    readonly name: string;
+    readonly data?: string;
+    constructor(message?: string, code?: number, data?: string);
+}
+/**
+ * Interface for handling export service errors
+ */
+export interface ExportServiceError {
+    name: string;
+    code: number;
+    details: string;
+    metadata: {
+        [key: string]: unknown;
+    };
+    message: string;
+    stack: string;
+}
+//# sourceMappingURL=types.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/types.js

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTLPExporterError = void 0;
+/**
+ * Interface for handling error
+ */
+class OTLPExporterError extends Error {
+    constructor(message, code, data) {
+        super(message);
+        this.name = 'OTLPExporterError';
+        this.data = data;
+        this.code = code;
+    }
+}
+exports.OTLPExporterError = OTLPExporterError;
+//# sourceMappingURL=types.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH;;GAEG;AACH,MAAa,iBAAkB,SAAQ,KAAK;IAK1C,YAAY,OAAgB,EAAE,IAAa,EAAE,IAAa;QACxD,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,SAAI,GAAW,mBAAmB,CAAC;QAKnD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAVD,8CAUC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Interface for handling error\n */\nexport class OTLPExporterError extends Error {\n  readonly code?: number;\n  override readonly name: string = 'OTLPExporterError';\n  readonly data?: string;\n\n  constructor(message?: string, code?: number, data?: string) {\n    super(message);\n    this.data = data;\n    this.code = code;\n  }\n}\n\n/**\n * Interface for handling export service errors\n */\nexport interface ExportServiceError {\n  name: string;\n  code: number;\n  details: string;\n  metadata: { [key: string]: unknown };\n  message: string;\n  stack: string;\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parses headers from config leaving only those that have defined values
+ * @param partialHeaders
+ */
+export declare function validateAndNormalizeHeaders(partialHeaders: (() => Record<string, string>) | undefined): () => Record<string, string>;
+//# sourceMappingURL=util.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/util.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndNormalizeHeaders = void 0;
+const api_1 = require("@opentelemetry/api");
+/**
+ * Parses headers from config leaving only those that have defined values
+ * @param partialHeaders
+ */
+function validateAndNormalizeHeaders(partialHeaders) {
+    return () => {
+        var _a;
+        const headers = {};
+        Object.entries((_a = partialHeaders === null || partialHeaders === void 0 ? void 0 : partialHeaders()) !== null && _a !== void 0 ? _a : {}).forEach(([key, value]) => {
+            if (typeof value !== 'undefined') {
+                headers[key] = String(value);
+            }
+            else {
+                api_1.diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
+            }
+        });
+        return headers;
+    };
+}
+exports.validateAndNormalizeHeaders = validateAndNormalizeHeaders;
+//# sourceMappingURL=util.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,4CAA0C;AAE1C;;;GAGG;AACH,SAAgB,2BAA2B,CACzC,cAA0D;IAE1D,OAAO,GAAG,EAAE;;QACV,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,MAAM,CAAC,OAAO,CAAC,MAAA,cAAc,aAAd,cAAc,uBAAd,cAAc,EAAI,mCAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAChE,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE;gBAChC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;aAC9B;iBAAM;gBACL,UAAI,CAAC,IAAI,CACP,WAAW,GAAG,wBAAwB,KAAK,uBAAuB,CACnE,CAAC;aACH;QACH,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;AACJ,CAAC;AAhBD,kEAgBC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { diag } from '@opentelemetry/api';\n\n/**\n * Parses headers from config leaving only those that have defined values\n * @param partialHeaders\n */\nexport function validateAndNormalizeHeaders(\n  partialHeaders: (() => Record<string, string>) | undefined\n): () => Record<string, string> {\n  return () => {\n    const headers: Record<string, string> = {};\n    Object.entries(partialHeaders?.() ?? {}).forEach(([key, value]) => {\n      if (typeof value !== 'undefined') {\n        headers[key] = String(value);\n      } else {\n        diag.warn(\n          `Header \"${key}\" has invalid value (${value}) and will be ignored`\n        );\n      }\n    });\n    return headers;\n  };\n}\n"]}

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.57.2";
+//# sourceMappingURL=version.d.ts.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/version.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// this is autogenerated file, see scripts/version-update.js
+exports.VERSION = '0.57.2';
+//# sourceMappingURL=version.js.map

~/.npm-cache/@opentelemetry/otlp-exporter-base@0.57.2@@@1/build/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,4DAA4D;AAC/C,QAAA,OAAO,GAAG,QAAQ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// this is autogenerated file, see scripts/version-update.js\nexport const VERSION = '0.57.2';\n"]}