@tickernelz/paperclip-pro-server 2026.1017.2 → 2026.1021.0

package/node_modules/@opentelemetry/api/dist/trace/span.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.cts","names":[],"sources":["../../src/trace/span.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiBiB;;;;;;;;;;EAUb,eAAe;;;;;;;;;;EAUf,aAAa,aAAa,OAAO;;;;;;;;EAQjC,cAAc,YAAY;;;;;;;;;;EAU1B,SAAS,cAAc,wBAAwB,iBAAiB,WAAW,YAAY;;;;;;;;;;;EAWvF,QAAQ,MAAM;;;;;;;;;;;EAWd,SAAS,OAAO;;;;;;;;;;;;;;;;;;EAkBhB,UAAU,QAAQ;;;;;;;;;;;EAWlB,WAAW;;;;;;;;;;;;;EAaX,IAAI,UAAU;;;;;;;EAOd;;;;;;;EAOA,gBAAgB,WAAW,WAAW,OAAO"}

package/node_modules/@opentelemetry/api/dist/trace/span.d.mts

@@ -0,0 +1,139 @@
+import { TimeInput } from "../common/Time.mjs";
+import { Exception } from "../common/Exception.mjs";
+import { SpanAttributeValue, SpanAttributes } from "./attributes.mjs";
+import { SpanContext } from "./span_context.mjs";
+import { SpanStatus } from "./status.mjs";
+import { Link } from "./link.mjs";
+//#region src/trace/span.d.ts
+/**
+ * An interface that represents a span. A span represents a single operation
+ * within a trace. Examples of span might include remote procedure calls or a
+ * in-process function calls to sub-components. A Trace has a single, top-level
+ * "root" Span that in turn may have zero or more child Spans, which in turn
+ * may have children.
+ *
+ * Spans are created by the {@link Tracer.startSpan} method.
+ *
+ * @since 1.0.0
+ */
+interface Span {
+  /**
+   * Returns the {@link SpanContext} object associated with this Span.
+   *
+   * Get an immutable, serializable identifier for this span that can be used
+   * to create new child spans. Returned SpanContext is usable even after the
+   * span ends.
+   *
+   * @returns the SpanContext object associated with this Span.
+   */
+  spanContext(): SpanContext;
+  /**
+   * Sets an attribute to the span.
+   *
+   * Sets a single Attribute with the key and value passed as arguments.
+   *
+   * @param key the key for this attribute.
+   * @param value the value for this attribute. Setting a value null or
+   *              undefined is invalid and will result in undefined behavior.
+   */
+  setAttribute(key: string, value: SpanAttributeValue): this;
+  /**
+   * Sets attributes to the span.
+   *
+   * @param attributes the attributes that will be added.
+   *                   null or undefined attribute values
+   *                   are invalid and will result in undefined behavior.
+   */
+  setAttributes(attributes: SpanAttributes): this;
+  /**
+   * Adds an event to the Span.
+   *
+   * @param name the name of the event.
+   * @param [attributesOrStartTime] the attributes that will be added; these are
+   *     associated with this event. Can be also a start time
+   *     if type is {@type TimeInput} and 3rd param is undefined
+   * @param [startTime] start time of the event.
+   */
+  addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+  /**
+   * Adds a single link to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param link the link to add.
+   *
+   * @since 1.9.0
+   */
+  addLink(link: Link): this;
+  /**
+   * Adds multiple links to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param links the links to add.
+   *
+   * @since 1.9.0
+   */
+  addLinks(links: Link[]): this;
+  /**
+   * Sets the status of the span.
+   *
+   * By default, a span has status {@link SpanStatusCode.UNSET}.
+   * Calling this method overrides that default.
+   *
+   * The status codes have a total order: `OK > ERROR > UNSET`.
+   *
+   * - Once {@link SpanStatusCode.OK} is set, any further attempts to change
+   *   the status are ignored.
+   * - Any attempt to set {@link SpanStatusCode.UNSET} is always ignored.
+   *
+   * The `message` field is only used when {@link SpanStatusCode.ERROR} is set.
+   * For all other status codes, `message` is ignored.
+   *
+   * @param status The {@link SpanStatus} to set.
+   */
+  setStatus(status: SpanStatus): this;
+  /**
+   * Updates the Span name.
+   *
+   * This will override the name provided via {@link Tracer.startSpan}.
+   *
+   * Upon this update, any sampling behavior based on Span name will depend on
+   * the implementation.
+   *
+   * @param name the Span name.
+   */
+  updateName(name: string): this;
+  /**
+   * Marks the end of Span execution.
+   *
+   * Call to End of a Span MUST not have any effects on child spans. Those may
+   * still be running and can be ended later.
+   *
+   * Do not return `this`. The Span generally should not be used after it
+   * is ended so chaining is not desired in this context.
+   *
+   * @param [endTime] the time to set as Span's end time. If not provided,
+   *     use the current time as the span's end time.
+   */
+  end(endTime?: TimeInput): void;
+  /**
+   * Returns the flag whether this span will be recorded.
+   *
+   * @returns true if this Span is active and recording information like events
+   *     with the `AddEvent` operation and attributes using `setAttributes`.
+   */
+  isRecording(): boolean;
+  /**
+   * Sets exception as a span event
+   * @param exception the exception the only accepted values are string or Error
+   * @param [time] the time to set as Span's event time. If not provided,
+   *     use the current time.
+   */
+  recordException(exception: Exception, time?: TimeInput): void;
+}
+//#endregion
+export { Span };
+//# sourceMappingURL=span.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.mts","names":[],"sources":["../../src/trace/span.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiBiB;;;;;;;;;;EAUb,eAAe;;;;;;;;;;EAUf,aAAa,aAAa,OAAO;;;;;;;;EAQjC,cAAc,YAAY;;;;;;;;;;EAU1B,SAAS,cAAc,wBAAwB,iBAAiB,WAAW,YAAY;;;;;;;;;;;EAWvF,QAAQ,MAAM;;;;;;;;;;;EAWd,SAAS,OAAO;;;;;;;;;;;;;;;;;;EAkBhB,UAAU,QAAQ;;;;;;;;;;;EAWlB,WAAW;;;;;;;;;;;;;EAaX,IAAI,UAAU;;;;;;;EAOd;;;;;;;EAOA,gBAAgB,WAAW,WAAW,OAAO"}

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.cts

