@adviser/cement 0.3.14 → 0.3.16

package/index.cjs

@@ -14,9 +14,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from2, except, desc) => {
   if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key2 of __getOwnPropNames(from2))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -53,6 +53,7 @@ __export(index_exports, {
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
   KeyedResolvSeq: () => KeyedResolvSeq,
+  LRUCache: () => LRUCache,
   Level: () => Level,
   LevelHandlerImpl: () => LevelHandlerImpl,
   LevelHandlerSingleton: () => LevelHandlerSingleton,
@@ -95,9 +96,8 @@ __export(index_exports, {
   hasHostPartProtocols: () => hasHostPartProtocols,
   isCoerceURI: () => isCoerceURI,
   isURL: () => isURL,
-  key: () => key,
   logValue: () => logValue,
-  param: () => param2,
+  param: () => param,
   pathOps: () => pathOps,
   registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
@@ -156,13 +156,12 @@ function bin2string(hex, size = 0) {
 }
 
 // src/logger.ts
-var Level = /* @__PURE__ */ ((Level2) => {
-  Level2["WARN"] = "warn";
-  Level2["DEBUG"] = "debug";
-  Level2["INFO"] = "info";
-  Level2["ERROR"] = "error";
-  return Level2;
-})(Level || {});
+var Level = {
+  WARN: "warn",
+  DEBUG: "debug",
+  INFO: "info",
+  ERROR: "error"
+};
 var LogValue = class {
   constructor(fn) {
     this.fn = fn;
@@ -256,16 +255,16 @@ function logValueInternal(val, ctx) {
       }
       const res = {};
       const typedVal = val;
-      for (const key2 in typedVal) {
-        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key2)) {
+      for (const key in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
           continue;
         }
-        const element = typedVal[key2];
+        const element = typedVal[key];
         if (element instanceof LogValue) {
-          res[key2] = element;
+          res[key] = element;
         } else {
           if (typeof element !== "function") {
-            res[key2] = logValueInternal(element, ctx);
+            res[key] = logValueInternal(element, ctx);
           }
         }
       }
@@ -300,34 +299,31 @@ function IsLogger(obj) {
 }
 
 // src/sys-abstraction.ts
-var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
-  TimeMode2["REAL"] = "real";
-  TimeMode2["CONST"] = "const";
-  TimeMode2["STEP"] = "step";
-  return TimeMode2;
-})(TimeMode || {});
-var RandomMode = /* @__PURE__ */ ((RandomMode2) => {
-  RandomMode2["CONST"] = "const";
-  RandomMode2["STEP"] = "step";
-  RandomMode2["RANDOM"] = "random";
-  return RandomMode2;
-})(RandomMode || {});
-var IDMode = /* @__PURE__ */ ((IDMode2) => {
-  IDMode2["UUID"] = "uuid";
-  IDMode2["CONST"] = "const";
-  IDMode2["STEP"] = "step";
-  return IDMode2;
-})(IDMode || {});
+var TimeMode = {
+  REAL: "real",
+  CONST: "const",
+  STEP: "step"
+};
+var RandomMode = {
+  CONST: "const",
+  STEP: "step",
+  RANDOM: "random"
+};
+var IDMode = {
+  UUID: "uuid",
+  CONST: "const",
+  STEP: "step"
+};
 function String2TimeMode(s) {
   switch (s == null ? void 0 : s.toLowerCase()) {
     case "real":
-      return "real" /* REAL */;
+      return TimeMode.REAL;
     case "const":
-      return "const" /* CONST */;
+      return TimeMode.CONST;
     case "step":
-      return "step" /* STEP */;
+      return TimeMode.STEP;
     default:
-      return "real" /* REAL */;
+      return TimeMode.REAL;
   }
 }
 
@@ -338,13 +334,15 @@ var Time = class {
     return now.getTime() - start.getTime();
   }
 };
-var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
-  TimeUnits2[TimeUnits2["Microsecond"] = 1] = "Microsecond";
-  TimeUnits2[TimeUnits2["Second"] = 1e3] = "Second";
-  TimeUnits2[TimeUnits2["Minute"] = 6e4] = "Minute";
-  TimeUnits2[TimeUnits2["Hour"] = 36e5] = "Hour";
-  return TimeUnits2;
-})(TimeUnits || {});
+var TimeUnits = {
+  Microsecond: 1,
+  Second: 1e3 * 1,
+  //Microsecond,
+  Minute: 60 * 1e3 * 1,
+  //Second,
+  Hour: 60 * 60 * 1e3 * 1
+  // Minute,
+};
 
 // src/base-sys-abstraction.ts
 var SysTime = class extends Time {
@@ -390,11 +388,11 @@ var StepTime = class extends Time {
 };
 function TimeFactory(timeMode) {
   switch (timeMode) {
-    case "real" /* REAL */:
+    case TimeMode.REAL:
       return new SysTime();
-    case "const" /* CONST */:
+    case TimeMode.CONST:
       return new ConstTime();
-    case "step" /* STEP */:
+    case TimeMode.STEP:
       return new StepTime();
   }
   return new SysTime();
@@ -406,12 +404,12 @@ var RandomService = class {
   }
   Random0ToValue(value) {
     switch (this._mode) {
-      case "const" /* CONST */:
+      case RandomMode.CONST:
         return 0.5 * value;
-      case "step" /* STEP */:
+      case RandomMode.STEP:
         this._step += 1e-4;
         return this._step * value;
-      case "random" /* RANDOM */:
+      case RandomMode.RANDOM:
         return Math.random() * value;
       default:
         throw new Error("Unknown RandomMode");
@@ -422,17 +420,17 @@ var IdService = class {
   constructor(mode) {
     this._step = 0;
     if (!mode) {
-      mode = "uuid" /* UUID */;
+      mode = IDMode.UUID;
     }
     this._mode = mode;
   }
   NextId() {
     switch (this._mode) {
-      case "uuid" /* UUID */:
+      case IDMode.UUID:
         return crypto.randomUUID();
-      case "const" /* CONST */:
+      case IDMode.CONST:
         return "VeryUniqueID";
-      case "step" /* STEP */:
+      case IDMode.STEP:
         return `STEPId-${this._step++}`;
       default:
         throw new Error("Unknown IDMode");
@@ -462,7 +460,7 @@ var BaseSysAbstraction = class {
   constructor(params) {
     this._time = new SysTime();
     this._idService = new IdService();
-    this._randomService = new RandomService("random" /* RANDOM */);
+    this._randomService = new RandomService(RandomMode.RANDOM);
     this._fileSystem = params.FileSystem;
     this._systemService = params.SystemService;
     this._txtEnDe = params.TxtEnDecoder;
@@ -792,24 +790,24 @@ var Keyed = class {
     this._map = /* @__PURE__ */ new Map();
     this.factory = factory;
   }
-  async asyncGet(key2) {
-    return this.get(await key2());
+  async asyncGet(key) {
+    return this.get(await key());
   }
-  get(key2) {
-    if (typeof key2 === "function") {
-      key2 = key2();
+  get(key) {
+    if (typeof key === "function") {
+      key = key();
     }
-    let keyed = this._map.get(key2);
+    let keyed = this._map.get(key);
     if (!keyed) {
-      keyed = this.factory(key2);
-      this._map.set(key2, keyed);
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
     }
     return keyed;
   }
-  unget(key2) {
-    const keyed = this._map.get(key2);
+  unget(key) {
+    const keyed = this._map.get(key);
     keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key2);
+    this._map.delete(key);
   }
   reset() {
     this._map.forEach((keyed) => keyed.reset());
@@ -818,7 +816,7 @@ var Keyed = class {
 };
 var KeyedResolvOnce = class extends Keyed {
   constructor() {
-    super((key2) => new ResolveOnce(key2));
+    super((key) => new ResolveOnce(key));
   }
   /**
    *
@@ -844,7 +842,7 @@ var KeyedResolvOnce = class extends Keyed {
 };
 var KeyedResolvSeq = class extends Keyed {
   constructor() {
-    super((key2) => new ResolveSeq(key2));
+    super((key) => new ResolveSeq(key));
   }
 };
 
@@ -900,8 +898,8 @@ var _DenoEnvActions = class _DenoEnvActions {
     return __privateGet(this, _deno).Deno.env;
   }
   register(env) {
-    for (const key2 of env.keys()) {
-      this._env.set(key2, env.get(key2) || "");
+    for (const key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
     }
     return env;
   }
@@ -911,16 +909,16 @@ var _DenoEnvActions = class _DenoEnvActions {
   keys() {
     return Object.keys(this._env.toObject());
   }
-  get(key2) {
-    return this._env.get(key2);
+  get(key) {
+    return this._env.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this._env.set(key2, value);
+      this._env.set(key, value);
     }
   }
-  delete(key2) {
-    this._env.delete(key2);
+  delete(key) {
+    this._env.delete(key);
   }
 };
 _deno = new WeakMap();
@@ -939,8 +937,8 @@ var _NodeEnvActions = class _NodeEnvActions {
     return once2.once(() => new _NodeEnvActions(opts));
   }
   register(env) {
-    for (const key2 of env.keys()) {
-      this._env[key2] = env.get(key2) || "";
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
     }
     return env;
   }
@@ -950,16 +948,16 @@ var _NodeEnvActions = class _NodeEnvActions {
   keys() {
     return Object.keys(this._env);
   }
-  get(key2) {
-    return this._env[key2];
+  get(key) {
+    return this._env[key];
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this._env[key2] = value;
+      this._env[key] = value;
     }
   }
-  delete(key2) {
-    delete this._env[key2];
+  delete(key) {
+    delete this._env[key];
   }
 };
 _node = new WeakMap();
@@ -975,16 +973,16 @@ var BrowserEnvActions = class _BrowserEnvActions {
   static new(opts) {
     return once3.once(() => new _BrowserEnvActions(opts));
   }
-  get(key2) {
-    return this.env.get(key2);
+  get(key) {
+    return this.env.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this.env.set(key2, value);
+      this.env.set(key, value);
     }
   }
-  delete(key2) {
-    this.env.delete(key2);
+  delete(key) {
+    this.env.delete(key);
   }
   keys() {
     return Array.from(this.env.keys());
@@ -1012,13 +1010,13 @@ var CFEnvActions = class _CFEnvActions {
   }
   static inject(o) {
     const env = _CFEnvActions.new({});
-    for (const key2 in o) {
-      const value = o[key2];
+    for (const key in o) {
+      const value = o[key];
       if (typeof value === "string") {
         if (env.env) {
-          env.env.set(key2, value);
+          env.env.set(key, value);
         } else {
-          env.injectOnRegister[key2] = value;
+          env.injectOnRegister[key] = value;
         }
       }
     }
@@ -1028,42 +1026,44 @@ var CFEnvActions = class _CFEnvActions {
   }
   register(env) {
     this.env = env;
-    for (const key2 in this.injectOnRegister) {
-      env.set(key2, this.injectOnRegister[key2]);
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
     }
     return env;
   }
-  get(key2) {
-    return this.cfEnv.get(key2);
+  get(key) {
+    return this.cfEnv.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this.cfEnv.set(key2, value);
+      this.cfEnv.set(key, value);
     }
   }
-  delete(key2) {
-    this.cfEnv.delete(key2);
+  delete(key) {
+    this.cfEnv.delete(key);
   }
   keys() {
     return Array.from(this.cfEnv.keys());
   }
 };
 
-// src/utils/get-params-result.ts
-var _REQUIRED = class {
+// src/types.ts
+var _Required = class {
   constructor() {
-    this.val = "REQUIRED";
+    this.type = "REQUIRED";
   }
 };
-var _OPTIONAL = class {
+var _Optional = class {
   constructor() {
-    this.val = "OPTIONAL";
+    this.type = "OPTIONAL";
   }
 };
 var param = {
-  REQUIRED: new _REQUIRED(),
-  OPTIONAL: new _OPTIONAL()
+  REQUIRED: new _Required(),
+  OPTIONAL: new _Optional()
 };
+
+// src/utils/get-params-result.ts
 function getParamsResult(keys, getParam) {
   const keyDef = keys.flat().reduce(
     (acc, i) => {
@@ -1157,16 +1157,16 @@ var EnvImpl = class {
     });
   }
   sets(...keys) {
-    keys.forEach((key2) => {
-      if (Array.isArray(key2)) {
-        if (key2.length === 2) {
-          const [k, v] = key2;
+    keys.forEach((key) => {
+      if (Array.isArray(key)) {
+        if (key.length === 2) {
+          const [k, v] = key;
           if (typeof k === "string" && typeof v === "string") {
             this.set(k, v);
             return;
           }
         }
-        for (const item of key2) {
+        for (const item of key) {
           if (Array.isArray(item)) {
             if (item.length === 2) {
               const [k, v] = item;
@@ -1177,14 +1177,14 @@ var EnvImpl = class {
           }
         }
       } else {
-        if (isIterable(key2)) {
-          for (const [k, v] of key2) {
+        if (isIterable(key)) {
+          for (const [k, v] of key) {
             if (typeof k === "string" && typeof v === "string") {
               this.set(k, v);
             }
           }
         } else {
-          const rKey = key2;
+          const rKey = key;
           for (const k in rKey) {
             const v = rKey[k];
             if (typeof k === "string" && typeof v === "string") {
@@ -1199,15 +1199,15 @@ var EnvImpl = class {
     if (!presetEnv) {
       return;
     }
-    for (const [key2, value] of presetEnv) {
-      this._map.set(key2, value);
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
     }
   }
-  _applyOnSet(onSet, key2, value) {
+  _applyOnSet(onSet, key, value) {
     onSet.forEach((item) => {
       let keys = [];
-      if (key2) {
-        keys = [key2];
+      if (key) {
+        keys = [key];
       } else {
         keys = this._map.keys();
       }
@@ -1221,9 +1221,9 @@ var EnvImpl = class {
         return false;
       }).forEach((k) => {
         let v;
-        if (!key2 && !value) {
+        if (!key && !value) {
           v = this._map.get(k);
-        } else if (key2 && !value) {
+        } else if (key && !value) {
           v = void 0;
         } else {
           v = value;
@@ -1241,19 +1241,19 @@ var EnvImpl = class {
     this._onSet.push(item);
     this._applyOnSet([item]);
   }
-  get(key2) {
-    return this._map.get(key2);
+  get(key) {
+    return this._map.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (!value) {
       return;
     }
-    this._map.set(key2, value);
-    this._applyOnSet(this._onSet, key2, value);
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
   }
-  delete(key2) {
-    this._map.delete(key2);
-    this._applyOnSet(this._onSet, key2);
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
   }
 };
 
@@ -1392,18 +1392,25 @@ var WebSystemService = class {
   }
 };
 var my = void 0;
-function WebSysAbstraction(param3) {
+function WebSysAbstraction(param2) {
   if (!my) {
     my = new BaseSysAbstraction({
-      TxtEnDecoder: (param3 == null ? void 0 : param3.TxtEnDecoder) || TxtEnDecoderSingleton(),
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton(),
       FileSystem: new WebFileService(),
       SystemService: new WebSystemService()
     });
   }
-  return new WrapperSysAbstraction(my, param3);
+  return new WrapperSysAbstraction(my, param2);
 }
 
 // src/utils/relative-path.ts
+var PartType = {
+  Slash: 1,
+  Root: 3,
+  Up: 4,
+  Noop: 8
+  // RootUp = 0x8 /* ../ */,
+};
 var Path = class {
   constructor(parts = []) {
     this.parts = parts;
@@ -1414,10 +1421,10 @@ var Path = class {
         return part;
       } else {
         switch (part) {
-          case 1 /* Slash */:
-          case 3 /* Root */:
+          case PartType.Slash:
+          case PartType.Root:
             return "/";
-          case 4 /* Up */:
+          case PartType.Up:
             return "..";
           default:
             return part;
@@ -1426,22 +1433,22 @@ var Path = class {
     }).join("");
   }
   add(part) {
-    if (this.parts.includes(3 /* Root */) && part === 3 /* Root */) {
+    if (this.parts.includes(PartType.Root) && part === PartType.Root) {
       throw new Error("Cannot add absolute part to absolute path");
     }
     const last = this.parts[this.parts.length - 1];
-    if (last & 1 /* Slash */ && part === 1 /* Slash */) {
+    if (last & PartType.Slash && part === PartType.Slash) {
       return;
     }
     switch (part) {
       case ".":
-        this.parts.push(8 /* Noop */);
+        this.parts.push(PartType.Noop);
         return;
       case "..":
-        part = 4 /* Up */;
+        part = PartType.Up;
     }
-    if (last === 8 /* Noop */ && part === 1 /* Slash */) {
-      if (last === 8 /* Noop */) {
+    if (last === PartType.Noop && part === PartType.Slash) {
+      if (last === PartType.Noop) {
         this.parts.pop();
       }
       return;
@@ -1457,9 +1464,9 @@ function splitPath(path) {
   for (let count = 0; path.length; count++) {
     if (path.match(/^\/+/)) {
       if (count === 0) {
-        p.add(3 /* Root */);
+        p.add(PartType.Root);
       } else {
-        p.add(1 /* Slash */);
+        p.add(PartType.Slash);
       }
       path = path.replace(/^\/+/, "");
     } else {
@@ -1493,7 +1500,7 @@ function pathJoin(...paths) {
 function relativePath(path, relative) {
   const relativeParts = splitPath(relative);
   let result;
-  if (relativeParts.parts[0] === 3 /* Root */) {
+  if (relativeParts.parts[0] === PartType.Root) {
     result = relative;
   } else {
     result = pathJoin(path, relative);
@@ -1503,13 +1510,13 @@ function relativePath(path, relative) {
   let topUp = false;
   for (const part of unoptPath.parts) {
     switch (part) {
-      case 3 /* Root */:
-        out.push(3 /* Root */);
+      case PartType.Root:
+        out.push(PartType.Root);
         break;
-      case 4 /* Up */:
+      case PartType.Up:
         if (out.length && !topUp) {
           const last = out.length - 1;
-          if (typeof out[last] === "string" && out[last - 1] == 3 /* Root */) {
+          if (typeof out[last] === "string" && out[last - 1] == PartType.Root) {
             out.pop();
           } else {
             out.pop();
@@ -1517,15 +1524,15 @@ function relativePath(path, relative) {
           }
           if (out.length === 0) {
             topUp = !topUp ? true : topUp;
-            out.push(4 /* Up */);
+            out.push(PartType.Up);
           }
         } else {
-          out.push(4 /* Up */);
+          out.push(PartType.Up);
         }
         break;
-      case 1 /* Slash */:
-        if (!(out[out.length - 1] & 1 /* Slash */)) {
-          out.push(1 /* Slash */);
+      case PartType.Slash:
+        if (!(out[out.length - 1] & PartType.Slash)) {
+          out.push(PartType.Slash);
         }
         break;
       default:
@@ -1556,37 +1563,37 @@ function localStripper(path, restrips, obj) {
     return obj.map((i) => localStripper(path, restrips, i));
   }
   const ret = { ...obj };
-  const matcher = (key2, nextPath) => {
+  const matcher = (key, nextPath) => {
     for (const re of restrips) {
-      if (re.test(key2) || re.test(nextPath)) {
+      if (re.test(key) || re.test(nextPath)) {
         return true;
       }
     }
     return false;
   };
-  for (const key2 in ret) {
-    if (Object.prototype.hasOwnProperty.call(ret, key2)) {
+  for (const key in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key)) {
       let nextPath;
       if (path) {
-        nextPath = [path, key2].join(".");
+        nextPath = [path, key].join(".");
       } else {
-        nextPath = key2;
+        nextPath = key;
       }
-      if (matcher(key2, nextPath)) {
-        delete ret[key2];
+      if (matcher(key, nextPath)) {
+        delete ret[key];
         continue;
       }
-      if (typeof ret[key2] === "object") {
-        if (Array.isArray(ret[key2])) {
-          ret[key2] = ret[key2].reduce((acc, v, i) => {
-            const toDelete = matcher(key2, `${nextPath}[${i}]`);
+      if (typeof ret[key] === "object") {
+        if (Array.isArray(ret[key])) {
+          ret[key] = ret[key].reduce((acc, v, i) => {
+            const toDelete = matcher(key, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
             }
             return acc;
           }, []);
         } else {
-          ret[key2] = localStripper(nextPath, restrips, ret[key2]);
+          ret[key] = localStripper(nextPath, restrips, ret[key]);
         }
       }
     }
@@ -1595,16 +1602,15 @@ function localStripper(path, restrips, obj) {
 }
 
 // src/uri.ts
-var key = param;
-function coerceKey(key2, def) {
-  if (typeof key2 === "object") {
-    const keys = Object.keys(key2);
+function coerceKey(key, def) {
+  if (typeof key === "object") {
+    const keys = Object.keys(key);
     if (keys.length !== 1) {
-      throw new Error(`Invalid key: ${JSON.stringify(key2)}`);
+      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
     }
-    return { key: keys[0], def: key2[keys[0]] };
+    return { key: keys[0], def: key[keys[0]] };
   }
-  return { key: key2, def };
+  return { key, def };
 }
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -1707,8 +1713,8 @@ var MutableURL = class _MutableURL extends URL {
   toString() {
     let search = "";
     if (this._sysURL.searchParams.size) {
-      for (const [key2, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-        search += `${!search.length ? "?" : "&"}${key2}=${encodeURIComponent(value)}`;
+      for (const [key, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+        search += `${!search.length ? "?" : "&"}${key}=${encodeURIComponent(value)}`;
       }
     }
     let hostpart = "";
@@ -1743,11 +1749,11 @@ function from(fac, strURLUri, defaultProtocol) {
       throw new Error(`Invalid argument: ${typeof strURLUri}`);
   }
 }
-function getParamResult(key2, val, msgFn = (key3) => {
-  return `missing parameter: ${key3}`;
+function getParamResult(key, val, msgFn = (key2) => {
+  return `missing parameter: ${key2}`;
 }) {
   if (val === void 0) {
-    return Result.Err(msgFn(key2));
+    return Result.Err(msgFn(key));
   }
   return Result.Ok(val);
 }
@@ -1804,47 +1810,47 @@ var BuildURI = class _BuildURI {
     const pathname = "./" + appendUrl.pathname;
     const basePath = this._url.pathname;
     this.pathname(relativePath(basePath, pathname));
-    for (const [key2, value] of appendUrl.getParams) {
-      this.setParam(key2, value);
+    for (const [key, value] of appendUrl.getParams) {
+      this.setParam(key, value);
     }
     return this;
   }
   cleanParams() {
-    for (const key2 of Array.from(this._url.searchParams.keys())) {
-      this._url.searchParams.delete(key2);
+    for (const key of Array.from(this._url.searchParams.keys())) {
+      this._url.searchParams.delete(key);
     }
     return this;
   }
-  delParam(key2) {
-    this._url.searchParams.delete(key2);
+  delParam(key) {
+    this._url.searchParams.delete(key);
     return this;
   }
-  defParam(key2, str) {
-    if (!this._url.searchParams.has(key2)) {
-      this._url.searchParams.set(key2, str);
+  defParam(key, str) {
+    if (!this._url.searchParams.has(key)) {
+      this._url.searchParams.set(key, str);
     }
     return this;
   }
-  setParam(key2, str) {
-    this._url.searchParams.set(key2, str);
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
     return this;
   }
-  hasParam(key2) {
-    return this._url.searchParams.has(key2);
+  hasParam(key) {
+    return this._url.searchParams.has(key);
   }
   get getParams() {
     return this._url.searchParams.entries();
   }
-  getParam(key2, def) {
-    const { key: k, def: d } = coerceKey(key2, def);
+  getParam(key, def) {
+    const { key: k, def: d } = coerceKey(key, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key2, msgFn) {
-    return getParamResult(key2, this.getParam(key2), msgFn);
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -1905,8 +1911,8 @@ var URI = class _URI {
     if (!(fPath.length === 0 || fPath === "/" || fPath === "./")) {
       intoUrl.pathname(fromUrl.pathname);
     }
-    for (const [key2, value] of fromUrl.getParams) {
-      intoUrl.setParam(key2, value);
+    for (const [key, value] of fromUrl.getParams) {
+      intoUrl.setParam(key, value);
     }
     return intoUrl.URI();
   }
@@ -1959,19 +1965,19 @@ var URI = class _URI {
   get getParams() {
     return this._url.searchParams.entries();
   }
-  hasParam(key2) {
-    return this._url.searchParams.has(key2);
+  hasParam(key) {
+    return this._url.searchParams.has(key);
   }
-  getParam(key2, def) {
-    const { key: k, def: d } = coerceKey(key2, def);
+  getParam(key, def) {
+    const { key: k, def: d } = coerceKey(key, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key2, msgFn) {
-    return getParamResult(key2, this.getParam(key2), msgFn);
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -2175,7 +2181,7 @@ var None = class extends Option {
 // src/log-level-impl.ts
 var LevelHandlerImpl = class {
   constructor() {
-    this._globalLevels = /* @__PURE__ */ new Set(["info" /* INFO */, "error" /* ERROR */, "warn" /* WARN */]);
+    this._globalLevels = /* @__PURE__ */ new Set([Level.INFO, Level.ERROR, Level.WARN]);
     this._modules = /* @__PURE__ */ new Map();
     this.ignoreAttr = Option.Some(/^_/);
     this.isStackExposed = false;
@@ -2225,9 +2231,9 @@ var LevelHandlerImpl = class {
   }
   setDebug(...modules) {
     this.forModules(
-      "debug" /* DEBUG */,
+      Level.DEBUG,
       (p) => {
-        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, "debug" /* DEBUG */]));
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, Level.DEBUG]));
       },
       ...modules
     );
@@ -2380,9 +2386,9 @@ var LoggerImpl = class _LoggerImpl {
     this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
-  Module(key2) {
-    this._attributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
-    this._withAttributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
+  Module(key) {
+    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
@@ -2403,30 +2409,30 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Warn() {
-    this._attributes["level"] = logValue("warn" /* WARN */, toLogValueCtx(this.levelHandler));
+    this._attributes["level"] = logValue(Level.WARN, toLogValueCtx(this.levelHandler));
     return this;
   }
   Log() {
     return this;
   }
   Debug() {
-    this._attributes["level"] = logValue("debug" /* DEBUG */, toLogValueCtx(this.levelHandler));
+    this._attributes["level"] = logValue(Level.DEBUG, toLogValueCtx(this.levelHandler));
     return this;
   }
   Error() {
-    this._attributes["level"] = logValue("error" /* ERROR */, toLogValueCtx(this.levelHandler));
+    this._attributes["level"] = logValue(Level.ERROR, toLogValueCtx(this.levelHandler));
     return this;
   }
   Info() {
-    this._attributes["level"] = logValue("info" /* INFO */, toLogValueCtx(this.levelHandler));
+    this._attributes["level"] = logValue(Level.INFO, toLogValueCtx(this.levelHandler));
     return this;
   }
   Err(err) {
     var _a;
-    let key2 = "error";
+    let key = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        key2 = "noerror";
+        key = "noerror";
         err = err.Ok();
       } else {
         err = err.Err();
@@ -2434,12 +2440,12 @@ var LoggerImpl = class _LoggerImpl {
     }
     if (err instanceof Error) {
       if (err.cause) {
-        this.coerceKey(key2, {
+        this.coerceKey(key, {
           message: err.message,
           cause: err.cause
         });
       } else {
-        this._attributes[key2] = logValue(err.message, toLogValueCtx(this.levelHandler));
+        this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
@@ -2448,7 +2454,7 @@ var LoggerImpl = class _LoggerImpl {
         );
       }
     } else {
-      this.Any(key2, err);
+      this.Any(key, err);
     }
     return this;
   }
@@ -2456,22 +2462,22 @@ var LoggerImpl = class _LoggerImpl {
     this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Ref(key2, action) {
+  Ref(key, action) {
     if (typeof action === "function") {
-      this._attributes[key2] = logValue(action, toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(action, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key2] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key2] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
-  Bool(key2, value) {
-    this.coerceKey(key2, !!value);
+  Bool(key, value) {
+    this.coerceKey(key, !!value);
     return this;
   }
   Http(...mix) {
-    const key2 = mix.find((x) => typeof x === "string");
+    const key = mix.find((x) => typeof x === "string");
     mix = mix.filter((x) => typeof x !== "string");
     const resErrors = mix.filter((x) => Result.Is(x) && x.isErr());
     if (resErrors.length) {
@@ -2491,70 +2497,70 @@ var LoggerImpl = class _LoggerImpl {
       reqAndOrres = req;
     }
     if (reqAndOrres) {
-      this.Any(key2 || "Http", reqAndOrres);
+      this.Any(key || "Http", reqAndOrres);
     }
     return this;
   }
   Pair(x) {
-    for (const key2 of Object.keys(x)) {
-      const value = x[key2];
+    for (const key of Object.keys(x)) {
+      const value = x[key];
       if (value instanceof LogValue) {
-        this._attributes[key2] = value;
+        this._attributes[key] = value;
         continue;
       }
       if (Result.Is(value)) {
-        this.Result(key2, value);
+        this.Result(key, value);
         continue;
       }
-      this.Any(key2, value);
+      this.Any(key, value);
     }
     return this;
   }
-  Result(key2, res) {
+  Result(key, res) {
     if (res.isOk()) {
-      this._attributes[key2] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
-  Len(value, key2 = "len") {
-    this._attributes[key2] = getLen(value, toLogValueCtx(this.levelHandler));
+  Len(value, key = "len") {
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Hash(value, key2 = "hash") {
+  Hash(value, key = "hash") {
     throw new Error("Not implemented");
   }
-  Url(url, key2 = "url") {
-    this.Ref(key2, () => URI.from(url).toString());
+  Url(url, key = "url") {
+    this.Ref(key, () => URI.from(url).toString());
     return this;
   }
-  coerceKey(key2, value) {
-    if (typeof key2 === "string") {
-      this._attributes[key2] = logValue(value, toLogValueCtx(this.levelHandler));
+  coerceKey(key, value) {
+    if (typeof key === "string") {
+      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
-      this.Pair(key2);
+      this.Pair(key);
     }
   }
-  Str(key2, value) {
-    this.coerceKey(key2, value);
+  Str(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Any(key2, value) {
-    this.coerceKey(key2, value);
+  Any(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Dur(key2, nsec) {
-    this._attributes[key2] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
+  Dur(key, nsec) {
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Uint64(key2, value) {
-    this.coerceKey(key2, value);
+  Uint64(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Int(key2, value) {
-    return this.Uint64(key2, value);
+  Int(key, value) {
+    return this.Uint64(key, value);
   }
   async Flush() {
     return new Promise((resolve) => {
@@ -2577,8 +2583,8 @@ var LoggerImpl = class _LoggerImpl {
   }
   _resetAttributes(fn) {
     const ret = fn();
-    Object.keys(this._attributes).forEach((key2) => {
-      delete this._attributes[key2];
+    Object.keys(this._attributes).forEach((key) => {
+      delete this._attributes[key];
     });
     Object.assign(this._attributes, this._withAttributes);
     return ret;
@@ -2645,8 +2651,8 @@ var WithLoggerBuilder = class {
     this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
-  Module(key2) {
-    this._li.Module(key2);
+  Module(key) {
+    this._li.Module(key);
     return this;
   }
   SetDebug(...modules) {
@@ -2661,36 +2667,36 @@ var WithLoggerBuilder = class {
     this._li.Pair(x);
     return this;
   }
-  Str(key2, value) {
-    this._li.Str(key2, value);
+  Str(key, value) {
+    this._li.Str(key, value);
     return this;
   }
-  Len(value, key2) {
-    this._li.Len(value, key2);
+  Len(value, key) {
+    this._li.Len(value, key);
     return this;
   }
-  Hash(value, key2) {
-    this._li.Hash(value, key2);
+  Hash(value, key) {
+    this._li.Hash(value, key);
     return this;
   }
-  Ref(key2, action) {
-    this._li.Ref(key2, action);
+  Ref(key, action) {
+    this._li.Ref(key, action);
     return this;
   }
-  Bool(key2, value) {
-    this._li.Bool(key2, value);
+  Bool(key, value) {
+    this._li.Bool(key, value);
     return this;
   }
-  Result(key2, res) {
-    this._li.Result(key2, res);
+  Result(key, res) {
+    this._li.Result(key, res);
     return this;
   }
-  Url(url, key2) {
-    this._li.Url(url, key2);
+  Url(url, key) {
+    this._li.Url(url, key);
     return this;
   }
-  Int(key2, value) {
-    this._li.Int(key2, value);
+  Int(key, value) {
+    this._li.Int(key, value);
     return this;
   }
   Log() {
@@ -2725,16 +2731,16 @@ var WithLoggerBuilder = class {
     this._li.Timestamp();
     return this;
   }
-  Any(key2, value) {
-    this._li.Any(key2, value);
+  Any(key, value) {
+    this._li.Any(key, value);
     return this;
   }
-  Dur(key2, nsec) {
-    this._li.Dur(key2, nsec);
+  Dur(key, nsec) {
+    this._li.Dur(key, nsec);
     return this;
   }
-  Uint64(key2, value) {
-    this._li.Uint64(key2, value);
+  Uint64(key, value) {
+    this._li.Uint64(key, value);
     return this;
   }
 };
@@ -2899,8 +2905,8 @@ var Metrics = class {
   }
   toJSON() {
     const obj = {};
-    for (const [key2, value] of this.map) {
-      obj[key2] = value.value;
+    for (const [key, value] of this.map) {
+      obj[key] = value.value;
     }
     return obj;
   }
@@ -3073,15 +3079,15 @@ var HeadersImpl = class extends Headers {
   values() {
     return this._headers.values();
   }
-  append(key2, value) {
-    const values = this._headers.get(key2);
+  append(key, value) {
+    const values = this._headers.get(key);
     if (typeof value === "undefined") {
       value = "";
     }
     if (Array.isArray(value)) {
-      this._headers.set(key2, [values, ...value].filter((i) => i).join(", "));
+      this._headers.set(key, [values, ...value].filter((i) => i).join(", "));
     } else {
-      this._headers.set(key2, [values, value].filter((i) => i).join(", "));
+      this._headers.set(key, [values, value].filter((i) => i).join(", "));
     }
     return this;
   }
@@ -3124,38 +3130,38 @@ var HttpHeader = class _HttpHeader {
   }
   _asStringString() {
     const ret = /* @__PURE__ */ new Map();
-    for (const [key2, values] of this._headers) {
-      ret.set(key2, values.join(", "));
+    for (const [key, values] of this._headers) {
+      ret.set(key, values.join(", "));
     }
     return ret;
   }
-  _key(key2) {
-    return key2.toLowerCase();
+  _key(key) {
+    return key.toLowerCase();
   }
-  Values(key2) {
-    const values = this._headers.get(this._key(key2));
+  Values(key) {
+    const values = this._headers.get(this._key(key));
     return values || [];
   }
-  Get(key2) {
-    const values = this._headers.get(this._key(key2));
+  Get(key) {
+    const values = this._headers.get(this._key(key));
     if (values === void 0 || values.length === 0) {
       return void 0;
     }
     return values[0];
   }
-  Set(key2, valueOr) {
+  Set(key, valueOr) {
     const value = Array.isArray(valueOr) ? valueOr : [valueOr];
-    this._headers.set(this._key(key2), value);
+    this._headers.set(this._key(key), value);
     return this;
   }
-  Add(key2, value) {
+  Add(key, value) {
     if (typeof value === "undefined") {
       return this;
     }
     const vs = Array.isArray(value) ? value : [value];
-    const values = this._headers.get(this._key(key2));
+    const values = this._headers.get(this._key(key));
     if (values === void 0) {
-      this._headers.set(this._key(key2), vs);
+      this._headers.set(this._key(key), vs);
     } else {
       values.push(...vs);
     }
@@ -3173,29 +3179,29 @@ var HttpHeader = class _HttpHeader {
   }
   Clone() {
     const clone = new _HttpHeader();
-    for (const [key2, values] of this._headers.entries()) {
-      clone._headers.set(key2, values.slice());
+    for (const [key, values] of this._headers.entries()) {
+      clone._headers.set(key, values.slice());
     }
     return clone;
   }
   AsRecordStringStringArray() {
     const obj = {};
-    for (const [key2, values] of this._headers.entries()) {
-      obj[key2] = [...values];
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = [...values];
     }
     return obj;
   }
   AsRecordStringString() {
     const obj = {};
-    for (const [key2, values] of this._headers.entries()) {
-      obj[key2] = values.join(", ");
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values.join(", ");
     }
     return obj;
   }
   AsHeaderInit() {
     const obj = {};
-    for (const [key2, values] of this._headers.entries()) {
-      obj[key2] = values[0];
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values[0];
     }
     return obj;
   }
@@ -3205,8 +3211,8 @@ var HttpHeader = class _HttpHeader {
   Merge(other) {
     const ret = this.Clone();
     if (other) {
-      for (const [key2, values] of other.Items()) {
-        ret.Add(key2, values);
+      for (const [key, values] of other.Items()) {
+        ret.Add(key, values);
       }
     }
     return ret;
@@ -3287,6 +3293,57 @@ function JSONEnDecoderSingleton(txtEnde) {
   return jsonEnDecoder;
 }
 
+// src/lru-cache.ts
+var LRUCache = class {
+  constructor(c = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.param = {
+      maxEntries: c.maxEntries || 100,
+      maxAge: c.maxAge || 0
+    };
+  }
+  touch(key) {
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  get size() {
+    return this.cache.size;
+  }
+  async getPut(key, createFN) {
+    const val = this.get(key);
+    if (val) {
+      return val;
+    } else {
+      const val2 = await createFN(key);
+      this.put(key, val2);
+      return val2;
+    }
+  }
+  get(key) {
+    if (this.cache.has(key)) {
+      return this.touch(key);
+    }
+    return this.cache.get(key);
+  }
+  put(key, value) {
+    this.cache.delete(key);
+    if (this.cache.size >= this.param.maxEntries) {
+      this.cache.delete(this.cache.keys().next().value);
+      this.cache.set(key, value);
+    } else {
+      this.cache.set(key, value);
+    }
+  }
+  //   getLeastRecent(): K {
+  //     return Array.from(this.cache)[0];
+  //   }
+  //   getMostRecent(): K {
+  //     return Array.from(this.cache)[this.cache.size - 1];
+  //   }
+};
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -3299,7 +3356,6 @@ __export(utils_exports, {
   coerceIntoUint8: () => coerceIntoUint8,
   devnull: () => devnull,
   getParamsResult: () => getParamsResult,
-  param: () => param,
   rebuffer: () => rebuffer,
   rebufferArray: () => rebufferArray,
   stream2array: () => stream2array,
@@ -3524,9 +3580,6 @@ function UInt8ArrayEqual(a, b) {
   }
   return true;
 }
-
-// src/index.ts
-var param2 = param;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseSysAbstraction,
@@ -3544,6 +3597,7 @@ var param2 = param;
   Keyed,
   KeyedResolvOnce,
   KeyedResolvSeq,
+  LRUCache,
   Level,
   LevelHandlerImpl,
   LevelHandlerSingleton,
@@ -3586,7 +3640,6 @@ var param2 = param;
   hasHostPartProtocols,
   isCoerceURI,
   isURL,
-  key,
   logValue,
   param,
   pathOps,