@adviser/cement 0.3.1 → 0.3.2

package/deno/index.cjs

@@ -0,0 +1,940 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/deno/index.ts
+var deno_exports = {};
+__export(deno_exports, {
+  DenoEnvActions: () => DenoEnvActions,
+  DenoExitServiceImpl: () => DenoExitServiceImpl,
+  DenoFileService: () => DenoFileService,
+  DenoSysAbstraction: () => DenoSysAbstraction,
+  DenoSystemService: () => DenoSystemService
+});
+module.exports = __toCommonJS(deno_exports);
+
+// src/time.ts
+var Time = class {
+  TimeSince(start) {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+};
+
+// 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 decoder2 = this._txtEnDe;
+    this._stdout = CFWriteableStream(async (chunk) => {
+      const decoded = decoder2.decode(chunk);
+      console.log(decoded.trimEnd());
+    });
+    this._stderr = CFWriteableStream(async (chunk) => {
+      const decoded = decoder2.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 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));
+  }
+};
+
+// 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/node/node-file-service.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_process = __toESM(require("process"), 1);
+
+// src/txt-en-decoder.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Utf8EnDecoder = class {
+  encode(str) {
+    return encoder.encode(str);
+  }
+  decode(data) {
+    return decoder.decode(data);
+  }
+};
+var utf8EnDecoder = new Utf8EnDecoder();
+function Utf8EnDecoderSingleton() {
+  return utf8EnDecoder;
+}
+
+// src/node/node-sys-abstraction.ts
+var import_node_process2 = __toESM(require("process"), 1);
+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 {
+        }
+      }
+    };
+    import_node_process2.default.on("unhandledRejection", (reason, p) => {
+      this.exit(19);
+    });
+    import_node_process2.default.on("uncaughtException", (error) => {
+      this.exit(18);
+    });
+    import_node_process2.default.on("close", () => {
+      this.exit(0);
+    });
+    import_node_process2.default.on("exit", () => {
+      this.exit(0);
+    });
+    import_node_process2.default.on("SIGQUIT", () => {
+      this.exit(3);
+    });
+    import_node_process2.default.on("SIGINT", () => {
+      this.exit(2);
+    });
+    import_node_process2.default.on("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  injectExitHandlers(hdls) {
+    this._exitHandlers = hdls;
+  }
+  exit(code) {
+    this._handleExit().then(() => {
+      import_node_process2.default.exit(code);
+    }).catch((err) => {
+      console.error("ExitService: failed to handle exit", err);
+      import_node_process2.default.exit(code);
+    });
+  }
+};
+var _NodeSystemService = class _NodeSystemService {
+  constructor() {
+    this._exitService = new NodeExitServiceImpl();
+    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return import_node_process2.default.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;
+
+// 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;
+  }
+};
+
+// 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());
+  }
+};
+
+// 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) }
+];
+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-file-service.ts
+var path2 = __toESM(require("path"), 1);
+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 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 = Deno.cwd();
+    }
+    const ret = path2.relative(from, to);
+    return ret;
+  }
+  abs(fname) {
+    if (path2.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = Deno.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 Deno.mkdir(base, { recursive: true });
+    const out = await Deno.open(oName, {
+      write: true,
+      create: true,
+      truncate: true
+    });
+    return {
+      name: oName,
+      stream: out
+    };
+  }
+};
+
+// 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 my = void 0;
+function DenoSysAbstraction(param) {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new DenoFileService(),
+      SystemService: new DenoSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DenoEnvActions,
+  DenoExitServiceImpl,
+  DenoFileService,
+  DenoSysAbstraction,
+  DenoSystemService
+});
+//# sourceMappingURL=index.cjs.map