@hashgraphonline/standards-sdk 0.0.50 → 0.0.51

package/dist/es/standards-sdk.es31.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es31.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"standards-sdk.es31.js","sources":["../../node_modules/pino/browser.js"],"sourcesContent":["'use strict'\n\nconst format = require('quick-format-unescaped')\n\nmodule.exports = pino\n\nconst _console = pfGlobalThisOrFallback().console || {}\nconst stdSerializers = {\n  mapHttpRequest: mock,\n  mapHttpResponse: mock,\n  wrapRequestSerializer: passthrough,\n  wrapResponseSerializer: passthrough,\n  wrapErrorSerializer: passthrough,\n  req: mock,\n  res: mock,\n  err: asErrValue,\n  errWithCause: asErrValue\n}\nfunction levelToValue (level, logger) {\n  return level === 'silent'\n    ? Infinity\n    : logger.levels.values[level]\n}\nconst baseLogFunctionSymbol = Symbol('pino.logFuncs')\nconst hierarchySymbol = Symbol('pino.hierarchy')\n\nconst logFallbackMap = {\n  error: 'log',\n  fatal: 'error',\n  warn: 'error',\n  info: 'log',\n  debug: 'log',\n  trace: 'log'\n}\n\nfunction appendChildLogger (parentLogger, childLogger) {\n  const newEntry = {\n    logger: childLogger,\n    parent: parentLogger[hierarchySymbol]\n  }\n  childLogger[hierarchySymbol] = newEntry\n}\n\nfunction setupBaseLogFunctions (logger, levels, proto) {\n  const logFunctions = {}\n  levels.forEach(level => {\n    logFunctions[level] = proto[level] ? proto[level] : (_console[level] || _console[logFallbackMap[level] || 'log'] || noop)\n  })\n  logger[baseLogFunctionSymbol] = logFunctions\n}\n\nfunction shouldSerialize (serialize, serializers) {\n  if (Array.isArray(serialize)) {\n    const hasToFilter = serialize.filter(function (k) {\n      return k !== '!stdSerializers.err'\n    })\n    return hasToFilter\n  } else if (serialize === true) {\n    return Object.keys(serializers)\n  }\n\n  return false\n}\n\nfunction pino (opts) {\n  opts = opts || {}\n  opts.browser = opts.browser || {}\n\n  const transmit = opts.browser.transmit\n  if (transmit && typeof transmit.send !== 'function') { throw Error('pino: transmit option must have a send function') }\n\n  const proto = opts.browser.write || _console\n  if (opts.browser.write) opts.browser.asObject = true\n  const serializers = opts.serializers || {}\n  const serialize = shouldSerialize(opts.browser.serialize, serializers)\n  let stdErrSerialize = opts.browser.serialize\n\n  if (\n    Array.isArray(opts.browser.serialize) &&\n    opts.browser.serialize.indexOf('!stdSerializers.err') > -1\n  ) stdErrSerialize = false\n\n  const customLevels = Object.keys(opts.customLevels || {})\n  const levels = ['error', 'fatal', 'warn', 'info', 'debug', 'trace'].concat(customLevels)\n\n  if (typeof proto === 'function') {\n    levels.forEach(function (level) {\n      proto[level] = proto\n    })\n  }\n  if (opts.enabled === false || opts.browser.disabled) opts.level = 'silent'\n  const level = opts.level || 'info'\n  const logger = Object.create(proto)\n  if (!logger.log) logger.log = noop\n\n  setupBaseLogFunctions(logger, levels, proto)\n  // setup root hierarchy entry\n  appendChildLogger({}, logger)\n\n  Object.defineProperty(logger, 'levelVal', {\n    get: getLevelVal\n  })\n  Object.defineProperty(logger, 'level', {\n    get: getLevel,\n    set: setLevel\n  })\n\n  const setOpts = {\n    transmit,\n    serialize,\n    asObject: opts.browser.asObject,\n    formatters: opts.browser.formatters,\n    levels,\n    timestamp: getTimeFunction(opts),\n    messageKey: opts.messageKey || 'msg',\n    onChild: opts.onChild || noop\n  }\n  logger.levels = getLevels(opts)\n  logger.level = level\n\n  logger.setMaxListeners = logger.getMaxListeners =\n  logger.emit = logger.addListener = logger.on =\n  logger.prependListener = logger.once =\n  logger.prependOnceListener = logger.removeListener =\n  logger.removeAllListeners = logger.listeners =\n  logger.listenerCount = logger.eventNames =\n  logger.write = logger.flush = noop\n  logger.serializers = serializers\n  logger._serialize = serialize\n  logger._stdErrSerialize = stdErrSerialize\n  logger.child = function (...args) { return child.call(this, setOpts, ...args) }\n\n  if (transmit) logger._logEvent = createLogEventShape()\n\n  function getLevelVal () {\n    return levelToValue(this.level, this)\n  }\n\n  function getLevel () {\n    return this._level\n  }\n  function setLevel (level) {\n    if (level !== 'silent' && !this.levels.values[level]) {\n      throw Error('unknown level ' + level)\n    }\n    this._level = level\n\n    set(this, setOpts, logger, 'error') // <-- must stay first\n    set(this, setOpts, logger, 'fatal')\n    set(this, setOpts, logger, 'warn')\n    set(this, setOpts, logger, 'info')\n    set(this, setOpts, logger, 'debug')\n    set(this, setOpts, logger, 'trace')\n\n    customLevels.forEach((level) => {\n      set(this, setOpts, logger, level)\n    })\n  }\n\n  function child (setOpts, bindings, childOptions) {\n    if (!bindings) {\n      throw new Error('missing bindings for child Pino')\n    }\n    childOptions = childOptions || {}\n    if (serialize && bindings.serializers) {\n      childOptions.serializers = bindings.serializers\n    }\n    const childOptionsSerializers = childOptions.serializers\n    if (serialize && childOptionsSerializers) {\n      var childSerializers = Object.assign({}, serializers, childOptionsSerializers)\n      var childSerialize = opts.browser.serialize === true\n        ? Object.keys(childSerializers)\n        : serialize\n      delete bindings.serializers\n      applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize)\n    }\n    function Child (parent) {\n      this._childLevel = (parent._childLevel | 0) + 1\n\n      // make sure bindings are available in the `set` function\n      this.bindings = bindings\n\n      if (childSerializers) {\n        this.serializers = childSerializers\n        this._serialize = childSerialize\n      }\n      if (transmit) {\n        this._logEvent = createLogEventShape(\n          [].concat(parent._logEvent.bindings, bindings)\n        )\n      }\n    }\n    Child.prototype = this\n    const newLogger = new Child(this)\n\n    // must happen before the level is assigned\n    appendChildLogger(this, newLogger)\n    newLogger.child = function (...args) { return child.call(this, setOpts, ...args) }\n    // required to actually initialize the logger functions for any given child\n    newLogger.level = childOptions.level || this.level // allow level to be set by childOptions\n    setOpts.onChild(newLogger)\n\n    return newLogger\n  }\n  return logger\n}\n\nfunction getLevels (opts) {\n  const customLevels = opts.customLevels || {}\n\n  const values = Object.assign({}, pino.levels.values, customLevels)\n  const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels))\n\n  return {\n    values,\n    labels\n  }\n}\n\nfunction invertObject (obj) {\n  const inverted = {}\n  Object.keys(obj).forEach(function (key) {\n    inverted[obj[key]] = key\n  })\n  return inverted\n}\n\npino.levels = {\n  values: {\n    fatal: 60,\n    error: 50,\n    warn: 40,\n    info: 30,\n    debug: 20,\n    trace: 10\n  },\n  labels: {\n    10: 'trace',\n    20: 'debug',\n    30: 'info',\n    40: 'warn',\n    50: 'error',\n    60: 'fatal'\n  }\n}\n\npino.stdSerializers = stdSerializers\npino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime })\n\nfunction getBindingChain (logger) {\n  const bindings = []\n  if (logger.bindings) {\n    bindings.push(logger.bindings)\n  }\n\n  // traverse up the tree to get all bindings\n  let hierarchy = logger[hierarchySymbol]\n  while (hierarchy.parent) {\n    hierarchy = hierarchy.parent\n    if (hierarchy.logger.bindings) {\n      bindings.push(hierarchy.logger.bindings)\n    }\n  }\n\n  return bindings.reverse()\n}\n\nfunction set (self, opts, rootLogger, level) {\n  // override the current log functions with either `noop` or the base log function\n  Object.defineProperty(self, level, {\n    value: (levelToValue(self.level, rootLogger) > levelToValue(level, rootLogger)\n      ? noop\n      : rootLogger[baseLogFunctionSymbol][level]),\n    writable: true,\n    enumerable: true,\n    configurable: true\n  })\n\n  if (self[level] === noop) {\n    if (!opts.transmit) return\n\n    const transmitLevel = opts.transmit.level || self.level\n    const transmitValue = levelToValue(transmitLevel, rootLogger)\n    const methodValue = levelToValue(level, rootLogger)\n    if (methodValue < transmitValue) return\n  }\n\n  // make sure the log format is correct\n  self[level] = createWrap(self, opts, rootLogger, level)\n\n  // prepend bindings if it is not the root logger\n  const bindings = getBindingChain(self)\n  if (bindings.length === 0) {\n    // early exit in case for rootLogger\n    return\n  }\n  self[level] = prependBindingsInArguments(bindings, self[level])\n}\n\nfunction prependBindingsInArguments (bindings, logFunc) {\n  return function () {\n    return logFunc.apply(this, [...bindings, ...arguments])\n  }\n}\n\nfunction createWrap (self, opts, rootLogger, level) {\n  return (function (write) {\n    return function LOG () {\n      const ts = opts.timestamp()\n      const args = new Array(arguments.length)\n      const proto = (Object.getPrototypeOf && Object.getPrototypeOf(this) === _console) ? _console : this\n      for (var i = 0; i < args.length; i++) args[i] = arguments[i]\n\n      var argsIsSerialized = false\n      if (opts.serialize) {\n        applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize)\n        argsIsSerialized = true\n      }\n      if (opts.asObject || opts.formatters) {\n        write.call(proto, asObject(this, level, args, ts, opts))\n      } else write.apply(proto, args)\n\n      if (opts.transmit) {\n        const transmitLevel = opts.transmit.level || self._level\n        const transmitValue = levelToValue(transmitLevel, rootLogger)\n        const methodValue = levelToValue(level, rootLogger)\n        if (methodValue < transmitValue) return\n        transmit(this, {\n          ts,\n          methodLevel: level,\n          methodValue,\n          transmitLevel,\n          transmitValue: rootLogger.levels.values[opts.transmit.level || self._level],\n          send: opts.transmit.send,\n          val: levelToValue(self._level, rootLogger)\n        }, args, argsIsSerialized)\n      }\n    }\n  })(self[baseLogFunctionSymbol][level])\n}\n\nfunction asObject (logger, level, args, ts, opts) {\n  const {\n    level: levelFormatter,\n    log: logObjectFormatter = (obj) => obj\n  } = opts.formatters || {}\n  const argsCloned = args.slice()\n  let msg = argsCloned[0]\n  const logObject = {}\n  if (ts) {\n    logObject.time = ts\n  }\n\n  if (levelFormatter) {\n    const formattedLevel = levelFormatter(level, logger.levels.values[level])\n    Object.assign(logObject, formattedLevel)\n  } else {\n    logObject.level = logger.levels.values[level]\n  }\n\n  let lvl = (logger._childLevel | 0) + 1\n  if (lvl < 1) lvl = 1\n  // deliberate, catching objects, arrays\n  if (msg !== null && typeof msg === 'object') {\n    while (lvl-- && typeof argsCloned[0] === 'object') {\n      Object.assign(logObject, argsCloned.shift())\n    }\n    msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined\n  } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned)\n  if (msg !== undefined) logObject[opts.messageKey] = msg\n\n  const formattedLogObject = logObjectFormatter(logObject)\n  return formattedLogObject\n}\n\nfunction applySerializers (args, serialize, serializers, stdErrSerialize) {\n  for (const i in args) {\n    if (stdErrSerialize && args[i] instanceof Error) {\n      args[i] = pino.stdSerializers.err(args[i])\n    } else if (typeof args[i] === 'object' && !Array.isArray(args[i]) && serialize) {\n      for (const k in args[i]) {\n        if (serialize.indexOf(k) > -1 && k in serializers) {\n          args[i][k] = serializers[k](args[i][k])\n        }\n      }\n    }\n  }\n}\n\nfunction transmit (logger, opts, args, argsIsSerialized = false) {\n  const send = opts.send\n  const ts = opts.ts\n  const methodLevel = opts.methodLevel\n  const methodValue = opts.methodValue\n  const val = opts.val\n  const bindings = logger._logEvent.bindings\n\n  if (!argsIsSerialized) {\n    applySerializers(\n      args,\n      logger._serialize || Object.keys(logger.serializers),\n      logger.serializers,\n      logger._stdErrSerialize === undefined ? true : logger._stdErrSerialize\n    )\n  }\n\n  logger._logEvent.ts = ts\n  logger._logEvent.messages = args.filter(function (arg) {\n    // bindings can only be objects, so reference equality check via indexOf is fine\n    return bindings.indexOf(arg) === -1\n  })\n\n  logger._logEvent.level.label = methodLevel\n  logger._logEvent.level.value = methodValue\n\n  send(methodLevel, logger._logEvent, val)\n\n  logger._logEvent = createLogEventShape(bindings)\n}\n\nfunction createLogEventShape (bindings) {\n  return {\n    ts: 0,\n    messages: [],\n    bindings: bindings || [],\n    level: { label: '', value: 0 }\n  }\n}\n\nfunction asErrValue (err) {\n  const obj = {\n    type: err.constructor.name,\n    msg: err.message,\n    stack: err.stack\n  }\n  for (const key in err) {\n    if (obj[key] === undefined) {\n      obj[key] = err[key]\n    }\n  }\n  return obj\n}\n\nfunction getTimeFunction (opts) {\n  if (typeof opts.timestamp === 'function') {\n    return opts.timestamp\n  }\n  if (opts.timestamp === false) {\n    return nullTime\n  }\n  return epochTime\n}\n\nfunction mock () { return {} }\nfunction passthrough (a) { return a }\nfunction noop () {}\n\nfunction nullTime () { return false }\nfunction epochTime () { return Date.now() }\nfunction unixTime () { return Math.round(Date.now() / 1000.0) }\nfunction isoTime () { return new Date(Date.now()).toISOString() } // using Date.now() for testability\n\n/* eslint-disable */\n/* istanbul ignore next */\nfunction pfGlobalThisOrFallback () {\n  function defd (o) { return typeof o !== 'undefined' && o }\n  try {\n    if (typeof globalThis !== 'undefined') return globalThis\n    Object.defineProperty(Object.prototype, 'globalThis', {\n      get: function () {\n        delete Object.prototype.globalThis\n        return (this.globalThis = this)\n      },\n      configurable: true\n    })\n    return globalThis\n  } catch (e) {\n    return defd(self) || defd(window) || defd(this) || {}\n  }\n}\n/* eslint-enable */\n\nmodule.exports.default = pino\nmodule.exports.pino = pino\n"],"names":["require$$0","browserModule","transmit","level","setOpts","self"],"mappings":";;;;;;AAEA,QAAM,SAASA,4BAAA;AAEfC,UAAA,UAAiB;AAEjB,QAAM,WAAW,uBAAwB,EAAC,WAAW,CAAA;AACrD,QAAM,iBAAiB;AAAA,IACrB,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,uBAAuB;AAAA,IACvB,wBAAwB;AAAA,IACxB,qBAAqB;AAAA,IACrB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,cAAc;AAAA,EAChB;AACA,WAAS,aAAc,OAAO,QAAQ;AACpC,WAAO,UAAU,WACb,WACA,OAAO,OAAO,OAAO,KAAK;AAAA,EAChC;AACA,QAAM,wBAAwB,OAAO,eAAe;AACpD,QAAM,kBAAkB,OAAO,gBAAgB;AAE/C,QAAM,iBAAiB;AAAA,IACrB,OAAO;AAAA,IACP,OAAO;AAAA,IACP,MAAM;AAAA,IACN,MAAM;AAAA,IACN,OAAO;AAAA,IACP,OAAO;AAAA,EACT;AAEA,WAAS,kBAAmB,cAAc,aAAa;AACrD,UAAM,WAAW;AAAA,MACf,QAAQ;AAAA,MACR,QAAQ,aAAa,eAAe;AAAA,IACxC;AACE,gBAAY,eAAe,IAAI;AAAA,EACjC;AAEA,WAAS,sBAAuB,QAAQ,QAAQ,OAAO;AACrD,UAAM,eAAe,CAAA;AACrB,WAAO,QAAQ,WAAS;AACtB,mBAAa,KAAK,IAAI,MAAM,KAAK,IAAI,MAAM,KAAK,IAAK,SAAS,KAAK,KAAK,SAAS,eAAe,KAAK,KAAK,KAAK,KAAK;AAAA,IACrH,CAAA;AACD,WAAO,qBAAqB,IAAI;AAAA,EAClC;AAEA,WAAS,gBAAiB,WAAW,aAAa;AAChD,QAAI,MAAM,QAAQ,SAAS,GAAG;AAC5B,YAAM,cAAc,UAAU,OAAO,SAAU,GAAG;AAChD,eAAO,MAAM;AAAA,MACd,CAAA;AACD,aAAO;AAAA,IACX,WAAa,cAAc,MAAM;AAC7B,aAAO,OAAO,KAAK,WAAW;AAAA,IAClC;AAEE,WAAO;AAAA,EACT;AAEA,WAAS,KAAM,MAAM;AACnB,WAAO,QAAQ,CAAA;AACf,SAAK,UAAU,KAAK,WAAW,CAAA;AAE/B,UAAMC,YAAW,KAAK,QAAQ;AAC9B,QAAIA,aAAY,OAAOA,UAAS,SAAS,YAAY;AAAE,YAAM,MAAM,iDAAiD;AAAA,IAAC;AAErH,UAAM,QAAQ,KAAK,QAAQ,SAAS;AACpC,QAAI,KAAK,QAAQ,MAAO,MAAK,QAAQ,WAAW;AAChD,UAAM,cAAc,KAAK,eAAe,CAAA;AACxC,UAAM,YAAY,gBAAgB,KAAK,QAAQ,WAAW,WAAW;AACrE,QAAI,kBAAkB,KAAK,QAAQ;AAEnC,QACE,MAAM,QAAQ,KAAK,QAAQ,SAAS,KACpC,KAAK,QAAQ,UAAU,QAAQ,qBAAqB,IAAI,GACxD,mBAAkB;AAEpB,UAAM,eAAe,OAAO,KAAK,KAAK,gBAAgB,CAAE,CAAA;AACxD,UAAM,SAAS,CAAC,SAAS,SAAS,QAAQ,QAAQ,SAAS,OAAO,EAAE,OAAO,YAAY;AAEvF,QAAI,OAAO,UAAU,YAAY;AAC/B,aAAO,QAAQ,SAAUC,QAAO;AAC9B,cAAMA,MAAK,IAAI;AAAA,MAChB,CAAA;AAAA,IACL;AACE,QAAI,KAAK,YAAY,SAAS,KAAK,QAAQ,SAAU,MAAK,QAAQ;AAClE,UAAM,QAAQ,KAAK,SAAS;AAC5B,UAAM,SAAS,OAAO,OAAO,KAAK;AAClC,QAAI,CAAC,OAAO,IAAK,QAAO,MAAM;AAE9B,0BAAsB,QAAQ,QAAQ,KAAK;AAE3C,sBAAkB,CAAE,GAAE,MAAM;AAE5B,WAAO,eAAe,QAAQ,YAAY;AAAA,MACxC,KAAK;AAAA,IACN,CAAA;AACD,WAAO,eAAe,QAAQ,SAAS;AAAA,MACrC,KAAK;AAAA,MACL,KAAK;AAAA,IACN,CAAA;AAED,UAAM,UAAU;AAAA,MACd,UAAAD;AAAA,MACA;AAAA,MACA,UAAU,KAAK,QAAQ;AAAA,MACvB,YAAY,KAAK,QAAQ;AAAA,MACzB;AAAA,MACA,WAAW,gBAAgB,IAAI;AAAA,MAC/B,YAAY,KAAK,cAAc;AAAA,MAC/B,SAAS,KAAK,WAAW;AAAA,IAC7B;AACE,WAAO,SAAS,UAAU,IAAI;AAC9B,WAAO,QAAQ;AAEf,WAAO,kBAAkB,OAAO,kBAChC,OAAO,OAAO,OAAO,cAAc,OAAO,KAC1C,OAAO,kBAAkB,OAAO,OAChC,OAAO,sBAAsB,OAAO,iBACpC,OAAO,qBAAqB,OAAO,YACnC,OAAO,gBAAgB,OAAO,aAC9B,OAAO,QAAQ,OAAO,QAAQ;AAC9B,WAAO,cAAc;AACrB,WAAO,aAAa;AACpB,WAAO,mBAAmB;AAC1B,WAAO,QAAQ,YAAa,MAAM;AAAE,aAAO,MAAM,KAAK,MAAM,SAAS,GAAG,IAAI;AAAA,IAAC;AAE7E,QAAIA,UAAU,QAAO,YAAY,oBAAmB;AAEpD,aAAS,cAAe;AACtB,aAAO,aAAa,KAAK,OAAO,IAAI;AAAA,IACxC;AAEE,aAAS,WAAY;AACnB,aAAO,KAAK;AAAA,IAChB;AACE,aAAS,SAAUC,QAAO;AACxB,UAAIA,WAAU,YAAY,CAAC,KAAK,OAAO,OAAOA,MAAK,GAAG;AACpD,cAAM,MAAM,mBAAmBA,MAAK;AAAA,MAC1C;AACI,WAAK,SAASA;AAEd,UAAI,MAAM,SAAS,QAAQ,OAAO;AAClC,UAAI,MAAM,SAAS,QAAQ,OAAO;AAClC,UAAI,MAAM,SAAS,QAAQ,MAAM;AACjC,UAAI,MAAM,SAAS,QAAQ,MAAM;AACjC,UAAI,MAAM,SAAS,QAAQ,OAAO;AAClC,UAAI,MAAM,SAAS,QAAQ,OAAO;AAElC,mBAAa,QAAQ,CAACA,WAAU;AAC9B,YAAI,MAAM,SAAS,QAAQA,MAAK;AAAA,MACjC,CAAA;AAAA,IACL;AAEE,aAAS,MAAOC,UAAS,UAAU,cAAc;AAC/C,UAAI,CAAC,UAAU;AACb,cAAM,IAAI,MAAM,iCAAiC;AAAA,MACvD;AACI,qBAAe,gBAAgB,CAAA;AAC/B,UAAI,aAAa,SAAS,aAAa;AACrC,qBAAa,cAAc,SAAS;AAAA,MAC1C;AACI,YAAM,0BAA0B,aAAa;AAC7C,UAAI,aAAa,yBAAyB;AACxC,YAAI,mBAAmB,OAAO,OAAO,CAAE,GAAE,aAAa,uBAAuB;AAC7E,YAAI,iBAAiB,KAAK,QAAQ,cAAc,OAC5C,OAAO,KAAK,gBAAgB,IAC5B;AACJ,eAAO,SAAS;AAChB,yBAAiB,CAAC,QAAQ,GAAG,gBAAgB,kBAAkB,KAAK,gBAAgB;AAAA,MAC1F;AACI,eAAS,MAAO,QAAQ;AACtB,aAAK,eAAe,OAAO,cAAc,KAAK;AAG9C,aAAK,WAAW;AAEhB,YAAI,kBAAkB;AACpB,eAAK,cAAc;AACnB,eAAK,aAAa;AAAA,QAC1B;AACM,YAAIF,WAAU;AACZ,eAAK,YAAY;AAAA,YACf,CAAA,EAAG,OAAO,OAAO,UAAU,UAAU,QAAQ;AAAA,UACvD;AAAA,QACA;AAAA,MACA;AACI,YAAM,YAAY;AAClB,YAAM,YAAY,IAAI,MAAM,IAAI;AAGhC,wBAAkB,MAAM,SAAS;AACjC,gBAAU,QAAQ,YAAa,MAAM;AAAE,eAAO,MAAM,KAAK,MAAME,UAAS,GAAG,IAAI;AAAA,MAAC;AAEhF,gBAAU,QAAQ,aAAa,SAAS,KAAK;AAC7C,MAAAA,SAAQ,QAAQ,SAAS;AAEzB,aAAO;AAAA,IACX;AACE,WAAO;AAAA,EACT;AAEA,WAAS,UAAW,MAAM;AACxB,UAAM,eAAe,KAAK,gBAAgB,CAAA;AAE1C,UAAM,SAAS,OAAO,OAAO,CAAE,GAAE,KAAK,OAAO,QAAQ,YAAY;AACjE,UAAM,SAAS,OAAO,OAAO,CAAE,GAAE,KAAK,OAAO,QAAQ,aAAa,YAAY,CAAC;AAE/E,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACJ;AAAA,EACA;AAEA,WAAS,aAAc,KAAK;AAC1B,UAAM,WAAW,CAAA;AACjB,WAAO,KAAK,GAAG,EAAE,QAAQ,SAAU,KAAK;AACtC,eAAS,IAAI,GAAG,CAAC,IAAI;AAAA,IACtB,CAAA;AACD,WAAO;AAAA,EACT;AAEA,OAAK,SAAS;AAAA,IACZ,QAAQ;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,MACP,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,IACR;AAAA,IACD,QAAQ;AAAA,MACN,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,IAAI;AAAA,IACR;AAAA,EACA;AAEA,OAAK,iBAAiB;AACtB,OAAK,mBAAmB,OAAO,OAAO,CAAA,GAAI,EAAE,UAAU,WAAW,UAAU,QAAS,CAAA;AAEpF,WAAS,gBAAiB,QAAQ;AAChC,UAAM,WAAW,CAAA;AACjB,QAAI,OAAO,UAAU;AACnB,eAAS,KAAK,OAAO,QAAQ;AAAA,IACjC;AAGE,QAAI,YAAY,OAAO,eAAe;AACtC,WAAO,UAAU,QAAQ;AACvB,kBAAY,UAAU;AACtB,UAAI,UAAU,OAAO,UAAU;AAC7B,iBAAS,KAAK,UAAU,OAAO,QAAQ;AAAA,MAC7C;AAAA,IACA;AAEE,WAAO,SAAS,QAAO;AAAA,EACzB;AAEA,WAAS,IAAKC,OAAM,MAAM,YAAY,OAAO;AAE3C,WAAO,eAAeA,OAAM,OAAO;AAAA,MACjC,OAAQ,aAAaA,MAAK,OAAO,UAAU,IAAI,aAAa,OAAO,UAAU,IACzE,OACA,WAAW,qBAAqB,EAAE,KAAK;AAAA,MAC3C,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,cAAc;AAAA,IACf,CAAA;AAED,QAAIA,MAAK,KAAK,MAAM,MAAM;AACxB,UAAI,CAAC,KAAK,SAAU;AAEpB,YAAM,gBAAgB,KAAK,SAAS,SAASA,MAAK;AAClD,YAAM,gBAAgB,aAAa,eAAe,UAAU;AAC5D,YAAM,cAAc,aAAa,OAAO,UAAU;AAClD,UAAI,cAAc,cAAe;AAAA,IACrC;AAGE,IAAAA,MAAK,KAAK,IAAI,WAAWA,OAAM,MAAM,YAAY,KAAK;AAGtD,UAAM,WAAW,gBAAgBA,KAAI;AACrC,QAAI,SAAS,WAAW,GAAG;AAEzB;AAAA,IACJ;AACE,IAAAA,MAAK,KAAK,IAAI,2BAA2B,UAAUA,MAAK,KAAK,CAAC;AAAA,EAChE;AAEA,WAAS,2BAA4B,UAAU,SAAS;AACtD,WAAO,WAAY;AACjB,aAAO,QAAQ,MAAM,MAAM,CAAC,GAAG,UAAU,GAAG,SAAS,CAAC;AAAA,IAC1D;AAAA,EACA;AAEA,WAAS,WAAYA,OAAM,MAAM,YAAY,OAAO;AAClD,WAAQ,yBAAU,OAAO;AACvB,aAAO,SAAS,MAAO;AACrB,cAAM,KAAK,KAAK,UAAS;AACzB,cAAM,OAAO,IAAI,MAAM,UAAU,MAAM;AACvC,cAAM,QAAS,OAAO,kBAAkB,OAAO,eAAe,IAAI,MAAM,WAAY,WAAW;AAC/F,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,IAAK,MAAK,CAAC,IAAI,UAAU,CAAC;AAE3D,YAAI,mBAAmB;AACvB,YAAI,KAAK,WAAW;AAClB,2BAAiB,MAAM,KAAK,YAAY,KAAK,aAAa,KAAK,gBAAgB;AAC/E,6BAAmB;AAAA,QAC3B;AACM,YAAI,KAAK,YAAY,KAAK,YAAY;AACpC,gBAAM,KAAK,OAAO,SAAS,MAAM,OAAO,MAAM,IAAI,IAAI,CAAC;AAAA,QAC/D,MAAa,OAAM,MAAM,OAAO,IAAI;AAE9B,YAAI,KAAK,UAAU;AACjB,gBAAM,gBAAgB,KAAK,SAAS,SAASA,MAAK;AAClD,gBAAM,gBAAgB,aAAa,eAAe,UAAU;AAC5D,gBAAM,cAAc,aAAa,OAAO,UAAU;AAClD,cAAI,cAAc,cAAe;AACjC,mBAAS,MAAM;AAAA,YACb;AAAA,YACA,aAAa;AAAA,YACb;AAAA,YAEA,eAAe,WAAW,OAAO,OAAO,KAAK,SAAS,SAASA,MAAK,MAAM;AAAA,YAC1E,MAAM,KAAK,SAAS;AAAA,YACpB,KAAK,aAAaA,MAAK,QAAQ,UAAU;AAAA,UAC1C,GAAE,MAAM,gBAAgB;AAAA,QACjC;AAAA,MACA;AAAA,IACA,EAAKA,MAAK,qBAAqB,EAAE,KAAK,CAAC;AAAA,EACvC;AAEA,WAAS,SAAU,QAAQ,OAAO,MAAM,IAAI,MAAM;AAChD,UAAM;AAAA,MACJ,OAAO;AAAA,MACP,KAAK,qBAAqB,CAAC,QAAQ;AAAA,IACvC,IAAM,KAAK,cAAc,CAAA;AACvB,UAAM,aAAa,KAAK,MAAK;AAC7B,QAAI,MAAM,WAAW,CAAC;AACtB,UAAM,YAAY,CAAA;AAClB,QAAI,IAAI;AACN,gBAAU,OAAO;AAAA,IACrB;AAEE,QAAI,gBAAgB;AAClB,YAAM,iBAAiB,eAAe,OAAO,OAAO,OAAO,OAAO,KAAK,CAAC;AACxE,aAAO,OAAO,WAAW,cAAc;AAAA,IAC3C,OAAS;AACL,gBAAU,QAAQ,OAAO,OAAO,OAAO,KAAK;AAAA,IAChD;AAEE,QAAI,OAAO,OAAO,cAAc,KAAK;AACrC,QAAI,MAAM,EAAG,OAAM;AAEnB,QAAI,QAAQ,QAAQ,OAAO,QAAQ,UAAU;AAC3C,aAAO,SAAS,OAAO,WAAW,CAAC,MAAM,UAAU;AACjD,eAAO,OAAO,WAAW,WAAW,MAAO,CAAA;AAAA,MACjD;AACI,YAAM,WAAW,SAAS,OAAO,WAAW,MAAK,GAAI,UAAU,IAAI;AAAA,IACvE,WAAa,OAAO,QAAQ,SAAU,OAAM,OAAO,WAAW,MAAK,GAAI,UAAU;AAC/E,QAAI,QAAQ,OAAW,WAAU,KAAK,UAAU,IAAI;AAEpD,UAAM,qBAAqB,mBAAmB,SAAS;AACvD,WAAO;AAAA,EACT;AAEA,WAAS,iBAAkB,MAAM,WAAW,aAAa,iBAAiB;AACxE,eAAW,KAAK,MAAM;AACpB,UAAI,mBAAmB,KAAK,CAAC,aAAa,OAAO;AAC/C,aAAK,CAAC,IAAI,KAAK,eAAe,IAAI,KAAK,CAAC,CAAC;AAAA,MAC1C,WAAU,OAAO,KAAK,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,KAAK,CAAC,CAAC,KAAK,WAAW;AAC9E,mBAAW,KAAK,KAAK,CAAC,GAAG;AACvB,cAAI,UAAU,QAAQ,CAAC,IAAI,MAAM,KAAK,aAAa;AACjD,iBAAK,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;AAAA,UAChD;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAEA,WAAS,SAAU,QAAQ,MAAM,MAAM,mBAAmB,OAAO;AAC/D,UAAM,OAAO,KAAK;AAClB,UAAM,KAAK,KAAK;AAChB,UAAM,cAAc,KAAK;AACzB,UAAM,cAAc,KAAK;AACzB,UAAM,MAAM,KAAK;AACjB,UAAM,WAAW,OAAO,UAAU;AAElC,QAAI,CAAC,kBAAkB;AACrB;AAAA,QACE;AAAA,QACA,OAAO,cAAc,OAAO,KAAK,OAAO,WAAW;AAAA,QACnD,OAAO;AAAA,QACP,OAAO,qBAAqB,SAAY,OAAO,OAAO;AAAA,MAC5D;AAAA,IACA;AAEE,WAAO,UAAU,KAAK;AACtB,WAAO,UAAU,WAAW,KAAK,OAAO,SAAU,KAAK;AAErD,aAAO,SAAS,QAAQ,GAAG,MAAM;AAAA,IAClC,CAAA;AAED,WAAO,UAAU,MAAM,QAAQ;AAC/B,WAAO,UAAU,MAAM,QAAQ;AAE/B,SAAK,aAAa,OAAO,WAAW,GAAG;AAEvC,WAAO,YAAY,oBAAoB,QAAQ;AAAA,EACjD;AAEA,WAAS,oBAAqB,UAAU;AACtC,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,UAAU,CAAE;AAAA,MACZ,UAAU,YAAY,CAAE;AAAA,MACxB,OAAO,EAAE,OAAO,IAAI,OAAO,EAAC;AAAA,IAChC;AAAA,EACA;AAEA,WAAS,WAAY,KAAK;AACxB,UAAM,MAAM;AAAA,MACV,MAAM,IAAI,YAAY;AAAA,MACtB,KAAK,IAAI;AAAA,MACT,OAAO,IAAI;AAAA,IACf;AACE,eAAW,OAAO,KAAK;AACrB,UAAI,IAAI,GAAG,MAAM,QAAW;AAC1B,YAAI,GAAG,IAAI,IAAI,GAAG;AAAA,MACxB;AAAA,IACA;AACE,WAAO;AAAA,EACT;AAEA,WAAS,gBAAiB,MAAM;AAC9B,QAAI,OAAO,KAAK,cAAc,YAAY;AACxC,aAAO,KAAK;AAAA,IAChB;AACE,QAAI,KAAK,cAAc,OAAO;AAC5B,aAAO;AAAA,IACX;AACE,WAAO;AAAA,EACT;AAEA,WAAS,OAAQ;AAAE,WAAO,CAAE;AAAA,EAAA;AAC5B,WAAS,YAAa,GAAG;AAAE,WAAO;AAAA,EAAC;AACnC,WAAS,OAAQ;AAAA,EAAA;AAEjB,WAAS,WAAY;AAAE,WAAO;AAAA,EAAK;AACnC,WAAS,YAAa;AAAE,WAAO,KAAK,IAAK;AAAA,EAAA;AACzC,WAAS,WAAY;AAAE,WAAO,KAAK,MAAM,KAAK,IAAK,IAAG,GAAM;AAAA,EAAC;AAC7D,WAAS,UAAW;AAAE,WAAO,IAAI,KAAK,KAAK,IAAK,CAAA,EAAE;EAAe;AAIjE,WAAS,yBAA0B;AACjC,aAAS,KAAM,GAAG;AAAE,aAAO,OAAO,MAAM,eAAe;AAAA,IAAC;AACxD,QAAI;AACF,UAAI,OAAO,eAAe,YAAa,QAAO;AAC9C,aAAO,eAAe,OAAO,WAAW,cAAc;AAAA,QACpD,KAAK,WAAY;AACf,iBAAO,OAAO,UAAU;AACxB,iBAAQ,KAAK,aAAa;AAAA,QAC3B;AAAA,QACD,cAAc;AAAA,MACf,CAAA;AACD,aAAO;AAAA,IACR,SAAQ,GAAG;AACV,aAAO,KAAK,IAAI,KAAK,KAAK,MAAM,KAAK,KAAK,IAAI,KAAK,CAAA;AAAA,IACvD;AAAA,EACA;AAGAJ,UAAA,QAAA,UAAyB;AACzBA,UAAA,QAAA,OAAsB;;;","x_google_ignoreList":[0]}

