@scaleway/sdk-std 1.0.1

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/build-fetcher.d.ts

@@ -0,0 +1,23 @@
+import type { Settings } from '../client-settings.js';
+import type { ResponseUnmarshaller, ScwRequest } from './types';
+/**
+ * Builds Request from {@link ScwRequest} & {@link Settings}.
+ *
+ * @param request - A scaleway request
+ * @param settings - The settings
+ * @returns A fetch Request
+ *
+ * @internal
+ */
+export declare const buildRequest: (request: Readonly<ScwRequest>, settings: Readonly<Settings>) => Request;
+export type Fetcher = <T>(request: Readonly<ScwRequest>, unwrapper?: ResponseUnmarshaller<T>) => Promise<T>;
+/**
+ * Builds a resource fetcher.
+ *
+ * @param settings - The {@link Settings} object
+ * @param httpClient - The HTTP client that should be used to call the API
+ * @returns The fetcher
+ *
+ * @internal
+ */
+export declare const buildFetcher: (settings: Settings, httpClient: typeof fetch) => <T>(request: Readonly<ScwRequest>, unwrapper?: ResponseUnmarshaller<T>) => Promise<T>;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/build-fetcher.js

@@ -0,0 +1,60 @@
+import { isBrowser } from "../../helpers/is-browser.js";
+import { composeRequestInterceptors, composeResponseInterceptors, composeResponseErrorInterceptors } from "../../internal/interceptors/composer.js";
+import { obfuscateAuthHeadersEntry } from "../auth.js";
+import { logRequest, logResponse, obfuscateInterceptor } from "./http-interceptors.js";
+import { responseParser } from "./response-parser.js";
+const buildRequest = (request, settings) => {
+  let { path } = request;
+  if (request.urlParams instanceof URLSearchParams) {
+    path = path.concat(`?${request.urlParams.toString()}`);
+  }
+  return new Request(`${settings.apiURL}${path}`, {
+    body: request.body,
+    headers: {
+      Accept: "application/json",
+      .../* istanbul ignore next */
+      !isBrowser() ? { "User-Agent": settings.userAgent } : {},
+      ...request.headers
+    },
+    method: request.method
+  });
+};
+const asIs = (response) => response;
+const buildFetcher = (settings, httpClient) => {
+  let requestNumber = 0;
+  const prepareRequest = (requestId) => composeRequestInterceptors([
+    ...settings.interceptors.map((obj) => obj.request).filter((obj) => obj),
+    logRequest(requestId, obfuscateInterceptor(obfuscateAuthHeadersEntry))
+  ]);
+  const prepareResponse = (requestId) => composeResponseInterceptors([
+    ...settings.interceptors.map((obj) => obj.response).filter((obj) => obj),
+    logResponse(requestId)
+  ]);
+  const prepareResponseErrors = () => composeResponseErrorInterceptors(
+    settings.interceptors.map((obj) => obj.responseError).filter((obj) => obj)
+  );
+  return async (request, unwrapper = asIs) => {
+    const requestId = `${requestNumber += 1}`;
+    const reqInterceptors = prepareRequest(requestId);
+    const finalRequest = await reqInterceptors(buildRequest(request, settings));
+    try {
+      const response = await httpClient(finalRequest);
+      const resInterceptors = prepareResponse(requestId);
+      const finalResponse = await resInterceptors(response);
+      const resUnmarshaller = responseParser(
+        unwrapper,
+        request.responseType ?? "json"
+      );
+      const unmarshaledResponse = await resUnmarshaller(finalResponse);
+      return unmarshaledResponse;
+    } catch (err) {
+      const resErrorInterceptors = prepareResponseErrors();
+      const handledError = await resErrorInterceptors(finalRequest, err);
+      return unwrapper(handledError);
+    }
+  };
+};
+export {
+  buildFetcher,
+  buildRequest
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-dumper.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const toPascalCase = (str) => str.replace(
+  /\w+/g,
+  (word) => `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}`
+);
+const serializeHeadersEntry = ([name, value]) => `${toPascalCase(name)}: ${value}`;
+const serializeHeaders = (headers) => Array.from(headers.entries(), serializeHeadersEntry);
+const dumpRequest = async (request) => [
+  `${request.method.toUpperCase()}: ${request.url}`,
+  ...serializeHeaders(request.headers),
+  await request.clone().text()
+].join("\r\n");
+const dumpResponse = async (response) => [
+  `HTTP ${response.status} ${response.ok ? "OK" : "NOK"}`,
+  ...serializeHeaders(response.headers),
+  await response.clone().text()
+].join("\r\n");
+exports.dumpRequest = dumpRequest;
+exports.dumpResponse = dumpResponse;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-dumper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dumps a Request into a readable string.
+ *
+ * @param request - The request
+ * @returns The readable string
+ *
+ * @internal
+ */
+export declare const dumpRequest: (request: Readonly<Request>) => Promise<string>;
+/**
+ * Dumps a Response into a readable string.
+ *
+ * @param response - The response
+ * @returns The readable string
+ *
+ * @internal
+ */
+export declare const dumpResponse: (response: Readonly<Response>) => Promise<string>;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-dumper.js

@@ -0,0 +1,20 @@
+const toPascalCase = (str) => str.replace(
+  /\w+/g,
+  (word) => `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}`
+);
+const serializeHeadersEntry = ([name, value]) => `${toPascalCase(name)}: ${value}`;
+const serializeHeaders = (headers) => Array.from(headers.entries(), serializeHeadersEntry);
+const dumpRequest = async (request) => [
+  `${request.method.toUpperCase()}: ${request.url}`,
+  ...serializeHeaders(request.headers),
+  await request.clone().text()
+].join("\r\n");
+const dumpResponse = async (response) => [
+  `HTTP ${response.status} ${response.ok ? "OK" : "NOK"}`,
+  ...serializeHeaders(response.headers),
+  await response.clone().text()
+].join("\r\n");
+export {
+  dumpRequest,
+  dumpResponse
+};

package/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-interceptors.js

@@ -0,0 +1,43 @@
+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);
+    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 (shouldLog(LevelResolver[getLogger().logLevel], "debug")) {
+    getLogger().debug(
+      `--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await dumpRequest(await obfuscate({ request }))}
+---------------------------------------------------------`
+    );
+  }
+  return request;
+};
+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
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/resource-paginator.cjs

