@adviser/cement 0.0.0-jsr-t1

package/index.js

@@ -0,0 +1,1533 @@
+import {
+  ConsoleWriterStream,
+  FanoutWriteStream,
+  utils_exports
+} from "./chunk-7KFVMTOS.js";
+import {
+  WebSysAbstraction
+} from "./chunk-WMMUXBDX.js";
+import {
+  BaseSysAbstraction,
+  BrowserEnvActions,
+  ConstTime,
+  EnvImpl,
+  Future,
+  IDMode,
+  IdService,
+  Keyed,
+  KeyedResolvOnce,
+  KeyedResolvSeq,
+  RandomMode,
+  RandomService,
+  ResolveOnce,
+  ResolveSeq,
+  StepTime,
+  String2TimeMode,
+  SysTime,
+  Time,
+  TimeFactory,
+  TimeMode,
+  TimeUnits,
+  WrapperSysAbstraction,
+  envFactory
+} from "./chunk-Q65HLCNL.js";
+import {
+  Utf8EnDecoder,
+  Utf8EnDecoderSingleton,
+  __spreadProps,
+  __spreadValues,
+  __yieldStar
+} from "./chunk-GES3MUGV.js";
+
+// src/logger-impl.ts
+import YAML from "yaml";
+
+// src/bin2text.ts
+function bin2text(hex, lineFn, size = 0) {
+  const arr = new Uint8Array(hex.buffer, hex.byteOffset, hex.byteLength);
+  let cutted = "  ";
+  if (size == 0) {
+    size = arr.length;
+  }
+  size = Math.min(size, arr.length);
+  const cols = 16;
+  for (let line = 0; line < size; line += cols) {
+    if (line + cols <= size || arr.length == size) {
+    } else {
+      line = arr.length - arr.length % cols;
+      size = arr.length;
+      cutted = ">>";
+    }
+    const l = [line.toString(16).padStart(4, "0"), cutted];
+    for (let col = 0; col < cols; col++) {
+      if (line + col < size) {
+        l.push(arr[line + col].toString(16).padStart(2, "0"));
+      } else {
+        l.push("  ");
+      }
+      l.push(" ");
+    }
+    for (let col = 0; col < cols; col++) {
+      if (line + col < size) {
+        const ch = arr[line + col];
+        l.push(ch >= 32 && ch < 127 ? String.fromCharCode(ch) : ".");
+      }
+    }
+    lineFn(l.join(""));
+  }
+}
+function bin2string(hex, size = 0) {
+  const collector = [];
+  bin2text(
+    hex,
+    (line) => {
+      collector.push(line);
+    },
+    size
+  );
+  return collector.join("\n");
+}
+
+// src/logger.ts
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2["WARN"] = "warn";
+  Level2["DEBUG"] = "debug";
+  Level2["INFO"] = "info";
+  Level2["ERROR"] = "error";
+  return Level2;
+})(Level || {});
+var LogValue = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  value() {
+    return this.fn();
+  }
+  toJSON() {
+    return this.value();
+  }
+};
+function removeSelfRef(lineEnd) {
+  const cache = /* @__PURE__ */ new Set();
+  return function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      if (cache.has(value)) return "...";
+      cache.add(value);
+    }
+    return lineEnd ? value + lineEnd : value;
+  };
+}
+function asyncLogValue(val) {
+  throw new Error("Not implemented");
+}
+function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
+  switch (typeof val) {
+    case "function":
+      return new LogValue(val);
+    case "string": {
+      try {
+        const ret = JSON.parse(val);
+        if (typeof ret === "object" && ret !== null) {
+          return logValue(ret, state);
+        }
+      } catch (e) {
+        if (val.match(/[\n\r]/)) {
+          const lines = val.trimEnd().split(/[\n\r]/);
+          return new LogValue(() => lines);
+        }
+      }
+      return new LogValue(() => val.toString());
+    }
+    case "number":
+      return new LogValue(() => val);
+    case "boolean":
+      return new LogValue(() => val);
+    case "object": {
+      if (ArrayBuffer.isView(val)) {
+        return logValue(bin2string(val, 512));
+      }
+      if (Array.isArray(val)) {
+        return new LogValue(() => val.map((v) => logValue(v).value()));
+      }
+      if (val === null) {
+        return new LogValue(() => "null");
+      }
+      if (state.has(val)) {
+        return new LogValue(() => "...");
+      }
+      state.add(val);
+      const res = {};
+      const typedVal = val;
+      for (const key in typedVal) {
+        const element = typedVal[key];
+        if (element instanceof LogValue) {
+          res[key] = element;
+        } else {
+          res[key] = logValue(element, state);
+        }
+      }
+      return new LogValue(() => res);
+    }
+    default:
+      if (!val) {
+        return new LogValue(() => "--Falsy--");
+      }
+      throw new Error(`Invalid type:${typeof val}`);
+  }
+}
+function IsLogger(obj) {
+  return typeof obj === "object" && [
+    "Module",
+    "EnableLevel",
+    "DisableLevel",
+    "SetDebug",
+    "Str",
+    "Error",
+    "Warn",
+    "Debug",
+    "Log",
+    "WithLevel",
+    "Err",
+    "Info",
+    "Timestamp",
+    "Any",
+    "Dur",
+    "Uint64"
+  ].map((fn) => typeof obj[fn] === "function").reduce((a, b) => a && b, true);
+}
+
+// src/result.ts
+var Result = class _Result {
+  static Ok(t) {
+    return new ResultOK(t);
+  }
+  static Err(t) {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t));
+    }
+    return new ResultError(t);
+  }
+  static Is(t) {
+    if (!t) {
+      return false;
+    }
+    if (t instanceof _Result) {
+      return true;
+    }
+    const rt = t;
+    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
+      return true;
+    }
+    return false;
+  }
+  isOk() {
+    return this.is_ok();
+  }
+  isErr() {
+    return this.is_err();
+  }
+  Ok() {
+    return this.unwrap();
+  }
+  Err() {
+    return this.unwrap_err();
+  }
+};
+var ResultOK = class extends Result {
+  constructor(t) {
+    super();
+    this._t = t;
+  }
+  is_ok() {
+    return true;
+  }
+  is_err() {
+    return false;
+  }
+  unwrap_err() {
+    throw new Error("Result is Ok");
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var ResultError = class extends Result {
+  constructor(t) {
+    super();
+    this._error = t;
+  }
+  is_ok() {
+    return false;
+  }
+  is_err() {
+    return true;
+  }
+  unwrap() {
+    throw new Error(`Result is Err: ${this._error}`);
+  }
+  unwrap_err() {
+    return this._error;
+  }
+};
+function exception2Result(fn) {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
+    }
+    return Result.Ok(res);
+  } catch (e) {
+    return Result.Err(e);
+  }
+}
+
+// src/uri.ts
+function falsy2undef(value) {
+  return value === void 0 || value === null ? void 0 : value;
+}
+function ensureURLWithDefaultProto(url, defaultProtocol) {
+  if (!url) {
+    return new MutableURL(`${defaultProtocol}//`);
+  }
+  if (typeof url === "string") {
+    try {
+      return new MutableURL(url);
+    } catch (e) {
+      return new MutableURL(`${defaultProtocol}//${url}`);
+    }
+  } else {
+    return new MutableURL(url.toString());
+  }
+}
+function isURL(value) {
+  return value instanceof URL || !!value && typeof value.searchParams === "object" && typeof value.searchParams.sort === "function" && typeof value.hash === "string";
+}
+var MutableURL = class _MutableURL extends URL {
+  constructor(urlStr) {
+    super("defect://does.not.exist");
+    const partedURL = urlStr.split(":");
+    this._hasHostpart = protocols.has(partedURL[0]);
+    let hostPartUrl = ["http", ...partedURL.slice(1)].join(":");
+    if (!this._hasHostpart) {
+      const pathname = hostPartUrl.replace(/http:\/\/[/]*/, "").replace(/[#?].*$/, "");
+      hostPartUrl = hostPartUrl.replace(/http:\/\//, `http://localhost/${pathname}`);
+    }
+    try {
+      this._sysURL = new URL(hostPartUrl);
+    } catch (ie) {
+      const e = ie;
+      e.message = `${e.message} for URL: ${urlStr}`;
+      throw e;
+    }
+    this._protocol = `${partedURL[0]}:`;
+    if (this._hasHostpart) {
+      this._pathname = this._sysURL.pathname;
+    } else {
+      this._pathname = urlStr.replace(new RegExp(`^${this._protocol}//`), "").replace(/[#?].*$/, "");
+    }
+    this.hash = this._sysURL.hash;
+  }
+  clone() {
+    return new _MutableURL(this.toString());
+  }
+  get host() {
+    if (!this._hasHostpart) {
+      throw new Error(
+        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(protocols.keys()))}`
+      );
+    }
+    return this._sysURL.host;
+  }
+  get port() {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    return this._sysURL.port;
+  }
+  set port(p) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    this._sysURL.port = p;
+  }
+  get hostname() {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    return this._sysURL.hostname;
+  }
+  set hostname(h) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    this._sysURL.hostname = h;
+  }
+  set pathname(p) {
+    this._pathname = p;
+  }
+  get pathname() {
+    return this._pathname;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  set protocol(p) {
+    if (!p.endsWith(":")) {
+      p = `${p}:`;
+    }
+    this._protocol = p;
+  }
+  get searchParams() {
+    return this._sysURL.searchParams;
+  }
+  toString() {
+    let search = "";
+    if (this._sysURL.searchParams.size) {
+      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 = "";
+    if (this._hasHostpart) {
+      hostpart = this._sysURL.hostname;
+      if (this._sysURL.port) {
+        hostpart += `:${this._sysURL.port}`;
+      }
+      if (!this._pathname.startsWith("/")) {
+        hostpart += "/";
+      }
+    }
+    return `${this._protocol}//${hostpart}${this._pathname}${search}`;
+  }
+};
+function from(fac, strURLUri, defaultProtocol) {
+  switch (typeof falsy2undef(strURLUri)) {
+    case "undefined":
+      return fac(new MutableURL(`${defaultProtocol}///`));
+    case "string":
+      return fac(ensureURLWithDefaultProto(strURLUri, defaultProtocol));
+    case "object":
+      if (BuildURI.is(strURLUri)) {
+        return fac(new MutableURL(strURLUri._url.toString()));
+      } else if (URI.is(strURLUri)) {
+        return fac(new MutableURL(strURLUri._url.toString()));
+      } else if (isURL(strURLUri)) {
+        return fac(new MutableURL(strURLUri.toString()));
+      }
+      throw new Error(`unknown object type: ${strURLUri}`);
+    default:
+      throw new Error(`Invalid argument: ${typeof strURLUri}`);
+  }
+}
+var BuildURI = class _BuildURI {
+  // pathname needs this
+  constructor(url) {
+    this._url = url;
+  }
+  static is(value) {
+    return value instanceof _BuildURI || !!value && typeof value.delParam === "function" && typeof value.setParam === "function";
+  }
+  static from(strURLUri, defaultProtocol = "file:") {
+    return from((url) => new _BuildURI(url), strURLUri, defaultProtocol);
+  }
+  port(p) {
+    this._url.port = p;
+    return this;
+  }
+  hostname(h) {
+    this._url.hostname = h;
+    return this;
+  }
+  // password(p: string) {
+  //   this._url.password = p;
+  //   return this;
+  // }
+  // port(p: string) {
+  //   this._url.port = p;
+  //   return this;
+  // }
+  // username(u: string) {
+  //   this._url.username = u;
+  //   return this;
+  // }
+  // search(s: string) {
+  //   this._url.search = s;
+  //   return this;
+  // }
+  protocol(p) {
+    this._url.protocol = p;
+    return this;
+  }
+  pathname(p) {
+    this._url.pathname = p;
+    return this;
+  }
+  // hash(h: string) {
+  //   this._url.hash = h;
+  //   return this;
+  // }
+  // host(h: string) {
+  //   this._url.host = h;
+  //   return this;
+  // }
+  delParam(key) {
+    this._url.searchParams.delete(key);
+    return this;
+  }
+  defParam(key, str) {
+    if (!this._url.searchParams.has(key)) {
+      this._url.searchParams.set(key, str);
+    }
+    return this;
+  }
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
+    return this;
+  }
+  hasParam(key) {
+    return this._url.searchParams.has(key);
+  }
+  getParam(key) {
+    return falsy2undef(this._url.searchParams.get(key));
+  }
+  toString() {
+    this._url.searchParams.sort();
+    return this._url.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+  URI() {
+    return URI.from(this._url);
+  }
+};
+var protocols = /* @__PURE__ */ new Set(["http", "https", "ws", "wss"]);
+var URI = class _URI {
+  static protocolHasHostpart(protocol) {
+    protocol = protocol.replace(/:$/, "");
+    protocols.add(protocol);
+    return () => {
+      protocols.delete(protocol);
+    };
+  }
+  // if no protocol is provided, default to file:
+  static merge(into, from2, defaultProtocol = "file:") {
+    const intoUrl = BuildURI.from(into, defaultProtocol);
+    const fromUrl = _URI.from(from2, defaultProtocol);
+    intoUrl.protocol(fromUrl.protocol);
+    const fPath = fromUrl.pathname;
+    if (!(fPath.length === 0 || fPath === "/" || fPath === "./")) {
+      intoUrl.pathname(fromUrl.pathname);
+    }
+    for (const [key, value] of fromUrl.getParams) {
+      intoUrl.setParam(key, value);
+    }
+    return intoUrl.URI();
+  }
+  static is(value) {
+    return value instanceof _URI || !!value && typeof value.asURL === "function" && typeof value.getParam === "function" && typeof value.hasParam === "function";
+  }
+  // if no protocol is provided, default to file:
+  static from(strURLUri, defaultProtocol = "file:") {
+    return from((url) => new _URI(url), strURLUri, defaultProtocol);
+  }
+  static fromResult(strURLUri, defaultProtocol = "file:") {
+    return exception2Result(() => from((url) => new _URI(url), strURLUri, defaultProtocol));
+  }
+  constructor(url) {
+    this._url = url.clone();
+  }
+  build() {
+    return BuildURI.from(this._url);
+  }
+  get hostname() {
+    return this._url.hostname;
+  }
+  // get password(): string {
+  //   return this._url.password;
+  // }
+  get port() {
+    return this._url.port;
+  }
+  get host() {
+    return this._url.host;
+  }
+  // get username(): string {
+  //   return this._url.username;
+  // }
+  // get search(): string {
+  //   return this._url.search;
+  // }
+  get protocol() {
+    return this._url.protocol;
+  }
+  get pathname() {
+    return this._url.pathname;
+  }
+  // get hash(): string {
+  //   return this._url.hash;
+  // }
+  // get host(): string {
+  //   return this._url.host;
+  // }
+  get getParams() {
+    return this._url.searchParams.entries();
+  }
+  hasParam(key) {
+    return this._url.searchParams.has(key);
+  }
+  getParam(key) {
+    return falsy2undef(this._url.searchParams.get(key));
+  }
+  clone() {
+    return new _URI(this._url);
+  }
+  asURL() {
+    return this._url.clone();
+  }
+  toString() {
+    return this._url.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+};
+
+// src/runtime.ts
+function isSet(value, ref = globalThis) {
+  const [head, ...tail] = value.split(".");
+  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
+    if (tail.length <= 1) {
+      return true;
+    }
+    return isSet(tail.join("."), ref[head]);
+  }
+  return false;
+}
+function runtimeFn() {
+  const gt = globalThis;
+  const isReactNative = isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
+  let isNodeIsh = false;
+  if (!isSet("Deno")) {
+    isNodeIsh = isSet("process.versions.node") && !isReactNative;
+  }
+  const isDeno = isSet("Deno");
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
+    isDeno,
+    isReactNative
+  };
+}
+
+// src/log-writer-impl.ts
+var LogWriterStream = class {
+  constructor(out) {
+    this._toFlush = [];
+    this._flushIsRunning = false;
+    this._flushDoneFns = [];
+    this._out = out;
+  }
+  write(encoded) {
+    const my = async () => {
+      try {
+        const writer = this._out.getWriter();
+        await writer.ready;
+        await writer.write(encoded);
+        await writer.releaseLock();
+      } catch (err) {
+        console.error("Chunk error:", err);
+      }
+    };
+    this._toFlush.push(my);
+    this._flush();
+  }
+  _flush(toFlush = void 0, done) {
+    if (done) {
+      this._flushDoneFns.push(done);
+    }
+    if (this._toFlush.length == 0) {
+      this._flushIsRunning = false;
+      this._flushDoneFns.forEach((fn) => fn());
+      this._flushDoneFns = [];
+      return;
+    }
+    if (!toFlush && this._toFlush.length == 1 && !this._flushIsRunning) {
+      this._flushIsRunning = true;
+    } else if (!toFlush) {
+      return;
+    }
+    const my = this._toFlush.shift();
+    my == null ? void 0 : my().finally(() => {
+      this._flush(this._toFlush);
+    });
+  }
+};
+
+// 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.isStackExposed = false;
+  }
+  enableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.add(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, level]));
+      },
+      ...modules
+    );
+  }
+  disableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.delete(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.delete(p);
+      },
+      ...modules
+    );
+  }
+  setExposeStack(enable) {
+    this.isStackExposed = !!enable;
+  }
+  forModules(level, fnAction, ...modules) {
+    for (const m of modules.flat()) {
+      if (typeof m !== "string") {
+        continue;
+      }
+      const parts = m.split(",").map((s) => s.trim()).filter((s) => s.length);
+      for (const p of parts) {
+        fnAction(p);
+      }
+    }
+  }
+  setDebug(...modules) {
+    this.forModules(
+      "debug" /* DEBUG */,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, "debug" /* DEBUG */]));
+      },
+      ...modules
+    );
+  }
+  isEnabled(ilevel, module) {
+    const level = ilevel;
+    if (typeof module === "string") {
+      const levels = this._modules.get(module);
+      if (levels && levels.has(level)) {
+        return true;
+      }
+    }
+    const wlevel = this._modules.get("*");
+    if (wlevel && typeof level === "string") {
+      if (wlevel.has(level)) {
+        return true;
+      }
+    }
+    if (typeof level !== "string") {
+      return true;
+    }
+    return this._globalLevels.has(level);
+  }
+};
+var levelSingleton = new LevelHandlerImpl();
+function LevelHandlerSingleton() {
+  return levelSingleton;
+}
+
+// src/logger-impl.ts
+function getLen(value) {
+  if (Array.isArray(value)) {
+    return logValue(() => value.length);
+  } else if (typeof value === "string") {
+    return logValue(() => value.length);
+  } else if (typeof value === "object" && value !== null) {
+    if (typeof value.size === "number") {
+      return logValue(() => value.size);
+    } else if (typeof value.length === "number") {
+      return logValue(() => value.length);
+    }
+    return logValue(() => Object.keys(value).length);
+  }
+  return logValue(() => -1);
+}
+function hash(value) {
+  return "not implemented";
+}
+function toLogValue(lop) {
+  if (lop && typeof lop.then === "function") {
+    throw new Error("async logValue Not implemented");
+  }
+  return lop;
+}
+var JSONFormatter = class {
+  constructor(txtEnde, space) {
+    this._txtEnDe = txtEnde;
+    this._space = space;
+  }
+  format(attr) {
+    return this._txtEnDe.encode(JSON.stringify(attr, removeSelfRef(), this._space) + "\n");
+  }
+};
+var YAMLFormatter = class {
+  constructor(txtEnde, space) {
+    this._txtEnDe = txtEnde;
+    this._space = space;
+  }
+  format(attr) {
+    return this._txtEnDe.encode("---\n" + YAML.stringify(attr, removeSelfRef(), this._space) + "\n");
+  }
+};
+var LoggerImpl = class _LoggerImpl {
+  // readonly _id: string = "logger-" + Math.random().toString(36)
+  constructor(params) {
+    this._attributes = {};
+    if (!params) {
+      params = {};
+    }
+    if (!params.sys) {
+      this._sys = WebSysAbstraction();
+    } else {
+      this._sys = params.sys;
+    }
+    if (!params.txtEnDe) {
+      this._txtEnDe = Utf8EnDecoderSingleton();
+    } else {
+      this._txtEnDe = params.txtEnDe;
+    }
+    if (!params.formatter) {
+      this._formatter = new JSONFormatter(this._txtEnDe);
+    } else {
+      this._formatter = params.formatter;
+    }
+    if (params.logWriter) {
+      this._logWriter = params.logWriter;
+    } else {
+      if (!params.out) {
+        const rt = runtimeFn();
+        let stream;
+        if (rt.isBrowser) {
+          stream = new ConsoleWriterStream();
+        } else {
+          if (rt.isNodeIsh || rt.isReactNative || rt.isDeno) {
+            stream = this._sys.Stdout();
+          } else {
+            throw new Error("No output defined for runtime");
+          }
+        }
+        this._logWriter = new LogWriterStream(stream);
+      } else {
+        this._logWriter = new LogWriterStream(params.out);
+      }
+    }
+    if (!params.withAttributes) {
+      this._withAttributes = {};
+    } else {
+      this._withAttributes = __spreadValues({}, params.withAttributes);
+    }
+    this._attributes = __spreadValues({}, this._withAttributes);
+    if (params.levelHandler) {
+      this._levelHandler = params.levelHandler;
+    } else {
+      this._levelHandler = LevelHandlerSingleton();
+    }
+  }
+  TxtEnDe() {
+    return this._txtEnDe;
+  }
+  Attributes() {
+    return JSON.parse(JSON.stringify(this._attributes, removeSelfRef()));
+  }
+  SetExposeStack(enable) {
+    this._levelHandler.setExposeStack(enable);
+    return this;
+  }
+  EnableLevel(level, ...modules) {
+    this._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  DisableLevel(level, ...modules) {
+    this._levelHandler.disableLevel(level, ...modules);
+    return this;
+  }
+  Module(key) {
+    this._attributes["module"] = logValue(key);
+    this._withAttributes["module"] = logValue(key);
+    return this;
+  }
+  // if the string is "*" it will enable for all modules
+  SetDebug(...modules) {
+    this._levelHandler.setDebug(...modules);
+    return this;
+  }
+  SetFormatter(formatter) {
+    this._formatter = formatter;
+    return this;
+  }
+  Timestamp() {
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
+    return this;
+  }
+  Warn() {
+    this._attributes["level"] = logValue("warn" /* WARN */);
+    return this;
+  }
+  Log() {
+    return this;
+  }
+  Debug() {
+    this._attributes["level"] = logValue("debug" /* DEBUG */);
+    return this;
+  }
+  Error() {
+    this._attributes["level"] = logValue("error" /* ERROR */);
+    return this;
+  }
+  Info() {
+    this._attributes["level"] = logValue("info" /* INFO */);
+    return this;
+  }
+  Err(err) {
+    var _a;
+    if (Result.Is(err)) {
+      if (err.isOk()) {
+        this.Result("noerror", err);
+      } else {
+        this.Result("error", 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()));
+      }
+    } else {
+      this._attributes["error"] = logValue("" + err);
+    }
+    return this;
+  }
+  WithLevel(l) {
+    this._attributes["level"] = logValue(l);
+    return this;
+  }
+  Ref(key, action) {
+    if (typeof action === "function") {
+      this._attributes[key] = logValue(action);
+    } else if (typeof action.toString === "function") {
+      this._attributes[key] = logValue(() => action.toString());
+    } else {
+      this._attributes[key] = logValue("INVALID REF");
+    }
+    return this;
+  }
+  Bool(key, value) {
+    this._attributes[key] = logValue(!!value);
+    return this;
+  }
+  Result(key, res) {
+    if (res.isOk()) {
+      this._attributes[key] = logValue(res.Ok());
+    } else {
+      this.Err(res.Err());
+    }
+    return this;
+  }
+  Len(value, key = "len") {
+    this._attributes[key] = getLen(value);
+    return this;
+  }
+  Hash(value, key = "hash") {
+    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
+    return this;
+  }
+  Url(url, key = "url") {
+    this.Ref(key, () => URI.from(url).toString());
+    return this;
+  }
+  Str(key, value) {
+    this._attributes[key] = logValue(value);
+    return this;
+  }
+  Any(key, value) {
+    this._attributes[key] = logValue(value);
+    return this;
+  }
+  Dur(key, nsec) {
+    this._attributes[key] = logValue(`${nsec}ms`);
+    return this;
+  }
+  Uint64(key, value) {
+    this._attributes[key] = logValue(value);
+    return this;
+  }
+  Int(key, value) {
+    return this.Uint64(key, value);
+  }
+  async Flush() {
+    return new Promise((resolve) => {
+      this._logWriter._flush(void 0, resolve);
+    });
+  }
+  With() {
+    return new WithLoggerBuilder(
+      new _LoggerImpl({
+        logWriter: this._logWriter,
+        sys: this._sys,
+        levelHandler: this._levelHandler,
+        formatter: this._formatter,
+        withAttributes: __spreadValues({
+          module: this._attributes["module"]
+        }, this._withAttributes)
+      })
+    );
+  }
+  _resetAttributes(fn) {
+    const ret = fn();
+    Object.keys(this._attributes).forEach((key) => {
+      delete this._attributes[key];
+    });
+    Object.assign(this._attributes, this._withAttributes);
+    return ret;
+  }
+  Msg(...args) {
+    const fnError = this._resetAttributes(() => {
+      var _a, _b;
+      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(" "));
+      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));
+      if (doWrite) {
+        const encoded = fnRet();
+        this._logWriter.write(encoded);
+        fnRet = () => encoded;
+      }
+      return fnRet;
+    });
+    return {
+      AsError: () => new Error(this._txtEnDe.decode(fnError()))
+    };
+  }
+};
+var WithLoggerBuilder = class {
+  constructor(li) {
+    this._li = li;
+  }
+  TxtEnDe() {
+    return this._li.TxtEnDe();
+  }
+  Logger() {
+    Object.assign(this._li._withAttributes, this._li._attributes);
+    return this._li;
+  }
+  Attributes() {
+    return __spreadValues({}, this._li._attributes);
+  }
+  SetExposeStack(enable) {
+    this._li._levelHandler.setExposeStack(enable);
+    return this;
+  }
+  SetFormatter(fmt) {
+    this._li.SetFormatter(fmt);
+    return this;
+  }
+  EnableLevel(level, ...modules) {
+    this._li._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  DisableLevel(level, ...modules) {
+    this._li._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  Module(key) {
+    this._li.Module(key);
+    return this;
+  }
+  SetDebug(...modules) {
+    this._li.SetDebug(...modules);
+    return this;
+  }
+  Str(key, value) {
+    this._li.Str(key, value);
+    return this;
+  }
+  Len(value, key) {
+    this._li.Len(value, key);
+    return this;
+  }
+  Hash(value, key) {
+    this._li.Hash(value, key);
+    return this;
+  }
+  Ref(key, action) {
+    this._li.Ref(key, action);
+    return this;
+  }
+  Bool(key, value) {
+    this._li.Bool(key, value);
+    return this;
+  }
+  Result(key, res) {
+    this._li.Result(key, res);
+    return this;
+  }
+  Url(url, key) {
+    this._li.Url(url, key);
+    return this;
+  }
+  Int(key, value) {
+    this._li.Int(key, value);
+    return this;
+  }
+  Log() {
+    this._li.Log();
+    return this;
+  }
+  WithLevel(level) {
+    this._li.WithLevel(level);
+    return this;
+  }
+  Error() {
+    this._li.Error();
+    return this;
+  }
+  Warn() {
+    this._li.Error();
+    return this;
+  }
+  Debug() {
+    this._li.Debug();
+    return this;
+  }
+  Err(err) {
+    this._li.Err(err);
+    return this;
+  }
+  Info() {
+    this._li.Info();
+    return this;
+  }
+  Timestamp() {
+    this._li.Timestamp();
+    return this;
+  }
+  Any(key, value) {
+    this._li.Any(key, value);
+    return this;
+  }
+  Dur(key, nsec) {
+    this._li.Dur(key, nsec);
+    return this;
+  }
+  Uint64(key, value) {
+    this._li.Uint64(key, value);
+    return this;
+  }
+};
+
+// src/test/log-write-stream.ts
+var LogWriteStream = class {
+  constructor(bufferArr) {
+    this._resolveClosed = new Future();
+    this.closed = this._resolveClosed.asPromise();
+    this.desiredSize = null;
+    this.ready = Promise.resolve(void 0);
+    this._bufferArr = bufferArr;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+    await this.closed;
+    return Promise.resolve(void 0);
+  }
+  releaseLock() {
+  }
+  async write(chunk) {
+    if (chunk) {
+      this._bufferArr.push(chunk);
+    }
+    return Promise.resolve(void 0);
+  }
+};
+var LogCollector = class {
+  constructor(pass, txtEnDe) {
+    this.locked = false;
+    this._bufferArr = [];
+    this._pass = pass;
+    this._txtEnDe = txtEnDe || Utf8EnDecoderSingleton();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+    if (this._writer) {
+      const ret = await this._writer.close();
+      this._writer = void 0;
+      return ret;
+    }
+    return Promise.resolve(void 0);
+  }
+  getWriter() {
+    if (!this._writer) {
+      const dests = [new LogWriteStream(this._bufferArr)];
+      if (this._pass) {
+        dests.push(this._pass);
+      }
+      this._writer = new FanoutWriteStream(dests);
+    }
+    return this._writer;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Logs(notJsonLine = false) {
+    if (!this._writer) {
+      return [];
+    }
+    const jsonNlStr = this._txtEnDe.decode(
+      new Uint8Array(
+        function* (res) {
+          for (const x of res) {
+            yield* __yieldStar(x);
+          }
+        }(this._bufferArr)
+      )
+    );
+    if (!notJsonLine) {
+      const splitStr = jsonNlStr.split("\n");
+      const filterStr = splitStr.filter((a) => a.length);
+      const mapStr = filterStr.map((a) => JSON.parse(a));
+      return mapStr;
+    }
+    return jsonNlStr.split("\n").filter((a) => a.length);
+  }
+};
+
+// src/test/mock-logger.ts
+function MockLogger(params) {
+  const lc = new LogCollector(params == null ? void 0 : params.pass);
+  let modNames = ["MockLogger"];
+  if (typeof (params == null ? void 0 : params.moduleName) === "string") {
+    modNames = [params == null ? void 0 : params.moduleName];
+  } else if (Array.isArray(params == null ? void 0 : params.moduleName)) {
+    modNames = [...params.moduleName, ...modNames];
+  }
+  const logger = new LoggerImpl({
+    out: lc,
+    sys: params == null ? void 0 : params.sys,
+    levelHandler: new LevelHandlerImpl()
+  }).With().Module(modNames[0]).Logger();
+  if (!(params == null ? void 0 : params.disableDebug)) {
+    logger.SetDebug(...modNames);
+  }
+  return {
+    logCollector: lc,
+    logger
+  };
+}
+
+// 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) {
+    this.path = path;
+  }
+  set(value) {
+    this.value = value;
+  }
+  add(value) {
+    if (typeof value === "number") {
+      if (this.value === void 0) {
+        this.value = 0;
+      }
+      this.value = this.value + value;
+    } else if (Array.isArray(value)) {
+      if (!Array.isArray(this.value)) {
+        this.value = [];
+      }
+      this.value.push(...value);
+    } else {
+      throw new Error("add only support number or array");
+    }
+  }
+};
+var Metrics = class {
+  constructor(tracenode) {
+    this.spanRefs = /* @__PURE__ */ new Map();
+    this.tracenode = tracenode;
+    this.map = tracenode.ctx.metrics;
+  }
+  toJSON() {
+    const obj = {};
+    for (const [key, value] of this.map) {
+      obj[key] = value.value;
+    }
+    return obj;
+  }
+  get(ipath) {
+    const path = ipath.replace(/[/]+/g, "/").trim();
+    if (path.startsWith("/")) {
+      if (path.slice(1).length === 0) {
+        throw new Error(`Metrics path must contain value /:${path}`);
+      }
+      let metric = this.map.get(path);
+      if (!metric) {
+        metric = new Metric(path);
+        this.map.set(path, metric);
+      }
+      this.spanRefs.set(path, metric);
+      return metric;
+    } else if (path.includes("/")) {
+      throw new Error(`Metrics path must start with /:${path}`);
+    }
+    const rootPath = this.tracenode.getRootPath();
+    return this.get(`${rootPath}/${path}`);
+  }
+};
+var TraceNode = class _TraceNode {
+  constructor(ctx) {
+    this.childs = /* @__PURE__ */ new Map();
+    this.invokations = [];
+    this.spanId = ctx.spanId;
+    this.ctx = ctx;
+    this.metrics = new Metrics(this);
+  }
+  static root(time, logger) {
+    return new _TraceNode({
+      spanId: "root",
+      time,
+      logger,
+      metrics: /* @__PURE__ */ new Map(),
+      parent: void 0
+    });
+  }
+  getRootPath(rpath = []) {
+    if (!this.ctx.parent) {
+      return "/" + rpath.reverse().join("/");
+    }
+    return this.ctx.parent.getRootPath(rpath.concat(this.ctx.spanId));
+  }
+  invokes() {
+    const cleanCtx = __spreadValues({}, 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({
+      ctx: cleanCtx,
+      invokations: this.invokations
+    }, metricsRefs);
+  }
+  ctxWith(spanId, logger) {
+    const ctx = __spreadProps(__spreadValues({}, this.ctx), {
+      spanId
+    });
+    if (logger) {
+      ctx.logger = logger;
+    }
+    return ctx;
+  }
+  // <V extends () => Promise<T> | T, T>(id: string, fn: V): ReturnType<V>
+  span(inSpanId, fn) {
+    let ctx;
+    if (typeof inSpanId === "string") {
+      ctx = __spreadProps(__spreadValues({}, this.ctx), {
+        spanId: inSpanId,
+        parent: this
+      });
+    } else {
+      ctx = __spreadProps(__spreadValues(__spreadValues({}, this.ctx), inSpanId), {
+        parent: this
+      });
+    }
+    if (ctx.logger) {
+      ctx = __spreadValues(__spreadValues({}, ctx), ctx.logger.Attributes());
+    }
+    const spanId = ctx.spanId;
+    let spanTrace = this.childs.get(spanId);
+    if (!spanTrace) {
+      spanTrace = new _TraceNode(ctx);
+      this.childs.set(spanId.toString(), spanTrace);
+    }
+    const invokation = {
+      start: this.ctx.time.Now().getTime(),
+      end: 0,
+      result: "success"
+    };
+    spanTrace.invokations.push(invokation);
+    try {
+      const possiblePromise = fn(spanTrace);
+      if (possiblePromise instanceof Promise) {
+        return possiblePromise.then((v) => {
+          return v;
+        }).catch((e) => {
+          invokation.result = "error";
+          throw e;
+        }).finally(() => {
+          invokation.end = this.ctx.time.Now().getTime();
+        });
+      }
+      invokation.end = this.ctx.time.Now().getTime();
+      return possiblePromise;
+    } catch (e) {
+      invokation.result = "error";
+      invokation.end = this.ctx.time.Now().getTime();
+      throw e;
+    }
+  }
+};
+
+// src/crypto.ts
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (size > 0) {
+    crypto.getRandomValues(bytes);
+  }
+  return bytes;
+}
+function digestSHA256(data) {
+  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
+}
+function toCryptoRuntime(cryptoOpts = {}) {
+  const runtime = {
+    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    exportKey: cryptoOpts.exportKey || crypto.subtle.exportKey.bind(crypto.subtle),
+    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
+    randomBytes: cryptoOpts.randomBytes || randomBytes,
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
+  };
+  return runtime;
+}
+
+// src/version.ts
+var VERSION = Object.keys({
+  __packageVersion__: "xxxx"
+})[0];
+export {
+  BaseSysAbstraction,
+  BrowserEnvActions,
+  BuildURI,
+  ConstTime,
+  EnvImpl,
+  Future,
+  IDMode,
+  IdService,
+  IsLogger,
+  JSONFormatter,
+  Keyed,
+  KeyedResolvOnce,
+  KeyedResolvSeq,
+  Level,
+  LevelHandlerImpl,
+  LevelHandlerSingleton,
+  LogCollector,
+  LogValue,
+  LogWriteStream,
+  LoggerImpl,
+  Metric,
+  Metrics,
+  MockLogger,
+  MutableURL,
+  None,
+  Option,
+  RandomMode,
+  RandomService,
+  ResolveOnce,
+  ResolveSeq,
+  Result,
+  ResultError,
+  ResultOK,
+  Some,
+  StepTime,
+  String2TimeMode,
+  SysTime,
+  Time,
+  TimeFactory,
+  TimeMode,
+  TimeUnits,
+  TraceNode,
+  URI,
+  Utf8EnDecoder,
+  Utf8EnDecoderSingleton,
+  VERSION,
+  WrapperSysAbstraction,
+  YAMLFormatter,
+  asyncLogValue,
+  bin2string,
+  bin2text,
+  envFactory,
+  exception2Result,
+  isURL,
+  logValue,
+  protocols,
+  removeSelfRef,
+  runtimeFn,
+  toCryptoRuntime,
+  utils_exports as utils
+};
+//# sourceMappingURL=index.js.map