@adviser/cement 0.2.41 → 0.2.43

package/{chunk-USQXEZHL.js → chunk-3RHIVQAA.js}

@@ -1,7 +1,7 @@
 import {
   Utf8EnDecoderSingleton,
   __export
-} from "./chunk-GES3MUGV.js";
+} from "./chunk-PPS4L4VW.js";
 
 // src/utils/index.ts
 var utils_exports = {};
@@ -308,4 +308,4 @@ export {
   uint8array2stream,
   utils_exports
 };
-//# sourceMappingURL=chunk-USQXEZHL.js.map
+//# sourceMappingURL=chunk-3RHIVQAA.js.map

package/{chunk-W2GV5KXV.js → chunk-N3NUTN4B.js}

@@ -2,10 +2,10 @@ import {
   BaseSysAbstraction,
   WrapperSysAbstraction,
   envFactory
-} from "./chunk-F5W6VELE.js";
+} from "./chunk-N5LQQXOU.js";
 import {
   Utf8EnDecoderSingleton
-} from "./chunk-GES3MUGV.js";
+} from "./chunk-PPS4L4VW.js";
 
 // src/web/web-sys-abstraction.ts
 var WebFileService = class {
@@ -84,4 +84,4 @@ function WebSysAbstraction(param) {
 export {
   WebSysAbstraction
 };
-//# sourceMappingURL=chunk-W2GV5KXV.js.map
+//# sourceMappingURL=chunk-N3NUTN4B.js.map

package/{chunk-F5W6VELE.js → chunk-N5LQQXOU.js}

@@ -2,7 +2,7 @@ import {
   __privateAdd,
   __privateGet,
   __privateSet
-} from "./chunk-GES3MUGV.js";
+} from "./chunk-PPS4L4VW.js";
 
 // src/sys-abstraction.ts
 var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
@@ -607,4 +607,4 @@ export {
   envFactory,
   EnvImpl
 };
-//# sourceMappingURL=chunk-F5W6VELE.js.map
+//# sourceMappingURL=chunk-N5LQQXOU.js.map

package/chunk-PPS4L4VW.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+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);
+
+// src/txt-en-decoder.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Utf8EnDecoder = class {
+  encode(str) {
+    return encoder.encode(str);
+  }
+  decode(data) {
+    return decoder.decode(data);
+  }
+};
+var utf8EnDecoder = new Utf8EnDecoder();
+function Utf8EnDecoderSingleton() {
+  return utf8EnDecoder;
+}
+
+export {
+  __export,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  Utf8EnDecoder,
+  Utf8EnDecoderSingleton
+};
+//# sourceMappingURL=chunk-PPS4L4VW.js.map

