@readme/api-core 7.0.0-alpha.2 → 7.0.0-alpha.4

package/dist/chunk-L7DN22AA.js

@@ -0,0 +1,25 @@
+// src/errors/fetchError.ts
+var FetchError = class _FetchError extends Error {
+  /** HTTP Status */
+  status;
+  /** The content of the response. */
+  data;
+  /** The Headers of the response. */
+  headers;
+  /** The raw `Response` object. */
+  res;
+  constructor(status, data, headers, res) {
+    super(res.statusText);
+    this.name = "FetchError";
+    this.status = status;
+    this.data = data;
+    this.headers = headers;
+    this.res = res;
+    Object.setPrototypeOf(this, _FetchError.prototype);
+  }
+};
+
+export {
+  FetchError
+};
+//# sourceMappingURL=chunk-L7DN22AA.js.map

package/dist/chunk-L7DN22AA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/fetchError.ts"],"sourcesContent":["export default class FetchError<Status = number, Data = unknown> extends Error {\n  /** HTTP Status */\n  status: Status;\n\n  /** The content of the response. */\n  data: Data;\n\n  /** The Headers of the response. */\n  headers: Headers;\n\n  /** The raw `Response` object. */\n  res: Response;\n\n  constructor(status: Status, data: Data, headers: Headers, res: Response) {\n    super(res.statusText);\n\n    this.name = 'FetchError';\n    this.status = status;\n    this.data = data;\n    this.headers = headers;\n    this.res = res;\n\n    // We could fix this by updating our target to ES2015 but because we support exporting to CJS\n    // we can't.\n    //\n    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/\n    Object.setPrototypeOf(this, FetchError.prototype);\n  }\n}\n"],"mappings":";AAAA,IAAqB,aAArB,MAAqB,oBAAoD,MAAM;AAAA;AAAA,EAE7E;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA,EAEA,YAAY,QAAgB,MAAY,SAAkB,KAAe;AACvE,UAAM,IAAI,UAAU;AAEpB,SAAK,OAAO;AACZ,SAAK,SAAS;AACd,SAAK,OAAO;AACZ,SAAK,UAAU;AACf,SAAK,MAAM;AAMX,WAAO,eAAe,MAAM,YAAW,SAAS;AAAA,EAClD;AACF;","names":[]}

package/dist/chunk-NVFSP2R3.cjs

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/errors/fetchError.ts
+var FetchError = class _FetchError extends Error {
+  /** HTTP Status */
+  
+  /** The content of the response. */
+  
+  /** The Headers of the response. */
+  
+  /** The raw `Response` object. */
+  
+  constructor(status, data, headers, res) {
+    super(res.statusText);
+    this.name = "FetchError";
+    this.status = status;
+    this.data = data;
+    this.headers = headers;
+    this.res = res;
+    Object.setPrototypeOf(this, _FetchError.prototype);
+  }
+};
+
+
+
+exports.FetchError = FetchError;
+//# sourceMappingURL=chunk-NVFSP2R3.cjs.map

package/dist/chunk-NVFSP2R3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/fetchError.ts"],"names":[],"mappings":";AAAA,IAAqB,aAArB,MAAqB,oBAAoD,MAAM;AAAA;AAAA,EAE7E;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA,EAEA,YAAY,QAAgB,MAAY,SAAkB,KAAe;AACvE,UAAM,IAAI,UAAU;AAEpB,SAAK,OAAO;AACZ,SAAK,SAAS;AACd,SAAK,OAAO;AACZ,SAAK,UAAU;AACf,SAAK,MAAM;AAMX,WAAO,eAAe,MAAM,YAAW,SAAS;AAAA,EAClD;AACF","sourcesContent":["export default class FetchError<Status = number, Data = unknown> extends Error {\n  /** HTTP Status */\n  status: Status;\n\n  /** The content of the response. */\n  data: Data;\n\n  /** The Headers of the response. */\n  headers: Headers;\n\n  /** The raw `Response` object. */\n  res: Response;\n\n  constructor(status: Status, data: Data, headers: Headers, res: Response) {\n    super(res.statusText);\n\n    this.name = 'FetchError';\n    this.status = status;\n    this.data = data;\n    this.headers = headers;\n    this.res = res;\n\n    // We could fix this by updating our target to ES2015 but because we support exporting to CJS\n    // we can't.\n    //\n    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/\n    Object.setPrototypeOf(this, FetchError.prototype);\n  }\n}\n"]}

package/dist/errors/fetchError.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNVFSP2R3cjs = require('../chunk-NVFSP2R3.cjs');
+
+
+exports.default = _chunkNVFSP2R3cjs.FetchError;
+
+module.exports = exports.default//# sourceMappingURL=fetchError.cjs.map

package/dist/errors/fetchError.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/errors/fetchError.d.cts

@@ -0,0 +1,13 @@
+declare class FetchError<Status = number, Data = unknown> extends Error {
+    /** HTTP Status */
+    status: Status;
+    /** The content of the response. */
+    data: Data;
+    /** The Headers of the response. */
+    headers: Headers;
+    /** The raw `Response` object. */
+    res: Response;
+    constructor(status: Status, data: Data, headers: Headers, res: Response);
+}
+
+export = FetchError;

package/dist/errors/fetchError.d.ts

@@ -9,4 +9,5 @@ declare class FetchError<Status = number, Data = unknown> extends Error {
     res: Response;
     constructor(status: Status, data: Data, headers: Headers, res: Response);
 }
-export default FetchError;
+
+export { FetchError as default };

package/dist/errors/fetchError.js

@@ -1,26 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class FetchError extends Error {
-    /** HTTP Status */
-    status;
-    /** The content of the response. */
-    data;
-    /** The Headers of the response. */
-    headers;
-    /** The raw `Response` object. */
-    res;
-    constructor(status, data, headers, res) {
-        super(res.statusText);
-        this.name = 'FetchError';
-        this.status = status;
-        this.data = data;
-        this.headers = headers;
-        this.res = res;
-        // We could fix this by updating our target to ES2015 but because we support exporting to CJS
-        // we can't.
-        //
-        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
-        Object.setPrototypeOf(this, FetchError.prototype);
-    }
-}
-exports.default = FetchError;
+import {
+  FetchError
+} from "../chunk-L7DN22AA.js";
+export {
+  FetchError as default
+};
+//# sourceMappingURL=fetchError.js.map

package/dist/errors/fetchError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.cjs

@@ -0,0 +1,516 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkNVFSP2R3cjs = require('./chunk-NVFSP2R3.cjs');
+
+// src/index.ts
+var _oastohar = require('@readme/oas-to-har'); var _oastohar2 = _interopRequireDefault(_oastohar);
+var _fetchhar = require('fetch-har'); var _fetchhar2 = _interopRequireDefault(_fetchhar);
+
+// src/lib/getJSONSchemaDefaults.ts
+var _jsonschematraverse = require('json-schema-traverse'); var _jsonschematraverse2 = _interopRequireDefault(_jsonschematraverse);
+function getJSONSchemaDefaults(jsonSchemas) {
+  return jsonSchemas.map(({ type: payloadType, schema: jsonSchema }) => {
+    const defaults = {};
+    _jsonschematraverse2.default.call(void 0, 
+      jsonSchema,
+      (schema, pointer, rootSchema, parentPointer, parentKeyword, parentSchema, indexProperty) => {
+        if (!pointer.startsWith("/properties/")) {
+          return;
+        }
+        if (Array.isArray(_optionalChain([parentSchema, 'optionalAccess', _ => _.required])) && _optionalChain([parentSchema, 'optionalAccess', _2 => _2.required, 'access', _3 => _3.includes, 'call', _4 => _4(String(indexProperty))])) {
+          if (schema.type === "object" && indexProperty) {
+            defaults[indexProperty] = {};
+          }
+          let destination = defaults;
+          if (parentPointer) {
+            parentPointer.replace(/\/properties/g, "").split("/").forEach((subSchema) => {
+              if (subSchema === "") {
+                return;
+              }
+              destination = _optionalChain([destination, 'optionalAccess', _5 => _5[subSchema]]) || {};
+            });
+          }
+          if (schema.default !== void 0) {
+            if (indexProperty !== void 0) {
+              destination[indexProperty] = schema.default;
+            }
+          }
+        }
+      }
+    );
+    if (!Object.keys(defaults).length) {
+      return {};
+    }
+    return {
+      // @todo should we filter out empty and undefined objects from here with `remove-undefined-objects`?
+      [payloadType]: defaults
+    };
+  }).reduce((prev, next) => Object.assign(prev, next));
+}
+
+// src/lib/parseResponse.ts
+var _utils = require('oas/utils');
+async function parseResponse(response) {
+  const contentType = response.headers.get("Content-Type");
+  const isJSON = contentType && (_utils.matchesMimeType.json(contentType) || _utils.matchesMimeType.wildcard(contentType));
+  const responseBody = await response.text();
+  let data = responseBody;
+  if (isJSON) {
+    try {
+      data = JSON.parse(responseBody);
+    } catch (e) {
+    }
+  }
+  return {
+    data,
+    status: response.status,
+    headers: response.headers,
+    res: response
+  };
+}
+
+// src/lib/prepareAuth.ts
+function prepareAuth(authKey, operation) {
+  if (authKey.length === 0) {
+    return {};
+  }
+  const preparedAuth = {};
+  const security = operation.getSecurity();
+  if (security.length === 0) {
+    return {};
+  }
+  if (security.every((s) => Object.keys(s).length > 1)) {
+    throw new Error(
+      "Sorry, this operation currently requires multiple forms of authentication which this library doesn't yet support."
+    );
+  }
+  const usableSecurity = security.map((s) => {
+    return Object.keys(s).length === 1 ? s : false;
+  }).filter(Boolean);
+  const usableSecuritySchemes = usableSecurity.map((s) => Object.keys(s)).reduce((prev, next) => prev.concat(next), []);
+  const preparedSecurity = operation.prepareSecurity();
+  if (authKey.length >= 2) {
+    if (!("Basic" in preparedSecurity)) {
+      throw new Error("Multiple auth tokens were supplied for this endpoint but only a single token is needed.");
+    }
+    const schemes2 = preparedSecurity.Basic.filter((s) => usableSecuritySchemes.includes(s._key));
+    if (!schemes2.length) {
+      throw new Error(
+        "Credentials for Basic Authentication were supplied but this operation requires another form of auth in that case, which this library does not yet support. This operation does, however, allow supplying a single auth token."
+      );
+    }
+    const scheme2 = schemes2.shift();
+    preparedAuth[scheme2._key] = {
+      user: authKey[0],
+      pass: authKey.length === 2 ? authKey[1] : ""
+    };
+    return preparedAuth;
+  }
+  const usableScheme = usableSecuritySchemes[0];
+  const schemes = Object.entries(preparedSecurity).map(([, ps]) => ps.filter((s) => usableScheme === s._key)).reduce((prev, next) => prev.concat(next), []);
+  const scheme = schemes.shift();
+  switch (scheme.type) {
+    case "http":
+      if (scheme.scheme === "basic") {
+        preparedAuth[scheme._key] = {
+          user: authKey[0],
+          pass: authKey.length === 2 ? authKey[1] : ""
+        };
+      } else if (scheme.scheme === "bearer") {
+        preparedAuth[scheme._key] = authKey[0];
+      }
+      break;
+    case "oauth2":
+      preparedAuth[scheme._key] = authKey[0];
+      break;
+    case "apiKey":
+      if (scheme.in === "query" || scheme.in === "header" || scheme.in === "cookie") {
+        preparedAuth[scheme._key] = authKey[0];
+      }
+      break;
+    default:
+      throw new Error(
+        `Sorry, this API currently uses a security scheme, ${scheme.type}, which this library doesn't yet support.`
+      );
+  }
+  return preparedAuth;
+}
+
+// src/lib/prepareParams.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _stream = require('stream'); var _stream2 = _interopRequireDefault(_stream);
+var _caseless = require('caseless'); var _caseless2 = _interopRequireDefault(_caseless);
+var _parserjs = require('datauri/parser.js'); var _parserjs2 = _interopRequireDefault(_parserjs);
+var _syncjs = require('datauri/sync.js'); var _syncjs2 = _interopRequireDefault(_syncjs);
+var _getstream = require('get-stream'); var _getstream2 = _interopRequireDefault(_getstream);
+var _lodashmerge = require('lodash.merge'); var _lodashmerge2 = _interopRequireDefault(_lodashmerge);
+var _removeundefinedobjects = require('remove-undefined-objects'); var _removeundefinedobjects2 = _interopRequireDefault(_removeundefinedobjects);
+var specialHeaders = ["accept", "authorization"];
+function digestParameters(parameters) {
+  return parameters.reduce((prev, param) => {
+    if ("$ref" in param || "allOf" in param || "anyOf" in param || "oneOf" in param) {
+      throw new Error("The OpenAPI document for this operation wasn't dereferenced before processing.");
+    } else if (param.name in prev) {
+      throw new Error(
+        `The operation you are using has the same parameter, ${param.name}, spread across multiple entry points. We unfortunately can't handle this right now.`
+      );
+    }
+    return Object.assign(prev, { [param.name]: param });
+  }, {});
+}
+function isEmpty(obj) {
+  return [Object, Array].includes((obj || {}).constructor) && !Object.entries(obj || {}).length;
+}
+function isObject(thing) {
+  if (thing instanceof _stream2.default.Readable) {
+    return false;
+  }
+  return typeof thing === "object" && thing !== null && !Array.isArray(thing);
+}
+function isPrimitive(obj) {
+  return obj === null || typeof obj === "number" || typeof obj === "string";
+}
+function merge(src, target) {
+  if (Array.isArray(target)) {
+    return target;
+  } else if (!isObject(target)) {
+    return target;
+  }
+  return _lodashmerge2.default.call(void 0, src, target);
+}
+function processFile(paramName, file) {
+  if (typeof file === "string") {
+    const resolvedFile = _path2.default.resolve(file);
+    return new Promise((resolve, reject) => {
+      _fs2.default.stat(resolvedFile, async (err) => {
+        if (err) {
+          if (err.code === "ENOENT") {
+            return resolve(void 0);
+          }
+          return reject(err);
+        }
+        const fileMetadata = await _syncjs2.default.call(void 0, resolvedFile);
+        const payloadFilename = encodeURIComponent(_path2.default.basename(resolvedFile));
+        return resolve({
+          paramName,
+          base64: _optionalChain([fileMetadata, 'optionalAccess', _6 => _6.content, 'optionalAccess', _7 => _7.replace, 'call', _8 => _8(";base64", `;name=${payloadFilename};base64`)]),
+          filename: payloadFilename,
+          buffer: fileMetadata.buffer
+        });
+      });
+    });
+  } else if (file instanceof _stream2.default.Readable) {
+    return _getstream2.default.buffer(file).then((buffer) => {
+      const filePath = file.path;
+      const parser = new (0, _parserjs2.default)();
+      const base64 = parser.format(filePath, buffer).content;
+      const payloadFilename = encodeURIComponent(_path2.default.basename(filePath));
+      return {
+        paramName,
+        base64: _optionalChain([base64, 'optionalAccess', _9 => _9.replace, 'call', _10 => _10(";base64", `;name=${payloadFilename};base64`)]),
+        filename: payloadFilename,
+        buffer
+      };
+    });
+  }
+  return Promise.reject(
+    new TypeError(
+      paramName ? `The data supplied for the \`${paramName}\` request body parameter is not a file handler that we support.` : "The data supplied for the request body payload is not a file handler that we support."
+    )
+  );
+}
+async function prepareParams(operation, body, metadata) {
+  let metadataIntersected = false;
+  const digestedParameters = digestParameters(operation.getParameters());
+  const jsonSchema = operation.getParametersAsJSONSchema();
+  metadata = _removeundefinedobjects2.default.call(void 0, metadata);
+  if (!jsonSchema && (body !== void 0 || metadata !== void 0)) {
+    let throwNoParamsError = true;
+    if (body !== void 0) {
+      if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+        if (Object.keys(body).length <= 2) {
+          const bodyParams = _caseless2.default.call(void 0, body);
+          if (specialHeaders.some((header) => bodyParams.has(header))) {
+            throwNoParamsError = false;
+          }
+        }
+      }
+    }
+    if (throwNoParamsError) {
+      throw new Error(
+        "You supplied metadata and/or body data for this operation but it doesn't have any documented parameters or request payloads. If you think this is an error please contact support for the API you're using."
+      );
+    }
+  }
+  const jsonSchemaDefaults = jsonSchema ? getJSONSchemaDefaults(jsonSchema) : {};
+  const params = jsonSchemaDefaults;
+  if (typeof body !== "undefined") {
+    if (Array.isArray(body) || isPrimitive(body)) {
+      params.body = merge(params.body, body);
+    } else if (typeof metadata === "undefined") {
+      const headerParams = _caseless2.default.call(void 0, {});
+      Object.entries(digestedParameters).forEach(([paramName, param]) => {
+        if (param.in === "header") {
+          headerParams.set(paramName, "");
+        }
+      });
+      specialHeaders.forEach((header) => {
+        if (!headerParams.has(header)) {
+          headerParams.set(header, "");
+        }
+      });
+      const intersection = Object.keys(body).filter((value) => {
+        if (Object.keys(digestedParameters).includes(value)) {
+          return true;
+        } else if (headerParams.has(value)) {
+          return true;
+        }
+        return false;
+      }).length;
+      if (intersection && intersection / Object.keys(body).length > 0.25) {
+        metadataIntersected = true;
+        metadata = merge(params.body, body);
+        body = void 0;
+      } else {
+        params.body = merge(params.body, body);
+      }
+    } else {
+      params.body = merge(params.body, body);
+    }
+  }
+  if (!operation.hasRequestBody()) {
+    delete params.body;
+  } else {
+    if (!("body" in params))
+      params.body = {};
+    const payloadJsonSchema = jsonSchema.find((js) => js.type === "body");
+    if (payloadJsonSchema) {
+      if (!params.files)
+        params.files = {};
+      const conversions = [];
+      if (_optionalChain([payloadJsonSchema, 'access', _11 => _11.schema, 'optionalAccess', _12 => _12.properties])) {
+        Object.entries(_optionalChain([payloadJsonSchema, 'access', _13 => _13.schema, 'optionalAccess', _14 => _14.properties])).filter(([, schema]) => _optionalChain([schema, 'optionalAccess', _15 => _15.format]) === "binary").filter(([prop]) => Object.keys(params.body).includes(prop)).forEach(([prop]) => {
+          conversions.push(processFile(prop, params.body[prop]));
+        });
+      } else if (_optionalChain([payloadJsonSchema, 'access', _16 => _16.schema, 'optionalAccess', _17 => _17.type]) === "string") {
+        if (_optionalChain([payloadJsonSchema, 'access', _18 => _18.schema, 'optionalAccess', _19 => _19.format]) === "binary") {
+          conversions.push(processFile(void 0, params.body));
+        }
+      }
+      await Promise.all(conversions).then((fileMetadata) => fileMetadata.filter(Boolean)).then((fm) => {
+        fm.forEach((fileMetadata) => {
+          if (!fileMetadata) {
+            return;
+          }
+          if (fileMetadata.paramName) {
+            params.body[fileMetadata.paramName] = fileMetadata.base64;
+          } else {
+            params.body = fileMetadata.base64;
+          }
+          if (fileMetadata.buffer && _optionalChain([params, 'optionalAccess', _20 => _20.files])) {
+            params.files[fileMetadata.filename] = fileMetadata.buffer;
+          }
+        });
+      });
+    }
+  }
+  if (operation.isFormUrlEncoded()) {
+    params.formData = merge(params.formData, params.body);
+    delete params.body;
+  }
+  if (typeof metadata !== "undefined") {
+    if (!("cookie" in params))
+      params.cookie = {};
+    if (!("header" in params))
+      params.header = {};
+    if (!("path" in params))
+      params.path = {};
+    if (!("query" in params))
+      params.query = {};
+    Object.entries(digestedParameters).forEach(([paramName, param]) => {
+      let value;
+      let metadataHeaderParam;
+      if (typeof metadata === "object" && !isEmpty(metadata)) {
+        if (paramName in metadata) {
+          value = metadata[paramName];
+          metadataHeaderParam = paramName;
+        } else if (param.in === "header") {
+          metadataHeaderParam = Object.keys(metadata).find((k) => k.toLowerCase() === paramName.toLowerCase()) || "";
+          value = metadata[metadataHeaderParam];
+        }
+      }
+      if (value === void 0) {
+        return;
+      }
+      switch (param.in) {
+        case "path":
+          params.path[paramName] = value;
+          if (_optionalChain([metadata, 'optionalAccess', _21 => _21[paramName]]))
+            delete metadata[paramName];
+          break;
+        case "query":
+          params.query[paramName] = value;
+          if (_optionalChain([metadata, 'optionalAccess', _22 => _22[paramName]]))
+            delete metadata[paramName];
+          break;
+        case "header":
+          params.header[paramName.toLowerCase()] = value;
+          if (metadataHeaderParam && _optionalChain([metadata, 'optionalAccess', _23 => _23[metadataHeaderParam]]))
+            delete metadata[metadataHeaderParam];
+          break;
+        case "cookie":
+          params.cookie[paramName] = value;
+          if (_optionalChain([metadata, 'optionalAccess', _24 => _24[paramName]]))
+            delete metadata[paramName];
+          break;
+        default:
+      }
+      if (metadataIntersected && operation.isFormUrlEncoded()) {
+        if (paramName in params.formData) {
+          delete params.formData[paramName];
+        }
+      }
+    });
+    if (!isEmpty(metadata)) {
+      if (typeof metadata === "object") {
+        specialHeaders.forEach((headerName) => {
+          const headerParam = Object.keys(metadata || {}).find((m) => m.toLowerCase() === headerName);
+          if (headerParam) {
+            if (typeof metadata === "object") {
+              if (typeof params.header === "object") {
+                params.header[headerName] = metadata[headerParam];
+              }
+              delete metadata[headerParam];
+            }
+          }
+        });
+      }
+      if (operation.isFormUrlEncoded()) {
+        params.formData = merge(params.formData, metadata);
+      } else {
+      }
+    }
+  }
+  ["body", "cookie", "files", "formData", "header", "path", "query"].forEach((type) => {
+    if (type in params && isEmpty(params[type])) {
+      delete params[type];
+    }
+  });
+  return params;
+}
+
+// src/lib/prepareServer.ts
+function stripTrailingSlash(url) {
+  if (url[url.length - 1] === "/") {
+    return url.slice(0, -1);
+  }
+  return url;
+}
+function prepareServer(spec, url, variables = {}) {
+  let serverIdx;
+  const sanitizedUrl = stripTrailingSlash(url);
+  (spec.api.servers || []).forEach((server, i) => {
+    if (server.url === sanitizedUrl) {
+      serverIdx = i;
+    }
+  });
+  if (serverIdx) {
+    return {
+      selected: serverIdx,
+      variables
+    };
+  } else if (Object.keys(variables).length) {
+  } else {
+    const server = spec.splitVariables(url);
+    if (server) {
+      return {
+        selected: server.selected,
+        variables: server.variables
+      };
+    }
+  }
+  return false;
+}
+
+// src/index.ts
+var APICore = (_class = class {
+  
+  __init() {this.auth = []}
+  __init2() {this.server = false}
+  __init3() {this.config = {}}
+  
+  constructor(spec, userAgent) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    if (spec)
+      this.spec = spec;
+    if (userAgent)
+      this.userAgent = userAgent;
+  }
+  setSpec(spec) {
+    this.spec = spec;
+  }
+  setConfig(config) {
+    this.config = config;
+    return this;
+  }
+  setUserAgent(userAgent) {
+    this.userAgent = userAgent;
+    return this;
+  }
+  setAuth(...values) {
+    this.auth = values;
+    return this;
+  }
+  setServer(url, variables = {}) {
+    this.server = { url, variables };
+    return this;
+  }
+  async fetch(path2, method, body, metadata) {
+    const operation = this.spec.operation(path2, method);
+    return this.fetchOperation(operation, body, metadata);
+  }
+  async fetchOperation(operation, body, metadata) {
+    return prepareParams(operation, body, metadata).then((params) => {
+      const data = { ...params };
+      if (this.server) {
+        const preparedServer = prepareServer(this.spec, this.server.url, this.server.variables);
+        if (preparedServer) {
+          data.server = preparedServer;
+        }
+      }
+      const har = _oastohar2.default.call(void 0, this.spec, operation, data, prepareAuth(this.auth, operation));
+      let timeoutSignal;
+      const init = {};
+      if (this.config.timeout) {
+        const controller = new AbortController();
+        timeoutSignal = setTimeout(() => controller.abort(), this.config.timeout);
+        init.signal = controller.signal;
+      }
+      return _fetchhar2.default.call(void 0, har, {
+        files: data.files || {},
+        init,
+        userAgent: this.userAgent
+      }).then(async (res) => {
+        const parsed = await parseResponse(res);
+        if (res.status >= 400 && res.status <= 599) {
+          throw new (0, _chunkNVFSP2R3cjs.FetchError)(
+            parsed.status,
+            parsed.data,
+            parsed.headers,
+            parsed.res
+          );
+        }
+        return parsed;
+      }).finally(() => {
+        if (this.config.timeout) {
+          clearTimeout(timeoutSignal);
+        }
+      });
+    });
+  }
+}, _class);
+
+
+exports.default = APICore;
+
+module.exports = exports.default//# sourceMappingURL=index.cjs.map