@adviser/cement 0.3.20 → 0.4.1

package/index.cjs

@@ -38,7 +38,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BaseBasicSysAbstraction: () => BaseBasicSysAbstraction,
   BaseSysAbstraction: () => BaseSysAbstraction,
+  BasicSysAbstractionFactory: () => BasicSysAbstractionFactory,
   BuildURI: () => BuildURI,
   ConstTime: () => ConstTime,
   EnvImpl: () => EnvImpl,
@@ -87,7 +89,8 @@ __export(index_exports, {
   TxtEnDecoderSingleton: () => TxtEnDecoderSingleton,
   URI: () => URI,
   VERSION: () => VERSION,
-  WrapperSysAbstraction: () => WrapperSysAbstraction,
+  WrapperBasicSysAbstraction: () => WrapperBasicSysAbstraction,
+  WrapperRuntimeSysAbstraction: () => WrapperRuntimeSysAbstraction,
   YAMLFormatter: () => YAMLFormatter,
   asyncLogValue: () => asyncLogValue,
   bin2string: () => bin2string,
@@ -103,6 +106,10 @@ __export(index_exports, {
   registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
+  to_arraybuf: () => to_arraybuf,
+  to_blob: () => to_blob,
+  to_uint8: () => to_uint8,
+  top_uint8: () => top_uint8,
   utils: () => utils_exports
 });
 module.exports = __toCommonJS(index_exports);
@@ -299,1964 +306,2195 @@ function IsLogger(obj) {
   ].map((fn) => typeof obj[fn] === "function").reduce((a, b) => a && b, true);
 }
 
-// src/sys-abstraction.ts
-var TimeMode = {
-  REAL: "real",
-  CONST: "const",
-  STEP: "step"
-};
-var RandomMode = {
-  CONST: "const",
-  STEP: "step",
-  RANDOM: "random"
-};
-var IDMode = {
-  UUID: "uuid",
-  CONST: "const",
-  STEP: "step"
-};
-function String2TimeMode(s) {
-  switch (s == null ? void 0 : s.toLowerCase()) {
-    case "real":
-      return TimeMode.REAL;
-    case "const":
-      return TimeMode.CONST;
-    case "step":
-      return TimeMode.STEP;
-    default:
-      return TimeMode.REAL;
+// src/result.ts
+var Result = class _Result {
+  static Ok(t) {
+    return new ResultOK(t);
   }
-}
-
-// src/time.ts
-var Time = class {
-  TimeSince(start) {
-    const now = this.Now();
-    return now.getTime() - start.getTime();
+  static Err(t) {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t));
+    }
+    if (_Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok"));
+      }
+      return t;
+    }
+    return new ResultError(t);
   }
-};
-var TimeUnits = {
-  Microsecond: 1,
-  Second: 1e3 * 1,
-  //Microsecond,
-  Minute: 60 * 1e3 * 1,
-  //Second,
-  Hour: 60 * 60 * 1e3 * 1
-  // Minute,
-};
-
-// src/base-sys-abstraction.ts
-var SysTime = class extends Time {
-  Now() {
-    return /* @__PURE__ */ new Date();
+  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;
   }
-  Sleep(duration) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve();
-      }, duration);
-    });
+  isOk() {
+    return this.is_ok();
   }
