// Module ID: 217
// Function ID: 218
// Dependencies: [109, 41, 42, 93, 95, 98, 209, 218, 38, 200, 203, 212, 206, 220, 133, 221, 205, 132]

// Module 217
import _modDef38 from "module_38" /* 38 */;
import dispatchDefault from "dispatch" /* 132 */;
import EventDefault from "Event" /* 133 */;
import BlobManagerDefault from "BlobManager" /* 200 */;
import BlobDefault from "Blob" /* 203 */;
import byteLengthDefault from "byteLength" /* 206 */;
import NativeEventEmitterDefault from "NativeEventEmitter" /* 209 */;
import WebSocketModuleDefault from "WebSocketModule" /* 218 */;
import _modDef220 from "module_220" /* 220 */;
import _modDef221 from "module_221" /* 221 */;
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
import _classCallCheck from "_classCallCheck" /* 41 */;
import _createClass from "_createClass" /* 42 */;
import metroRequire from "_possibleConstructorReturn" /* 93 */;
import _getPrototypeOf from "_getPrototypeOf" /* 95 */;
import _inherits from "_inherits" /* 98 */;

const WebSocket = arg1;
function _isNativeReflectConstruct() {
  try {
    const _Boolean = Boolean;
    const call = valueOf.call;
    const _Reflect = Reflect;
    const _Boolean2 = Boolean;
    if (typeof call === "unknown") {
      let callResult = valueOf();
    } else {
      callResult = call(constructResult);
    }
    closure_0 = !callResult;
    _isNativeReflectConstruct = function _isNativeReflectConstruct() {
      return closure_0;
    };
    return _isNativeReflectConstruct();
  } catch (err) {
  }
}
let closure_3 = ["headers"];
let c9 = 0;
class WebSocket {
  constructor(arg0, arg1, arg2) {
    self = this;
    tmp3 = hasOwnProperty(this, WebSocket);
    tmp4 = closure_7;
    obj = closure_7(WebSocket);
    tmp5 = metroRequire;
    if (closure_8()) {
      tmp7 = globalThis;
      _Reflect = Reflect;
      constructResult = Reflect.construct(obj, [], tmp4(self).constructor);
    } else {
      constructResult = obj.apply(self, undefined);
    }
    tmp5Result = tmp5(self, constructResult);
    tmp5Result.CONNECTING = 0;
    tmp5Result.OPEN = 1;
    tmp5Result.CLOSING = 2;
    tmp5Result.CLOSED = 3;
    tmp5Result.readyState = 0;
    tmp5Result.url = global;
    tmp8 = arg1;
    if (typeof arg1 === "string") {
      items = [];
      items[0] = arg1;
      tmp8 = items;
    }
    obj1 = importDefault;
    if (!importDefault) {
      obj1 = {};
    }
    headers = obj1.headers;
    if (undefined === headers) {
      headers = {};
    }
    tmp9 = closure_4(obj1, closure_3);
    tmp10 = tmp9;
    if (tmp9) {
      tmp10 = typeof tmp9.origin === "string";
    }
    if (tmp10) {
      tmp11 = globalThis;
      _console = console;
      str = "Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.";
      warnResult = console.warn("Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.");
      headers.origin = tmp9.origin;
      str2 = "origin";
      delete tmp2[tmp];
    }
    if (Object.keys(tmp9).length > 0) {
      _console2 = console;
      _Object = Object;
      keys = Object.keys(tmp9);
      str3 = "`, `";
      str4 = "Unrecognized WebSocket connection option(s) `";
      str5 = "`. Did you mean to put these under `headers`?";
      warnResult1 = console.warn(`Unrecognized WebSocket connection option(s) \`${obj5.join("`, `")}\`. Did you mean to put these under \`headers\`?`);
    }
    tmp14 = tmp8;
    if (!Array.isArray(tmp8)) {
      tmp14 = null;
    }
    tmp15 = new closure_1(c2[6])(null);
    tmp5Result._eventEmitter = tmp15;
    tmp16 = +closure_9;
    closure_9 = tmp16 + 1;
    tmp5Result._socketId = tmp16;
    _registerEventsResult = tmp5Result._registerEvents();
    obj6 = closure_1(c2[7]);
    obj8 = { headers };
    connectResult = obj6.connect(global, tmp14, obj8, tmp5Result._socketId);
    return tmp5Result;
  }
}
_inherits(WebSocket, dispatchDefault);
let items = [
  {
    key: "binaryType",
    get() {
      return this._binaryType;
    },
    set(_binaryType) {
      if ("blob" !== _binaryType) {
        if ("arraybuffer" !== _binaryType) {
          const _Error = Error;
          const error = new Error("binaryType must be either 'blob' or 'arraybuffer'");
          throw error;
        }
      }
      const self = this;
      if (!tmp2) {
        _modDef38(BlobManagerDefault.isAvailable, "Native module BlobModule is required for blob support");
        if ("blob" === _binaryType) {
          tmp3(200).addWebSocketHandler(self._socketId);
          const tmp3Result = tmp3(200);
        } else {
          const result = tmp3(200).removeWebSocketHandler(self._socketId);
          const tmp3Result2 = tmp3(200);
        }
      }
      self._binaryType = _binaryType;
    }
  },
  {
    key: "close",
    value: function close(arg0, arg1) {
      const self = this;
      if (tmp) {
        self.readyState = self.CLOSING;
        self._close(arg0, arg1);
      }
    }
  },
  {
    key: "send",
    value: function send(str) {
      const self = this;
      if (this.readyState === this.CONNECTING) {
        const _Error2 = Error;
        const error = new Error("INVALID_STATE_ERR");
        throw error;
      } else if (str instanceof BlobDefault) {
        tmp16(38)(tmp16(200).isAvailable, "Native module BlobModule is required for blob support");
        const tmp16Result = tmp16(38);
        tmp16(200).sendOverSocket(str, self._socketId);
      } else if (typeof str !== "string") {
        const _ArrayBuffer = ArrayBuffer;
        if (!(str instanceof ArrayBuffer)) {
          const _ArrayBuffer2 = ArrayBuffer;
          if (!ArrayBuffer.isView(str)) {
            const _Error = Error;
            const error1 = new Error("Unsupported data type");
            throw error1;
          }
        }
        tmp16(218).sendBinary(tmp16(212)(str), self._socketId);
        const tmp16Result5 = tmp16(218);
      } else {
        tmp16(218).send(str, self._socketId);
        const tmp16Result6 = tmp16(218);
      }
    }
  },
  {
    key: "ping",
    value: function ping() {
      if (this.readyState === this.CONNECTING) {
        const _Error = Error;
        const error = new Error("INVALID_STATE_ERR");
        throw error;
      } else {
        WebSocketModuleDefault.ping(tmp._socketId);
      }
    }
  },
  {
    key: "_close",
    value: function _close(num, str) {
      num = 1000;
      str = "";
      const self = this;
      WebSocketModuleDefault.close(num, str, this._socketId);
      let isAvailable = BlobManagerDefault.isAvailable;
      if (isAvailable) {
        isAvailable = "blob" === self._binaryType;
      }
      if (isAvailable) {
        const result = BlobManagerDefault.removeWebSocketHandler(self._socketId);
        const tmpResult = BlobManagerDefault;
      }
    }
  },
  {
    key: "_unregisterEvents",
    value: function _unregisterEvents() {
      const _subscriptions = this._subscriptions;
      const item = _subscriptions.forEach((remove) => remove.remove());
      this._subscriptions = [];
    }
  },
  {
    key: "_registerEvents",
    value: function _registerEvents() {
      const self = this;
      const _eventEmitter = this._eventEmitter;
      const items = [
        _eventEmitter.addListener("websocketMessage", (id) => {
          let dispatchEventResult = id;
          if (id.id === self._socketId) {
            ({ data, type } = dispatchEventResult);
            if ("binary" === type) {
              data = byteLengthDefault.toByteArray(dispatchEventResult.data).buffer;
            } else if ("blob" === type) {
              data = BlobManagerDefault.createFromOptions(dispatchEventResult.data);
            }
            const obj4 = { data, raw_length: dispatchEventResult.raw_length };
            const tmp11 = new _modDef220("message", obj4);
            dispatchEventResult = self.dispatchEvent(tmp11);
          }
        }),
      ,
      ,

      ];
      const _eventEmitter2 = this._eventEmitter;
      items[1] = _eventEmitter2.addListener("websocketOpen", (id) => {
        if (id.id === self._socketId) {
          obj.readyState = obj.OPEN;
          obj.protocol = id.protocol;
          const tmp5 = new EventDefault("open");
          obj.dispatchEvent(tmp5);
        }
      });
      const _eventEmitter3 = this._eventEmitter;
      items[2] = _eventEmitter3.addListener("websocketClosed", (id) => {
        if (id.id === self._socketId) {
          obj.readyState = obj.CLOSED;
          const obj3 = { code: null, reason: null };
          ({ code: obj2.code, reason: obj2.reason } = id);
          const tmp6 = new _modDef221("close", obj3);
          obj.dispatchEvent(tmp6);
          obj._unregisterEvents();
          obj.close();
        }
      });
      const _eventEmitter4 = this._eventEmitter;
      items[3] = _eventEmitter4.addListener("websocketFailed", (id) => {
        if (id.id === self._socketId) {
          obj.readyState = obj.CLOSED;
          const tmp5 = new EventDefault("error");
          obj.dispatchEvent(tmp5);
          const obj2 = { code: 1006, reason: id.message };
          const tmp11 = new _modDef221("close", obj2);
          obj.dispatchEvent(tmp11);
          obj._unregisterEvents();
          obj.close();
        }
      });
      this._subscriptions = items;
    }
  },
  {
    key: "onclose",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "close");
    },
    set(handleEvent) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "close", handleEvent);
    }
  },
  {
    key: "onerror",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "error");
    },
    set(handleEvent) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "error", handleEvent);
    }
  },
  {
    key: "onmessage",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "message");
    },
    set(handleEvent) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "message", handleEvent);
    }
  },
  {
    key: "onopen",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "open");
    },
    set(handleEvent) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "open", handleEvent);
    }
  }
];
const importDefaultResultResult = _createClass(WebSocket, items);
importDefaultResultResult.CONNECTING = 0;
importDefaultResultResult.OPEN = 1;
importDefaultResultResult.CLOSING = 2;
importDefaultResultResult.CLOSED = 3;

export default importDefaultResultResult;