@mrxsys/mrx-core 2.11.0-2-and-276-20251029 → 2.11.0-2-and-279-20251103

package/dist/chunk-9d3zvgp6.js

@@ -0,0 +1,9 @@
+// @bun
+// source/modules/jwt/enums/jwt-error-keys.ts
+var JWT_ERROR_KEYS = {
+  JWT_EXPIRATION_PASSED: "mrx-core.jwt.error.expiration_passed",
+  JWT_SECRET_NOT_FOUND: "mrx-core.jwt.error.secret_not_found",
+  JWT_SIGN_ERROR: "mrx-core.jwt.error.sign_error"
+};
+
+export { JWT_ERROR_KEYS };

package/dist/chunk-9dzsj7f2.js

@@ -0,0 +1,23 @@
+// @bun
+// source/shared/utils/flatten.ts
+import { KindGuard } from "@sinclair/typebox";
+import { t } from "elysia";
+var _flattenInto = (type, result) => {
+  if (KindGuard.IsUnion(type))
+    for (const subType of type.anyOf)
+      _flattenInto(subType, result);
+  else
+    result.push(type);
+};
+var flatten = (type) => {
+  if (!KindGuard.IsUnion(type))
+    return type;
+  const isAlreadyFlat = type.anyOf.every((subType) => !KindGuard.IsUnion(subType));
+  if (isAlreadyFlat)
+    return type;
+  const result = [];
+  _flattenInto(type, result);
+  return t.Union(result);
+};
+
+export { flatten };

package/dist/chunk-9r5anep5.js

@@ -0,0 +1,11 @@
+// @bun
+// source/modules/totp/enums/totp-error-keys.ts
+var TOTP_ERROR_KEYS = {
+  INVALID_ALGORITHM: "mrx-core.totp.error.invalid_algorithm",
+  INVALID_BASE32_CHARACTER: "mrx-core.totp.error.invalid_base32_character",
+  INVALID_OTP_AUTH_URI: "mrx-core.totp.error.invalid_otp_auth_uri",
+  INVALID_SECRET_LENGTH: "mrx-core.totp.error.invalid_secret_length",
+  MISSING_SECRET: "mrx-core.totp.error.missing_secret"
+};
+
+export { TOTP_ERROR_KEYS };

package/dist/chunk-afd82epa.js

