@adviser/cement 0.2.40 → 0.2.42

package/index.cjs

@@ -1,31 +1,13 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -51,38 +33,6 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __yieldStar = (value) => {
-  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
-  if (obj == null) {
-    obj = value[__knownSymbol("iterator")]();
-    method = (k) => it[k] = (x) => obj[k](x);
-  } else {
-    obj = obj.call(value);
-    method = (k) => it[k] = (v) => {
-      if (isAwait) {
-        isAwait = false;
-        if (k === "throw") throw v;
-        return v;
-      }
-      isAwait = true;
-      return {
-        done: false,
-        value: new __await(new Promise((resolve) => {
-          var x = obj[k](v);
-          if (!(x instanceof Object)) __typeError("Object expected");
-          resolve(x);
-        }), 1)
-      };
-    };
-  }
-  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
-    throw x;
-  }, "return" in obj && method("return"), it;
-};
 
 // src/index.ts
 var src_exports = {};
@@ -93,6 +43,8 @@ __export(src_exports, {
   ConstTime: () => ConstTime,
   EnvImpl: () => EnvImpl,
   Future: () => Future,
+  HeadersImpl: () => HeadersImpl,
+  HttpHeader: () => HttpHeader,
   IDMode: () => IDMode,
   IdService: () => IdService,
   IsLogger: () => IsLogger,
@@ -113,6 +65,7 @@ __export(src_exports, {
   MutableURL: () => MutableURL,
   None: () => None,
   Option: () => Option,
+  REQUIRED: () => REQUIRED,
   RandomMode: () => RandomMode,
   RandomService: () => RandomService,
   ResolveOnce: () => ResolveOnce,
@@ -224,7 +177,18 @@ var LogValue = class {
 function asyncLogValue(val) {
   throw new Error("Not implemented");
 }
-function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
+function logValue(val, ctx) {
+  return logValueInternal(val, {
+    ...ctx,
+    state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
+  });
+}
+function logValueInternal(val, ctx) {
+  var _a, _b;
+  ctx = {
+    ...ctx,
+    state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
+  };
   switch (typeof val) {
     case "function":
       return new LogValue(val);
@@ -232,7 +196,7 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
       try {
         const ret = JSON.parse(val);
         if (typeof ret === "object" && ret !== null) {
-          return logValue(ret, state);
+          return logValueInternal(ret, ctx);
         }
       } catch (e) {
         if (val.match(/[\n\r]/)) {
@@ -255,13 +219,15 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
           const decoder2 = new TextDecoder();
           const asStr = decoder2.decode(val);
           const obj = JSON.parse(asStr);
-          return logValue(obj, state);
+          return logValueInternal(obj, ctx);
         } catch (e) {
-          return logValue(bin2string(val, 512));
+          return logValueInternal(bin2string(val, 512), ctx);
         }
       }
       if (Array.isArray(val)) {
-        return new LogValue(() => val.map((v) => logValue(v).value()));
+        return new LogValue(
+          () => val.map((v) => logValue(v, { ...ctx, state: void 0 }).value())
+        );
       }
       if (val instanceof Headers) {
         return new LogValue(() => Object.fromEntries(val.entries()));
@@ -272,22 +238,25 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
       if (val instanceof Promise) {
         return new LogValue(() => ">Promise<");
       }
-      if (state.has(val)) {
+      if ((_a = ctx.state) == null ? void 0 : _a.has(val)) {
         return new LogValue(() => "...");
       }
-      state.add(val);
+      (_b = ctx.state) == null ? void 0 : _b.add(val);
       if (typeof val.toJSON === "function") {
         return new LogValue(() => val.toJSON());
       }
       const res = {};
       const typedVal = val;
       for (const key in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
+          continue;
+        }
         const element = typedVal[key];
         if (element instanceof LogValue) {
           res[key] = element;
         } else {
           if (typeof element !== "function") {
-            res[key] = logValue(element, state);
+            res[key] = logValueInternal(element, ctx);
           }
         }
       }
@@ -998,6 +967,12 @@ var Result = class _Result {
     if (typeof t === "string") {
       return new ResultError(new Error(t));
     }
+    if (_Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok"));
+      }
+      return t;
+    }
     return new ResultError(t);
   }
   static Is(t) {
@@ -1074,6 +1049,139 @@ function exception2Result(fn) {
   }
 }
 
+// src/utils/relative-path.ts
+var Path = class {
+  constructor(parts = []) {
+    this.parts = parts;
+  }
+  toString() {
+    return this.parts.map((part) => {
+      if (typeof part === "string") {
+        return part;
+      } else {
+        switch (part) {
+          case 1 /* Slash */:
+          case 3 /* Root */:
+            return "/";
+          case 4 /* Up */:
+            return "..";
+          default:
+            return part;
+        }
+      }
+    }).join("");
+  }
+  add(part) {
+    if (this.parts.includes(3 /* Root */) && part === 3 /* 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 */) {
+      return;
+    }
+    switch (part) {
+      case ".":
+        this.parts.push(8 /* Noop */);
+        return;
+      case "..":
+        part = 4 /* Up */;
+    }
+    if (last === 8 /* Noop */ && part === 1 /* Slash */) {
+      if (last === 8 /* Noop */) {
+        this.parts.pop();
+      }
+      return;
+    }
+    this.parts.push(part);
+  }
+};
+function splitPath(path) {
+  const p = new Path();
+  if (path === "") {
+    return p;
+  }
+  for (let count = 0; path.length; count++) {
+    if (path.match(/^\/+/)) {
+      if (count === 0) {
+        p.add(3 /* Root */);
+      } else {
+        p.add(1 /* Slash */);
+      }
+      path = path.replace(/^\/+/, "");
+    } else {
+      const part = path.replace(/\/.*$/, "");
+      p.add(part);
+      path = path.replace(/^[^/]+/, "");
+    }
+  }
+  return p;
+}
+function pathJoin(...paths) {
+  let prev = "";
+  const res = [];
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path === "") {
+      continue;
+    }
+    if (!(prev.endsWith("/") || path.startsWith("/"))) {
+      if (prev !== "") {
+        res.push("/");
+      }
+      res.push(path);
+    } else {
+      res.push(path);
+    }
+    prev = path;
+  }
+  return res.join("");
+}
+function relativePath(path, relative) {
+  const relativeParts = splitPath(relative);
+  let result;
+  if (relativeParts.parts[0] === 3 /* Root */) {
+    result = relative;
+  } else {
+    result = pathJoin(path, relative);
+  }
+  const unoptPath = splitPath(result);
+  const out = [];
+  let topUp = false;
+  for (const part of unoptPath.parts) {
+    switch (part) {
+      case 3 /* Root */:
+        out.push(3 /* Root */);
+        break;
+      case 4 /* Up */:
+        if (out.length && !topUp) {
+          const last = out.length - 1;
+          if (typeof out[last] === "string" && out[last - 1] == 3 /* Root */) {
+            out.pop();
+          } else {
+            out.pop();
+            out.pop();
+          }
+          if (out.length === 0) {
+            topUp = !topUp ? true : topUp;
+            out.push(4 /* Up */);
+          }
+        } else {
+          out.push(4 /* Up */);
+        }
+        break;
+      case 1 /* Slash */:
+        if (!(out[out.length - 1] & 1 /* Slash */)) {
+          out.push(1 /* Slash */);
+        }
+        break;
+      default:
+        out.push(part);
+        break;
+    }
+  }
+  return new Path(out).toString();
+}
+
 // src/utils/stripper.ts
 function stripper(strip, obj) {
   const strips = Array.isArray(strip) ? strip : [strip];
@@ -1093,7 +1201,7 @@ function localStripper(path, restrips, obj) {
   if (Array.isArray(obj)) {
     return obj.map((i) => localStripper(path, restrips, i));
   }
-  const ret = __spreadValues({}, obj);
+  const ret = { ...obj };
   const matcher = (key, nextPath) => {
     for (const re of restrips) {
       if (re.test(key) || re.test(nextPath)) {
@@ -1133,6 +1241,7 @@ function localStripper(path, restrips, obj) {
 }
 
 // src/uri.ts
+var REQUIRED = 4711;
 function coerceKey(key, def) {
   if (typeof key === "object") {
     const keys = Object.keys(key);
@@ -1353,17 +1462,29 @@ var BuildURI = class _BuildURI {
     this._url.pathname = p;
     return this;
   }
-  appendRelative(p) {
-    const appendUrl = URI.from(p);
-    let pathname = appendUrl.pathname;
-    let basePath = this._url.pathname;
-    if (pathname.startsWith("/")) {
-      pathname = pathname.replace(/^\//, "");
+  // could pass a relative path or a full URL
+  // if relative path, it will be appended to the current path
+  resolve(p) {
+    if (!p) {
+      return this;
     }
-    if (basePath.length > 0) {
-      basePath = basePath.replace(/\/$/, "");
+    if (typeof p === "string") {
+      if (!p.match(/^[a-zA-Z0-9]+:/)) {
+        if (p.startsWith("/")) {
+          this.pathname(p);
+          return this;
+        }
+        return this.appendRelative(p);
+      }
     }
-    this.pathname(basePath + "/" + pathname);
+    this._url = new MutableURL(p.toString());
+    return this;
+  }
+  appendRelative(p) {
+    const appendUrl = URI.from(p);
+    const pathname = "./" + appendUrl.pathname;
+    const basePath = this._url.pathname;
+    this.pathname(relativePath(basePath, pathname));
     for (const [key, value] of appendUrl.getParams) {
       this.setParam(key, value);
     }
@@ -1538,11 +1659,12 @@ var URI = class _URI {
       searchParams: Object.fromEntries(this.getParams)
     };
     if (hasHostPartProtocols.has(this.protocol.replace(/:$/, ""))) {
-      return stripper(strips, __spreadProps(__spreadValues({}, pathURI), {
+      return stripper(strips, {
+        ...pathURI,
         style: "host",
         hostname: this.hostname,
         port: this.port
-      }));
+      });
     }
     return stripper(strips, pathURI);
   }
@@ -1683,11 +1805,66 @@ var LogWriterStream = class {
   }
 };
 
+// src/option.ts
+var Option = class _Option {
+  static Some(t) {
+    return new Some(t);
+  }
+  static None() {
+    return new None();
+  }
+  static Is(t) {
+    return t instanceof _Option;
+  }
+  static From(t) {
+    if (!t) {
+      return new None();
+    }
+    return new Some(t);
+  }
+  IsNone() {
+    return this.is_none();
+  }
+  IsSome() {
+    return this.is_some();
+  }
+  Unwrap() {
+    return this.unwrap();
+  }
+};
+var Some = class extends Option {
+  constructor(_t) {
+    super();
+    this._t = _t;
+  }
+  is_none() {
+    return false;
+  }
+  is_some() {
+    return true;
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var None = class extends Option {
+  is_none() {
+    return true;
+  }
+  is_some() {
+    return false;
+  }
+  unwrap() {
+    throw new Error("None.unwrap");
+  }
+};
+
 // src/log-level-impl.ts
 var LevelHandlerImpl = class {
   constructor() {
     this._globalLevels = /* @__PURE__ */ new Set(["info" /* INFO */, "error" /* ERROR */, "warn" /* WARN */]);
     this._modules = /* @__PURE__ */ new Map();
+    this.ignoreAttr = Option.Some(/^_/);
     this.isStackExposed = false;
   }
   enableLevel(level, ...modules) {
@@ -1719,6 +1896,9 @@ var LevelHandlerImpl = class {
   setExposeStack(enable) {
     this.isStackExposed = !!enable;
   }
+  setIgnoreAttr(re) {
+    this.ignoreAttr = Option.From(re);
+  }
   forModules(level, fnAction, ...modules) {
     for (const m of modules.flat()) {
       if (typeof m !== "string") {
@@ -1765,20 +1945,20 @@ function LevelHandlerSingleton() {
 }
 
 // src/logger-impl.ts
-function getLen(value) {
+function getLen(value, lvs) {
   if (Array.isArray(value)) {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "string") {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "object" && value !== null) {
     if (typeof value.size === "number") {
-      return logValue(() => value.size);
+      return logValue(() => value.size, lvs);
     } else if (typeof value.length === "number") {
-      return logValue(() => value.length);
+      return logValue(() => value.length, lvs);
     }
-    return logValue(() => Object.keys(value).length);
+    return logValue(() => Object.keys(value).length, lvs);
   }
-  return logValue(() => -1);
+  return logValue(() => -1, lvs);
 }
 function hash(value) {
   return "not implemented";
@@ -1813,6 +1993,11 @@ var YAMLFormatter = class {
     return this._txtEnDe.encode("---\n" + import_yaml.default.stringify(attr, null, this._space) + "\n");
   }
 };
+function toLogValueCtx(lvh) {
+  return {
+    ignoreAttr: lvh.ignoreAttr
+  };
+}
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -1858,13 +2043,13 @@ var LoggerImpl = class _LoggerImpl {
     if (!params.withAttributes) {
       this._withAttributes = {};
     } else {
-      this._withAttributes = __spreadValues({}, params.withAttributes);
+      this._withAttributes = { ...params.withAttributes };
     }
-    this._attributes = __spreadValues({}, this._withAttributes);
+    this._attributes = { ...this._withAttributes };
     if (params.levelHandler) {
-      this._levelHandler = params.levelHandler;
+      this.levelHandler = params.levelHandler;
     } else {
-      this._levelHandler = LevelHandlerSingleton();
+      this.levelHandler = LevelHandlerSingleton();
     }
   }
   TxtEnDe() {
@@ -1874,25 +2059,29 @@ var LoggerImpl = class _LoggerImpl {
     return JSON.parse(JSON.stringify(this._attributes, null));
   }
   SetExposeStack(enable) {
-    this._levelHandler.setExposeStack(enable);
+    this.levelHandler.setExposeStack(enable);
     return this;
   }
   EnableLevel(level, ...modules) {
-    this._levelHandler.enableLevel(level, ...modules);
+    this.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level, ...modules) {
-    this._levelHandler.disableLevel(level, ...modules);
+    this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
   Module(key) {
-    this._attributes["module"] = logValue(key);
-    this._withAttributes["module"] = logValue(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
   SetDebug(...modules) {
-    this._levelHandler.setDebug(...modules);
+    this.levelHandler.setDebug(...modules);
+    return this;
+  }
+  SetIgnoreAttribute(re) {
+    this.levelHandler.setIgnoreAttr(re);
     return this;
   }
   SetFormatter(formatter) {
@@ -1900,57 +2089,63 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Timestamp() {
-    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString(), toLogValueCtx(this.levelHandler));
     return this;
   }
   Warn() {
-    this._attributes["level"] = logValue("warn" /* WARN */);
+    this._attributes["level"] = logValue("warn" /* WARN */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Log() {
     return this;
   }
   Debug() {
-    this._attributes["level"] = logValue("debug" /* DEBUG */);
+    this._attributes["level"] = logValue("debug" /* DEBUG */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Error() {
-    this._attributes["level"] = logValue("error" /* ERROR */);
+    this._attributes["level"] = logValue("error" /* ERROR */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Info() {
-    this._attributes["level"] = logValue("info" /* INFO */);
+    this._attributes["level"] = logValue("info" /* INFO */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Err(err) {
     var _a;
+    let key = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        this.Result("noerror", err);
+        key = "noerror";
+        err = err.Ok();
       } else {
-        this.Result("error", err);
+        err = err.Err();
       }
-    } else if (err instanceof Error) {
-      this._attributes["error"] = logValue(err.message);
-      if (this._levelHandler.isStackExposed) {
-        this._attributes["stack"] = logValue((_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()));
+    }
+    if (err instanceof Error) {
+      this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
+      if (this.levelHandler.isStackExposed) {
+        this._attributes["stack"] = logValue(
+          (_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()),
+          toLogValueCtx(this.levelHandler)
+        );
       }
     } else {
-      this._attributes["error"] = logValue("" + err);
+      this.Any(key, err);
     }
     return this;
   }
   WithLevel(l) {
-    this._attributes["level"] = logValue(l);
+    this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
   Ref(key, action) {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action);
+      this._attributes[key] = logValue(action, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key] = logValue(() => action.toString());
+      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key] = logValue("INVALID REF");
+      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
@@ -2000,18 +2195,20 @@ var LoggerImpl = class _LoggerImpl {
   }
   Result(key, res) {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok());
+      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
   Len(value, key = "len") {
-    this._attributes[key] = getLen(value);
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
   Hash(value, key = "hash") {
-    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
+    this._attributes[key] = asyncLogValue(
+      async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`
+    );
     return this;
   }
   Url(url, key = "url") {
@@ -2020,7 +2217,7 @@ var LoggerImpl = class _LoggerImpl {
   }
   coerceKey(key, value) {
     if (typeof key === "string") {
-      this._attributes[key] = logValue(value);
+      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
       this.Pair(key);
     }
@@ -2034,7 +2231,7 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Dur(key, nsec) {
-    this._attributes[key] = logValue(`${nsec}ms`);
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
   Uint64(key, value) {
@@ -2054,11 +2251,12 @@ var LoggerImpl = class _LoggerImpl {
       new _LoggerImpl({
         logWriter: this._logWriter,
         sys: this._sys,
-        levelHandler: this._levelHandler,
+        levelHandler: this.levelHandler,
         formatter: this._formatter,
-        withAttributes: __spreadValues({
-          module: this._attributes["module"]
-        }, this._withAttributes)
+        withAttributes: {
+          module: this._attributes["module"],
+          ...this._withAttributes
+        }
       })
     );
   }
@@ -2073,16 +2271,16 @@ var LoggerImpl = class _LoggerImpl {
   Msg(...args) {
     const fnError = this._resetAttributes(() => {
       var _a, _b;
-      const doWrite = this._levelHandler.isEnabled(
+      const doWrite = this.levelHandler.isEnabled(
         (_a = toLogValue(this._attributes["level"])) == null ? void 0 : _a.value(),
         (_b = toLogValue(this._attributes["module"])) == null ? void 0 : _b.value()
       );
-      this._attributes["msg"] = logValue(args.join(" "));
+      this._attributes["msg"] = logValue(args.join(" "), toLogValueCtx(this.levelHandler));
       const msg = this._attributes["msg"].value();
       if (typeof msg === "string" && !msg.trim().length) {
         delete this._attributes["msg"];
       }
-      let fnRet = () => this._formatter.format(__spreadValues({}, this._attributes));
+      let fnRet = () => this._formatter.format({ ...this._attributes });
       if (doWrite) {
         const encoded = fnRet();
         this._logWriter.write(encoded);
@@ -2100,6 +2298,7 @@ var LoggerImpl = class _LoggerImpl {
 var WithLoggerBuilder = class {
   constructor(li) {
     this._li = li;
+    this.levelHandler = li.levelHandler;
   }
   TxtEnDe() {
     return this._li.TxtEnDe();
@@ -2109,10 +2308,14 @@ var WithLoggerBuilder = class {
     return this._li;
   }
   Attributes() {
-    return __spreadValues({}, this._li._attributes);
+    return { ...this._li._attributes };
   }
   SetExposeStack(enable) {
-    this._li._levelHandler.setExposeStack(enable);
+    this._li.levelHandler.setExposeStack(enable);
+    return this;
+  }
+  SetIgnoreAttribute(re) {
+    this._li.levelHandler.setIgnoreAttr(re);
     return this;
   }
   SetFormatter(fmt) {
@@ -2120,11 +2323,11 @@ var WithLoggerBuilder = class {
     return this;
   }
   EnableLevel(level, ...modules) {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level, ...modules) {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   Module(key) {
@@ -2311,7 +2514,7 @@ var LogCollector = class {
       new Uint8Array(
         function* (res) {
           for (const x of res) {
-            yield* __yieldStar(x);
+            yield* x;
           }
         }(this._bufferArr)
       )
@@ -2349,54 +2552,6 @@ function MockLogger(params) {
   };
 }
 
-// src/option.ts
-var Option = class _Option {
-  static Some(t) {
-    return new Some(t);
-  }
-  static None() {
-    return new None();
-  }
-  static Is(t) {
-    return t instanceof _Option;
-  }
-  IsNone() {
-    return this.is_none();
-  }
-  IsSome() {
-    return this.is_some();
-  }
-  Unwrap() {
-    return this.unwrap();
-  }
-};
-var Some = class extends Option {
-  constructor(_t) {
-    super();
-    this._t = _t;
-  }
-  is_none() {
-    return false;
-  }
-  is_some() {
-    return true;
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var None = class extends Option {
-  is_none() {
-    return true;
-  }
-  is_some() {
-    return false;
-  }
-  unwrap() {
-    throw new Error("None.unwrap");
-  }
-};
-
 // src/tracer.ts
 var Metric = class {
   constructor(path) {
@@ -2478,22 +2633,24 @@ var TraceNode = class _TraceNode {
     return this.ctx.parent.getRootPath(rpath.concat(this.ctx.spanId));
   }
   invokes() {
-    const cleanCtx = __spreadValues({}, this.ctx);
+    const cleanCtx = { ...this.ctx };
     delete cleanCtx.parent;
     delete cleanCtx.time;
     delete cleanCtx.logger;
     delete cleanCtx.metrics;
     const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs });
     const metricsRefs = Object.keys(spanRefs).length > 0 ? { metricRefs: spanRefs } : {};
-    return __spreadValues({
+    return {
       ctx: cleanCtx,
-      invokations: this.invokations
-    }, metricsRefs);
+      invokations: this.invokations,
+      ...metricsRefs
+    };
   }
   ctxWith(spanId, logger) {
-    const ctx = __spreadProps(__spreadValues({}, this.ctx), {
+    const ctx = {
+      ...this.ctx,
       spanId
-    });
+    };
     if (logger) {
       ctx.logger = logger;
     }
@@ -2503,17 +2660,23 @@ var TraceNode = class _TraceNode {
   span(inSpanId, fn) {
     let ctx;
     if (typeof inSpanId === "string") {
-      ctx = __spreadProps(__spreadValues({}, this.ctx), {
+      ctx = {
+        ...this.ctx,
         spanId: inSpanId,
         parent: this
-      });
+      };
     } else {
-      ctx = __spreadProps(__spreadValues(__spreadValues({}, this.ctx), inSpanId), {
+      ctx = {
+        ...this.ctx,
+        ...inSpanId,
         parent: this
-      });
+      };
     }
     if (ctx.logger) {
-      ctx = __spreadValues(__spreadValues({}, ctx), ctx.logger.Attributes());
+      ctx = {
+        ...ctx,
+        ...ctx.logger.Attributes()
+      };
     }
     const spanId = ctx.spanId;
     let spanTrace = this.childs.get(spanId);
@@ -2577,6 +2740,161 @@ var VERSION = Object.keys({
   __packageVersion__: "xxxx"
 })[0];
 
+// src/http_header.ts
+var HeadersImpl = class extends Headers {
+  constructor(init) {
+    super();
+    this._headers = init;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  entries() {
+    return this._headers.entries();
+  }
+  keys() {
+    return this._headers.keys();
+  }
+  values() {
+    return this._headers.values();
+  }
+  append(key, value) {
+    const values = this._headers.get(key);
+    if (typeof value === "undefined") {
+      value = "";
+    }
+    if (Array.isArray(value)) {
+      this._headers.set(key, [values, ...value].filter((i) => i).join(", "));
+    } else {
+      this._headers.set(key, [values, value].filter((i) => i).join(", "));
+    }
+    return this;
+  }
+};
+var HttpHeader = class _HttpHeader {
+  constructor() {
+    this._headers = /* @__PURE__ */ new Map();
+  }
+  static from(headers) {
+    const h = new _HttpHeader();
+    if (headers) {
+      if (Array.isArray(headers)) {
+        for (const [k, v] of headers) {
+          if (v) {
+            h.Add(k, v);
+          }
+        }
+      } else if (headers instanceof Headers) {
+        for (const [k, v] of headers.entries()) {
+          if (v) {
+            h.Add(
+              k,
+              v.split(",").map((v2) => v2.trim())
+            );
+          }
+        }
+      } else {
+        for (const k in headers) {
+          const v = headers[k];
+          if (v) {
+            h.Add(k, v);
+          }
+        }
+      }
+    }
+    return h;
+  }
+  _asStringString() {
+    const ret = /* @__PURE__ */ new Map();
+    for (const [key, values] of this._headers) {
+      ret.set(key, values.join(", "));
+    }
+    return ret;
+  }
+  _key(key) {
+    return key.toLowerCase();
+  }
+  Values(key) {
+    const values = this._headers.get(this._key(key));
+    return values || [];
+  }
+  Get(key) {
+    const values = this._headers.get(this._key(key));
+    if (values === void 0 || values.length === 0) {
+      return void 0;
+    }
+    return values[0];
+  }
+  Set(key, valueOr) {
+    const value = Array.isArray(valueOr) ? valueOr : [valueOr];
+    this._headers.set(this._key(key), value);
+    return this;
+  }
+  Add(key, value) {
+    if (typeof value === "undefined") {
+      return this;
+    }
+    const vs = Array.isArray(value) ? value : [value];
+    const values = this._headers.get(this._key(key));
+    if (values === void 0) {
+      this._headers.set(this._key(key), vs);
+    } else {
+      values.push(...vs);
+    }
+    return this;
+  }
+  Del(ey) {
+    this._headers.delete(this._key(ey));
+    return this;
+  }
+  Items() {
+    return Array.from(this._headers).filter(([_, vs]) => vs.length > 0);
+  }
+  SortItems() {
+    return this.Items().sort(([[a]], [[b]]) => a.localeCompare(b));
+  }
+  Clone() {
+    const clone = new _HttpHeader();
+    for (const [key, values] of this._headers.entries()) {
+      clone._headers.set(key, values.slice());
+    }
+    return clone;
+  }
+  AsRecordStringStringArray() {
+    const obj = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = [...values];
+    }
+    return obj;
+  }
+  AsRecordStringString() {
+    const obj = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values.join(", ");
+    }
+    return obj;
+  }
+  AsHeaderInit() {
+    const obj = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values[0];
+    }
+    return obj;
+  }
+  AsHeaders() {
+    return new HeadersImpl(this._asStringString());
+  }
+  Merge(other) {
+    const ret = this.Clone();
+    if (other) {
+      for (const [key, values] of other.Items()) {
+        ret.Add(key, values);
+      }
+    }
+    return ret;
+  }
+};
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -2783,6 +3101,8 @@ function uint8array2stream(str) {
   ConstTime,
   EnvImpl,
   Future,
+  HeadersImpl,
+  HttpHeader,
   IDMode,
   IdService,
   IsLogger,
@@ -2803,6 +3123,7 @@ function uint8array2stream(str) {
   MutableURL,
   None,
   Option,
+  REQUIRED,
   RandomMode,
   RandomService,
   ResolveOnce,