@@ -0,0 +1,58 @@
+import { TraceState } from "./trace_state.cjs";
+//#region src/trace/span_context.d.ts
+/**
+ * A SpanContext represents the portion of a {@link Span} which must be
+ * serialized and propagated along side of a {@link Baggage}.
+ *
+ * @since 1.0.0
+ */
+interface SpanContext {
+  /**
+   * The ID of the trace that this span belongs to. It is worldwide unique
+   * with practically sufficient probability by being made as 16 randomly
+   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+   * 128 bits.
+   */
+  traceId: string;
+  /**
+   * The ID of the Span. It is globally unique with practically sufficient
+   * probability by being made as 8 randomly generated bytes, encoded as a 16
+   * lowercase hex characters corresponding to 64 bits.
+   */
+  spanId: string;
+  /**
+   * Only true if the SpanContext was propagated from a remote parent.
+   */
+  isRemote?: boolean;
+  /**
+   * Trace flags to propagate.
+   *
+   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+   * sampled or not. When set, the least significant bit documents that the
+   * caller may have recorded trace data. A caller who does not record trace
+   * data out-of-band leaves this flag unset.
+   *
+   * see {@link TraceFlags} for valid flag values.
+   */
+  traceFlags: number;
+  /**
+   * Tracing-system-specific info to propagate.
+   *
+   * The tracestate field value is a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+   *
+   * Examples:
+   *     Single tracing system (generic format):
+   *         tracestate: rojo=00f067aa0ba902b7
+   *     Multiple tracing systems (with different formatting):
+   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+   */
+  traceState?: TraceState;
+}
+//#endregion
+export { SpanContext };
+//# sourceMappingURL=span_context.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_context.d.cts","names":[],"sources":["../../src/trace/span_context.d.ts"],"mappings":";;;;;;;;UAOiB;;;;;;;EAOb;;;;;;EAMA;;;;EAIA;;;;;;;;;;;EAWA;;;;;;;;;;;;;;;;;EAiBA,aAAa"}

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.mts

