@scaleway/sdk 2.26.0 → 2.28.0

package/dist/scw/fetch/http-interceptors.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../internal/logger/index.cjs");
+const levelResolver = require("../../internal/logger/level-resolver.cjs");
+const httpDumper = require("./http-dumper.cjs");
+class ObfuscatedRequest extends Request {
+  constructor(request, obfuscate) {
+    super(request);
+    this.request = request;
+    this.obfuscate = obfuscate;
+  }
+  get headers() {
+    return new Headers(Array.from(this.request.headers, this.obfuscate));
+  }
+  clone() {
+    return new ObfuscatedRequest(this.request, this.obfuscate);
+  }
+}
+const obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
+const identity = ({ request }) => request;
+const logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
+  if (levelResolver.shouldLog(levelResolver.LevelResolver[index.getLogger().logLevel], "debug")) {
+    index.getLogger().debug(
+      `--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await httpDumper.dumpRequest(await obfuscate({ request }))}
+---------------------------------------------------------`
+    );
+  }
+  return request;
+};
+const logResponse = (identifier) => async ({ response }) => {
+  if (levelResolver.shouldLog(levelResolver.LevelResolver[index.getLogger().logLevel], "debug")) {
+    index.getLogger().debug(
+      `--------------- Scaleway SDK RESPONSE ${identifier} ---------------
+${await httpDumper.dumpResponse(response)}
+---------------------------------------------------------`
+    );
+  }
+  return response;
+};
+exports.logRequest = logRequest;
+exports.logResponse = logResponse;
+exports.obfuscateInterceptor = obfuscateInterceptor;

package/dist/scw/fetch/http-interceptors.d.ts

@@ -0,0 +1,38 @@
+import type { RequestInterceptor, ResponseInterceptor } from '../../internal/interceptors/types';
+/**
+ * Mapper of an header entry.
+ *
+ * @internal
+ */
+interface HeaderEntryMapper {
+    (entry: [string, string]): [string, string];
+}
+/**
+ * Creates an interceptor to obfuscate the requests.
+ *
+ * @param obfuscate - The Header entries obfuscator mapper
+ * @returns The obfuscated Request
+ *
+ * @internal
+ */
+export declare const obfuscateInterceptor: (obfuscate: HeaderEntryMapper) => RequestInterceptor;
+/**
+ * Creates an interceptor to log the requests.
+ *
+ * @param identifier - The request identifier
+ * @param obfuscate - The obfuscation interceptor
+ * @returns The interceptor
+ *
+ * @internal
+ */
+export declare const logRequest: (identifier: string, obfuscate?: RequestInterceptor) => RequestInterceptor;
+/**
+ * Creates an interceptor to log the responses.
+ *
+ * @param identifier - The request identifier
+ * @returns The interceptor
+ *
+ * @internal
+ */
+export declare const logResponse: (identifier: string) => ResponseInterceptor;
+export {};

package/dist/scw/fetch/http-interceptors.js

