@safaricom-mxl/web-sdk 0.0.16 → 0.0.18

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.cjs

@@ -0,0 +1,170 @@
+"use strict";
+//#region ../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.js
+var require_common_serializer = /* @__PURE__ */ require("../../../../../../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.writeResource = exports.writeInstrumentationScope = exports.writeAnyValue = exports.writeKeyValue = exports.writeAttributes = exports.writeHrTimeAsFixed64 = void 0;
+	/**
+	* Write HrTime [seconds, nanoseconds] directly as fixed64 to the serializer.
+	* Converts to nanoseconds and writes as 64-bit little-endian integer without allocations.
+	*
+	* HrTime represents: total_nanos = seconds * 1_000_000_000 + nanoseconds
+	* We need to split this into low (bits 0-31) and high (bits 32-63).
+	*
+	* @param serializer - The protobuf writer
+	* @param hrTime - HrTime tuple [seconds, nanoseconds]
+	*/
+	function writeHrTimeAsFixed64(serializer, hrTime) {
+		const seconds = hrTime[0];
+		const nanos = hrTime[1];
+		const nanosPerSecond = 1e9;
+		const secondsLower16Bits = seconds & 65535;
+		const secondsUpperBits = seconds / 65536 >>> 0;
+		const nanosFromLower16Bits = secondsLower16Bits * nanosPerSecond;
+		const nanosFromUpperBits = secondsUpperBits * nanosPerSecond;
+		const lower16ContributionLow32 = nanosFromLower16Bits >>> 0;
+		const lower16ContributionHigh32 = Math.floor(nanosFromLower16Bits / 4294967296);
+		const upperBitsContributionLow32 = (nanosFromUpperBits & 65535) * 65536 >>> 0;
+		const upperBitsContributionHigh32 = nanosFromUpperBits / 65536 >>> 0;
+		const low32WithCarry = lower16ContributionLow32 + upperBitsContributionLow32 + nanos;
+		const totalLow = low32WithCarry >>> 0;
+		const carry = Math.floor(low32WithCarry / 4294967296);
+		const totalHigh = lower16ContributionHigh32 + upperBitsContributionHigh32 + carry >>> 0;
+		serializer.writeFixed64(totalLow, totalHigh);
+	}
+	exports.writeHrTimeAsFixed64 = writeHrTimeAsFixed64;
+	/**
+	* Write Attributes directly to protobuf as repeated KeyValue
+	*/
+	function writeAttributes(writer, attributes, fieldNumber) {
+		for (const key in attributes) {
+			if (!Object.prototype.hasOwnProperty.call(attributes, key)) continue;
+			const value = attributes[key];
+			writer.writeTag(fieldNumber, 2);
+			const kvStart = writer.startLengthDelimited();
+			const startPos = writer.pos;
+			writeKeyValue(writer, key, value);
+			writer.finishLengthDelimited(kvStart, writer.pos - startPos);
+		}
+	}
+	exports.writeAttributes = writeAttributes;
+	/**
+	* Write a KeyValue pair directly to protobuf
+	*/
+	function writeKeyValue(writer, key, value) {
+		writer.writeTag(1, 2);
+		writer.writeString(key);
+		writer.writeTag(2, 2);
+		const valueStart = writer.startLengthDelimited();
+		const startPos = writer.pos;
+		writeAnyValue(writer, value);
+		writer.finishLengthDelimited(valueStart, writer.pos - startPos);
+	}
+	exports.writeKeyValue = writeKeyValue;
+	const MIN_64_BIT_INT = -(2 ** 63);
+	const MAX_64_BIT_INT = 2 ** 63;
+	/**
+	* Write an AnyValue directly from raw attribute value to protobuf
+	*/
+	function writeAnyValue(writer, value) {
+		const t = typeof value;
+		if (t === "string") {
+			writer.writeTag(1, 2);
+			writer.writeString(value);
+		} else if (t === "boolean") {
+			writer.writeTag(2, 0);
+			writer.writeVarint(value ? 1 : 0);
+		} else if (t === "number") {
+			const numValue = value;
+			if (Number.isInteger(numValue) && numValue >= MIN_64_BIT_INT && numValue < MAX_64_BIT_INT) {
+				writer.writeTag(3, 0);
+				writer.writeVarint(numValue);
+			} else {
+				writer.writeTag(4, 1);
+				writer.writeDouble(numValue);
+			}
+		} else if (value instanceof Uint8Array) {
+			writer.writeTag(7, 2);
+			writer.writeBytes(value);
+		} else if (Array.isArray(value)) {
+			writer.writeTag(5, 2);
+			const arrayStart = writer.startLengthDelimited();
+			const arrayStartPos = writer.pos;
+			for (const item of value) {
+				writer.writeTag(1, 2);
+				const itemStart = writer.startLengthDelimited();
+				const itemStartPos = writer.pos;
+				writeAnyValue(writer, item);
+				writer.finishLengthDelimited(itemStart, writer.pos - itemStartPos);
+			}
+			writer.finishLengthDelimited(arrayStart, writer.pos - arrayStartPos);
+		} else if (t === "object" && value != null) {
+			writer.writeTag(6, 2);
+			const kvlistStart = writer.startLengthDelimited();
+			const kvlistStartPos = writer.pos;
+			const obj = value;
+			for (const k in obj) {
+				if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
+				const v = obj[k];
+				writer.writeTag(1, 2);
+				const kvStart = writer.startLengthDelimited();
+				const kvStartPos = writer.pos;
+				writer.writeTag(1, 2);
+				writer.writeString(k);
+				writer.writeTag(2, 2);
+				const valueStart = writer.startLengthDelimited();
+				const valueStartPos = writer.pos;
+				writeAnyValue(writer, v);
+				writer.finishLengthDelimited(valueStart, writer.pos - valueStartPos);
+				writer.finishLengthDelimited(kvStart, writer.pos - kvStartPos);
+			}
+			writer.finishLengthDelimited(kvlistStart, writer.pos - kvlistStartPos);
+		}
+	}
+	exports.writeAnyValue = writeAnyValue;
+	/**
+	* Write an InstrumentationScope message.
+	*
+	* Proto fields (InstrumentationScope):
+	*   1  name     string  (wire type 2)
+	*   2  version  string  (wire type 2)
+	*/
+	function writeInstrumentationScope(writer, scope, fieldNumber) {
+		writer.writeTag(fieldNumber, 2);
+		const start = writer.startLengthDelimited();
+		const startPos = writer.pos;
+		writer.writeTag(1, 2);
+		writer.writeString(scope.name);
+		if (scope.version) {
+			writer.writeTag(2, 2);
+			writer.writeString(scope.version);
+		}
+		writer.finishLengthDelimited(start, writer.pos - startPos);
+	}
+	exports.writeInstrumentationScope = writeInstrumentationScope;
+	/**
+	* Write a Resource message and its enclosing tag.
+	*
+	* Proto fields (Resource):
+	*   1  attributes                repeated KeyValue  (wire type 2)
+	*   2  dropped_attributes_count  uint32             (wire type 0)
+	*/
+	function writeResource(writer, resource, fieldNumber) {
+		writer.writeTag(fieldNumber, 2);
+		const resourceStart = writer.startLengthDelimited();
+		const resourceStartPos = writer.pos;
+		if (resource.attributes) writeAttributes(writer, resource.attributes, 1);
+		writer.writeTag(2, 0);
+		writer.writeVarint(0);
+		writer.finishLengthDelimited(resourceStart, writer.pos - resourceStartPos);
+	}
+	exports.writeResource = writeResource;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_common_serializer();
+	}
+});
+
+//# sourceMappingURL=common-serializer.cjs.map

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-serializer.cjs","names":[],"sources":["../../../../../../../../../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.writeResource = exports.writeInstrumentationScope = exports.writeAnyValue = exports.writeKeyValue = exports.writeAttributes = exports.writeHrTimeAsFixed64 = void 0;\n/**\n * Write HrTime [seconds, nanoseconds] directly as fixed64 to the serializer.\n * Converts to nanoseconds and writes as 64-bit little-endian integer without allocations.\n *\n * HrTime represents: total_nanos = seconds * 1_000_000_000 + nanoseconds\n * We need to split this into low (bits 0-31) and high (bits 32-63).\n *\n * @param serializer - The protobuf writer\n * @param hrTime - HrTime tuple [seconds, nanoseconds]\n */\nfunction writeHrTimeAsFixed64(serializer, hrTime) {\n    const seconds = hrTime[0];\n    const nanos = hrTime[1];\n    // Calculate total nanoseconds (seconds * 1_000_000_000 + nanos) split into [low32, high32].\n    //\n    // We cannot use `seconds * 1e9` directly because for Unix timestamps\n    // (seconds > ~9_007_199) the product exceeds Number.MAX_SAFE_INTEGER and loses\n    // integer precision in IEEE 754 double arithmetic.\n    //\n    // So we split `seconds` into its lower 16 bits and remaining upper bits so\n    // every multiplication stays\n    // within the safe-integer range (< 2^53):\n    //   secondsLower16Bits * 1e9 <= 65535 * 1e9 ≈ 6.55e13 < 2^53\n    //   secondsUpperBits   * 1e9 <= 65535 * 1e9 ≈ 6.55e13 < 2^53\n    //\n    // Then recombine:\n    //   seconds * 1e9 =\n    //     secondsUpperBits * 1e9 * 2^16 +\n    //     secondsLower16Bits * 1e9\n    const nanosPerSecond = 1000000000;\n    // Split `seconds` into low 16 bits and the remaining upper bits.\n    // This avoids the signed 32-bit seconds limit behind the Year 2038 problem:\n    // the practical limit here is the encoded fixed64 range. Callers must keep\n    // `seconds * 1e9 + nanos` within uint64, i.e. up to\n    // [18_446_744_073, 709_551_615]. Beyond that, the serialized value wraps.\n    const secondsLower16Bits = seconds & 0xffff; // bits 0-15 of seconds\n    const secondsUpperBits = (seconds / 0x10000) >>> 0; // bits 16+ of seconds\n    const nanosFromLower16Bits = secondsLower16Bits * nanosPerSecond; // exact integer, < 2^53\n    const nanosFromUpperBits = secondsUpperBits * nanosPerSecond; // exact integer, < 2^53\n    // Split the lower-16-bit contribution into [low32, high32].\n    const lower16ContributionLow32 = nanosFromLower16Bits >>> 0;\n    const lower16ContributionHigh32 = Math.floor(nanosFromLower16Bits / 0x100000000);\n    // The upper-bits contribution is shifted left by 16 bits when recombined.\n    const upperBitsContributionLow32 = ((nanosFromUpperBits & 0xffff) * 0x10000) >>> 0;\n    const upperBitsContributionHigh32 = (nanosFromUpperBits / 0x10000) >>> 0;\n    // Add the two contributions plus the sub-second nanoseconds with carry propagation.\n    const low32WithCarry = lower16ContributionLow32 + upperBitsContributionLow32 + nanos;\n    const totalLow = low32WithCarry >>> 0;\n    const carry = Math.floor(low32WithCarry / 0x100000000); // 0, 1, or 2\n    const totalHigh = (lower16ContributionHigh32 + upperBitsContributionHigh32 + carry) >>> 0;\n    serializer.writeFixed64(totalLow, totalHigh);\n}\nexports.writeHrTimeAsFixed64 = writeHrTimeAsFixed64;\n/**\n * Write Attributes directly to protobuf as repeated KeyValue\n */\nfunction writeAttributes(writer, attributes, fieldNumber) {\n    for (const key in attributes) {\n        if (!Object.prototype.hasOwnProperty.call(attributes, key)) {\n            continue;\n        }\n        const value = attributes[key];\n        writer.writeTag(fieldNumber, 2); // repeated KeyValue attributes (field varies, length-delimited)\n        const kvStart = writer.startLengthDelimited();\n        const startPos = writer.pos;\n        writeKeyValue(writer, key, value);\n        writer.finishLengthDelimited(kvStart, writer.pos - startPos);\n    }\n}\nexports.writeAttributes = writeAttributes;\n/**\n * Write a KeyValue pair directly to protobuf\n */\nfunction writeKeyValue(writer, key, value) {\n    writer.writeTag(1, 2); // KeyValue.key (field 1, string, length-delimited)\n    writer.writeString(key);\n    writer.writeTag(2, 2); // KeyValue.value (field 2, AnyValue, length-delimited)\n    const valueStart = writer.startLengthDelimited();\n    const startPos = writer.pos;\n    writeAnyValue(writer, value);\n    writer.finishLengthDelimited(valueStart, writer.pos - startPos);\n}\nexports.writeKeyValue = writeKeyValue;\n// int64 range bounds for int_value vs double_value encoding.\n// -(2^63) is the signed int64 minimum; 2^63 is one past the maximum.\n// Both are exact IEEE 754 doubles (powers of two), so comparisons are precise.\nconst MIN_64_BIT_INT = -(2 ** 63);\nconst MAX_64_BIT_INT = 2 ** 63;\n/**\n * Write an AnyValue directly from raw attribute value to protobuf\n */\nfunction writeAnyValue(writer, value) {\n    const t = typeof value;\n    if (t === 'string') {\n        writer.writeTag(1, 2); // AnyValue.string_value (field 1, length-delimited)\n        writer.writeString(value);\n    }\n    else if (t === 'boolean') {\n        writer.writeTag(2, 0); // AnyValue.bool_value (field 2, varint)\n        writer.writeVarint(value ? 1 : 0);\n    }\n    else if (t === 'number') {\n        const numValue = value;\n        // Encode as int_value (int64) when the number is an integer within the int64\n        // range. Number.isSafeInteger() would be too conservative — integers beyond\n        // 2^53-1 that are exactly representable in IEEE 754 (e.g. powers of two)\n        // still fit in int64 and must not be downgraded to double_value.\n        if (Number.isInteger(numValue) &&\n            numValue >= MIN_64_BIT_INT &&\n            numValue < MAX_64_BIT_INT) {\n            writer.writeTag(3, 0); // AnyValue.int_value (field 3, varint)\n            writer.writeVarint(numValue);\n        }\n        else {\n            writer.writeTag(4, 1); // AnyValue.double_value (field 4, fixed64)\n            writer.writeDouble(numValue);\n        }\n    }\n    else if (value instanceof Uint8Array) {\n        writer.writeTag(7, 2); // AnyValue.bytes_value (field 7, length-delimited)\n        writer.writeBytes(value);\n    }\n    else if (Array.isArray(value)) {\n        writer.writeTag(5, 2); // AnyValue.array_value (field 5, ArrayValue, length-delimited)\n        const arrayStart = writer.startLengthDelimited();\n        const arrayStartPos = writer.pos;\n        for (const item of value) {\n            writer.writeTag(1, 2); // ArrayValue.values (field 1, AnyValue, length-delimited)\n            const itemStart = writer.startLengthDelimited();\n            const itemStartPos = writer.pos;\n            writeAnyValue(writer, item);\n            writer.finishLengthDelimited(itemStart, writer.pos - itemStartPos);\n        }\n        writer.finishLengthDelimited(arrayStart, writer.pos - arrayStartPos);\n    }\n    else if (t === 'object' && value != null) {\n        writer.writeTag(6, 2); // AnyValue.kvlist_value (field 6, KeyValueList, length-delimited)\n        const kvlistStart = writer.startLengthDelimited();\n        const kvlistStartPos = writer.pos;\n        const obj = value;\n        for (const k in obj) {\n            if (!Object.prototype.hasOwnProperty.call(obj, k)) {\n                continue;\n            }\n            const v = obj[k];\n            writer.writeTag(1, 2); // KeyValueList.values (field 1, KeyValue, length-delimited)\n            const kvStart = writer.startLengthDelimited();\n            const kvStartPos = writer.pos;\n            writer.writeTag(1, 2); // KeyValue.key (field 1, string, length-delimited)\n            writer.writeString(k);\n            writer.writeTag(2, 2); // KeyValue.value (field 2, AnyValue, length-delimited)\n            const valueStart = writer.startLengthDelimited();\n            const valueStartPos = writer.pos;\n            writeAnyValue(writer, v);\n            writer.finishLengthDelimited(valueStart, writer.pos - valueStartPos);\n            writer.finishLengthDelimited(kvStart, writer.pos - kvStartPos);\n        }\n        writer.finishLengthDelimited(kvlistStart, writer.pos - kvlistStartPos);\n    }\n    // Else: unsupported type, write nothing\n}\nexports.writeAnyValue = writeAnyValue;\n/**\n * Write an InstrumentationScope message.\n *\n * Proto fields (InstrumentationScope):\n *   1  name     string  (wire type 2)\n *   2  version  string  (wire type 2)\n */\nfunction writeInstrumentationScope(writer, scope, fieldNumber) {\n    writer.writeTag(fieldNumber, 2);\n    const start = writer.startLengthDelimited();\n    const startPos = writer.pos;\n    // name (field 1, string)\n    writer.writeTag(1, 2);\n    writer.writeString(scope.name);\n    // version (field 2, string) - skip if empty\n    if (scope.version) {\n        writer.writeTag(2, 2);\n        writer.writeString(scope.version);\n    }\n    writer.finishLengthDelimited(start, writer.pos - startPos);\n}\nexports.writeInstrumentationScope = writeInstrumentationScope;\n/**\n * Write a Resource message and its enclosing tag.\n *\n * Proto fields (Resource):\n *   1  attributes                repeated KeyValue  (wire type 2)\n *   2  dropped_attributes_count  uint32             (wire type 0)\n */\nfunction writeResource(writer, resource, fieldNumber) {\n    writer.writeTag(fieldNumber, 2);\n    const resourceStart = writer.startLengthDelimited();\n    const resourceStartPos = writer.pos;\n    // attributes (field 1, repeated KeyValue)\n    if (resource.attributes) {\n        writeAttributes(writer, resource.attributes, 1);\n    }\n    // dropped_attributes_count (field 2, uint32) - set to 0 as we don't track this\n    writer.writeTag(2, 0);\n    writer.writeVarint(0);\n    writer.finishLengthDelimited(resourceStart, writer.pos - resourceStartPos);\n}\nexports.writeResource = writeResource;\n//# sourceMappingURL=common-serializer.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.cjs

@@ -0,0 +1,108 @@
+"use strict";
+//#region ../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.js
+var require_protobuf_reader = /* @__PURE__ */ require("../../../../../../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ProtobufReader = void 0;
+	/**
+	* Minimal binary protobuf reader.
+	* Only implements the wire-types that we currently need; this is not intended
+	* to be a general-purpose protobuf reader.
+	*
+	* Since the values we parse are generally small and not very nested, it's public
+	* interface does not enforce the same low-allocation philosophy that ProtobufWriter does.
+	* If this is needed in the future, we should refactor this to fit the use-case.
+	*/
+	var ProtobufReader = class {
+		pos = 0;
+		_buf;
+		_textDecoder;
+		constructor(buf) {
+			this._buf = buf;
+			this._textDecoder = new TextDecoder();
+		}
+		isAtEnd() {
+			return this.pos >= this._buf.length;
+		}
+		/** Read a varint and decode it as a tag, returning field number and wire type. */
+		readTag() {
+			const raw = this.readVarint();
+			return {
+				fieldNumber: raw >>> 3,
+				wireType: raw & 7
+			};
+		}
+		/**
+		* Read a base-128 varint.
+		* Returns a JS `number`; precision above 2^53 is silently lost.
+		* Throws if the buffer is truncated mid-varint.
+		*/
+		readVarint() {
+			let result = 0;
+			let shift = 0;
+			let terminated = false;
+			while (this.pos < this._buf.length) {
+				const b = this._buf[this.pos++];
+				result += (b & 127) * Math.pow(2, shift);
+				shift += 7;
+				if ((b & 128) === 0) {
+					terminated = true;
+					break;
+				}
+			}
+			if (!terminated) throw new Error("Truncated buffer: unexpected end of data while reading varint");
+			return result;
+		}
+		/** Read a length-delimited byte sequence (bytes field or embedded message). */
+		readBytes() {
+			const len = this.readVarint();
+			if (this.pos + len > this._buf.length) throw new Error(`Truncated buffer: expected ${len} bytes at position ${this.pos}, but only ${this._buf.length - this.pos} available`);
+			const slice = this._buf.subarray(this.pos, this.pos + len);
+			this.pos += len;
+			return slice;
+		}
+		/** Read a length-delimited UTF-8 string. */
+		readString() {
+			return this._textDecoder.decode(this.readBytes());
+		}
+		/**
+		* Skip an unknown field.
+		* Handles wire types 0 (varint), 1 (64-bit), 2 (length-delimited),
+		* 3 (start-group), 4 (end-group), and 5 (32-bit).
+		*/
+		skip(wireType) {
+			switch (wireType) {
+				case 0:
+					this.readVarint();
+					break;
+				case 1:
+					this.pos += 8;
+					break;
+				case 2:
+					this.readBytes();
+					break;
+				case 3:
+					while (!this.isAtEnd()) {
+						const { wireType: nestedWireType } = this.readTag();
+						if (nestedWireType === 4) break;
+						this.skip(nestedWireType);
+					}
+					break;
+				case 4: break;
+				case 5:
+					this.pos += 4;
+					break;
+				default: throw new Error(`Unknown wire type ${wireType}, cannot safely skip`);
+			}
+		}
+	};
+	exports.ProtobufReader = ProtobufReader;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_protobuf_reader();
+	}
+});
+
+//# sourceMappingURL=protobuf-reader.cjs.map

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protobuf-reader.cjs","names":[],"sources":["../../../../../../../../../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ProtobufReader = void 0;\n/**\n * Minimal binary protobuf reader.\n * Only implements the wire-types that we currently need; this is not intended\n * to be a general-purpose protobuf reader.\n *\n * Since the values we parse are generally small and not very nested, it's public\n * interface does not enforce the same low-allocation philosophy that ProtobufWriter does.\n * If this is needed in the future, we should refactor this to fit the use-case.\n */\nclass ProtobufReader {\n    pos = 0;\n    _buf;\n    _textDecoder;\n    constructor(buf) {\n        this._buf = buf;\n        this._textDecoder = new TextDecoder();\n    }\n    isAtEnd() {\n        return this.pos >= this._buf.length;\n    }\n    /** Read a varint and decode it as a tag, returning field number and wire type. */\n    readTag() {\n        const raw = this.readVarint();\n        return { fieldNumber: raw >>> 3, wireType: raw & 0x7 };\n    }\n    /**\n     * Read a base-128 varint.\n     * Returns a JS `number`; precision above 2^53 is silently lost.\n     * Throws if the buffer is truncated mid-varint.\n     */\n    readVarint() {\n        let result = 0;\n        let shift = 0;\n        let terminated = false;\n        while (this.pos < this._buf.length) {\n            const b = this._buf[this.pos++];\n            result += (b & 0x7f) * Math.pow(2, shift);\n            shift += 7;\n            if ((b & 0x80) === 0) {\n                terminated = true;\n                break;\n            }\n        }\n        if (!terminated) {\n            throw new Error('Truncated buffer: unexpected end of data while reading varint');\n        }\n        return result;\n    }\n    /** Read a length-delimited byte sequence (bytes field or embedded message). */\n    readBytes() {\n        const len = this.readVarint();\n        if (this.pos + len > this._buf.length) {\n            throw new Error(`Truncated buffer: expected ${len} bytes at position ${this.pos}, but only ${this._buf.length - this.pos} available`);\n        }\n        const slice = this._buf.subarray(this.pos, this.pos + len);\n        this.pos += len;\n        return slice;\n    }\n    /** Read a length-delimited UTF-8 string. */\n    readString() {\n        return this._textDecoder.decode(this.readBytes());\n    }\n    /**\n     * Skip an unknown field.\n     * Handles wire types 0 (varint), 1 (64-bit), 2 (length-delimited),\n     * 3 (start-group), 4 (end-group), and 5 (32-bit).\n     */\n    skip(wireType) {\n        switch (wireType) {\n            case 0: // varint\n                this.readVarint();\n                break;\n            case 1: // 64-bit fixed\n                this.pos += 8;\n                break;\n            case 2: // length-delimited\n                this.readBytes();\n                break;\n            case 3: // start group (deprecated)\n                // We should never encounter this, but let's handle it gracefully in case we do:\n                // Read nested tags until matching end-group (wire type 4) is found.\n                // Groups can be nested, so continue until the end-group for this\n                // start-group is encountered.\n                while (!this.isAtEnd()) {\n                    const { wireType: nestedWireType } = this.readTag();\n                    if (nestedWireType === 4) {\n                        // matched end-group for this start-group\n                        break;\n                    }\n                    // recursive skip also handles nested groups\n                    this.skip(nestedWireType);\n                }\n                break;\n            case 4: // end group\n                // End-group should be handled by the start-group logic above.\n                // When encountered directly in skip, treat it as a no-op (it signals\n                // termination of the enclosing group).\n                break;\n            case 5: // 32-bit fixed\n                this.pos += 4;\n                break;\n            default:\n                throw new Error(`Unknown wire type ${wireType}, cannot safely skip`);\n        }\n    }\n}\nexports.ProtobufReader = ProtobufReader;\n//# sourceMappingURL=protobuf-reader.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,iBAAiB,KAAK;;;;;;;;;;CAU9B,IAAM,iBAAN,MAAqB;EACjB,MAAM;EACN;EACA;EACA,YAAY,KAAK;AACb,QAAK,OAAO;AACZ,QAAK,eAAe,IAAI,aAAa;;EAEzC,UAAU;AACN,UAAO,KAAK,OAAO,KAAK,KAAK;;;EAGjC,UAAU;GACN,MAAM,MAAM,KAAK,YAAY;AAC7B,UAAO;IAAE,aAAa,QAAQ;IAAG,UAAU,MAAM;IAAK;;;;;;;EAO1D,aAAa;GACT,IAAI,SAAS;GACb,IAAI,QAAQ;GACZ,IAAI,aAAa;AACjB,UAAO,KAAK,MAAM,KAAK,KAAK,QAAQ;IAChC,MAAM,IAAI,KAAK,KAAK,KAAK;AACzB,eAAW,IAAI,OAAQ,KAAK,IAAI,GAAG,MAAM;AACzC,aAAS;AACT,SAAK,IAAI,SAAU,GAAG;AAClB,kBAAa;AACb;;;AAGR,OAAI,CAAC,WACD,OAAM,IAAI,MAAM,gEAAgE;AAEpF,UAAO;;;EAGX,YAAY;GACR,MAAM,MAAM,KAAK,YAAY;AAC7B,OAAI,KAAK,MAAM,MAAM,KAAK,KAAK,OAC3B,OAAM,IAAI,MAAM,8BAA8B,IAAI,qBAAqB,KAAK,IAAI,aAAa,KAAK,KAAK,SAAS,KAAK,IAAI,YAAY;GAEzI,MAAM,QAAQ,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1D,QAAK,OAAO;AACZ,UAAO;;;EAGX,aAAa;AACT,UAAO,KAAK,aAAa,OAAO,KAAK,WAAW,CAAC;;;;;;;EAOrD,KAAK,UAAU;AACX,WAAQ,UAAR;IACI,KAAK;AACD,UAAK,YAAY;AACjB;IACJ,KAAK;AACD,UAAK,OAAO;AACZ;IACJ,KAAK;AACD,UAAK,WAAW;AAChB;IACJ,KAAK;AAKD,YAAO,CAAC,KAAK,SAAS,EAAE;MACpB,MAAM,EAAE,UAAU,mBAAmB,KAAK,SAAS;AACnD,UAAI,mBAAmB,EAEnB;AAGJ,WAAK,KAAK,eAAe;;AAE7B;IACJ,KAAK,EAID;IACJ,KAAK;AACD,UAAK,OAAO;AACZ;IACJ,QACI,OAAM,IAAI,MAAM,qBAAqB,SAAS,sBAAsB;;;;AAIpF,SAAQ,iBAAiB"}

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.cjs

@@ -0,0 +1,82 @@
+"use strict";
+const require_runtime = require("../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_utils$1 = require("./utils.cjs");
+//#region ../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.js
+var require_protobuf_size_estimator = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ProtobufSizeEstimator = void 0;
+	const utils_1 = require_utils$1.default;
+	/**
+	* Calculate UTF-8 byte length without encoding
+	* @param str valid UTF-16 string
+	*/
+	function utf8ByteLength(str) {
+		const len = str.length;
+		let byteLen = 0;
+		for (let i = 0; i < len; i++) {
+			const code = str.charCodeAt(i);
+			if (code < 128) byteLen += 1;
+			else if (code < 2048) byteLen += 2;
+			else if (code < 55296 || code >= 57344) byteLen += 3;
+			else {
+				i++;
+				byteLen += 4;
+			}
+		}
+		return byteLen;
+	}
+	/**
+	* Size estimator for protobuf messages.
+	* Implements the same interface as ProtobufWriter but only counts bytes without allocating a buffer.
+	* @internal
+	*/
+	var ProtobufSizeEstimator = class {
+		pos = 0;
+		startLengthDelimited() {
+			return this.pos;
+		}
+		finishLengthDelimited(_, length) {
+			this.pos += (0, utils_1.estimateVarintSize)(length);
+		}
+		writeVarint(value) {
+			this.pos += (0, utils_1.estimateVarintSize)(value);
+		}
+		writeSint32(value) {
+			this.pos += (0, utils_1.estimateVarintSize)((value << 1 ^ value >> 31) >>> 0);
+		}
+		writeSfixed64(_value) {
+			this.pos += 8;
+		}
+		writeFixed32(_value) {
+			this.pos += 4;
+		}
+		writeFixed64(_low, _high) {
+			this.pos += 8;
+		}
+		writeBytes(bytes) {
+			this.pos += (0, utils_1.estimateVarintSize)(bytes.length);
+			this.pos += bytes.length;
+		}
+		writeTag(fieldNumber, wireType) {
+			this.writeVarint(fieldNumber << 3 | wireType);
+		}
+		writeDouble(_value) {
+			this.pos += 8;
+		}
+		writeString(str) {
+			const byteLen = utf8ByteLength(str);
+			this.pos += (0, utils_1.estimateVarintSize)(byteLen);
+			this.pos += byteLen;
+		}
+	};
+	exports.ProtobufSizeEstimator = ProtobufSizeEstimator;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_protobuf_size_estimator();
+	}
+});
+
+//# sourceMappingURL=protobuf-size-estimator.cjs.map

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protobuf-size-estimator.cjs","names":[],"sources":["../../../../../../../../../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ProtobufSizeEstimator = void 0;\nconst utils_1 = require(\"./utils\");\n/**\n * Calculate UTF-8 byte length without encoding\n * @param str valid UTF-16 string\n */\nfunction utf8ByteLength(str) {\n    // No quick path for ASCII, since we need to loop though all chars anyway.\n    const len = str.length;\n    let byteLen = 0;\n    for (let i = 0; i < len; i++) {\n        const code = str.charCodeAt(i);\n        if (code < 0x80) {\n            byteLen += 1;\n        }\n        else if (code < 0x800) {\n            byteLen += 2;\n        }\n        else if (code < 0xd800 || code >= 0xe000) {\n            byteLen += 3;\n        }\n        else {\n            // Surrogate pair\n            i++; // Skip the next character\n            byteLen += 4;\n        }\n    }\n    return byteLen;\n}\n/**\n * Size estimator for protobuf messages.\n * Implements the same interface as ProtobufWriter but only counts bytes without allocating a buffer.\n * @internal\n */\nclass ProtobufSizeEstimator {\n    pos = 0;\n    startLengthDelimited() {\n        return this.pos;\n    }\n    finishLengthDelimited(_, length) {\n        this.pos += (0, utils_1.estimateVarintSize)(length);\n    }\n    writeVarint(value) {\n        this.pos += (0, utils_1.estimateVarintSize)(value);\n    }\n    writeSint32(value) {\n        // Zigzag encode: (n << 1) ^ (n >> 31)\n        this.pos += (0, utils_1.estimateVarintSize)(((value << 1) ^ (value >> 31)) >>> 0);\n    }\n    writeSfixed64(_value) {\n        this.pos += 8;\n    }\n    writeFixed32(_value) {\n        this.pos += 4;\n    }\n    writeFixed64(_low, _high) {\n        this.pos += 8;\n    }\n    writeBytes(bytes) {\n        this.pos += (0, utils_1.estimateVarintSize)(bytes.length);\n        this.pos += bytes.length;\n    }\n    writeTag(fieldNumber, wireType) {\n        this.writeVarint((fieldNumber << 3) | wireType);\n    }\n    writeDouble(_value) {\n        this.pos += 8;\n    }\n    writeString(str) {\n        const byteLen = utf8ByteLength(str);\n        this.pos += (0, utils_1.estimateVarintSize)(byteLen);\n        this.pos += byteLen;\n    }\n}\nexports.ProtobufSizeEstimator = ProtobufSizeEstimator;\n//# sourceMappingURL=protobuf-size-estimator.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB,KAAK;CACrC,MAAM,UAAA,gBAAA;;;;;CAKN,SAAS,eAAe,KAAK;EAEzB,MAAM,MAAM,IAAI;EAChB,IAAI,UAAU;AACd,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;GAC1B,MAAM,OAAO,IAAI,WAAW,EAAE;AAC9B,OAAI,OAAO,IACP,YAAW;YAEN,OAAO,KACZ,YAAW;YAEN,OAAO,SAAU,QAAQ,MAC9B,YAAW;QAEV;AAED;AACA,eAAW;;;AAGnB,SAAO;;;;;;;CAOX,IAAM,wBAAN,MAA4B;EACxB,MAAM;EACN,uBAAuB;AACnB,UAAO,KAAK;;EAEhB,sBAAsB,GAAG,QAAQ;AAC7B,QAAK,QAAQ,GAAG,QAAQ,oBAAoB,OAAO;;EAEvD,YAAY,OAAO;AACf,QAAK,QAAQ,GAAG,QAAQ,oBAAoB,MAAM;;EAEtD,YAAY,OAAO;AAEf,QAAK,QAAQ,GAAG,QAAQ,qBAAsB,SAAS,IAAM,SAAS,QAAS,EAAE;;EAErF,cAAc,QAAQ;AAClB,QAAK,OAAO;;EAEhB,aAAa,QAAQ;AACjB,QAAK,OAAO;;EAEhB,aAAa,MAAM,OAAO;AACtB,QAAK,OAAO;;EAEhB,WAAW,OAAO;AACd,QAAK,QAAQ,GAAG,QAAQ,oBAAoB,MAAM,OAAO;AACzD,QAAK,OAAO,MAAM;;EAEtB,SAAS,aAAa,UAAU;AAC5B,QAAK,YAAa,eAAe,IAAK,SAAS;;EAEnD,YAAY,QAAQ;AAChB,QAAK,OAAO;;EAEhB,YAAY,KAAK;GACb,MAAM,UAAU,eAAe,IAAI;AACnC,QAAK,QAAQ,GAAG,QAAQ,oBAAoB,QAAQ;AACpD,QAAK,OAAO;;;AAGpB,SAAQ,wBAAwB"}

package/dist/node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-writer.cjs

@@ -0,0 +1,240 @@
+"use strict";
+const require_runtime = require("../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_utils$1 = require("./utils.cjs");
+//#region ../../node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-writer.js
+var require_protobuf_writer = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ProtobufWriter = exports.GROWING_BUFFER_DEBUG_MESSAGE = void 0;
+	const api_1 = require("@opentelemetry/api");
+	const utils_1 = require_utils$1.default;
+	exports.GROWING_BUFFER_DEBUG_MESSAGE = "ProtobufWriter: estimated size was too small, growing buffer.";
+	/**
+	* bytes reserved for length in length-delimited fields
+	* using 1 to assume most length-delimited fields are small
+	*/
+	const RESERVED_LENGTH_BYTES = 1;
+	/**
+	* Primitive protobuf writer, optimized to avoid small object allocations.
+	* Grows buffer dynamically if initial size is exceeded.
+	*/
+	var ProtobufWriter = class {
+		_buffer;
+		_textEncoder;
+		_dataView;
+		pos = 0;
+		constructor(estimatedSize = 65536) {
+			this._buffer = new Uint8Array(estimatedSize);
+			this._textEncoder = new TextEncoder();
+			this._dataView = new DataView(this._buffer.buffer, this._buffer.byteOffset);
+		}
+		/**
+		* Ensure buffer has capacity for at least size more bytes
+		*/
+		_ensureCapacity(size) {
+			const needed = this.pos + size;
+			if (needed <= this._buffer.length) return;
+			api_1.diag.debug(exports.GROWING_BUFFER_DEBUG_MESSAGE);
+			let newSize = this._buffer.length * 2;
+			while (newSize < needed) newSize *= 2;
+			const newBuffer = new Uint8Array(newSize);
+			newBuffer.set(this._buffer);
+			this._buffer = newBuffer;
+			this._dataView = new DataView(this._buffer.buffer, this._buffer.byteOffset);
+		}
+		/**
+		* Get the written bytes as a Uint8Array
+		*/
+		finish() {
+			return this._buffer.subarray(0, this.pos);
+		}
+		/**
+		* Insert placeholder for length. Update later with {@link finishLengthDelimited}
+		* Returns the position where to write the length.
+		*/
+		startLengthDelimited() {
+			const lengthPos = this.pos;
+			this._ensureCapacity(RESERVED_LENGTH_BYTES);
+			this.pos += RESERVED_LENGTH_BYTES;
+			return lengthPos;
+		}
+		/**
+		* Write length varint at placeholder position and shift content forward if needed.
+		* Most messages are small (< 128 bytes), so we reserve 1 byte and only shift
+		* when the length needs more bytes.
+		*/
+		finishLengthDelimited(pos, length) {
+			const v = length >>> 0;
+			const varintSize = (0, utils_1.estimateVarintSize)(v);
+			if (varintSize > RESERVED_LENGTH_BYTES) {
+				const additionalBytes = varintSize - RESERVED_LENGTH_BYTES;
+				this._ensureCapacity(additionalBytes);
+				this._buffer.copyWithin(pos + varintSize, pos + RESERVED_LENGTH_BYTES, this.pos);
+				this.pos += additionalBytes;
+			}
+			let writePos = pos;
+			if (v < 128) this._buffer[writePos] = v;
+			else if (v < 16384) {
+				this._buffer[writePos++] = v & 127 | 128;
+				this._buffer[writePos] = v >>> 7;
+			} else if (v < 2097152) {
+				this._buffer[writePos++] = v & 127 | 128;
+				this._buffer[writePos++] = v >>> 7 & 127 | 128;
+				this._buffer[writePos] = v >>> 14;
+			} else if (v < 268435456) {
+				this._buffer[writePos++] = v & 127 | 128;
+				this._buffer[writePos++] = v >>> 7 & 127 | 128;
+				this._buffer[writePos++] = v >>> 14 & 127 | 128;
+				this._buffer[writePos] = v >>> 21;
+			} else {
+				this._buffer[writePos++] = v & 127 | 128;
+				this._buffer[writePos++] = v >>> 7 & 127 | 128;
+				this._buffer[writePos++] = v >>> 14 & 127 | 128;
+				this._buffer[writePos++] = v >>> 21 & 127 | 128;
+				this._buffer[writePos] = v >>> 28;
+			}
+		}
+		/**
+		* Write a sint32 value using zigzag encoding
+		*/
+		writeSint32(value) {
+			this.writeVarint((value << 1 ^ value >> 31) >>> 0);
+		}
+		/**
+		* Write a signed 64-bit fixed integer (sfixed64) from a JS number.
+		* Handles negative values via two's complement.
+		*/
+		writeSfixed64(value) {
+			let low;
+			let high;
+			if (value >= 0) {
+				low = value >>> 0;
+				high = value / 4294967296 >>> 0;
+			} else {
+				const abs = Math.abs(value);
+				low = abs >>> 0;
+				high = abs / 4294967296 >>> 0;
+				low = ~low >>> 0;
+				high = ~high >>> 0;
+				low = low + 1 >>> 0;
+				if (low === 0) high = high + 1 >>> 0;
+			}
+			this.writeFixed64(low, high);
+		}
+		/**
+		* Write a varint (variable-length integer)
+		*/
+		writeVarint(value) {
+			this._ensureCapacity((0, utils_1.estimateVarintSize)(value));
+			if (value >= 0 && value <= 4294967295) {
+				let v = value >>> 0;
+				while (v > 127) {
+					this._buffer[this.pos++] = v & 127 | 128;
+					v >>>= 7;
+				}
+				this._buffer[this.pos++] = v;
+			} else {
+				let low;
+				let high;
+				if (value >= 0) {
+					low = value >>> 0;
+					high = value / 4294967296 >>> 0;
+				} else {
+					const abs = Math.abs(value);
+					low = abs >>> 0;
+					high = abs / 4294967296 >>> 0;
+					low = ~low >>> 0;
+					high = ~high >>> 0;
+					low = low + 1 >>> 0;
+					if (low === 0) high = high + 1 >>> 0;
+				}
+				while (high > 0 || low > 127) {
+					this._buffer[this.pos++] = low & 127 | 128;
+					low = (low >>> 7 | high << 25) >>> 0;
+					high >>>= 7;
+				}
+				this._buffer[this.pos++] = low & 127;
+			}
+		}
+		/**
+		* Write a 32-bit fixed integer (little-endian)
+		*/
+		writeFixed32(value) {
+			this._ensureCapacity(4);
+			const v = value >>> 0;
+			this._buffer[this.pos++] = v & 255;
+			this._buffer[this.pos++] = v >>> 8 & 255;
+			this._buffer[this.pos++] = v >>> 16 & 255;
+			this._buffer[this.pos++] = v >>> 24 & 255;
+		}
+		/**
+		* Write a 64-bit fixed integer (little-endian)
+		* @param low - Low 32 bits
+		* @param high - High 32 bits
+		*/
+		writeFixed64(low, high) {
+			this._ensureCapacity(8);
+			const l = low >>> 0;
+			const h = high >>> 0;
+			this._buffer[this.pos++] = l & 255;
+			this._buffer[this.pos++] = l >>> 8 & 255;
+			this._buffer[this.pos++] = l >>> 16 & 255;
+			this._buffer[this.pos++] = l >>> 24 & 255;
+			this._buffer[this.pos++] = h & 255;
+			this._buffer[this.pos++] = h >>> 8 & 255;
+			this._buffer[this.pos++] = h >>> 16 & 255;
+			this._buffer[this.pos++] = h >>> 24 & 255;
+		}
+		/**
+		* Write length-delimited data (varint length + bytes)
+		*/
+		writeBytes(bytes) {
+			this.writeVarint(bytes.length);
+			this._ensureCapacity(bytes.length);
+			this._buffer.set(bytes, this.pos);
+			this.pos += bytes.length;
+		}
+		/**
+		* Write a field key (field number + wire type)
+		*/
+		writeTag(fieldNumber, wireType) {
+			this.writeVarint(fieldNumber << 3 | wireType);
+		}
+		/**
+		* Write a double (64-bit IEEE 754)
+		*/
+		writeDouble(value) {
+			this._ensureCapacity(8);
+			this._dataView.setFloat64(this.pos, value, true);
+			this.pos += 8;
+		}
+		/**
+		* Write a string as UTF-8 bytes (length-delimited)
+		*/
+		writeString(str) {
+			let isAscii = true;
+			const len = str.length;
+			for (let i = 0; i < len; i++) if (str.charCodeAt(i) > 127) {
+				isAscii = false;
+				break;
+			}
+			if (isAscii) {
+				this.writeVarint(len);
+				this._ensureCapacity(len);
+				for (let i = 0; i < len; i++) this._buffer[this.pos++] = str.charCodeAt(i);
+			} else {
+				const bytes = this._textEncoder.encode(str);
+				this.writeBytes(bytes);
+			}
+		}
+	};
+	exports.ProtobufWriter = ProtobufWriter;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_protobuf_writer();
+	}
+});
+
+//# sourceMappingURL=protobuf-writer.cjs.map