@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

package/index.cjs

@@ -1,2593 +0,0 @@
-"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 });
-};
-var __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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);
-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 = {};
-__export(src_exports, {
-  BaseSysAbstraction: () => BaseSysAbstraction,
-  BrowserEnvActions: () => BrowserEnvActions,
-  BuildURI: () => BuildURI,
-  ConstTime: () => ConstTime,
-  EnvImpl: () => EnvImpl,
-  Future: () => Future,
-  IDMode: () => IDMode,
-  IdService: () => IdService,
-  IsLogger: () => IsLogger,
-  JSONFormatter: () => JSONFormatter,
-  Keyed: () => Keyed,
-  KeyedResolvOnce: () => KeyedResolvOnce,
-  KeyedResolvSeq: () => KeyedResolvSeq,
-  Level: () => Level,
-  LevelHandlerImpl: () => LevelHandlerImpl,
-  LevelHandlerSingleton: () => LevelHandlerSingleton,
-  LogCollector: () => LogCollector,
-  LogValue: () => LogValue,
-  LogWriteStream: () => LogWriteStream,
-  LoggerImpl: () => LoggerImpl,
-  Metric: () => Metric,
-  Metrics: () => Metrics,
-  MockLogger: () => MockLogger,
-  MutableURL: () => MutableURL,
-  None: () => None,
-  Option: () => Option,
-  RandomMode: () => RandomMode,
-  RandomService: () => RandomService,
-  ResolveOnce: () => ResolveOnce,
-  ResolveSeq: () => ResolveSeq,
-  Result: () => Result,
-  ResultError: () => ResultError,
-  ResultOK: () => ResultOK,
-  Some: () => Some,
-  StepTime: () => StepTime,
-  String2TimeMode: () => String2TimeMode,
-  SysTime: () => SysTime,
-  Time: () => Time,
-  TimeFactory: () => TimeFactory,
-  TimeMode: () => TimeMode,
-  TimeUnits: () => TimeUnits,
-  TraceNode: () => TraceNode,
-  URI: () => URI,
-  Utf8EnDecoder: () => Utf8EnDecoder,
-  Utf8EnDecoderSingleton: () => Utf8EnDecoderSingleton,
-  VERSION: () => VERSION,
-  WrapperSysAbstraction: () => WrapperSysAbstraction,
-  YAMLFormatter: () => YAMLFormatter,
-  asyncLogValue: () => asyncLogValue,
-  bin2string: () => bin2string,
-  bin2text: () => bin2text,
-  envFactory: () => envFactory,
-  exception2Result: () => exception2Result,
-  isURL: () => isURL,
-  logValue: () => logValue,
-  protocols: () => protocols,
-  removeSelfRef: () => removeSelfRef,
-  runtimeFn: () => runtimeFn,
-  toCryptoRuntime: () => toCryptoRuntime,
-  utils: () => utils_exports
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/logger-impl.ts
-var import_yaml = __toESM(require("yaml"), 1);
-
-// 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/sys-abstraction.ts
-var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
-  TimeMode2["REAL"] = "real";
-  TimeMode2["CONST"] = "const";
-  TimeMode2["STEP"] = "step";
-  return TimeMode2;
-})(TimeMode || {});
-var RandomMode = /* @__PURE__ */ ((RandomMode2) => {
-  RandomMode2["CONST"] = "const";
-  RandomMode2["STEP"] = "step";
-  RandomMode2["RANDOM"] = "random";
-  return RandomMode2;
-})(RandomMode || {});
-var IDMode = /* @__PURE__ */ ((IDMode2) => {
-  IDMode2["UUID"] = "uuid";
-  IDMode2["CONST"] = "const";
-  IDMode2["STEP"] = "step";
-  return IDMode2;
-})(IDMode || {});
-function String2TimeMode(s) {
-  switch (s == null ? void 0 : s.toLowerCase()) {
-    case "real":
-      return "real" /* REAL */;
-    case "const":
-      return "const" /* CONST */;
-    case "step":
-      return "step" /* STEP */;
-    default:
-      return "real" /* REAL */;
-  }
-}
-
-// src/time.ts
-var Time = class {
-  TimeSince(start) {
-    const now = this.Now();
-    return now.getTime() - start.getTime();
-  }
-};
-var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
-  TimeUnits2[TimeUnits2["Microsecond"] = 1] = "Microsecond";
-  TimeUnits2[TimeUnits2["Second"] = 1e3] = "Second";
-  TimeUnits2[TimeUnits2["Minute"] = 6e4] = "Minute";
-  TimeUnits2[TimeUnits2["Hour"] = 36e5] = "Hour";
-  return TimeUnits2;
-})(TimeUnits || {});
-
-// src/base-sys-abstraction.ts
-var SysTime = class extends Time {
-  Now() {
-    return /* @__PURE__ */ new Date();
-  }
-  Sleep(duration) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve();
-      }, duration);
-    });
-  }
-};
-var ConstTime = class extends Time {
-  Now() {
-    return new Date(2021, 1, 1, 0, 0, 0, 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Sleep(duration) {
-    return Promise.resolve();
-  }
-};
-var StepTime = class extends Time {
-  constructor() {
-    super();
-    this._step = new ConstTime().Now();
-    this._start = this._step;
-  }
-  Now(steps = 1) {
-    for (let i = 0; steps > 0 && i < steps; i++) {
-      this._step = new Date(this._step.getTime() + 1e3);
-    }
-    if (steps < 1) {
-      this._step = new Date(this._start.getTime() + steps * -1e3);
-    }
-    return this._step;
-  }
-  Sleep(duration) {
-    this._step = new Date(this._step.getTime() + duration);
-    return Promise.resolve();
-  }
-};
-function TimeFactory(timeMode) {
-  switch (timeMode) {
-    case "real" /* REAL */:
-      return new SysTime();
-    case "const" /* CONST */:
-      return new ConstTime();
-    case "step" /* STEP */:
-      return new StepTime();
-  }
-  return new SysTime();
-}
-var RandomService = class {
-  constructor(mode) {
-    this._step = 0;
-    this._mode = mode;
-  }
-  Random0ToValue(value) {
-    switch (this._mode) {
-      case "const" /* CONST */:
-        return 0.5 * value;
-      case "step" /* STEP */:
-        this._step += 1e-4;
-        return this._step * value;
-      case "random" /* RANDOM */:
-        return Math.random() * value;
-      default:
-        throw new Error("Unknown RandomMode");
-    }
-  }
-};
-var IdService = class {
-  constructor(mode) {
-    this._step = 0;
-    if (!mode) {
-      mode = "uuid" /* UUID */;
-    }
-    this._mode = mode;
-  }
-  NextId() {
-    switch (this._mode) {
-      case "uuid" /* UUID */:
-        return crypto.randomUUID();
-      case "const" /* CONST */:
-        return "VeryUniqueID";
-      case "step" /* STEP */:
-        return `STEPId-${this._step++}`;
-      default:
-        throw new Error("Unknown IDMode");
-    }
-  }
-};
-var BaseSysAbstraction = class {
-  constructor(params) {
-    this._time = new SysTime();
-    this._idService = new IdService();
-    this._randomService = new RandomService("random" /* RANDOM */);
-    this._fileSystem = params.FileSystem;
-    this._systemService = params.SystemService;
-    this._txtEnDe = params.TxtEnDecoder;
-    const decoder2 = this._txtEnDe;
-    this._stdout = new WritableStream({
-      write(chunk) {
-        return new Promise((resolve) => {
-          const decoded = decoder2.decode(chunk);
-          console.log(decoded.trimEnd());
-          resolve();
-        });
-      }
-    });
-    this._stderr = new WritableStream({
-      write(chunk) {
-        return new Promise((resolve) => {
-          const decoded = decoder2.decode(chunk);
-          console.error(decoded.trimEnd());
-          resolve();
-        });
-      }
-    });
-  }
-};
-var WrapperSysAbstraction = class {
-  constructor(base, params) {
-    this._time = base._time;
-    this._stdout = base._stdout;
-    this._stderr = base._stderr;
-    this._idService = base._idService;
-    this._randomService = base._randomService;
-    this._fileSystem = base._fileSystem;
-    this._systemService = base._systemService;
-    if (params) {
-      if (params.TimeMode) {
-        this._time = TimeFactory(params.TimeMode);
-      }
-      if (params.Stdout) {
-        this._stdout = params.Stdout;
-      }
-      if (params.Stderr) {
-        this._stderr = params.Stderr;
-      }
-      if (params.IdMode) {
-        this._idService = new IdService(params.IdMode);
-      }
-      if (params.RandomMode) {
-        this._randomService = new RandomService(params.RandomMode);
-      }
-      if (params.FileSystem) {
-        this._fileSystem = params.FileSystem;
-      }
-      if (params.SystemService) {
-        this._systemService = params.SystemService;
-      }
-    }
-  }
-  Time() {
-    return this._time;
-  }
-  NextId() {
-    return this._idService.NextId();
-  }
-  Random0ToValue(value) {
-    return this._randomService.Random0ToValue(value);
-  }
-  Stdout() {
-    return this._stdout;
-  }
-  Stderr() {
-    return this._stderr;
-  }
-  System() {
-    return this._systemService;
-  }
-  FileSystem() {
-    return this._fileSystem;
-  }
-};
-
-// src/future.ts
-var _promise, _resolveFn, _rejectFn;
-var Future = class {
-  constructor() {
-    __privateAdd(this, _promise);
-    __privateAdd(this, _resolveFn, () => {
-      throw new Error("This Promise is not working as expected.");
-    });
-    __privateAdd(this, _rejectFn, () => {
-      throw new Error("This Promise is not working as expected.");
-    });
-    __privateSet(this, _promise, new Promise((resolve, reject) => {
-      __privateSet(this, _resolveFn, resolve);
-      __privateSet(this, _rejectFn, reject);
-    }));
-  }
-  async asPromise() {
-    return __privateGet(this, _promise);
-  }
-  resolve(value) {
-    __privateGet(this, _resolveFn).call(this, value);
-  }
-  reject(reason) {
-    __privateGet(this, _rejectFn).call(this, reason);
-  }
-};
-_promise = new WeakMap();
-_resolveFn = new WeakMap();
-_rejectFn = new WeakMap();
-
-// src/resolve-once.ts
-var ResolveSeq = class {
-  constructor(ctx) {
-    this._seqFutures = [];
-    this.ctx = ctx;
-  }
-  reset() {
-  }
-  async _step(item) {
-    if (!item) {
-      return;
-    }
-    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
-      this._seqFutures.shift();
-      this._step(this._seqFutures[0]);
-    });
-  }
-  async add(fn, id) {
-    const future = new Future();
-    this._seqFutures.push({ future, fn, id });
-    if (this._seqFutures.length === 1) {
-      this._step(this._seqFutures[0]);
-    }
-    return future.asPromise();
-  }
-};
-var ResolveOnce = class {
-  constructor(ctx) {
-    this._onceDone = false;
-    this._onceFutures = [];
-    this._onceOk = false;
-    this._isPromise = false;
-    this.ctx = ctx;
-  }
-  get ready() {
-    return this._onceDone;
-  }
-  reset() {
-    this._onceDone = false;
-    this._onceOk = false;
-    this._onceValue = void 0;
-    this._onceError = void 0;
-    this._onceFutures.length = 0;
-  }
-  // T extends Option<infer U> ? U : T
-  once(fn) {
-    if (this._onceDone) {
-      if (this._onceError) {
-        if (this._isPromise) {
-          return Promise.reject(this._onceError);
-        } else {
-          throw this._onceError;
-        }
-      }
-      if (this._onceOk) {
-        if (this._isPromise) {
-          return Promise.resolve(this._onceValue);
-        } else {
-          return this._onceValue;
-        }
-      }
-      throw new Error("ResolveOnce.once impossible");
-    }
-    const future = new Future();
-    this._onceFutures.push(future);
-    if (this._onceFutures.length === 1) {
-      const okFn = (value) => {
-        this._onceValue = value;
-        this._onceOk = true;
-        this._onceDone = true;
-        if (this._isPromise) {
-          this._onceFutures.forEach((f) => f.resolve(this._onceValue));
-        }
-        this._onceFutures.length = 0;
-      };
-      const catchFn = (e) => {
-        this._onceError = e;
-        this._onceOk = false;
-        this._onceValue = void 0;
-        this._onceDone = true;
-        if (this._isPromise) {
-          this._onceFutures.forEach((f) => f.reject(this._onceError));
-        }
-        this._onceFutures.length = 0;
-      };
-      try {
-        const ret = fn(this.ctx);
-        if (typeof ret.then === "function") {
-          this._isPromise = true;
-          ret.then(okFn).catch(catchFn);
-        } else {
-          okFn(ret);
-        }
-      } catch (e) {
-        catchFn(e);
-      }
-    }
-    if (this._isPromise) {
-      return future.asPromise();
-    } else {
-      return this.once(fn);
-    }
-  }
-};
-var Keyed = class {
-  constructor(factory) {
-    this._map = /* @__PURE__ */ new Map();
-    this.factory = factory;
-  }
-  async asyncGet(key) {
-    return this.get(await key());
-  }
-  get(key) {
-    if (typeof key === "function") {
-      key = key();
-    }
-    let keyed = this._map.get(key);
-    if (!keyed) {
-      keyed = this.factory(key);
-      this._map.set(key, keyed);
-    }
-    return keyed;
-  }
-  unget(key) {
-    const keyed = this._map.get(key);
-    keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key);
-  }
-  reset() {
-    this._map.forEach((keyed) => keyed.reset());
-    this._map.clear();
-  }
-};
-var KeyedResolvOnce = class extends Keyed {
-  constructor() {
-    super((key) => new ResolveOnce(key));
-  }
-};
-var KeyedResolvSeq = class extends Keyed {
-  constructor() {
-    super((key) => new ResolveSeq(key));
-  }
-};
-
-// src/sys-env.ts
-var _node;
-var NodeEnvActions = class {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
-  constructor(opts) {
-    __privateAdd(this, _node, globalThis);
-    this._env = this.active() ? __privateGet(this, _node).process.env : {};
-  }
-  register(env) {
-    return env;
-  }
-  active() {
-    return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
-  }
-  keys() {
-    return Object.keys(this._env);
-  }
-  get(key) {
-    return this._env[key];
-  }
-  set(key, value) {
-    if (value) {
-      this._env[key] = value;
-    }
-  }
-  delete(key) {
-    delete this._env[key];
-  }
-};
-_node = new WeakMap();
-var _deno;
-var DenoEnvActions = class {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
-  constructor(opts) {
-    __privateAdd(this, _deno, globalThis);
-  }
-  get _env() {
-    return __privateGet(this, _deno).Deno.env;
-  }
-  register(env) {
-    return env;
-  }
-  active() {
-    return typeof __privateGet(this, _deno) === "object" && typeof __privateGet(this, _deno).Deno === "object" && typeof __privateGet(this, _deno).Deno.env === "object";
-  }
-  keys() {
-    return Array.from(this._env.keys());
-  }
-  get(key) {
-    return this._env.get(key);
-  }
-  set(key, value) {
-    if (value) {
-      this._env.set(key, value);
-    }
-  }
-  delete(key) {
-    this._env.delete(key);
-  }
-};
-_deno = new WeakMap();
-var BrowserEnvActions = class {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
-  }
-  get(key) {
-    return this.env.get(key);
-  }
-  set(key, value) {
-    if (value) {
-      this.env.set(key, value);
-    }
-  }
-  delete(key) {
-    this.env.delete(key);
-  }
-  keys() {
-    return Array.from(this.env.keys());
-  }
-  active() {
-    return true;
-  }
-  register(env) {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis;
-    browser[sym] = env;
-    return env;
-  }
-};
-var _envFactory = new ResolveOnce();
-function envFactory(opts = {}) {
-  return _envFactory.once(() => {
-    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.active());
-    if (!found) {
-      throw new Error("SysContainer:envFactory: no env available");
-    }
-    const ret = new EnvImpl(found, opts);
-    found.register(ret);
-    return ret;
-  });
-}
-var EnvImpl = class {
-  constructor(map, opts = {}) {
-    this._onSet = [];
-    this._map = map;
-    this._updatePresets(opts.presetEnv);
-  }
-  _updatePresets(presetEnv) {
-    if (!presetEnv) {
-      return;
-    }
-    for (const [key, value] of presetEnv) {
-      this._map.set(key, value);
-    }
-  }
-  _applyOnSet(onSet, key, value) {
-    onSet.forEach((item) => {
-      let keys = [];
-      if (key) {
-        keys = [key];
-      } else {
-        keys = this._map.keys();
-      }
-      keys.filter((k) => {
-        if (item.filter.size === 0) {
-          return true;
-        }
-        if (item.filter.has(k)) {
-          return true;
-        }
-        return false;
-      }).forEach((k) => {
-        let v;
-        if (!key && !value) {
-          v = this._map.get(k);
-        } else if (key && !value) {
-          v = void 0;
-        } else {
-          v = value;
-        }
-        item.fn(k, v);
-      });
-    });
-  }
-  keys() {
-    return this._map.keys();
-  }
-  // filter is not set all sets passed
-  onSet(fn, ...filter) {
-    const item = { filter: new Set(filter), fn };
-    this._onSet.push(item);
-    this._applyOnSet([item]);
-  }
-  get(key) {
-    return this._map.get(key);
-  }
-  set(key, value) {
-    if (!value) {
-      return;
-    }
-    this._map.set(key, value);
-    this._applyOnSet(this._onSet, key, value);
-  }
-  delete(key) {
-    this._map.delete(key);
-    this._applyOnSet(this._onSet, key);
-  }
-};
-
-// 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;
-}
-
-// src/web/web-sys-abstraction.ts
-var WebFileService = class {
-  get baseDir() {
-    throw new Error("basedir-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  create(fname) {
-    throw new Error("create-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  readFileString(fname) {
-    throw new Error("readFileString-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  writeFileString(fname, content) {
-    throw new Error("writeFileString-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  abs(fname) {
-    throw new Error("abs-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  join(...paths) {
-    throw new Error("join-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  relative(from2, to) {
-    throw new Error("relative-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  dirname(fname) {
-    throw new Error("dirname-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  basename(fname) {
-    throw new Error("basename-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  nodeImport(fname) {
-    throw new Error("nodeImport-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  isAbsolute(fname) {
-    throw new Error("isAbsolute-Method not implemented.");
-  }
-};
-var WebSystemService = class {
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    throw new Error("Args-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  OnExit(hdl) {
-    throw new Error("OnExit-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Exit(code) {
-    throw new Error("Exit-Method not implemented.");
-  }
-};
-var my = void 0;
-function WebSysAbstraction(param) {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
-      FileSystem: new WebFileService(),
-      SystemService: new WebSystemService()
-    });
-  }
-  return new WrapperSysAbstraction(my, param);
-}
-
-// 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/utils/console-write-stream.ts
-var ConsoleWriterStreamDefaultWriter = class {
-  constructor(stream) {
-    this.stream = stream;
-    this.desiredSize = null;
-    this.decoder = new TextDecoder();
-    this._stream = stream;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  async close() {
-  }
-  releaseLock() {
-    this._stream.locked = false;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  async write(chunk) {
-    const str = this.decoder.decode(chunk).trimEnd();
-    let output = "log";
-    try {
-      const decode = JSON.parse(str);
-      output = decode.level;
-    } catch (e) {
-    }
-    switch (output) {
-      case "error":
-        console.error(str);
-        break;
-      case "warn":
-        console.warn(str);
-        break;
-      default:
-        console.log(str);
-    }
-  }
-};
-var ConsoleWriterStream = class {
-  constructor() {
-    this.locked = false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  async close() {
-    return;
-  }
-  getWriter() {
-    if (this.locked) {
-      throw new Error("Stream is locked");
-    }
-    this.locked = true;
-    if (!this._writer) {
-      this._writer = new ConsoleWriterStreamDefaultWriter(this);
-    }
-    return this._writer;
-  }
-};
-
-// src/log-writer-impl.ts
-var LogWriterStream = class {
-  constructor(out) {
-    this._toFlush = [];
-    this._flushIsRunning = false;
-    this._flushDoneFns = [];
-    this._out = out;
-  }
-  write(encoded) {
-    const my2 = 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(my2);
-    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 my2 = this._toFlush.shift();
-    my2 == null ? void 0 : my2().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, module2) {
-    const level = ilevel;
-    if (typeof module2 === "string") {
-      const levels = this._modules.get(module2);
-      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" + import_yaml.default.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/utils/fanout-write-stream.ts
-var FanoutWriteStream = class {
-  constructor(writers) {
-    this.desiredSize = null;
-    this._writers = writers;
-    this.ready = Promise.all(this._writers.map((w) => w.ready)).then(() => void 0);
-    this.closed = Promise.all(this._writers.map((w) => w.closed)).then(() => void 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  abort(reason) {
-    return Promise.all(this._writers.map((w) => w.abort(reason))).then(() => {
-    });
-  }
-  close() {
-    return Promise.all(this._writers.map((w) => w.close())).then(() => {
-    });
-  }
-  releaseLock() {
-    this._writers.map((w) => w.releaseLock());
-  }
-  write(chunk) {
-    return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
-    });
-  }
-};
-
-// 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];
-
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  ConsoleWriterStream: () => ConsoleWriterStream,
-  ConsoleWriterStreamDefaultWriter: () => ConsoleWriterStreamDefaultWriter,
-  FanoutWriteStream: () => FanoutWriteStream,
-  array2stream: () => array2stream,
-  devnull: () => devnull,
-  rebuffer: () => rebuffer,
-  rebufferArray: () => rebufferArray,
-  stream2array: () => stream2array,
-  stream2string: () => stream2string,
-  stream2uint8array: () => stream2uint8array,
-  streamMap: () => streamMap,
-  string2stream: () => string2stream,
-  uint8array2stream: () => uint8array2stream
-});
-
-// src/utils/stream-map.ts
-function streamMap(s, sm) {
-  const state = { reader: s.getReader(), streamMap: sm, idx: 0 };
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await state.reader.read();
-      if (done) {
-        if (state.streamMap.Close) {
-          state.streamMap.Close();
-        }
-        controller.close();
-        return;
-      }
-      const promiseOrU = state.streamMap.Map(value, state.idx++);
-      let mapped;
-      if (promiseOrU instanceof Promise || typeof promiseOrU.then === "function") {
-        mapped = await promiseOrU;
-      } else {
-        mapped = promiseOrU;
-      }
-      controller.enqueue(mapped);
-    }
-  });
-}
-async function devnull(a) {
-  const reader = a.getReader();
-  let cnt = 0;
-  while (true) {
-    const { done } = await reader.read();
-    if (done) {
-      break;
-    }
-    cnt++;
-  }
-  return cnt;
-}
-function array2stream(a) {
-  let i = 0;
-  return new ReadableStream({
-    pull(controller) {
-      if (i >= a.length) {
-        controller.close();
-        return;
-      }
-      controller.enqueue(a[i]);
-      i++;
-    }
-  });
-}
-async function stream2array(a) {
-  const ret = [];
-  const reader = a.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    ret.push(value);
-  }
-  return ret;
-}
-
-// src/utils/rebuffer.ts
-async function rebufferArray(a, chunkSize) {
-  return stream2array(rebuffer(array2stream(a), chunkSize));
-}
-function reChunk(cs, chunkSize) {
-  const len = cs.reduce((acc, v) => acc + v.length, 0);
-  const last = cs[cs.length - 1];
-  const lastOfs = len - last.length;
-  const rest = last.subarray(chunkSize - lastOfs);
-  cs[cs.length - 1] = last.subarray(0, chunkSize - lastOfs);
-  const chunk = new Uint8Array(chunkSize);
-  let ofs = 0;
-  for (const c of cs) {
-    chunk.set(c, ofs);
-    ofs += c.length;
-  }
-  return { rest, chunk };
-}
-function pump(ps, controller, next) {
-  ps.reader.read().then(({ done, value }) => {
-    if (done) {
-      if (ps.tmpLen > 0) {
-        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
-      }
-      controller.close();
-      next();
-      return;
-    }
-    if (ps.tmpLen + value.length > ps.chunkSize) {
-      ps.tmp.push(value);
-      const res = reChunk(ps.tmp, ps.chunkSize);
-      controller.enqueue(res.chunk);
-      ps.tmp = [res.rest];
-      ps.tmpLen = res.rest.length;
-      next();
-      return;
-    } else if (value.length) {
-      ps.tmp.push(value);
-      ps.tmpLen += value.length;
-    }
-    pump(ps, controller, next);
-  });
-}
-function rebuffer(a, chunkSize) {
-  const state = {
-    reader: a.getReader(),
-    tmp: [],
-    tmpLen: 0,
-    chunkSize
-  };
-  return new ReadableStream({
-    async pull(controller) {
-      return new Promise((resolve) => {
-        pump(state, controller, resolve);
-      });
-    }
-  });
-}
-
-// src/utils/stream2string.ts
-async function stream2string(stream, maxSize) {
-  if (!stream) {
-    return Promise.resolve("");
-  }
-  const reader = stream.getReader();
-  let res = "";
-  const decoder2 = new TextDecoder();
-  let rSize = 0;
-  while (typeof maxSize === "undefined" || rSize < maxSize) {
-    try {
-      const read = await reader.read();
-      if (read.done) {
-        break;
-      }
-      if (maxSize && rSize + read.value.length > maxSize) {
-        read.value = read.value.slice(0, maxSize - rSize);
-      }
-      const block = decoder2.decode(read.value, { stream: true });
-      rSize += read.value.length;
-      res += block;
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-  return Promise.resolve(res);
-}
-async function stream2uint8array(stream) {
-  if (!stream) {
-    return Promise.resolve(new Uint8Array());
-  }
-  const reader = stream.getReader();
-  let res = new Uint8Array();
-  while (1) {
-    try {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      res = new Uint8Array([...res, ...value]);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-  return Promise.resolve(res);
-}
-
-// src/utils/string2stream.ts
-function string2stream(str, ende = Utf8EnDecoderSingleton()) {
-  return uint8array2stream(ende.encode(str));
-}
-function uint8array2stream(str) {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(str);
-      controller.close();
-    }
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  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
-});
-//# sourceMappingURL=index.cjs.map