@eventuras/logger 0.7.0

package/dist/esm-wJpbN37y.js

@@ -0,0 +1,528 @@
+import { A as e, C as t, E as n, O as r, S as i, T as a, _ as o, a as s, b as c, c as l, d as u, f as d, g as f, h as p, i as m, j as h, k as g, l as _, m as v, n as y, o as b, p as x, r as S, s as C, u as w, v as T } from "./esm-B1-Y8LUx.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+resources@2.6.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/esm/default-service-name.js
+var E;
+function D() {
+	if (E === void 0) try {
+		let e = globalThis.process.argv0;
+		E = e ? `unknown_service:${e}` : "unknown_service";
+	} catch {
+		E = "unknown_service";
+	}
+	return E;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+resources@2.6.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/esm/utils.js
+var O = (e) => typeof e == "object" && !!e && typeof e.then == "function";
+a(), y(), w();
+var k = class e {
+	_rawAttributes;
+	_asyncAttributesPending = !1;
+	_schemaUrl;
+	_memoizedAttributes;
+	static FromAttributeList(t, n) {
+		let r = new e({}, n);
+		return r._rawAttributes = M(t), r._asyncAttributesPending = t.filter(([e, t]) => O(t)).length > 0, r;
+	}
+	constructor(e, t) {
+		let n = e.attributes ?? {};
+		this._rawAttributes = Object.entries(n).map(([e, t]) => (O(t) && (this._asyncAttributesPending = !0), [e, t])), this._rawAttributes = M(this._rawAttributes), this._schemaUrl = N(t?.schemaUrl);
+	}
+	get asyncAttributesPending() {
+		return this._asyncAttributesPending;
+	}
+	async waitForAsyncAttributes() {
+		if (this.asyncAttributesPending) {
+			for (let e = 0; e < this._rawAttributes.length; e++) {
+				let [t, n] = this._rawAttributes[e];
+				this._rawAttributes[e] = [t, O(n) ? await n : n];
+			}
+			this._asyncAttributesPending = !1;
+		}
+	}
+	get attributes() {
+		if (this.asyncAttributesPending && r.error("Accessing resource attributes before async attributes settled"), this._memoizedAttributes) return this._memoizedAttributes;
+		let e = {};
+		for (let [t, n] of this._rawAttributes) {
+			if (O(n)) {
+				r.debug(`Unsettled resource attribute ${t} skipped`);
+				continue;
+			}
+			n != null && (e[t] ??= n);
+		}
+		return this._asyncAttributesPending || (this._memoizedAttributes = e), e;
+	}
+	getRawAttributes() {
+		return this._rawAttributes;
+	}
+	get schemaUrl() {
+		return this._schemaUrl;
+	}
+	merge(t) {
+		if (t == null) return this;
+		let n = P(this, t), r = n ? { schemaUrl: n } : void 0;
+		return e.FromAttributeList([...t.getRawAttributes(), ...this.getRawAttributes()], r);
+	}
+};
+function A(e, t) {
+	return k.FromAttributeList(Object.entries(e), t);
+}
+function j() {
+	return A({
+		[v]: D(),
+		[p]: _[p],
+		[f]: _[f],
+		[o]: _[o]
+	});
+}
+function M(e) {
+	return e.map(([e, t]) => O(t) ? [e, t.catch((t) => {
+		r.debug("promise rejection for resource attribute: %s - %s", e, t);
+	})] : [e, t]);
+}
+function N(e) {
+	if (typeof e == "string" || e === void 0) return e;
+	r.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", e);
+}
+function P(e, t) {
+	let n = e?.schemaUrl, i = t?.schemaUrl, a = n === void 0 || n === "", o = i === void 0 || i === "";
+	if (a) return i;
+	if (o || n === i) return n;
+	r.warn("Schema URL merge conflict: old resource has \"%s\", updating resource has \"%s\". Resulting resource will have undefined Schema URL.", n, i);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/utils/validation.js
+c();
+function F(e) {
+	return I(e, /* @__PURE__ */ new WeakSet());
+}
+function I(e, t) {
+	if (e == null || typeof e == "string" || typeof e == "number" || typeof e == "boolean" || e instanceof Uint8Array) return !0;
+	if (typeof e == "object") {
+		if (t.has(e)) return !1;
+		if (t.add(e), Array.isArray(e)) return e.every((e) => I(e, t));
+		let n = e;
+		return n.constructor !== Object && n.constructor !== void 0 ? !1 : Object.values(n).every((e) => I(e, t));
+	}
+	return !1;
+}
+a(), y(), w();
+var L = class {
+	hrTime;
+	hrTimeObserved;
+	spanContext;
+	resource;
+	instrumentationScope;
+	attributes = {};
+	_severityText;
+	_severityNumber;
+	_body;
+	_eventName;
+	_attributesCount = 0;
+	_droppedAttributesCount = 0;
+	_isReadonly = !1;
+	_logRecordLimits;
+	set severityText(e) {
+		this._isLogRecordReadonly() || (this._severityText = e);
+	}
+	get severityText() {
+		return this._severityText;
+	}
+	set severityNumber(e) {
+		this._isLogRecordReadonly() || (this._severityNumber = e);
+	}
+	get severityNumber() {
+		return this._severityNumber;
+	}
+	set body(e) {
+		this._isLogRecordReadonly() || (this._body = e);
+	}
+	get body() {
+		return this._body;
+	}
+	get eventName() {
+		return this._eventName;
+	}
+	set eventName(e) {
+		this._isLogRecordReadonly() || (this._eventName = e);
+	}
+	get droppedAttributesCount() {
+		return this._droppedAttributesCount;
+	}
+	constructor(t, r, i) {
+		let { timestamp: a, observedTimestamp: o, eventName: s, severityNumber: c, severityText: u, body: d, attributes: f = {}, exception: p, context: m } = i, h = Date.now();
+		if (this.hrTime = l(a ?? h), this.hrTimeObserved = l(o ?? h), m) {
+			let t = n.getSpanContext(m);
+			t && e(t) && (this.spanContext = t);
+		}
+		this.severityNumber = c, this.severityText = u, this.body = d, this.resource = t.resource, this.instrumentationScope = r, this._logRecordLimits = t.logRecordLimits, this._eventName = s, this.setAttributes(f), p != null && this._setException(p);
+	}
+	setAttribute(e, t) {
+		if (this._isLogRecordReadonly()) return this;
+		if (e.length === 0) return r.warn(`Invalid attribute key: ${e}`), this;
+		if (!F(t)) return r.warn(`Invalid attribute value set for key: ${e}`), this;
+		let n = !Object.prototype.hasOwnProperty.call(this.attributes, e);
+		return n && this._attributesCount >= this._logRecordLimits.attributeCountLimit ? (this._droppedAttributesCount++, this._droppedAttributesCount === 1 && r.warn("Dropping extra attributes."), this) : (this.attributes[e] = this._truncateToSize(t), n && this._attributesCount++, this);
+	}
+	setAttributes(e) {
+		for (let [t, n] of Object.entries(e)) this.setAttribute(t, n);
+		return this;
+	}
+	setBody(e) {
+		return this.body = e, this;
+	}
+	setEventName(e) {
+		return this.eventName = e, this;
+	}
+	setSeverityNumber(e) {
+		return this.severityNumber = e, this;
+	}
+	setSeverityText(e) {
+		return this.severityText = e, this;
+	}
+	_makeReadonly() {
+		this._isReadonly = !0;
+	}
+	_truncateToSize(e) {
+		let t = this._logRecordLimits.attributeValueLengthLimit;
+		if (t <= 0) return r.warn(`Attribute value limit must be positive, got ${t}`), e;
+		if (e == null) return e;
+		if (typeof e == "string") return this._truncateToLimitUtil(e, t);
+		if (e instanceof Uint8Array) return e;
+		if (Array.isArray(e)) return e.map((e) => this._truncateToSize(e));
+		if (typeof e == "object") {
+			let t = {};
+			for (let [n, r] of Object.entries(e)) t[n] = this._truncateToSize(r);
+			return t;
+		}
+		return e;
+	}
+	_setException(e) {
+		let t = !1;
+		if (typeof e == "string" || typeof e == "number") Object.hasOwn(this.attributes, "exception.message") || this.setAttribute(u, String(e)), t = !0;
+		else if (e && typeof e == "object") {
+			let n = e;
+			n.code ? (Object.hasOwn(this.attributes, "exception.type") || this.setAttribute(x, n.code.toString()), t = !0) : n.name && (Object.hasOwn(this.attributes, "exception.type") || this.setAttribute(x, n.name), t = !0), n.message && (Object.hasOwn(this.attributes, "exception.message") || this.setAttribute(u, n.message), t = !0), n.stack && (Object.hasOwn(this.attributes, "exception.stacktrace") || this.setAttribute(d, n.stack), t = !0);
+		}
+		t || r.warn(`Failed to record an exception ${e}`);
+	}
+	_truncateToLimitUtil(e, t) {
+		return e.length <= t ? e : e.substring(0, t);
+	}
+	_isLogRecordReadonly() {
+		return this._isReadonly && r.warn("Can not execute the operation on emitted log record"), this._isReadonly;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/Logger.js
+a();
+var R = class {
+	instrumentationScope;
+	_sharedState;
+	_loggerConfig;
+	constructor(e, t) {
+		this.instrumentationScope = e, this._sharedState = t, this._loggerConfig = this._sharedState.getLoggerConfig(this.instrumentationScope);
+	}
+	emit(r) {
+		let i = this._loggerConfig, a = r.context || g.active(), o = r.severityNumber ?? t.UNSPECIFIED;
+		if (o !== t.UNSPECIFIED && o < i.minimumSeverity) return;
+		if (i.traceBased) {
+			let t = n.getSpanContext(a);
+			if (t && e(t) && (t.traceFlags & h.SAMPLED) !== h.SAMPLED) return;
+		}
+		let s = new L(this._sharedState, this.instrumentationScope, {
+			context: a,
+			...r
+		});
+		this._sharedState.activeProcessor.onEmit(s, a), s._makeReadonly();
+	}
+}, z = class {
+	forceFlush() {
+		return Promise.resolve();
+	}
+	onEmit(e, t) {}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/MultiLogRecordProcessor.js
+y();
+var B = class {
+	processors;
+	forceFlushTimeoutMillis;
+	constructor(e, t) {
+		this.processors = e, this.forceFlushTimeoutMillis = t;
+	}
+	async forceFlush() {
+		let e = this.forceFlushTimeoutMillis;
+		await Promise.all(this.processors.map((t) => s(t.forceFlush(), e)));
+	}
+	onEmit(e, t) {
+		this.processors.forEach((n) => n.onEmit(e, t));
+	}
+	async shutdown() {
+		await Promise.all(this.processors.map((e) => e.shutdown()));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/internal/utils.js
+function V(e) {
+	return `${e.name}@${e.version || ""}:${e.schemaUrl || ""}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/internal/LoggerProviderSharedState.js
+c();
+var H = {
+	disabled: !1,
+	minimumSeverity: t.UNSPECIFIED,
+	traceBased: !1
+}, U = () => ({ ...H }), W = class {
+	loggers = /* @__PURE__ */ new Map();
+	activeProcessor;
+	registeredLogRecordProcessors = [];
+	resource;
+	forceFlushTimeoutMillis;
+	logRecordLimits;
+	processors;
+	_loggerConfigurator;
+	_loggerConfigs = /* @__PURE__ */ new Map();
+	constructor(e, t, n, r, i) {
+		this.resource = e, this.forceFlushTimeoutMillis = t, this.logRecordLimits = n, this.processors = r, r.length > 0 ? (this.registeredLogRecordProcessors = r, this.activeProcessor = new B(this.registeredLogRecordProcessors, this.forceFlushTimeoutMillis)) : this.activeProcessor = new z(), this._loggerConfigurator = i ?? U;
+	}
+	getLoggerConfig(e) {
+		let t = V(e), n = this._loggerConfigs.get(t);
+		return n || (n = this._loggerConfigurator(e), this._loggerConfigs.set(t, n), n);
+	}
+};
+a(), c(), y();
+var G = class {
+	_shutdownOnce;
+	_sharedState;
+	constructor(e = {}) {
+		let t = {
+			resource: e.resource ?? j(),
+			forceFlushTimeoutMillis: e.forceFlushTimeoutMillis ?? 3e4,
+			logRecordLimits: {
+				attributeCountLimit: e.logRecordLimits?.attributeCountLimit ?? 128,
+				attributeValueLengthLimit: e.logRecordLimits?.attributeValueLengthLimit ?? Infinity
+			},
+			loggerConfigurator: e.loggerConfigurator ?? U,
+			processors: e.processors ?? []
+		};
+		this._sharedState = new W(t.resource, t.forceFlushTimeoutMillis, t.logRecordLimits, t.processors, t.loggerConfigurator), this._shutdownOnce = new m(this._shutdown, this);
+	}
+	getLogger(e, t, n) {
+		if (this._shutdownOnce.isCalled) return r.warn("A shutdown LoggerProvider cannot provide a Logger"), i;
+		e || r.warn("Logger requested without instrumentation scope name.");
+		let a = e || "unknown", o = `${a}@${t || ""}:${n?.schemaUrl || ""}`;
+		return this._sharedState.loggers.has(o) || this._sharedState.loggers.set(o, new R({
+			name: a,
+			version: t,
+			schemaUrl: n?.schemaUrl
+		}, this._sharedState)), this._sharedState.loggers.get(o);
+	}
+	forceFlush() {
+		return this._shutdownOnce.isCalled ? (r.warn("invalid attempt to force flush after LoggerProvider shutdown"), this._shutdownOnce.promise) : this._sharedState.activeProcessor.forceFlush();
+	}
+	shutdown() {
+		return this._shutdownOnce.isCalled ? (r.warn("shutdown may only be called once per LoggerProvider"), this._shutdownOnce.promise) : this._shutdownOnce.call();
+	}
+	_shutdown() {
+		return this._sharedState.activeProcessor.shutdown();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/export/ConsoleLogRecordExporter.js
+y();
+var K = class {
+	export(e, t) {
+		this._sendLogRecords(e, t);
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+	_exportInfo(e) {
+		return {
+			resource: { attributes: e.resource.attributes },
+			instrumentationScope: e.instrumentationScope,
+			timestamp: C(e.hrTime),
+			traceId: e.spanContext?.traceId,
+			spanId: e.spanContext?.spanId,
+			traceFlags: e.spanContext?.traceFlags,
+			severityText: e.severityText,
+			severityNumber: e.severityNumber,
+			eventName: e.eventName,
+			body: e.body,
+			attributes: e.attributes
+		};
+	}
+	_sendLogRecords(e, t) {
+		for (let t of e) console.dir(this._exportInfo(t), { depth: 3 });
+		t?.({ code: b.SUCCESS });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/export/SimpleLogRecordProcessor.js
+y();
+var q = class {
+	_exporter;
+	_shutdownOnce;
+	_unresolvedExports;
+	constructor(e) {
+		this._exporter = e, this._shutdownOnce = new m(this._shutdown, this), this._unresolvedExports = /* @__PURE__ */ new Set();
+	}
+	onEmit(e) {
+		if (this._shutdownOnce.isCalled) return;
+		let t = () => S._export(this._exporter, [e]).then((e) => {
+			e.code !== b.SUCCESS && T(e.error ?? /* @__PURE__ */ Error(`SimpleLogRecordProcessor: log record export failed (status ${e})`));
+		}).catch(T);
+		if (e.resource.asyncAttributesPending) {
+			let n = e.resource.waitForAsyncAttributes?.().then(() => (this._unresolvedExports.delete(n), t()), T);
+			n != null && this._unresolvedExports.add(n);
+		} else t();
+	}
+	async forceFlush() {
+		await Promise.all(Array.from(this._unresolvedExports));
+	}
+	shutdown() {
+		return this._shutdownOnce.call();
+	}
+	_shutdown() {
+		return this._exporter.shutdown();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/export/InMemoryLogRecordExporter.js
+y();
+var J = class {
+	_finishedLogRecords = [];
+	_stopped = !1;
+	export(e, t) {
+		if (this._stopped) return t({
+			code: b.FAILED,
+			error: /* @__PURE__ */ Error("Exporter has been stopped")
+		});
+		this._finishedLogRecords.push(...e), t({ code: b.SUCCESS });
+	}
+	shutdown() {
+		return this._stopped = !0, this.reset(), Promise.resolve();
+	}
+	getFinishedLogRecords() {
+		return this._finishedLogRecords;
+	}
+	reset() {
+		this._finishedLogRecords = [];
+	}
+};
+a(), y();
+var Y = class {
+	_maxExportBatchSize;
+	_maxQueueSize;
+	_scheduledDelayMillis;
+	_exportTimeoutMillis;
+	_exporter;
+	_isExporting = !1;
+	_finishedLogRecords = [];
+	_timer;
+	_shutdownOnce;
+	constructor(e, t) {
+		this._exporter = e, this._maxExportBatchSize = t?.maxExportBatchSize ?? 512, this._maxQueueSize = t?.maxQueueSize ?? 2048, this._scheduledDelayMillis = t?.scheduledDelayMillis ?? 5e3, this._exportTimeoutMillis = t?.exportTimeoutMillis ?? 3e4, this._shutdownOnce = new m(this._shutdown, this), this._maxExportBatchSize > this._maxQueueSize && (r.warn("BatchLogRecordProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize"), this._maxExportBatchSize = this._maxQueueSize);
+	}
+	onEmit(e) {
+		this._shutdownOnce.isCalled || this._addToBuffer(e);
+	}
+	forceFlush() {
+		return this._shutdownOnce.isCalled ? this._shutdownOnce.promise : this._flushAll();
+	}
+	shutdown() {
+		return this._shutdownOnce.call();
+	}
+	async _shutdown() {
+		this.onShutdown(), await this._flushAll(), await this._exporter.shutdown();
+	}
+	_addToBuffer(e) {
+		this._finishedLogRecords.length >= this._maxQueueSize || (this._finishedLogRecords.push(e), this._maybeStartTimer());
+	}
+	_flushAll() {
+		return new Promise((e, t) => {
+			let n = [], r = Math.ceil(this._finishedLogRecords.length / this._maxExportBatchSize);
+			for (let e = 0; e < r; e++) n.push(this._flushOneBatch());
+			Promise.all(n).then(() => {
+				e();
+			}).catch(t);
+		});
+	}
+	_flushOneBatch() {
+		return this._clearTimer(), this._finishedLogRecords.length === 0 ? Promise.resolve() : s(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis);
+	}
+	_maybeStartTimer() {
+		if (this._isExporting) return;
+		let e = () => {
+			this._isExporting = !0, this._flushOneBatch().then(() => {
+				this._isExporting = !1, this._finishedLogRecords.length > 0 && (this._clearTimer(), this._maybeStartTimer());
+			}).catch((e) => {
+				this._isExporting = !1, T(e);
+			});
+		};
+		if (this._finishedLogRecords.length >= this._maxExportBatchSize) return e();
+		this._timer === void 0 && (this._timer = setTimeout(() => e(), this._scheduledDelayMillis), typeof this._timer != "number" && this._timer.unref());
+	}
+	_clearTimer() {
+		this._timer !== void 0 && (clearTimeout(this._timer), this._timer = void 0);
+	}
+	_export(e) {
+		let t = () => S._export(this._exporter, e).then((e) => {
+			e.code !== b.SUCCESS && T(e.error ?? /* @__PURE__ */ Error(`BatchLogRecordProcessor: log record export failed (status ${e})`));
+		}).catch(T), n = [];
+		for (let t = 0; t < e.length; t++) {
+			let r = e[t].resource;
+			r.asyncAttributesPending && typeof r.waitForAsyncAttributes == "function" && n.push(r.waitForAsyncAttributes());
+		}
+		return n.length === 0 ? t() : Promise.all(n).then(t, T);
+	}
+}, X = class extends Y {
+	_visibilityChangeListener;
+	_pageHideListener;
+	constructor(e, t) {
+		super(e, t), this._onInit(t);
+	}
+	onShutdown() {
+		typeof document > "u" || (this._visibilityChangeListener && document.removeEventListener("visibilitychange", this._visibilityChangeListener), this._pageHideListener && document.removeEventListener("pagehide", this._pageHideListener));
+	}
+	_onInit(e) {
+		e?.disableAutoFlushOnDocumentHide === !0 || typeof document > "u" || (this._visibilityChangeListener = () => {
+			document.visibilityState === "hidden" && this.forceFlush();
+		}, this._pageHideListener = () => {
+			this.forceFlush();
+		}, document.addEventListener("visibilitychange", this._visibilityChangeListener), document.addEventListener("pagehide", this._pageHideListener));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-logs@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-logs/build/esm/config/LoggerConfigurators.js
+c();
+var Z = {
+	disabled: !1,
+	minimumSeverity: t.UNSPECIFIED,
+	traceBased: !1
+};
+function Q(e) {
+	return (t) => {
+		let n = t.name;
+		for (let { pattern: t, config: r } of e) if ($(n, t)) return {
+			disabled: r.disabled ?? Z.disabled,
+			minimumSeverity: r.minimumSeverity ?? Z.minimumSeverity,
+			traceBased: r.traceBased ?? Z.traceBased
+		};
+		return { ...Z };
+	};
+}
+function $(e, t) {
+	if (t === e) return !0;
+	if (t.includes("*")) {
+		let n = t.split("*").map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+		return RegExp(`^${n}$`).test(e);
+	}
+	return !1;
+}
+//#endregion
+export { X as BatchLogRecordProcessor, K as ConsoleLogRecordExporter, J as InMemoryLogRecordExporter, G as LoggerProvider, q as SimpleLogRecordProcessor, Q as createLoggerConfigurator };

package/dist/httpLogger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP logging utilities for API clients.
+ * Provides header redaction for structured logging.
+ */
+/**
+ * Redact sensitive headers for logging.
+ * Use with logger.debug/info/error to safely log HTTP headers.
+ *
+ * @example
+ * logger.debug({
+ *   request: {
+ *     url: '/api/users',
+ *     headers: redactHeaders(headers)
+ *   }
+ * }, 'HTTP request');
+ */
+export declare function redactHeaders(headers: Headers | Record<string, unknown> | [string, string][]): Record<string, string>;
+//# sourceMappingURL=httpLogger.d.ts.map

package/dist/httpLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpLogger.d.ts","sourceRoot":"","sources":["../src/httpLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAC9D,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkBxB"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Logger } from './Logger';
+export type { LoggerOptions, ErrorLoggerOptions, LoggerConfig, LogLevel, LogTransport } from './types';
+export { PinoTransport, type PinoTransportOptions } from './transports/pino';
+export { ConsoleTransport } from './transports/console';
+export { redactHeaders } from './httpLogger';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGvG,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}