@certik/skynet 0.24.0 → 0.25.0

package/dist/availability.d.ts

@@ -1,23 +0,0 @@
-import pThrottle from "p-throttle";
-import { type CacheStorage } from "p-memoize";
-import type { AsyncReturnType } from "type-fest";
-export declare type AnyAsyncFunction = (...arguments_: readonly any[]) => Promise<any>;
-export declare function wait(time: number): Promise<unknown>;
-export declare function exponentialRetry<T>(func: () => Promise<T>, { maxRetry, initialDuration, growFactor, test, verbose, }: {
-    maxRetry: number;
-    initialDuration?: number;
-    growFactor?: number;
-    test: (result: T) => boolean;
-    verbose?: boolean;
-}): Promise<T>;
-export declare function withRetry<F extends AnyAsyncFunction>(func: F, options?: {
-    maxRetry?: number;
-    initialDuration?: number;
-    growFactor?: number;
-}): F;
-export declare function memoize<F extends AnyAsyncFunction>(func: F, options?: {
-    cache?: CacheStorage<string, AsyncReturnType<F>> | false;
-    cacheKey?: (args: Parameters<F>) => string;
-    lruMaxSize?: number;
-}): F;
-export { pThrottle as throttle };

package/dist/availability.js

@@ -1,133 +0,0 @@
-// src/object-hash.ts
-import xh from "@node-rs/xxhash";
-function getHash(obj) {
-  const xxh3 = xh.xxh3.Xxh3.withSeed();
-  hash(obj, xxh3);
-  return xxh3.digest().toString(16);
-}
-function hash(obj, xxh3) {
-  if (obj === null) {
-    xxh3.update("null");
-  } else if (obj === undefined) {
-    xxh3.update("undefined");
-  } else if (typeof obj === "string") {
-    xxh3.update(obj);
-  } else if (typeof obj === "number") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "boolean") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "bigint") {
-    xxh3.update(obj.toString());
-  } else if (obj instanceof Date) {
-    xxh3.update(obj.toISOString());
-  } else if (Array.isArray(obj)) {
-    arrayHash(obj, xxh3);
-  } else if (obj instanceof Set) {
-    setHash(obj, xxh3);
-  } else if (obj instanceof Map) {
-    mapHash(obj, xxh3);
-  } else if (typeof obj === "object") {
-    objectHash(obj, xxh3);
-  } else {
-    throw new Error(`Unsupported type: ${obj}`);
-  }
-}
-function arrayHash(array, xxh3) {
-  xxh3.update("[");
-  for (const obj of array) {
-    hash(obj, xxh3);
-  }
-  xxh3.update("]");
-}
-function setHash(_set, _xxh3) {
-  throw new Error("Set hashing not implemented");
-}
-function mapHash(map, xxh3) {
-  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-function objectHash(obj, xxh3) {
-  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-
-// src/availability.ts
-import pThrottle from "p-throttle";
-import pMemoize from "p-memoize";
-import QuickLRU from "quick-lru";
-async function wait(time) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-}
-async function exponentialRetry(func, {
-  maxRetry,
-  initialDuration,
-  growFactor,
-  test,
-  verbose
-}) {
-  let retries = maxRetry;
-  let duration = initialDuration || 5000;
-  const growFactorFinal = growFactor || 2;
-  let result = await func();
-  while (!test(result) && retries > 0) {
-    if (verbose) {
-      console.log("failed attempt result", result);
-      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
-    }
-    retries = retries - 1;
-    await wait(duration);
-    result = await func();
-    duration = duration * growFactorFinal;
-  }
-  if (verbose) {
-    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
-  }
-  return result;
-}
-function withRetry(func, options) {
-  let retries = options?.maxRetry || 3;
-  let duration = options?.initialDuration || 500;
-  const growFactorFinal = options?.growFactor || 2;
-  return async (...args) => {
-    do {
-      try {
-        return await func(...args);
-      } catch (error) {
-        retries = retries - 1;
-        if (retries <= 0) {
-          throw error;
-        }
-        await wait(duration);
-        duration = duration * growFactorFinal;
-      }
-    } while (retries > 0);
-    throw new Error("unreachable");
-  };
-}
-function memoize(func, options) {
-  if (!options) {
-    options = {};
-  }
-  if (!options.cache) {
-    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
-  }
-  if (!options.cacheKey) {
-    options.cacheKey = (args) => getHash(args);
-  }
-  return pMemoize(func, options);
-}
-export {
-  withRetry,
-  wait,
-  pThrottle as throttle,
-  memoize,
-  exponentialRetry
-};

package/dist/cli.d.ts

@@ -1,5 +0,0 @@
-declare function getBinaryName(): string;
-declare function detectSkynetDirectory(): string;
-declare function detectWorkingDirectory(): string;
-declare function detectBin(): string;
-export { getBinaryName, detectSkynetDirectory, detectWorkingDirectory, detectBin };

package/dist/cli.js

@@ -1,41 +0,0 @@
-// src/cli.ts
-import path from "path";
-import fs from "fs";
-function getBinaryName() {
-  const binaryNameParts = process.argv[1].split(path.sep);
-  const binaryName = binaryNameParts[binaryNameParts.length - 1];
-  return binaryName;
-}
-function detectSkynetDirectory() {
-  return detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-}
-function detectWorkingDirectory() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-  const skynetd = detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
-}
-function detectDirectory(fullBinPath, sentinel = "package.json") {
-  let parentFolder = path.dirname(fullBinPath);
-  while (parentFolder) {
-    const sentinelPath = path.join(parentFolder, sentinel);
-    if (fs.existsSync(sentinelPath)) {
-      return parentFolder;
-    }
-    const newParentFolder = path.dirname(parentFolder);
-    if (newParentFolder === parentFolder) {
-      break;
-    }
-    parentFolder = newParentFolder;
-  }
-  throw new Error("Cannot detect current working directory");
-}
-function detectBin() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
-}
-export {
-  getBinaryName,
-  detectWorkingDirectory,
-  detectSkynetDirectory,
-  detectBin
-};

