// Module ID: 16485
// Function ID: 16486
// Name: _isNativeReflectConstruct
// Dependencies: [5, 41, 42, 93, 95, 98, 16486, 16488, 16490]

// Module 16485 (_isNativeReflectConstruct)
import asyncGeneratorStep from "_inherits";
import _classCallCheck from "_classCallCheck";
import _createClass from "_createClass";
import c4 from "_possibleConstructorReturn";
import _getPrototypeOf from "_getPrototypeOf";
import _inherits from "_inherits";

const PQueue = require;
let closure_1 = dependencyMap;
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);
    }
    let closure_0 = !callResult;
    function _isNativeReflectConstruct() {
      return closure_0;
    }
    return _isNativeReflectConstruct();
  } catch (err) {
  }
}
function empty() {

}
const timeoutError = new require("_isNativeReflectConstruct").TimeoutError();
closure_1 = undefined;
asyncGeneratorStep = undefined;
_classCallCheck = undefined;
c4 = undefined;
class PQueue {
  constructor(arg0) {
    self = this;
    tmp = f100204(this, PQueue);
    tmp2 = outer1_5;
    obj = outer1_5(PQueue);
    tmp3 = f100202;
    if (_isNativeReflectConstruct()) {
      tmp5 = globalThis;
      _Reflect = Reflect;
      constructResult = Reflect.construct(obj, [], tmp2(self).constructor);
    } else {
      constructResult = obj.apply(self, undefined);
    }
    tmp3Result = tmp3(self, constructResult);
    tmp3Result._intervalCount = 0;
    tmp3Result._intervalEnd = 0;
    tmp3Result._pendingCount = 0;
    tmp3Result._resolveEmpty = empty;
    tmp3Result._resolveIdle = empty;
    obj = { carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: require("PriorityQueue").default };
    merged = Object.assign(obj, global);
    if (typeof merged.intervalCap === "number") {
      num = 1;
      if (merged.intervalCap >= 1) {
        if (undefined !== merged.interval) {
          _Number = Number;
          if (Number.isFinite(merged.interval)) {
            if (merged.interval >= 0) {
              tmp3Result._carryoverConcurrencyCount = merged.carryoverConcurrencyCount;
              num2 = Infinity;
              tmp3Result._isIntervalIgnored = merged.intervalCap === Infinity || 0 === merged.interval;
              ({ intervalCap: tmp6._intervalCap, interval: tmp6._interval } = merged);
              tmp10 = new.target;
              tmp11 = new.target;
              queueClass = new merged.queueClass();
              tmp13 = queueClass;
              tmp3Result._queue = queueClass;
              ({ queueClass: tmp6._queueClass, concurrency: tmp6.concurrency, timeout: tmp6._timeout } = merged);
              flag = true;
              tmp3Result._throwOnTimeout = true === merged.throwOnTimeout;
              flag2 = false;
              tmp3Result._isPaused = false === merged.autoStart;
              return tmp3Result;
            }
          }
        }
        str3 = merged.interval;
        tmp14 = null;
        str = undefined;
        if (null !== str3) {
          if (undefined !== str3) {
            str = str3.toString();
          }
        }
        str4 = "";
        str5 = "";
        if (null !== str) {
          str5 = "";
          if (undefined !== str) {
            str5 = str;
          }
        }
        _HermesInternal = HermesInternal;
        str6 = ")";
        str7 = "` (";
        str8 = "Expected `interval` to be a finite number >= 0, got `";
        tmp16 = str5;
        tmp17 = new.target;
        tmp18 = new.target;
        typeError = new TypeError("Expected `interval` to be a finite number >= 0, got `" + str5 + "` (" + typeof merged.interval + ")");
        tmp20 = typeError;
        throw typeError;
      }
    }
    str = merged.intervalCap;
    str1 = undefined;
    if (null !== str) {
      if (undefined !== str) {
        str1 = str.toString();
      }
    }
    str2 = "";
    if (null !== str1) {
      str2 = "";
      if (undefined !== str1) {
        str2 = str1;
      }
    }
    typeError1 = new TypeError("Expected `intervalCap` to be a number from 1 and up, got `" + str2 + "` (" + typeof merged.intervalCap + ")");
    throw typeError1;
  }
}
_inherits(PQueue, require("Events"));
let obj = {
  key: "_doesIntervalAllowAnother",
  get() {
    const self = this;
    return this._isIntervalIgnored || self._intervalCount < self._intervalCap;
  }
};
const items = [
  obj,
  {
    key: "_doesConcurrentAllowAnother",
    get() {
      return this._pendingCount < this._concurrency;
    }
  },
  {
    key: "_next",
    value: function _next() {
      this._pendingCount = this._pendingCount - 1;
      this._tryToStartAnother();
      this.emit("next");
    }
  },
  {
    key: "_resolvePromises",
    value: function _resolvePromises() {
      const self = this;
      this._resolveEmpty();
      this._resolveEmpty = empty;
      if (0 === this._pendingCount) {
        self._resolveIdle();
        self._resolveIdle = tmp2;
        self.emit("idle");
      }
    }
  },
  {
    key: "_onResumeInterval",
    value: function _onResumeInterval() {
      this._onInterval();
      const result = this._initializeIntervalIfNeeded();
      this._timeoutId = undefined;
    }
  },
  {
    key: "_isIntervalPaused",
    value: function _isIntervalPaused() {
      let self = this;
      self = this;
      if (undefined === this._intervalId) {
        const diff = self._intervalEnd - tmp;
        if (diff < 0) {
          let num2 = 0;
          if (self._carryoverConcurrencyCount) {
            num2 = self._pendingCount;
          }
          self._intervalCount = num2;
        } else {
          if (undefined === self._timeoutId) {
            const _setTimeout = setTimeout;
            self._timeoutId = setTimeout(() => {
              self._onResumeInterval();
            }, diff);
          }
          return true;
        }
      }
      return false;
    }
  },
  {
    key: "_tryToStartAnother",
    value: function _tryToStartAnother() {
      const self = this;
      if (0 === this._queue.size) {
        if (self._intervalId) {
          const _clearInterval = clearInterval;
          clearInterval(self._intervalId);
        }
        self._intervalId = undefined;
        self._resolvePromises();
        return false;
      } else {
        if (!self._isPaused) {
          const _isIntervalPausedResult = self._isIntervalPaused();
          if (self._doesIntervalAllowAnother) {
            if (self._doesConcurrentAllowAnother) {
              const _queue = self._queue;
              const dequeueResult = _queue.dequeue();
              let flag = dequeueResult;
              if (flag) {
                self.emit("active");
                dequeueResult();
                flag = true;
                if (!_isIntervalPausedResult) {
                  const result = self._initializeIntervalIfNeeded();
                  flag = true;
                }
              }
              return flag;
            }
          }
        }
        return false;
      }
    }
  },
  {
    key: "_initializeIntervalIfNeeded",
    value: function _initializeIntervalIfNeeded() {
      let self = this;
      self = this;
      let _isIntervalIgnored = this._isIntervalIgnored;
      if (!_isIntervalIgnored) {
        _isIntervalIgnored = undefined !== self._intervalId;
      }
      if (!_isIntervalIgnored) {
        const _setInterval = setInterval;
        self._intervalId = setInterval(() => {
          self._onInterval();
        }, self._interval);
        const _Date = Date;
        self._intervalEnd = Date.now() + self._interval;
      }
    }
  },
  {
    key: "_onInterval",
    value: function _onInterval() {
      const self = this;
      if (tmp) {
        const _clearInterval = clearInterval;
        clearInterval(self._intervalId);
        self._intervalId = undefined;
      }
      let num = 0;
      if (self._carryoverConcurrencyCount) {
        num = self._pendingCount;
      }
      self._intervalCount = num;
      self._processQueue();
    }
  },
  {
    key: "_processQueue",
    value: function _processQueue() {
      let _tryToStartAnotherResult;
      const self = this;
      if (this._tryToStartAnother()) {
        do {
          _tryToStartAnotherResult = self._tryToStartAnother();
        } while (_tryToStartAnotherResult);
      }
    }
  },
  {
    key: "concurrency",
    get() {
      return this._concurrency;
    },
    set(num) {
      if (typeof num === "number") {
        if (num >= 1) {
          const self = this;
          this._concurrency = num;
          this._processQueue();
        }
      }
      const typeError = new TypeError("Expected `concurrency` to be a number from 1 and up, got `" + num + "` (" + typeof num + ")");
      throw typeError;
    }
  },
,
,
,
,
,
,
,
,
,
,
,

];
obj = { key: "add", value: null };
c4 = asyncGeneratorStep(function(arg0) {
  let self = this;
  let closure_1 = arg0;
  let closure_2 = arg1;
  let c5 = 0;
  let c6 = 0;
  const iter = (function*(arg0) {
    let closure_4 = closure_0;
    let closure_3 = tmp2;
    closure_3 = closure_0;
    if (obj1 === undefined) {
      obj1 = {};
    }
    yield "ct";
    closure_0 = closure_4;
    const promise = new Promise((arg0, arg1) => {
      let closure_0 = arg0;
      let closure_1 = arg1;
      closure_0 = obj1(function*() {
        if (c5 === 2) {
          c5 = 3;
          HermesBuiltin.throwTypeError();
        } else if (tmp6 === 3) {
          if (arg0 === 1) {
            throw arg1;
          } else if (arg0 === 2) {
            let obj = { value: null, done: true };
            obj[0] = arg1;
            return obj;
          } else {
            return { value: "HermesInternal", done: null };
          }
        } else {
          try {
            c5 = 2;
            if (0 === c4) {
              if (arg0 === 1) {
                c5 = 3;
                throw arg1;
              } else if (arg0 === 2) {
                c5 = 3;
                obj = { value: null, done: true };
                obj[0] = arg1;
                return obj;
              } else {
                const dependencyMap = tmp3;
                lib._pendingCount = lib._pendingCount + 1;
                lib._intervalCount = lib._intervalCount + 1;
                let c3 = 1;
                if (undefined !== lib._timeout) {
                  const resolved = Promise.resolve(dependencyMap());
                  if (undefined === outer2_2.timeout) {
                    let timeout = lib._timeout;
                  } else {
                    timeout = tmp23.timeout;
                  }
                  lib(16486).default(resolved, timeout, () => {
                    if (undefined === tmp29.throwOnTimeout) {
                      let throwOnTimeout = _throwOnTimeout._throwOnTimeout;
                    } else {
                      throwOnTimeout = tmp.throwOnTimeout;
                    }
                    if (throwOnTimeout) {
                      tmp3(outer2_8);
                    }
                  });
                  lib = outer1_0;
                  c4 = 2;
                  c5 = 1;
                  const obj2 = lib(16486);
                }
                dependencyMap();
              }
            } else {
              if (1 === tmp7) {
                c3 = 0;
                outer1_1(closure_2);
                lib._next();
                c5 = 3;
              } else if (arg0 === 1) {
                c5 = 3;
                throw arg1;
              } else if (arg0 !== 2) {
                lib(arg1);
                c3 = 0;
              }
              c3 = 0;
              c5 = 3;
              obj = { value: null, done: true };
              obj[0] = arg1;
              return obj;
            }
          } catch (tmp29) {
            closure_2 = tmp29;
            if (tmp4 === c3) {
              c5 = tmp2;
              throw tmp29;
            } else {
              c4 = tmp;
            }
          }
        }
      });
      const _queue = closure_3._queue;
      _queue.enqueue(function run() {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      }, obj1);
      closure_3._tryToStartAnother();
      closure_3.emit("add");
    });
    return promise;
  })();
  iter.next();
  return iter;
});
obj[1] = function add(arg0) {
  const self = this;
  const apply = closure_4.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
};
items[11] = obj;
obj = { key: "addAll", value: null };
_classCallCheck = asyncGeneratorStep(function(arg0, arg1) {
  let self = this;
  let closure_1 = arg0;
  let closure_2 = arg1;
  let c3 = 0;
  return (function*(arg0, arg1) {
    if (c3 === 2) {
      c3 = 3;
      HermesBuiltin.throwTypeError();
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw arg1;
      } else if (arg0 === 2) {
        let obj = { value: null, done: true };
        obj[0] = arg1;
        return obj;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c3 = 2;
        if (arg0 === 1) {
          c3 = 3;
          throw arg1;
        } else if (arg0 === 2) {
          c3 = 3;
          obj = { value: null, done: true };
          obj[0] = arg1;
          return obj;
        } else {
          let closure_0 = closure_2;
          let closure_1 = closure_0;
          c3 = 3;
          obj = { value: null, done: true };
          obj[0] = Promise.all(closure_1.map((() => {
            let closure_0 = outer1_2((arg0) => {
              let closure_0 = arg0;
              let c1 = 0;
              return (function*(arg0) {
                if (set === 2) {
                  set = 3;
                  HermesBuiltin.throwTypeError();
                } else if (tmp3 === 3) {
                  if (arg0 === 1) {
                    throw arg1;
                  } else if (arg0 === 2) {
                    let obj = { value: null, done: true };
                    obj[0] = arg1;
                    return obj;
                  } else {
                    return { value: "HermesInternal", done: null };
                  }
                } else {
                  try {
                    set = 2;
                    if (arg0 === 1) {
                      set = 3;
                      throw arg1;
                    } else if (arg0 === 2) {
                      set = 3;
                      obj = { value: null, done: true };
                      obj[0] = arg1;
                      return obj;
                    } else {
                      set = 3;
                      obj = { value: null, done: true };
                      obj[0] = set.add(closure_0, closure_0);
                      return obj;
                    }
                  } catch (tmp7) {
                    set = tmp;
                    throw tmp7;
                  }
                }
              })();
            });
            return function(arg0) {
              const self = this;
              const apply = closure_0.apply;
              if (typeof apply === "unknown") {
                let applyArgumentsResult = HermesBuiltin.applyArguments(self);
              } else {
                applyArgumentsResult = apply(self, arguments);
              }
              return applyArgumentsResult;
            };
          })()));
          return obj;
        }
      } catch (tmp8) {
        c3 = tmp;
        throw tmp8;
      }
    }
  })();
});
obj[1] = function addAll(arg0, arg1) {
  const self = this;
  const apply = _classCallCheck.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
};
items[12] = obj;
items[13] = {
  key: "start",
  value: function start() {
    const self = this;
    if (this._isPaused) {
      self._isPaused = false;
      self._processQueue();
    }
    return self;
  }
};
items[14] = {
  key: "pause",
  value: function pause() {
    this._isPaused = true;
  }
};
items[15] = {
  key: "clear",
  value: function clear() {
    const _queueClass = new this._queueClass();
    this._queue = _queueClass;
  }
};
let obj1 = { key: "onEmpty", value: null };
asyncGeneratorStep = asyncGeneratorStep(function() {
  const self = this;
  let c1 = 0;
  return (function*() {
    if (c1 === 2) {
      c1 = 3;
      HermesBuiltin.throwTypeError();
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw arg1;
      } else if (arg0 === 2) {
        let obj = { value: null, done: true };
        obj[0] = arg1;
        return obj;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c1 = 2;
        if (arg0 === 1) {
          c1 = 3;
          throw arg1;
        } else if (arg0 === 2) {
          c1 = 3;
          obj = { value: null, done: true };
          obj[0] = arg1;
          return obj;
        } else if (0 !== _self._queue.size) {
          const promise = new Promise((arg0) => {
            let _resolveEmpty = arg0;
            _resolveEmpty = _resolveEmpty._resolveEmpty;
            _resolveEmpty._resolveEmpty = () => {
              _resolveEmpty();
              callback();
            };
          });
          c1 = 3;
          obj = { value: null, done: true };
          obj[0] = promise;
          return obj;
        } else {
          c1 = 3;
          return { value: "HermesInternal", done: null };
        }
      } catch (tmp10) {
        c1 = tmp;
        throw tmp10;
      }
    }
  })();
});
obj1[1] = function onEmpty() {
  const self = this;
  const apply = asyncGeneratorStep.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
};
items[16] = obj1;
let obj2 = { key: "onIdle", value: null };
closure_1 = asyncGeneratorStep(function() {
  const self = this;
  let c1 = 0;
  return (function*() {
    if (c1 === 2) {
      c1 = 3;
      HermesBuiltin.throwTypeError();
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw arg1;
      } else if (arg0 === 2) {
        let obj = { value: null, done: true };
        obj[0] = arg1;
        return obj;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c1 = 2;
        if (arg0 === 1) {
          c1 = 3;
          throw arg1;
        } else if (arg0 === 2) {
          c1 = 3;
          obj = { value: null, done: true };
          obj[0] = arg1;
          return obj;
        } else {
          if (0 === _self._pendingCount) {
            if (0 === _self._queue.size) {
              c1 = 3;
              return { value: "HermesInternal", done: null };
            }
          }
          const promise = new Promise((arg0) => {
            let _resolveIdle = arg0;
            _resolveIdle = _resolveIdle._resolveIdle;
            _resolveIdle._resolveIdle = () => {
              _resolveIdle();
              callback();
            };
          });
          c1 = 3;
          obj = { value: null, done: true };
          obj[0] = promise;
          return obj;
        }
      } catch (tmp9) {
        c1 = tmp;
        throw tmp9;
      }
    }
  })();
});
obj2[1] = function onIdle() {
  const self = this;
  const apply = closure_1.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
};
items[17] = obj2;
items[18] = {
  key: "size",
  get() {
    return this._queue.size;
  }
};
items[19] = {
  key: "sizeBy",
  value: function sizeBy(arg0) {
    const _queue = this._queue;
    return _queue.filter(arg0).length;
  }
};
items[20] = {
  key: "pending",
  get() {
    return this._pendingCount;
  }
};
items[21] = {
  key: "isPaused",
  get() {
    return this._isPaused;
  }
};
items[22] = {
  key: "timeout",
  get() {
    return this._timeout;
  },
  set(_timeout) {
    this._timeout = _timeout;
  }
};

export default _createClass(PQueue, items);