package/dist/es/standards-sdk.es32.js

@@ -1,5 +1,5 @@
-const __viteBrowserExternal = {};
+var browser = { exports: {} };
 export {
-  __viteBrowserExternal as default
+  browser as __module
 };
 //# sourceMappingURL=standards-sdk.es32.js.map

package/dist/es/standards-sdk.es32.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es32.js","sources":["../../__vite-browser-external"],"sourcesContent":["export default {}"],"names":[],"mappings":"AAAA,MAAe,wBAAA,CAAA;"}
+{"version":3,"file":"standards-sdk.es32.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/es/standards-sdk.es33.js

@@ -1,5 +1,123 @@
-const version = "6.13.5";
+var quickFormatUnescaped;
+var hasRequiredQuickFormatUnescaped;
+function requireQuickFormatUnescaped() {
+  if (hasRequiredQuickFormatUnescaped) return quickFormatUnescaped;
+  hasRequiredQuickFormatUnescaped = 1;
+  function tryStringify(o) {
+    try {
+      return JSON.stringify(o);
+    } catch (e) {
+      return '"[Circular]"';
+    }
+  }
+  quickFormatUnescaped = format;
+  function format(f, args, opts) {
+    var ss = opts && opts.stringify || tryStringify;
+    var offset = 1;
+    if (typeof f === "object" && f !== null) {
+      var len = args.length + offset;
+      if (len === 1) return f;
+      var objects = new Array(len);
+      objects[0] = ss(f);
+      for (var index = 1; index < len; index++) {
+        objects[index] = ss(args[index]);
+      }
+      return objects.join(" ");
+    }
+    if (typeof f !== "string") {
+      return f;
+    }
+    var argLen = args.length;
+    if (argLen === 0) return f;
+    var str = "";
+    var a = 1 - offset;
+    var lastPos = -1;
+    var flen = f && f.length || 0;
+    for (var i = 0; i < flen; ) {
+      if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+        lastPos = lastPos > -1 ? lastPos : 0;
+        switch (f.charCodeAt(i + 1)) {
+          case 100:
+          // 'd'
+          case 102:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Number(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 105:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Math.floor(Number(args[a]));
+            lastPos = i + 2;
+            i++;
+            break;
+          case 79:
+          // 'O'
+          case 111:
+          // 'o'
+          case 106:
+            if (a >= argLen)
+              break;
+            if (args[a] === void 0) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            var type = typeof args[a];
+            if (type === "string") {
+              str += "'" + args[a] + "'";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            if (type === "function") {
+              str += args[a].name || "<anonymous>";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            str += ss(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 115:
+            if (a >= argLen)
+              break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += String(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 37:
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += "%";
+            lastPos = i + 2;
+            i++;
+            a--;
+            break;
+        }
+        ++a;
+      }
+      ++i;
+    }
+    if (lastPos === -1)
+      return f;
+    else if (lastPos < flen) {
+      str += f.slice(lastPos);
+    }
+    return str;
+  }
+  return quickFormatUnescaped;
+}
 export {
-  version
+  requireQuickFormatUnescaped as __require
 };
 //# sourceMappingURL=standards-sdk.es33.js.map

package/dist/es/standards-sdk.es33.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es33.js","sources":["../../node_modules/ethers/lib.esm/_version.js"],"sourcesContent":["/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */\n/**\n *  The current version of Ethers.\n */\nexport const version = \"6.13.5\";\n//# sourceMappingURL=_version.js.map"],"names":[],"mappings":"AAIY,MAAC,UAAU;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es33.js","sources":["../../node_modules/quick-format-unescaped/index.js"],"sourcesContent":["'use strict'\nfunction tryStringify (o) {\n  try { return JSON.stringify(o) } catch(e) { return '\"[Circular]\"' }\n}\n\nmodule.exports = format\n\nfunction format(f, args, opts) {\n  var ss = (opts && opts.stringify) || tryStringify\n  var offset = 1\n  if (typeof f === 'object' && f !== null) {\n    var len = args.length + offset\n    if (len === 1) return f\n    var objects = new Array(len)\n    objects[0] = ss(f)\n    for (var index = 1; index < len; index++) {\n      objects[index] = ss(args[index])\n    }\n    return objects.join(' ')\n  }\n  if (typeof f !== 'string') {\n    return f\n  }\n  var argLen = args.length\n  if (argLen === 0) return f\n  var str = ''\n  var a = 1 - offset\n  var lastPos = -1\n  var flen = (f && f.length) || 0\n  for (var i = 0; i < flen;) {\n    if (f.charCodeAt(i) === 37 && i + 1 < flen) {\n      lastPos = lastPos > -1 ? lastPos : 0\n      switch (f.charCodeAt(i + 1)) {\n        case 100: // 'd'\n        case 102: // 'f'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Number(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 105: // 'i'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Math.floor(Number(args[a]))\n          lastPos = i + 2\n          i++\n          break\n        case 79: // 'O'\n        case 111: // 'o'\n        case 106: // 'j'\n          if (a >= argLen)\n            break\n          if (args[a] === undefined) break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          var type = typeof args[a]\n          if (type === 'string') {\n            str += '\\'' + args[a] + '\\''\n            lastPos = i + 2\n            i++\n            break\n          }\n          if (type === 'function') {\n            str += args[a].name || '<anonymous>'\n            lastPos = i + 2\n            i++\n            break\n          }\n          str += ss(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 115: // 's'\n          if (a >= argLen)\n            break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += String(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 37: // '%'\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += '%'\n          lastPos = i + 2\n          i++\n          a--\n          break\n      }\n      ++a\n    }\n    ++i\n  }\n  if (lastPos === -1)\n    return f\n  else if (lastPos < flen) {\n    str += f.slice(lastPos)\n  }\n\n  return str\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}