-};
-var ConstTime = class extends Time {
-  Now() {
-    return new Date(2021, 1, 1, 0, 0, 0, 0);
+  isErr() {
+    return this.is_err();
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Sleep(duration) {
-    return Promise.resolve();
+  Ok() {
+    return this.unwrap();
+  }
+  Err() {
+    return this.unwrap_err();
   }
 };
-var StepTime = class extends Time {
-  constructor() {
+var ResultOK = class extends Result {
+  constructor(t) {
     super();
-    this._step = new ConstTime().Now();
-    this._start = this._step;
+    this._t = t;
   }
-  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;
+  is_ok() {
+    return true;
   }
-  Sleep(duration) {
-    this._step = new Date(this._step.getTime() + duration);
-    return Promise.resolve();
+  is_err() {
+    return false;
+  }
+  unwrap_err() {
+    throw new Error("Result is Ok");
+  }
+  unwrap() {
+    return this._t;
   }
 };
-function TimeFactory(timeMode) {
-  switch (timeMode) {
-    case TimeMode.REAL:
-      return new SysTime();
-    case TimeMode.CONST:
-      return new ConstTime();
-    case TimeMode.STEP:
-      return new StepTime();
+var ResultError = class extends Result {
+  constructor(t) {
+    super();
+    this._error = t;
   }
-  return new SysTime();
-}
-var RandomService = class {
-  constructor(mode) {
-    this._step = 0;
-    this._mode = mode;
+  is_ok() {
+    return false;
   }
-  Random0ToValue(value) {
-    switch (this._mode) {
-      case RandomMode.CONST:
-        return 0.5 * value;
-      case RandomMode.STEP:
-        this._step += 1e-4;
-        return this._step * value;
-      case RandomMode.RANDOM:
-        return Math.random() * value;
-      default:
-        throw new Error("Unknown RandomMode");
-    }
+  is_err() {
+    return true;
   }
-};
-var IdService = class {
-  constructor(mode) {
-    this._step = 0;
-    if (!mode) {
-      mode = IDMode.UUID;
-    }
-    this._mode = mode;
+  unwrap() {
+    throw new Error(`Result is Err: ${this._error}`);
   }
-  NextId() {
-    switch (this._mode) {
-      case IDMode.UUID:
-        return crypto.randomUUID();
-      case IDMode.CONST:
-        return "VeryUniqueID";
-      case IDMode.STEP:
-        return `STEPId-${this._step++}`;
-      default:
-        throw new Error("Unknown IDMode");
-    }
+  unwrap_err() {
+    return this._error;
   }
 };
-function consumeReadableStream(reader, writeFn) {
-  reader.read().then(({ done, value }) => {
-    if (done) {
-      return;
+function exception2Result(fn) {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
     }
-    writeFn(value).then(() => {
-      consumeReadableStream(reader, writeFn);
-    }).catch((e) => {
-      console.error("consumeReadableStream:writeFn", e);
-    });
-  }).catch((e) => {
-    console.error("consumeReadableStream:read", e);
-  });
-}
-function CFWriteableStream(writeFn) {
-  const ts = new TransformStream();
-  consumeReadableStream(ts.readable.getReader(), writeFn);
-  return ts.writable;
+    return Result.Ok(res);
+  } catch (e) {
+    return Result.Err(e);
+  }
 }
-var BaseSysAbstraction = class {
-  constructor(params) {
-    this._time = new SysTime();
-    this._idService = new IdService();
-    this._randomService = new RandomService(RandomMode.RANDOM);
-    this._fileSystem = params.FileSystem;
-    this._systemService = params.SystemService;
-    this._txtEnDe = params.TxtEnDecoder;
-    const decoder = this._txtEnDe;
-    this._stdout = CFWriteableStream((chunk) => {
-      const decoded = decoder.decode(chunk);
-      console.log(decoded.trimEnd());
-      return Promise.resolve();
-    });
-    this._stderr = CFWriteableStream((chunk) => {
-      const decoded = decoder.decode(chunk);
-      console.error(decoded.trimEnd());
-      return Promise.resolve();
-    });
+
+// src/types.ts
+var _Required = class {
+  constructor() {
+    this.type = "REQUIRED";
   }
 };
-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;
+var _Optional = class {
+  constructor() {
+    this.type = "OPTIONAL";
   }
 };
-
-// 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);
-  }
+var param = {
+  REQUIRED: new _Required(),
+  OPTIONAL: new _Optional()
 };
-_promise = new WeakMap();
-_resolveFn = new WeakMap();
-_rejectFn = new WeakMap();
 
-// src/lru-map-set.ts
-var LRUSet = class {
-  constructor(param2 = {}) {
-    this._lruMap = new LRUMap(param2);
-  }
-  setParam(param2 = {}) {
-    this._lruMap.setParam(param2);
-  }
-  get size() {
-    return this._lruMap.size;
-  }
-  has(key) {
-    return this._lruMap.has(key);
-  }
-  add(key) {
-    this._lruMap.set(key, key);
-  }
-  delete(key) {
-    this._lruMap.delete(key);
-  }
-  clear() {
-    this._lruMap.clear();
-  }
-  forEach(callbackfn) {
-    this._lruMap.forEach((value) => callbackfn(value, value));
+// src/utils/get-params-result.ts
+function getParamsResult(keys, getParam) {
+  const keyDef = keys.flat().reduce(
+    (acc, i) => {
+      if (typeof i === "string") {
+        acc.push({ key: i, def: void 0, isOptional: false });
+      } else if (typeof i === "object") {
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : void 0,
+            isOptional: i[k] === param.OPTIONAL
+          }))
+        );
+      }
+      return acc;
+    },
+    []
+  );
+  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
+    const msg = keys2.join(",");
+    return `missing parameters: ${msg}`;
+  });
+  const errors = [];
+  const result = {};
+  for (const kd of keyDef) {
+    const val = getParam.getParam(kd.key);
+    if (val === void 0) {
+      if (typeof kd.def === "string") {
+        result[kd.key] = kd.def;
+      } else {
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
+      }
+    } else {
+      result[kd.key] = val;
+    }
   }
-  entries() {
-    return this._lruMap.entries();
+  if (errors.length) {
+    return Result.Err(msgFn(...errors));
   }
+  return Result.Ok(result);
+}
+
+// src/utils/relative-path.ts
+var PartType = {
+  Slash: 1,
+  Root: 3,
+  Up: 4,
+  Noop: 8
+  // RootUp = 0x8 /* ../ */,
 };
-var LRUMap = class {
-  constructor(c = {}) {
-    this._map = /* @__PURE__ */ new Map();
-    this.param = {
-      maxEntries: c.maxEntries || 100,
-      maxAge: c.maxAge || 0
-    };
-  }
-  touch(key) {
-    if (!this._map.has(key)) {
-      throw new Error(`key not found in cache: ${key}`);
-    }
-    const value = this._map.get(key);
-    this._map.delete(key);
-    this._map.set(key, value);
-    return value;
+var Path = class {
+  constructor(parts = []) {
+    this.parts = parts;
   }
-  setParam(param2 = {}) {
-    if (typeof param2.maxEntries === "number") {
-      this.param.maxEntries = param2.maxEntries;
-      if (param2.maxEntries > 0 && this._map.size > param2.maxEntries) {
-        const toDelete = [];
-        let cacheSize = this._map.size;
-        for (const key of this._map.keys()) {
-          if (cacheSize > param2.maxEntries) {
-            toDelete.push(key);
-            cacheSize--;
-          } else {
-            break;
-          }
-        }
-        for (const key of toDelete) {
-          this._map.delete(key);
+  toString() {
+    return this.parts.map((part) => {
+      if (typeof part === "string") {
+        return part;
+      } else {
+        switch (part) {
+          case PartType.Slash:
+          case PartType.Root:
+            return "/";
+          case PartType.Up:
+            return "..";
+          default:
+            return part;
         }
       }
-    }
+    }).join("");
   }
-  has(key) {
-    return this._map.has(key);
+  add(part) {
+    if (this.parts.includes(PartType.Root) && part === PartType.Root) {
+      throw new Error("Cannot add absolute part to absolute path");
+    }
+    const last = this.parts[this.parts.length - 1];
+    if (last & PartType.Slash && part === PartType.Slash) {
+      return;
+    }
+    switch (part) {
+      case ".":
+        this.parts.push(PartType.Noop);
+        return;
+      case "..":
+        part = PartType.Up;
+    }
+    if (last === PartType.Noop && part === PartType.Slash) {
+      if (last === PartType.Noop) {
+        this.parts.pop();
+      }
+      return;
+    }
+    this.parts.push(part);
   }
-  get size() {
-    return this._map.size;
+};
+function splitPath(path) {
+  const p = new Path();
+  if (path === "") {
+    return p;
   }
-  async getSet(key, createFN) {
-    const val = this.get(key);
-    if (val) {
-      return val;
+  for (let count = 0; path.length; count++) {
+    if (path.match(/^\/+/)) {
+      if (count === 0) {
+        p.add(PartType.Root);
+      } else {
+        p.add(PartType.Slash);
+      }
+      path = path.replace(/^\/+/, "");
     } else {
-      const val2 = await createFN(key);
-      this.set(key, val2);
-      return val2;
+      const part = path.replace(/\/.*$/, "");
+      p.add(part);
+      path = path.replace(/^[^/]+/, "");
     }
   }
-  get(key) {
-    if (this._map.has(key)) {
-      return this.touch(key);
+  return p;
+}
+function pathJoin(...paths) {
+  let prev = "";
+  const res = [];
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path === "") {
+      continue;
     }
-    return this._map.get(key);
-  }
-  set(key, value) {
-    this._map.delete(key);
-    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
-      this._map.delete(this._map.keys().next().value);
-      this._map.set(key, value);
+    if (!(prev.endsWith("/") || path.startsWith("/"))) {
+      if (prev !== "") {
+        res.push("/");
+      }
+      res.push(path);
     } else {
-      this._map.set(key, value);
+      res.push(path);
     }
+    prev = path;
   }
-  delete(key) {
-    this._map.delete(key);
-  }
-  clear() {
-    this._map.clear();
+  return res.join("");
+}
+function relativePath(path, relative) {
+  const relativeParts = splitPath(relative);
+  let result;
+  if (relativeParts.parts[0] === PartType.Root) {
+    result = relative;
+  } else {
+    result = pathJoin(path, relative);
   }
-  forEach(callbackfn) {
-    this._map.forEach(callbackfn);
-  }
-  entries() {
-    return this._map.entries();
+  const unoptPath = splitPath(result);
+  const out = [];
+  let topUp = false;
+  for (const part of unoptPath.parts) {
+    switch (part) {
+      case PartType.Root:
+        out.push(PartType.Root);
+        break;
+      case PartType.Up:
+        if (out.length && !topUp) {
+          const last = out.length - 1;
+          if (typeof out[last] === "string" && out[last - 1] == PartType.Root) {
+            out.pop();
+          } else {
+            out.pop();
+            out.pop();
+          }
+          if (out.length === 0) {
+            topUp = !topUp ? true : topUp;
+            out.push(PartType.Up);
+          }
+        } else {
+          out.push(PartType.Up);
+        }
+        break;
+      case PartType.Slash:
+        if (!(out[out.length - 1] & PartType.Slash)) {
+          out.push(PartType.Slash);
+        }
+        break;
+      default:
+        out.push(part);
+        break;
+    }
   }
-  // *entries(): IterableIterator<[T, K]> {
-  //   for (const x of this._cache.entries()) {
-  //     yield x;
-  //   }
-  // }
-  //   getLeastRecent(): K {
-  //     return Array.from(this.cache)[0];
-  //   }
-  //   getMostRecent(): K {
-  //     return Array.from(this.cache)[this.cache.size - 1];
-  //   }
-};
+  return new Path(out).toString();
+}
 
-// src/result.ts
-var Result = class _Result {
-  static Ok(t) {
-    return new ResultOK(t);
+// src/utils/stripper.ts
+function stripper(strip, obj) {
+  const strips = Array.isArray(strip) ? strip : [strip];
+  const restrips = strips.map((s) => {
+    if (typeof s === "string") {
+      const escaped = s.replace(/[-\\[\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\^\\$\\|]/g, "\\$&");
+      return new RegExp(`^${escaped}$`);
+    }
+    return s;
+  });
+  return localStripper(void 0, restrips, obj);
+}
+function localStripper(path, restrips, obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
   }
-  static Err(t) {
-    if (typeof t === "string") {
-      return new ResultError(new Error(t));
+  if (Array.isArray(obj)) {
+    return obj.map((i) => localStripper(path, restrips, i));
+  }
+  const ret = { ...obj };
+  const matcher = (key, nextPath) => {
+    for (const re of restrips) {
+      if (re.test(key) || re.test(nextPath)) {
+        return true;
+      }
     }
-    if (_Result.Is(t)) {
-      if (t.is_ok()) {
-        return new ResultError(new Error("Result Error is Ok"));
+    return false;
+  };
+  for (const key in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key)) {
+      let nextPath;
+      if (path) {
+        nextPath = [path, key].join(".");
+      } else {
+        nextPath = key;
+      }
+      if (matcher(key, nextPath)) {
+        delete ret[key];
+        continue;
+      }
+      if (typeof ret[key] === "object") {
+        if (Array.isArray(ret[key])) {
+          ret[key] = ret[key].reduce((acc, v, i) => {
+            const toDelete = matcher(key, `${nextPath}[${i}]`);
+            if (!toDelete) {
+              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
+            }
+            return acc;
+          }, []);
+        } else {
+          ret[key] = localStripper(nextPath, restrips, ret[key]);
+        }
       }
-      return t;
     }
-    return new ResultError(t);
   }
-  static Is(t) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
+  return ret;
+}
+
+// src/uri.ts
+function match(iref, ioth) {
+  const mr = {
+    score: 0,
+    protocol: false,
+    hostname: false,
+    port: false,
+    pathname: false,
+    pathParts: [],
+    params: {}
+  };
+  const ref = URI.from(iref);
+  const oth = URI.from(ioth);
+  if (ref.protocol === oth.protocol) {
+    mr.score += 1;
+    mr.protocol = true;
+  }
+  try {
+    const refH = ref.hostname;
+    const refP = ref.port;
+    if (refH === oth.hostname) {
+      mr.score += 1;
+      mr.hostname = 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;
+    if (refP.length && refP === oth.port) {
+      mr.score += 1;
+      mr.port = true;
     }
-    return false;
+  } catch (e) {
   }
-  isOk() {
-    return this.is_ok();
+  if (ref.pathname.length && ref.pathname !== "/") {
+    const pref = ref.pathname.split("/").filter((p) => p.length);
+    const poth = oth.pathname.split("/").filter((p) => p.length);
+    for (let i = 0; i < pref.length && i < poth.length; i++) {
+      if (poth[i] === pref[i]) {
+        mr.score += 1;
+        mr.pathname = true;
+        mr.pathParts.push(pref[i]);
+      }
+    }
   }
-  isErr() {
-    return this.is_err();
+  for (const [key, value] of ref.getParams) {
+    if (oth.getParam(key) === value) {
+      mr.score += 1;
+      mr.params[key] = value;
+    }
   }
-  Ok() {
-    return this.unwrap();
+  return mr;
+}
+function coerceKey(key, def) {
+  if (typeof key === "object") {
+    const keys = Object.keys(key);
+    if (keys.length !== 1) {
+      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
+    }
+    return { key: keys[0], def: key[keys[0]] };
   }
-  Err() {
-    return this.unwrap_err();
+  return { key, def };
+}
+function falsy2undef(value) {
+  return value === void 0 || value === null ? void 0 : value;
+}
+function ensureURLWithDefaultProto(url, defaultProtocol) {
+  if (!url) {
+    return new MutableURL(`${defaultProtocol}//`);
   }
-};
-var ResultOK = class extends Result {
-  constructor(t) {
-    super();
-    this._t = t;
+  if (typeof url === "string") {
+    try {
+      return new MutableURL(url);
+    } catch (e) {
+      return new MutableURL(`${defaultProtocol}//${url}`);
+    }
+  } else {
+    return new MutableURL(url.toString());
   }
-  is_ok() {
-    return true;
+}
+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 = hasHostPartProtocols.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;
   }
-  is_err() {
-    return false;
+  clone() {
+    return new _MutableURL(this.toString());
   }
-  unwrap_err() {
-    throw new Error("Result is Ok");
+  get host() {
+    if (!this._hasHostpart) {
+      throw new Error(
+        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`
+      );
+    }
+    return this._sysURL.host;
   }
-  unwrap() {
-    return this._t;
+  get port() {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+    }
+    return this._sysURL.port;
   }
-};
-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));
+  set port(p) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
-    return Result.Ok(res);
-  } catch (e) {
-    return Result.Err(e);
-  }
-}
-
-// src/resolve-once.ts
-var ResolveSeq = class {
-  constructor(ctx) {
-    this._flushWaiting = [];
-    this._seqFutures = [];
-    this.ctx = ctx;
-  }
-  reset() {
+    this._sysURL.port = p;
   }
-  flush() {
-    var _a;
-    if (this._seqFutures.length > 0) {
-      const waitForFlush = new Future();
-      (_a = this._flushWaiting) == null ? void 0 : _a.push(waitForFlush);
-      return waitForFlush.asPromise();
+  get hostname() {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
-    return Promise.resolve();
+    return this._sysURL.hostname;
   }
-  _step(item) {
-    var _a;
-    if (!item) {
-      this._flushWaiting.forEach((f) => f.resolve());
-      (_a = this._flushWaiting) == null ? void 0 : _a.splice(0, this._flushWaiting.length);
-      return Promise.resolve();
+  set hostname(h) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
-    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
-      this._seqFutures.shift();
-      void this._step(this._seqFutures[0]);
-    });
-    return Promise.resolve();
+    this._sysURL.hostname = h;
   }
-  async add(fn, id) {
-    const future = new Future();
-    this._seqFutures.push({ future, fn, id });
-    if (this._seqFutures.length === 1) {
-      void this._step(this._seqFutures[0]);
-    }
-    return future.asPromise();
+  set pathname(p) {
+    this._pathname = p;
   }
-};
-var ResolveOnce = class {
-  constructor(ctx) {
-    this._onceDone = false;
-    this._onceFutures = [];
-    this._onceOk = false;
-    this._isPromise = false;
-    this.ctx = ctx;
+  get pathname() {
+    return this._pathname;
   }
-  get ready() {
-    return this._onceDone;
+  get protocol() {
+    return this._protocol;
   }
-  reset() {
-    this._onceDone = false;
-    this._onceOk = false;
-    this._onceValue = void 0;
-    this._onceError = void 0;
-    if (this._inProgress) {
-      const idx = this._onceFutures.findIndex((f) => f === this._inProgress);
-      if (idx >= 0) {
-        this._onceFutures.push(...this._onceFutures.splice(2).slice(1));
-      }
-    } else {
-      this._onceFutures.length = 0;
+  set protocol(p) {
+    if (!p.endsWith(":")) {
+      p = `${p}:`;
     }
+    this._protocol = p;
   }
-  // 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;
-        }
+  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)}`;
       }
-      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;
-      };
-      this._inProgress = future;
-      try {
-        const ret = fn(this.ctx);
-        if (typeof ret.then === "function") {
-          this._isPromise = true;
-          ret.then(okFn).catch(catchFn).finally(() => {
-            this._inProgress = void 0;
-          });
-        } else {
-          okFn(ret);
-        }
-      } catch (e) {
-        catchFn(e);
+    let hostpart = "";
+    if (this._hasHostpart) {
+      hostpart = this._sysURL.hostname;
+      if (this._sysURL.port) {
+        hostpart += `:${this._sysURL.port}`;
       }
-      if (!this._isPromise) {
-        this._inProgress = void 0;
+      if (!this._pathname.startsWith("/")) {
+        hostpart += "/";
       }
     }
-    if (this._isPromise) {
-      return future.asPromise();
-    } else {
-      return this.once(fn);
-    }
+    return `${this._protocol}//${hostpart}${this._pathname}${search}`;
   }
 };
-var Keyed = class {
-  constructor(factory, params) {
-    var _a;
-    this.factory = factory;
-    this._map = new LRUMap((_a = params == null ? void 0 : params.lru) != null ? _a : { maxEntries: -1 });
+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}`);
   }
-  setParam(params) {
-    this._map.setParam(params.lru);
+}
+function getParamResult(key, val, msgFn = (key2) => {
+  return `missing parameter: ${key2}`;
+}) {
+  if (val === void 0) {
+    return Result.Err(msgFn(key));
   }
-  async asyncGet(key) {
-    return this.get(await key());
+  return Result.Ok(val);
+}
+var BuildURI = class _BuildURI {
+  // pathname needs this
+  constructor(url) {
+    this._url = url;
   }
-  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;
+  static is(value) {
+    return value instanceof _BuildURI || !!value && typeof value.delParam === "function" && typeof value.setParam === "function";
   }
-  unget(key) {
-    const keyed = this._map.get(key);
-    keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key);
+  static from(strURLUri, defaultProtocol = "file:") {
+    return from((url) => new _BuildURI(url), strURLUri, defaultProtocol);
   }
-  reset() {
-    this._map.forEach((keyed) => keyed.reset());
-    this._map.clear();
+  match(other) {
+    return match(this.URI(), URI.from(other));
   }
-};
-var KeyedResolvOnce = class extends Keyed {
-  constructor(kp = {}) {
-    super((key) => new ResolveOnce(key), kp);
+  port(p) {
+    this._url.port = p;
+    return this;
   }
-  /**
-   *
-   * @returns The values of the resolved keys
-   */
-  values() {
-    return Array.from(this._map.entries()).filter(([_, v]) => v._onceDone).map(([k, v]) => {
-      if (v._onceDone) {
-        if (v._onceError) {
-          return {
-            key: k,
-            value: Result.Err(v._onceError)
-          };
-        }
-        return {
-          key: k,
-          value: Result.Ok(v._onceValue)
-        };
-      }
-      throw new Error("KeyedResolvOnce.values impossible");
-    });
-  }
-};
-var KeyedResolvSeq = class extends Keyed {
-  constructor(kp = {}) {
-    super((key) => new ResolveSeq(key), kp);
+  hostname(h) {
+    this._url.hostname = h;
+    return this;
   }
-};
-
-// 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;
+  protocol(p) {
+    if (!p.endsWith(":")) {
+      p = `${p}:`;
     }
-    return isSet(tail.join("."), ref[head]);
-  }
-  return false;
-}
-function runtimeFn() {
-  const gt = globalThis;
-  let isReactNative = (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative"
-  );
-  let isNodeIsh = false;
-  if (!isSet("Deno")) {
-    isNodeIsh = isSet("process.versions.node") && !isReactNative;
-  }
-  let isDeno = isSet("Deno");
-  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
-  if (isCFWorker) {
-    isDeno = false;
-    isNodeIsh = false;
-    isReactNative = false;
-  }
-  return {
-    isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno || isCFWorker || isReactNative),
-    isDeno,
-    isReactNative,
-    isCFWorker
-  };
-}
-
-// src/deno/deno-env-actions.ts
-var once = new ResolveOnce();
-var _deno;
-var _DenoEnvActions = class _DenoEnvActions {
-  constructor(opts) {
-    __privateAdd(this, _deno, globalThis);
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once.once(() => new _DenoEnvActions(opts));
+    this._url.protocol = p;
+    return this;
   }
-  get _env() {
-    return __privateGet(this, _deno).Deno.env;
+  pathname(p) {
+    this._url.pathname = p;
+    return this;
   }
-  register(env) {
-    for (const key of env.keys()) {
-      this._env.set(key, env.get(key) || "");
+  // could pass a relative path or a full URL
+  // if relative path, it will be appended to the current path
+  resolve(p) {
+    if (!p) {
+      return this;
     }
-    return env;
+    if (typeof p === "string") {
+      if (!p.match(/^[a-zA-Z0-9]+:/)) {
+        if (p.startsWith("/")) {
+          this.pathname(p);
+          return this;
+        }
+        return this.appendRelative(p);
+      }
+    }
+    this._url = new MutableURL(p.toString());
+    return this;
   }
-  active() {
-    return runtimeFn().isDeno;
+  appendRelative(p) {
+    const appendUrl = URI.from(p);
+    const pathname = "./" + appendUrl.pathname;
+    const basePath = this._url.pathname;
+    this.pathname(relativePath(basePath, pathname));
+    for (const [key, value] of appendUrl.getParams) {
+      this.setParam(key, value);
+    }
+    return this;
   }
-  keys() {
-    return Object.keys(this._env.toObject());
+  cleanParams() {
+    for (const key of Array.from(this._url.searchParams.keys())) {
+      this._url.searchParams.delete(key);
+    }
+    return this;
   }
-  get(key) {
-    return this._env.get(key);
+  delParam(key) {
+    this._url.searchParams.delete(key);
+    return this;
   }
-  set(key, value) {
-    if (value) {
-      this._env.set(key, value);
+  defParam(key, str) {
+    if (!this._url.searchParams.has(key)) {
+      this._url.searchParams.set(key, str);
     }
+    return this;
   }
-  delete(key) {
-    this._env.delete(key);
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
+    return this;
   }
-};
-_deno = new WeakMap();
-var DenoEnvActions = _DenoEnvActions;
-
-// src/node/node-env-actions.ts
-var once2 = new ResolveOnce();
-var _node;
-var _NodeEnvActions = class _NodeEnvActions {
-  constructor(opts) {
-    __privateAdd(this, _node, globalThis);
-    this._env = this.active() ? __privateGet(this, _node).process.env : {};
-    this.opts = opts;
+  hasParam(key) {
+    return this._url.searchParams.has(key);
   }
-  static new(opts) {
-    return once2.once(() => new _NodeEnvActions(opts));
+  get getParams() {
+    return this._url.searchParams.entries();
   }
-  register(env) {
-    for (const key of env.keys()) {
-      this._env[key] = env.get(key) || "";
+  getParam(key, def) {
+    const { key: k, def: d } = coerceKey(key, def);
+    let val = this._url.searchParams.get(k);
+    if (!falsy2undef(val) && d) {
+      val = d;
     }
-    return env;
+    return falsy2undef(val);
   }
-  active() {
-    return runtimeFn().isNodeIsh;
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
-  keys() {
-    return Object.keys(this._env);
+  getParamsResult(...keys) {
+    return getParamsResult(keys, this);
   }
-  get(key) {
-    return this._env[key];
+  toString() {
+    this._url.searchParams.sort();
+    return this._url.toString();
   }
-  set(key, value) {
-    if (value) {
-      this._env[key] = value;
-    }
+  toJSON() {
+    return this.toString();
   }
-  delete(key) {
-    delete this._env[key];
+  asURL() {
+    return this.URI().asURL();
   }
-};
-_node = new WeakMap();
-var NodeEnvActions = _NodeEnvActions;
-
-// src/web/web-env-actions.ts
-var once3 = new ResolveOnce();
-var BrowserEnvActions = class _BrowserEnvActions {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
+  asObj(...strips) {
+    return this.URI().asObj(...strips);
   }
-  static new(opts) {
-    return once3.once(() => new _BrowserEnvActions(opts));
+  clone() {
+    return _BuildURI.from(this.toString());
   }
-  get(key) {
-    return this.env.get(key);
+  URI() {
+    return URI.from(this._url);
   }
-  set(key, value) {
-    if (value) {
-      this.env.set(key, value);
-    }
+};
+function isCoerceURI(value) {
+  if (!value) {
+    return false;
   }
-  delete(key) {
-    this.env.delete(key);
+  if (isURL(value)) {
+    return true;
   }
-  keys() {
-    return Array.from(this.env.keys());
+  if (URI.is(value)) {
+    return true;
   }
-  active() {
+  if (BuildURI.is(value)) {
     return true;
   }
-  register(env) {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis;
-    browser[sym] = env;
-    return env;
+  if (typeof value === "string") {
+    return true;
   }
-};
-
-// src/cf/cf-env-actions.ts
-var once4 = new ResolveOnce();
-var CFEnvActions = class _CFEnvActions {
-  constructor(env) {
-    this.injectOnRegister = {};
-    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
+  return false;
+}
+var hasHostPartProtocols = /* @__PURE__ */ new Set(["http", "https", "ws", "wss"]);
+var URI = class _URI {
+  static protocolHasHostpart(protocol) {
+    protocol = protocol.replace(/:$/, "");
+    hasHostPartProtocols.add(protocol);
+    return () => {
+      hasHostPartProtocols.delete(protocol);
+    };
   }
-  static new(opts) {
-    return once4.once(() => new _CFEnvActions(opts));
+  match(other) {
+    return match(this, other);
   }
-  static inject(o) {
-    const env = _CFEnvActions.new({});
-    for (const key in o) {
-      const value = o[key];
-      if (typeof value === "string") {
-        if (env.env) {
-          env.env.set(key, value);
-        } else {
-          env.injectOnRegister[key] = value;
-        }
-      }
+  // 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();
   }
-  active() {
-    return runtimeFn().isCFWorker;
+  static is(value) {
+    return value instanceof _URI || !!value && typeof value.asURL === "function" && typeof value.getParam === "function" && typeof value.hasParam === "function";
   }
-  register(env) {
-    this.env = env;
-    for (const key in this.injectOnRegister) {
-      env.set(key, this.injectOnRegister[key]);
-    }
-    return env;
+  // if no protocol is provided, default to file:
+  static from(strURLUri, defaultProtocol = "file:") {
+    return from((url) => new _URI(url), strURLUri, defaultProtocol);
   }
-  get(key) {
-    return this.cfEnv.get(key);
+  static fromResult(strURLUri, defaultProtocol = "file:") {
+    return exception2Result(() => from((url) => new _URI(url), strURLUri, defaultProtocol));
   }
-  set(key, value) {
-    if (value) {
-      this.cfEnv.set(key, value);
+  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, def) {
+    const { key: k, def: d } = coerceKey(key, def);
+    let val = this._url.searchParams.get(k);
+    if (!falsy2undef(val) && d) {
+      val = d;
     }
+    return falsy2undef(val);
   }
-  delete(key) {
-    this.cfEnv.delete(key);
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
-  keys() {
-    return Array.from(this.cfEnv.keys());
+  getParamsResult(...keys) {
+    return getParamsResult(keys, this);
+  }
+  clone() {
+    return new _URI(this._url);
+  }
+  asURL() {
+    return this._url.clone();
+  }
+  toString() {
+    return this._url.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+  asObj(...strips) {
+    const pathURI = {
+      style: "path",
+      protocol: this.protocol,
+      pathname: this.pathname,
+      searchParams: Object.fromEntries(this.getParams)
+    };
+    if (hasHostPartProtocols.has(this.protocol.replace(/:$/, ""))) {
+      return stripper(strips, {
+        ...pathURI,
+        style: "host",
+        hostname: this.hostname,
+        port: this.port
+      });
+    }
+    return stripper(strips, pathURI);
   }
 };
 
-// src/types.ts
-var _Required = class {
+// src/future.ts
+var _promise, _resolveFn, _rejectFn;
+var Future = class {
   constructor() {
-    this.type = "REQUIRED";
+    __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);
+    }));
   }
-};
-var _Optional = class {
-  constructor() {
-    this.type = "OPTIONAL";
+  async asPromise() {
+    return __privateGet(this, _promise);
+  }
+  resolve(value) {
+    __privateGet(this, _resolveFn).call(this, value);
+  }
+  reject(reason) {
+    __privateGet(this, _rejectFn).call(this, reason);
   }
 };
-var param = {
-  REQUIRED: new _Required(),
-  OPTIONAL: new _Optional()
-};
+_promise = new WeakMap();
+_resolveFn = new WeakMap();
+_rejectFn = new WeakMap();
 
-// src/utils/get-params-result.ts
-function getParamsResult(keys, getParam) {
-  const keyDef = keys.flat().reduce(
-    (acc, i) => {
-      if (typeof i === "string") {
-        acc.push({ key: i, def: void 0, isOptional: false });
-      } else if (typeof i === "object") {
-        acc.push(
-          ...Object.keys(i).map((k) => ({
-            key: k,
-            def: typeof i[k] === "string" ? i[k] : void 0,
-            isOptional: i[k] === param.OPTIONAL
-          }))
-        );
-      }
-      return acc;
-    },
-    []
-  );
-  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
-    const msg = keys2.join(",");
-    return `missing parameters: ${msg}`;
-  });
-  const errors = [];
-  const result = {};
-  for (const kd of keyDef) {
-    const val = getParam.getParam(kd.key);
-    if (val === void 0) {
-      if (typeof kd.def === "string") {
-        result[kd.key] = kd.def;
-      } else {
-        if (!kd.isOptional) {
-          errors.push(kd.key);
-        }
-      }
-    } else {
-      result[kd.key] = val;
-    }
+// src/lru-map-set.ts
+var LRUSet = class {
+  constructor(param2 = {}) {
+    this._lruMap = new LRUMap(param2);
   }
-  if (errors.length) {
-    return Result.Err(msgFn(...errors));
+  setParam(param2 = {}) {
+    this._lruMap.setParam(param2);
   }
-  return Result.Ok(result);
-}
-
-// src/sys-env.ts
-var envActions = [
-  { id: "cf", fn: (opts) => CFEnvActions.new(opts) },
-  { id: "node", fn: (opts) => NodeEnvActions.new(opts) },
-  { id: "deno", fn: (opts) => DenoEnvActions.new(opts) },
-  { id: "browser", fn: (opts) => BrowserEnvActions.new(opts) }
-];
-function registerEnvAction(fn) {
-  const id = `id-${Math.random()}`;
-  envActions.unshift({ id, fn });
-  _envFactories.unget(id);
-  return () => {
-    const index = envActions.findIndex((i) => i.id === id);
-    if (index >= 0) {
-      envActions.splice(index, 1);
-    }
-  };
-}
-var _envFactories = new KeyedResolvOnce();
-function envFactory(opts = {}) {
-  const found = envActions.find((fi) => fi.fn(opts).active());
-  if (!found) {
-    throw new Error("SysContainer:envFactory: no env available");
+  get size() {
+    return this._lruMap.size;
   }
-  return _envFactories.get(found.id).once(() => {
-    const action = found.fn(opts);
-    const ret = new EnvImpl(action, opts);
-    action.register(ret);
-    return ret;
-  });
-}
-function isIterable(obj) {
-  if (obj == null) {
-    return false;
+  has(key) {
+    return this._lruMap.has(key);
   }
-  return typeof obj[Symbol.iterator] === "function";
-}
-var EnvImpl = class {
-  constructor(map, opts = {}) {
-    this._onSet = [];
-    this._map = map;
-    this._updatePresets(opts.presetEnv);
+  add(key) {
+    this._lruMap.set(key, key);
   }
-  gets(...kparams) {
-    return getParamsResult(kparams, {
-      getParam: (k) => this.get(k)
-    });
+  delete(key) {
+    this._lruMap.delete(key);
   }
-  sets(...keys) {
-    keys.forEach((key) => {
-      if (Array.isArray(key)) {
-        if (key.length === 2) {
-          const [k, v] = key;
-          if (typeof k === "string" && typeof v === "string") {
-            this.set(k, v);
-            return;
-          }
-        }
-        for (const item of key) {
-          if (Array.isArray(item)) {
-            if (item.length === 2) {
-              const [k, v] = item;
-              if (typeof k === "string" && typeof v === "string") {
-                this.set(k, v);
-              }
-            }
+  clear() {
+    this._lruMap.clear();
+  }
+  forEach(callbackfn) {
+    this._lruMap.forEach((value) => callbackfn(value, value));
+  }
+  entries() {
+    return this._lruMap.entries();
+  }
+};
+var LRUMap = class {
+  constructor(c = {}) {
+    this._map = /* @__PURE__ */ new Map();
+    this.param = {
+      maxEntries: c.maxEntries || 100,
+      maxAge: c.maxAge || 0
+    };
+  }
+  touch(key) {
+    if (!this._map.has(key)) {
+      throw new Error(`key not found in cache: ${key}`);
+    }
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+  setParam(param2 = {}) {
+    if (typeof param2.maxEntries === "number") {
+      this.param.maxEntries = param2.maxEntries;
+      if (param2.maxEntries > 0 && this._map.size > param2.maxEntries) {
+        const toDelete = [];
+        let cacheSize = this._map.size;
+        for (const key of this._map.keys()) {
+          if (cacheSize > param2.maxEntries) {
+            toDelete.push(key);
+            cacheSize--;
+          } else {
+            break;
           }
         }
-      } else {
-        if (isIterable(key)) {
-          for (const [k, v] of key) {
-            if (typeof k === "string" && typeof v === "string") {
-              this.set(k, v);
-            }
-          }
-        } else {
-          const rKey = key;
-          for (const k in rKey) {
-            const v = rKey[k];
-            if (typeof k === "string" && typeof v === "string") {
-              this.set(k, v);
-            }
-          }
+        for (const key of toDelete) {
+          this._map.delete(key);
         }
       }
-    });
-  }
-  _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);
-      });
-    });
+  has(key) {
+    return this._map.has(key);
   }
-  keys() {
-    return this._map.keys();
+  get size() {
+    return this._map.size;
   }
-  // filter is not set all sets passed
-  onSet(fn, ...filter) {
-    const item = { filter: new Set(filter), fn };
-    this._onSet.push(item);
-    this._applyOnSet([item]);
+  async getSet(key, createFN) {
+    const val = this.get(key);
+    if (val) {
+      return val;
+    } else {
+      const val2 = await createFN(key);
+      this.set(key, val2);
+      return val2;
+    }
   }
   get(key) {
+    if (this._map.has(key)) {
+      return this.touch(key);
+    }
     return this._map.get(key);
   }
   set(key, value) {
-    if (!value) {
-      return;
+    this._map.delete(key);
+    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
+      this._map.delete(this._map.keys().next().value);
+      this._map.set(key, value);
+    } else {
+      this._map.set(key, value);
     }
-    this._map.set(key, value);
-    this._applyOnSet(this._onSet, key, value);
   }
   delete(key) {
     this._map.delete(key);
-    this._applyOnSet(this._onSet, key);
-  }
-};
-
-// src/utils/coerce-uint8.ts
-var globalBuffer = globalThis;
-function coerceIntoUint8(raw) {
-  if (raw instanceof ArrayBuffer) {
-    return Result.Ok(new Uint8Array(raw));
-  }
-  if (ArrayBuffer.isView(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Blob) {
-    return Result.Err("Blob not supported");
   }
-  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Uint8Array) {
-    return Result.Ok(raw);
+  clear() {
+    this._map.clear();
   }
-  if (Result.Is(raw)) {
-    if (raw.isErr()) {
-      return Result.Err(raw);
-    }
-    return coerceIntoUint8(raw.unwrap());
+  forEach(callbackfn) {
+    this._map.forEach(callbackfn);
   }
-  return Result.Err("Not a Uint8Array");
-}
-async function asyncCoerceIntoUint8(raw) {
-  let resolved = await raw;
-  if (resolved instanceof Blob) {
-    resolved = await resolved.arrayBuffer();
+  entries() {
+    return this._map.entries();
   }
-  return coerceIntoUint8(resolved);
-}
+  // *entries(): IterableIterator<[T, K]> {
+  //   for (const x of this._cache.entries()) {
+  //     yield x;
+  //   }
+  // }
+  //   getLeastRecent(): K {
+  //     return Array.from(this.cache)[0];
+  //   }
+  //   getMostRecent(): K {
+  //     return Array.from(this.cache)[this.cache.size - 1];
+  //   }
+};
 
-// src/txt-en-decoder.ts
-var TxtOps = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.decoder = new TextDecoder();
+// src/resolve-once.ts
+var ResolveSeq = class {
+  constructor(ctx) {
+    this._flushWaiting = [];
+    this._seqFutures = [];
+    this.ctx = ctx;
   }
-  encode(str) {
-    return this.encoder.encode(str);
+  reset() {
   }
-  decode(data) {
-    if (Result.Is(data)) {
-      if (data.isErr()) {
-        throw data.Err();
-      }
-      const unwrapped = data.unwrap();
-      if (typeof unwrapped === "string") {
-        return this.decode(unwrapped);
-      }
+  flush() {
+    var _a;
+    if (this._seqFutures.length > 0) {
+      const waitForFlush = new Future();
+      (_a = this._flushWaiting) == null ? void 0 : _a.push(waitForFlush);
+      return waitForFlush.asPromise();
     }
-    if (typeof data === "string") {
-      return data;
+    return Promise.resolve();
+  }
+  _step(item) {
+    var _a;
+    if (!item) {
+      this._flushWaiting.forEach((f) => f.resolve());
+      (_a = this._flushWaiting) == null ? void 0 : _a.splice(0, this._flushWaiting.length);
+      return Promise.resolve();
     }
-    return this.decoder.decode(coerceIntoUint8(data).Ok());
+    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
+      this._seqFutures.shift();
+      void this._step(this._seqFutures[0]);
+    });
+    return Promise.resolve();
   }
-  async asyncDecode(data) {
-    let resolved = await data;
-    if (resolved instanceof Blob) {
-      resolved = await resolved.arrayBuffer();
+  async add(fn, id) {
+    const future = new Future();
+    this._seqFutures.push({ future, fn, id });
+    if (this._seqFutures.length === 1) {
+      void this._step(this._seqFutures[0]);
     }
-    return this.decode(resolved);
+    return future.asPromise();
   }
 };
-var txtEnDecoder;
-function TxtEnDecoderSingleton() {
-  txtEnDecoder = txtEnDecoder != null ? txtEnDecoder : new TxtOps();
-  return txtEnDecoder;
-}
-
-// 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.");
+var ResolveOnce = class {
+  constructor(ctx) {
+    this._onceDone = false;
+    this._onceFutures = [];
+    this._onceOk = false;
+    this._isPromise = false;
+    this.ctx = ctx;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  readFileString(fname) {
-    throw new Error("readFileString-Method not implemented.");
+  get ready() {
+    return this._onceDone;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  writeFileString(fname, content) {
-    throw new Error("writeFileString-Method not implemented.");
+  reset() {
+    this._onceDone = false;
+    this._onceOk = false;
+    this._onceValue = void 0;
+    this._onceError = void 0;
+    if (this._inProgress) {
+      const idx = this._onceFutures.findIndex((f) => f === this._inProgress);
+      if (idx >= 0) {
+        this._onceFutures.push(...this._onceFutures.splice(2).slice(1));
+      }
+    } else {
+      this._onceFutures.length = 0;
+    }
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  abs(fname) {
-    throw new Error("abs-Method not implemented.");
+  // 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;
+      };
+      this._inProgress = future;
+      try {
+        const ret = fn(this.ctx);
+        if (typeof ret.then === "function") {
+          this._isPromise = true;
+          ret.then(okFn).catch(catchFn).finally(() => {
+            this._inProgress = void 0;
+          });
+        } else {
+          okFn(ret);
+        }
+      } catch (e) {
+        catchFn(e);
+      }
+      if (!this._isPromise) {
+        this._inProgress = void 0;
+      }
+    }
+    if (this._isPromise) {
+      return future.asPromise();
+    } else {
+      return this.once(fn);
+    }
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  join(...paths) {
-    throw new Error("join-Method not implemented.");
+};
+var Keyed = class {
+  constructor(factory, params) {
+    var _a;
+    this.factory = factory;
+    this._map = new LRUMap((_a = params == null ? void 0 : params.lru) != null ? _a : { maxEntries: -1 });
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  relative(from2, to) {
-    throw new Error("relative-Method not implemented.");
+  setParam(params) {
+    this._map.setParam(params.lru);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  dirname(fname) {
-    throw new Error("dirname-Method not implemented.");
+  async asyncGet(key) {
+    return this.get(await key());
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  basename(fname) {
-    throw new Error("basename-Method not implemented.");
+  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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  nodeImport(fname) {
-    throw new Error("nodeImport-Method not implemented.");
+  unget(key) {
+    const keyed = this._map.get(key);
+    keyed == null ? void 0 : keyed.reset();
+    this._map.delete(key);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  isAbsolute(fname) {
-    throw new Error("isAbsolute-Method not implemented.");
+  reset() {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
   }
 };
-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.");
+var KeyedResolvOnce = class extends Keyed {
+  constructor(kp = {}) {
+    super((key) => new ResolveOnce(key), kp);
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Exit(code) {
-    throw new Error("Exit-Method not implemented.");
+  /**
+   *
+   * @returns The values of the resolved keys
+   */
+  values() {
+    return Array.from(this._map.entries()).filter(([_, v]) => v._onceDone).map(([k, v]) => {
+      if (v._onceDone) {
+        if (v._onceError) {
+          return {
+            key: k,
+            value: Result.Err(v._onceError)
+          };
+        }
+        return {
+          key: k,
+          value: Result.Ok(v._onceValue)
+        };
+      }
+      throw new Error("KeyedResolvOnce.values impossible");
+    });
   }
 };
-var my = void 0;
-function WebSysAbstraction(param2) {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton(),
-      FileSystem: new WebFileService(),
-      SystemService: new WebSystemService()
-    });
+var KeyedResolvSeq = class extends Keyed {
+  constructor(kp = {}) {
+    super((key) => new ResolveSeq(key), kp);
   }
-  return new WrapperSysAbstraction(my, param2);
-}
-
-// src/utils/relative-path.ts
-var PartType = {
-  Slash: 1,
-  Root: 3,
-  Up: 4,
-  Noop: 8
-  // RootUp = 0x8 /* ../ */,
 };
-var Path = class {
-  constructor(parts = []) {
-    this.parts = parts;
+
+// src/utils/coerce-uint8.ts
+var globalBuffer = globalThis;
+function coerceIntoUint8(raw) {
+  if (raw instanceof ArrayBuffer) {
+    return Result.Ok(new Uint8Array(raw));
   }
-  toString() {
-    return this.parts.map((part) => {
-      if (typeof part === "string") {
-        return part;
-      } else {
-        switch (part) {
-          case PartType.Slash:
-          case PartType.Root:
-            return "/";
-          case PartType.Up:
-            return "..";
-          default:
-            return part;
-        }
-      }
-    }).join("");
+  if (ArrayBuffer.isView(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
   }
-  add(part) {
-    if (this.parts.includes(PartType.Root) && part === PartType.Root) {
-      throw new Error("Cannot add absolute part to absolute path");
-    }
-    const last = this.parts[this.parts.length - 1];
-    if (last & PartType.Slash && part === PartType.Slash) {
-      return;
-    }
-    switch (part) {
-      case ".":
-        this.parts.push(PartType.Noop);
-        return;
-      case "..":
-        part = PartType.Up;
-    }
-    if (last === PartType.Noop && part === PartType.Slash) {
-      if (last === PartType.Noop) {
-        this.parts.pop();
-      }
-      return;
-    }
-    this.parts.push(part);
+  if (raw instanceof Blob) {
+    return Result.Err("Blob not supported");
   }
-};
-function splitPath(path) {
-  const p = new Path();
-  if (path === "") {
-    return p;
+  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
   }
-  for (let count = 0; path.length; count++) {
-    if (path.match(/^\/+/)) {
-      if (count === 0) {
-        p.add(PartType.Root);
-      } else {
-        p.add(PartType.Slash);
-      }
-      path = path.replace(/^\/+/, "");
-    } else {
-      const part = path.replace(/\/.*$/, "");
-      p.add(part);
-      path = path.replace(/^[^/]+/, "");
+  if (raw instanceof Uint8Array) {
+    return Result.Ok(raw);
+  }
+  if (Result.Is(raw)) {
+    if (raw.isErr()) {
+      return Result.Err(raw);
     }
+    return coerceIntoUint8(raw.unwrap());
   }
-  return p;
+  return Result.Err("Not a Uint8Array");
 }
-function pathJoin(...paths) {
-  let prev = "";
-  const res = [];
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-    if (path === "") {
-      continue;
-    }
-    if (!(prev.endsWith("/") || path.startsWith("/"))) {
-      if (prev !== "") {
-        res.push("/");
+async function asyncCoerceIntoUint8(raw) {
+  let resolved = await raw;
+  if (resolved instanceof Blob) {
+    resolved = await resolved.arrayBuffer();
+  }
+  return coerceIntoUint8(resolved);
+}
+
+// src/txt-en-decoder.ts
+var TxtOps = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+  }
+  encode(str) {
+    return this.encoder.encode(str);
+  }
+  decode(data) {
+    if (Result.Is(data)) {
+      if (data.isErr()) {
+        throw data.Err();
+      }
+      const unwrapped = data.unwrap();
+      if (typeof unwrapped === "string") {
+        return this.decode(unwrapped);
       }
-      res.push(path);
-    } else {
-      res.push(path);
     }
-    prev = path;
+    if (typeof data === "string") {
+      return data;
+    }
+    return this.decoder.decode(coerceIntoUint8(data).Ok());
   }
-  return res.join("");
+  async asyncDecode(data) {
+    let resolved = await data;
+    if (resolved instanceof Blob) {
+      resolved = await resolved.arrayBuffer();
+    }
+    return this.decode(resolved);
+  }
+};
+var txtEnDecoder = new ResolveOnce();
+function TxtEnDecoderSingleton() {
+  return txtEnDecoder.once(() => new TxtOps());
 }
-function relativePath(path, relative) {
-  const relativeParts = splitPath(relative);
-  let result;
-  if (relativeParts.parts[0] === PartType.Root) {
-    result = relative;
-  } else {
-    result = pathJoin(path, relative);
+
+// src/option.ts
+var Option = class _Option {
+  static Some(t) {
+    return new Some(t);
   }
-  const unoptPath = splitPath(result);
-  const out = [];
-  let topUp = false;
-  for (const part of unoptPath.parts) {
-    switch (part) {
-      case PartType.Root:
-        out.push(PartType.Root);
-        break;
-      case PartType.Up:
-        if (out.length && !topUp) {
-          const last = out.length - 1;
-          if (typeof out[last] === "string" && out[last - 1] == PartType.Root) {
-            out.pop();
-          } else {
-            out.pop();
-            out.pop();
-          }
-          if (out.length === 0) {
-            topUp = !topUp ? true : topUp;
-            out.push(PartType.Up);
-          }
-        } else {
-          out.push(PartType.Up);
-        }
-        break;
-      case PartType.Slash:
-        if (!(out[out.length - 1] & PartType.Slash)) {
-          out.push(PartType.Slash);
-        }
-        break;
-      default:
-        out.push(part);
-        break;
+  static None() {
+    return new None();
+  }
+  static Is(t) {
+    return t instanceof _Option;
+  }
+  static From(t) {
+    if (!t) {
+      return new None();
     }
+    return new Some(t);
   }
-  return new Path(out).toString();
-}
+  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/utils/stripper.ts
-function stripper(strip, obj) {
-  const strips = Array.isArray(strip) ? strip : [strip];
-  const restrips = strips.map((s) => {
-    if (typeof s === "string") {
-      const escaped = s.replace(/[-\\[\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\^\\$\\|]/g, "\\$&");
-      return new RegExp(`^${escaped}$`);
+// src/log-level-impl.ts
+var LevelHandlerImpl = class {
+  constructor() {
+    this._globalLevels = /* @__PURE__ */ new Set([Level.INFO, Level.ERROR, Level.WARN]);
+    this._modules = /* @__PURE__ */ new Map();
+    this.ignoreAttr = Option.Some(/^_/);
+    this.isStackExposed = false;
+  }
+  enableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.add(level);
+      return;
     }
-    return s;
-  });
-  return localStripper(void 0, restrips, obj);
-}
-function localStripper(path, restrips, obj) {
-  if (typeof obj !== "object" || obj === null) {
-    return obj;
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, level]));
+      },
+      ...modules
+    );
   }
-  if (Array.isArray(obj)) {
-    return obj.map((i) => localStripper(path, restrips, i));
+  disableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.delete(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.delete(p);
+      },
+      ...modules
+    );
   }
-  const ret = { ...obj };
-  const matcher = (key, nextPath) => {
-    for (const re of restrips) {
-      if (re.test(key) || re.test(nextPath)) {
-        return true;
+  setExposeStack(enable) {
+    this.isStackExposed = !!enable;
+  }
+  setIgnoreAttr(re) {
+    this.ignoreAttr = Option.From(re);
+  }
+  forModules(level, fnAction, ...modules) {
+    for (const m of modules.flat()) {
+      if (typeof m !== "string") {
+        continue;
       }
-    }
-    return false;
-  };
-  for (const key in ret) {
-    if (Object.prototype.hasOwnProperty.call(ret, key)) {
-      let nextPath;
-      if (path) {
-        nextPath = [path, key].join(".");
-      } else {
-        nextPath = key;
+      const parts = m.split(",").map((s) => s.trim()).filter((s) => s.length);
+      for (const p of parts) {
+        fnAction(p);
       }
-      if (matcher(key, nextPath)) {
-        delete ret[key];
-        continue;
+    }
+  }
+  setDebug(...modules) {
+    this.forModules(
+      Level.DEBUG,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, Level.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;
       }
-      if (typeof ret[key] === "object") {
-        if (Array.isArray(ret[key])) {
-          ret[key] = ret[key].reduce((acc, v, i) => {
-            const toDelete = matcher(key, `${nextPath}[${i}]`);
-            if (!toDelete) {
-              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
-            }
-            return acc;
-          }, []);
-        } else {
-          ret[key] = localStripper(nextPath, restrips, ret[key]);
-        }
+    }
+    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);
   }
-  return ret;
+};
+var levelSingleton = new LevelHandlerImpl();
+function LevelHandlerSingleton() {
+  return levelSingleton;
 }
 
-// src/uri.ts
-function match(iref, ioth) {
-  const mr = {
-    score: 0,
-    protocol: false,
-    hostname: false,
-    port: false,
-    pathname: false,
-    pathParts: [],
-    params: {}
+// 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;
+  let isReactNative = (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative"
+  );
+  let isNodeIsh = false;
+  if (!isSet("Deno")) {
+    isNodeIsh = isSet("process.versions.node") && !isReactNative;
+  }
+  let isDeno = isSet("Deno");
+  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
+  if (isCFWorker) {
+    isDeno = false;
+    isNodeIsh = false;
+    isReactNative = false;
+  }
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno || isCFWorker || isReactNative),
+    isDeno,
+    isReactNative,
+    isCFWorker
   };
-  const ref = URI.from(iref);
-  const oth = URI.from(ioth);
-  if (ref.protocol === oth.protocol) {
-    mr.score += 1;
-    mr.protocol = true;
+}
+
+// src/sys-abstraction.ts
+var TimeMode = {
+  REAL: "real",
+  CONST: "const",
+  STEP: "step"
+};
+var RandomMode = {
+  CONST: "const",
+  STEP: "step",
+  RANDOM: "random"
+};
+var IDMode = {
+  UUID: "uuid",
+  CONST: "const",
+  STEP: "step"
+};
+function String2TimeMode(s) {
+  switch (s == null ? void 0 : s.toLowerCase()) {
+    case "real":
+      return TimeMode.REAL;
+    case "const":
+      return TimeMode.CONST;
+    case "step":
+      return TimeMode.STEP;
+    default:
+      return TimeMode.REAL;
   }
-  try {
-    const refH = ref.hostname;
-    const refP = ref.port;
-    if (refH === oth.hostname) {
-      mr.score += 1;
-      mr.hostname = true;
+}
+
+// src/time.ts
+var Time = class {
+  TimeSince(start) {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+};
+var TimeUnits = {
+  Microsecond: 1,
+  Second: 1e3 * 1,
+  //Microsecond,
+  Minute: 60 * 1e3 * 1,
+  //Second,
+  Hour: 60 * 60 * 1e3 * 1
+  // Minute,
+};
+
+// src/deno/deno-env-actions.ts
+var once = new ResolveOnce();
+var _deno;
+var _DenoEnvActions = class _DenoEnvActions {
+  constructor(opts) {
+    __privateAdd(this, _deno, globalThis);
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once.once(() => new _DenoEnvActions(opts));
+  }
+  get _env() {
+    return __privateGet(this, _deno).Deno.env;
+  }
+  register(env) {
+    for (const key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
     }
-    if (refP.length && refP === oth.port) {
-      mr.score += 1;
-      mr.port = true;
+    return env;
+  }
+  active() {
+    return runtimeFn().isDeno;
+  }
+  keys() {
+    return Object.keys(this._env.toObject());
+  }
+  get(key) {
+    return this._env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this._env.set(key, value);
     }
-  } catch (e) {
   }
-  if (ref.pathname.length && ref.pathname !== "/") {
-    const pref = ref.pathname.split("/").filter((p) => p.length);
-    const poth = oth.pathname.split("/").filter((p) => p.length);
-    for (let i = 0; i < pref.length && i < poth.length; i++) {
-      if (poth[i] === pref[i]) {
-        mr.score += 1;
-        mr.pathname = true;
-        mr.pathParts.push(pref[i]);
-      }
+  delete(key) {
+    this._env.delete(key);
+  }
+};
+_deno = new WeakMap();
+var DenoEnvActions = _DenoEnvActions;
+
+// src/node/node-env-actions.ts
+var once2 = new ResolveOnce();
+var _node;
+var _NodeEnvActions = class _NodeEnvActions {
+  constructor(opts) {
+    __privateAdd(this, _node, globalThis);
+    this._env = this.active() ? __privateGet(this, _node).process.env : {};
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once2.once(() => new _NodeEnvActions(opts));
+  }
+  register(env) {
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
     }
+    return env;
   }
-  for (const [key, value] of ref.getParams) {
-    if (oth.getParam(key) === value) {
-      mr.score += 1;
-      mr.params[key] = value;
-    }
+  active() {
+    return runtimeFn().isNodeIsh;
   }
-  return mr;
-}
-function coerceKey(key, def) {
-  if (typeof key === "object") {
-    const keys = Object.keys(key);
-    if (keys.length !== 1) {
-      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
-    }
-    return { key: keys[0], def: key[keys[0]] };
+  keys() {
+    return Object.keys(this._env);
   }
-  return { key, def };
-}
-function falsy2undef(value) {
-  return value === void 0 || value === null ? void 0 : value;
-}
-function ensureURLWithDefaultProto(url, defaultProtocol) {
-  if (!url) {
-    return new MutableURL(`${defaultProtocol}//`);
+  get(key) {
+    return this._env[key];
   }
-  if (typeof url === "string") {
-    try {
-      return new MutableURL(url);
-    } catch (e) {
-      return new MutableURL(`${defaultProtocol}//${url}`);
+  set(key, value) {
+    if (value) {
+      this._env[key] = value;
     }
-  } 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 = hasHostPartProtocols.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;
+  delete(key) {
+    delete this._env[key];
   }
-  clone() {
-    return new _MutableURL(this.toString());
+};
+_node = new WeakMap();
+var NodeEnvActions = _NodeEnvActions;
+
+// src/web/web-env-actions.ts
+var once3 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
   }
-  get host() {
-    if (!this._hasHostpart) {
-      throw new Error(
-        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`
-      );
-    }
-    return this._sysURL.host;
+  static new(opts) {
+    return once3.once(() => new _BrowserEnvActions(opts));
   }
-  get port() {
-    if (!this._hasHostpart) {
-      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
-    }
-    return this._sysURL.port;
+  get(key) {
+    return this.env.get(key);
   }
-  set port(p) {
-    if (!this._hasHostpart) {
-      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
     }
-    this._sysURL.port = p;
   }
-  get hostname() {
-    if (!this._hasHostpart) {
-      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+  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;
+  }
+};
+
+// src/cf/cf-env-actions.ts
+var once4 = new ResolveOnce();
+var CFEnvActions = class _CFEnvActions {
+  constructor(env) {
+    this.injectOnRegister = {};
+    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
+  }
+  static new(opts) {
+    return once4.once(() => new _CFEnvActions(opts));
+  }
+  static inject(o) {
+    const env = _CFEnvActions.new({});
+    for (const key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        if (env.env) {
+          env.env.set(key, value);
+        } else {
+          env.injectOnRegister[key] = value;
+        }
+      }
     }
-    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(hasHostPartProtocols.keys()))}`);
+  active() {
+    return runtimeFn().isCFWorker;
+  }
+  register(env) {
+    this.env = env;
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
     }
-    this._sysURL.hostname = h;
+    return env;
   }
-  set pathname(p) {
-    this._pathname = p;
+  get(key) {
+    return this.cfEnv.get(key);
   }
-  get pathname() {
-    return this._pathname;
+  set(key, value) {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
   }
-  get protocol() {
-    return this._protocol;
+  delete(key) {
+    this.cfEnv.delete(key);
   }
-  set protocol(p) {
-    if (!p.endsWith(":")) {
-      p = `${p}:`;
+  keys() {
+    return Array.from(this.cfEnv.keys());
+  }
+};
+
+// src/sys-env.ts
+var envActions = [
+  { id: "cf", fn: (opts) => CFEnvActions.new(opts) },
+  { id: "node", fn: (opts) => NodeEnvActions.new(opts) },
+  { id: "deno", fn: (opts) => DenoEnvActions.new(opts) },
+  { id: "browser", fn: (opts) => BrowserEnvActions.new(opts) }
+];
+function registerEnvAction(fn) {
+  const id = `id-${Math.random()}`;
+  envActions.unshift({ id, fn });
+  _envFactories.unget(id);
+  return () => {
+    const index = envActions.findIndex((i) => i.id === id);
+    if (index >= 0) {
+      envActions.splice(index, 1);
     }
-    this._protocol = p;
+  };
+}
+var _envFactories = new KeyedResolvOnce();
+function envFactory(opts = {}) {
+  const found = envActions.find((fi) => fi.fn(opts).active());
+  if (!found) {
+    throw new Error("SysContainer:envFactory: no env available");
   }
-  get searchParams() {
-    return this._sysURL.searchParams;
+  return _envFactories.get(found.id).once(() => {
+    const action = found.fn(opts);
+    const ret = new EnvImpl(action, opts);
+    action.register(ret);
+    return ret;
+  });
+}
+function isIterable(obj) {
+  if (obj == null) {
+    return false;
   }
-  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)}`;
+  return typeof obj[Symbol.iterator] === "function";
+}
+var EnvImpl = class {
+  constructor(map, opts = {}) {
+    this._onSet = [];
+    this._map = map;
+    this._updatePresets(opts.presetEnv);
+  }
+  gets(...kparams) {
+    return getParamsResult(kparams, {
+      getParam: (k) => this.get(k)
+    });
+  }
+  sets(...keys) {
+    keys.forEach((key) => {
+      if (Array.isArray(key)) {
+        if (key.length === 2) {
+          const [k, v] = key;
+          if (typeof k === "string" && typeof v === "string") {
+            this.set(k, v);
+            return;
+          }
+        }
+        for (const item of key) {
+          if (Array.isArray(item)) {
+            if (item.length === 2) {
+              const [k, v] = item;
+              if (typeof k === "string" && typeof v === "string") {
+                this.set(k, v);
+              }
+            }
+          }
+        }
+      } else {
+        if (isIterable(key)) {
+          for (const [k, v] of key) {
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        } else {
+          const rKey = key;
+          for (const k in rKey) {
+            const v = rKey[k];
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        }
       }
+    });
+  }
+  _updatePresets(presetEnv) {
+    if (!presetEnv) {
+      return;
     }
-    let hostpart = "";
-    if (this._hasHostpart) {
-      hostpart = this._sysURL.hostname;
-      if (this._sysURL.port) {
-        hostpart += `:${this._sysURL.port}`;
-      }
-      if (!this._pathname.startsWith("/")) {
-        hostpart += "/";
-      }
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
     }
-    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()));
+  _applyOnSet(onSet, key, value) {
+    onSet.forEach((item) => {
+      let keys = [];
+      if (key) {
+        keys = [key];
+      } else {
+        keys = this._map.keys();
       }
-      throw new Error(`unknown object type: ${strURLUri}`);
-    default:
-      throw new Error(`Invalid argument: ${typeof strURLUri}`);
+      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);
+      });
+    });
   }
-}
-function getParamResult(key, val, msgFn = (key2) => {
-  return `missing parameter: ${key2}`;
-}) {
-  if (val === void 0) {
-    return Result.Err(msgFn(key));
+  keys() {
+    return this._map.keys();
   }
-  return Result.Ok(val);
-}
-var BuildURI = class _BuildURI {
-  // pathname needs this
-  constructor(url) {
-    this._url = url;
+  // filter is not set all sets passed
+  onSet(fn, ...filter) {
+    const item = { filter: new Set(filter), fn };
+    this._onSet.push(item);
+    this._applyOnSet([item]);
   }
-  static is(value) {
-    return value instanceof _BuildURI || !!value && typeof value.delParam === "function" && typeof value.setParam === "function";
+  get(key) {
+    return this._map.get(key);
   }
-  static from(strURLUri, defaultProtocol = "file:") {
-    return from((url) => new _BuildURI(url), strURLUri, defaultProtocol);
+  set(key, value) {
+    if (!value) {
+      return;
+    }
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
   }
-  match(other) {
-    return match(this.URI(), URI.from(other));
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
   }
-  port(p) {
-    this._url.port = p;
-    return this;
+};
+
+// 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);
   }
-  hostname(h) {
-    this._url.hostname = h;
-    return this;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason) {
+    throw new Error("Method not implemented.");
   }
-  protocol(p) {
-    if (!p.endsWith(":")) {
-      p = `${p}:`;
-    }
-    this._url.protocol = p;
-    return this;
+  async close() {
   }
-  pathname(p) {
-    this._url.pathname = p;
-    return this;
+  releaseLock() {
+    this._stream.locked = false;
+    this.ready = Promise.resolve(void 0);
+    this.closed = Promise.resolve(void 0);
   }
-  // could pass a relative path or a full URL
-  // if relative path, it will be appended to the current path
-  resolve(p) {
-    if (!p) {
-      return this;
+  write(chunk) {
+    let strObj = this.decoder.decode(chunk).trimEnd();
+    let output = "log";
+    try {
+      strObj = JSON.parse(strObj);
+      output = strObj.level;
+    } catch (e) {
     }
-    if (typeof p === "string") {
-      if (!p.match(/^[a-zA-Z0-9]+:/)) {
-        if (p.startsWith("/")) {
-          this.pathname(p);
-          return this;
-        }
-        return this.appendRelative(p);
-      }
+    switch (output) {
+      case "error":
+        console.error(strObj);
+        break;
+      case "warn":
+        console.warn(strObj);
+        break;
+      default:
+        console.log(strObj);
     }
-    this._url = new MutableURL(p.toString());
-    return this;
+    return Promise.resolve();
   }
-  appendRelative(p) {
-    const appendUrl = URI.from(p);
-    const pathname = "./" + appendUrl.pathname;
-    const basePath = this._url.pathname;
-    this.pathname(relativePath(basePath, pathname));
-    for (const [key, value] of appendUrl.getParams) {
-      this.setParam(key, value);
-    }
-    return this;
+};
+var ConsoleWriterStream = class {
+  constructor() {
+    this.locked = false;
   }
-  cleanParams() {
-    for (const key of Array.from(this._url.searchParams.keys())) {
-      this._url.searchParams.delete(key);
-    }
-    return this;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+  abort(reason) {
+    throw new Error("Method not implemented.");
   }
-  delParam(key) {
-    this._url.searchParams.delete(key);
-    return this;
+  close() {
+    return Promise.resolve();
   }
-  defParam(key, str) {
-    if (!this._url.searchParams.has(key)) {
-      this._url.searchParams.set(key, str);
+  getWriter() {
+    if (this.locked) {
+      throw new Error("Stream is locked");
     }
-    return this;
-  }
-  setParam(key, str) {
-    this._url.searchParams.set(key, str);
-    return this;
-  }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
-  }
-  get getParams() {
-    return this._url.searchParams.entries();
-  }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
-    let val = this._url.searchParams.get(k);
-    if (!falsy2undef(val) && d) {
-      val = d;
+    this.locked = true;
+    if (!this._writer) {
+      this._writer = new ConsoleWriterStreamDefaultWriter(this);
     }
-    return falsy2undef(val);
-  }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
-  }
-  getParamsResult(...keys) {
-    return getParamsResult(keys, this);
-  }
-  toString() {
-    this._url.searchParams.sort();
-    return this._url.toString();
-  }
-  toJSON() {
-    return this.toString();
+    return this._writer;
   }
-  asURL() {
-    return this.URI().asURL();
+};
+
+// src/web/web-basic-sys-abstraction.ts
+var WebSystemService = class {
+  constructor(ende) {
+    this._txtEnDe = ende;
   }
-  asObj(...strips) {
-    return this.URI().asObj(...strips);
+  Env() {
+    return envFactory();
   }
-  clone() {
-    return _BuildURI.from(this.toString());
+  Args() {
+    throw new Error("Args-Method not implemented.");
   }
-  URI() {
-    return URI.from(this._url);
+  Stdout() {
+    return new ConsoleWriterStream();
+  }
+  Stderr() {
+    const decoder = this._txtEnDe;
+    return new WritableStream({
+      write(chunk) {
+        return new Promise((resolve) => {
+          const decoded = decoder.decode(chunk);
+          console.error(decoded.trimEnd());
+          resolve();
+        });
+      }
+    });
   }
 };
-function isCoerceURI(value) {
-  if (!value) {
-    return false;
+var baseSysAbstraction = new ResolveOnce();
+function WebBasicSysAbstraction(param2) {
+  var _a;
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton()
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new WebSystemService((_a = param2 == null ? void 0 : param2.TxtEnDecoder) != null ? _a : my._txtEnDe),
+    ...param2
+  });
+}
+
+// src/cf/cf-basic-sys-abstraction.ts
+var CFRuntimeService = class {
+  constructor(ende) {
+    this._txtEnDe = ende;
   }
-  if (isURL(value)) {
-    return true;
+  Env() {
+    return envFactory();
   }
-  if (URI.is(value)) {
-    return true;
+  Args() {
+    throw new Error("Args-Method not implemented.");
   }
-  if (BuildURI.is(value)) {
-    return true;
+  Stdout() {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      console.log(decoded.trimEnd());
+      return Promise.resolve();
+    });
   }
-  if (typeof value === "string") {
-    return true;
+  Stderr() {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      console.error(decoded.trimEnd());
+      return Promise.resolve();
+    });
   }
-  return false;
+};
+function consumeReadableStream(reader, writeFn) {
+  reader.read().then(({ done, value }) => {
+    if (done) {
+      return;
+    }
+    writeFn(value).then(() => {
+      consumeReadableStream(reader, writeFn);
+    }).catch((e) => {
+      console.error("consumeReadableStream:writeFn", e);
+    });
+  }).catch((e) => {
+    console.error("consumeReadableStream:read", e);
+  });
 }
-var hasHostPartProtocols = /* @__PURE__ */ new Set(["http", "https", "ws", "wss"]);
-var URI = class _URI {
-  static protocolHasHostpart(protocol) {
-    protocol = protocol.replace(/:$/, "");
-    hasHostPartProtocols.add(protocol);
-    return () => {
-      hasHostPartProtocols.delete(protocol);
-    };
+function CFWriteableStream(writeFn) {
+  const ts = new TransformStream();
+  consumeReadableStream(ts.readable.getReader(), writeFn);
+  return ts.writable;
+}
+var baseSysAbstraction2 = new ResolveOnce();
+function CFBasicSysAbstraction(param2) {
+  var _a;
+  const my = baseSysAbstraction2.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton()
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new CFRuntimeService((_a = param2 == null ? void 0 : param2.TxtEnDecoder) != null ? _a : my._txtEnDe),
+    ...param2
+  });
+}
+
+// src/deno/deno-basic-sys-abstraction.ts
+var DenoRuntimeService = class {
+  constructor(ende) {
+    this._txtEnDe = ende;
   }
-  match(other) {
-    return match(this, other);
+  Env() {
+    return envFactory();
   }
-  // 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();
+  Args() {
+    return globalThis.Deno.args;
   }
-  static is(value) {
-    return value instanceof _URI || !!value && typeof value.asURL === "function" && typeof value.getParam === "function" && typeof value.hasParam === "function";
+  Stdout() {
+    return globalThis.Deno.stdout.writable;
   }
-  // if no protocol is provided, default to file:
-  static from(strURLUri, defaultProtocol = "file:") {
-    return from((url) => new _URI(url), strURLUri, defaultProtocol);
+  Stderr() {
+    return globalThis.Deno.stderr.writable;
   }
-  static fromResult(strURLUri, defaultProtocol = "file:") {
-    return exception2Result(() => from((url) => new _URI(url), strURLUri, defaultProtocol));
+};
+var baseSysAbstraction3 = new ResolveOnce();
+function DenoBasicSysAbstraction(param2) {
+  var _a;
+  const my = baseSysAbstraction3.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton()
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new DenoRuntimeService((_a = param2 == null ? void 0 : param2.TxtEnDecoder) != null ? _a : my._txtEnDe),
+    ...param2
+  });
+}
+
+// src/node/node-basic-sys-abstraction.ts
+var NodeRuntimeService = class {
+  constructor(ende) {
+    this._txtEnDe = ende;
+    this._gthis = globalThis;
   }
-  constructor(url) {
-    this._url = url.clone();
+  Env() {
+    return envFactory();
   }
-  build() {
-    return BuildURI.from(this._url);
+  Args() {
+    return this._gthis.process.argv;
   }
-  get hostname() {
-    return this._url.hostname;
+  Stdout() {
+    return new WritableStream({
+      write: (chunk) => {
+        this._gthis.process.stdout.write(chunk);
+      }
+    });
   }
-  // get password(): string {
-  //   return this._url.password;
-  // }
-  get port() {
-    return this._url.port;
+  Stderr() {
+    return new WritableStream({
+      write: (chunk) => {
+        this._gthis.process.stderr.write(chunk);
+      }
+    });
   }
-  get host() {
-    return this._url.host;
+};
+var baseSysAbstraction4 = new ResolveOnce();
+function NodeBasicSysAbstraction(param2) {
+  var _a;
+  const my = baseSysAbstraction4.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton()
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new NodeRuntimeService((_a = param2 == null ? void 0 : param2.TxtEnDecoder) != null ? _a : my._txtEnDe),
+    ...param2
+  });
+}
+
+// src/base-sys-abstraction.ts
+var SysTime = class extends Time {
+  Now() {
+    return /* @__PURE__ */ new Date();
   }
-  // get username(): string {
-  //   return this._url.username;
-  // }
-  // get search(): string {
-  //   return this._url.search;
-  // }
-  get protocol() {
-    return this._url.protocol;
+  Sleep(duration) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, duration);
+    });
   }
-  get pathname() {
-    return this._url.pathname;
+};
+var ConstTime = class extends Time {
+  Now() {
+    return new Date(2021, 1, 1, 0, 0, 0, 0);
   }
-  // get hash(): string {
-  //   return this._url.hash;
-  // }
-  // get host(): string {
-  //   return this._url.host;
-  // }
-  get getParams() {
-    return this._url.searchParams.entries();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Sleep(duration) {
+    return Promise.resolve();
   }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
+};
+var StepTime = class extends Time {
+  constructor() {
+    super();
+    this._step = new ConstTime().Now();
+    this._start = this._step;
   }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
-    let val = this._url.searchParams.get(k);
-    if (!falsy2undef(val) && d) {
-      val = d;
+  Now(steps = 1) {
+    for (let i = 0; steps > 0 && i < steps; i++) {
+      this._step = new Date(this._step.getTime() + 1e3);
     }
-    return falsy2undef(val);
-  }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
+    if (steps < 1) {
+      this._step = new Date(this._start.getTime() + steps * -1e3);
+    }
+    return this._step;
   }
-  getParamsResult(...keys) {
-    return getParamsResult(keys, this);
+  Sleep(duration) {
+    this._step = new Date(this._step.getTime() + duration);
+    return Promise.resolve();
   }
-  clone() {
-    return new _URI(this._url);
+};
+function TimeFactory(timeMode) {
+  switch (timeMode) {
+    case TimeMode.REAL:
+      return new SysTime();
+    case TimeMode.CONST:
+      return new ConstTime();
+    case TimeMode.STEP:
+      return new StepTime();
   }
-  asURL() {
-    return this._url.clone();
+  return new SysTime();
+}
+var RandomService = class {
+  constructor(mode) {
+    this._step = 0;
+    this._mode = mode;
   }
-  toString() {
-    return this._url.toString();
+  Random0ToValue(value) {
+    switch (this._mode) {
+      case RandomMode.CONST:
+        return 0.5 * value;
+      case RandomMode.STEP:
+        this._step += 1e-4;
+        return this._step * value;
+      case RandomMode.RANDOM:
+        return Math.random() * value;
+      default:
+        throw new Error("Unknown RandomMode");
+    }
   }
-  toJSON() {
-    return this.toString();
+};
+var IdService = class {
+  constructor(mode) {
+    this._step = 0;
+    if (!mode) {
+      mode = IDMode.UUID;
+    }
+    this._mode = mode;
   }
-  asObj(...strips) {
-    const pathURI = {
-      style: "path",
-      protocol: this.protocol,
-      pathname: this.pathname,
-      searchParams: Object.fromEntries(this.getParams)
-    };
-    if (hasHostPartProtocols.has(this.protocol.replace(/:$/, ""))) {
-      return stripper(strips, {
-        ...pathURI,
-        style: "host",
-        hostname: this.hostname,
-        port: this.port
-      });
+  NextId() {
+    switch (this._mode) {
+      case IDMode.UUID:
+        return crypto.randomUUID();
+      case IDMode.CONST:
+        return "VeryUniqueID";
+      case IDMode.STEP:
+        return `STEPId-${this._step++}`;
+      default:
+        throw new Error("Unknown IDMode");
     }
-    return stripper(strips, pathURI);
   }
 };
-
-// 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.");
+var BaseBasicSysAbstraction = class {
+  constructor(params) {
+    this._time = new SysTime();
+    // system independent services
+    this._idService = new IdService();
+    this._randomService = new RandomService(RandomMode.RANDOM);
+    this._txtEnDe = params.TxtEnDecoder;
   }
-  async close() {
+};
+var BaseSysAbstraction = class extends BaseBasicSysAbstraction {
+  constructor(params) {
+    super(params);
+    this._fileSystem = params.FileSystem;
+    this._systemService = params.SystemService;
   }
-  releaseLock() {
-    this._stream.locked = false;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
+};
+function BasicSysAbstractionFactory(params) {
+  const fn = runtimeFn();
+  switch (true) {
+    case fn.isBrowser:
+      return WebBasicSysAbstraction(params);
+    case fn.isDeno:
+      return DenoBasicSysAbstraction(params);
+    case fn.isCFWorker:
+      return CFBasicSysAbstraction(params);
+    case fn.isNodeIsh:
+      return NodeBasicSysAbstraction(params);
+    default:
+      throw new Error("Unknown runtime");
   }
-  write(chunk) {
-    let strObj = this.decoder.decode(chunk).trimEnd();
-    let output = "log";
-    try {
-      strObj = JSON.parse(strObj);
-      output = strObj.level;
-    } catch (e) {
+}
+var WrapperBasicSysAbstraction = class {
+  constructor(base, params) {
+    this._time = base._time;
+    this._basicRuntimeService = params.basicRuntimeService;
+    this._idService = base._idService;
+    this._randomService = base._randomService;
+    if (params.TimeMode) {
+      this._time = TimeFactory(params.TimeMode);
     }
-    switch (output) {
-      case "error":
-        console.error(strObj);
-        break;
-      case "warn":
-        console.warn(strObj);
-        break;
-      default:
-        console.log(strObj);
+    if (params.IdMode) {
+      this._idService = new IdService(params.IdMode);
+    }
+    if (params.RandomMode) {
+      this._randomService = new RandomService(params.RandomMode);
     }
-    return Promise.resolve();
   }
-};
-var ConsoleWriterStream = class {
-  constructor() {
-    this.locked = false;
+  Time() {
+    return this._time;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  abort(reason) {
-    throw new Error("Method not implemented.");
+  NextId() {
+    return this._idService.NextId();
   }
-  close() {
-    return Promise.resolve();
+  Random0ToValue(value) {
+    return this._randomService.Random0ToValue(value);
   }
-  getWriter() {
-    if (this.locked) {
-      throw new Error("Stream is locked");
-    }
-    this.locked = true;
-    if (!this._writer) {
-      this._writer = new ConsoleWriterStreamDefaultWriter(this);
-    }
-    return this._writer;
+  Stdout() {
+    return this._basicRuntimeService.Stdout();
+  }
+  Stderr() {
+    return this._basicRuntimeService.Stderr();
+  }
+  Env() {
+    return this._basicRuntimeService.Env();
+  }
+  Args() {
+    return this._basicRuntimeService.Args();
+  }
+  // System(): SystemService {
+  //   return this._systemService;
+  // }
+  // FileSystem(): FileService {
+  //   return this._fileSystem;
+  // }
+};
+var WrapperRuntimeSysAbstraction = class extends WrapperBasicSysAbstraction {
+  constructor(base, params) {
+    var _a, _b;
+    super(base, params);
+    this._systemService = (_a = params.systemService) != null ? _a : base._systemService;
+    this._fileSystem = (_b = params.fileSystem) != null ? _b : base._fileSystem;
+  }
+  System() {
+    return this._systemService;
+  }
+  FileSystem() {
+    return this._fileSystem;
   }
 };
 
@@ -2267,9 +2505,10 @@ var LogWriterStream = class {
     this._flushIsRunning = false;
     this._flushDoneFns = [];
     this._out = out;
+    this._id = Math.random();
   }
   write(encoded) {
-    const my2 = async () => {
+    const my = async () => {
       try {
         const writer = this._out.getWriter();
         await writer.ready;
@@ -2279,7 +2518,7 @@ var LogWriterStream = class {
         console.error("Chunk error:", err);
       }
     };
-    this._toFlush.push(my2);
+    this._toFlush.push(my);
     this._flush();
   }
   _flush(toFlush = void 0, done) {
@@ -2297,8 +2536,8 @@ var LogWriterStream = class {
     } else if (!toFlush) {
       return;
     }
-    const my2 = this._toFlush.shift();
-    my2 == null ? void 0 : my2().catch((e) => {
+    const my = this._toFlush.shift();
+    my == null ? void 0 : my().catch((e) => {
       console.error("Flush error:", e);
     }).finally(() => {
       this._flush(this._toFlush);
@@ -2306,145 +2545,6 @@ var LogWriterStream = class {
   }
 };
 
-// src/option.ts
-var Option = class _Option {
-  static Some(t) {
-    return new Some(t);
-  }
-  static None() {
-    return new None();
-  }
-  static Is(t) {
-    return t instanceof _Option;
-  }
-  static From(t) {
-    if (!t) {
-      return new None();
-    }
-    return new Some(t);
-  }
-  IsNone() {
-    return this.is_none();
-  }
-  IsSome() {
-    return this.is_some();
-  }
-  Unwrap() {
-    return this.unwrap();
-  }
-};
-var Some = class extends Option {
-  constructor(_t) {
-    super();
-    this._t = _t;
-  }
-  is_none() {
-    return false;
-  }
-  is_some() {
-    return true;
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var None = class extends Option {
-  is_none() {
-    return true;
-  }
-  is_some() {
-    return false;
-  }
-  unwrap() {
-    throw new Error("None.unwrap");
-  }
-};
-
-// src/log-level-impl.ts
-var LevelHandlerImpl = class {
-  constructor() {
-    this._globalLevels = /* @__PURE__ */ new Set([Level.INFO, Level.ERROR, Level.WARN]);
-    this._modules = /* @__PURE__ */ new Map();
-    this.ignoreAttr = Option.Some(/^_/);
-    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;
-  }
-  setIgnoreAttr(re) {
-    this.ignoreAttr = Option.From(re);
-  }
-  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(
-      Level.DEBUG,
-      (p) => {
-        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, Level.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, lvs) {
   if (Array.isArray(value)) {
@@ -2504,7 +2604,7 @@ var LoggerImpl = class _LoggerImpl {
       params = {};
     }
     if (!params.sys) {
-      this._sys = WebSysAbstraction();
+      this._sys = BasicSysAbstractionFactory();
     } else {
       this._sys = params.sys;
     }
@@ -2522,18 +2622,7 @@ var LoggerImpl = class _LoggerImpl {
       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 || rt.isCFWorker) {
-            stream = this._sys.Stdout();
-          } else {
-            throw new Error("No output defined for runtime");
-          }
-        }
-        this._logWriter = new LogWriterStream(stream);
+        this._logWriter = new LogWriterStream(this._sys.Stdout());
       } else {
         this._logWriter = new LogWriterStream(params.out);
       }
@@ -3475,6 +3564,39 @@ function JSONEnDecoderSingleton(txtEnde) {
   return jsonEnDecoder;
 }
 
+// src/coerce-binary.ts
+async function top_uint8(input) {
+  if (input instanceof Blob) {
+    return new Uint8Array(await input.arrayBuffer());
+  }
+  return to_uint8(input);
+}
+function to_uint8(input, encoder) {
+  if (typeof input === "string") {
+    return (encoder != null ? encoder : new TextEncoder()).encode(input);
+  }
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  return new Uint8Array(input);
+}
+function to_blob(input, encoder) {
+  if (input instanceof Blob) {
+    return input;
+  }
+  return new Blob([to_uint8(input, encoder)]);
+}
+function to_arraybuf(input, encoder) {
+  if (input instanceof ArrayBuffer) {
+    return input;
+  }
+  const u8 = to_uint8(input, encoder);
+  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
+}
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -3713,7 +3835,9 @@ function UInt8ArrayEqual(a, b) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseBasicSysAbstraction,
   BaseSysAbstraction,
+  BasicSysAbstractionFactory,
   BuildURI,
   ConstTime,
   EnvImpl,
@@ -3762,7 +3886,8 @@ function UInt8ArrayEqual(a, b) {
   TxtEnDecoderSingleton,
   URI,
   VERSION,
-  WrapperSysAbstraction,
+  WrapperBasicSysAbstraction,
+  WrapperRuntimeSysAbstraction,
   YAMLFormatter,
   asyncLogValue,
   bin2string,
@@ -3778,6 +3903,10 @@ function UInt8ArrayEqual(a, b) {
   registerEnvAction,
   runtimeFn,
   toCryptoRuntime,
+  to_arraybuf,
+  to_blob,
+  to_uint8,
+  top_uint8,
   utils
 });
 //# sourceMappingURL=index.cjs.map