@@ -0,0 +1,201 @@
+// @bun
+import {
+  Repository
+} from "./chunk-afyz8rg5.js";
+import {
+  TypedEventEmitter
+} from "./chunk-mvrxngm7.js";
+import {
+  DATABASE_ERROR_KEYS
+} from "./chunk-4v86f7gp.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/database/table.ts
+class Table extends TypedEventEmitter {
+  _databaseName;
+  _fields = [];
+  _name;
+  _primaryKey;
+  constructor(databaseName, tableName, fields, primaryKey) {
+    super();
+    this._databaseName = databaseName;
+    this._name = tableName;
+    this._fields = fields;
+    this._primaryKey = primaryKey;
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get name() {
+    return this._name;
+  }
+  get fields() {
+    return this._fields;
+  }
+  get primaryKey() {
+    return this._primaryKey;
+  }
+}
+
+// source/modules/database/mssql.ts
+import knex from "knex";
+class MSSQL extends TypedEventEmitter {
+  _isConnected = false;
+  _databaseName;
+  _tables = new Map;
+  _repositories = new Map;
+  _db;
+  _isEventEnabled;
+  constructor(options) {
+    super();
+    this._databaseName = options.databaseName;
+    this._isEventEnabled = options.isEventEnabled ?? false;
+    this._db = knex({
+      client: "mssql",
+      acquireConnectionTimeout: options.connectionTimeout ?? 20000,
+      compileSqlOnError: true,
+      connection: {
+        database: options.databaseName,
+        host: options.host,
+        port: options.port,
+        user: options.user,
+        password: options.password,
+        options: {
+          encrypt: options.encrypt ?? true
+        },
+        bigNumberStrings: false
+      },
+      pool: {
+        min: options.poolMin ?? 2,
+        max: options.poolMax ?? 10
+      }
+    });
+  }
+  async connect() {
+    try {
+      await this._introspectDatabase();
+      this._isConnected = true;
+      if (this._isEventEnabled)
+        this._addEventKnex();
+    } catch (error) {
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_CONNECTION_ERROR, {
+        databaseName: this._databaseName,
+        error
+      });
+    }
+  }
+  async disconnect() {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, {
+        databaseName: this._databaseName
+      });
+    try {
+      await this._db.destroy();
+      this._isConnected = false;
+    } catch (error) {
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_DISCONNECT_ERROR, {
+        databaseName: this._databaseName,
+        error
+      });
+    }
+  }
+  getRepository(tableName, customRepository) {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    if (!this._tables.has(tableName))
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND, { table: tableName });
+    let repo = this._repositories.get(tableName);
+    if (customRepository) {
+      const table = this._tables.get(tableName);
+      if (repo && repo instanceof customRepository)
+        return repo;
+      repo = new customRepository(this._db, table);
+      this._repositories.set(tableName, repo);
+      return repo;
+    }
+    return this._repositories.get(tableName);
+  }
+  getTable(tableName) {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    if (!this._tables.has(tableName))
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND, { table: tableName });
+    return this._tables.get(tableName);
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get tables() {
+    return this._tables;
+  }
+  get repositories() {
+    return this._repositories;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  get db() {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    return this._db;
+  }
+  async _introspectDatabase() {
+    const result = await this._db.from({ c: "information_schema.columns" }).select("c.table_name as tableName").select(this._db.raw("STRING_AGG(c.column_name, ',') AS fields")).select("pk.primaryKeyColumn as primaryKeyColumn").select("pk.primaryKeyType as primaryKeyType").leftJoin(this._db.from({ tc: "information_schema.table_constraints" }).join({ kcu: "information_schema.key_column_usage" }, "tc.constraint_name", "kcu.constraint_name").join({ col: "information_schema.columns" }, (builder) => {
+      builder.on("col.table_name", "=", "kcu.table_name").andOn("col.column_name", "=", "kcu.column_name");
+    }).where("tc.constraint_type", "PRIMARY KEY").groupBy("tc.table_name", "kcu.column_name", "col.data_type").select("tc.table_name as tableName").select("kcu.column_name as primaryKeyColumn").select("col.data_type as primaryKeyType").as("pk"), "c.table_name", "pk.tableName").groupBy("c.table_name", "pk.primaryKeyColumn", "pk.primaryKeyType");
+    const fieldsByTable = result.reduce((acc, { tableName, fields, primaryKeyColumn, primaryKeyType }) => {
+      const primaryKeyTypeTs = primaryKeyType === "int" ? "NUMBER" : "STRING";
+      acc.set(tableName, {
+        fields: fields.split(","),
+        primaryKey: [primaryKeyColumn, primaryKeyTypeTs]
+      });
+      return acc;
+    }, new Map);
+    fieldsByTable.forEach((desc, tableName) => {
+      const table = new Table(this._databaseName, tableName, desc.fields, desc.primaryKey);
+      this._tables.set(tableName, table);
+      this._repositories.set(tableName, new Repository(this._db, table));
+    });
+  }
+  _extractTablesFromSqlQuery(sql) {
+    const tableRegex = /(?:update|insert\s+into|delete\s+from|from|join|with)\s+\[?([^\]\s]+)\]?/gi;
+    const matches = [...sql.matchAll(tableRegex)].map((match) => match[1]);
+    return Array.from(new Set(matches));
+  }
+  _handleQueryResponse(response, queryContext) {
+    const tables = this._extractTablesFromSqlQuery(queryContext.sql);
+    const table = this._tables.get(tables[0]);
+    switch (queryContext.method) {
+      case "select":
+        table?.emit("selected", response, queryContext);
+        break;
+      case "insert":
+        table?.emit("inserted", response, queryContext);
+        break;
+      case "update":
+        table?.emit("updated", response, queryContext);
+        break;
+      case "del":
+        table?.emit("deleted", response, queryContext);
+        break;
+      default:
+        break;
+    }
+  }
+  _addEventKnex() {
+    this._db.on("query", (queryContext) => {
+      this.emit("query", queryContext);
+    });
+    this._db.on("query-error", (error, queryContext) => {
+      this.emit("query:error", error, queryContext);
+    });
+    this._db.on("query-response", (response, queryContext) => {
+      this.emit("query:response", response, queryContext);
+      this._handleQueryResponse(response, queryContext);
+    });
+  }
+}
+
+export { Table, MSSQL };

package/dist/chunk-afyz8rg5.js

