text: // Licensed to the .NET Foundation under one or more agreements.
  // The .NET Foundation licenses this file to you under the MIT license.
  import { LogLevel } from "./ILogger";
  import { NullLogger } from "./Loggers";
  // Version token that will be replaced by the prepack command
  /** The version of the SignalR client. */
  export const VERSION = "6.0.0";
  /** @private */
  export class Arg {
      static isRequired(val, name) {
          if (val === null || val === undefined) {
              throw new Error(`The '${name}' argument is required.`);
          }
      }
      static isNotEmpty(val, name) {
          if (!val || val.match(/^\s*$/)) {
              throw new Error(`The '${name}' argument should not be empty.`);
          }
      }
      static isIn(val, values, name) {
          // TypeScript enums have keys for **both** the name and the value of each enum member on the type itself.
          if (!(val in values)) {
              throw new Error(`Unknown ${name} value: ${val}.`);
          }
      }
  }
  /** @private */
  export class Platform {
      static get isBrowser() {
          return typeof window === "object";
      }
      static get isWebWorker() {
          return typeof self === "object" && "importScripts" in self;
      }
      static get isNode() {
          return !this.isBrowser && !this.isWebWorker;
      }
  }
  /** @private */
  export function getDataDetail(data, includeContent) {
      let detail = "";
      if (isArrayBuffer(data)) {
          detail = `Binary data of length ${data.byteLength}`;
          if (includeContent) {
              detail += `. Content: '${formatArrayBuffer(data)}'`;
          }
      }
      else if (typeof data === "string") {
          detail = `String data of length ${data.length}`;
          if (includeContent) {
              detail += `. Content: '${data}'`;
          }
      }
      return detail;
  }
  /** @private */
  export function formatArrayBuffer(data) {
      const view = new Uint8Array(data);
      // Uint8Array.map only supports returning another Uint8Array?
      let str = "";
      view.forEach((num) => {
          const pad = num < 16 ? "0" : "";
          str += `0x${pad}${num.toString(16)} `;
      });
      // Trim of trailing space.
      return str.substr(0, str.length - 1);
  }
  // Also in signalr-protocol-msgpack/Utils.ts
  /** @private */
  export function isArrayBuffer(val) {
      return val && typeof ArrayBuffer !== "undefined" &&
          (val instanceof ArrayBuffer ||
              // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof
              (val.constructor && val.constructor.name === "ArrayBuffer"));
  }
  /** @private */
  export async function sendMessage(logger, transportName, httpClient, url, accessTokenFactory, content, options) {
      let headers = {};
      if (accessTokenFactory) {
          const token = await accessTokenFactory();
          if (token) {
              headers = {
                  ["Authorization"]: `Bearer ${token}`,
              };
          }
      }
      const [name, value] = getUserAgentHeader();
      headers[name] = value;
      logger.log(LogLevel.Trace, `(${transportName} transport) sending data. ${getDataDetail(content, options.logMessageContent)}.`);
      const responseType = isArrayBuffer(content) ? "arraybuffer" : "text";
      const response = await httpClient.post(url, {
          content,
          headers: { ...headers, ...options.headers },
          responseType,
          timeout: options.timeout,
          withCredentials: options.withCredentials,
      });
      logger.log(LogLevel.Trace, `(${transportName} transport) request complete. Response status: ${response.statusCode}.`);
  }
  /** @private */
  export function createLogger(logger) {
      if (logger === undefined) {
          return new ConsoleLogger(LogLevel.Information);
      }
      if (logger === null) {
          return NullLogger.instance;
      }
      if (logger.log !== undefined) {
          return logger;
      }
      return new ConsoleLogger(logger);
  }
  /** @private */
  export class SubjectSubscription {
      constructor(subject, observer) {
          this._subject = subject;
          this._observer = observer;
      }
      dispose() {
          const index = this._subject.observers.indexOf(this._observer);
          if (index > -1) {
              this._subject.observers.splice(index, 1);
          }
          if (this._subject.observers.length === 0 && this._subject.cancelCallback) {
              this._subject.cancelCallback().catch((_) => { });
          }
      }
  }
  /** @private */
  export class ConsoleLogger {
      constructor(minimumLogLevel) {
          this._minLevel = minimumLogLevel;
          this.out = console;
      }
      log(logLevel, message) {
          if (logLevel >= this._minLevel) {
              const msg = `[${new Date().toISOString()}] ${LogLevel[logLevel]}: ${message}`;
              switch (logLevel) {
                  case LogLevel.Critical:
                  case LogLevel.Error:
                      this.out.error(msg);
                      break;
                  case LogLevel.Warning:
                      this.out.warn(msg);
                      break;
                  case LogLevel.Information:
                      this.out.info(msg);
                      break;
                  default:
                      // console.debug only goes to attached debuggers in Node, so we use console.log for Trace and Debug
                      this.out.log(msg);
                      break;
              }
          }
      }
  }
  /** @private */
  export function getUserAgentHeader() {
      let userAgentHeaderName = "X-SignalR-User-Agent";
      if (Platform.isNode) {
          userAgentHeaderName = "User-Agent";
      }
      return [userAgentHeaderName, constructUserAgent(VERSION, getOsName(), getRuntime(), getRuntimeVersion())];
  }
  /** @private */
  export function constructUserAgent(version, os, runtime, runtimeVersion) {
      // Microsoft SignalR/[Version] ([Detailed Version]; [Operating System]; [Runtime]; [Runtime Version])
      let userAgent = "Microsoft SignalR/";
      const majorAndMinor = version.split(".");
      userAgent += `${majorAndMinor[0]}.${majorAndMinor[1]}`;
      userAgent += ` (${version}; `;
      if (os && os !== "") {
          userAgent += `${os}; `;
      }
      else {
          userAgent += "Unknown OS; ";
      }
      userAgent += `${runtime}`;
      if (runtimeVersion) {
          userAgent += `; ${runtimeVersion}`;
      }
      else {
          userAgent += "; Unknown Runtime Version";
      }
      userAgent += ")";
      return userAgent;
  }
  // eslint-disable-next-line spaced-comment
  /*#__PURE__*/ function getOsName() {
      if (Platform.isNode) {
          switch (process.platform) {
              case "win32":
                  return "Windows NT";
              case "darwin":
                  return "macOS";
              case "linux":
                  return "Linux";
              default:
                  return process.platform;
          }
      }
      else {
          return "";
      }
  }
  // eslint-disable-next-line spaced-comment
  /*#__PURE__*/ function getRuntimeVersion() {
      if (Platform.isNode) {
          return process.versions.node;
      }
      return undefined;
  }
  function getRuntime() {
      if (Platform.isNode) {
          return "NodeJS";
      }
      else {
          return "Browser";
      }
  }
  /** @private */
  export function getErrorString(e) {
      if (e.stack) {
          return e.stack;
      }
      else if (e.message) {
          return e.message;
      }
      return `${e}`;
  }
  /** @private */
  export function getGlobalThis() {
      // globalThis is semi-new and not available in Node until v12
      if (typeof globalThis !== "undefined") {
          return globalThis;
      }
      if (typeof self !== "undefined") {
          return self;
      }
      if (typeof window !== "undefined") {
          return window;
      }
      if (typeof global !== "undefined") {
          return global;
      }
      throw new Error("could not find global");
  }
  //# sourceMappingURL=Utils.js.map