@@ -0,0 +1,58 @@
+import { TraceState } from "./trace_state.mjs";
+//#region src/trace/span_context.d.ts
+/**
+ * A SpanContext represents the portion of a {@link Span} which must be
+ * serialized and propagated along side of a {@link Baggage}.
+ *
+ * @since 1.0.0
+ */
+interface SpanContext {
+  /**
+   * The ID of the trace that this span belongs to. It is worldwide unique
+   * with practically sufficient probability by being made as 16 randomly
+   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+   * 128 bits.
+   */
+  traceId: string;
+  /**
+   * The ID of the Span. It is globally unique with practically sufficient
+   * probability by being made as 8 randomly generated bytes, encoded as a 16
+   * lowercase hex characters corresponding to 64 bits.
+   */
+  spanId: string;
+  /**
+   * Only true if the SpanContext was propagated from a remote parent.
+   */
+  isRemote?: boolean;
+  /**
+   * Trace flags to propagate.
+   *
+   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+   * sampled or not. When set, the least significant bit documents that the
+   * caller may have recorded trace data. A caller who does not record trace
+   * data out-of-band leaves this flag unset.
+   *
+   * see {@link TraceFlags} for valid flag values.
+   */
+  traceFlags: number;
+  /**
+   * Tracing-system-specific info to propagate.
+   *
+   * The tracestate field value is a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+   *
+   * Examples:
+   *     Single tracing system (generic format):
+   *         tracestate: rojo=00f067aa0ba902b7
+   *     Multiple tracing systems (with different formatting):
+   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+   */
+  traceState?: TraceState;
+}
+//#endregion
+export { SpanContext };
+//# sourceMappingURL=span_context.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_context.d.mts","names":[],"sources":["../../src/trace/span_context.d.ts"],"mappings":";;;;;;;;UAOiB;;;;;;;EAOb;;;;;;EAMA;;;;EAIA;;;;;;;;;;;EAWA;;;;;;;;;;;;;;;;;EAiBA,aAAa"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.cjs