package/dist/const.d.ts

@@ -1,34 +0,0 @@
-type Protocol = {
-    nativeTokenName: string;
-    nativeTokenSymbol: string;
-    nativeTokenDecimals: number;
-    nativeTokenAddress: string;
-    nativeTokenLogo?: string;
-    nativeTokenCoinGeckoId?: string;
-    nativeTokenCmcId?: number;
-    endpoint: string;
-    backupEndpoint?: string;
-    archiveEndpoint?: string;
-    tokenStandard: string;
-    scanApi?: {
-        endpoint: string;
-        key?: string;
-    };
-    multiCallProvider?: string;
-    scanUrl?: string;
-    chainId: number;
-};
-type TimeIntervals = {
-    SECOND: number;
-    MINUTE: number;
-    HOUR: number;
-    DAY: number;
-    WEEK: number;
-    YEAR: number;
-};
-declare const PROTOCOLS: Record<string, Protocol>;
-declare const TIME: {
-    BY_MS: TimeIntervals;
-    BY_S: TimeIntervals;
-};
-export { PROTOCOLS, TIME };

package/dist/const.js

@@ -1,162 +0,0 @@
-// src/env.ts
-function ensureAndGet(envName, defaultValue) {
-  return process.env[envName] || defaultValue;
-}
-function getEnvironment() {
-  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
-}
-function getEnvOrThrow(envName) {
-  if (!process.env[envName]) {
-    throw new Error(`Must set environment variable ${envName}`);
-  }
-  return process.env[envName];
-}
-function isProduction() {
-  return getEnvironment() === "prd";
-}
-function isDev() {
-  return getEnvironment() === "dev";
-}
-// src/const.ts
-function getNodeRealApiKey(identifier) {
-  return ensureAndGet(`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`) ?? ensureAndGet("SKYNET_NODEREAL_API_KEY");
-}
-var PROTOCOLS = {
-  eth: {
-    nativeTokenName: "Ethereum",
-    nativeTokenSymbol: "ETH",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "eth:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/eth:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "ethereum",
-    nativeTokenCmcId: 1027,
-    endpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
-    archiveEndpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
-    tokenStandard: "ERC20",
-    scanApi: {
-      endpoint: "https://api.etherscan.io/api",
-      key: ensureAndGet("SKYNET_ETHER_SCAN_API_KEY")
-    },
-    multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
-    scanUrl: "https://etherscan.io/",
-    chainId: 1
-  },
-  bsc: {
-    nativeTokenName: "Binance Coin",
-    nativeTokenSymbol: "BNB",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "bsc:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/bsc:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "binance-coin",
-    nativeTokenCmcId: 1839,
-    endpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
-    archiveEndpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
-    tokenStandard: "BEP20",
-    scanApi: {
-      endpoint: "https://api.bscscan.com/api",
-      key: ensureAndGet("SKYNET_BSC_SCAN_API_KEY")
-    },
-    multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
-    scanUrl: "https://bscscan.com/",
-    chainId: 56
-  },
-  polygon: {
-    nativeTokenName: "Polygon",
-    nativeTokenSymbol: "MATIC",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/polygon:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "matic-network",
-    nativeTokenCmcId: 3890,
-    endpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
-    archiveEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
-    backupEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
-    tokenStandard: "ERC20",
-    scanApi: {
-      endpoint: "https://api.polygonscan.com/api",
-      key: ensureAndGet("SKYNET_POLYGON_SCAN_API_KEY")
-    },
-    multiCallProvider: "0x8eC86392e0aDB57d00fDffbA39b8870e107c0757",
-    scanUrl: "https://polygonscan.com/",
-    chainId: 137
-  },
-  heco: {
-    nativeTokenName: "Heco",
-    nativeTokenSymbol: "HT",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "heco:0x0000000000000000000000000000000000000000",
-    endpoint: `https://http-mainnet.hecochain.com`,
-    tokenStandard: "HRC20",
-    multiCallProvider: "0xe7144e57d832c9005d252f415d205b4b8d78228e",
-    scanUrl: "https://hecoinfo.com/",
-    chainId: 128
-  },
-  avax: {
-    nativeTokenName: "Avalanche",
-    nativeTokenSymbol: "AVAX",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "avax:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/avax:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "avalanche-2",
-    nativeTokenCmcId: 5805,
-    endpoint: `https://api.avax.network/ext/bc/C/rpc`,
-    tokenStandard: "ARC20",
-    scanApi: {
-      endpoint: "https://api.snowtrace.io/api",
-      key: ensureAndGet("SKYNET_AVASCAN_API_KEY")
-    },
-    scanUrl: "https://snowtrace.io/",
-    chainId: 43114
-  },
-  ftm: {
-    nativeTokenName: "Fantom",
-    nativeTokenSymbol: "FTM",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "ftm:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/ftm:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "fantom",
-    nativeTokenCmcId: 3513,
-    endpoint: `https://rpcapi.fantom.network`,
-    tokenStandard: "ERC20",
-    scanApi: {
-      endpoint: "https://api.ftmscan.com/api",
-      key: ensureAndGet("SKYNET_FTMSCAN_API_KEY")
-    },
-    scanUrl: "https://ftmscan.com/",
-    chainId: 250
-  },
-  algo: {
-    nativeTokenName: "Algorand",
-    nativeTokenSymbol: "ALGO",
-    nativeTokenDecimals: 6,
-    nativeTokenAddress: "algo:native",
-    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/algo:native.png`,
-    nativeTokenCoinGeckoId: "algorand",
-    nativeTokenCmcId: 4030,
-    endpoint: "https://algo-node.certik-skynet.com/",
-    tokenStandard: "ASA",
-    chainId: 1300
-  }
-};
-var TIME = {
-  BY_MS: {
-    SECOND: 1000,
-    MINUTE: 1000 * 60,
-    HOUR: 1000 * 60 * 60,
-    DAY: 1000 * 60 * 60 * 24,
-    WEEK: 1000 * 60 * 60 * 24 * 7,
-    YEAR: 1000 * 60 * 60 * 24 * 365
-  },
-  BY_S: {
-    SECOND: 1,
-    MINUTE: 60,
-    HOUR: 60 * 60,
-    DAY: 60 * 60 * 24,
-    WEEK: 60 * 60 * 24 * 7,
-    YEAR: 60 * 60 * 24 * 365
-  }
-};
-export {
-  TIME,
-  PROTOCOLS
-};

package/dist/databricks.d.ts

@@ -1,3 +0,0 @@
-import type { DBSQLParameterValue } from "@databricks/sql/dist/DBSQLParameter.js";
-declare function executeSql<T>(sql: string, bindings: Record<string, DBSQLParameterValue>): Promise<T[]>;
-export { executeSql };

package/dist/databricks.js

@@ -1,208 +0,0 @@
-// src/env.ts
-function ensureAndGet(envName, defaultValue) {
-  return process.env[envName] || defaultValue;
-}
-function getEnvironment() {
-  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
-}
-function getEnvOrThrow(envName) {
-  if (!process.env[envName]) {
-    throw new Error(`Must set environment variable ${envName}`);
-  }
-  return process.env[envName];
-}
-function isProduction() {
-  return getEnvironment() === "prd";
-}
-function isDev() {
-  return getEnvironment() === "dev";
-}
-// src/object-hash.ts
-import xh from "@node-rs/xxhash";
-function getHash(obj) {
-  const xxh3 = xh.xxh3.Xxh3.withSeed();
-  hash(obj, xxh3);
-  return xxh3.digest().toString(16);
-}
-function hash(obj, xxh3) {
-  if (obj === null) {
-    xxh3.update("null");
-  } else if (obj === undefined) {
-    xxh3.update("undefined");
-  } else if (typeof obj === "string") {
-    xxh3.update(obj);
-  } else if (typeof obj === "number") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "boolean") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "bigint") {
-    xxh3.update(obj.toString());
-  } else if (obj instanceof Date) {
-    xxh3.update(obj.toISOString());
-  } else if (Array.isArray(obj)) {
-    arrayHash(obj, xxh3);
-  } else if (obj instanceof Set) {
-    setHash(obj, xxh3);
-  } else if (obj instanceof Map) {
-    mapHash(obj, xxh3);
-  } else if (typeof obj === "object") {
-    objectHash(obj, xxh3);
-  } else {
-    throw new Error(`Unsupported type: ${obj}`);
-  }
-}
-function arrayHash(array, xxh3) {
-  xxh3.update("[");
-  for (const obj of array) {
-    hash(obj, xxh3);
-  }
-  xxh3.update("]");
-}
-function setHash(_set, _xxh3) {
-  throw new Error("Set hashing not implemented");
-}
-function mapHash(map, xxh3) {
-  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-function objectHash(obj, xxh3) {
-  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-
-// src/availability.ts
-import pThrottle from "p-throttle";
-import pMemoize from "p-memoize";
-import QuickLRU from "quick-lru";
-async function wait(time) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-}
-async function exponentialRetry(func, {
-  maxRetry,
-  initialDuration,
-  growFactor,
-  test,
-  verbose
-}) {
-  let retries = maxRetry;
-  let duration = initialDuration || 5000;
-  const growFactorFinal = growFactor || 2;
-  let result = await func();
-  while (!test(result) && retries > 0) {
-    if (verbose) {
-      console.log("failed attempt result", result);
-      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
-    }
-    retries = retries - 1;
-    await wait(duration);
-    result = await func();
-    duration = duration * growFactorFinal;
-  }
-  if (verbose) {
-    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
-  }
-  return result;
-}
-function withRetry(func, options) {
-  let retries = options?.maxRetry || 3;
-  let duration = options?.initialDuration || 500;
-  const growFactorFinal = options?.growFactor || 2;
-  return async (...args) => {
-    do {
-      try {
-        return await func(...args);
-      } catch (error) {
-        retries = retries - 1;
-        if (retries <= 0) {
-          throw error;
-        }
-        await wait(duration);
-        duration = duration * growFactorFinal;
-      }
-    } while (retries > 0);
-    throw new Error("unreachable");
-  };
-}
-function memoize(func, options) {
-  if (!options) {
-    options = {};
-  }
-  if (!options.cache) {
-    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
-  }
-  if (!options.cacheKey) {
-    options.cacheKey = (args) => getHash(args);
-  }
-  return pMemoize(func, options);
-}
-// src/databricks.ts
-import { DBSQLClient, DBSQLParameter } from "@databricks/sql";
-var client = null;
-var session = null;
-async function initSession() {
-  if (!client) {
-    client = new DBSQLClient;
-    await client.connect({
-      authType: "access-token",
-      token: getEnvOrThrow("SKYNET_DATABRICKS_TOKEN"),
-      host: getEnvOrThrow("SKYNET_DATABRICKS_SERVER_HOSTNAME"),
-      path: getEnvOrThrow("SKYNET_DATABRICKS_HTTP_PATH")
-    });
-  }
-  if (!session) {
-    session = await client.openSession();
-  }
-}
-async function executeSql(sql, bindings) {
-  const results = await exponentialRetry(async () => {
-    let queryOperation;
-    try {
-      await initSession();
-      if (!session)
-        throw new Error("Session is not initialized");
-      queryOperation = await session.executeStatement(sql, {
-        runAsync: true,
-        namedParameters: objToParameter(bindings)
-      });
-      const result = await queryOperation.fetchAll();
-      return result;
-    } catch (err) {
-      if (!checkIsDatabricksError(err)) {
-        throw err;
-      }
-      return err;
-    } finally {
-      await queryOperation?.close();
-    }
-  }, {
-    maxRetry: 3,
-    initialDuration: 500,
-    test: (result) => {
-      return !checkIsDatabricksError(result);
-    }
-  });
-  if (checkIsDatabricksError(results)) {
-    throw results;
-  }
-  return results;
-}
-function checkIsDatabricksError(err) {
-  return err?.errno === "ECONNRESET" || err?.message?.includes("java.lang.NullPointerException");
-}
-function objToParameter(obj) {
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    acc[key] = new DBSQLParameter({ value });
-    return acc;
-  }, {});
-}
-export {
-  executeSql
-};

package/dist/date.d.ts

@@ -1,5 +0,0 @@
-declare function getDateOnly(date: number | string | Date): string;
-declare function findDateAfter(date: number | string | Date, n: number): string;
-declare function daysInRange(from: number | string | Date, to: number | string | Date): string[];
-declare function dateRange(from: number | string | Date, to: number | string | Date, step: number): [string, string][];
-export { getDateOnly, findDateAfter, daysInRange, dateRange };

package/dist/date.js

@@ -1,56 +0,0 @@
-// src/util.ts
-function range(startAt, endAt, step) {
-  const arr = [];
-  for (let i = startAt;i <= endAt; i += step) {
-    arr.push([i, Math.min(endAt, i + step - 1)]);
-  }
-  return arr;
-}
-function arrayGroup(array, groupSize) {
-  const groups = [];
-  for (let i = 0;i < array.length; i += groupSize) {
-    groups.push(array.slice(i, i + groupSize));
-  }
-  return groups;
-}
-function fillRange(start, end) {
-  const result = [];
-  for (let i = start;i <= end; i++) {
-    result.push(i);
-  }
-  return result;
-}
-// src/date.ts
-var MS_IN_A_DAY = 3600 * 24 * 1000;
-function getDateOnly(date) {
-  return new Date(date).toISOString().split("T")[0];
-}
-function findDateAfter(date, n) {
-  const d = new Date(date);
-  const after = new Date(d.getTime() + MS_IN_A_DAY * n);
-  return getDateOnly(after);
-}
-function daysInRange(from, to) {
-  const fromTime = new Date(from).getTime();
-  const toTime = new Date(to).getTime();
-  if (fromTime > toTime) {
-    throw new Error(`range to date couldn't be earlier than range from date`);
-  }
-  const daysBetween = Math.floor((toTime - fromTime) / MS_IN_A_DAY);
-  const dates = [getDateOnly(new Date(fromTime))];
-  for (let i = 1;i <= daysBetween; i += 1) {
-    dates.push(getDateOnly(new Date(fromTime + i * MS_IN_A_DAY)));
-  }
-  return dates;
-}
-function dateRange(from, to, step) {
-  const days = daysInRange(from, to);
-  const windows = arrayGroup(days, step);
-  return windows.map((w) => [w[0], w[w.length - 1]]);
-}
-export {
-  getDateOnly,
-  findDateAfter,
-  daysInRange,
-  dateRange
-};