mybase 1.2.2 → 1.2.3

package/mybase.ts

@@ -1,397 +0,0 @@
-/// <reference path="./ip6addr.d.ts" />
-//#region imports
-import ipRangeCheck from 'ip-range-check'
-import aesjs from 'aes-js'
-import createDebug from 'debug'
-import os from 'os'
-import fs from 'fs'
-import path from 'path'
-import net from 'net'
-import chalk from 'chalk'
-import validURLFn from '@7c/validurl'
-import { sha512 } from 'js-sha512'
-import * as ip6 from 'ip6'
-import { Reader as MaxmindReader } from '@maxmind/geoip2-node'
-import type { MysqlConfig, MysqlConnection, MysqlConnector, SqlQueryable } from './ts/types'
-import { randomString } from './ts/funcs/randomString'
-//#endregion
-
-//#region re-export from ts/funcs
-export { randomString }
-export { wait } from './ts/funcs/wait'
-export { utcnow } from './ts/funcs/utcnow'
-export { isLocal } from './ts/funcs/isLocal'
-export { validEmail } from './ts/funcs/validEmail'
-export { asJSON } from './ts/funcs/asJSON'
-export { promiseTimeout } from './ts/funcs/promiseTimeout'
-export { randomIP } from './ts/funcs/randomIP'
-export { MaxRuntimeHours } from './ts/funcs/MaxRuntimeHours'
-export { Geoip2Paths } from './ts/funcs/Geoip2Paths'
-export { vaultRead } from './ts/funcs/vaultRead'
-export { vaultFill } from './ts/funcs/vaultFill'
-export { hash_sha512 } from './ts/funcs/hash_sha512'
-export { isLoopbackIP } from './ts/funcs/isLoopbackIP'
-export { isLANIp } from './ts/funcs/isLANIp'
-//#endregion
-
-const debug = createDebug('mybase')
-
-//#region Date.prototype extension
-declare global {
-  interface Date {
-    yyyymmdd(): string
-  }
-}
-
-Date.prototype.yyyymmdd = function yyyymmdd(this: Date) {
-  const mm = this.getMonth() + 1
-  const dd = this.getDate()
-  return [this.getFullYear(), (mm > 9 ? '' : '0') + mm, (dd > 9 ? '' : '0') + dd].join('')
-}
-//#endregion
-
-export function validHPassword(hpassword: string): boolean {
-  return !!(hpassword && hpassword.length === 128 && hpassword.search(/^[a-f0-9]+$/) === 0)
-}
-
-export function randomHPassword(length = 10): string {
-  const plain = randomString(length)
-  return sha512(plain)
-}
-
-export function arrayRandomItem<T>(arry: unknown, defaultValue: T | false = false): T | false {
-  if (Array.isArray(arry)) return arry[Math.floor(Math.random() * arry.length)] as T
-  return defaultValue
-}
-
-export function validIp(str: unknown): boolean {
-  console.log(`WARNING: validIp is deprecated, use validIpNative or IPAddress model`)
-  if (str && typeof str === 'string') {
-    const splitted = str.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$/)
-    if (splitted) {
-      for (const octet of splitted) {
-        if (parseInt(octet, 10) >= 0 && parseInt(octet, 10) <= 255) continue
-        return false
-      }
-      return true
-    }
-  }
-  return false
-}
-
-export function validIpNative(str: string): boolean {
-  return net.isIP(str) !== 0
-}
-
-export function isURL(url: unknown): URL | false {
-  if (typeof url === 'string') {
-    try {
-      return new URL(url)
-    } catch {
-      /* ignore */
-    }
-  }
-  return false
-}
-
-export function validTime(t: unknown): number | false {
-  const valid = !!(t && parseInt(String(t), 10) > 0 && String(t).length === 10)
-  if (!valid) return false
-  return parseInt(String(t), 10)
-}
-
-export function validURL(host: unknown): boolean {
-  return validURLFn(host)
-}
-
-export function isObject(a: unknown): boolean {
-  return !!a && (a as object).constructor === Object
-}
-
-export async function getMysql(mysqlClass: MysqlConnector, config: MysqlConfig, keep_pinging = true): Promise<MysqlConnection> {
-  const mysql_client = mysqlClass.createConnection({
-    host: config.host,
-    port: config.port ? config.port : 3306,
-    user: config.login,
-    password: config.password,
-    database: config.db,
-  })
-  await new Promise<void>((resolve, reject) => {
-    mysql_client.connect((err) => {
-      if (err) {
-        debug(`mysql connection has failed to ${config.host}@${config.db}`, err)
-        reject(err)
-        return
-      }
-      debug(`mysql connection has been established to ${config.host}@${config.db}`)
-      if (keep_pinging) {
-        setInterval(() => {
-          mysql_client.ping((errPing?: NodeJS.ErrnoException | Error | null) => {
-            if (errPing && 'code' in errPing) return console.log(`could not ping mysql ${config.host}@${config.db}`, errPing.code)
-            debug(chalk.bold(`mysql ${config.host}@${config.db} is pinging properly`))
-          })
-        }, 30000)
-      }
-      resolve()
-    })
-  })
-  return mysql_client
-}
-
-export async function maxmindOpen(geoipFile: string) {
-  debug(`maxmindOpen ${geoipFile}`)
-  try {
-    const reader = await MaxmindReader.open(geoipFile, { watchForUpdates: true })
-    debug(`${geoipFile} is opened successfully`)
-    return reader
-  } catch (err) {
-    debug(`maxmindOpen Error at ${geoipFile}`, err)
-    throw err
-  }
-}
-
-export function randomBase32(length = 10): string {
-  const charSet = 'abcdefghijklmnopqrstuvwxyz234567'
-  let text = ''
-  for (let i = 0; i < length; i++) text += charSet.charAt(Math.floor(Math.random() * charSet.length))
-  return text
-}
-
-export function validAuthcode(authcode: string): boolean {
-  const alphabetOnly = 'abcdefghijklmnopqrstuvwxyz'
-  if (!authcode || authcode.length !== 12) return false
-  const ac = authcode.toLowerCase()
-  if (ac.charAt(3) !== '-') return false
-  if (ac.charAt(9) !== '-') return false
-  let checksum = 0
-  const body = ac.substring(1)
-  for (let i = 0; i < body.length; i++) {
-    const c = body.charAt(i)
-    if (c === '-') continue
-    checksum += c.charCodeAt(0)
-  }
-  const checksumChar = alphabetOnly.charAt(checksum % alphabetOnly.length)
-  if (checksumChar !== ac.charAt(0)) return false
-  return true
-}
-
-export function randomAuthcode(): string {
-  const length = 9
-  const charSet = 'abcdefghijklmnopqrstuvwxyz234567'
-  const alphabetOnly = 'abcdefghijklmnopqrstuvwxyz'
-  let checksum = 0
-  let text = ''
-  for (let i = 0; i < length; i++) {
-    if (i === 2 || i === 7) text += '-'
-    const c = charSet.charAt(Math.floor(Math.random() * charSet.length))
-    checksum += c.charCodeAt(0)
-    text += c
-  }
-  text = alphabetOnly.charAt(checksum % alphabetOnly.length) + text
-  return text
-}
-
-export function array_shuffle<T>(a: T[]): T[] {
-  let j: number
-  let x: T
-  for (let i = a.length - 1; i > 0; i--) {
-    j = Math.floor(Math.random() * (i + 1))
-    x = a[i]
-    a[i] = a[j]
-    a[j] = x
-  }
-  return a
-}
-
-export function object_shuffle<T extends Record<string, unknown>>(object: T): T {
-  const keys = array_shuffle(Object.keys(object))
-  const ret: Record<string, unknown> = {}
-  for (const k of keys) ret[k] = object[k]
-  return ret as T
-}
-
-export async function canReadAndWrite(targetPath: string, _create = false): Promise<boolean> {
-  await new Promise<void>((resolve, reject) => {
-    fs.stat(targetPath, (err) => {
-      if (err) {
-        if (err.code === 'ENOENT') {
-          fs.mkdirSync(targetPath)
-        } else {
-          reject(err)
-          return
-        }
-      }
-      fs.access(targetPath, fs.constants.W_OK | fs.constants.R_OK, (errAcc) => {
-        if (errAcc) return reject(errAcc)
-        debug(`canReadAndWrite ${targetPath}`)
-        resolve()
-      })
-    })
-  })
-  return true
-}
-
-export function softexit(message: string | false = false, seconds = 60, exitcode = 1): void {
-  if (message) console.log(message)
-  console.log(`Softexit: will stop in ${seconds} seconds..`)
-  setTimeout(() => {
-    process.exit(exitcode)
-  }, seconds * 1000)
-}
-
-export function validHostname(value: unknown): boolean {
-  if (typeof value !== 'string') return false
-  let v = value
-  const validHostnameChars = /^[a-zA-Z0-9-.]{1,253}\.?$/g
-  if (!validHostnameChars.test(v)) return false
-  if (v.endsWith('.')) v = v.slice(0, v.length - 1)
-  if (v.length > 253) return false
-  const labels = v.split('.')
-  return labels.every((label) => {
-    const validLabelChars = /^([a-zA-Z0-9-]+)$/g
-    return validLabelChars.test(label) && label.length < 64 && !label.startsWith('-') && !label.endsWith('-')
-  })
-}
-
-export function validHostname2(domainName: unknown): boolean {
-  const domainNameRegex =
-    /^(?:[a-z0-9](?:[a-z0-9_\-]{0,61}[a-z0-9])?\.){0,126}(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9]))\.?$/i
-  if (!domainName || typeof domainName !== 'string') return false
-  if (net.isIPv4(domainName) || net.isIPv6(domainName.replace(/[\[\]]/g, ''))) return true
-  let dn = domainName.replace(/\.$/, '')
-  if (dn.length < 2) return false
-  if (dn.length > 255) return false
-  if (dn.search(/\./) < 0 && dn.search(/^[0-9]+$/) === 0) return false
-  return domainNameRegex.test(dn)
-}
-
-export function removeDoubleSlashes(url: unknown): string | false {
-  if (typeof url === 'string') return url.replace(/([^:]\/)\/+/g, '$1')
-  return false
-}
-
-export function getTemp(filename: string | false = false): string {
-  const tempDirectorySymbol = Symbol.for('__RESOLVED_TEMP_DIRECTORY__')
-  const g = globalThis as typeof globalThis & { [k: symbol]: string | undefined }
-  if (!g[tempDirectorySymbol]) {
-    Object.defineProperty(g, tempDirectorySymbol, {
-      value: fs.realpathSync(os.tmpdir()),
-    })
-  }
-  let tmp = g[tempDirectorySymbol] as string
-  if (filename) tmp = path.join(tmp, filename)
-  return tmp
-}
-
-export async function sqlQuery(sqlHandle: SqlQueryable, query: string, values: unknown[] = []): Promise<unknown> {
-  return await new Promise((resolve, reject) => {
-    sqlHandle.query(query, values, (err, res) => {
-      if (err) return reject(err)
-      resolve(res)
-    })
-  })
-}
-
-export function isMochaRunning(): boolean {
-  const context = globalThis as typeof globalThis & Record<string, unknown>
-  return ['afterEach', 'after', 'beforeEach', 'before', 'describe', 'it'].every((functionName) => {
-    return context[functionName] instanceof Function
-  })
-}
-
-export function validUUID4(uuid: string): boolean {
-  return /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(uuid)
-}
-
-export async function portCheck_tcp(port: number, opts: { timeout?: number; host?: string } = {}): Promise<boolean> {
-  const { timeout = 1000, host = '127.0.0.1' } = opts
-  const promise = new Promise<void>((resolve, reject) => {
-    const socket = new net.Socket()
-    const onError = (err: unknown) => {
-      debug(`onError`, err)
-      socket.destroy()
-      reject()
-    }
-    socket.setTimeout(timeout)
-    socket.once('error', onError)
-    socket.once('timeout', onError)
-    socket.connect(port, host, () => {
-      debug(`socket.connect ${host}:${port}`)
-      socket.end()
-      resolve()
-    })
-  })
-  try {
-    await promise
-    return true
-  } catch (e) {
-    console.log(e)
-    return false
-  }
-}
-
-export function ensureProperty<T>(target: Record<string, unknown>, propsString: string, defaultValue: T | false = false, debugWalk = false): unknown {
-  function iterate(o: Record<string, unknown>, parts: string[]): unknown {
-    if (debugWalk) console.log(parts)
-    const pname = parts.shift()
-    if (pname === undefined) return defaultValue
-    if (debugWalk) console.log(`iterate`, o, pname)
-    if (Object.prototype.hasOwnProperty.call(o, pname) && typeof o[pname] === 'object' && o[pname] !== null && parts.length > 0) {
-      return iterate(o[pname] as Record<string, unknown>, parts)
-    }
-    if (debugWalk) console.log(`--`, o, pname, o[pname], parts)
-    if (Object.prototype.hasOwnProperty.call(o, pname) && parts.length === 0) return o[pname]
-    if (debugWalk) console.log(`+++`)
-    return defaultValue
-  }
-  const parts = propsString.split('.')
-  return iterate(target, parts)
-}
-
-export function int2ip(ipInt: number): string {
-  return `${ipInt >>> 24}.${(ipInt >> 16) & 255}.${(ipInt >> 8) & 255}.${ipInt & 255}`
-}
-
-export function ip2int(ip: string): number {
-  return (
-    ip.split('.').reduce((ipInt, octet) => (ipInt << 8) + parseInt(octet, 10), 0) >>> 0
-  )
-}
-
-export function encryptAES_CBC_NOIV(plainString: string, encryptionKey: string): string | false {
-  try {
-    const key = aesjs.utils.utf8.toBytes(encryptionKey)
-    const textBytes = aesjs.utils.utf8.toBytes(plainString)
-    const aesCbc = new aesjs.ModeOfOperation.cbc(key)
-    const encryptedBytes = aesCbc.encrypt(aesjs.padding.pkcs7.pad(textBytes, 16))
-    return aesjs.utils.hex.fromBytes(encryptedBytes)
-  } catch {
-    return false
-  }
-}
-
-export function decryptAES_CBC_NOIV(encryptedHex: string, encryptionKey: string): string | false {
-  try {
-    const key = aesjs.utils.utf8.toBytes(encryptionKey)
-    const encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex)
-    const aesCbc = new aesjs.ModeOfOperation.cbc(key)
-    const decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(encryptedBytes))
-    return aesjs.utils.utf8.fromBytes(decryptedBytes)
-  } catch {
-    return false
-  }
-}
-
-export function isReservedLANIP(address: string): boolean {
-  const reservedLANIPRanges = [
-    '127.0.0.0/8',
-    '10.0.0.0/8',
-    '172.16.0.0/12',
-    '192.168.0.0/16',
-    '100.64.0.0/10',
-    'fd00::/8',
-  ]
-  const normalizedAddress = net.isIPv6(address) ? ip6.normalize(address) : address
-  return ipRangeCheck(normalizedAddress, reservedLANIPRanges)
-}
-