@@ -0,0 +1,36 @@
+"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/node_modules/@scaleway/sdk-client/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>>(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>, 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>, 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/node_modules/@scaleway/sdk-client/dist/scw/fetch/resource-paginator.js

@@ -0,0 +1,36 @@
+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)
+  });
+};
+export {
+  enrichForPagination,
+  extract,
+  fetchAll,
+  fetchPaginated
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/response-parser.cjs

@@ -0,0 +1,55 @@
+"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/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/dist/scw/fetch/response-parser.js

@@ -0,0 +1,55 @@
+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) {
+    return obj;
+  }
+  const totalCount = parseInt(headerVal, 10);
+  if (Number.isNaN(totalCount)) {
+    return obj;
+  }
+  if (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(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 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"
+  );
+};
+export {
+  fixLegacyTotalCount,
+  responseParser
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/types.d.ts

@@ -0,0 +1,16 @@
+/** Scaleway Request. */
+export interface 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/node_modules/@scaleway/sdk-client/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' | 'pl-waw-3' | (string & {});

package/node_modules/@scaleway/sdk-client/dist/vendor/base64/index.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var lookup = [];
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(
+      encodeChunk(
+        uint8,
+        i,
+        i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+      )
+    );
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+exports.fromByteArray = fromByteArray;

package/node_modules/@scaleway/sdk-client/dist/vendor/base64/index.js

@@ -0,0 +1,46 @@
+var lookup = [];
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(
+      encodeChunk(
+        uint8,
+        i,
+        i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+      )
+    );
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+export {
+  fromByteArray
+};