@adviser/cement 0.3.14 → 0.3.16

package/{chunk-KY47QBK3.js → chunk-WGRZHIFK.js}

@@ -5,18 +5,17 @@ import {
 } from "./chunk-PHS255C5.js";
 import {
   WebSysAbstraction
-} from "./chunk-GLUGMVET.js";
+} from "./chunk-Z3IR6QEZ.js";
 import {
   Future,
   runtimeFn
-} from "./chunk-22GI5ETU.js";
+} from "./chunk-H3CAVBMO.js";
 import {
   Result,
   TxtEnDecoderSingleton,
   exception2Result,
-  getParamsResult,
-  param
-} from "./chunk-A57BAYWU.js";
+  getParamsResult
+} from "./chunk-LXTKPZ6M.js";
 
 // src/test/log-write-stream.ts
 var LogWriteStream = class {
@@ -144,13 +143,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;
@@ -244,16 +242,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);
           }
         }
       }
@@ -344,7 +342,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;
@@ -394,9 +392,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
     );
@@ -430,6 +428,13 @@ function LevelHandlerSingleton() {
 import YAML from "yaml";
 
 // 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;
@@ -440,10 +445,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;
@@ -452,22 +457,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;
@@ -483,9 +488,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 {
@@ -519,7 +524,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);
@@ -529,13 +534,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();
@@ -543,15 +548,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:
@@ -563,16 +568,15 @@ function relativePath(path, relative) {
 }
 
 // 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;
@@ -675,8 +679,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 = "";
@@ -711,11 +715,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);
 }
@@ -772,47 +776,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);
@@ -873,8 +877,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();
   }
@@ -927,19 +931,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);
@@ -1144,9 +1148,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
@@ -1167,30 +1171,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();
@@ -1198,12 +1202,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(
@@ -1212,7 +1216,7 @@ var LoggerImpl = class _LoggerImpl {
         );
       }
     } else {
-      this.Any(key2, err);
+      this.Any(key, err);
     }
     return this;
   }
@@ -1220,22 +1224,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) {
@@ -1255,70 +1259,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) => {
@@ -1341,8 +1345,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;
@@ -1409,8 +1413,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) {
@@ -1425,36 +1429,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() {
@@ -1489,16 +1493,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;
   }
 };
@@ -1534,7 +1538,6 @@ export {
   asyncLogValue,
   logValue,
   IsLogger,
-  key,
   isURL,
   MutableURL,
   BuildURI,
@@ -1553,4 +1556,4 @@ export {
   LogCollector,
   MockLogger
 };
-//# sourceMappingURL=chunk-KY47QBK3.js.map
+//# sourceMappingURL=chunk-WGRZHIFK.js.map