apollo79

export type Epoch =
  | "millisecond"
  | "milliseconds"
  | "ms"
  | "second"
  | "seconds"
  | "sec"
  | "s"
  | "minute"
  | "minutes"

apollo79

import { Deferred } from "https://deno.land/std@0.161.0/async/deferred.ts";

export interface DeferredPromise<T> extends Promise<T> {
  readonly state: Deferred<T>["state"];
}

export function createDeferredPromise<T>(
  deferred: Deferred<T>
): DeferredPromise<T> {
  const promise = new Promise((resolve, reject) => {

apollo79

const waitForTimeout = (
    fn: (args?: unknown[]) => void | Promise<void>,
    timeout: number,
    ...args: any[]
): Promise<void> => {
    return new Promise((resolve) => {
        const timeoutId = setTimeout(
            async (args) => {
                await fn(args);

apollo79

export function isJSON(str: unknown) {
    if (typeof str !== "string") return false;

    try {
        const result = JSON.parse(str);

        const type = Object.prototype.toString.call(result);

        return type === "[object Object]" ||
            type === "[object Array]";

apollo79

const ArrayBufferView =
    Object.getPrototypeOf(Object.getPrototypeOf(new Uint8Array())).constructor;

export function isAbv(value: unknown) {
    return value instanceof ArrayBufferView;
}

apollo79

type Fn<
    Params extends readonly unknown[] = readonly unknown[],
    Result = unknown,
> = (...params: Params) => Result;

export class EnhancedSet<T> extends Set<T> {
    map(func: Fn<[T], T>): EnhancedSet<unknown> {
        const newSet = new EnhancedSet();

        for (const value of this) {

apollo79

export type ValueAndKeyFunction<K = unknown, V = unknown, R = unknown> = (
    value: V,
    key?: K,
    map?: EnhancedMap<K, V>,
) => R;

// deno-lint-ignore no-explicit-any
export class EnhancedMap<K = any, V = any> extends Map<K, V> {
    map<TK = unknown, TV = unknown>(
        func: ValueAndKeyFunction<K, V, [TK, TV]>,

apollo79

export const createMapEntryIfNotExistsAndGet = <K = unknown, T = unknown>(
    map: Map<K, T>,
    name: K,
    value: T,
) => {
    if (map.has(name)) {
        return map.get(name)!;
    }

    return map.set(name, value).get(name)!;

apollo79

type Epoch = 'years' | 'months' | 'days' | 'hours' | 'minutes' | 'seconds' | 'now';

const epochs: Record<Epoch, number> = {
    years: 31536000,
    months: 2592000,
    days: 86400,
    hours: 3600,
    minutes: 60,
    seconds: 1,
    now: 0,