// Module ID: 1362
// Function ID: 16293
// Name: priv
// Dependencies: []

// Module 1362 (priv)
function priv(self, lruList, dispose) {
  let tmp = dispose;
  if (closure_3[lruList]) {
    let tmp3 = closure_3[lruList];
  } else {
    tmp3 = callback(lruList);
    closure_3[lruList] = tmp3;
  }
  if (2 === arguments.length) {
    tmp = self[tmp3];
  } else {
    self[tmp3] = tmp;
  }
  return tmp;
}
function naiveLength() {
  return 1;
}
class LRUCache {
  constructor(arg0) {
    self = this;
    if (this instanceof LRUCache) {
      str = "number";
      obj = global;
      if ("number" === typeof global) {
        obj = {};
        obj.max = global;
      }
      if (!obj) {
        obj = {};
      }
      tmp7 = priv;
      str2 = "max";
      tmp8 = priv(self, "max", obj.max);
      tmp9 = !tmp8 || "number" !== typeof tmp8;
      if (!tmp9) {
        num = 0;
        tmp9 = tmp8 <= 0;
      }
      if (tmp9) {
        tmp10 = priv;
        num2 = Infinity;
        tmp11 = priv(self, "max", Infinity);
      }
      tmp12 = obj.length || naiveLength;
      str3 = "function";
      if ("function" !== typeof tmp12) {
        tmp12 = naiveLength;
      }
      str4 = "lengthCalculator";
      tmp13 = priv;
      tmp14 = priv(self, "lengthCalculator", tmp12);
      tmp15 = obj.stale || false;
      str5 = "allowStale";
      tmp13Result = tmp13(self, "allowStale", tmp15);
      num3 = obj.maxAge;
      tmp17 = priv;
      if (!num3) {
        num3 = 0;
      }
      str6 = "maxAge";
      tmp17Result = tmp17(self, "maxAge", num3);
      tmp19 = priv;
      str7 = "dispose";
      tmp20 = priv(self, "dispose", obj.dispose);
      resetResult = self.reset();
      return;
    } else {
      tmp = LRUCache;
      prototype = LRUCache.prototype;
      tmp2 = new.target;
      tmp3 = new.target;
      tmp4 = global;
      tmp5 = new LRUCache(global);
      tmp6 = tmp5;
      return tmp5;
    }
  }
  rforEach(arg0, arg1) {
    tmp = require;
    self = this;
    if (!require) {
      tmp = self;
    }
    prev = priv(self, "lruList").tail;
    if (null !== prev) {
      do {
        tmp3 = closure_7;
        tmp4 = self;
        tmp5 = global;
        tmp6 = prev;
        tmp7 = tmp;
        tmp8 = closure_7(self, global, prev, tmp);
        prev = prev.prev;
      } while (null !== tmp2);
    }
    return;
  }
  forEach(arg0, arg1) {
    tmp = require;
    self = this;
    if (!require) {
      tmp = self;
    }
    iter = priv(self, "lruList").head;
    if (null !== iter) {
      do {
        tmp3 = closure_7;
        tmp4 = self;
        tmp5 = global;
        tmp6 = iter;
        tmp7 = tmp;
        tmp8 = closure_7(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;
    length = priv(this, "dispose");
    if (length) {
      tmp = priv;
      str = "lruList";
      length = priv(self, "lruList");
    }
    if (length) {
      tmp2 = priv;
      str2 = "lruList";
      length = priv(self, "lruList").length;
    }
    if (length) {
      tmp3 = priv;
      str3 = "lruList";
      arr = priv(self, "lruList");
      item = arr.forEach(function(key) {
        callback(this, "dispose").call(this, key.key, key.value);
      }, self);
    }
    tmp5 = require(dependencyMap[0]);
    tmp5 = new tmp5();
    tmp7 = priv(self, "cache", tmp5);
    tmp8 = require(dependencyMap[1]);
    tmp8 = new tmp8();
    tmp10 = priv(self, "lruList", tmp8);
    tmp11 = priv(self, "length", 0);
    return;
  }
  dump() {
    arr = priv(this, "lruList");
    mapped = arr.map(function(arg0) {
      let maxAge;
      let now;
      if (!callback(this, arg0)) {
        const obj = {};
        ({ key: obj.k, value: obj.v, maxAge, now } = arg0);
        if (!maxAge) {
          maxAge = 0;
        }
        obj.e = now + maxAge;
        return obj;
      }
    }, this);
    toArrayResult = mapped.toArray();
    return toArrayResult.filter((arg0) => arg0);
  }
  dumpLru() {
    return priv(this, "lruList");
  }
  inspect(arg0, arg1) {
    self = this;
    closure_1 = "LRUCache {";
    closure_2 = false;
    flag = false;
    if (priv(this, "allowStale")) {
      tmp = closure_1;
      str = "\n  allowStale: true";
      closure_1 = `${closure_1}
  allowStale: true`;
      flag2 = true;
      closure_2 = true;
      flag = true;
    }
    tmp2 = priv(self, "max");
    tmp3 = tmp2;
    if (tmp2) {
      num = Infinity;
      tmp3 = tmp2 !== Infinity;
    }
    flag3 = flag;
    if (tmp3) {
      if (flag) {
        tmp4 = closure_1;
        str2 = ",";
        closure_1 = `${closure_1},`;
      }
      tmp5 = closure_1;
      tmp6 = require;
      tmp7 = closure_1;
      num2 = 2;
      obj = require(closure_1[2]);
      str3 = "\n  max: ";
      closure_1 = `${closure_1}
  max: ${obj.inspect(tmp2, require)}`;
      flag4 = true;
      closure_2 = true;
      flag3 = true;
    }
    tmp8 = priv(self, "maxAge");
    module = tmp8;
    flag5 = flag3;
    if (tmp8) {
      if (flag3) {
        tmp9 = closure_1;
        str4 = ",";
        closure_1 = `${closure_1},`;
      }
      tmp10 = closure_1;
      tmp11 = require;
      tmp12 = closure_1;
      num3 = 2;
      obj2 = require(closure_1[2]);
      str5 = "\n  maxAge: ";
      closure_1 = `${closure_1}
  maxAge: ${obj2.inspect(tmp8, require)}`;
      flag6 = true;
      closure_2 = true;
      flag5 = true;
    }
    tmp13 = priv(self, "lengthCalculator");
    priv = tmp13;
    tmp14 = tmp13;
    if (tmp13) {
      tmp15 = closure_5;
      tmp14 = tmp13 !== closure_5;
    }
    flag7 = flag5;
    if (tmp14) {
      if (flag5) {
        tmp16 = closure_1;
        str6 = ",";
        closure_1 = `${closure_1},`;
      }
      tmp17 = closure_1;
      tmp18 = require;
      tmp19 = closure_1;
      num4 = 2;
      tmp20 = require(closure_1[2]);
      tmp22 = priv;
      str7 = "length";
      str8 = "\n  length: ";
      closure_1 = `${closure_1}
  length: ${tmp21(closure_4(self, "length"), require)}`;
      flag8 = true;
      closure_2 = true;
      flag7 = true;
    }
    closure_5 = false;
    arr = priv(self, "lruList");
    item = arr.forEach(function(key) {
      if (closure_5) {
        let closure_1 = `${closure_1},
        `;
      } else {
        if (closure_2) {
          closure_1 = `${closure_1},
      `;
        }
        closure_5 = true;
        closure_1 = `${closure_1}
        `;
      }
      let obj = arg1(closure_1[2]);
      const parts = obj.inspect(key.key).split("\n");
      obj = { value: key.value };
      const joined = parts.join("\n  ");
      if (key.maxAge !== tmp8) {
        obj.maxAge = key.maxAge;
      }
      if (tmp13 !== closure_5) {
        obj.length = key.length;
      }
      if (callback(this, key)) {
        obj.stale = true;
      }
      const str4 = obj.inspect(key.key);
      const obj4 = arg1(closure_1[2]);
      const parts1 = arg1(closure_1[2]).inspect(obj, arg1).split("\n");
      closure_1 = `${closure_1}${tmp5} => ${obj5.join("\n  ")}`;
    });
    tmp24 = closure_5;
    if (!closure_5) {
      tmp24 = flag7;
    }
    if (tmp24) {
      tmp25 = closure_1;
      str9 = "\n";
      closure_1 = `${closure_1}
`;
    }
    closure_1 = `${closure_1}}`;
    return `${closure_1}}`;
  }
  set(arg0, arg1, arg2) {
    tmp = importDefault;
    self = this;
    if (!importDefault) {
      tmp2 = priv;
      str = "maxAge";
      tmp = priv(self, "maxAge");
    }
    num = 0;
    if (tmp) {
      tmp3 = globalThis;
      _Date = Date;
      num = Date.now();
    }
    obj = priv(self, "lengthCalculator");
    callResult = obj.call(self, require, global);
    obj2 = priv(self, "cache");
    if (obj2.has(global)) {
      tmp24 = priv;
      str6 = "max";
      if (callResult > priv(self, "max")) {
        tmp32 = del;
        tmp33 = priv;
        obj6 = priv(self, "cache");
        tmp34 = del(self, obj6.get(global));
        flag3 = false;
        return false;
      } else {
        tmp35 = priv;
        obj7 = priv(self, "cache");
        iter = obj7.get(global).value;
        str8 = "dispose";
        if (priv(self, "dispose")) {
          tmp25 = priv;
          obj5 = priv(self, "dispose");
          callResult1 = obj5.call(self, global, iter.value);
        }
        iter.now = num;
        iter.maxAge = tmp;
        iter.value = require;
        tmp27 = priv;
        str7 = "length";
        tmp28 = priv(self, "length", priv(self, "length") + (callResult - iter.length));
        iter.length = callResult;
        value = self.get(global);
        tmp30 = trim;
        tmp31 = trim(self);
        flag2 = true;
        return true;
      }
    } else {
      tmp5 = Entry;
      prototype = Entry.prototype;
      tmp6 = new.target;
      tmp7 = new.target;
      tmp8 = global;
      tmp9 = require;
      tmp10 = callResult;
      tmp11 = num;
      tmp12 = tmp;
      arr = new Entry(global, require, callResult, num, tmp);
      tmp13 = arr;
      tmp14 = priv;
      str2 = "max";
      if (arr.length > priv(self, "max")) {
        tmp21 = priv;
        str5 = "dispose";
        flag = false;
        if (priv(self, "dispose")) {
          tmp22 = priv;
          obj4 = priv(self, "dispose");
          callResult2 = obj4.call(self, global, require);
          flag = false;
        }
      } else {
        tmp15 = priv;
        str3 = "length";
        tmp16 = priv(self, "length", priv(self, "length") + arr.length);
        str4 = "lruList";
        arr2 = priv(self, "lruList");
        arr = arr2.unshift(arr);
        obj3 = priv(self, "cache");
        result = obj3.set(global, priv(self, "lruList").head);
        tmp19 = trim;
        tmp20 = trim(self);
        flag = true;
      }
      return flag;
    }
  }
  has(arg0) {
    self = this;
    obj = priv(this, "cache");
    tmp = !obj.has(global);
    tmp2 = !tmp;
    if (!tmp) {
      tmp3 = isStale;
      tmp4 = priv;
      obj2 = priv(self, "cache");
      tmp2 = !isStale(self, obj2.get(global).value);
    }
    return tmp2;
  }
  get(arg0) {
    return get(this, global, true);
  }
  peek(arg0) {
    return get(this, global, false);
  }
  pop() {
    iter = priv(this, "lruList").tail;
    value = null;
    if (iter) {
      tmp2 = del;
      tmp3 = del(this, iter);
      value = iter.value;
    }
    return value;
  }
  del(arg0) {
    obj = priv(this, "cache");
    tmp = del(this, obj.get(global));
    return;
  }
  load(arg0) {
    self = this;
    resetResult = this.reset();
    diff = global.length - 1;
    if (diff >= 0) {
      do {
        tmp5 = global[diff];
        tmp6 = tmp5.e || 0;
        if (0 === tmp6) {
          result = self.set(tmp5.k, tmp5.v);
          tmp8 = tmp4;
        } else {
          diff1 = tmp6 - tmp2;
          tmp8 = diff1;
          if (diff1 > 0) {
            result1 = self.set(tmp5.k, tmp5.v, diff1);
            tmp8 = diff1;
          }
        }
        diff = diff - 1;
        tmp4 = tmp8;
      } while (diff >= 0);
    }
    return;
  }
  prune() {
    require = this;
    arr = priv(this, "cache");
    item = arr.forEach((arg0, arg1) => {
      callback(self, arg1, false);
    });
    return;
  }
}
function forEachStep(self, call, value) {
  value = value.value;
  let iter = value;
  if (isStale(self, value)) {
    del(self, value);
    iter = value;
  }
  if (iter) {
    call.call(arg3, iter.value, iter.key, self);
  }
}
function get(self) {
  const iter = priv(self, "cache").get(arg1);
  let value;
  if (iter) {
    value = iter.value;
    if (isStale(self, value)) {
      del(self, iter);
      let iter2 = value;
    } else {
      iter2 = value;
      if (arg2) {
        priv(self, "lruList").unshiftNode(iter);
        iter2 = value;
        const obj2 = priv(self, "lruList");
      }
    }
    value = iter2;
    if (iter2) {
      value = iter2.value;
    }
  }
  return value;
}
function isStale(self, maxAge) {
  if (maxAge) {
    const _Date = Date;
    const diff = Date.now() - maxAge.now;
    if (maxAge.maxAge) {
      let tmp5 = diff > maxAge.maxAge;
    } else {
      tmp5 = priv(self, "maxAge");
      if (tmp5) {
        tmp5 = diff > priv(self, "maxAge");
      }
    }
    return tmp5;
  }
  return false;
}
function trim(self) {
  if (tmp > priv(self, "max")) {
    let tail = priv(self, "lruList").tail;
    if (tmp3 > priv(self, "max")) {
      if (null !== tail) {
        const prev = tail.prev;
        del(self, tail);
        while (tmp8 > priv(self, "max")) {
          tail = prev;
          if (null === prev) {
            break;
          }
        }
        const tmp8 = priv(self, "length");
      }
    }
    const tmp3 = priv(self, "length");
  }
}
function del(self, value) {
  if (value) {
    if (priv(self, "dispose")) {
      self = this;
      priv(self, "dispose").call(this, iter.key, iter.value);
      const obj = priv(self, "dispose");
    }
    priv(self, "length", priv(self, "length") - value.value.length);
    priv(self, "cache").delete(value.value.key);
    const obj2 = priv(self, "cache");
    priv(self, "lruList").removeNode(value);
    const obj3 = priv(self, "lruList");
  }
}
function Entry(key, value, arg2, now) {
  let num = arg4;
  this.key = key;
  this.value = value;
  this.length = arg2;
  this.now = now;
  if (!arg4) {
    num = 0;
  }
  this.maxAge = num;
}
let closure_3 = {};
let closure_2 = "function" === typeof Symbol ? function makeSymbol(arg0) {
  return Symbol.for(arg0);
} : function makeSymbol(arg0) {
  return "_" + arg0;
};
let obj = {
  set(dispose) {
    let num = dispose;
    const self = this;
    let tmp = !dispose;
    if (!tmp) {
      tmp = "number" !== typeof num;
    }
    if (!tmp) {
      tmp = num <= 0;
    }
    if (tmp) {
      num = Infinity;
    }
    priv(self, "max", num);
    trim(self);
  },
  get() {
    return priv(this, "max");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "max", obj);
obj = {
  set(dispose) {
    priv(this, "allowStale", dispose);
  },
  get() {
    return priv(this, "allowStale");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "allowStale", obj);
obj = {
  set(dispose) {
    let num = dispose;
    const self = this;
    let tmp = !dispose;
    if (!tmp) {
      tmp = "number" !== typeof num;
    }
    if (!tmp) {
      tmp = num < 0;
    }
    if (tmp) {
      num = 0;
    }
    priv(self, "maxAge", num);
    trim(self);
  },
  get() {
    return priv(this, "maxAge");
  },
  enumerable: true
};
Object.defineProperty(LRUCache.prototype, "maxAge", obj);
Object.defineProperty(LRUCache.prototype, "lengthCalculator", {
  set(dispose) {
    let tmp = dispose;
    const self = this;
    if ("function" !== typeof dispose) {
      tmp = naiveLength;
    }
    if (tmp !== priv(self, "lengthCalculator")) {
      priv(self, "lengthCalculator", tmp);
      priv(self, "length", 0);
      const item = priv(self, "lruList").forEach(function(value) {
        value.length = callback(this, "lengthCalculator").call(this, value.value, value.key);
        callback(this, "length", callback(this, "length") + value.length);
      }, self);
      const arr = priv(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;