@adviser/cement 0.4.7 → 0.4.9

package/deno/index.cjs

@@ -1,1280 +0,0 @@
-"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, {
-  DenoExitServiceImpl: () => DenoExitServiceImpl,
-  DenoFileService: () => DenoFileService,
-  DenoSysAbstraction: () => DenoSysAbstraction,
-  DenoSystemService: () => DenoSystemService
-});
-module.exports = __toCommonJS(deno_exports);
-
-// 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
-  };
-}
-
-// 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"
-};
-
-// 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/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/lru-map-set.ts
-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;
-          }
-        }
-        for (const key of toDelete) {
-          this._map.delete(key);
-        }
-      }
-    }
-  }
-  has(key) {
-    return this._map.has(key);
-  }
-  get size() {
-    return this._map.size;
-  }
-  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) {
-    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);
-    }
-  }
-  delete(key) {
-    this._map.delete(key);
-  }
-  clear() {
-    this._map.clear();
-  }
-  forEach(callbackfn) {
-    this._map.forEach(callbackfn);
-  }
-  entries() {
-    return this._map.entries();
-  }
-  // *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/result.ts
-var Result = class _Result {
-  static Ok(t) {
-    return new ResultOK(t);
-  }
-  static Err(t) {
-    if (typeof t === "string") {
-      return new ResultError(new Error(t));
-    }
-    if (_Result.Is(t)) {
-      if (t.is_ok()) {
-        return new ResultError(new Error("Result Error is Ok"));
-      }
-      return t;
-    }
-    return new ResultError(t);
-  }
-  static Is(t) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
-    }
-    const rt = t;
-    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
-      return true;
-    }
-    return false;
-  }
-  isOk() {
-    return this.is_ok();
-  }
-  isErr() {
-    return this.is_err();
-  }
-  Ok() {
-    return this.unwrap();
-  }
-  Err() {
-    return this.unwrap_err();
-  }
-};
-var ResultOK = class extends Result {
-  constructor(t) {
-    super();
-    this._t = t;
-  }
-  is_ok() {
-    return true;
-  }
-  is_err() {
-    return false;
-  }
-  unwrap_err() {
-    throw new Error("Result is Ok");
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var ResultError = class extends Result {
-  constructor(t) {
-    super();
-    this._error = t;
-  }
-  is_ok() {
-    return false;
-  }
-  is_err() {
-    return true;
-  }
-  unwrap() {
-    throw new Error(`Result is Err: ${this._error}`);
-  }
-  unwrap_err() {
-    return this._error;
-  }
-};
-
-// 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;
-    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;
-    }
-  }
-  // 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);
-    }
-  }
-};
-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 });
-  }
-  setParam(params) {
-    this._map.setParam(params.lru);
-  }
-  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(kp = {}) {
-    super((key) => new ResolveOnce(key), kp);
-  }
-  /**
-   *
-   * @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");
-    });
-  }
-};
-
-// 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) || "");
-    }
-    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;
-
-// 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;
-  }
-  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;
-
-// src/web/web-env-actions.ts
-var once3 = new ResolveOnce();
-var BrowserEnvActions = class _BrowserEnvActions {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once3.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-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;
-        }
-      }
-    }
-  }
-  active() {
-    return runtimeFn().isCFWorker;
-  }
-  register(env) {
-    this.env = env;
-    for (const key in this.injectOnRegister) {
-      env.set(key, this.injectOnRegister[key]);
-    }
-    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/types.ts
-var _Required = class {
-  constructor() {
-    this.type = "REQUIRED";
-  }
-};
-var _Optional = class {
-  constructor() {
-    this.type = "OPTIONAL";
-  }
-};
-var param = {
-  REQUIRED: new _Required(),
-  OPTIONAL: new _Optional()
-};
-
-// 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;
-    }
-  }
-  if (errors.length) {
-    return Result.Err(msgFn(...errors));
-  }
-  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) }
-];
-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 EnvImpl(action, opts);
-    action.register(ret);
-    return ret;
-  });
-}
-function isIterable(obj) {
-  if (obj == null) {
-    return false;
-  }
-  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;
-    }
-    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/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);
-  }
-  if (Result.Is(raw)) {
-    if (raw.isErr()) {
-      return Result.Err(raw);
-    }
-    return coerceIntoUint8(raw.unwrap());
-  }
-  return Result.Err("Not a Uint8Array");
-}
-
-// 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);
-      }
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    return this.decoder.decode(coerceIntoUint8(data).Ok());
-  }
-  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());
-}
-
-// src/web/web-basic-sys-abstraction.ts
-var baseSysAbstraction = new ResolveOnce();
-
-// src/cf/cf-basic-sys-abstraction.ts
-var baseSysAbstraction2 = new ResolveOnce();
-
-// src/deno/deno-basic-sys-abstraction.ts
-var DenoRuntimeService = class {
-  constructor(ende) {
-    this._txtEnDe = ende;
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    return globalThis.Deno.args;
-  }
-  Stdout() {
-    return globalThis.Deno.stdout.writable;
-  }
-  Stderr() {
-    return globalThis.Deno.stderr.writable;
-  }
-};
-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 baseSysAbstraction4 = new ResolveOnce();
-
-// 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 TimeMode.REAL:
-      return new SysTime();
-    case TimeMode.CONST:
-      return new ConstTime();
-    case TimeMode.STEP:
-      return new StepTime();
-  }
-  return new SysTime();
-}
-var RandomService = class {
-  constructor(mode) {
-    this._step = 0;
-    this._mode = mode;
-  }
-  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");
-    }
-  }
-};
-var IdService = class {
-  constructor(mode) {
-    this._step = 0;
-    if (!mode) {
-      mode = IDMode.UUID;
-    }
-    this._mode = mode;
-  }
-  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");
-    }
-  }
-};
-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;
-  }
-};
-var BaseSysAbstraction = class extends BaseBasicSysAbstraction {
-  constructor(params) {
-    super(params);
-    this._fileSystem = params.FileSystem;
-    this._systemService = params.SystemService;
-  }
-};
-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);
-    }
-    if (params.IdMode) {
-      this._idService = new IdService(params.IdMode);
-    }
-    if (params.RandomMode) {
-      this._randomService = new RandomService(params.RandomMode);
-    }
-  }
-  Time() {
-    return this._time;
-  }
-  NextId() {
-    return this._idService.NextId();
-  }
-  Random0ToValue(value) {
-    return this._randomService.Random0ToValue(value);
-  }
-  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;
-  }
-};
-
-// src/deno/deno-file-service.ts
-var path = __toESM(require("path"), 1);
-var Deno = globalThis.Deno;
-var DenoFileService = class {
-  constructor(baseDir = Deno.cwd(), txtEnde = TxtEnDecoderSingleton()) {
-    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 = TxtEnDecoderSingleton()) {
-    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/deno/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);
-  }
-  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 baseSysAbstraction5 = new ResolveOnce();
-function DenoSysAbstraction(param2) {
-  const my = baseSysAbstraction5.once(
-    () => new BaseSysAbstraction({
-      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton(),
-      FileSystem: new DenoFileService(),
-      SystemService: new DenoSystemService()
-    })
-  );
-  return new WrapperRuntimeSysAbstraction(my, {
-    basicRuntimeService: DenoBasicSysAbstraction(param2),
-    ...param2
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DenoExitServiceImpl,
-  DenoFileService,
-  DenoSysAbstraction,
-  DenoSystemService
-});
-//# sourceMappingURL=index.cjs.map