@adviser/cement 0.3.0 → 0.3.2

package/chunk-DZPKZQIT.js

@@ -0,0 +1,1182 @@
+import {
+  Utf8EnDecoderSingleton,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-PPS4L4VW.js";
+
+// src/sys-abstraction.ts
+var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
+  TimeMode2["REAL"] = "real";
+  TimeMode2["CONST"] = "const";
+  TimeMode2["STEP"] = "step";
+  return TimeMode2;
+})(TimeMode || {});
+var RandomMode = /* @__PURE__ */ ((RandomMode2) => {
+  RandomMode2["CONST"] = "const";
+  RandomMode2["STEP"] = "step";
+  RandomMode2["RANDOM"] = "random";
+  return RandomMode2;
+})(RandomMode || {});
+var IDMode = /* @__PURE__ */ ((IDMode2) => {
+  IDMode2["UUID"] = "uuid";
+  IDMode2["CONST"] = "const";
+  IDMode2["STEP"] = "step";
+  return IDMode2;
+})(IDMode || {});
+function String2TimeMode(s) {
+  switch (s == null ? void 0 : s.toLowerCase()) {
+    case "real":
+      return "real" /* REAL */;
+    case "const":
+      return "const" /* CONST */;
+    case "step":
+      return "step" /* STEP */;
+    default:
+      return "real" /* REAL */;
+  }
+}
+
+// src/time.ts
+var Time = class {
+  TimeSince(start) {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+};
+var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
+  TimeUnits2[TimeUnits2["Microsecond"] = 1] = "Microsecond";
+  TimeUnits2[TimeUnits2["Second"] = 1e3] = "Second";
+  TimeUnits2[TimeUnits2["Minute"] = 6e4] = "Minute";
+  TimeUnits2[TimeUnits2["Hour"] = 36e5] = "Hour";
+  return TimeUnits2;
+})(TimeUnits || {});
+
+// src/base-sys-abstraction.ts
+var SysTime = class extends Time {
+  Now() {
+    return /* @__PURE__ */ new Date();
+  }
+  Sleep(duration) {
+    return new Promise((resolve2) => {
+      setTimeout(() => {
+        resolve2();
+      }, duration);
+    });
+  }
+};
+var ConstTime = class extends Time {
+  Now() {
+    return new Date(2021, 1, 1, 0, 0, 0, 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Sleep(duration) {
+    return Promise.resolve();
+  }
+};
+var StepTime = class extends Time {
+  constructor() {
+    super();
+    this._step = new ConstTime().Now();
+    this._start = this._step;
+  }
+  Now(steps = 1) {
+    for (let i = 0; steps > 0 && i < steps; i++) {
+      this._step = new Date(this._step.getTime() + 1e3);
+    }
+    if (steps < 1) {
+      this._step = new Date(this._start.getTime() + steps * -1e3);
+    }
+    return this._step;
+  }
+  Sleep(duration) {
+    this._step = new Date(this._step.getTime() + duration);
+    return Promise.resolve();
+  }
+};
+function TimeFactory(timeMode) {
+  switch (timeMode) {
+    case "real" /* REAL */:
+      return new SysTime();
+    case "const" /* CONST */:
+      return new ConstTime();
+    case "step" /* STEP */:
+      return new StepTime();
+  }
+  return new SysTime();
+}
+var RandomService = class {
+  constructor(mode) {
+    this._step = 0;
+    this._mode = mode;
+  }
+  Random0ToValue(value) {
+    switch (this._mode) {
+      case "const" /* CONST */:
+        return 0.5 * value;
+      case "step" /* STEP */:
+        this._step += 1e-4;
+        return this._step * value;
+      case "random" /* RANDOM */:
+        return Math.random() * value;
+      default:
+        throw new Error("Unknown RandomMode");
+    }
+  }
+};
+var IdService = class {
+  constructor(mode) {
+    this._step = 0;
+    if (!mode) {
+      mode = "uuid" /* UUID */;
+    }
+    this._mode = mode;
+  }
+  NextId() {
+    switch (this._mode) {
+      case "uuid" /* UUID */:
+        return crypto.randomUUID();
+      case "const" /* CONST */:
+        return "VeryUniqueID";
+      case "step" /* STEP */:
+        return `STEPId-${this._step++}`;
+      default:
+        throw new Error("Unknown IDMode");
+    }
+  }
+};
+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);
+  });
+}
+function CFWriteableStream(writeFn) {
+  const ts = new TransformStream();
+  consumeReadableStream(ts.readable.getReader(), writeFn);
+  return ts.writable;
+}
+var BaseSysAbstraction = class {
+  constructor(params) {
+    this._time = new SysTime();
+    this._idService = new IdService();
+    this._randomService = new RandomService("random" /* RANDOM */);
+    this._fileSystem = params.FileSystem;
+    this._systemService = params.SystemService;
+    this._txtEnDe = params.TxtEnDecoder;
+    const decoder = this._txtEnDe;
+    this._stdout = CFWriteableStream(async (chunk) => {
+      const decoded = decoder.decode(chunk);
+      console.log(decoded.trimEnd());
+    });
+    this._stderr = CFWriteableStream(async (chunk) => {
+      const decoded = decoder.decode(chunk);
+      console.error(decoded.trimEnd());
+    });
+  }
+};
+var WrapperSysAbstraction = class {
+  constructor(base, params) {
+    this._time = base._time;
+    this._stdout = base._stdout;
+    this._stderr = base._stderr;
+    this._idService = base._idService;
+    this._randomService = base._randomService;
+    this._fileSystem = base._fileSystem;
+    this._systemService = base._systemService;
+    if (params) {
+      if (params.TimeMode) {
+        this._time = TimeFactory(params.TimeMode);
+      }
+      if (params.Stdout) {
+        this._stdout = params.Stdout;
+      }
+      if (params.Stderr) {
+        this._stderr = params.Stderr;
+      }
+      if (params.IdMode) {
+        this._idService = new IdService(params.IdMode);
+      }
+      if (params.RandomMode) {
+        this._randomService = new RandomService(params.RandomMode);
+      }
+      if (params.FileSystem) {
+        this._fileSystem = params.FileSystem;
+      }
+      if (params.SystemService) {
+        this._systemService = params.SystemService;
+      }
+    }
+  }
+  Time() {
+    return this._time;
+  }
+  NextId() {
+    return this._idService.NextId();
+  }
+  Random0ToValue(value) {
+    return this._randomService.Random0ToValue(value);
+  }
+  Stdout() {
+    return this._stdout;
+  }
+  Stderr() {
+    return this._stderr;
+  }
+  System() {
+    return this._systemService;
+  }
+  FileSystem() {
+    return this._fileSystem;
+  }
+};
+
+// src/future.ts
+var _promise, _resolveFn, _rejectFn;
+var Future = class {
+  constructor() {
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolveFn, () => {
+      throw new Error("This Promise is not working as expected.");
+    });
+    __privateAdd(this, _rejectFn, () => {
+      throw new Error("This Promise is not working as expected.");
+    });
+    __privateSet(this, _promise, new Promise((resolve2, reject) => {
+      __privateSet(this, _resolveFn, resolve2);
+      __privateSet(this, _rejectFn, reject);
+    }));
+  }
+  async asPromise() {
+    return __privateGet(this, _promise);
+  }
+  resolve(value) {
+    __privateGet(this, _resolveFn).call(this, value);
+  }
+  reject(reason) {
+    __privateGet(this, _rejectFn).call(this, reason);
+  }
+};
+_promise = new WeakMap();
+_resolveFn = new WeakMap();
+_rejectFn = new WeakMap();
+
+// src/resolve-once.ts
+var ResolveSeq = class {
+  constructor(ctx) {
+    this._seqFutures = [];
+    this.ctx = ctx;
+  }
+  reset() {
+  }
+  async _step(item) {
+    if (!item) {
+      return;
+    }
+    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
+      this._seqFutures.shift();
+      this._step(this._seqFutures[0]);
+    });
+  }
+  async add(fn, id) {
+    const future = new Future();
+    this._seqFutures.push({ future, fn, id });
+    if (this._seqFutures.length === 1) {
+      this._step(this._seqFutures[0]);
+    }
+    return future.asPromise();
+  }
+};
+var ResolveOnce = class {
+  constructor(ctx) {
+    this._onceDone = false;
+    this._onceFutures = [];
+    this._onceOk = false;
+    this._isPromise = false;
+    this.ctx = ctx;
+  }
+  get ready() {
+    return this._onceDone;
+  }
+  reset() {
+    this._onceDone = false;
+    this._onceOk = false;
+    this._onceValue = void 0;
+    this._onceError = void 0;
+    this._onceFutures.length = 0;
+  }
+  // T extends Option<infer U> ? U : T
+  once(fn) {
+    if (this._onceDone) {
+      if (this._onceError) {
+        if (this._isPromise) {
+          return Promise.reject(this._onceError);
+        } else {
+          throw this._onceError;
+        }
+      }
+      if (this._onceOk) {
+        if (this._isPromise) {
+          return Promise.resolve(this._onceValue);
+        } else {
+          return this._onceValue;
+        }
+      }
+      throw new Error("ResolveOnce.once impossible");
+    }
+    const future = new Future();
+    this._onceFutures.push(future);
+    if (this._onceFutures.length === 1) {
+      const okFn = (value) => {
+        this._onceValue = value;
+        this._onceOk = true;
+        this._onceDone = true;
+        if (this._isPromise) {
+          this._onceFutures.forEach((f) => f.resolve(this._onceValue));
+        }
+        this._onceFutures.length = 0;
+      };
+      const catchFn = (e) => {
+        this._onceError = e;
+        this._onceOk = false;
+        this._onceValue = void 0;
+        this._onceDone = true;
+        if (this._isPromise) {
+          this._onceFutures.forEach((f) => f.reject(this._onceError));
+        }
+        this._onceFutures.length = 0;
+      };
+      try {
+        const ret = fn(this.ctx);
+        if (typeof ret.then === "function") {
+          this._isPromise = true;
+          ret.then(okFn).catch(catchFn);
+        } else {
+          okFn(ret);
+        }
+      } catch (e) {
+        catchFn(e);
+      }
+    }
+    if (this._isPromise) {
+      return future.asPromise();
+    } else {
+      return this.once(fn);
+    }
+  }
+};
+var Keyed = class {
+  constructor(factory) {
+    this._map = /* @__PURE__ */ new Map();
+    this.factory = factory;
+  }
+  async asyncGet(key) {
+    return this.get(await key());
+  }
+  get(key) {
+    if (typeof key === "function") {
+      key = key();
+    }
+    let keyed = this._map.get(key);
+    if (!keyed) {
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
+    }
+    return keyed;
+  }
+  unget(key) {
+    const keyed = this._map.get(key);
+    keyed == null ? void 0 : keyed.reset();
+    this._map.delete(key);
+  }
+  reset() {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
+  }
+};
+var KeyedResolvOnce = class extends Keyed {
+  constructor() {
+    super((key) => new ResolveOnce(key));
+  }
+};
+var KeyedResolvSeq = class extends Keyed {
+  constructor() {
+    super((key) => new ResolveSeq(key));
+  }
+};
+
+// src/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 = 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-file-service.ts
+import * as path from "node:path";
+var Deno = globalThis.Deno;
+var DenoFileService = class {
+  constructor(baseDir = Deno.cwd(), txtEnde = Utf8EnDecoderSingleton()) {
+    this.baseDir = this.abs(baseDir);
+    this.txtEnde = txtEnde;
+  }
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+  async readFileString(fname) {
+    return this.txtEnde.decode(await Deno.readFile(fname));
+  }
+  dirname(fname) {
+    return path.dirname(fname);
+  }
+  basename(fname) {
+    return path.basename(fname);
+  }
+  join(...paths) {
+    return path.join(...paths);
+  }
+  relative(from, to) {
+    if (to === void 0) {
+      to = from;
+      from = Deno.cwd();
+    }
+    const ret = path.relative(from, to);
+    return ret;
+  }
+  abs(fname) {
+    if (path.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = Deno.cwd();
+      return path.resolve(cwd, fname);
+    }
+  }
+  isAbsolute(fname) {
+    return path.isAbsolute(fname);
+  }
+  async writeFileString(fname, content, ende = Utf8EnDecoderSingleton()) {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+  async create(fname) {
+    let oName = fname;
+    if (!path.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+    const base = path.dirname(oName);
+    await Deno.mkdir(base, { recursive: true });
+    const out = await Deno.open(oName, {
+      write: true,
+      create: true,
+      truncate: true
+    });
+    return {
+      name: oName,
+      stream: out
+    };
+  }
+};
+
+// src/node/node-file-service.ts
+import path2 from "node:path";
+import fs from "node:fs";
+import process from "node:process";
+var NodeFileService = class {
+  constructor(baseDir = process.cwd()) {
+    this.baseDir = this.abs(baseDir);
+  }
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+  readFileString(fname) {
+    return fs.promises.readFile(fname, { encoding: "utf-8" });
+  }
+  dirname(fname) {
+    return path2.dirname(fname);
+  }
+  basename(fname) {
+    return path2.basename(fname);
+  }
+  join(...paths) {
+    return path2.join(...paths);
+  }
+  relative(from, to) {
+    if (to === void 0) {
+      to = from;
+      from = process.cwd();
+    }
+    const ret = path2.relative(from, to);
+    return ret;
+  }
+  abs(fname) {
+    if (path2.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = process.cwd();
+      return path2.resolve(cwd, fname);
+    }
+  }
+  isAbsolute(fname) {
+    return path2.isAbsolute(fname);
+  }
+  async writeFileString(fname, content, ende = Utf8EnDecoderSingleton()) {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+  async create(fname) {
+    let oName = fname;
+    if (!path2.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+    const base = path2.dirname(oName);
+    await fs.promises.mkdir(base, { recursive: true });
+    const out = fs.createWriteStream(oName);
+    return {
+      name: oName,
+      stream: new WritableStream({
+        write(chunk) {
+          out.write(chunk);
+        },
+        close() {
+          out.close();
+        },
+        abort() {
+          throw new Error("not implemented");
+        }
+      })
+    };
+  }
+};
+
+// src/node/node-sys-abstraction.ts
+import process2 from "node:process";
+var once = 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 once.once(() => new _NodeEnvActions(opts));
+  }
+  register(env) {
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
+    }
+    return env;
+  }
+  active() {
+    return runtimeFn().isNodeIsh;
+  }
+  keys() {
+    return Object.keys(this._env);
+  }
+  get(key) {
+    return this._env[key];
+  }
+  set(key, value) {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key) {
+    delete this._env[key];
+  }
+};
+_node = new WeakMap();
+var NodeEnvActions = _NodeEnvActions;
+var NodeExitServiceImpl = class {
+  constructor() {
+    this._exitHandlers = [];
+    this.invoked = false;
+    this._handleExit = async () => {
+      if (this.invoked) {
+        return;
+      }
+      this.invoked = true;
+      for (const h of this._exitHandlers) {
+        try {
+          const ret = h.hdl();
+          if (typeof ret.then === "function") {
+            await ret;
+          }
+        } finally {
+        }
+      }
+    };
+    process2.on("unhandledRejection", (reason, p) => {
+      this.exit(19);
+    });
+    process2.on("uncaughtException", (error) => {
+      this.exit(18);
+    });
+    process2.on("close", () => {
+      this.exit(0);
+    });
+    process2.on("exit", () => {
+      this.exit(0);
+    });
+    process2.on("SIGQUIT", () => {
+      this.exit(3);
+    });
+    process2.on("SIGINT", () => {
+      this.exit(2);
+    });
+    process2.on("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  injectExitHandlers(hdls) {
+    this._exitHandlers = hdls;
+  }
+  exit(code) {
+    this._handleExit().then(() => {
+      process2.exit(code);
+    }).catch((err) => {
+      console.error("ExitService: failed to handle exit", err);
+      process2.exit(code);
+    });
+  }
+};
+var _NodeSystemService = class _NodeSystemService {
+  constructor() {
+    this._exitService = new NodeExitServiceImpl();
+    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return process2.argv;
+  }
+  OnExit(hdl) {
+    const id = crypto.randomUUID();
+    _NodeSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = _NodeSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        _NodeSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+  Exit(code) {
+    this._exitService.exit(code);
+  }
+};
+_NodeSystemService._exitHandlers = [];
+var NodeSystemService = _NodeSystemService;
+var my = void 0;
+function NodeSysAbstraction(param) {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new NodeFileService(),
+      SystemService: new NodeSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}
+
+// src/web/web-sys-abstraction.ts
+var once2 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once2.once(() => new _BrowserEnvActions(opts));
+  }
+  get(key) {
+    return this.env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key) {
+    this.env.delete(key);
+  }
+  keys() {
+    return Array.from(this.env.keys());
+  }
+  active() {
+    return true;
+  }
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
+  }
+};
+var WebFileService = class {
+  get baseDir() {
+    throw new Error("basedir-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  create(fname) {
+    throw new Error("create-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  readFileString(fname) {
+    throw new Error("readFileString-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  writeFileString(fname, content) {
+    throw new Error("writeFileString-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abs(fname) {
+    throw new Error("abs-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  join(...paths) {
+    throw new Error("join-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  relative(from, to) {
+    throw new Error("relative-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dirname(fname) {
+    throw new Error("dirname-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  basename(fname) {
+    throw new Error("basename-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  nodeImport(fname) {
+    throw new Error("nodeImport-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isAbsolute(fname) {
+    throw new Error("isAbsolute-Method not implemented.");
+  }
+};
+var WebSystemService = class {
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    throw new Error("Args-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  OnExit(hdl) {
+    throw new Error("OnExit-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Exit(code) {
+    throw new Error("Exit-Method not implemented.");
+  }
+};
+var my2 = void 0;
+function WebSysAbstraction(param) {
+  if (!my2) {
+    my2 = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new WebFileService(),
+      SystemService: new WebSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my2, param);
+}
+
+// src/cf/cf-sys-abstraction.ts
+var once3 = new ResolveOnce();
+var CFEnvActions = class _CFEnvActions {
+  static new(opts) {
+    return once3.once(() => new _CFEnvActions(opts));
+  }
+  static inject(o) {
+    var _a;
+    const env = _CFEnvActions.new({});
+    for (const key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        (_a = env.env) == null ? void 0 : _a.set(key, value);
+      }
+    }
+  }
+  constructor(env) {
+    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
+  }
+  active() {
+    return runtimeFn().isCFWorker;
+  }
+  register(env) {
+    this.env = env;
+    return env;
+  }
+  get(key) {
+    return this.cfEnv.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
+  }
+  delete(key) {
+    this.cfEnv.delete(key);
+  }
+  keys() {
+    return Array.from(this.cfEnv.keys());
+  }
+};
+var CFSystemService = class {
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    throw new Error("Args-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  OnExit(hdl) {
+    throw new Error("OnExit-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Exit(code) {
+    throw new Error("Exit-Method not implemented.");
+  }
+};
+var my3 = void 0;
+function CFSysAbstraction(param) {
+  if (!my3) {
+    my3 = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new WebFileService(),
+      SystemService: new CFSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my3, param);
+}
+
+// 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");
+  }
+  return _envFactories.get(found.id).once(() => {
+    const action = found.fn(opts);
+    const ret = new EnvImpl2(action, opts);
+    action.register(ret);
+    return ret;
+  });
+}
+var EnvImpl2 = class {
+  constructor(map, opts = {}) {
+    this._onSet = [];
+    this._map = map;
+    this._updatePresets(opts.presetEnv);
+  }
+  _updatePresets(presetEnv) {
+    if (!presetEnv) {
+      return;
+    }
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
+    }
+  }
+  _applyOnSet(onSet, key, value) {
+    onSet.forEach((item) => {
+      let keys = [];
+      if (key) {
+        keys = [key];
+      } else {
+        keys = this._map.keys();
+      }
+      keys.filter((k) => {
+        if (item.filter.size === 0) {
+          return true;
+        }
+        if (item.filter.has(k)) {
+          return true;
+        }
+        return false;
+      }).forEach((k) => {
+        let v;
+        if (!key && !value) {
+          v = this._map.get(k);
+        } else if (key && !value) {
+          v = void 0;
+        } else {
+          v = value;
+        }
+        item.fn(k, v);
+      });
+    });
+  }
+  keys() {
+    return this._map.keys();
+  }
+  // filter is not set all sets passed
+  onSet(fn, ...filter) {
+    const item = { filter: new Set(filter), fn };
+    this._onSet.push(item);
+    this._applyOnSet([item]);
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  set(key, value) {
+    if (!value) {
+      return;
+    }
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
+  }
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
+  }
+};
+
+// src/deno/deno-sys-abstraction.ts
+var Deno2 = globalThis.Deno;
+var once4 = new ResolveOnce();
+var _deno;
+var _DenoEnvActions = class _DenoEnvActions {
+  constructor(opts) {
+    __privateAdd(this, _deno, globalThis);
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once4.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) || "");
+    }
+    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);
+    }
+  }
+  delete(key) {
+    this._env.delete(key);
+  }
+};
+_deno = new WeakMap();
+var DenoEnvActions = _DenoEnvActions;
+var DenoExitServiceImpl = class {
+  constructor() {
+    this._exitHandlers = [];
+    this.invoked = false;
+    this._handleExit = async () => {
+      if (this.invoked) {
+        return;
+      }
+      this.invoked = true;
+      for (const h of this._exitHandlers) {
+        try {
+          const ret = h.hdl();
+          if (typeof ret.then === "function") {
+            await ret;
+          }
+        } finally {
+        }
+      }
+    };
+    globalThis.addEventListener("unhandledrejection", (e) => {
+      e.preventDefault();
+      this.exit(19);
+    });
+    globalThis.addEventListener("error", () => {
+      this.exit(19);
+    });
+    globalThis.addEventListener("uncaughtException", () => {
+      this.exit(19);
+    });
+    globalThis.addEventListener("unload", () => {
+      this.exit(0);
+    });
+    Deno2.addSignalListener("SIGQUIT", () => {
+      this.exit(3);
+    });
+    Deno2.addSignalListener("SIGINT", () => {
+      this.exit(2);
+    });
+    Deno2.addSignalListener("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  injectExitHandlers(hdls) {
+    this._exitHandlers = hdls;
+  }
+  exit(code) {
+    this._handleExit().then(() => {
+      Deno2.exit(code);
+    }).catch((err) => {
+      console.error("ExitService: failed to handle exit", err);
+      Deno2.exit(code);
+    });
+  }
+};
+var _DenoSystemService = class _DenoSystemService {
+  constructor() {
+    this._exitService = new DenoExitServiceImpl();
+    this._exitService.injectExitHandlers(_DenoSystemService._exitHandlers);
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return Deno2.args;
+  }
+  OnExit(hdl) {
+    const id = crypto.randomUUID();
+    _DenoSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = _DenoSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        _DenoSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+  Exit(code) {
+    this._exitService.exit(code);
+  }
+};
+_DenoSystemService._exitHandlers = [];
+var DenoSystemService = _DenoSystemService;
+var my4 = void 0;
+function DenoSysAbstraction(param) {
+  if (!my4) {
+    my4 = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new DenoFileService(),
+      SystemService: new DenoSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my4, param);
+}
+
+export {
+  TimeMode,
+  RandomMode,
+  IDMode,
+  String2TimeMode,
+  Time,
+  TimeUnits,
+  SysTime,
+  ConstTime,
+  StepTime,
+  TimeFactory,
+  RandomService,
+  IdService,
+  BaseSysAbstraction,
+  WrapperSysAbstraction,
+  Future,
+  ResolveSeq,
+  ResolveOnce,
+  Keyed,
+  KeyedResolvOnce,
+  KeyedResolvSeq,
+  runtimeFn,
+  DenoFileService,
+  DenoEnvActions,
+  DenoExitServiceImpl,
+  DenoSystemService,
+  DenoSysAbstraction,
+  NodeFileService,
+  NodeEnvActions,
+  NodeExitServiceImpl,
+  NodeSystemService,
+  NodeSysAbstraction,
+  CFEnvActions,
+  CFSystemService,
+  CFSysAbstraction,
+  registerEnvAction,
+  envFactory,
+  EnvImpl2 as EnvImpl,
+  BrowserEnvActions,
+  WebFileService,
+  WebSysAbstraction
+};
+//# sourceMappingURL=chunk-DZPKZQIT.js.map