package/{chunk-GES3MUGV.js.map → chunk-PPS4L4VW.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/txt-en-decoder.ts"],"sourcesContent":["export interface TxtEnDecoder {\n  encode(str: string): Uint8Array;\n  decode(data: Uint8Array): string;\n}\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nexport class Utf8EnDecoder implements TxtEnDecoder {\n  encode(str: string): Uint8Array {\n    return encoder.encode(str);\n  }\n  decode(data: Uint8Array): string {\n    return decoder.decode(data);\n  }\n}\n\nconst utf8EnDecoder = new Utf8EnDecoder();\nexport function Utf8EnDecoderSingleton(): TxtEnDecoder {\n  return utf8EnDecoder;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,UAAU,IAAI,YAAY;AAEzB,IAAM,gBAAN,MAA4C;AAAA,EACjD,OAAO,KAAyB;AAC9B,WAAO,QAAQ,OAAO,GAAG;AAAA,EAC3B;AAAA,EACA,OAAO,MAA0B;AAC/B,WAAO,QAAQ,OAAO,IAAI;AAAA,EAC5B;AACF;AAEA,IAAM,gBAAgB,IAAI,cAAc;AACjC,SAAS,yBAAuC;AACrD,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/txt-en-decoder.ts"],"sourcesContent":["export interface TxtEnDecoder {\n  encode(str: string): Uint8Array;\n  decode(data: Uint8Array): string;\n}\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nexport class Utf8EnDecoder implements TxtEnDecoder {\n  encode(str: string): Uint8Array {\n    return encoder.encode(str);\n  }\n  decode(data: Uint8Array): string {\n    return decoder.decode(data);\n  }\n}\n\nconst utf8EnDecoder = new Utf8EnDecoder();\nexport function Utf8EnDecoderSingleton(): TxtEnDecoder {\n  return utf8EnDecoder;\n}\n"],"mappings":";;;;;;;;;;;;;;AAKA,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,UAAU,IAAI,YAAY;AAEzB,IAAM,gBAAN,MAA4C;AAAA,EACjD,OAAO,KAAyB;AAC9B,WAAO,QAAQ,OAAO,GAAG;AAAA,EAC3B;AAAA,EACA,OAAO,MAA0B;AAC/B,WAAO,QAAQ,OAAO,IAAI;AAAA,EAC5B;AACF;AAEA,IAAM,gBAAgB,IAAI,cAAc;AACjC,SAAS,yBAAuC;AACrD,SAAO;AACT;","names":[]}

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,
@@ -226,15 +178,17 @@ function asyncLogValue(val) {
   throw new Error("Not implemented");
 }
 function logValue(val, ctx) {
-  return logValueInternal(val, __spreadProps(__spreadValues({}, ctx), {
+  return logValueInternal(val, {
+    ...ctx,
     state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
-  }));
+  });
 }
 function logValueInternal(val, ctx) {
   var _a, _b;
-  ctx = __spreadProps(__spreadValues({}, ctx), {
+  ctx = {
+    ...ctx,
     state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
-  });
+  };
   switch (typeof val) {
     case "function":
       return new LogValue(val);
@@ -272,7 +226,7 @@ function logValueInternal(val, ctx) {
       }
       if (Array.isArray(val)) {
         return new LogValue(
-          () => val.map((v) => logValue(v, __spreadProps(__spreadValues({}, ctx), { state: void 0 })).value())
+          () => val.map((v) => logValue(v, { ...ctx, state: void 0 }).value())
         );
       }
       if (val instanceof Headers) {
@@ -1095,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];
@@ -1114,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)) {
@@ -1375,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);
     }
@@ -1560,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);
   }
@@ -1943,9 +2043,9 @@ 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;
     } else {
@@ -2153,9 +2253,10 @@ var LoggerImpl = class _LoggerImpl {
         sys: this._sys,
         levelHandler: this.levelHandler,
         formatter: this._formatter,
-        withAttributes: __spreadValues({
-          module: this._attributes["module"]
-        }, this._withAttributes)
+        withAttributes: {
+          module: this._attributes["module"],
+          ...this._withAttributes
+        }
       })
     );
   }
@@ -2179,7 +2280,7 @@ var LoggerImpl = class _LoggerImpl {
       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);
@@ -2207,7 +2308,7 @@ var WithLoggerBuilder = class {
     return this._li;
   }
   Attributes() {
-    return __spreadValues({}, this._li._attributes);
+    return { ...this._li._attributes };
   }
   SetExposeStack(enable) {
     this._li.levelHandler.setExposeStack(enable);
@@ -2413,7 +2514,7 @@ var LogCollector = class {
       new Uint8Array(
         function* (res) {
           for (const x of res) {
-            yield* __yieldStar(x);
+            yield* x;
           }
         }(this._bufferArr)
       )
@@ -2532,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;
     }
@@ -2557,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);
@@ -2631,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];
+          (Array.isArray(v) ? v : [v]).forEach((v2) => {
+            h.Add(k, v2);
+          });
+        }
+      }
+    }
+    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, {
@@ -2837,6 +3101,8 @@ function uint8array2stream(str) {
   ConstTime,
   EnvImpl,
   Future,
+  HeadersImpl,
+  HttpHeader,
   IDMode,
   IdService,
   IsLogger,