@adviser/cement 0.0.0-jsr-t1

package/node/index.cjs

@@ -0,0 +1,924 @@
+"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/node/index.ts
+var node_exports = {};
+__export(node_exports, {
+  DenoExitServiceImpl: () => DenoExitServiceImpl,
+  DenoSysAbstraction: () => DenoSysAbstraction,
+  DenoSystemService: () => DenoSystemService,
+  MockFileService: () => MockFileService,
+  NodeExitServiceImpl: () => NodeExitServiceImpl,
+  NodeFileService: () => NodeFileService,
+  NodeSysAbstraction: () => NodeSysAbstraction,
+  NodeSystemService: () => NodeSystemService
+});
+module.exports = __toCommonJS(node_exports);
+
+// 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-file-service.ts
+var NodeFileService = class {
+  constructor(baseDir = import_node_process.default.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 import_node_fs.default.promises.readFile(fname, { encoding: "utf-8" });
+  }
+  dirname(fname) {
+    return import_node_path.default.dirname(fname);
+  }
+  basename(fname) {
+    return import_node_path.default.basename(fname);
+  }
+  join(...paths) {
+    return import_node_path.default.join(...paths);
+  }
+  relative(from, to) {
+    if (to === void 0) {
+      to = from;
+      from = import_node_process.default.cwd();
+    }
+    const ret = import_node_path.default.relative(from, to);
+    return ret;
+  }
+  abs(fname) {
+    if (import_node_path.default.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = import_node_process.default.cwd();
+      return import_node_path.default.resolve(cwd, fname);
+    }
+  }
+  isAbsolute(fname) {
+    return import_node_path.default.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 (!import_node_path.default.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+    const base = import_node_path.default.dirname(oName);
+    await import_node_fs.default.promises.mkdir(base, { recursive: true });
+    const out = import_node_fs.default.createWriteStream(oName);
+    return {
+      name: oName,
+      stream: new WritableStream({
+        write(chunk) {
+          out.write(chunk);
+        },
+        close() {
+          out.close();
+        },
+        abort() {
+          throw new Error("not implemented");
+        }
+      })
+    };
+  }
+};
+
+// 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");
+    }
+  }
+};
+var BaseSysAbstraction = class {
+  constructor(params) {
+    this._time = new SysTime();
+    this._idService = new IdService();
+    this._randomService = new RandomService("random" /* RANDOM */);
+    this._fileSystem = params.FileSystem;
+    this._systemService = params.SystemService;
+    this._txtEnDe = params.TxtEnDecoder;
+    const decoder2 = this._txtEnDe;
+    this._stdout = new WritableStream({
+      write(chunk) {
+        return new Promise((resolve2) => {
+          const decoded = decoder2.decode(chunk);
+          console.log(decoded.trimEnd());
+          resolve2();
+        });
+      }
+    });
+    this._stderr = new WritableStream({
+      write(chunk) {
+        return new Promise((resolve2) => {
+          const decoded = decoder2.decode(chunk);
+          console.error(decoded.trimEnd());
+          resolve2();
+        });
+      }
+    });
+  }
+};
+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);
+    }
+  }
+};
+
+// src/sys-env.ts
+var _node;
+var NodeEnvActions = class {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+  constructor(opts) {
+    __privateAdd(this, _node, globalThis);
+    this._env = this.active() ? __privateGet(this, _node).process.env : {};
+  }
+  register(env) {
+    return env;
+  }
+  active() {
+    return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
+  }
+  keys() {
+    return Object.keys(this._env);
+  }
+  get(key) {
+    return this._env[key];
+  }
+  set(key, value) {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key) {
+    delete this._env[key];
+  }
+};
+_node = new WeakMap();
+var _deno;
+var DenoEnvActions = class {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+  constructor(opts) {
+    __privateAdd(this, _deno, globalThis);
+  }
+  get _env() {
+    return __privateGet(this, _deno).Deno.env;
+  }
+  register(env) {
+    return env;
+  }
+  active() {
+    return typeof __privateGet(this, _deno) === "object" && typeof __privateGet(this, _deno).Deno === "object" && typeof __privateGet(this, _deno).Deno.env === "object";
+  }
+  keys() {
+    return Array.from(this._env.keys());
+  }
+  get(key) {
+    return this._env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this._env.set(key, value);
+    }
+  }
+  delete(key) {
+    this._env.delete(key);
+  }
+};
+_deno = new WeakMap();
+var BrowserEnvActions = class {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
+  }
+  get(key) {
+    return this.env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key) {
+    this.env.delete(key);
+  }
+  keys() {
+    return Array.from(this.env.keys());
+  }
+  active() {
+    return true;
+  }
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
+  }
+};
+var _envFactory = new ResolveOnce();
+function envFactory(opts = {}) {
+  return _envFactory.once(() => {
+    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.active());
+    if (!found) {
+      throw new Error("SysContainer:envFactory: no env available");
+    }
+    const ret = new EnvImpl(found, opts);
+    found.register(ret);
+    return ret;
+  });
+}
+var EnvImpl = class {
+  constructor(map, opts = {}) {
+    this._onSet = [];
+    this._map = map;
+    this._updatePresets(opts.presetEnv);
+  }
+  _updatePresets(presetEnv) {
+    if (!presetEnv) {
+      return;
+    }
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
+    }
+  }
+  _applyOnSet(onSet, key, value) {
+    onSet.forEach((item) => {
+      let keys = [];
+      if (key) {
+        keys = [key];
+      } else {
+        keys = this._map.keys();
+      }
+      keys.filter((k) => {
+        if (item.filter.size === 0) {
+          return true;
+        }
+        if (item.filter.has(k)) {
+          return true;
+        }
+        return false;
+      }).forEach((k) => {
+        let v;
+        if (!key && !value) {
+          v = this._map.get(k);
+        } else if (key && !value) {
+          v = void 0;
+        } else {
+          v = value;
+        }
+        item.fn(k, v);
+      });
+    });
+  }
+  keys() {
+    return this._map.keys();
+  }
+  // filter is not set all sets passed
+  onSet(fn, ...filter) {
+    const item = { filter: new Set(filter), fn };
+    this._onSet.push(item);
+    this._applyOnSet([item]);
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  set(key, value) {
+    if (!value) {
+      return;
+    }
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
+  }
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
+  }
+};
+
+// src/node/node-sys-abstraction.ts
+var import_node_process2 = __toESM(require("process"), 1);
+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;
+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/node/deno-sys-abstraction.ts
+var process3 = __toESM(require("process"), 1);
+
+// src/node/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/node/deno-sys-abstraction.ts
+var Deno2 = globalThis.Deno;
+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 process3.argv;
+  }
+  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 my2 = void 0;
+function DenoSysAbstraction(param) {
+  if (!my2) {
+    my2 = new BaseSysAbstraction({
+      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      FileSystem: new DenoFileService(),
+      SystemService: new DenoSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my2, param);
+}
+
+// src/node/mock-file-service.ts
+var MockFileService = class extends NodeFileService {
+  constructor() {
+    super(...arguments);
+    this.files = {};
+  }
+  // override abs(fname: string): string {
+  //   return this.join("/mock/", fname);
+  // }
+  async create(fname) {
+    let oName = fname;
+    if (!this.isAbsolute(fname)) {
+      oName = await this.abs(fname);
+    }
+    const fc = {
+      name: oName,
+      content: ""
+    };
+    this.files[oName] = fc;
+    this.files[fname] = fc;
+    const decoder2 = new TextDecoder();
+    return {
+      name: oName,
+      stream: new WritableStream({
+        write(chunk) {
+          fc.content = fc.content + decoder2.decode(chunk);
+        },
+        close() {
+        },
+        abort() {
+          throw new Error("not implemented");
+        }
+      })
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DenoExitServiceImpl,
+  DenoSysAbstraction,
+  DenoSystemService,
+  MockFileService,
+  NodeExitServiceImpl,
+  NodeFileService,
+  NodeSysAbstraction,
+  NodeSystemService
+});
+//# sourceMappingURL=index.cjs.map