package/ts/funcs/Geoip2Paths.test.ts

@@ -1,11 +0,0 @@
-import { Geoip2Paths } from './Geoip2Paths'
-import * as fs from 'fs'
-
-describe('Geoip2Paths', () => {
-  it('should return a valid path', () => {
-    const paths = Geoip2Paths()
-    expect(paths).toHaveProperty('country')
-    expect(typeof paths.country).toBe('string')
-    expect(fs.existsSync(paths.country as string)).toBe(true)
-  })
-})

package/ts/funcs/Geoip2Paths.ts

@@ -1,28 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-export type Geoip2Paths = {
-    country:string|false,
-    city:string|false,
-    isp:string|false,
-    ct:string|false,
-}
-
-
-export function Geoip2Paths() :Geoip2Paths {
-    function firstExisting(paths:Array<string>) : string|false {
-        if (Array.isArray(paths))
-            for(let fpath of paths)
-                if (fs.existsSync(fpath)) return fpath
-        return false
-    }
-
-    const pkgRoot = path.join(__dirname, '..', '..')
-    const mainPath = require?.main?.path
-    return {
-        country:firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb','/usr/local/var/GeoIP/GeoIP2-Country.mmdb','/var/lib/GeoIP/GeoIP2-Country.mmdb','/usr/share/GeoIP/GeoIP2-Country.mmdb',path.join(pkgRoot, 'assets/GeoIP2-Country.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-Country.mmdb')]),
-        city:firstExisting(['/opt/geoip2/GeoIP2-City.mmdb','/usr/local/var/GeoIP/GeoIP2-City.mmdb','/var/lib/GeoIP/GeoIP2-City.mmdb','/usr/share/GeoIP/GeoIP2-City.mmdb',path.join(pkgRoot, 'assets/GeoIP2-City.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-City.mmdb')]),
-        isp:firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb','/usr/local/var/GeoIP/GeoIP2-ISP.mmdb','/var/lib/GeoIP/GeoIP2-ISP.mmdb','/usr/share/GeoIP/GeoIP2-ISP.mmdb',path.join(pkgRoot, 'assets/GeoIP2-ISP.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-ISP.mmdb')]),
-        ct:firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb','/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb','/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb','/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb',path.join(pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb'),path.join(mainPath || pkgRoot, 'assets/GeoIP2-Connection-Type.mmdb')]),
-    }
-}

