@lark-apaas/observable-web 1.0.6 → 1.0.7-beta.0

package/dist/index.js

@@ -54,19 +54,24 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// ../../../node_modules/@opentelemetry/api/build/esm/platform/browser/globalThis.js
+var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+
 // ../../../node_modules/@opentelemetry/api/build/esm/version.js
-var VERSION = "1.9.1";
+var VERSION = "1.9.0";
 
 // ../../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
 var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
 function _makeCompatibilityCheck(ownVersion) {
-  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
-  const rejectedVersions = /* @__PURE__ */ new Set();
-  const myVersionMatch = ownVersion.match(re);
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
   if (!myVersionMatch) {
-    return () => false;
+    return function() {
+      return false;
+    };
   }
-  const ownVersionParsed = {
+  var ownVersionParsed = {
     major: +myVersionMatch[1],
     minor: +myVersionMatch[2],
     patch: +myVersionMatch[3],
@@ -92,11 +97,11 @@ function _makeCompatibilityCheck(ownVersion) {
     if (rejectedVersions.has(globalVersion)) {
       return false;
     }
-    const globalVersionMatch = globalVersion.match(re);
+    var globalVersionMatch = globalVersion.match(re);
     if (!globalVersionMatch) {
       return _reject(globalVersion);
     }
-    const globalVersionParsed = {
+    var globalVersionParsed = {
       major: +globalVersionMatch[1],
       minor: +globalVersionMatch[2],
       patch: +globalVersionMatch[3],
@@ -124,70 +129,124 @@ var isCompatible = _makeCompatibilityCheck(VERSION);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
 var major = VERSION.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
-var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
-function registerGlobal(type, instance, diag, allowOverride = false) {
+var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+function registerGlobal(type, instance, diag, allowOverride) {
   var _a;
-  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
     version: VERSION
   };
   if (!allowOverride && api[type]) {
-    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
     diag.error(err.stack || err.message);
     return false;
   }
   if (api.version !== VERSION) {
-    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
     diag.error(err.stack || err.message);
     return false;
   }
   api[type] = instance;
-  diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
   return true;
 }
 function getGlobal(type) {
   var _a, _b;
-  const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
   if (!globalVersion || !isCompatible(globalVersion)) {
     return;
   }
   return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
 }
 function unregisterGlobal(type, diag) {
-  diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
-  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
   if (api) {
     delete api[type];
   }
 }
 
 // ../../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
-var DiagComponentLogger = class {
-  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);
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
   }
-  verbose(...args) {
-    return logProxy("verbose", this._namespace, args);
+  return ar;
+};
+var __spreadArray = function(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
   }
+  return to.concat(ar || Array.prototype.slice.call(from));
 };
+var DiagComponentLogger = (
+  /** @class */
+  (function() {
+    function DiagComponentLogger2(props) {
+      this._namespace = props.namespace || "DiagComponentLogger";
+    }
+    DiagComponentLogger2.prototype.debug = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("debug", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.error = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("error", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.info = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("info", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.warn = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("warn", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.verbose = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("verbose", this._namespace, args);
+    };
+    return DiagComponentLogger2;
+  })()
+);
 function logProxy(funcName, namespace, args) {
-  const logger = getGlobal("diag");
+  var logger = getGlobal("diag");
   if (!logger) {
     return;
   }
-  return logger[funcName](namespace, ...args);
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
 }
 
 // ../../../node_modules/@opentelemetry/api/build/esm/diag/types.js
@@ -211,7 +270,7 @@ function createLogLevelDiagLogger(maxLevel, logger) {
   }
   logger = logger || {};
   function _filterFunc(funcName, theLevel) {
-    const theFunc = logger[funcName];
+    var theFunc = logger[funcName];
     if (typeof theFunc === "function" && maxLevel >= theLevel) {
       return theFunc.bind(logger);
     }
@@ -228,169 +287,248 @@ function createLogLevelDiagLogger(maxLevel, logger) {
 }
 
 // ../../../node_modules/@opentelemetry/api/build/esm/api/diag.js
-var API_NAME = "diag";
-var DiagAPI = class _DiagAPI {
-  /** Get the singleton instance of the DiagAPI API */
-  static instance() {
-    if (!this._instance) {
-      this._instance = new _DiagAPI();
+var __read2 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
     }
-    return this._instance;
   }
-  /**
-   * Private internal constructor
-   * @private
-   */
-  constructor() {
-    function _logProxy(funcName) {
-      return function(...args) {
-        const logger = getGlobal("diag");
-        if (!logger)
-          return;
-        return logger[funcName](...args);
-      };
+  return ar;
+};
+var __spreadArray2 = function(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
     }
-    const self2 = this;
-    const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
-      var _a, _b, _c;
-      if (logger === self2) {
-        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
-        return false;
-      }
-      if (typeof optionsOrLogLevel === "number") {
-        optionsOrLogLevel = {
-          logLevel: optionsOrLogLevel
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME = "diag";
+var DiagAPI = (
+  /** @class */
+  (function() {
+    function DiagAPI2() {
+      function _logProxy(funcName) {
+        return function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var logger = getGlobal("diag");
+          if (!logger)
+            return;
+          return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
         };
       }
-      const oldLogger = getGlobal("diag");
-      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
-      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
-        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _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}`);
+      var self2 = this;
+      var setLogger = function(logger, optionsOrLogLevel) {
+        var _a, _b, _c;
+        if (optionsOrLogLevel === void 0) {
+          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+        }
+        if (logger === self2) {
+          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        var oldLogger = getGlobal("diag");
+        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _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 registerGlobal("diag", newLogger, self2, true);
+      };
+      self2.setLogger = setLogger;
+      self2.disable = function() {
+        unregisterGlobal(API_NAME, self2);
+      };
+      self2.createComponentLogger = function(options) {
+        return new DiagComponentLogger(options);
+      };
+      self2.verbose = _logProxy("verbose");
+      self2.debug = _logProxy("debug");
+      self2.info = _logProxy("info");
+      self2.warn = _logProxy("warn");
+      self2.error = _logProxy("error");
+    }
+    DiagAPI2.instance = function() {
+      if (!this._instance) {
+        this._instance = new DiagAPI2();
       }
-      return registerGlobal("diag", newLogger, self2, true);
-    };
-    self2.setLogger = setLogger;
-    self2.disable = () => {
-      unregisterGlobal(API_NAME, self2);
+      return this._instance;
     };
-    self2.createComponentLogger = (options) => {
-      return new DiagComponentLogger(options);
-    };
-    self2.verbose = _logProxy("verbose");
-    self2.debug = _logProxy("debug");
-    self2.info = _logProxy("info");
-    self2.warn = _logProxy("warn");
-    self2.error = _logProxy("error");
-  }
-};
+    return DiagAPI2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/context/context.js
 function createContextKey(description) {
   return Symbol.for(description);
 }
-var BaseContext = class _BaseContext {
-  /**
-   * Construct a new context which inherits values from an optional parent context.
-   *
-   * @param parentContext a context from which to inherit values
-   */
-  constructor(parentContext) {
-    const self2 = this;
-    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-    self2.getValue = (key) => self2._currentContext.get(key);
-    self2.setValue = (key, value) => {
-      const context2 = new _BaseContext(self2._currentContext);
-      context2._currentContext.set(key, value);
-      return context2;
-    };
-    self2.deleteValue = (key) => {
-      const context2 = new _BaseContext(self2._currentContext);
-      context2._currentContext.delete(key);
-      return context2;
-    };
-  }
-};
+var BaseContext = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function BaseContext2(parentContext) {
+      var self2 = this;
+      self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+      self2.getValue = function(key) {
+        return self2._currentContext.get(key);
+      };
+      self2.setValue = function(key, value) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.set(key, value);
+        return context2;
+      };
+      self2.deleteValue = function(key) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.delete(key);
+        return context2;
+      };
+    }
+    return BaseContext2;
+  })()
+);
 var ROOT_CONTEXT = new BaseContext();
 
 // ../../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
-var NoopContextManager = class {
-  active() {
-    return ROOT_CONTEXT;
-  }
-  with(_context, fn, thisArg, ...args) {
-    return fn.call(thisArg, ...args);
-  }
-  bind(_context, target) {
-    return target;
-  }
-  enable() {
-    return this;
+var __read3 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
   }
-  disable() {
-    return this;
+  return ar;
+};
+var __spreadArray3 = function(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
   }
+  return to.concat(ar || Array.prototype.slice.call(from));
 };
+var NoopContextManager = (
+  /** @class */
+  (function() {
+    function NoopContextManager2() {
+    }
+    NoopContextManager2.prototype.active = function() {
+      return ROOT_CONTEXT;
+    };
+    NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
+    };
+    NoopContextManager2.prototype.bind = function(_context, target) {
+      return target;
+    };
+    NoopContextManager2.prototype.enable = function() {
+      return this;
+    };
+    NoopContextManager2.prototype.disable = function() {
+      return this;
+    };
+    return NoopContextManager2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/api/context.js
-var API_NAME2 = "context";
-var NOOP_CONTEXT_MANAGER = new NoopContextManager();
-var ContextAPI = class _ContextAPI {
-  /** Empty private constructor prevents end users from constructing a new instance of the API */
-  constructor() {
-  }
-  /** Get the singleton instance of the Context API */
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _ContextAPI();
+var __read4 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
     }
-    return this._instance;
-  }
-  /**
-   * Set the current context manager.
-   *
-   * @returns true if the context manager was successfully registered, else false
-   */
-  setGlobalContextManager(contextManager) {
-    return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
-  }
-  /**
-   * Get the currently active context
-   */
-  active() {
-    return this._getContextManager().active();
-  }
-  /**
-   * Execute a function with an active context
-   *
-   * @param context context to be active during function execution
-   * @param fn function to execute in a context
-   * @param thisArg optional receiver to be used for calling fn
-   * @param args optional arguments forwarded to fn
-   */
-  with(context2, fn, thisArg, ...args) {
-    return this._getContextManager().with(context2, fn, thisArg, ...args);
-  }
-  /**
-   * Bind a context to a target function or event emitter
-   *
-   * @param context context to bind to the event emitter or function. Defaults to the currently active context
-   * @param target function or event emitter to bind
-   */
-  bind(context2, target) {
-    return this._getContextManager().bind(context2, target);
   }
-  _getContextManager() {
-    return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
-  }
-  /** Disable and remove the global context manager */
-  disable() {
-    this._getContextManager().disable();
-    unregisterGlobal(API_NAME2, DiagAPI.instance());
+  return ar;
+};
+var __spreadArray4 = function(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
   }
+  return to.concat(ar || Array.prototype.slice.call(from));
 };
+var API_NAME2 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var ContextAPI = (
+  /** @class */
+  (function() {
+    function ContextAPI2() {
+    }
+    ContextAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new ContextAPI2();
+      }
+      return this._instance;
+    };
+    ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+      return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+    };
+    ContextAPI2.prototype.active = function() {
+      return this._getContextManager().active();
+    };
+    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+      var _a;
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read4(args), false));
+    };
+    ContextAPI2.prototype.bind = function(context2, target) {
+      return this._getContextManager().bind(context2, target);
+    };
+    ContextAPI2.prototype._getContextManager = function() {
+      return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+    };
+    ContextAPI2.prototype.disable = function() {
+      this._getContextManager().disable();
+      unregisterGlobal(API_NAME2, DiagAPI.instance());
+    };
+    return ContextAPI2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
 var TraceFlags;
@@ -409,51 +547,49 @@ var INVALID_SPAN_CONTEXT = {
 };
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
-var NonRecordingSpan = class {
-  constructor(spanContext = INVALID_SPAN_CONTEXT) {
-    this._spanContext = spanContext;
-  }
-  // Returns a SpanContext.
-  spanContext() {
-    return this._spanContext;
-  }
-  // By default does nothing
-  setAttribute(_key, _value) {
-    return this;
-  }
-  // By default does nothing
-  setAttributes(_attributes) {
-    return this;
-  }
-  // By default does nothing
-  addEvent(_name, _attributes) {
-    return this;
-  }
-  addLink(_link) {
-    return this;
-  }
-  addLinks(_links) {
-    return this;
-  }
-  // By default does nothing
-  setStatus(_status) {
-    return this;
-  }
-  // By default does nothing
-  updateName(_name) {
-    return this;
-  }
-  // By default does nothing
-  end(_endTime) {
-  }
-  // isRecording always returns false for NonRecordingSpan.
-  isRecording() {
-    return false;
-  }
-  // By default does nothing
-  recordException(_exception, _time) {
-  }
-};
+var NonRecordingSpan = (
+  /** @class */
+  (function() {
+    function NonRecordingSpan2(_spanContext) {
+      if (_spanContext === void 0) {
+        _spanContext = INVALID_SPAN_CONTEXT;
+      }
+      this._spanContext = _spanContext;
+    }
+    NonRecordingSpan2.prototype.spanContext = function() {
+      return this._spanContext;
+    };
+    NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLink = function(_link) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLinks = function(_links) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setStatus = function(_status) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.updateName = function(_name) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.end = function(_endTime) {
+    };
+    NonRecordingSpan2.prototype.isRecording = function() {
+      return false;
+    };
+    NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
+    };
+    return NonRecordingSpan2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
@@ -478,125 +614,13 @@ function getSpanContext(context2) {
 }
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
-var 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;
-}
+var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
 function isValidTraceId(traceId) {
-  return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
 }
 function isValidSpanId(spanId) {
-  return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
 }
 function isSpanContextValid(spanContext) {
   return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
@@ -607,174 +631,178 @@ function wrapSpanContext(spanContext) {
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
 var contextApi = ContextAPI.getInstance();
-var NoopTracer = class {
-  // startSpan starts a noop span.
-  startSpan(name, options, context2 = contextApi.active()) {
-    const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
-    if (root) {
-      return new NonRecordingSpan();
-    }
-    const parentFromContext = context2 && getSpanContext(context2);
-    if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-      return new NonRecordingSpan(parentFromContext);
-    } else {
-      return new NonRecordingSpan();
+var NoopTracer = (
+  /** @class */
+  (function() {
+    function NoopTracer2() {
     }
-  }
-  startActiveSpan(name, 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 !== void 0 ? ctx : contextApi.active();
-    const span = this.startSpan(name, opts, parentContext);
-    const contextWithSpanSet = setSpan(parentContext, span);
-    return contextApi.with(contextWithSpanSet, fn, void 0, span);
-  }
-};
+    NoopTracer2.prototype.startSpan = function(name, options, context2) {
+      if (context2 === void 0) {
+        context2 = contextApi.active();
+      }
+      var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+      if (root) {
+        return new NonRecordingSpan();
+      }
+      var parentFromContext = context2 && getSpanContext(context2);
+      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+        return new NonRecordingSpan(parentFromContext);
+      } else {
+        return new NonRecordingSpan();
+      }
+    };
+    NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
+      var opts;
+      var ctx;
+      var 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;
+      }
+      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+      var span = this.startSpan(name, opts, parentContext);
+      var contextWithSpanSet = setSpan(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn, void 0, span);
+    };
+    return NoopTracer2;
+  })()
+);
 function isSpanContext(spanContext) {
-  return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
 }
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
 var NOOP_TRACER = new NoopTracer();
-var ProxyTracer = class {
-  constructor(provider, name, version, options) {
-    this._provider = provider;
-    this.name = name;
-    this.version = version;
-    this.options = options;
-  }
-  startSpan(name, options, context2) {
-    return this._getTracer().startSpan(name, options, context2);
-  }
-  startActiveSpan(_name, _options, _context, _fn) {
-    const tracer = this._getTracer();
-    return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
-  }
-  /**
-   * Try to get a tracer from the proxy tracer provider.
-   * If the proxy tracer provider has no delegate, return a noop tracer.
-   */
-  _getTracer() {
-    if (this._delegate) {
-      return this._delegate;
+var ProxyTracer = (
+  /** @class */
+  (function() {
+    function ProxyTracer2(_provider, name, version, options) {
+      this._provider = _provider;
+      this.name = name;
+      this.version = version;
+      this.options = options;
     }
-    const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
-    if (!tracer) {
-      return NOOP_TRACER;
-    }
-    this._delegate = tracer;
-    return this._delegate;
-  }
-};
+    ProxyTracer2.prototype.startSpan = function(name, options, context2) {
+      return this._getTracer().startSpan(name, options, context2);
+    };
+    ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
+      var tracer = this._getTracer();
+      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+    };
+    ProxyTracer2.prototype._getTracer = function() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+      if (!tracer) {
+        return NOOP_TRACER;
+      }
+      this._delegate = tracer;
+      return this._delegate;
+    };
+    return ProxyTracer2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
-var NoopTracerProvider = class {
-  getTracer(_name, _version, _options) {
-    return new NoopTracer();
-  }
-};
+var NoopTracerProvider = (
+  /** @class */
+  (function() {
+    function NoopTracerProvider2() {
+    }
+    NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
+      return new NoopTracer();
+    };
+    return NoopTracerProvider2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
 var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
-var ProxyTracerProvider = class {
-  /**
-   * Get a {@link ProxyTracer}
-   */
-  getTracer(name, version, options) {
-    var _a;
-    return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
-  }
-  getDelegate() {
-    var _a;
-    return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
-  }
-  /**
-   * Set the delegate tracer provider
-   */
-  setDelegate(delegate) {
-    this._delegate = delegate;
-  }
-  getDelegateTracer(name, version, options) {
-    var _a;
-    return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
-  }
-};
+var ProxyTracerProvider = (
+  /** @class */
+  (function() {
+    function ProxyTracerProvider2() {
+    }
+    ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
+      var _a;
+      return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+    };
+    ProxyTracerProvider2.prototype.getDelegate = function() {
+      var _a;
+      return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+    };
+    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+      this._delegate = delegate;
+    };
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
+      var _a;
+      return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+    };
+    return ProxyTracerProvider2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/context-api.js
 var context = ContextAPI.getInstance();
 
 // ../../../node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME3 = "trace";
-var TraceAPI = class _TraceAPI {
-  /** Empty private constructor prevents end users from constructing a new instance of the API */
-  constructor() {
-    this._proxyTracerProvider = new ProxyTracerProvider();
-    this.wrapSpanContext = wrapSpanContext;
-    this.isSpanContextValid = isSpanContextValid;
-    this.deleteSpan = deleteSpan;
-    this.getSpan = getSpan;
-    this.getActiveSpan = getActiveSpan;
-    this.getSpanContext = getSpanContext;
-    this.setSpan = setSpan;
-    this.setSpanContext = setSpanContext;
-  }
-  /** Get the singleton instance of the Trace API */
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _TraceAPI();
+var TraceAPI = (
+  /** @class */
+  (function() {
+    function TraceAPI2() {
+      this._proxyTracerProvider = new ProxyTracerProvider();
+      this.wrapSpanContext = wrapSpanContext;
+      this.isSpanContextValid = isSpanContextValid;
+      this.deleteSpan = deleteSpan;
+      this.getSpan = getSpan;
+      this.getActiveSpan = getActiveSpan;
+      this.getSpanContext = getSpanContext;
+      this.setSpan = setSpan;
+      this.setSpanContext = setSpanContext;
     }
-    return this._instance;
-  }
-  /**
-   * Set the current global tracer.
-   *
-   * @returns true if the tracer provider was successfully registered, else false
-   */
-  setGlobalTracerProvider(provider) {
-    const success = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
-    if (success) {
-      this._proxyTracerProvider.setDelegate(provider);
-    }
-    return success;
-  }
-  /**
-   * Returns the global tracer provider.
-   */
-  getTracerProvider() {
-    return getGlobal(API_NAME3) || this._proxyTracerProvider;
-  }
-  /**
-   * Returns a tracer from the global tracer provider.
-   */
-  getTracer(name, version) {
-    return this.getTracerProvider().getTracer(name, version);
-  }
-  /** Remove the global tracer provider */
-  disable() {
-    unregisterGlobal(API_NAME3, DiagAPI.instance());
-    this._proxyTracerProvider = new ProxyTracerProvider();
-  }
-};
+    TraceAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new TraceAPI2();
+      }
+      return this._instance;
+    };
+    TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
+      var success = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
+      if (success) {
+        this._proxyTracerProvider.setDelegate(provider);
+      }
+      return success;
+    };
+    TraceAPI2.prototype.getTracerProvider = function() {
+      return getGlobal(API_NAME3) || this._proxyTracerProvider;
+    };
+    TraceAPI2.prototype.getTracer = function(name, version) {
+      return this.getTracerProvider().getTracer(name, version);
+    };
+    TraceAPI2.prototype.disable = function() {
+      unregisterGlobal(API_NAME3, DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider();
+    };
+    return TraceAPI2;
+  })()
+);
 
 // ../../../node_modules/@opentelemetry/api/build/esm/trace-api.js
 var trace = TraceAPI.getInstance();
 
 // package.json
 var package_default = {
-  version: "1.0.6"};
+  version: "1.0.7-beta.0"};
 
 // src/const.ts
 var defaultResourceAttr = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/observable-web",
-  "version": "1.0.6",
+  "version": "1.0.7-beta.0",
   "description": "Observable SDK For Web",
   "main": "./dist/index.js",
   "files": [