@@ -0,0 +1,35 @@
+//#region src/trace/span_kind.ts
+/**
+* @since 1.0.0
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+	return SpanKind;
+}({});
+//#endregion
+exports.SpanKind = SpanKind;
+
+//# sourceMappingURL=span_kind.cjs.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.cjs","names":[],"sources":["../../src/trace/span_kind.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @since 1.0.0\n */\nexport enum SpanKind {\n  /** Default value. Indicates that the span is used internally. */\n  INTERNAL = 0,\n\n  /**\n   * Indicates that the span covers server-side handling of an RPC or other\n   * remote request.\n   */\n  SERVER = 1,\n\n  /**\n   * Indicates that the span covers the client-side wrapper around an RPC or\n   * other remote request.\n   */\n  CLIENT = 2,\n\n  /**\n   * Indicates that the span describes producer sending a message to a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  PRODUCER = 3,\n\n  /**\n   * Indicates that the span describes consumer receiving a message from a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  CONSUMER = 4,\n}\n"],"mappings":";;;;AAQA,IAAY,WAAL,yBAAA,UAAA;;CAEL,SAAA,SAAA,cAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.cts

@@ -0,0 +1,33 @@
+//#region src/trace/span_kind.d.ts
+/**
+ * @since 1.0.0
+ */
+declare enum SpanKind {
+  /** Default value. Indicates that the span is used internally. */
+  INTERNAL = 0,
+  /**
+   * Indicates that the span covers server-side handling of an RPC or other
+   * remote request.
+   */
+  SERVER = 1,
+  /**
+   * Indicates that the span covers the client-side wrapper around an RPC or
+   * other remote request.
+   */
+  CLIENT = 2,
+  /**
+   * Indicates that the span describes producer sending a message to a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  PRODUCER = 3,
+  /**
+   * Indicates that the span describes consumer receiving a message from a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  CONSUMER = 4
+}
+//#endregion
+export { SpanKind };
+//# sourceMappingURL=span_kind.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.d.cts","names":[],"sources":["../../src/trace/span_kind.d.ts"],"mappings":";;;;aAGoB;;EAEhB;;;;;EAKA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.mts

@@ -0,0 +1,33 @@
+//#region src/trace/span_kind.d.ts
+/**
+ * @since 1.0.0
+ */
+declare enum SpanKind {
+  /** Default value. Indicates that the span is used internally. */
+  INTERNAL = 0,
+  /**
+   * Indicates that the span covers server-side handling of an RPC or other
+   * remote request.
+   */
+  SERVER = 1,
+  /**
+   * Indicates that the span covers the client-side wrapper around an RPC or
+   * other remote request.
+   */
+  CLIENT = 2,
+  /**
+   * Indicates that the span describes producer sending a message to a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  PRODUCER = 3,
+  /**
+   * Indicates that the span describes consumer receiving a message from a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  CONSUMER = 4
+}
+//#endregion
+export { SpanKind };
+//# sourceMappingURL=span_kind.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.d.mts","names":[],"sources":["../../src/trace/span_kind.d.ts"],"mappings":";;;;aAGoB;;EAEhB;;;;;EAKA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.mjs

@@ -0,0 +1,35 @@
+//#region src/trace/span_kind.ts
+/**
+* @since 1.0.0
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+	return SpanKind;
+}({});
+//#endregion
+export { SpanKind };
+
+//# sourceMappingURL=span_kind.mjs.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.mjs","names":[],"sources":["../../src/trace/span_kind.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @since 1.0.0\n */\nexport enum SpanKind {\n  /** Default value. Indicates that the span is used internally. */\n  INTERNAL = 0,\n\n  /**\n   * Indicates that the span covers server-side handling of an RPC or other\n   * remote request.\n   */\n  SERVER = 1,\n\n  /**\n   * Indicates that the span covers the client-side wrapper around an RPC or\n   * other remote request.\n   */\n  CLIENT = 2,\n\n  /**\n   * Indicates that the span describes producer sending a message to a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  PRODUCER = 3,\n\n  /**\n   * Indicates that the span describes consumer receiving a message from a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  CONSUMER = 4,\n}\n"],"mappings":";;;;AAQA,IAAY,WAAL,yBAAA,UAAA;;CAEL,SAAA,SAAA,cAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.cjs

@@ -0,0 +1,151 @@
+require("./invalid-span-constants.cjs");
+const require_NonRecordingSpan = require("./NonRecordingSpan.cjs");
+//#region src/trace/spancontext-utils.ts
+const isHex = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+function isValidHex(id, length) {
+	if (typeof id !== "string" || id.length !== length) return false;
+	let r = 0;
+	for (let i = 0; i < id.length; i += 4) r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+	return r === length;
+}
+/**
+* @since 1.0.0
+*/
+function isValidTraceId(traceId) {
+	return isValidHex(traceId, 32) && traceId !== "00000000000000000000000000000000";
+}
+/**
+* @since 1.0.0
+*/
+function isValidSpanId(spanId) {
+	return isValidHex(spanId, 16) && spanId !== "0000000000000000";
+}
+/**
+* Returns true if this {@link SpanContext} is valid.
+* @return true if this {@link SpanContext} is valid.
+*
+* @since 1.0.0
+*/
+function isSpanContextValid(spanContext) {
+	return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+/**
+* Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+*
+* @param spanContext span context to be wrapped
+* @returns a new non-recording {@link Span} with the provided context
+*/
+function wrapSpanContext(spanContext) {
+	return new require_NonRecordingSpan.NonRecordingSpan(spanContext);
+}
+//#endregion
+exports.isSpanContextValid = isSpanContextValid;
+exports.isValidSpanId = isValidSpanId;
+exports.isValidTraceId = isValidTraceId;
+exports.wrapSpanContext = wrapSpanContext;
+
+//# sourceMappingURL=spancontext-utils.cjs.map

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spancontext-utils.cjs","names":["NonRecordingSpan"],"sources":["../../src/trace/spancontext-utils.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { INVALID_SPANID, INVALID_TRACEID } from './invalid-span-constants';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nimport type { Span } from './span';\nimport type { SpanContext } from './span_context';\n\n// Valid characters (0-9, a-f, A-F) are marked as 1.\nconst isHex = new Uint8Array([\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,\n  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,\n]);\n\nfunction isValidHex(id: string, length: number): boolean {\n  // As of 1.9.0 the id was allowed to be a non-string value,\n  // even though it was not possible in the types.\n  if (typeof id !== 'string' || id.length !== length) return false;\n\n  let r = 0;\n  for (let i = 0; i < id.length; i += 4) {\n    r +=\n      (isHex[id.charCodeAt(i)] | 0) +\n      (isHex[id.charCodeAt(i + 1)] | 0) +\n      (isHex[id.charCodeAt(i + 2)] | 0) +\n      (isHex[id.charCodeAt(i + 3)] | 0);\n  }\n\n  return r === length;\n}\n\n/**\n * @since 1.0.0\n */\nexport function isValidTraceId(traceId: string): boolean {\n  return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;\n}\n\n/**\n * @since 1.0.0\n */\nexport function isValidSpanId(spanId: string): boolean {\n  return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;\n}\n\n/**\n * Returns true if this {@link SpanContext} is valid.\n * @return true if this {@link SpanContext} is valid.\n *\n * @since 1.0.0\n */\nexport function isSpanContextValid(spanContext: SpanContext): boolean {\n  return (\n    isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId)\n  );\n}\n\n/**\n * Wrap the given {@link SpanContext} in a new non-recording {@link Span}\n *\n * @param spanContext span context to be wrapped\n * @returns a new non-recording {@link Span} with the provided context\n */\nexport function wrapSpanContext(spanContext: SpanContext): Span {\n  return new NonRecordingSpan(spanContext);\n}\n"],"mappings":";;;AAUA,MAAM,QAAQ,IAAI,WAAW;CAC3B;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAC3E;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAC3E;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAC3E;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;CAAG;AAC1E,CAAC;AAED,SAAS,WAAW,IAAY,QAAyB;CAGvD,IAAI,OAAO,OAAO,YAAY,GAAG,WAAW,QAAQ,OAAO;CAE3D,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK,GAClC,MACG,MAAM,GAAG,WAAW,CAAC,KAAK,MAC1B,MAAM,GAAG,WAAW,IAAI,CAAC,KAAK,MAC9B,MAAM,GAAG,WAAW,IAAI,CAAC,KAAK,MAC9B,MAAM,GAAG,WAAW,IAAI,CAAC,KAAK;CAGnC,OAAO,MAAM;AACf;;;;AAKA,SAAgB,eAAe,SAA0B;CACvD,OAAO,WAAW,SAAS,EAAE,KAAK,YAAA;AACpC;;;;AAKA,SAAgB,cAAc,QAAyB;CACrD,OAAO,WAAW,QAAQ,EAAE,KAAK,WAAA;AACnC;;;;;;;AAQA,SAAgB,mBAAmB,aAAmC;CACpE,OACE,eAAe,YAAY,OAAO,KAAK,cAAc,YAAY,MAAM;AAE3E;;;;;;;AAQA,SAAgB,gBAAgB,aAAgC;CAC9D,OAAO,IAAIA,yBAAAA,iBAAiB,WAAW;AACzC"}

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.d.cts

@@ -0,0 +1,28 @@
+import { SpanContext } from "./span_context.cjs";
+import { Span } from "./span.cjs";
+//#region src/trace/spancontext-utils.d.ts
+/**
+ * @since 1.0.0
+ */
+declare function isValidTraceId(traceId: string): boolean;
+/**
+ * @since 1.0.0
+ */
+declare function isValidSpanId(spanId: string): boolean;
+/**
+ * Returns true if this {@link SpanContext} is valid.
+ * @return true if this {@link SpanContext} is valid.
+ *
+ * @since 1.0.0
+ */
+declare function isSpanContextValid(spanContext: SpanContext): boolean;
+/**
+ * Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+ *
+ * @param spanContext span context to be wrapped
+ * @returns a new non-recording {@link Span} with the provided context
+ */
+declare function wrapSpanContext(spanContext: SpanContext): Span;
+//#endregion
+export { isSpanContextValid, isValidSpanId, isValidTraceId, wrapSpanContext };
+//# sourceMappingURL=spancontext-utils.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spancontext-utils.d.cts","names":[],"sources":["../../src/trace/spancontext-utils.d.ts"],"mappings":";;;;;;iBAKwB,eAAe;;;;iBAIf,cAAc;;;;;;;iBAOd,mBAAmB,aAAa;;;;;;;iBAOhC,gBAAgB,aAAa,cAAc"}

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.d.mts

@@ -0,0 +1,28 @@
+import { SpanContext } from "./span_context.mjs";
+import { Span } from "./span.mjs";
+//#region src/trace/spancontext-utils.d.ts
+/**
+ * @since 1.0.0
+ */
+declare function isValidTraceId(traceId: string): boolean;
+/**
+ * @since 1.0.0
+ */
+declare function isValidSpanId(spanId: string): boolean;
+/**
+ * Returns true if this {@link SpanContext} is valid.
+ * @return true if this {@link SpanContext} is valid.
+ *
+ * @since 1.0.0
+ */
+declare function isSpanContextValid(spanContext: SpanContext): boolean;
+/**
+ * Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+ *
+ * @param spanContext span context to be wrapped
+ * @returns a new non-recording {@link Span} with the provided context
+ */
+declare function wrapSpanContext(spanContext: SpanContext): Span;
+//#endregion
+export { isSpanContextValid, isValidSpanId, isValidTraceId, wrapSpanContext };
+//# sourceMappingURL=spancontext-utils.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/spancontext-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spancontext-utils.d.mts","names":[],"sources":["../../src/trace/spancontext-utils.d.ts"],"mappings":";;;;;;iBAKwB,eAAe;;;;iBAIf,cAAc;;;;;;;iBAOd,mBAAmB,aAAa;;;;;;;iBAOhC,gBAAgB,aAAa,cAAc"}