snake-ai-game
Version:
A terminal-based snake game powered by AI.
1,340 lines (1,265 loc) • 999 kB
JavaScript
#!/usr/bin/env node
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
var require_globalThis = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports._globalThis = undefined;
exports._globalThis = typeof globalThis === "object" ? globalThis : global;
});
// node_modules/@opentelemetry/api/build/src/platform/node/index.js
var require_node = __commonJS((exports) => {
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
__createBinding(exports2, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require_globalThis(), exports);
});
// node_modules/@opentelemetry/api/build/src/platform/index.js
var require_platform = __commonJS((exports) => {
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
__createBinding(exports2, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require_node(), exports);
});
// node_modules/@opentelemetry/api/build/src/version.js
var require_version = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.VERSION = undefined;
exports.VERSION = "1.9.0";
});
// node_modules/@opentelemetry/api/build/src/internal/semver.js
var require_semver = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.isCompatible = exports._makeCompatibilityCheck = undefined;
var version_1 = require_version();
var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
function _makeCompatibilityCheck(ownVersion) {
const acceptedVersions = new Set([ownVersion]);
const rejectedVersions = new Set;
const myVersionMatch = ownVersion.match(re);
if (!myVersionMatch) {
return () => false;
}
const ownVersionParsed = {
major: +myVersionMatch[1],
minor: +myVersionMatch[2],
patch: +myVersionMatch[3],
prerelease: myVersionMatch[4]
};
if (ownVersionParsed.prerelease != null) {
return function isExactmatch(globalVersion) {
return globalVersion === ownVersion;
};
}
function _reject(v) {
rejectedVersions.add(v);
return false;
}
function _accept(v) {
acceptedVersions.add(v);
return true;
}
return function isCompatible(globalVersion) {
if (acceptedVersions.has(globalVersion)) {
return true;
}
if (rejectedVersions.has(globalVersion)) {
return false;
}
const globalVersionMatch = globalVersion.match(re);
if (!globalVersionMatch) {
return _reject(globalVersion);
}
const globalVersionParsed = {
major: +globalVersionMatch[1],
minor: +globalVersionMatch[2],
patch: +globalVersionMatch[3],
prerelease: globalVersionMatch[4]
};
if (globalVersionParsed.prerelease != null) {
return _reject(globalVersion);
}
if (ownVersionParsed.major !== globalVersionParsed.major) {
return _reject(globalVersion);
}
if (ownVersionParsed.major === 0) {
if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
return _accept(globalVersion);
}
return _reject(globalVersion);
}
if (ownVersionParsed.minor <= globalVersionParsed.minor) {
return _accept(globalVersion);
}
return _reject(globalVersion);
};
}
exports._makeCompatibilityCheck = _makeCompatibilityCheck;
exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
});
// node_modules/@opentelemetry/api/build/src/internal/global-utils.js
var require_global_utils = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = undefined;
var platform_1 = require_platform();
var version_1 = require_version();
var semver_1 = require_semver();
var major = version_1.VERSION.split(".")[0];
var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
var _global = platform_1._globalThis;
function registerGlobal(type, instance, diag, allowOverride = false) {
var _a15;
const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a15 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a15 !== undefined ? _a15 : {
version: version_1.VERSION
};
if (!allowOverride && api2[type]) {
const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
diag.error(err.stack || err.message);
return false;
}
if (api2.version !== version_1.VERSION) {
const err = new Error(`@opentelemetry/api: Registration of version v${api2.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
diag.error(err.stack || err.message);
return false;
}
api2[type] = instance;
diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`);
return true;
}
exports.registerGlobal = registerGlobal;
function getGlobal(type) {
var _a15, _b;
const globalVersion = (_a15 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a15 === undefined ? undefined : _a15.version;
if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
return;
}
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === undefined ? undefined : _b[type];
}
exports.getGlobal = getGlobal;
function unregisterGlobal(type, diag) {
diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY];
if (api2) {
delete api2[type];
}
}
exports.unregisterGlobal = unregisterGlobal;
});
// node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
var require_ComponentLogger = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiagComponentLogger = undefined;
var global_utils_1 = require_global_utils();
class DiagComponentLogger {
constructor(props) {
this._namespace = props.namespace || "DiagComponentLogger";
}
debug(...args) {
return logProxy("debug", this._namespace, args);
}
error(...args) {
return logProxy("error", this._namespace, args);
}
info(...args) {
return logProxy("info", this._namespace, args);
}
warn(...args) {
return logProxy("warn", this._namespace, args);
}
verbose(...args) {
return logProxy("verbose", this._namespace, args);
}
}
exports.DiagComponentLogger = DiagComponentLogger;
function logProxy(funcName, namespace, args) {
const logger = (0, global_utils_1.getGlobal)("diag");
if (!logger) {
return;
}
args.unshift(namespace);
return logger[funcName](...args);
}
});
// node_modules/@opentelemetry/api/build/src/diag/types.js
var require_types = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiagLogLevel = undefined;
var DiagLogLevel;
(function(DiagLogLevel2) {
DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
})(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {}));
});
// node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
var require_logLevelLogger = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createLogLevelDiagLogger = undefined;
var types_1 = require_types();
function createLogLevelDiagLogger(maxLevel, logger) {
if (maxLevel < types_1.DiagLogLevel.NONE) {
maxLevel = types_1.DiagLogLevel.NONE;
} else if (maxLevel > types_1.DiagLogLevel.ALL) {
maxLevel = types_1.DiagLogLevel.ALL;
}
logger = logger || {};
function _filterFunc(funcName, theLevel) {
const theFunc = logger[funcName];
if (typeof theFunc === "function" && maxLevel >= theLevel) {
return theFunc.bind(logger);
}
return function() {};
}
return {
error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
info: _filterFunc("info", types_1.DiagLogLevel.INFO),
debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
};
}
exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
});
// node_modules/@opentelemetry/api/build/src/api/diag.js
var require_diag = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiagAPI = undefined;
var ComponentLogger_1 = require_ComponentLogger();
var logLevelLogger_1 = require_logLevelLogger();
var types_1 = require_types();
var global_utils_1 = require_global_utils();
var API_NAME = "diag";
class DiagAPI {
constructor() {
function _logProxy(funcName) {
return function(...args) {
const logger = (0, global_utils_1.getGlobal)("diag");
if (!logger)
return;
return logger[funcName](...args);
};
}
const self = this;
const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
var _a15, _b, _c;
if (logger === self) {
const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
self.error((_a15 = err.stack) !== null && _a15 !== undefined ? _a15 : err.message);
return false;
}
if (typeof optionsOrLogLevel === "number") {
optionsOrLogLevel = {
logLevel: optionsOrLogLevel
};
}
const oldLogger = (0, global_utils_1.getGlobal)("diag");
const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== undefined ? _b : types_1.DiagLogLevel.INFO, logger);
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
const stack = (_c = new Error().stack) !== null && _c !== undefined ? _c : "<failed to generate stacktrace>";
oldLogger.warn(`Current logger will be overwritten from ${stack}`);
newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
}
return (0, global_utils_1.registerGlobal)("diag", newLogger, self, true);
};
self.setLogger = setLogger;
self.disable = () => {
(0, global_utils_1.unregisterGlobal)(API_NAME, self);
};
self.createComponentLogger = (options) => {
return new ComponentLogger_1.DiagComponentLogger(options);
};
self.verbose = _logProxy("verbose");
self.debug = _logProxy("debug");
self.info = _logProxy("info");
self.warn = _logProxy("warn");
self.error = _logProxy("error");
}
static instance() {
if (!this._instance) {
this._instance = new DiagAPI;
}
return this._instance;
}
}
exports.DiagAPI = DiagAPI;
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
var require_baggage_impl = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaggageImpl = undefined;
class BaggageImpl {
constructor(entries) {
this._entries = entries ? new Map(entries) : new Map;
}
getEntry(key) {
const entry = this._entries.get(key);
if (!entry) {
return;
}
return Object.assign({}, entry);
}
getAllEntries() {
return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
}
setEntry(key, entry) {
const newBaggage = new BaggageImpl(this._entries);
newBaggage._entries.set(key, entry);
return newBaggage;
}
removeEntry(key) {
const newBaggage = new BaggageImpl(this._entries);
newBaggage._entries.delete(key);
return newBaggage;
}
removeEntries(...keys) {
const newBaggage = new BaggageImpl(this._entries);
for (const key of keys) {
newBaggage._entries.delete(key);
}
return newBaggage;
}
clear() {
return new BaggageImpl;
}
}
exports.BaggageImpl = BaggageImpl;
});
// node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
var require_symbol = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.baggageEntryMetadataSymbol = undefined;
exports.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
});
// node_modules/@opentelemetry/api/build/src/baggage/utils.js
var require_utils = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.baggageEntryMetadataFromString = exports.createBaggage = undefined;
var diag_1 = require_diag();
var baggage_impl_1 = require_baggage_impl();
var symbol_1 = require_symbol();
var diag = diag_1.DiagAPI.instance();
function createBaggage(entries = {}) {
return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
}
exports.createBaggage = createBaggage;
function baggageEntryMetadataFromString(str) {
if (typeof str !== "string") {
diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
str = "";
}
return {
__TYPE__: symbol_1.baggageEntryMetadataSymbol,
toString() {
return str;
}
};
}
exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
});
// node_modules/@opentelemetry/api/build/src/context/context.js
var require_context = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ROOT_CONTEXT = exports.createContextKey = undefined;
function createContextKey(description) {
return Symbol.for(description);
}
exports.createContextKey = createContextKey;
class BaseContext {
constructor(parentContext) {
const self = this;
self._currentContext = parentContext ? new Map(parentContext) : new Map;
self.getValue = (key) => self._currentContext.get(key);
self.setValue = (key, value) => {
const context = new BaseContext(self._currentContext);
context._currentContext.set(key, value);
return context;
};
self.deleteValue = (key) => {
const context = new BaseContext(self._currentContext);
context._currentContext.delete(key);
return context;
};
}
}
exports.ROOT_CONTEXT = new BaseContext;
});
// node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
var require_consoleLogger = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiagConsoleLogger = undefined;
var consoleMap = [
{ n: "error", c: "error" },
{ n: "warn", c: "warn" },
{ n: "info", c: "info" },
{ n: "debug", c: "debug" },
{ n: "verbose", c: "trace" }
];
class DiagConsoleLogger {
constructor() {
function _consoleFunc(funcName) {
return function(...args) {
if (console) {
let theFunc = console[funcName];
if (typeof theFunc !== "function") {
theFunc = console.log;
}
if (typeof theFunc === "function") {
return theFunc.apply(console, args);
}
}
};
}
for (let i = 0;i < consoleMap.length; i++) {
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
}
}
}
exports.DiagConsoleLogger = DiagConsoleLogger;
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
var require_NoopMeter = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_GAUGE_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopGaugeMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = undefined;
class NoopMeter {
constructor() {}
createGauge(_name, _options) {
return exports.NOOP_GAUGE_METRIC;
}
createHistogram(_name, _options) {
return exports.NOOP_HISTOGRAM_METRIC;
}
createCounter(_name, _options) {
return exports.NOOP_COUNTER_METRIC;
}
createUpDownCounter(_name, _options) {
return exports.NOOP_UP_DOWN_COUNTER_METRIC;
}
createObservableGauge(_name, _options) {
return exports.NOOP_OBSERVABLE_GAUGE_METRIC;
}
createObservableCounter(_name, _options) {
return exports.NOOP_OBSERVABLE_COUNTER_METRIC;
}
createObservableUpDownCounter(_name, _options) {
return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
}
addBatchObservableCallback(_callback, _observables) {}
removeBatchObservableCallback(_callback) {}
}
exports.NoopMeter = NoopMeter;
class NoopMetric {
}
exports.NoopMetric = NoopMetric;
class NoopCounterMetric extends NoopMetric {
add(_value, _attributes) {}
}
exports.NoopCounterMetric = NoopCounterMetric;
class NoopUpDownCounterMetric extends NoopMetric {
add(_value, _attributes) {}
}
exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
class NoopGaugeMetric extends NoopMetric {
record(_value, _attributes) {}
}
exports.NoopGaugeMetric = NoopGaugeMetric;
class NoopHistogramMetric extends NoopMetric {
record(_value, _attributes) {}
}
exports.NoopHistogramMetric = NoopHistogramMetric;
class NoopObservableMetric {
addCallback(_callback) {}
removeCallback(_callback) {}
}
exports.NoopObservableMetric = NoopObservableMetric;
class NoopObservableCounterMetric extends NoopObservableMetric {
}
exports.NoopObservableCounterMetric = NoopObservableCounterMetric;
class NoopObservableGaugeMetric extends NoopObservableMetric {
}
exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
}
exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
exports.NOOP_METER = new NoopMeter;
exports.NOOP_COUNTER_METRIC = new NoopCounterMetric;
exports.NOOP_GAUGE_METRIC = new NoopGaugeMetric;
exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric;
exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric;
exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric;
exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric;
exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric;
function createNoopMeter() {
return exports.NOOP_METER;
}
exports.createNoopMeter = createNoopMeter;
});
// node_modules/@opentelemetry/api/build/src/metrics/Metric.js
var require_Metric = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueType = undefined;
var ValueType;
(function(ValueType2) {
ValueType2[ValueType2["INT"] = 0] = "INT";
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
})(ValueType = exports.ValueType || (exports.ValueType = {}));
});
// node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
var require_TextMapPropagator = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultTextMapSetter = exports.defaultTextMapGetter = undefined;
exports.defaultTextMapGetter = {
get(carrier, key) {
if (carrier == null) {
return;
}
return carrier[key];
},
keys(carrier) {
if (carrier == null) {
return [];
}
return Object.keys(carrier);
}
};
exports.defaultTextMapSetter = {
set(carrier, key, value) {
if (carrier == null) {
return;
}
carrier[key] = value;
}
};
});
// node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
var require_NoopContextManager = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoopContextManager = undefined;
var context_1 = require_context();
class NoopContextManager {
active() {
return context_1.ROOT_CONTEXT;
}
with(_context, fn, thisArg, ...args) {
return fn.call(thisArg, ...args);
}
bind(_context, target) {
return target;
}
enable() {
return this;
}
disable() {
return this;
}
}
exports.NoopContextManager = NoopContextManager;
});
// node_modules/@opentelemetry/api/build/src/api/context.js
var require_context2 = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ContextAPI = undefined;
var NoopContextManager_1 = require_NoopContextManager();
var global_utils_1 = require_global_utils();
var diag_1 = require_diag();
var API_NAME = "context";
var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager;
class ContextAPI {
constructor() {}
static getInstance() {
if (!this._instance) {
this._instance = new ContextAPI;
}
return this._instance;
}
setGlobalContextManager(contextManager) {
return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
}
active() {
return this._getContextManager().active();
}
with(context, fn, thisArg, ...args) {
return this._getContextManager().with(context, fn, thisArg, ...args);
}
bind(context, target) {
return this._getContextManager().bind(context, target);
}
_getContextManager() {
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
}
disable() {
this._getContextManager().disable();
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
}
exports.ContextAPI = ContextAPI;
});
// node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
var require_trace_flags = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.TraceFlags = undefined;
var TraceFlags;
(function(TraceFlags2) {
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
})(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
var require_invalid_span_constants = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = undefined;
var trace_flags_1 = require_trace_flags();
exports.INVALID_SPANID = "0000000000000000";
exports.INVALID_TRACEID = "00000000000000000000000000000000";
exports.INVALID_SPAN_CONTEXT = {
traceId: exports.INVALID_TRACEID,
spanId: exports.INVALID_SPANID,
traceFlags: trace_flags_1.TraceFlags.NONE
};
});
// node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
var require_NonRecordingSpan = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NonRecordingSpan = undefined;
var invalid_span_constants_1 = require_invalid_span_constants();
class NonRecordingSpan {
constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
this._spanContext = _spanContext;
}
spanContext() {
return this._spanContext;
}
setAttribute(_key, _value) {
return this;
}
setAttributes(_attributes) {
return this;
}
addEvent(_name, _attributes) {
return this;
}
addLink(_link) {
return this;
}
addLinks(_links) {
return this;
}
setStatus(_status) {
return this;
}
updateName(_name) {
return this;
}
end(_endTime) {}
isRecording() {
return false;
}
recordException(_exception, _time) {}
}
exports.NonRecordingSpan = NonRecordingSpan;
});
// node_modules/@opentelemetry/api/build/src/trace/context-utils.js
var require_context_utils = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = undefined;
var context_1 = require_context();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var context_2 = require_context2();
var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
function getSpan(context) {
return context.getValue(SPAN_KEY) || undefined;
}
exports.getSpan = getSpan;
function getActiveSpan() {
return getSpan(context_2.ContextAPI.getInstance().active());
}
exports.getActiveSpan = getActiveSpan;
function setSpan(context, span) {
return context.setValue(SPAN_KEY, span);
}
exports.setSpan = setSpan;
function deleteSpan(context) {
return context.deleteValue(SPAN_KEY);
}
exports.deleteSpan = deleteSpan;
function setSpanContext(context, spanContext) {
return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
}
exports.setSpanContext = setSpanContext;
function getSpanContext(context) {
var _a15;
return (_a15 = getSpan(context)) === null || _a15 === undefined ? undefined : _a15.spanContext();
}
exports.getSpanContext = getSpanContext;
});
// node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
var require_spancontext_utils = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = undefined;
var invalid_span_constants_1 = require_invalid_span_constants();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
function isValidTraceId(traceId) {
return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
}
exports.isValidTraceId = isValidTraceId;
function isValidSpanId(spanId) {
return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
}
exports.isValidSpanId = isValidSpanId;
function isSpanContextValid(spanContext) {
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
}
exports.isSpanContextValid = isSpanContextValid;
function wrapSpanContext(spanContext) {
return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
}
exports.wrapSpanContext = wrapSpanContext;
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
var require_NoopTracer = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoopTracer = undefined;
var context_1 = require_context2();
var context_utils_1 = require_context_utils();
var NonRecordingSpan_1 = require_NonRecordingSpan();
var spancontext_utils_1 = require_spancontext_utils();
var contextApi = context_1.ContextAPI.getInstance();
class NoopTracer {
startSpan(name14, options, context = contextApi.active()) {
const root = Boolean(options === null || options === undefined ? undefined : options.root);
if (root) {
return new NonRecordingSpan_1.NonRecordingSpan;
}
const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
} else {
return new NonRecordingSpan_1.NonRecordingSpan;
}
}
startActiveSpan(name14, arg2, arg3, arg4) {
let opts;
let ctx;
let fn;
if (arguments.length < 2) {
return;
} else if (arguments.length === 2) {
fn = arg2;
} else if (arguments.length === 3) {
opts = arg2;
fn = arg3;
} else {
opts = arg2;
ctx = arg3;
fn = arg4;
}
const parentContext = ctx !== null && ctx !== undefined ? ctx : contextApi.active();
const span = this.startSpan(name14, opts, parentContext);
const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
return contextApi.with(contextWithSpanSet, fn, undefined, span);
}
}
exports.NoopTracer = NoopTracer;
function isSpanContext(spanContext) {
return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
}
});
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
var require_ProxyTracer = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProxyTracer = undefined;
var NoopTracer_1 = require_NoopTracer();
var NOOP_TRACER = new NoopTracer_1.NoopTracer;
class ProxyTracer {
constructor(_provider, name14, version2, options) {
this._provider = _provider;
this.name = name14;
this.version = version2;
this.options = options;
}
startSpan(name14, options, context) {
return this._getTracer().startSpan(name14, options, context);
}
startActiveSpan(_name, _options, _context, _fn) {
const tracer = this._getTracer();
return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
}
_getTracer() {
if (this._delegate) {
return this._delegate;
}
const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
if (!tracer) {
return NOOP_TRACER;
}
this._delegate = tracer;
return this._delegate;
}
}
exports.ProxyTracer = ProxyTracer;
});
// node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
var require_NoopTracerProvider = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoopTracerProvider = undefined;
var NoopTracer_1 = require_NoopTracer();
class NoopTracerProvider {
getTracer(_name, _version, _options) {
return new NoopTracer_1.NoopTracer;
}
}
exports.NoopTracerProvider = NoopTracerProvider;
});
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
var require_ProxyTracerProvider = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProxyTracerProvider = undefined;
var ProxyTracer_1 = require_ProxyTracer();
var NoopTracerProvider_1 = require_NoopTracerProvider();
var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider;
class ProxyTracerProvider {
getTracer(name14, version2, options) {
var _a15;
return (_a15 = this.getDelegateTracer(name14, version2, options)) !== null && _a15 !== undefined ? _a15 : new ProxyTracer_1.ProxyTracer(this, name14, version2, options);
}
getDelegate() {
var _a15;
return (_a15 = this._delegate) !== null && _a15 !== undefined ? _a15 : NOOP_TRACER_PROVIDER;
}
setDelegate(delegate) {
this._delegate = delegate;
}
getDelegateTracer(name14, version2, options) {
var _a15;
return (_a15 = this._delegate) === null || _a15 === undefined ? undefined : _a15.getTracer(name14, version2, options);
}
}
exports.ProxyTracerProvider = ProxyTracerProvider;
});
// node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
var require_SamplingResult = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.SamplingDecision = undefined;
var SamplingDecision;
(function(SamplingDecision2) {
SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
})(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/span_kind.js
var require_span_kind = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpanKind = undefined;
var SpanKind;
(function(SpanKind2) {
SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
})(SpanKind = exports.SpanKind || (exports.SpanKind = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/status.js
var require_status = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpanStatusCode = undefined;
var SpanStatusCode;
(function(SpanStatusCode2) {
SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
})(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {}));
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
var require_tracestate_validators = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateValue = exports.validateKey = undefined;
var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
function validateKey(key) {
return VALID_KEY_REGEX.test(key);
}
exports.validateKey = validateKey;
function validateValue(value) {
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
}
exports.validateValue = validateValue;
});
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
var require_tracestate_impl = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.TraceStateImpl = undefined;
var tracestate_validators_1 = require_tracestate_validators();
var MAX_TRACE_STATE_ITEMS = 32;
var MAX_TRACE_STATE_LEN = 512;
var LIST_MEMBERS_SEPARATOR = ",";
var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
class TraceStateImpl {
constructor(rawTraceState) {
this._internalState = new Map;
if (rawTraceState)
this._parse(rawTraceState);
}
set(key, value) {
const traceState = this._clone();
if (traceState._internalState.has(key)) {
traceState._internalState.delete(key);
}
traceState._internalState.set(key, value);
return traceState;
}
unset(key) {
const traceState = this._clone();
traceState._internalState.delete(key);
return traceState;
}
get(key) {
return this._internalState.get(key);
}
serialize() {
return this._keys().reduce((agg, key) => {
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
return agg;
}, []).join(LIST_MEMBERS_SEPARATOR);
}
_parse(rawTraceState) {
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
return;
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
const listMember = part.trim();
const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
if (i !== -1) {
const key = listMember.slice(0, i);
const value = listMember.slice(i + 1, part.length);
if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
agg.set(key, value);
} else {}
}
return agg;
}, new Map);
if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
}
}
_keys() {
return Array.from(this._internalState.keys()).reverse();
}
_clone() {
const traceState = new TraceStateImpl;
traceState._internalState = new Map(this._internalState);
return traceState;
}
}
exports.TraceStateImpl = TraceStateImpl;
});
// node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
var require_utils2 = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.createTraceState = undefined;
var tracestate_impl_1 = require_tracestate_impl();
function createTraceState(rawTraceState) {
return new tracestate_impl_1.TraceStateImpl(rawTraceState);
}
exports.createTraceState = createTraceState;
});
// node_modules/@opentelemetry/api/build/src/context-api.js
var require_context_api = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.context = undefined;
var context_1 = require_context2();
exports.context = context_1.ContextAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/diag-api.js
var require_diag_api = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.diag = undefined;
var diag_1 = require_diag();
exports.diag = diag_1.DiagAPI.instance();
});
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
var require_NoopMeterProvider = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = undefined;
var NoopMeter_1 = require_NoopMeter();
class NoopMeterProvider {
getMeter(_name, _version, _options) {
return NoopMeter_1.NOOP_METER;
}
}
exports.NoopMeterProvider = NoopMeterProvider;
exports.NOOP_METER_PROVIDER = new NoopMeterProvider;
});
// node_modules/@opentelemetry/api/build/src/api/metrics.js
var require_metrics = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetricsAPI = undefined;
var NoopMeterProvider_1 = require_NoopMeterProvider();
var global_utils_1 = require_global_utils();
var diag_1 = require_diag();
var API_NAME = "metrics";
class MetricsAPI {
constructor() {}
static getInstance() {
if (!this._instance) {
this._instance = new MetricsAPI;
}
return this._instance;
}
setGlobalMeterProvider(provider) {
return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
}
getMeterProvider() {
return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
}
getMeter(name14, version2, options) {
return this.getMeterProvider().getMeter(name14, version2, options);
}
disable() {
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
}
exports.MetricsAPI = MetricsAPI;
});
// node_modules/@opentelemetry/api/build/src/metrics-api.js
var require_metrics_api = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.metrics = undefined;
var metrics_1 = require_metrics();
exports.metrics = metrics_1.MetricsAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
var require_NoopTextMapPropagator = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoopTextMapPropagator = undefined;
class NoopTextMapPropagator {
inject(_context, _carrier) {}
extract(context, _carrier) {
return context;
}
fields() {
return [];
}
}
exports.NoopTextMapPropagator = NoopTextMapPropagator;
});
// node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
var require_context_helpers = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = undefined;
var context_1 = require_context2();
var context_2 = require_context();
var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
function getBaggage(context) {
return context.getValue(BAGGAGE_KEY) || undefined;
}
exports.getBaggage = getBaggage;
function getActiveBaggage() {
return getBaggage(context_1.ContextAPI.getInstance().active());
}
exports.getActiveBaggage = getActiveBaggage;
function setBaggage(context, baggage) {
return context.setValue(BAGGAGE_KEY, baggage);
}
exports.setBaggage = setBaggage;
function deleteBaggage(context) {
return context.deleteValue(BAGGAGE_KEY);
}
exports.deleteBaggage = deleteBaggage;
});
// node_modules/@opentelemetry/api/build/src/api/propagation.js
var require_propagation = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.PropagationAPI = undefined;
var global_utils_1 = require_global_utils();
var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
var TextMapPropagator_1 = require_TextMapPropagator();
var context_helpers_1 = require_context_helpers();
var utils_1 = require_utils();
var diag_1 = require_diag();
var API_NAME = "propagation";
var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator;
class PropagationAPI {
constructor() {
this.createBaggage = utils_1.createBaggage;
this.getBaggage = context_helpers_1.getBaggage;
this.getActiveBaggage = context_helpers_1.getActiveBaggage;
this.setBaggage = context_helpers_1.setBaggage;
this.deleteBaggage = context_helpers_1.deleteBaggage;
}
static getInstance() {
if (!this._instance) {
this._instance = new PropagationAPI;
}
return this._instance;
}
setGlobalPropagator(propagator) {
return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
}
inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
return this._getGlobalPropagator().inject(context, carrier, setter);
}
extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
return this._getGlobalPropagator().extract(context, carrier, getter);
}
fields() {
return this._getGlobalPropagator().fields();
}
disable() {
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
}
_getGlobalPropagator() {
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
}
}
exports.PropagationAPI = PropagationAPI;
});
// node_modules/@opentelemetry/api/build/src/propagation-api.js
var require_propagation_api = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.propagation = undefined;
var propagation_1 = require_propagation();
exports.propagation = propagation_1.PropagationAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/api/trace.js
var require_trace = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.TraceAPI = undefined;
var global_utils_1 = require_global_utils();
var ProxyTracerProvider_1 = require_ProxyTracerProvider();
var spancontext_utils_1 = require_spancontext_utils();
var context_utils_1 = require_context_utils();
var diag_1 = require_diag();
var API_NAME = "trace";
class TraceAPI {
constructor() {
this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
this.deleteSpan = context_utils_1.deleteSpan;
this.getSpan = context_utils_1.getSpan;
this.getActiveSpan = context_utils_1.getActiveSpan;
this.getSpanContext = context_utils_1.getSpanContext;
this.setSpan = context_utils_1.setSpan;
this.setSpanContext = context_utils_1.setSpanContext;
}
static getInstance() {
if (!this._instance) {
this._instance = new TraceAPI;
}
return this._instance;
}
setGlobalTracerProvider(provider) {
const success2 = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
if (success2) {
this._proxyTracerProvider.setDelegate(provider);
}
return success2;
}
getTracerProvider() {
return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
}
getTracer(name14, version2) {
return this.getTracerProvider().getTracer(name14, version2);
}
disable() {
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
}
}
exports.TraceAPI = TraceAPI;
});
// node_modules/@opentelemetry/api/build/src/trace-api.js
var require_trace_api = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.trace = undefined;
var trace_1 = require_trace();
exports.trace = trace_1.TraceAPI.getInstance();
});
// node_modules/@opentelemetry/api/build/src/index.js
var require_src = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = undefined;
var utils_1 = require_utils();
Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
return utils_1.baggageEntryMetadataFromString;
} });
var context_1 = require_context();
Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function() {
return context_1.createContextKey;
} });
Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function() {
return context_1.ROOT_CONTEXT;
} });
var consoleLogger_1 = require_consoleLogger();
Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function() {
return consoleLogger_1.DiagConsoleLogger;
} });
var types_1 = require_types();
Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function() {
return types_1.DiagLogLevel;
} });
var NoopMeter_1 = require_NoopMeter();
Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function() {
return N