@@ -1,18 +1,6 @@
-import { getLogger } from '../../internal/logger/index.js';
-import { shouldLog, LevelResolver } from '../../internal/logger/level-resolver.js';
-import { dumpRequest, dumpResponse } from './http-dumper.js';
-
-/**
- * Mapper of an header entry.
- *
- * @internal
- */
-
-/**
- * HTTP Request with obfuscated secrets.
- *
- * @internal
- */
+import { getLogger } from "../../internal/logger/index.js";
+import { shouldLog, LevelResolver } from "../../internal/logger/level-resolver.js";
+import { dumpRequest, dumpResponse } from "./http-dumper.js";
 class ObfuscatedRequest extends Request {
   constructor(request, obfuscate) {
     super(request);
@@ -26,61 +14,30 @@ class ObfuscatedRequest extends Request {
     return new ObfuscatedRequest(this.request, this.obfuscate);
   }
 }
-
-/**
- * Creates an interceptor to obfuscate the requests.
- *
- * @param obfuscate - The Header entries obfuscator mapper
- * @returns The obfuscated Request
- *
- * @internal
- */
-const obfuscateInterceptor = obfuscate => ({
-  request
-}) => new ObfuscatedRequest(request, obfuscate);
-const identity = ({
-  request
-}) => request;
-
-/**
- * Creates an interceptor to log the requests.
- *
- * @param identifier - The request identifier
- * @param obfuscate - The obfuscation interceptor
- * @returns The interceptor
- *
- * @internal
- */
-const logRequest = (identifier, obfuscate = identity) => async ({
-  request
-}) => {
-  if (shouldLog(LevelResolver[getLogger().logLevel], 'debug')) {
-    getLogger().debug(`--------------- Scaleway SDK REQUEST ${identifier} ---------------
-${await dumpRequest(await obfuscate({
-      request
-    }))}
----------------------------------------------------------`);
+const obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
+const identity = ({ request }) => request;
+const logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
+  if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) {
+    getLogger().debug(
+      `--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await dumpRequest(await obfuscate({ request }))}
+---------------------------------------------------------`
+    );
   }
   return request;
 };
-
-/**
- * Creates an interceptor to log the responses.
- *
- * @param identifier - The request identifier
- * @returns The interceptor
- *
- * @internal
- */
-const logResponse = identifier => async ({
-  response
-}) => {
-  if (shouldLog(LevelResolver[getLogger().logLevel], 'debug')) {
-    getLogger().debug(`--------------- Scaleway SDK RESPONSE ${identifier} ---------------
+const logResponse = (identifier) => async ({ response }) => {
+  if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) {
+    getLogger().debug(
+      `--------------- Scaleway SDK RESPONSE ${identifier} ---------------
 ${await dumpResponse(response)}
----------------------------------------------------------`);
+---------------------------------------------------------`
+    );
   }
   return response;
 };
-
-export { logRequest, logResponse, obfuscateInterceptor };
+export {
+  logRequest,
+  logResponse,
+  obfuscateInterceptor
+};

package/dist/scw/fetch/resource-paginator.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const extract = (key) => (result) => result[key];
+function* pages(key, fetcher, request, firstPage) {
+  if (!Array.isArray(firstPage[key])) {
+    throw new Error(`Property ${key} is not a list in paginated result`);
+  }
+  const getList = extract(key);
+  let page = request.page || 1;
+  if (page === 1) {
+    yield Promise.resolve(getList(firstPage));
+    page += 1;
+  }
+  const { length } = firstPage[key];
+  if (!length)
+    return;
+  const { totalCount } = firstPage;
+  while (page <= Math.floor((totalCount + length - 1) / length)) {
+    yield fetcher({ ...request, page }).then(getList);
+    page += 1;
+  }
+}
+async function* fetchPaginated(key, fetcher, request, initial = fetcher(request)) {
+  yield* pages(key, fetcher, request, await initial);
+}
+const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
+const enrichForPagination = (key, fetcher, request) => {
+  const firstPage = fetcher(request);
+  return Object.assign(firstPage, {
+    all: () => fetchAll(key, fetcher, request, firstPage),
+    [Symbol.asyncIterator]: () => fetchPaginated(key, fetcher, request, firstPage)
+  });
+};
+exports.enrichForPagination = enrichForPagination;
+exports.extract = extract;
+exports.fetchAll = fetchAll;
+exports.fetchPaginated = fetchPaginated;

package/dist/scw/fetch/resource-paginator.d.ts

@@ -0,0 +1,47 @@
+interface PaginationOptions {
+    page?: number;
+    pageSize?: number;
+}
+interface PaginatedResponse {
+    totalCount: number;
+}
+export type PaginatedFetcher<T, R extends PaginationOptions = PaginationOptions> = (request: R) => Promise<T>;
+export type PaginatedContent<K extends string, T = unknown> = PaginatedResponse & {
+    [key in K]: T[];
+};
+export declare const extract: <K extends string>(key: K) => <T extends PaginatedContent<K, unknown>>(result: T) => T[K];
+/**
+ * Fetches a paginated resource.
+ *
+ * @param key - The resource key of values list
+ * @param fetcher - The method to retrieve paginated resources
+ * @param request - A request with pagination options
+ * @param initial - The first page
+ * @returns An async generator of resources arrays
+ */
+export declare function fetchPaginated<K extends string, T extends PaginatedContent<K>, R extends PaginationOptions>(key: K, fetcher: PaginatedFetcher<T, R>, request: R, initial?: Promise<T>): AsyncGenerator<T[K], void, void>;
+/**
+ * Fetches all paginated resource.
+ *
+ * @param key - The resource key of values list
+ * @param fetcher - The method to retrieve paginated resources
+ * @param request - A request with pagination options
+ * @param initial - The first page
+ * @returns A resources array Promise
+ */
+export declare const fetchAll: <K extends string, T extends PaginatedContent<K, unknown>, R extends PaginationOptions>(key: K, fetcher: PaginatedFetcher<T, R>, request: R, initial?: Promise<T>) => Promise<(Awaited<T[K]> extends infer T_1 ? T_1 extends Awaited<T[K]> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never)[]>;
+/**
+ * Enriches a listing method with helpers.
+ *
+ * @param key - The resource key of values list
+ * @param fetcher - The method to retrieve paginated resources
+ * @param request - A request with pagination options
+ * @returns A resource Promise with the pagination helpers
+ *
+ * @internal
+ */
+export declare const enrichForPagination: <K extends string, T extends PaginatedContent<K, unknown>, R extends PaginationOptions>(key: K, fetcher: PaginatedFetcher<T, R>, request: R) => Promise<T> & {
+    all: () => Promise<(Awaited<T[K]> extends infer T_1 ? T_1 extends Awaited<T[K]> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never)[]>;
+    [Symbol.asyncIterator]: () => AsyncGenerator<T[K], void, void>;
+};
+export {};

package/dist/scw/fetch/resource-paginator.js

@@ -1,4 +1,4 @@
-const extract = key => result => result[key];
+const extract = (key) => (result) => result[key];
 function* pages(key, fetcher, request, firstPage) {
   if (!Array.isArray(firstPage[key])) {
     throw new Error(`Property ${key} is not a list in paginated result`);
@@ -9,56 +9,19 @@ function* pages(key, fetcher, request, firstPage) {
     yield Promise.resolve(getList(firstPage));
     page += 1;
   }
-  const {
-    length
-  } = firstPage[key];
-  if (!length) return;
-  const {
-    totalCount
-  } = firstPage;
+  const { length } = firstPage[key];
+  if (!length)
+    return;
+  const { totalCount } = firstPage;
   while (page <= Math.floor((totalCount + length - 1) / length)) {
-    yield fetcher({
-      ...request,
-      page
-    }).then(getList);
+    yield fetcher({ ...request, page }).then(getList);
     page += 1;
   }
 }
-
-/**
- * Fetches a paginated resource.
- *
- * @param key - The resource key of values list
- * @param fetcher - The method to retrieve paginated resources
- * @param request - A request with pagination options
- * @param initial - The first page
- * @returns An async generator of resources arrays
- */
 async function* fetchPaginated(key, fetcher, request, initial = fetcher(request)) {
   yield* pages(key, fetcher, request, await initial);
 }
-
-/**
- * Fetches all paginated resource.
- *
- * @param key - The resource key of values list
- * @param fetcher - The method to retrieve paginated resources
- * @param request - A request with pagination options
- * @param initial - The first page
- * @returns A resources array Promise
- */
 const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
-
-/**
- * Enriches a listing method with helpers.
- *
- * @param key - The resource key of values list
- * @param fetcher - The method to retrieve paginated resources
- * @param request - A request with pagination options
- * @returns A resource Promise with the pagination helpers
- *
- * @internal
- */
 const enrichForPagination = (key, fetcher, request) => {
   const firstPage = fetcher(request);
   return Object.assign(firstPage, {
@@ -66,5 +29,9 @@ const enrichForPagination = (key, fetcher, request) => {
     [Symbol.asyncIterator]: () => fetchPaginated(key, fetcher, request, firstPage)
   });
 };
-
-export { enrichForPagination, extract, fetchAll, fetchPaginated };
+export {
+  enrichForPagination,
+  extract,
+  fetchAll,
+  fetchPaginated
+};

package/dist/scw/fetch/response-parser.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isResponse = require("../../helpers/is-response.cjs");
+const json = require("../../helpers/json.cjs");
+const errorParser = require("../errors/error-parser.cjs");
+const scwError = require("../errors/scw-error.cjs");
+const X_TOTAL_COUNT_HEADER_KEY = "x-total-count";
+const TOTAL_COUNT_RES_KEY = "total_count";
+const fixLegacyTotalCount = (obj, headers) => {
+  const headerVal = headers.get(X_TOTAL_COUNT_HEADER_KEY);
+  if (!headerVal) {
+    return obj;
+  }
+  const totalCount = parseInt(headerVal, 10);
+  if (Number.isNaN(totalCount)) {
+    return obj;
+  }
+  if (json.isJSONObject(obj) && !(TOTAL_COUNT_RES_KEY in obj)) {
+    return Object.assign(obj, { [TOTAL_COUNT_RES_KEY]: totalCount });
+  }
+  return obj;
+};
+const responseParser = (unmarshaller, responseType) => async (response) => {
+  if (!isResponse.isResponse(response)) {
+    throw new TypeError("Invalid response object");
+  }
+  if (response.ok) {
+    if (response.status === 204)
+      return unmarshaller(void 0);
+    const contentType = response.headers.get("Content-Type");
+    try {
+      if (responseType === "json" && contentType === "application/json") {
+        return unmarshaller(
+          fixLegacyTotalCount(await response.json(), response.headers)
+        );
+      }
+      if (responseType === "blob") {
+        return unmarshaller(await response.blob());
+      }
+      return unmarshaller(await response.text());
+    } catch (err) {
+      throw new scwError.ScalewayError(
+        response.status,
+        `could not parse '${contentType ?? ""}' response${err instanceof Error ? `: ${err.message}` : ""}`
+      );
+    }
+  }
+  const error = await response.clone().json().catch(() => response.text());
+  if (json.isJSONObject(error))
+    throw errorParser.parseScalewayError(response.status, error);
+  throw new scwError.ScalewayError(
+    response.status,
+    typeof error === "string" ? error : "cannot read error response body"
+  );
+};
+exports.fixLegacyTotalCount = fixLegacyTotalCount;
+exports.responseParser = responseParser;

package/dist/scw/fetch/response-parser.d.ts

@@ -0,0 +1,25 @@
+import type { ResponseUnmarshaller } from './types';
+/**
+ * Fixes the totalCount property for old APIs.
+ *
+ * @internal
+ */
+export declare const fixLegacyTotalCount: <T>(obj: T, headers: Headers) => T;
+/**
+ * Makes response parser.
+ *
+ * @param unmarshaller - The response payload unmarshaller
+ * @returns An async converter of HTTP Response to desired result
+ *
+ * @throws {@link ScalewayError}
+ * Thrown by the API if the request couldn't be completed.
+ *
+ * @throws TypeError
+ * Thrown if the response parameter isn't of the expected type.
+ *
+ * @throws Error
+ * JSON parsing could trigger an error.
+ *
+ * @internal
+ */
+export declare const responseParser: <T>(unmarshaller: ResponseUnmarshaller<T>, responseType: 'json' | 'text' | 'blob') => (response: Response) => Promise<T>;

package/dist/scw/fetch/response-parser.js

@@ -1,16 +1,9 @@
-import { isResponse } from '../../helpers/is-response.js';
-import { isJSONObject } from '../../helpers/json.js';
-import { parseScalewayError } from '../errors/error-parser.js';
-import { ScalewayError } from '../errors/scw-error.js';
-
-const X_TOTAL_COUNT_HEADER_KEY = 'x-total-count';
-const TOTAL_COUNT_RES_KEY = 'total_count';
-
-/**
- * Fixes the totalCount property for old APIs.
- *
- * @internal
- */
+import { isResponse } from "../../helpers/is-response.js";
+import { isJSONObject } from "../../helpers/json.js";
+import { parseScalewayError } from "../errors/error-parser.js";
+import { ScalewayError } from "../errors/scw-error.js";
+const X_TOTAL_COUNT_HEADER_KEY = "x-total-count";
+const TOTAL_COUNT_RES_KEY = "total_count";
 const fixLegacyTotalCount = (obj, headers) => {
   const headerVal = headers.get(X_TOTAL_COUNT_HEADER_KEY);
   if (!headerVal) {
@@ -21,52 +14,44 @@ const fixLegacyTotalCount = (obj, headers) => {
     return obj;
   }
   if (isJSONObject(obj) && !(TOTAL_COUNT_RES_KEY in obj)) {
-    return Object.assign(obj, {
-      [TOTAL_COUNT_RES_KEY]: totalCount
-    });
+    return Object.assign(obj, { [TOTAL_COUNT_RES_KEY]: totalCount });
   }
   return obj;
 };
-
-/**
- * Makes response parser.
- *
- * @param unmarshaller - The response payload unmarshaller
- * @returns An async converter of HTTP Response to desired result
- *
- * @throws {@link ScalewayError}
- * Thrown by the API if the request couldn't be completed.
- *
- * @throws TypeError
- * Thrown if the response parameter isn't of the expected type.
- *
- * @throws Error
- * JSON parsing could trigger an error.
- *
- * @internal
- */
-const responseParser = (unmarshaller, responseType) => async response => {
+const responseParser = (unmarshaller, responseType) => async (response) => {
   if (!isResponse(response)) {
-    throw new TypeError('Invalid response object');
+    throw new TypeError("Invalid response object");
   }
   if (response.ok) {
-    if (response.status === 204) return unmarshaller(undefined);
-    const contentType = response.headers.get('Content-Type');
+    if (response.status === 204)
+      return unmarshaller(void 0);
+    const contentType = response.headers.get("Content-Type");
     try {
-      if (responseType === 'json' && contentType === 'application/json') {
-        return unmarshaller(fixLegacyTotalCount(await response.json(), response.headers));
+      if (responseType === "json" && contentType === "application/json") {
+        return unmarshaller(
+          fixLegacyTotalCount(await response.json(), response.headers)
+        );
       }
-      if (responseType === 'blob') {
+      if (responseType === "blob") {
         return unmarshaller(await response.blob());
       }
       return unmarshaller(await response.text());
     } catch (err) {
-      throw new ScalewayError(response.status, `could not parse '${contentType ?? ''}' response${err instanceof Error ? `: ${err.message}` : ''}`);
+      throw new ScalewayError(
+        response.status,
+        `could not parse '${contentType ?? ""}' response${err instanceof Error ? `: ${err.message}` : ""}`
+      );
     }
   }
   const error = await response.clone().json().catch(() => response.text());
-  if (isJSONObject(error)) throw parseScalewayError(response.status, error);
-  throw new ScalewayError(response.status, typeof error === 'string' ? error : 'cannot read error response body');
+  if (isJSONObject(error))
+    throw parseScalewayError(response.status, error);
+  throw new ScalewayError(
+    response.status,
+    typeof error === "string" ? error : "cannot read error response body"
+  );
+};
+export {
+  fixLegacyTotalCount,
+  responseParser
 };
-
-export { fixLegacyTotalCount, responseParser };

package/dist/scw/fetch/types.d.ts

@@ -0,0 +1,16 @@
+/** Scaleway Request. */
+export type ScwRequest = {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    headers?: Record<string, string>;
+    body?: string;
+    urlParams?: URLSearchParams;
+    responseType?: 'json' | 'text' | 'blob';
+};
+/**
+ * A factory to unmarshal a response.
+ *
+ * @param obj - The input object.
+ * @returns The output object
+ */
+export type ResponseUnmarshaller<T> = (obj: unknown) => T;

package/dist/scw/locality.d.ts

@@ -0,0 +1,2 @@
+export type Region = 'fr-par' | 'nl-ams' | 'pl-waw' | (string & {});
+export type Zone = 'fr-par-1' | 'fr-par-2' | 'fr-par-3' | 'nl-ams-1' | 'nl-ams-2' | 'nl-ams-3' | 'pl-waw-1' | 'pl-waw-2' | (string & {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scaleway/sdk",
-  "version": "2.26.0",
+  "version": "2.28.0",
   "license": "Apache-2.0",
   "description": "Scaleway SDK.",
   "keywords": [
@@ -12,7 +12,11 @@
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "version": "./scripts/update-constants-file.sh"
+    "version": "./scripts/update-constants-file.sh",
+    "typecheck": "tsc --noEmit",
+    "type:generate": "tsc --declaration -p tsconfig.build.json",
+    "build": "vite build --config ../../vite.config.ts && pnpm run type:generate",
+    "build:profile": "npx vite-bundle-visualizer -c ../../vite.config.ts"
   },
   "files": [
     "dist"
@@ -35,5 +39,5 @@
   "bundledDependencies": [
     "@scaleway/random-name"
   ],
-  "gitHead": "845204da501951b48aa002f1715b343ffe15a1dd"
+  "gitHead": "a7d80e98eaa7977ce6ac697f3003823972f5c52f"
 }

package/dist/node_modules/.pnpm/@scaleway_random-name@4.0.3/node_modules/@scaleway/random-name/dist/index.js

@@ -1,11 +0,0 @@
-const ADJECTIVES = ['admiring', 'adoring', 'affectionate', 'agitated', 'amazing', 'angry', 'awesome', 'beautiful', 'blissful', 'bold', 'boring', 'brave', 'busy', 'charming', 'clever', 'cool', 'compassionate', 'competent', 'condescending', 'confident', 'cranky', 'crazy', 'dazzling', 'determined', 'distracted', 'dreamy', 'eager', 'ecstatic', 'elastic', 'elated', 'elegant', 'eloquent', 'epic', 'exciting', 'fervent', 'festive', 'flamboyant', 'focused', 'friendly', 'frosty', 'funny', 'gallant', 'gifted', 'goofy', 'gracious', 'great', 'happy', 'hardcore', 'heuristic', 'hopeful', 'hungry', 'infallible', 'inspiring', 'interesting', 'intelligent', 'jolly', 'jovial', 'keen', 'kind', 'laughing', 'loving', 'lucid', 'magical', 'mystifying', 'modest', 'musing', 'naughty', 'nervous', 'nice', 'nifty', 'nostalgic', 'objective', 'optimistic', 'peaceful', 'pedantic', 'pensive', 'practical', 'priceless', 'quirky', 'quizzical', 'recursing', 'relaxed', 'reverent', 'romantic', 'sad', 'serene', 'sharp', 'silly', 'sleepy', 'stoic', 'strange', 'stupefied', 'suspicious', 'sweet', 'tender', 'thirsty', 'trusting', 'unruffled', 'upbeat', 'vibrant', 'vigilant', 'vigorous', 'wizardly', 'wonderful', 'xenodochial', 'youthful', 'zealous', 'zen'];
-const NAMES = ['albattani', 'allen', 'almeida', 'antonelli', 'agnesi', 'archimedes', 'ardinghelli', 'aryabhata', 'austin', 'babbage', 'banach', 'banzai', 'bardeen', 'bartik', 'bassi', 'beaver', 'bell', 'benz', 'bhabha', 'bhaskara', 'black', 'blackburn', 'blackwell', 'bohr', 'booth', 'borg', 'bose', 'bouman', 'boyd', 'brahmagupta', 'brattain', 'brown', 'buck', 'burnell', 'cannon', 'carson', 'cartwright', 'carver', 'cerf', 'chandrasekhar', 'chaplygin', 'chatelet', 'chatterjee', 'chebyshev', 'cohen', 'chaum', 'clarke', 'colden', 'cori', 'cray', 'curran', 'curie', 'darwin', 'davinci', 'dewdney', 'dhawan', 'diffie', 'dijkstra', 'dirac', 'driscoll', 'dubinsky', 'easley', 'edison', 'einstein', 'elbakyan', 'elgamal', 'elion', 'ellis', 'engelbart', 'euclid', 'euler', 'faraday', 'feistel', 'fermat', 'fermi', 'feynman', 'franklin', 'gagarin', 'galileo', 'galois', 'ganguly', 'gates', 'gauss', 'germain', 'goldberg', 'goldstine', 'goldwasser', 'golick', 'goodall', 'gould', 'greider', 'grothendieck', 'haibt', 'hamilton', 'haslett', 'hawking', 'hellman', 'heisenberg', 'hermann', 'herschel', 'hertz', 'heyrovsky', 'hodgkin', 'hofstadter', 'hoover', 'hopper', 'hugle', 'hypatia', 'ishizaka', 'jackson', 'jang', 'jemison', 'jennings', 'jepsen', 'johnson', 'joliot', 'jones', 'kalam', 'kapitsa', 'kare', 'keldysh', 'keller', 'kepler', 'khayyam', 'khorana', 'kilby', 'kirch', 'knuth', 'kowalevski', 'lalande', 'lamarr', 'lamport', 'leakey', 'leavitt', 'lederberg', 'lehmann', 'lewin', 'lichterman', 'liskov', 'lovelace', 'lumiere', 'mahavira', 'margulis', 'matsumoto', 'maxwell', 'mayer', 'mccarthy', 'mcclintock', 'mclaren', 'mclean', 'mcnulty', 'mendel', 'mendeleev', 'meitner', 'meninsky', 'merkle', 'mestorf', 'mirzakhani', 'montalcini', 'moore', 'morse', 'murdock', 'moser', 'napier', 'nash', 'neumann', 'newton', 'niel', 'nightingale', 'nobel', 'noether', 'northcutt', 'noyce', 'panini', 'pare', 'pascal', 'pasteur', 'payne', 'perlman', 'pike', 'poincare', 'poitras', 'proskuriakova', 'ptolemy', 'raman', 'ramanujan', 'ride', 'ritchie', 'rhodes', 'robinson', 'roentgen', 'rosalind', 'rubin', 'saha', 'sammet', 'sanderson', 'satoshi', 'shamir', 'shannon', 'shaw', 'shirley', 'shockley', 'shtern', 'sinoussi', 'snyder', 'solomon', 'spence', 'stonebraker', 'sutherland', 'swanson', 'swartz', 'swirles', 'taussig', 'tereshkova', 'tesla', 'tharp', 'thompson', 'torvalds', 'tu', 'turing', 'varahamihira', 'vaughan', 'visvesvaraya', 'volhard', 'villani', 'wescoff', 'wilbur', 'wiles', 'williams', 'williamson', 'wilson', 'wing', 'wozniak', 'wright', 'wu', 'yalow', 'yonath', 'zhukovsky'];
-const randomName = (prefix = '', separator = '-') => {
-  const name = `${ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)] ?? ''}${separator}${NAMES[Math.floor(Math.random() * NAMES.length)] ?? ''}`;
-  if (name === `boring${separator}wozniak`) {
-    return randomName(prefix, separator);
-  }
-  return prefix.length > 0 ? `${prefix}${separator}${name}` : name;
-};
-
-export { randomName as default };