package/ts/funcs/MaxRuntimeHours.ts

@@ -1,7 +0,0 @@
-
-export function MaxRuntimeHours(hours:number=24) {
-    setTimeout(() => {
-        console.log(`Max runtime of ${hours} hours reached, exiting`)
-        process.exit(0)
-    }, hours * 60 * 60 * 1000)
-}

package/ts/funcs/asJSON.test.js

@@ -1,72 +0,0 @@
-const { asJSON } = require('./asJSON')
-
-describe('asJSON', () => {
-    // Returns parsed JSON object when valid JSON string is passed as input.
-    it('should return parsed JSON object when valid JSON string is passed as input', () => {
-        const inputString = '{"name": "John", "age": 30}';
-        const expectedOutput = { name: "John", age: 30 };
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when empty string is passed as input.
-    it('should return false when empty string is passed as input', () => {
-        const inputString = "";
-        const expectedOutput = false;
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when non-string input is passed.
-    it('should return false when non-string input is passed', () => {
-        const inputString = 123;
-        const expectedOutput = false;
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when null is passed as input.
-    it('should return false when null is passed as input', () => {
-        const inputString = null;
-        const expectedOutput = false;
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when undefined is passed as input.
-    it('should return false when undefined is passed as input', () => {
-        const inputString = undefined;
-        const expectedOutput = false;
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when NaN is passed as input.
-    it('should return false when NaN is passed as input', () => {
-        const inputString = NaN;
-        const expectedOutput = false;
-        const result = asJSON(inputString);
-        expect(result).toEqual(expectedOutput);
-    });
-
-    // Returns false when invalid JSON string is passed as input.
-    it('should return false when invalid JSON string is passed as input', () => {
-      const inputString = 'invalid json';
-      const result = asJSON(inputString);
-      expect(result).toBe(false);
-    });
-
-    // Returns false when Infinity is passed as input.
-    it('should return false when Infinity is passed as input', () => {
-      const inputString = 'Infinity';
-      const result = asJSON(inputString);
-      expect(result).toBe(false);
-    });
-
-    // Returns false when input string contains a single quote.
-    it('should return false when input string contains a single quote', () => {
-      const inputString = "{'name': 'John'}";
-      const result = asJSON(inputString);
-      expect(result).toBe(false);
-    });
-});

package/ts/funcs/asJSON.ts

@@ -1,9 +0,0 @@
-export function asJSON(str: unknown): unknown | false {
-  if (!str || typeof str !== 'string') return false
-  try {
-    return JSON.parse(str)
-  } catch {
-    /* ignore */
-  }
-  return false
-}

package/ts/funcs/deepCopy.test.ts

@@ -1,108 +0,0 @@
-import { Unixtime } from "../models/Unixtime";
-import { deepCopy } from "./deepCopy"
-
-describe('deepCopy', () => {
-  it('deep-copies plain objects', () => {
-    const src = { a: 1, b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-
-    copy.b.c = 3;
-    expect(src.b.c).toBe(2);   // original stays intact
-  });
-
-
-  it('Date objects are copied as Date objects', () => {
-    const src = { date: new Date() }
-    const copy = deepCopy(src) as typeof src
-    expect(copy.date).toBeInstanceOf(Date)
-    expect(copy.date).not.toBe(src.date)
-  })
-
-  it('deep-copies arrays', () => {
-    const src = [1, [2, 3]];
-    const copy = deepCopy(src) as typeof src;
-
-    expect(copy).toEqual(src);
-    //@ts-ignore
-    copy[1][0] = 99;
-    //@ts-ignore
-    expect(src[1][0]).toBe(2);
-  });
-
-  it('returns primitives unchanged', () => {
-    expect(deepCopy(42 as any)).toBe(42);
-    expect(deepCopy('hello' as any)).toBe('hello');
-    expect(deepCopy(null as any)).toBeNull();
-  });
-
-  it('should handle circular references', () => {
-    const obj: any = { a: 1 };
-    obj.self = obj;
-    const copy = deepCopy(obj);
-    expect(copy).toEqual({ a: 1, self: copy });
-    expect(copy.self).toBe(copy);
-  });
-
-  it('should preserve prototype chain', () => {
-    class MyClass { x = 1; }
-    const obj = new MyClass();
-    const copy = deepCopy(obj);
-    expect(copy).toBeInstanceOf(MyClass);
-    expect(copy.x).toBe(1);
-  });
-
-  it('changing Date at src should not change copy', () => {
-    const src = { a: new Date("2024-05-05"), b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-    src.a.setFullYear(2025)
-    expect(src.a.getFullYear()).toBe(2025)
-    expect(copy.a.getFullYear()).toBe(2024)
-  })
-
-  it('changing src integer should not change copy', () => {
-    const src = { a: 1, b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-    src.a = 2
-    expect(src.a).toBe(2)
-    expect(copy.a).toBe(1)
-  })
-
-  it('changing src string should not change copy', () => {
-    const src = { a: "hello", b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-    src.a = "world"
-    expect(src.a).toBe("world")
-    expect(copy.a).toBe("hello")
-  })
-
-  it('changing src boolean should not change copy', () => {
-    const src = { a: true, b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-    src.a = false
-    expect(src.a).toBe(false)
-    expect(copy.a).toBe(true)
-
-  })
-
-  it('changing src Unixtime should not change copy', () => {
-    const src = { a: new Unixtime("2024-05-02"), b: { c: 2 } };
-    const copy = deepCopy(src) as typeof src;
-    expect(copy).toEqual(src);
-    expect(copy).not.toBe(src);
-    src.a.addYears(-1)
-    expect(src.a.toDate().getFullYear()).toBe(2023)
-    expect(copy.a.toDate().getFullYear()).toBe(2024)
-  })
-
-});

package/ts/funcs/deepCopy.ts

@@ -1,34 +0,0 @@
-export function deepCopy<T>(obj: T, visited = new WeakMap()): T {
-    // Handle null and non-objects
-    if (obj === null || typeof obj !== 'object') {
-      return obj;
-    }
-  
-    // Handle circular references
-    if (visited.has(obj)) {
-      return visited.get(obj);
-    }
-  
-    // Handle Date
-    if (obj instanceof Date) {
-      return new Date(obj.getTime()) as any;
-    }
-  
-    // Handle Array
-    if (Array.isArray(obj)) {
-      const copy: any[] = [];
-      visited.set(obj, copy);
-      obj.forEach((item, i) => {
-        copy[i] = deepCopy(item, visited);
-      });
-      return copy as T;
-    }
-  
-    // Handle Object
-    const copy = Object.create(Object.getPrototypeOf(obj));
-    visited.set(obj, copy);
-    for (const key of Object.keys(obj)) {
-      copy[key] = deepCopy((obj as any)[key], visited);
-    }
-    return copy;
-  }