@@ -0,0 +1,209 @@
+// @bun
+import {
+  isDateString,
+  makeStreamAsyncIterable
+} from "./chunk-grfyngq0.js";
+import {
+  DATABASE_ERROR_KEYS,
+  MSSQL_ERROR_CODE
+} from "./chunk-4v86f7gp.js";
+import {
+  HttpError
+} from "./chunk-7t524zqh.js";
+
+// source/modules/repository/repository.ts
+import { PassThrough } from "stream";
+var _operators = {
+  $eq: (q, c, v) => q.where(c, v),
+  $neq: (q, c, v) => q.whereNot(c, v),
+  $lt: (q, c, v) => q.where(c, "<", v),
+  $lte: (q, c, v) => q.where(c, "<=", v),
+  $gt: (q, c, v) => q.where(c, ">", v),
+  $gte: (q, c, v) => q.where(c, ">=", v),
+  $in: (q, c, v) => q.whereIn(c, v),
+  $nin: (q, c, v) => q.whereNotIn(c, v),
+  $between: (q, c, v) => q.whereBetween(c, v),
+  $nbetween: (q, c, v) => q.whereNotBetween(c, v),
+  $like: (q, c, v) => {
+    const likeValue = `%${v}%`;
+    if (isDateString(v))
+      return q.whereRaw(`CONVERT(VARCHAR, ${c}, 23) LIKE ?`, [likeValue]);
+    return q.where(c, "LIKE", likeValue);
+  },
+  $nlike: (q, c, v) => {
+    const likeValue = `%${v}%`;
+    if (isDateString(v))
+      return q.whereRaw(`CONVERT(VARCHAR, ${c}, 23) NOT LIKE ?`, [likeValue]);
+    return q.whereRaw(`${c} NOT LIKE ?`, [likeValue]);
+  },
+  $isNull: (q, c, v) => v ? q.whereNull(c) : q.whereNotNull(c)
+};
+var _validOperatorKeys = new Set([
+  "$eq",
+  "$neq",
+  "$lt",
+  "$lte",
+  "$gt",
+  "$gte",
+  "$in",
+  "$nin",
+  "$between",
+  "$nbetween",
+  "$like",
+  "$nlike",
+  "$isNull"
+]);
+var _DEFAULT_LIMIT = 100;
+var _DEFAULT_OFFSET = 0;
+
+class Repository {
+  _knex;
+  _table;
+  constructor(knex, table) {
+    this._knex = knex;
+    this._table = table;
+  }
+  findStream(options) {
+    const query = this._knex(this._table.name);
+    this._applyQueryOptions(query, options);
+    const kStream = query.stream();
+    const passThrough = new PassThrough({
+      objectMode: true,
+      ...options?.transform && { transform: options.transform }
+    });
+    const cleanup = () => {
+      if (!kStream.destroyed)
+        kStream.destroy();
+      if (!passThrough.destroyed)
+        passThrough.destroy();
+    };
+    kStream.on("error", (error) => {
+      const code = error?.number || 0;
+      passThrough.emit("error", new HttpError(MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR, {
+        query: query.toSQL().sql,
+        error
+      }));
+    });
+    passThrough.on("close", cleanup);
+    passThrough.on("error", cleanup);
+    kStream.pipe(passThrough);
+    return makeStreamAsyncIterable(passThrough);
+  }
+  async find(options) {
+    const query = this._knex(this._table.name);
+    this._applyQueryOptions(query, options);
+    const limit = options?.limit || _DEFAULT_LIMIT;
+    const offset = options?.offset || _DEFAULT_OFFSET;
+    query.limit(limit).offset(offset);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  async count(options) {
+    const query = this._knex(this._table.name).count({ count: "*" });
+    this._applyFilter(query, options?.filters);
+    if (options?.transaction)
+      query.transacting(options.transaction);
+    return this._executeQuery(query, options?.throwIfNoResult).then((result) => result[0].count);
+  }
+  async insert(data, options) {
+    const query = this._knex(this._table.name).insert(data).returning(options?.selectedFields ?? "*");
+    if (options?.transaction)
+      query.transacting(options.transaction);
+    return this._executeQuery(query);
+  }
+  async update(data, options) {
+    const query = this._knex(this._table.name).update(data);
+    this._applyQueryOptions(query, options);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  async delete(options) {
+    const query = this._knex(this._table.name).delete();
+    this._applyQueryOptions(query, options);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  _applySelectedFields(query, selectedFields) {
+    const qMethod = query._method;
+    const sanitizedFields = selectedFields ? selectedFields === "*" ? "*" : Array.isArray(selectedFields) ? selectedFields.map((selectedField) => `${selectedField} as ${selectedField}`) : `${selectedFields} as ${selectedFields}` : "*";
+    if (qMethod === "del" || qMethod === "update" || qMethod === "insert")
+      query.returning(sanitizedFields, { includeTriggerModifications: true });
+    else
+      query.select(sanitizedFields);
+  }
+  _applyFilter(query, search) {
+    const processing = (query2, search2) => {
+      for (const key in search2) {
+        const prop = search2[key];
+        if (this._filterIsAdaptiveWhereClause(prop)) {
+          for (const operator in prop)
+            if (operator in _operators && prop[operator] !== undefined)
+              _operators[operator](query2, key, prop[operator]);
+        } else if (key === "$q" && prop !== null && (typeof prop === "string" || typeof prop === "number")) {
+          for (const field of this._table.fields)
+            if (prop)
+              query2.orWhere(field, "like", `%${prop}%`);
+        } else if (key === "$q" && prop !== null && typeof prop === "object" && "selectedFields" in prop && "value" in prop) {
+          const { selectedFields, value } = prop;
+          if (Array.isArray(selectedFields))
+            for (const field of selectedFields)
+              query2.orWhere(field, "like", `%${value}%`);
+          else
+            query2.orWhere(selectedFields, "like", `%${value}%`);
+        } else {
+          if (prop !== null && typeof prop === "object" && Object.keys(prop).length === 0)
+            continue;
+          if (prop !== undefined)
+            query2.where(key, prop);
+        }
+      }
+    };
+    if (search && Array.isArray(search))
+      search.reduce((acc, item) => acc.orWhere((q) => this._applyFilter(q, item)), query);
+    else if (search)
+      processing(query, search);
+  }
+  _applyOrderBy(query, orderBy) {
+    const qMethod = query._method;
+    if (!(qMethod === "select"))
+      return;
+    if (!orderBy)
+      query.orderBy(`[${this._table.name}].${this._table.primaryKey[0]}`, "asc");
+    else if (Array.isArray(orderBy))
+      orderBy.forEach((item) => {
+        query.orderBy(`[${this._table.name}].${item.selectedField}`, item.direction);
+      });
+    else
+      query.orderBy(`[${this._table.name}].${orderBy.selectedField}`, orderBy.direction);
+  }
+  _applyQueryOptions(query, options) {
+    this._applyFilter(query, options?.filters);
+    this._applyOrderBy(query, options?.orderBy);
+    this._applySelectedFields(query, options?.selectedFields);
+    if (options?.transaction)
+      query.transacting(options.transaction);
+  }
+  _handleError(error, query) {
+    if (error instanceof HttpError)
+      throw error;
+    const code = error?.number || 0;
+    throw new HttpError(MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR, {
+      query: query.toSQL().sql,
+      error
+    });
+  }
+  _filterIsAdaptiveWhereClause(data) {
+    return Boolean(data && typeof data === "object" && !Array.isArray(data) && Object.keys(data).some((key) => _validOperatorKeys.has(key)));
+  }
+  async _executeQuery(query, throwIfNoResult = false) {
+    try {
+      const result = await query;
+      if (throwIfNoResult && result.length === 0)
+        throw new HttpError(typeof throwIfNoResult === "object" && throwIfNoResult.message ? throwIfNoResult.message : DATABASE_ERROR_KEYS.MSSQL_NO_RESULT, typeof throwIfNoResult === "object" && throwIfNoResult.httpStatusCode ? throwIfNoResult.httpStatusCode : 404, {
+          query: query.toSQL().sql
+        });
+      return result;
+    } catch (error) {
+      return this._handleError(error, query);
+    }
+  }
+}
+
+export { Repository };

package/dist/chunk-dre2fgj0.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/elysia/rate-limit/enums/rate-limit-error-keys.ts
+var RATE_LIMIT_ERROR_KEYS = {
+  RATE_LIMIT_EXCEEDED: "mrx-core.elysia.rate-limit.error.exceeded"
+};
+
+export { RATE_LIMIT_ERROR_KEYS };

package/dist/chunk-e30paw8a.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "./chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/kv-store/memory/memory-store.ts
+class MemoryStore {
+  _store = new Map;
+  _cleanupInterval;
+  _cleanupTimer = null;
+  constructor(cleanupIntervalMs) {
+    this._cleanupInterval = cleanupIntervalMs ?? 300000;
+    this._startCleanup();
+  }
+  get(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return null;
+    const now = Date.now();
+    if (now > entry.expiresAt && entry.expiresAt !== -1) {
+      this._store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlSec) {
+    const expiresAt = ttlSec ? Date.now() + ttlSec * 1000 : -1;
+    this._store.set(key, { value, expiresAt });
+  }
+  increment(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue + amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  decrement(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue - amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  del(key) {
+    return this._store.delete(key);
+  }
+  expire(key, ttlSec) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return false;
+    entry.expiresAt = Date.now() + ttlSec * 1000;
+    return true;
+  }
+  ttl(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return -1;
+    if (entry.expiresAt === -1)
+      return -1;
+    const remaining = entry.expiresAt - Date.now();
+    return remaining > 0 ? Math.ceil(remaining / 1000) : -1;
+  }
+  clean() {
+    const sizeBefore = this._store.size;
+    this._store.clear();
+    return sizeBefore;
+  }
+  _startCleanup() {
+    if (this._cleanupTimer)
+      return;
+    this._cleanupTimer = setInterval(() => {
+      this._removeExpiredEntries();
+    }, this._cleanupInterval);
+  }
+  _removeExpiredEntries() {
+    const now = Date.now();
+    for (const [key, entry] of this._store.entries())
+      if (entry.expiresAt !== -1 && now > entry.expiresAt)
+        this._store.delete(key);
+  }
+  destroy() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+    this._store.clear();
+  }
+}
+
+export { MemoryStore };

package/dist/chunk-eeb7yskp.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS
+} from "./chunk-12qzn7jw.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/jwt/utils/parse-human-time-to-seconds.ts
+var TIME_UNITS = {
+  SECOND: 1,
+  MINUTE: 60,
+  HOUR: 60 * 60,
+  DAY: 60 * 60 * 24,
+  WEEK: 60 * 60 * 24 * 7,
+  YEAR: 60 * 60 * 24 * 365.25
+};
+var TIME_EXPRESSION_REGEX = /^(\+|-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+var UNIT_MAPPINGS = {
+  s: TIME_UNITS.SECOND,
+  sec: TIME_UNITS.SECOND,
+  secs: TIME_UNITS.SECOND,
+  second: TIME_UNITS.SECOND,
+  seconds: TIME_UNITS.SECOND,
+  m: TIME_UNITS.MINUTE,
+  min: TIME_UNITS.MINUTE,
+  mins: TIME_UNITS.MINUTE,
+  minute: TIME_UNITS.MINUTE,
+  minutes: TIME_UNITS.MINUTE,
+  h: TIME_UNITS.HOUR,
+  hr: TIME_UNITS.HOUR,
+  hrs: TIME_UNITS.HOUR,
+  hour: TIME_UNITS.HOUR,
+  hours: TIME_UNITS.HOUR,
+  d: TIME_UNITS.DAY,
+  day: TIME_UNITS.DAY,
+  days: TIME_UNITS.DAY,
+  w: TIME_UNITS.WEEK,
+  week: TIME_UNITS.WEEK,
+  weeks: TIME_UNITS.WEEK,
+  y: TIME_UNITS.YEAR,
+  yr: TIME_UNITS.YEAR,
+  yrs: TIME_UNITS.YEAR,
+  year: TIME_UNITS.YEAR,
+  years: TIME_UNITS.YEAR
+};
+var parseHumanTimeToSeconds = (timeExpression) => {
+  const match = TIME_EXPRESSION_REGEX.exec(timeExpression);
+  if (!match || match[4] && match[1])
+    throw new BaseError(PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS.INVALID_TIME_EXPRESSION);
+  const [, sign, valueStr, unitStr, direction] = match;
+  const value = parseFloat(valueStr);
+  const unit = unitStr.toLowerCase();
+  const multiplier = UNIT_MAPPINGS[unit];
+  const seconds = Math.round(value * multiplier);
+  if (sign === "-" || direction === "ago")
+    return -seconds;
+  return seconds;
+};
+
+export { parseHumanTimeToSeconds };

package/dist/chunk-fs3wm3p4.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  SINGLETON_MANAGER_ERROR_KEYS
+} from "./chunk-z0ct35ft.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/singleton-manager/singleton-manager.ts
+class SingletonManager {
+  static _registry = new Map;
+  static register(name, instance) {
+    if (this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_ALREADY_REGISTERED, { name });
+    this._registry.set(name, instance);
+  }
+  static unregister(name) {
+    if (!this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_NOT_REGISTERED, { name });
+    this._registry.delete(name);
+  }
+  static get(name) {
+    if (!this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_NOT_REGISTERED, { name });
+    return this._registry.get(name);
+  }
+  static has(name) {
+    return this._registry.has(name);
+  }
+}
+
+export { SingletonManager };