// Module ID: 1386
// Function ID: 1387
// Name: priv
// Dependencies: [1387, 1389, 1390]

// Module 1386 (priv)
function priv(self, lruList, max) {
  if (table[lruList]) {
    let tmp3 = tmp[lruList];
  } else {
    tmp3 = callback(lruList);
    tmp[lruList] = tmp3;
  }
  if (2 === arguments.length) {
    let tmp4 = self[tmp3];
  } else {
    tmp4 = max;
    self[tmp3] = max;
  }
  return tmp4;
}
function naiveLength() {
  return 1;
}
class LRUCache {
  constructor(arg0) {
    self = this;
    tmp = LRUCache;
    if (this instanceof LRUCache) {
      obj = global;
      if (typeof global === "number") {
        obj = { max: null };
        obj[0] = global;
      }
      if (!obj) {
        obj = {};
      }
      tmp4 = priv;
      str = "max";
      tmp5 = priv(self, "max", obj.max);
      tmp6 = !tmp5;
      if (tmp5) {
        tmp6 = typeof tmp5 !== "number";
      }
      if (!tmp6) {
        num = 0;
        tmp6 = tmp5 <= 0;
      }
      if (tmp6) {
        num2 = Infinity;
        tmp4Result = tmp4(self, "max", Infinity);
      }
      tmp8 = obj.length || naiveLength;
      if (typeof tmp8 !== "function") {
        tmp8 = naiveLength;
      }
      str2 = "lengthCalculator";
      tmp4Result1 = tmp4(self, "lengthCalculator", tmp8);
      tmp10 = obj.stale || false;
      str3 = "allowStale";
      tmp4Result2 = tmp4(self, "allowStale", tmp10);
      tmp12 = obj.maxAge || 0;
      str4 = "maxAge";
      tmp4Result3 = tmp4(self, "maxAge", tmp12);
      str5 = "dispose";
      tmp4Result4 = tmp4(self, "dispose", obj.dispose);
      resetResult = self.reset();
      return;
    } else {
      tmpResult = tmp(global);
      tmp3 = tmpResult;
      return tmpResult;
    }
  }
  rforEach(arg0, arg1) {
    self = this;
    tmp = require;
    if (!require) {
      tmp = self;
    }
    prev = priv(self, "lruList").tail;
    if (null !== prev) {
      do {
        tmp3 = forEachStep;
        tmp4 = self;
        tmp5 = global;
        tmp6 = prev;
        tmp7 = tmp;
        tmp8 = forEachStep(self, global, prev, tmp);
        prev = prev.prev;
      } while (null !== tmp2);
    }
    return;
  }
  forEach(arg0, arg1) {
    self = this;
    tmp = require;
    if (!require) {
      tmp = self;
    }
    iter = priv(self, "lruList").head;
    if (null !== iter) {
      do {
        tmp3 = forEachStep;
        tmp4 = self;
        tmp5 = global;
        tmp6 = iter;
        tmp7 = tmp;
        tmp8 = forEachStep(self, global, iter, tmp);
        iter = iter.next;
      } while (null !== tmp2);
    }
    return;
  }
  keys() {
    obj = priv(this, "lruList");
    toArrayResult = obj.toArray();
    return toArrayResult.map((key) => key.key, this);
  }
  values() {
    obj = priv(this, "lruList");
    toArrayResult = obj.toArray();
    return toArrayResult.map((value) => value.value, this);
  }
  reset() {
    self = this;
    tmp = priv;
    length = priv(this, "dispose");
    if (length) {
      str = "lruList";
      length = tmp(self, "lruList");
    }
    if (length) {
      str2 = "lruList";
      length = tmp(self, "lruList").length;
    }
    if (length) {
      str3 = "lruList";
      tmpResult = tmp(self, "lruList");
      item = tmpResult.forEach(function(arg0) {
        let key;
        let value;
        const self = this;
        const tmp = callback(this, "dispose");
        const call = tmp.call;
        ({ key, value } = arg0);
        if (typeof call === "unknown") {
          tmp(key, value);
        } else {
          call(self, key, value);
        }
      }, self);
    }
    tmp3 = new require("PseudoMap")();
    tmpResult1 = tmp(self, "cache", tmp3);
    tmp5 = new require("Yallist")();
    tmpResult2 = tmp(self, "lruList", tmp5);
    tmpResult3 = tmp(self, "length", 0);
    return;
  }
  dump() {
    arr = priv(this, "lruList");
    mapped = arr.map(function(maxAge) {
      let now;
      let flag = false;
      if (maxAge) {
        const self = this;
        if (!maxAge.maxAge) {
          flag = false;
        }
        const _Date = Date;
        const diff = Date.now() - maxAge.now;
        if (maxAge.maxAge) {
          let tmp5 = diff > maxAge.maxAge;
        } else {
          tmp5 = callback(self, "maxAge") && diff > callback(self, "maxAge");
          const tmp4 = callback;
        }
      }
      if (!flag) {
        const obj = { k: null, v: null, e: null };
        ({ key: obj[0], value: obj[1], maxAge, now } = maxAge);
        if (!maxAge) {
          maxAge = 0;
        }
        obj[2] = now + maxAge;
        return obj;
      }
    }, this);
    toArrayResult = mapped.toArray();
    return toArrayResult.filter((arg0) => arg0);
  }
  dumpLru() {
    return priv(this, "lruList");
  }
  inspect(arg0, arg1) {
    self = this;
    closure_0 = require;
    c1 = "LRUCache {";
    c2 = false;
    tmp = priv;
    flag = false;
    if (priv(this, "allowStale")) {
      tmp2 = c1;
      str = "\n  allowStale: true";
      c1 = `${c1}
  allowStale: true`;
      flag2 = true;
      c2 = true;
      flag = true;
    }
    tmpResult = tmp(self, "max");
    tmp4 = tmpResult;
    if (tmpResult) {
      num = Infinity;
      tmp4 = tmpResult !== Infinity;
    }
    flag3 = flag;
    if (tmp4) {
      if (flag) {
        tmp5 = c1;
        str2 = ",";
        c1 = `${c1},`;
      }
      tmp6 = c1;
      tmp7 = closure_0;
      tmp8 = c1;
      obj = require("inspect");
      str3 = "\n  max: ";
      c1 = `${c1}
  max: ${obj.inspect(tmp3, require)}`;
      flag4 = true;
      c2 = true;
      flag3 = true;
    }
    tmpResult1 = tmp(self, "maxAge");
    closure_3 = tmpResult1;
    flag5 = flag3;
    if (tmpResult1) {
      if (flag3) {
        tmp10 = c1;
        str4 = ",";
        c1 = `${c1},`;
      }
      tmp11 = c1;
      tmp12 = closure_0;
      tmp13 = c1;
      obj2 = require("inspect");
      str5 = "\n  maxAge: ";
      c1 = `${c1}
  maxAge: ${obj2.inspect(tmp9, require)}`;
      flag6 = true;
      c2 = true;
      flag5 = true;
    }
    tmpResult2 = tmp(self, "lengthCalculator");
    priv = tmpResult2;
    tmp15 = tmpResult2;
    if (tmpResult2) {
      tmp16 = c5;
      tmp15 = tmpResult2 !== c5;
    }
    flag7 = flag5;
    if (tmp15) {
      if (flag5) {
        tmp17 = c1;
        str6 = ",";
        c1 = `${c1},`;
      }
      tmp18 = c1;
      tmp19 = closure_0;
      tmp20 = c1;
      tmp21 = require("inspect");
      str7 = "length";
      str8 = "\n  length: ";
      c1 = `${c1}
  length: ${tmp22(tmp(self, "length"), require)}`;
      flag8 = true;
      c2 = true;
      flag7 = true;
    }
    c5 = false;
    tmpResult3 = tmp(self, "lruList");
    item = tmpResult3.forEach(function(key) {
      if (c5) {
        let table = `${closure_1},
        `;
      } else {
        if (c2) {
          table = `${closure_1},
      `;
        }
        c5 = true;
        table = `${closure_1}
        `;
      }
      let maxAge = key;
      let obj = callback(table[2]);
      const parts = obj.inspect(key.key).split("\n");
      obj = { value: key.value };
      const joined = parts.join("\n  ");
      if (key.maxAge !== closure_3) {
        obj.maxAge = maxAge.maxAge;
      }
      if (tmpResult1 !== c5) {
        obj.length = maxAge.length;
      }
      let flag2 = false;
      if (maxAge) {
        const self = this;
        if (!maxAge.maxAge) {
          flag2 = false;
        }
        const _Date = Date;
        const diff = Date.now() - maxAge.now;
        if (maxAge.maxAge) {
          maxAge = maxAge.maxAge;
          let tmp12 = diff > maxAge;
        } else {
          tmp12 = tmpResult1(self, "maxAge") && diff > tmpResult1(self, "maxAge");
          const tmp11 = tmpResult1;
        }
      }
      if (flag2) {
        obj.stale = true;
      }
      const str4 = obj.inspect(key.key);
      const tmp5 = callback;
      const tmp6 = table;
      const tmp5Result = callback(table[2]);
      const parts1 = callback(table[2]).inspect(obj, callback).split("\n");
      table = `${closure_1}${tmp7} => ${obj5.join("\n  ")}`;
    });
    tmp24 = c5;
    if (!c5) {
      tmp24 = flag7;
    }
    if (tmp24) {
      tmp25 = c1;
      str9 = "\n";
      c1 = `${c1}
`;
    }
    c1 = `${c1}}`;
    return `${c1}}`;
  }
  set(arg0, arg1, arg2) {
    self = this;
    objResult4 = importDefault;
    if (!importDefault) {
      tmp2 = priv;
      str = "maxAge";
      objResult4 = priv(self, "maxAge");
    }
    num = 0;
    if (objResult4) {
      tmp3 = globalThis;
      _Date = Date;
      num = Date.now();
    }
    obj = priv;
    tmp4 = priv(self, "lengthCalculator");
    call = tmp4.call;
    tmp5 = typeof call === "unknown" ? tmp4(require, global) : call(self, require, global);
    str2 = "cache";
    objResult = obj(self, "cache");
    if (objResult.has(global)) {
      str7 = "max";
      if (tmp5 > obj(self, "max")) {
        objResult1 = obj(self, `cache`);
        iter = objResult1.get(global);
        if (!iter) {
          flag3 = false;
          return false;
        } else {
          value = iter.value;
          str9 = "dispose";
          if (!obj(self, "dispose")) {
            value2 = "length";
            key = obj(self, "length");
            objResult2 = obj(self, "length", key - value.length);
            objResult3 = obj(self, `cache`);
            deleteResult = objResult3.delete(value.key);
            str10 = "lruList";
            obj = obj(self, "lruList");
            value = obj.removeNode(iter);
          } else {
            objResult4 = obj(self, "dispose");
            call4 = objResult4.call;
            ({ key, value: value2 } = value);
            if (typeof call4 !== "unknown") {
              tmp27 = globalThis;
              call4Result = call4(globalThis, key, value2);
            }
          }
          tmp21 = globalThis;
          tmpResult = objResult4(key, value2);
        }
      } else {
        objResult5 = obj(self, str2);
        iter2 = objResult5.get(global).value;
        str11 = "dispose";
        if (obj(self, "dispose")) {
          objResult6 = obj(self, "dispose");
          call3 = objResult6.call;
          value = iter2.value;
          if (typeof call3 === "unknown") {
            tmp15Result = objResult6(global, value);
          } else {
            call3Result = call3(self, global, value);
          }
        }
        iter2.now = num;
        iter2.maxAge = objResult4;
        iter2.value = require;
        str8 = "length";
        objResult7 = obj(self, "length", obj(self, "length") + (tmp5 - iter2.length));
        iter2.length = tmp5;
        value1 = self.get(global);
        tmp19 = trim;
        tmp20 = trim(self);
        flag2 = true;
        return true;
      }
    } else {
      tmp6 = Entry;
      obj = Object.create(Entry.prototype);
      obj1 = {};
      obj1.key = global;
      obj1.value = require;
      obj1.length = tmp5;
      obj1.now = num;
      num2 = objResult4;
      if (!objResult4) {
        num2 = 0;
      }
      obj1.maxAge = num2;
      str3 = "max";
      if (obj1.length > obj(self, "max")) {
        str6 = "dispose";
        flag = false;
        if (obj(self, "dispose")) {
          objResult8 = obj(self, "dispose");
          call2 = objResult8.call;
          if (typeof call2 === "unknown") {
            tmp13Result = objResult8(global, require);
            flag = false;
          } else {
            call2Result = call2(self, global, require);
            flag = false;
          }
        }
      } else {
        str4 = "length";
        objResult9 = obj(self, "length", obj(self, "length") + obj1.length);
        str5 = "lruList";
        objResult10 = obj(self, "lruList");
        arr = objResult10.unshift(obj1);
        objResult11 = obj(self, str2);
        result = objResult11.set(global, obj(self, "lruList").head);
        tmp11 = trim;
        tmp12 = trim(self);
        flag = true;
      }
      return flag;
    }
    return;
  }
  has(arg0) {
    self = this;
    tmp = priv;
    obj = priv(this, "cache");
    tmp2 = obj.has(global);
    if (tmp2) {
      tmpResult = tmp(self, "cache");
      maxAge = tmpResult.get(global).value;
      flag = false;
      if (maxAge) {
        if (!maxAge.maxAge) {
          str = "maxAge";
          flag = false;
        }
        tmp3 = globalThis;
        _Date = Date;
        diff = Date.now() - maxAge.now;
        if (maxAge.maxAge) {
          maxAge = maxAge.maxAge;
          tmp5 = diff > maxAge;
        } else {
          str2 = "maxAge";
          tmp5 = tmp(self, "maxAge") && diff > tmp(self, "maxAge");
        }
        tmp6 = tmp5;
      }
      tmp2 = !flag;
    }
    return tmp2;
  }
  get(arg0) {
    return get(this, global, true);
  }
  peek(arg0) {
    return get(this, global, false);
  }
  pop() {
    self = this;
    obj = priv;
    iter = priv(this, "lruList").tail;
    value = null;
    if (iter) {
      if (!iter) {
        value = iter.value;
      } else {
        value1 = iter.value;
        str = "dispose";
        if (!obj(self, "dispose")) {
          str2 = "length";
          key = obj(self, "length");
          objResult = obj(self, "length", key - value1.length);
          str3 = "cache";
          objResult1 = obj(self, "cache");
          value1 = objResult1.delete(value1.key);
          obj = obj(self, `lruList`);
          removeNodeResult = obj.removeNode(iter);
        } else {
          objResult2 = obj(self, "dispose");
          call = objResult2.call;
          ({ key, value } = value1);
          if (typeof call !== "unknown") {
            tmp7 = globalThis;
            callResult = call(globalThis, key, objResult1);
          }
        }
        tmp4 = globalThis;
        tmp3Result = objResult2(key, objResult1);
      }
    }
    return value;
  }
  del(arg0) {
    self = this;
    obj = priv;
    str = "cache";
    obj2 = priv(this, "cache");
    iter = obj2.get(global);
    if (!iter) {
      return;
    } else {
      value = iter.value;
      str2 = "dispose";
      if (!obj(self, "dispose")) {
        value = "length";
        key = obj(self, "length");
        objResult = obj(self, "length", key - value.length);
        objResult1 = obj(self, `cache`);
        deleteResult = objResult1.delete(value.key);
        str3 = "lruList";
        obj = obj(self, "lruList");
        value = obj.removeNode(iter);
      } else {
        objResult2 = obj(self, "dispose");
        call = objResult2.call;
        ({ key, value } = value);
        if (typeof call !== "unknown") {
          tmp6 = globalThis;
          callResult = call(globalThis, key, value);
        }
      }
      tmp2 = globalThis;
      tmpResult = objResult2(key, value);
    }
    return;
  }
  load(arg0) {
    self = this;
    resetResult = this.reset();
    diff = global.length - 1;
    if (0 <= diff) {
      do {
        tmp4 = global[diff];
        num = tmp4.e;
        tmp5 = diff;
        if (!num) {
          num = 0;
        }
        if (0 === num) {
          result = self.set(tmp4.k, tmp4.v);
        } else {
          diff1 = num - tmp2;
          if (diff1 > 0) {
            result1 = self.set(tmp4.k, tmp4.v, diff1);
          }
        }
        diff = diff - 1;
      } while (0 <= diff);
    }
    return;
  }
  prune() {
    self = this;
    arr = priv(this, "cache");
    item = arr.forEach((arg0, arg1) => {
      outer1_8(self, arg1, false);
    });
    return;
  }
}
function forEachStep(self, call, iter, arg3) {
  let key;
  let key2;
  let value2;
  let value3;
  let removeNodeResult = iter.value;
  let flag = false;
  if (removeNodeResult) {
    if (!removeNodeResult.maxAge) {
      flag = false;
    }
    const _Date = Date;
    const diff = Date.now() - removeNodeResult.now;
    if (removeNodeResult.maxAge) {
      let tmp5 = diff > removeNodeResult.maxAge;
    } else {
      tmp5 = priv(self, "maxAge") && diff > priv(self, "maxAge");
      const tmp4 = priv;
    }
  }
  let tmp7 = removeNodeResult;
  if (flag) {
    if (!iter) {
      tmp7 = removeNodeResult;
    } else {
      removeNodeResult = iter.value;
      let obj = priv;
      if (!priv(self, "dispose")) {
        key = obj(self, "length");
        let objResult = obj(self, "length", key - removeNodeResult.length);
        objResult = obj(self, "cache");
        objResult.delete(removeNodeResult.key);
        obj = obj(self, "lruList");
        removeNodeResult = obj.removeNode(iter);
      } else {
        const objResult1 = obj(self, "dispose");
        call = objResult1.call;
        ({ key, value: value2 } = removeNodeResult);
        if (typeof call !== "unknown") {
          call(globalThis, key, objResult);
        }
      }
      objResult1(key, objResult);
    }
  }
  if (tmp7) {
    const call2 = call.call;
    ({ value: value3, key: key2 } = tmp7);
    if (typeof call2 === "unknown") {
      call(value3, key2, self);
    } else {
      call2(arg3, value3, key2, self);
    }
  }
}
function get(self) {
  let key;
  let value2;
  let str = "cache";
  const iter = priv(self, "cache").get(arg1);
  let value;
  if (iter) {
    let removeNodeResult = iter.value;
    let flag = false;
    if (removeNodeResult) {
      if (!removeNodeResult.maxAge) {
        flag = false;
      }
      const _Date = Date;
      const diff = Date.now() - removeNodeResult.now;
      if (removeNodeResult.maxAge) {
        let tmp5 = diff > removeNodeResult.maxAge;
      } else {
        tmp5 = tmp(self, "maxAge") && diff > tmp(self, "maxAge");
      }
    }
    if (flag) {
      if (!iter) {
        let iter2 = removeNodeResult;
      } else {
        removeNodeResult = iter.value;
        if (!tmp(self, "dispose")) {
          value2 = "length";
          key = tmp(self, "length");
          let tmpResult = tmp(self, "length", key - removeNodeResult.length);
          tmpResult = tmp(self, str);
          tmpResult.delete(removeNodeResult.key);
          str = tmp(self, "lruList");
          removeNodeResult = str.removeNode(iter);
        } else {
          const tmpResult1 = tmp(self, "dispose");
          const call = tmpResult1.call;
          ({ key, value: value2 } = removeNodeResult);
          if (typeof call !== "unknown") {
            call(globalThis, key, value2);
          }
        }
        tmpResult1(key, value2);
      }
    } else {
      iter2 = removeNodeResult;
      if (arg2) {
        tmp(self, "lruList").unshiftNode(iter);
        iter2 = removeNodeResult;
        const tmpResult2 = tmp(self, "lruList");
      }
    }
    value = iter2;
    if (iter2) {
      value = iter2.value;
    }
  }
  return value;
}
function trim(self) {
  let key;
  let value;
  if (tmp2 > priv(self, "max")) {
    let iter = tmp(self, "lruList").tail;
    if (tmpResult > tmp(self, "max")) {
      if (null !== iter) {
        const prev = iter.prev;
        while (!iter) {
          let tmp9 = priv;
          let tmp10 = priv(self, "length");
          if (tmp10 > priv(self, "max")) {
            iter = prev;
          }
        }
        let removeNodeResultResult1 = iter.value;
        let removeNodeResult = priv;
        if (!priv(self, "dispose")) {
          removeNodeResult(self, "length", removeNodeResult(self, "length") - removeNodeResultResult1.length);
          key = removeNodeResult(self, "cache");
          key.delete(removeNodeResultResult1.key);
          removeNodeResultResult1 = removeNodeResult(self, "lruList");
          removeNodeResult = removeNodeResultResult1.removeNode(iter);
        } else {
          const removeNodeResultResult2 = removeNodeResult(self, "dispose");
          const call = removeNodeResultResult2.call;
          ({ key, value } = removeNodeResultResult1);
          if (typeof call !== "unknown") {
            call(globalThis, key, removeNodeResultResult1);
          }
        }
        removeNodeResultResult2(key, removeNodeResultResult1);
      }
    }
    tmpResult = tmp(self, "length");
  }
}
function Entry(key, value, length, now) {
  let num = arg4;
  if (!arg4) {
    num = 0;
  }
  { key, value, length, now }.maxAge = num;
}
let closure_3 = {};
let closure_2 = typeof Symbol === "function" ? ((arg0) => Symbol.for(arg0)) : ((arg0) => "_" + arg0);
let obj = {
  set(max) {
    let num = max;
    let tmp = !max;
    if (max) {
      tmp = typeof num !== "number";
    }
    if (!tmp) {
      tmp = num <= 0;
    }
    if (tmp) {
      num = Infinity;
    }
    priv(this, "max", num);
    trim(this);
  },
  get() {
    return priv(this, "max");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "max", obj);
obj = {
  set(max) {
    priv(this, "allowStale", max);
  },
  get() {
    return priv(this, "allowStale");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "allowStale", obj);
obj = {
  set(max) {
    let num = max;
    let tmp = !max;
    if (max) {
      tmp = typeof num !== "number";
    }
    if (!tmp) {
      tmp = num < 0;
    }
    if (tmp) {
      num = 0;
    }
    priv(this, "maxAge", num);
    trim(this);
  },
  get() {
    return priv(this, "maxAge");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "maxAge", obj);
Object.defineProperty(LRUCache.prototype, "lengthCalculator", {
  set(fn) {
    let tmp = fn;
    if (typeof fn !== "function") {
      tmp = naiveLength;
    }
    let self = this;
    if (tmp !== priv(this, "lengthCalculator")) {
      tmp2(self, "lengthCalculator", tmp);
      tmp2(self, "length", 0);
      const item = tmp2(self, "lruList").forEach(function(arg0) {
        let key;
        let value;
        const self = this;
        const tmp2 = callback(this, "lengthCalculator");
        const call = tmp2.call;
        ({ value, key } = arg0);
        arg0.length = typeof call === "unknown" ? tmp2(value, key) : call(self, value, key);
        callback(self, "length", callback(self, "length") + arg0.length);
      }, self);
      const tmp2Result1 = tmp2(self, "lruList");
    }
    trim(self);
  },
  get() {
    return priv(this, "lengthCalculator");
  },
  enumerable: true
});
Object.defineProperty(LRUCache.prototype, "length", {
  get() {
    return priv(this, "length");
  },
  enumerable: true
});
Object.defineProperty(LRUCache.prototype, "itemCount", {
  get() {
    return priv(this, "lruList").length;
  },
  enumerable: true
});

export default LRUCache;