@ad-sdk/bgd 0.0.1

package/lifecycle/index.d.ts

@@ -0,0 +1,2 @@
+export { IDisposable, IAsyncDisposable } from "./disposable";
+export type { Either } from "./either";

package/lifecycle/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "IAsyncDisposable", {
+  enumerable: true,
+  get: function () {
+    return _disposable.IAsyncDisposable;
+  }
+});
+Object.defineProperty(exports, "IDisposable", {
+  enumerable: true,
+  get: function () {
+    return _disposable.IDisposable;
+  }
+});
+var _disposable = require("./disposable");

package/mathlib/core.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+export declare namespace MathLib {
+    type ZipResult<T extends unknown[][]> = {
+        [K in keyof T]: T[K] extends (infer U)[] ? U : never;
+    }[];
+    export function zip<T extends unknown[][]>(...args: T): ZipResult<T>;
+    export {};
+}

package/mathlib/core.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MathLib = void 0;
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+/* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
+let MathLib = exports.MathLib = void 0;
+(function (_MathLib) {
+  function zip(...args) {
+    const minLen = Math.min(...args.map(arr => arr.length));
+    const result = new Array(minLen);
+    for (let i = 0; i < minLen; ++i) {
+      result[i] = args.map(arr => arr[i]);
+    }
+    return result;
+  }
+  _MathLib.zip = zip;
+})(MathLib || (exports.MathLib = MathLib = {}));

package/mathlib/index.d.ts

@@ -0,0 +1 @@
+export * from "./core";

package/mathlib/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _core[key];
+    }
+  });
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ad-sdk/bgd",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alertadino/bgd.git"
+  },
+  "engines": {
+    "node": ">=19"
+  },
+  "dependencies": {
+    "pg": "^8.16.3",
+    "uidlib": "^0.0.1"
+  }
+}

package/sqlx/core.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+export declare const SQL_MIGRATION_FILE_PATTERN: RegExp;

package/sqlx/core.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SQL_MIGRATION_FILE_PATTERN = void 0;
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+const SQL_MIGRATION_FILE_PATTERN = exports.SQL_MIGRATION_FILE_PATTERN = /^(\d+)_(.*)\.migration\.sql$/;

package/sqlx/database.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import { BGDException } from "../errors";
+import { type Either } from "../lifecycle";
+import type { Dict, MaybePromise } from "../types";
+export interface IAbstractQueryResult<T = Dict<any>> {
+    readonly dialect: string;
+    readonly command: string;
+    readonly queryText?: string;
+    readonly rowCount: number | null;
+    readonly rows: T[];
+    readonly oid?: number;
+}
+export interface ITransaction {
+    commit(): MaybePromise<void>;
+    rollback(): MaybePromise<void>;
+    exec<TResult>(text: string, values?: unknown[]): MaybePromise<Either<BGDException, IAbstractQueryResult<TResult>>>;
+    execBatch(queries: readonly {
+        query: string;
+        values?: unknown[];
+    }[], options?: {
+        onError?: "continue" | "break";
+    }): MaybePromise<readonly Either<BGDException, IAbstractQueryResult>[]>;
+}
+export declare abstract class Database {
+    abstract readonly dialect: string;
+    get type(): "sql";
+    abstract exec<T = Dict<unknown>>(query: string, values?: unknown[], options?: {
+        transaction?: unknown;
+    }): MaybePromise<Either<BGDException, IAbstractQueryResult<T>>>;
+    abstract exec<T = Dict<unknown>>(query: string, options?: {
+        transaction?: unknown;
+        values?: unknown[];
+    }): MaybePromise<Either<BGDException, IAbstractQueryResult<T>>>;
+    abstract createTransaction(o?: Dict<unknown>): MaybePromise<ITransaction>;
+    abstract dispose(): Promise<void> | void;
+}

package/sqlx/database.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Database = void 0;
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+class Database {
+  get type() {
+    return "sql";
+  }
+}
+exports.Database = Database;

package/sqlx/migrations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import * as fs from "node:fs";
+import { Database } from "./database";
+import { BGDException } from "../errors";
+import { type ILogger } from "../lifecycle/debugger";
+import { type Either } from "../lifecycle/either";
+export interface IMigrateOptions {
+    recursive?: boolean;
+    ensure?: boolean;
+    logger?: ILogger;
+}
+export declare function migrate(driver: Database, directory: fs.PathLike, options?: IMigrateOptions): Promise<Either<BGDException, void>>;

package/sqlx/migrations.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.migrate = migrate;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var fs = _interopRequireWildcard(require("node:fs"));
+var _uidlib = require("uidlib");
+var _errors = require("../errors");
+var _core = require("./core");
+var _either = require("../lifecycle/either");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+async function migrate(driver, directory, options) {
+  try {
+    if (!fs.existsSync(directory)) {
+      if (options?.ensure) {
+        throw new _errors.BGDException("[@@migrate] Migrations directory not found", "ER_IO_FAIL");
+      }
+      options?.logger?.log("Migrations directory not found at '%s'", directory.toString());
+      return (0, _either.right)(void 0);
+    }
+    const contentsList = await fs.promises.readdir(directory, {
+      withFileTypes: true
+    });
+    const executed = await listExecuted_(driver);
+    const tx = await driver.createTransaction({
+      allowQueryBatch: true
+    });
+    for (let i = 0; i < contentsList.length; ++i) {
+      if (!_core.SQL_MIGRATION_FILE_PATTERN.test(contentsList[i].name)) continue;
+      const currPath = _nodePath.default.join(contentsList[i].parentPath, contentsList[i].name // eslint-disable-line comma-dangle
+      );
+      if (contentsList[i].isDirectory() && options?.recursive) {
+        const res = await migrate(driver, currPath, options);
+        if (res.isLeft()) {
+          throw res.value;
+        }
+        continue;
+      }
+      if (!contentsList[i].isFile()) continue;
+      if (executed.some(item => {
+        return item.filename === contentsList[i].name;
+      })) {
+        options?.logger?.log("[@@migrate] Migration \"%s\" has already executed. Skipping...", contentsList[i].name);
+        continue;
+      }
+      const fc = await fs.promises.readFile(currPath, "utf8");
+      const res = await tx.execBatch([{
+        query: fc.trim()
+      }, {
+        query: `INSERT INTO ad_bgd_migrations (
+            migration_id, filename, sort_index
+          ) VALUES ($1::TEXT, $2::TEXT, $3::INT)`,
+        values: [(0, _uidlib.uuidv7)(), contentsList[0].name, parseInt(contentsList[i].name.split("_")[0], 10)]
+      }]);
+      for (let j = 0; j < res.length; ++j) {
+        if (res[j].isLeft()) {
+          await tx.rollback();
+          throw res[j].value;
+        }
+      }
+    }
+    await tx.commit();
+    return (0, _either.right)(void 0);
+  } catch (err) {
+    let e = err;
+    if (!(err instanceof _errors.BGDException)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      e = new _errors.BGDException(`[@@migrate] Failed to execute SQL migration due to: ${err?.message || String(err) || "Unknown error"}`);
+    }
+    return (0, _either.left)(e);
+  }
+}
+const PGCT_QUERY = `CREATE TABLE IF NOT EXISTS ad_bgd_migrations (
+  migration_id VARCHAR(100) NOT NULL UNIQUE PRIMARY KEY,
+  sequence SERIAL NOT NULL,
+  filename VARCHAR(255) NOT NULL UNIQUE,
+  sort_index INT NOT NULL,
+  executed_at TIMESTAMP WITH TIME ZONE NOT NULL
+    DEFAULT (NOW() AT TIME ZONE 'UTC')
+)`;
+async function ensureTable_(driver) {
+  let text = "";
+  switch (driver.dialect) {
+    case "pgsql":
+      {
+        text = PGCT_QUERY;
+      }
+      break;
+    default:
+      throw new _errors.BGDException(`[@@ensureTable_] Unknown or unsupported database dialect "${driver.dialect}"`);
+  }
+  await driver.exec(text);
+}
+async function listExecuted_(driver) {
+  await ensureTable_(driver);
+  const res = await driver.exec("SELECT * FROM migrations");
+  if (res.isLeft()) {
+    throw res.value;
+  }
+  return res.value.rows;
+}

package/sqlx/postgres.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import { type PoolClient } from "pg";
+import type { Dict } from "../types";
+import { BGDException } from "../errors";
+import { IAsyncDisposable } from "../lifecycle/disposable";
+import { type Either } from "../lifecycle/either";
+import { Database, IAbstractQueryResult, ITransaction } from "./database";
+export interface IPostgresResult<T = Dict<any>> extends IAbstractQueryResult<T> {
+    readonly dialect: "pgsql";
+}
+export declare class Postgres extends Database implements IAsyncDisposable {
+    #private;
+    constructor();
+    get dialect(): "pgsql";
+    exec<T = Dict<unknown>>(query: string, values?: unknown[], options?: {
+        transaction?: PoolClient;
+    }): Promise<Either<BGDException, IPostgresResult<T>>>;
+    exec<T = Dict<unknown>>(query: string, options?: {
+        transaction?: PoolClient;
+        values?: unknown[];
+    }): Promise<Either<BGDException, IPostgresResult<T>>>;
+    createTransaction(o?: TransactionOptions): Promise<PostgresTransaction>;
+    dispose(): Promise<void>;
+}
+export type TransactionOptions = {
+    autoCommit?: boolean;
+    allowQueryBatch?: boolean;
+};
+export declare class PostgresTransaction implements ITransaction {
+    #private;
+    static create(c: Postgres, o?: TransactionOptions): Promise<PostgresTransaction>;
+    private constructor();
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    exec<TResult = Dict<any>>(text: string, values?: unknown[]): Promise<Either<BGDException, IPostgresResult<TResult>>>;
+    execBatch(queries: readonly {
+        query: string;
+        values?: unknown[];
+    }[], options?: {
+        onError?: "continue" | "break";
+    }): Promise<readonly Either<BGDException, IPostgresResult>[]>;
+}

package/sqlx/postgres.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PostgresTransaction = exports.Postgres = void 0;
+var _errors = require("../errors");
+var _either = require("../lifecycle/either");
+var _database = require("./database");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); } /**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var _PoolI = /*#__PURE__*/new WeakMap();
+var _Disposed = /*#__PURE__*/new WeakMap();
+var _Postgres_brand = /*#__PURE__*/new WeakSet();
+class Postgres extends _database.Database {
+  constructor() {
+    super();
+    _classPrivateMethodInitSpec(this, _Postgres_brand);
+    _classPrivateFieldInitSpec(this, _PoolI, void 0);
+    _classPrivateFieldInitSpec(this, _Disposed, void 0);
+    _classPrivateFieldSet(_Disposed, this, false);
+  }
+  get dialect() {
+    return "pgsql";
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(text, valuesOrOptions, options) {
+    let values = void 0;
+    if (Array.isArray(valuesOrOptions)) {
+      values = valuesOrOptions;
+    } else {
+      options = {
+        transaction: valuesOrOptions?.transaction
+      };
+      values = valuesOrOptions?.values;
+      valuesOrOptions = null;
+    }
+    let client = null;
+    try {
+      client = options?.transaction ?? (await _assertClassBrand(_Postgres_brand, this, _GetConnection).call(this));
+      const result = await client.query({
+        text,
+        values
+      });
+      return (0, _either.right)({
+        dialect: "pgsql",
+        command: result.command,
+        rowCount: result.rowCount,
+        rows: result.rows,
+        oid: result.oid,
+        queryText: text
+      });
+    } catch (err) {
+      let e = err;
+      if (!(err instanceof _errors.BGDException)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        e = new _errors.BGDException(`[Postgres] Query execution was failed due to: ${err?.message || String(err) || "Unknown error"}`);
+      }
+      return (0, _either.left)(e);
+    } finally {
+      if (client != null && !options?.transaction) {
+        client.release();
+      }
+    }
+  }
+  createTransaction(o) {
+    _assertClassBrand(_Postgres_brand, this, _CheckDisposed).call(this);
+    return PostgresTransaction.create(this, o);
+  }
+  async dispose() {
+    if (!_classPrivateFieldGet(_Disposed, this)) {
+      await _classPrivateFieldGet(_PoolI, this)?.end();
+      _classPrivateFieldSet(_Disposed, this, true);
+    }
+  }
+}
+exports.Postgres = Postgres;
+function _GetConnection() {
+  throw _assertClassBrand(_Postgres_brand, this, _CheckDisposed);
+}
+function _CheckDisposed() {
+  if (_classPrivateFieldGet(_Disposed, this)) {
+    throw new _errors.BGDException("[Postgres] Database has already disposed", "ER_RESOURCE_DISPOSED");
+  }
+}
+var _Finished = /*#__PURE__*/new WeakMap();
+var _Client = /*#__PURE__*/new WeakMap();
+var _Options = /*#__PURE__*/new WeakMap();
+class PostgresTransaction {
+  static async create(c, o) {
+    await c.exec("BEGIN");
+    return new PostgresTransaction(c, o);
+  }
+  constructor(client, options) {
+    _classPrivateFieldInitSpec(this, _Finished, void 0);
+    _classPrivateFieldInitSpec(this, _Client, void 0);
+    _classPrivateFieldInitSpec(this, _Options, void 0);
+    _classPrivateFieldSet(_Finished, this, false);
+    _classPrivateFieldSet(_Client, this, client);
+    _classPrivateFieldSet(_Options, this, options ?? {});
+  }
+  async commit() {
+    if (_classPrivateFieldGet(_Finished, this)) return;
+    await _classPrivateFieldGet(_Client, this).exec("COMMIT");
+    _classPrivateFieldSet(_Finished, this, true);
+  }
+  async rollback() {
+    if (_classPrivateFieldGet(_Finished, this)) return;
+    await _classPrivateFieldGet(_Client, this).exec("ROLLBACK");
+    _classPrivateFieldSet(_Finished, this, true);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(text, values) {
+    if (_classPrivateFieldGet(_Finished, this)) {
+      throw new _errors.BGDException("[PostgresTransaction] Current transaction is already closed");
+    }
+    const result = await _classPrivateFieldGet(_Client, this).exec(text, values);
+    if (result.isRight()) {
+      if (_classPrivateFieldGet(_Options, this)?.autoCommit) {
+        await this.commit();
+      }
+      return result;
+    }
+    if (_classPrivateFieldGet(_Options, this)?.autoCommit) {
+      await this.rollback();
+    }
+    return result;
+  }
+  async execBatch(queries, options) {
+    if (_classPrivateFieldGet(_Finished, this)) {
+      throw new _errors.BGDException("[PostgresTransaction] Current transaction is already closed");
+    }
+    if (!_classPrivateFieldGet(_Options, this)?.allowQueryBatch) {
+      throw new _errors.BGDException("[PostgresTransaction] Current transaction is not allowed to execute batch queries");
+    }
+    const oe = options?.onError ?? "break";
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const result = [];
+      for (let i = 0; i < queries.length; ++i) {
+        const res = await _classPrivateFieldGet(_Client, this).exec(queries[i].query, queries[i].values);
+        if (res.isLeft() && oe !== "continue") {
+          throw res.value;
+        }
+        result.push(res);
+      }
+      if (_classPrivateFieldGet(_Options, this)?.autoCommit !== true) return result;
+      const success = result.every(r => r.isRight());
+      await this[success ? "commit" : "rollback"]();
+      return result;
+    } catch (err) {
+      if (_classPrivateFieldGet(_Options, this).autoCommit) {
+        await this.rollback();
+      }
+      throw err;
+    }
+  }
+}
+exports.PostgresTransaction = PostgresTransaction;

package/sss/poly.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Halfmoon Labs. All rights reserved.
+ *
+ * Modified in 2025 by Alerta Dino's IT Team.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @see https://github.com/shea256/secret-sharing/blob/master/secretsharing/polynomials.py
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+export declare function egcd(a: number, b: number): readonly [number, number, number];
+export declare function modInv(k: number, prime: number): number;
+export declare function randomPolynomial(degree: number, intercept: number, upperBound: number): number[];
+export declare function getPolynomialPoints(c: readonly number[], points: number, prime: number): readonly [number, number][];
+export declare function modularLagrangeInterpolation(x: number, points: readonly [number, number][], prime: number): number;

package/sss/poly.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.egcd = egcd;
+exports.getPolynomialPoints = getPolynomialPoints;
+exports.modInv = modInv;
+exports.modularLagrangeInterpolation = modularLagrangeInterpolation;
+exports.randomPolynomial = randomPolynomial;
+var _nodeCrypto = require("node:crypto");
+var _mathlib = require("../mathlib");
+var _util = require("../util");
+/**
+ * Copyright (c) Halfmoon Labs. All rights reserved.
+ * 
+ * Modified in 2025 by Alerta Dino's IT Team.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @see https://github.com/shea256/secret-sharing/blob/master/secretsharing/polynomials.py
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+function egcd(a, b) {
+  if (a === 0) return [b, 0, 1];
+  const [g, y, x] = egcd(b % a, a);
+  return [g, x - b / a * y, y];
+}
+function modInv(k, prime) {
+  k = k % prime;
+  const r = egcd(prime, k < 0 ? -k : k)[2];
+  return (prime + r) % prime;
+}
+function randomPolynomial(degree, intercept, upperBound) {
+  (0, _util.assertType)("uint32", degree);
+  const coefficients = [intercept];
+  for (let i = 0; i < degree; ++i) {
+    const rc = (0, _nodeCrypto.randomInt)(upperBound - 1);
+    coefficients.push(rc);
+  }
+  return coefficients;
+}
+function getPolynomialPoints(c, points, prime) {
+  const res = [];
+  for (let x = 1; x < points + 1; ++x) {
+    let y = c[0];
+    for (let j = 1; j < c.length; ++j) {
+      const exp = x ** j % prime;
+      const term = c[j] * exp % prime;
+      y = (y + term) % prime;
+    }
+    res.push([x, y]);
+  }
+  return res;
+}
+function modularLagrangeInterpolation(x, points, prime) {
+  const [xVals, yVals] = _mathlib.MathLib.zip(...points);
+  let fx = 0;
+  for (let i = 0; i < points.length; ++i) {
+    let n = 1,
+      d = 1;
+    for (let j = 0; j < points.length; ++j) {
+      if (j === i) continue;
+      n = n * (x - xVals[j]) % prime;
+      d = d * (xVals[i] - xVals[j]) % prime;
+    }
+    const lPol = n * modInv(d, prime);
+    fx = (prime + fx + yVals[i] * lPol) % prime;
+  }
+  return fx;
+}