modern-treasury 0.0.1

package/dist/cjs/core.js

@@ -0,0 +1,815 @@
+'use strict';
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+var __classPrivateFieldSet =
+  (this && this.__classPrivateFieldSet) ||
+  function (receiver, state, value, kind, f) {
+    if (kind === 'm') throw new TypeError('Private method is not writable');
+    if (kind === 'a' && !f) throw new TypeError('Private accessor was defined without a setter');
+    if (typeof state === 'function' ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError('Cannot write private member to an object whose class did not declare it');
+    return kind === 'a' ? f.call(receiver, value) : f ? (f.value = value) : state.set(receiver, value), value;
+  };
+var __classPrivateFieldGet =
+  (this && this.__classPrivateFieldGet) ||
+  function (receiver, state, kind, f) {
+    if (kind === 'a' && !f) throw new TypeError('Private accessor was defined without a getter');
+    if (typeof state === 'function' ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError('Cannot read private member from an object whose class did not declare it');
+    return kind === 'm' ? f : kind === 'a' ? f.call(receiver) : f ? f.value : state.get(receiver);
+  };
+var __rest =
+  (this && this.__rest) ||
+  function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+      }
+    return t;
+  };
+var __await =
+  (this && this.__await) ||
+  function (v) {
+    return this instanceof __await ? ((this.v = v), this) : new __await(v);
+  };
+var __asyncGenerator =
+  (this && this.__asyncGenerator) ||
+  function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
+    var g = generator.apply(thisArg, _arguments || []),
+      i,
+      q = [];
+    return (
+      (i = {}),
+      verb('next'),
+      verb('throw'),
+      verb('return'),
+      (i[Symbol.asyncIterator] = function () {
+        return this;
+      }),
+      i
+    );
+    function verb(n) {
+      if (g[n])
+        i[n] = function (v) {
+          return new Promise(function (a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+    }
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+      resume('next', value);
+    }
+    function reject(value) {
+      resume('throw', value);
+    }
+    function settle(f, v) {
+      if ((f(v), q.shift(), q.length)) resume(q[0][0], q[0][1]);
+    }
+  };
+var __asyncValues =
+  (this && this.__asyncValues) ||
+  function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
+    var m = o[Symbol.asyncIterator],
+      i;
+    return m
+      ? m.call(o)
+      : ((o = typeof __values === 'function' ? __values(o) : o[Symbol.iterator]()),
+        (i = {}),
+        verb('next'),
+        verb('throw'),
+        verb('return'),
+        (i[Symbol.asyncIterator] = function () {
+          return this;
+        }),
+        i);
+    function verb(n) {
+      i[n] =
+        o[n] &&
+        function (v) {
+          return new Promise(function (resolve, reject) {
+            (v = o[n](v)), settle(resolve, reject, v.done, v.value);
+          });
+        };
+    }
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function (v) {
+        resolve({ value: v, done: d });
+      }, reject);
+    }
+  };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+var _AbstractPage_client;
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getHeader =
+  exports.isHeadersProtocol =
+  exports.hasOwn =
+  exports.isEmptyObj =
+  exports.coerceInteger =
+  exports.multipartFormRequestOptions =
+  exports.APIConnectionTimeoutError =
+  exports.APIConnectionError =
+  exports.InternalServerError =
+  exports.RateLimitError =
+  exports.UnprocessableEntityError =
+  exports.ConflictError =
+  exports.NotFoundError =
+  exports.PermissionDeniedError =
+  exports.AuthenticationError =
+  exports.BadRequestError =
+  exports.APIError =
+  exports.isRequestOptions =
+  exports.createResponseHeaders =
+  exports.PagePromise =
+  exports.AbstractPage =
+  exports.APIResource =
+  exports.APIClient =
+    void 0;
+const qs_1 = __importDefault(require('qs'));
+const pkg_up_1 = __importDefault(require('pkg-up'));
+const abort_controller_1 = require('abort-controller');
+const formdata_node_1 = require('formdata-node');
+const form_data_encoder_1 = require('form-data-encoder');
+const stream_1 = require('stream');
+const isNode = typeof process !== 'undefined';
+let nodeFetch = undefined;
+let getDefaultAgent = (_url) => undefined;
+if (isNode) {
+  /* eslint-disable @typescript-eslint/no-var-requires */
+  nodeFetch = require('node-fetch');
+  const HttpAgent = require('agentkeepalive');
+  const HttpsAgent = HttpAgent.HttpsAgent;
+  /* eslint-enable @typescript-eslint/no-var-requires */
+  const defaultHttpAgent = new HttpAgent({ keepAlive: true });
+  const defaultHttpsAgent = new HttpsAgent({ keepAlive: true });
+  getDefaultAgent = (url) => (url.startsWith('https') ? defaultHttpsAgent : defaultHttpAgent);
+}
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_TIMEOUT = 60 * 1000; // 60s
+class APIClient {
+  constructor({ apiKey, baseURL, maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT, httpAgent }) {
+    this.apiKey = apiKey;
+    this.baseURL = baseURL;
+    this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
+    this.timeout = validatePositiveInteger('timeout', timeout);
+    this.httpAgent = httpAgent;
+    if (isNode) {
+      this.fetch = nodeFetch;
+    } else {
+      // For other environments, use a global fetch function expected to already be present
+      if (typeof fetch === 'undefined' || typeof fetch !== 'function') {
+        throw new Error(
+          `Unexpected; running in a non-Node environment without a global "fetch" function defined.`,
+        );
+      }
+      // For now, we just pretend that Fetch is the same type as NodeFetch.
+      this.fetch = fetch;
+    }
+  }
+  authHeaders() {
+    return {};
+  }
+  /**
+   * Override this to add your own default headers, for example:
+   *
+   *  {
+   *    ...super.defaultHeaders(),
+   *    Authorization: 'Bearer 123',
+   *  }
+   */
+  defaultHeaders() {
+    return Object.assign(
+      {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': this.getUserAgent(),
+        'X-Stainless-Client-User-Agent': getPlatformPropertiesJSON(),
+      },
+      this.authHeaders(),
+    );
+  }
+  /**
+   * Override this to add your own qs.stringify options, for example:
+   *
+   *  {
+   *    ...super.qsOptions(),
+   *    strictNullHandling: true,
+   *  }
+   */
+  qsOptions() {
+    return {};
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${uuid4()}`;
+  }
+  get(path, opts) {
+    return this.request(Object.assign({ method: 'get', path }, opts));
+  }
+  post(path, opts) {
+    return this.request(Object.assign({ method: 'post', path }, opts));
+  }
+  patch(path, opts) {
+    return this.request(Object.assign({ method: 'patch', path }, opts));
+  }
+  put(path, opts) {
+    return this.request(Object.assign({ method: 'put', path }, opts));
+  }
+  delete(path, opts) {
+    return this.request(Object.assign({ method: 'delete', path }, opts));
+  }
+  getAPIList(path, Page, opts) {
+    return this.requestAPIList(Page, Object.assign({ method: 'get', path }, opts));
+  }
+  request(options, retriesRemaining) {
+    var _a, _b, _c, _d;
+    if (retriesRemaining === void 0) {
+      retriesRemaining = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
+    }
+    return __awaiter(this, void 0, void 0, function* () {
+      const { method, path, query, headers: headers = {} } = options;
+      const body =
+        options.body instanceof stream_1.Readable
+          ? options.body
+          : options.body
+          ? JSON.stringify(options.body, null, 2)
+          : null;
+      const contentLength = typeof body === 'string' ? body.length.toString() : null;
+      const url = this.buildURL(path, query);
+      const httpAgent =
+        (_c = (_b = options.httpAgent) !== null && _b !== void 0 ? _b : this.httpAgent) !== null &&
+        _c !== void 0
+          ? _c
+          : getDefaultAgent(url);
+      const timeout = (_d = options.timeout) !== null && _d !== void 0 ? _d : this.timeout;
+      validatePositiveInteger('timeout', timeout);
+      if (this.idempotencyHeader && method !== 'get') {
+        if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
+        headers[this.idempotencyHeader] = options.idempotencyKey;
+      }
+      const req = Object.assign(
+        Object.assign(Object.assign({ method }, body && { body }), {
+          headers: Object.assign(
+            Object.assign(
+              Object.assign({}, contentLength && { 'Content-Length': contentLength }),
+              this.defaultHeaders(),
+            ),
+            headers,
+          ),
+        }),
+        httpAgent && { agent: httpAgent },
+      );
+      this.debug('request', url, options, req.headers);
+      const response = yield this.fetchWithTimeout(url, req, timeout).catch(castToError);
+      if (response instanceof Error) {
+        if (retriesRemaining) return this.retryRequest(options, retriesRemaining);
+        if (response.name === 'AbortError') throw new APIConnectionTimeoutError();
+        throw new APIConnectionError({ cause: response });
+      }
+      const responseHeaders = (0, exports.createResponseHeaders)(response.headers);
+      if (!response.ok) {
+        if (retriesRemaining && this.shouldRetry(response)) {
+          return this.retryRequest(options, retriesRemaining, responseHeaders);
+        }
+        const errText = yield response.text().catch(() => 'Unknown');
+        const errJSON = safeJSON(errText);
+        const errMessage = errJSON ? undefined : errText;
+        this.debug('response', response.status, url, responseHeaders, errMessage);
+        const err = APIError.generate(response.status, errJSON, errMessage, responseHeaders);
+        throw err;
+      }
+      const contentType = response.headers.get('content-type');
+      if (
+        contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json')
+      ) {
+        const json = yield response.json();
+        Object.defineProperty(json, 'responseHeaders', {
+          enumerable: false,
+          writable: false,
+          value: responseHeaders,
+        });
+        this.debug('response', response.status, url, responseHeaders, json);
+        return json;
+      } else {
+        // TODO handle blob, arraybuffer, other content types, etc.
+        const text = response.text();
+        this.debug('response', response.status, url, responseHeaders, text);
+        return text;
+      }
+    });
+  }
+  requestAPIList(Page, options) {
+    const requestPromise = this.request(options);
+    return new PagePromise(this, requestPromise, options, Page);
+  }
+  buildURL(path, query) {
+    const url = isAbsoluteURL(path) ? new URL(path) : new URL(this.baseURL + path);
+    if (query) {
+      url.search = qs_1.default.stringify(query, this.qsOptions());
+    }
+    return url.toString();
+  }
+  fetchWithTimeout(url, _a = {}, ms) {
+    var { signal } = _a,
+      options = __rest(_a, ['signal']);
+    return __awaiter(this, void 0, void 0, function* () {
+      const controller = new abort_controller_1.AbortController();
+      if (signal) signal.addEventListener('abort', controller.abort);
+      const timeout = setTimeout(() => controller.abort(), ms);
+      return this.fetch(url, Object.assign({ signal: controller.signal }, options)).finally(() => {
+        clearTimeout(timeout);
+      });
+    });
+  }
+  shouldRetry(response) {
+    // Note this is not a standard header.
+    const shouldRetryHeader = response.headers.get('x-should-retry');
+    // If the server explicitly says whether or not to retry, obey.
+    if (shouldRetryHeader === 'true') return true;
+    if (shouldRetryHeader === 'false') return false;
+    // Retry on lock timeouts.
+    if (response.status === 409) return true;
+    // Retry on rate limits.
+    if (response.status === 429) return true;
+    // Retry internal errors.
+    if (response.status >= 500) return true;
+    return false;
+  }
+  retryRequest(options, retriesRemaining, responseHeaders) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      retriesRemaining -= 1;
+      // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+      //
+      // TODO: we may want to handle the case where the header is using the http-date syntax: "Retry-After: <http-date>".
+      // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#syntax for details.
+      const retryAfter = parseInt(
+        (responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['retry-after']) ||
+          '',
+      );
+      const maxRetries = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
+      const timeout = this.calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) * 1000;
+      yield sleep(timeout);
+      return this.request(options, retriesRemaining);
+    });
+  }
+  calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 2;
+    // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+    // just do what it says.
+    if (Number.isInteger(retryAfter) && retryAfter <= 60) {
+      return retryAfter;
+    }
+    const numRetries = maxRetries - retriesRemaining;
+    // Apply exponential backoff, but not more than the max.
+    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(numRetries - 1, 2), maxRetryDelay);
+    // Apply some jitter, plus-or-minus half a second.
+    const jitter = Math.random() - 0.5;
+    return sleepSeconds + jitter;
+  }
+  getUserAgent() {
+    const packageVersion = getPackageVersion();
+    return `${this.constructor.name}/JS ${packageVersion}`;
+  }
+  debug(action, ...args) {
+    if (process.env['DEBUG'] === 'true') {
+      console.log(`${this.constructor.name}:DEBUG:${action}`, ...args);
+    }
+  }
+}
+exports.APIClient = APIClient;
+class APIResource {
+  constructor(client) {
+    this.client = client;
+    this.get = client.get.bind(client);
+    this.post = client.post.bind(client);
+    this.patch = client.patch.bind(client);
+    this.put = client.put.bind(client);
+    this.delete = client.delete.bind(client);
+    this.getAPIList = client.getAPIList.bind(client);
+  }
+}
+exports.APIResource = APIResource;
+class AbstractPage {
+  constructor(client, response, options) {
+    _AbstractPage_client.set(this, void 0);
+    __classPrivateFieldSet(this, _AbstractPage_client, client, 'f');
+    this.options = options;
+  }
+  hasNextPage() {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageParams() != null;
+  }
+  getNextPage() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const nextQuery = this.nextPageParams();
+      if (!nextQuery) {
+        throw new Error(
+          'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+        );
+      }
+      const nextOptions = Object.assign(Object.assign({}, this.options), {
+        query: Object.assign(Object.assign({}, this.options.query), nextQuery),
+      });
+      return yield __classPrivateFieldGet(this, _AbstractPage_client, 'f').requestAPIList(
+        this.constructor,
+        nextOptions,
+      );
+    });
+  }
+  iterPages() {
+    return __asyncGenerator(this, arguments, function* iterPages_1() {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      let page = this;
+      yield yield __await(page);
+      while (page.hasNextPage()) {
+        page = yield __await(page.getNextPage());
+        yield yield __await(page);
+      }
+    });
+  }
+  [((_AbstractPage_client = new WeakMap()), Symbol.asyncIterator)]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var e_1, _b;
+      try {
+        for (var _c = __asyncValues(this.iterPages()), _d; (_d = yield __await(_c.next())), !_d.done; ) {
+          const page = _d.value;
+          for (const item of page.getPaginatedItems()) {
+            yield yield __await(item);
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (_d && !_d.done && (_b = _c.return)) yield __await(_b.call(_c));
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    });
+  }
+}
+exports.AbstractPage = AbstractPage;
+class PagePromise extends Promise {
+  /**
+   * This subclass of Promise will resolve to an instantiated Page once the request completes.
+   */
+  constructor(client, requestPromise, options, Page) {
+    super((resolve, reject) =>
+      requestPromise.then((response) => resolve(new Page(client, response, options))).catch(reject),
+    );
+  }
+  /**
+   * Enable subclassing Promise.
+   * Ref: https://stackoverflow.com/a/60328122
+   */
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var e_2, _b;
+      const page = yield __await(this);
+      try {
+        for (
+          var page_1 = __asyncValues(page), page_1_1;
+          (page_1_1 = yield __await(page_1.next())), !page_1_1.done;
+
+        ) {
+          const item = page_1_1.value;
+          yield yield __await(item);
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (page_1_1 && !page_1_1.done && (_b = page_1.return)) yield __await(_b.call(page_1));
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+    });
+  }
+}
+exports.PagePromise = PagePromise;
+const createResponseHeaders = (headers) => {
+  return new Proxy(Object.fromEntries(headers.entries()), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    },
+  });
+};
+exports.createResponseHeaders = createResponseHeaders;
+// This is required so that we can determine if a given object matches the RequestOptions
+// type at runtime. While this requires duplication, it is enforced by the TypeScript
+// compiler such that any missing / extraneous keys will cause an error.
+const requestOptionsKeys = {
+  method: true,
+  path: true,
+  query: true,
+  body: true,
+  headers: true,
+  maxRetries: true,
+  timeout: true,
+  httpAgent: true,
+};
+const isRequestOptions = (obj) => {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    !isEmptyObj(obj) &&
+    Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k))
+  );
+};
+exports.isRequestOptions = isRequestOptions;
+class APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(message || (error === null || error === void 0 ? void 0 : error.message));
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+  static generate(status, error, message, headers) {
+    if (!status) return new APIConnectionError({ cause: castToError(error) });
+    if (status === 400) return new BadRequestError(status, error, message, headers);
+    if (status === 401) return new AuthenticationError(status, error, message, headers);
+    if (status === 403) return new PermissionDeniedError(status, error, message, headers);
+    if (status === 404) return new NotFoundError(status, error, message, headers);
+    if (status === 409) return new ConflictError(status, error, message, headers);
+    if (status === 422) return new UnprocessableEntityError(status, error, message, headers);
+    if (status === 429) return new RateLimitError(status, error, message, headers);
+    if (status >= 500) return new InternalServerError(status, error, message, headers);
+    return new APIError(status, error, message, headers);
+  }
+}
+exports.APIError = APIError;
+class BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 400;
+  }
+}
+exports.BadRequestError = BadRequestError;
+class AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 401;
+  }
+}
+exports.AuthenticationError = AuthenticationError;
+class PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 403;
+  }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 404;
+  }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 409;
+  }
+}
+exports.ConflictError = ConflictError;
+class UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 422;
+  }
+}
+exports.UnprocessableEntityError = UnprocessableEntityError;
+class RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 429;
+  }
+}
+exports.RateLimitError = RateLimitError;
+class InternalServerError extends APIError {}
+exports.InternalServerError = InternalServerError;
+class APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    this.status = undefined;
+    // eslint-disable-next-line
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+exports.APIConnectionError = APIConnectionError;
+class APIConnectionTimeoutError extends APIConnectionError {
+  constructor() {
+    super({ message: 'Request timed out.' });
+  }
+}
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+let _packageVersion;
+const getPackageVersion = () => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return _packageVersion !== null && _packageVersion !== void 0
+      ? _packageVersion
+      : (_packageVersion = require(pkg_up_1.default.sync()).version);
+  } catch (e) {
+    console.debug(`Ignoring error while determing package version ${e}`);
+    return (_packageVersion = 'unknown');
+  }
+};
+const getPlatformProperties = () => {
+  if (typeof process !== 'undefined') {
+    return {
+      lang: 'js',
+      packageVersion: getPackageVersion(),
+      os: process.platform,
+      arch: process.arch,
+      runtime: 'node',
+      runtimeVersion: process.version,
+    };
+  }
+  if (typeof Deno !== 'undefined') {
+    return {
+      lang: 'js',
+      packageVersion: getPackageVersion(),
+      os: Deno.build.os,
+      arch: Deno.build.arch,
+      runtime: 'deno',
+      runtimeVersion: Deno.version,
+    };
+  }
+  // TODO add support for Cloudflare workers, browsers, etc.
+};
+let _platformPropertiesJSON;
+const getPlatformPropertiesJSON = () => {
+  return (
+    (_platformPropertiesJSON !== null && _platformPropertiesJSON !== void 0
+      ? _platformPropertiesJSON
+      : (_platformPropertiesJSON = JSON.stringify(getPlatformProperties()))) || ''
+  );
+};
+const safeJSON = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};
+// https://stackoverflow.com/a/19709846
+const startsWithSchemeRegexp = new RegExp('^(?:[a-z]+:)?//', 'i');
+const isAbsoluteURL = (url) => {
+  return startsWithSchemeRegexp.test(url);
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const validatePositiveInteger = (name, n) => {
+  if (!Number.isInteger(n)) {
+    throw new Error(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return n;
+};
+const castToError = (err) => {
+  if (err instanceof Error) return err;
+  return new Error(err);
+};
+const validateFormValue = (value) => {
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    value instanceof formdata_node_1.File ||
+    value instanceof formdata_node_1.Blob
+  ) {
+    return value;
+  }
+  if (value == null) {
+    throw new TypeError(
+      `null is not a valid form data value, if you want to pass null then you need to use the string 'null'`,
+    );
+  }
+  throw new TypeError(
+    `Invalid value given to form, expected a string, number, boolean, File or Blob but got ${value} instead`,
+  );
+};
+const multipartFormRequestOptions = (opts) => {
+  const form = new formdata_node_1.FormData();
+  Object.entries(opts.body || {}).forEach(
+    ([key, value]) => value !== undefined && form.set(key, validateFormValue(value)),
+  );
+  const encoder = new form_data_encoder_1.FormDataEncoder(form);
+  return Object.assign(Object.assign({}, opts), {
+    headers: Object.assign(Object.assign(Object.assign({}, opts.headers), encoder.headers), {
+      'Content-Length': encoder.contentLength,
+    }),
+    body: stream_1.Readable.from(encoder),
+  });
+};
+exports.multipartFormRequestOptions = multipartFormRequestOptions;
+const coerceInteger = (value) => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value);
+  throw new Error(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+exports.coerceInteger = coerceInteger;
+// https://stackoverflow.com/a/34491287
+function isEmptyObj(obj) {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+exports.isEmptyObj = isEmptyObj;
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+exports.hasOwn = hasOwn;
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+const uuid4 = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+const isHeadersProtocol = (headers) => {
+  return typeof (headers === null || headers === void 0 ? void 0 : headers.get) === 'function';
+};
+exports.isHeadersProtocol = isHeadersProtocol;
+const getHeader = (headers, key) => {
+  const lowerKey = key.toLowerCase();
+  if ((0, exports.isHeadersProtocol)(headers)) return headers.get(key) || headers.get(lowerKey);
+  const value = headers[key] || headers[lowerKey];
+  if (Array.isArray(value)) {
+    if (value.length <= 1) return value[0];
+    console.warn(`Received ${value.length} entries for the ${key} header, using the first entry.`);
+    return value[0];
+  }
+  return value;
+};
+exports.getHeader = getHeader;
+//# sourceMappingURL=core.js.map