swagger-client/dist/swagger-client.browser.js

SwaggerJS - a collection of interfaces for OAI specs

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["SwaggerClient"] = factory();
	else
		root["SwaggerClient"] = factory();
})(window, () => {
return /******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 3832
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   ACCEPT_HEADER_VALUE_FOR_DOCUMENTS: () => (/* binding */ ACCEPT_HEADER_VALUE_FOR_DOCUMENTS),
/* harmony export */   DEFAULT_BASE_URL: () => (/* binding */ DEFAULT_BASE_URL),
/* harmony export */   DEFAULT_OPENAPI_3_SERVER: () => (/* binding */ DEFAULT_OPENAPI_3_SERVER),
/* harmony export */   TRAVERSE_LIMIT: () => (/* binding */ TRAVERSE_LIMIT)
/* harmony export */ });
const ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = 'application/json, application/yaml';
const DEFAULT_BASE_URL = 'https://swagger.io';
const DEFAULT_OPENAPI_3_SERVER = Object.freeze({
  url: '/'
});
const TRAVERSE_LIMIT = 3000;

/***/ },

/***/ 32729
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   baseUrl: () => (/* binding */ baseUrl),
/* harmony export */   buildRequest: () => (/* binding */ buildRequest),
/* harmony export */   execute: () => (/* binding */ execute),
/* harmony export */   self: () => (/* binding */ self)
/* harmony export */ });
/* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73236);
/* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(43628);
/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(46455);
/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(24955);
/* harmony import */ var openapi_server_url_templating__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29646);
/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(22874);
/* harmony import */ var _swagger_api_apidom_reference_configuration_empty__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(96664);
/* harmony import */ var _constants_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(3832);
/* harmony import */ var _http_index_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(51670);
/* harmony import */ var _http_serializers_request_index_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(29382);
/* harmony import */ var _swagger2_parameter_builders_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(90520);
/* harmony import */ var _oas3_parameter_builders_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(42276);
/* harmony import */ var _oas3_build_request_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(53044);
/* harmony import */ var _swagger2_build_request_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(77768);
/* harmony import */ var _helpers_index_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(50324);
/* harmony import */ var _helpers_index_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(47555);
/* harmony import */ var _helpers_openapi_predicates_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(50918);
/* harmony import */ var _helpers_cookie_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(48009);















const arrayOrEmpty = ar => Array.isArray(ar) ? ar : [];
const findObjectOrArraySchema = (schema, {
  recurse = true,
  depth = 1
} = {}) => {
  if (!(0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_3__["default"])(schema)) return undefined;

  // check if the schema is an object or array type
  if (schema.type === 'object' || schema.type === 'array' || Array.isArray(schema.type) && (schema.type.includes('object') || schema.type.includes('array'))) {
    return schema;
  }
  if (depth > _constants_js__WEBPACK_IMPORTED_MODULE_7__.TRAVERSE_LIMIT) return undefined;
  if (recurse) {
    // traverse oneOf keyword first
    const oneOfResult = Array.isArray(schema.oneOf) ? schema.oneOf.find(subschema => findObjectOrArraySchema(subschema, {
      recurse,
      depth: depth + 1
    })) : undefined;
    if (oneOfResult) return oneOfResult;

    // traverse anyOf keyword second
    const anyOfResult = Array.isArray(schema.anyOf) ? schema.anyOf.find(subschema => findObjectOrArraySchema(subschema, {
      recurse,
      depth: depth + 1
    })) : undefined;
    if (anyOfResult) return anyOfResult;
  }
  return undefined;
};
const parseJsonObjectOrArray = ({
  value,
  silentFail = false
}) => {
  try {
    const parsedValue = JSON.parse(value);
    if ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_3__["default"])(parsedValue) || Array.isArray(parsedValue)) {
      return parsedValue;
    }
    if (!silentFail) {
      throw new Error('Expected JSON serialized object or array');
    }
  } catch {
    if (!silentFail) {
      throw new Error('Could not parse parameter value string as JSON Object or JSON Array');
    }
  }
  return value;
};

/**
 * `parseURIReference` function simulates the behavior of `node:url` parse function.
 * New WHATWG URL API is not capable of parsing relative references natively,
 * but can be adapter by utilizing the `base` parameter.
 */
const parseURIReference = uriReference => {
  try {
    return new URL(uriReference);
  } catch {
    const parsedURL = new URL(uriReference, _constants_js__WEBPACK_IMPORTED_MODULE_7__.DEFAULT_BASE_URL);
    const pathname = String(uriReference).startsWith('/') ? parsedURL.pathname : parsedURL.pathname.substring(1);
    return {
      hash: parsedURL.hash,
      host: '',
      hostname: '',
      href: '',
      origin: '',
      password: '',
      pathname,
      port: '',
      protocol: '',
      search: parsedURL.search,
      searchParams: parsedURL.searchParams
    };
  }
};
class OperationNotFoundError extends _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_5__["default"] {}
const findParametersWithName = (name, parameters) => parameters.filter(p => p.name === name);

// removes parameters that have duplicate 'in' and 'name' properties
const deduplicateParameters = parameters => {
  const paramsMap = {};
  parameters.forEach(p => {
    if (!paramsMap[p.in]) {
      paramsMap[p.in] = {};
    }
    paramsMap[p.in][p.name] = p;
  });
  const dedupedParameters = [];
  Object.keys(paramsMap).forEach(i => {
    Object.keys(paramsMap[i]).forEach(p => {
      dedupedParameters.push(paramsMap[i][p]);
    });
  });
  return dedupedParameters;
};

// For stubbing in tests
const self = {
  buildRequest
};

// Execute request, with the given operationId and parameters
// pathName/method or operationId is optional
function execute({
  http: userHttp,
  fetch,
  // This is legacy
  spec,
  operationId,
  pathName,
  method,
  parameters,
  securities,
  ...extras
}) {
  // Provide default fetch implementation
  const http = userHttp || fetch || _http_index_js__WEBPACK_IMPORTED_MODULE_8__["default"]; // Default to _our_ http

  if (pathName && method && !operationId) {
    operationId = (0,_helpers_index_js__WEBPACK_IMPORTED_MODULE_15__["default"])(pathName, method);
  }
  const request = self.buildRequest({
    spec,
    operationId,
    parameters,
    securities,
    http,
    ...extras
  });
  if (request.body && ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_3__["default"])(request.body) || Array.isArray(request.body))) {
    request.body = JSON.stringify(request.body);
  }

  // Build request and execute it
  return http(request);
}

// Build a request, which can be handled by the `http.js` implementation.
function buildRequest(options) {
  const {
    spec,
    operationId,
    responseContentType,
    scheme,
    requestInterceptor,
    responseInterceptor,
    contextUrl,
    userFetch,
    server,
    serverVariables,
    http,
    signal,
    serverVariableEncoder
  } = options;
  let {
    parameters,
    parameterBuilders,
    baseURL
  } = options;
  const specIsOAS3 = (0,_helpers_openapi_predicates_js__WEBPACK_IMPORTED_MODULE_16__.isOpenAPI3)(spec);
  if (!parameterBuilders) {
    // user did not provide custom parameter builders
    if (specIsOAS3) {
      parameterBuilders = _oas3_parameter_builders_js__WEBPACK_IMPORTED_MODULE_11__;
    } else {
      parameterBuilders = _swagger2_parameter_builders_js__WEBPACK_IMPORTED_MODULE_10__["default"];
    }
  }

  // Set credentials with 'http.withCredentials' value
  const credentials = http && http.withCredentials ? 'include' : 'same-origin';

  // Base Template
  let req = {
    url: '',
    credentials,
    headers: {},
    cookies: {}
  };
  if (signal) {
    req.signal = signal;
  }
  if (requestInterceptor) {
    req.requestInterceptor = requestInterceptor;
  }
  if (responseInterceptor) {
    req.responseInterceptor = responseInterceptor;
  }
  if (userFetch) {
    req.userFetch = userFetch;
  }
  const operationRaw = (0,_helpers_index_js__WEBPACK_IMPORTED_MODULE_14__["default"])(spec, operationId);
  if (!operationRaw) {
    throw new OperationNotFoundError(`Operation ${operationId} not found`);
  }
  const {
    operation = {},
    method,
    pathName
  } = operationRaw;
  baseURL = baseURL ?? baseUrl({
    spec,
    scheme,
    contextUrl,
    server,
    serverVariables,
    pathName,
    method,
    serverVariableEncoder
  });
  req.url += baseURL;

  // Mostly for testing
  if (!operationId) {
    // Not removing req.cookies causes testing issues and would
    // change our interface, so we're always sure to remove it.
    // See the same statement lower down in this function for
    // more context.
    delete req.cookies;
    return req;
  }
  req.url += pathName; // Have not yet replaced the path parameters
  req.method = `${method}`.toUpperCase();
  parameters = parameters || {};
  const path = spec.paths[pathName] || {};
  if (responseContentType) {
    req.headers.accept = responseContentType;
  }
  const combinedParameters = deduplicateParameters([].concat(arrayOrEmpty(operation.parameters)) // operation parameters
  .concat(arrayOrEmpty(path.parameters))); // path parameters

  // REVIEW: OAS3: have any key names or parameter shapes changed?
  // Any new features that need to be plugged in here?

  // Add values to request
  combinedParameters.forEach(parameter => {
    const builder = parameterBuilders[parameter.in];
    let value;
    if (parameter.in === 'body' && parameter.schema && parameter.schema.properties) {
      value = parameters;
    }
    value = parameter && parameter.name && parameters[parameter.name];
    if (typeof value === 'undefined') {
      // check for `name-in` formatted key
      value = parameter && parameter.name && parameters[`${parameter.in}.${parameter.name}`];
    } else if (findParametersWithName(parameter.name, combinedParameters).length > 1) {
      // value came from `parameters[parameter.name]`
      // check to see if this is an ambiguous parameter
      // eslint-disable-next-line no-console
      console.warn(`Parameter '${parameter.name}' is ambiguous because the defined spec has more than one parameter with the name: '${parameter.name}' and the passed-in parameter values did not define an 'in' value.`);
    }
    if (value === null) {
      return;
    }
    if (typeof parameter.default !== 'undefined' && typeof value === 'undefined') {
      value = parameter.default;
    }
    if (typeof value === 'undefined' && parameter.required && !parameter.allowEmptyValue) {
      throw new Error(`Required parameter ${parameter.name} is not provided`);
    }
    if (specIsOAS3 && typeof value === 'string') {
      if ((0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])('type', parameter.schema) && typeof parameter.schema.type === 'string' && findObjectOrArraySchema(parameter.schema, {
        recurse: false
      })) {
        value = parseJsonObjectOrArray({
          value,
          silentFail: false
        });
      } else if ((0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])('type', parameter.schema) && Array.isArray(parameter.schema.type) && findObjectOrArraySchema(parameter.schema, {
        recurse: false
      })) {
        value = parseJsonObjectOrArray({
          value,
          silentFail: true
        });
      } else if (!(0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])('type', parameter.schema) && findObjectOrArraySchema(parameter.schema, {
        recurse: true
      })) {
        value = parseJsonObjectOrArray({
          value,
          silentFail: true
        });
      }
    }
    if (builder) {
      builder({
        req,
        parameter,
        value,
        operation,
        spec,
        baseURL
      });
    }
  });

  // Do version-specific tasks, then return those results.
  const versionSpecificOptions = {
    ...options,
    operation
  };
  if (specIsOAS3) {
    req = (0,_oas3_build_request_js__WEBPACK_IMPORTED_MODULE_12__["default"])(versionSpecificOptions, req);
  } else {
    // If not OAS3, then treat as Swagger2.
    req = (0,_swagger2_build_request_js__WEBPACK_IMPORTED_MODULE_13__["default"])(versionSpecificOptions, req);
  }

  // If the cookie convenience object exists in our request,
  // serialize its content and then delete the cookie object.
  if (req.cookies && Object.keys(req.cookies).length > 0) {
    const cookieString = (0,_helpers_cookie_js__WEBPACK_IMPORTED_MODULE_17__.serialize)(req.cookies);
    if ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_2__["default"])(req.headers.Cookie)) {
      req.headers.Cookie += `; ${cookieString}`;
    } else {
      req.headers.Cookie = cookieString;
    }
  }
  if (req.cookies) {
    // even if no cookies were defined, we need to remove
    // the cookies key from our request, or many legacy
    // tests will break.
    delete req.cookies;
  }

  // Will add the query object into the URL, if it exists
  // ... will also create a FormData instance, if multipart/form-data (eg: a file)
  return (0,_http_serializers_request_index_js__WEBPACK_IMPORTED_MODULE_9__.serializeRequest)(req);
}
const stripNonAlpha = str => str ? str.replace(/\W/g, '') : null;

// be careful when modifying this! it is a publicly-exposed method.
function baseUrl(obj) {
  const specIsOAS3 = (0,_helpers_openapi_predicates_js__WEBPACK_IMPORTED_MODULE_16__.isOpenAPI3)(obj.spec);
  return specIsOAS3 ? oas3BaseUrl(obj) : swagger2BaseUrl(obj);
}
const isNonEmptyServerList = value => Array.isArray(value) && value.length > 0;
function oas3BaseUrl({
  spec,
  pathName,
  method,
  server,
  contextUrl,
  serverVariables = {},
  serverVariableEncoder
}) {
  let servers = [];
  let selectedServerUrl = '';
  let selectedServerObj;

  // compute the servers (this will be taken care of by ApiDOM refrator plugins in future
  const operationLevelServers = spec?.paths?.[pathName]?.[(method || '').toLowerCase()]?.servers;
  const pathItemLevelServers = spec?.paths?.[pathName]?.servers;
  const rootLevelServers = spec?.servers;
  servers = isNonEmptyServerList(operationLevelServers) // eslint-disable-line no-nested-ternary
  ? operationLevelServers : isNonEmptyServerList(pathItemLevelServers) // eslint-disable-line no-nested-ternary
  ? pathItemLevelServers : isNonEmptyServerList(rootLevelServers) ? rootLevelServers : [_constants_js__WEBPACK_IMPORTED_MODULE_7__.DEFAULT_OPENAPI_3_SERVER];

  // pick the first server that matches the server url
  if (server) {
    selectedServerObj = servers.find(srv => srv.url === server);
    if (selectedServerObj) selectedServerUrl = server;
  }

  // default to the first server if we don't have one by now
  if (!selectedServerUrl) {
    [selectedServerObj] = servers;
    selectedServerUrl = selectedServerObj.url;
  }
  if ((0,openapi_server_url_templating__WEBPACK_IMPORTED_MODULE_4__.test)(selectedServerUrl, {
    strict: true
  })) {
    const selectedServerVariables = Object.entries({
      ...selectedServerObj.variables
    }).reduce((acc, [serverVariableName, serverVariable]) => {
      acc[serverVariableName] = serverVariable.default;
      return acc;
    }, {});
    selectedServerUrl = (0,openapi_server_url_templating__WEBPACK_IMPORTED_MODULE_4__.substitute)(selectedServerUrl, {
      ...selectedServerVariables,
      ...serverVariables
    }, {
      encoder: typeof serverVariableEncoder === 'function' ? serverVariableEncoder : ramda__WEBPACK_IMPORTED_MODULE_1__["default"]
    });
  }
  return buildOas3UrlWithContext(selectedServerUrl, contextUrl);
}
function buildOas3UrlWithContext(ourUrl = '', contextUrl = '') {
  // relative server url should be resolved against contextUrl
  const parsedUrl = ourUrl && contextUrl ? parseURIReference(_swagger_api_apidom_reference_configuration_empty__WEBPACK_IMPORTED_MODULE_6__.resolve(contextUrl, ourUrl)) : parseURIReference(ourUrl);
  const parsedContextUrl = parseURIReference(contextUrl);
  const computedScheme = stripNonAlpha(parsedUrl.protocol) || stripNonAlpha(parsedContextUrl.protocol);
  const computedHost = parsedUrl.host || parsedContextUrl.host;
  const computedPath = parsedUrl.pathname;
  let res;
  if (computedScheme && computedHost) {
    res = `${computedScheme}://${computedHost + computedPath}`;

    // if last character is '/', trim it off
  } else {
    res = computedPath;
  }
  return res[res.length - 1] === '/' ? res.slice(0, -1) : res;
}

// Compose the baseUrl ( scheme + host + basePath )
function swagger2BaseUrl({
  spec,
  scheme,
  contextUrl = ''
}) {
  const parsedContextUrl = parseURIReference(contextUrl);
  const firstSchemeInSpec = Array.isArray(spec.schemes) ? spec.schemes[0] : null;
  const computedScheme = scheme || firstSchemeInSpec || stripNonAlpha(parsedContextUrl.protocol) || 'http';
  const computedHost = spec.host || parsedContextUrl.host || '';
  const computedPath = spec.basePath || '';
  let res;
  if (computedScheme && computedHost) {
    // we have what we need for an absolute URL
    res = `${computedScheme}://${computedHost + computedPath}`;
  } else {
    // if not, a relative URL will have to do
    res = computedPath;
  }

  // If last character is '/', trim it off
  return res[res.length - 1] === '/' ? res.slice(0, -1) : res;
}

/***/ },

/***/ 53044
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   applySecurities: () => (/* binding */ applySecurities),
/* harmony export */   "default": () => (/* binding */ buildRequest)
/* harmony export */ });
/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24955);
/* harmony import */ var _helpers_btoa_node_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(39687);
// This function runs after the common function,
// `src/execute/index.js#buildRequest`


function buildRequest(options, req) {
  const {
    operation,
    requestBody,
    securities,
    spec,
    attachContentTypeForEmptyPayload
  } = options;
  let {
    requestContentType
  } = options;
  req = applySecurities({
    request: req,
    securities,
    operation,
    spec
  });
  const requestBodyDef = operation.requestBody || {};
  const requestBodyMediaTypes = Object.keys(requestBodyDef.content || {});
  const isExplicitContentTypeValid = requestContentType && requestBodyMediaTypes.indexOf(requestContentType) > -1;

  // for OAS3: set the Content-Type
  if (requestBody || attachContentTypeForEmptyPayload) {
    // does the passed requestContentType appear in the requestBody definition?

    if (requestContentType && isExplicitContentTypeValid) {
      req.headers['Content-Type'] = requestContentType;
    } else if (!requestContentType) {
      const firstMediaType = requestBodyMediaTypes[0];
      if (firstMediaType) {
        req.headers['Content-Type'] = firstMediaType;
        requestContentType = firstMediaType;
      }
    }
  } else if (requestContentType && isExplicitContentTypeValid) {
    req.headers['Content-Type'] = requestContentType;
  }
  if (!options.responseContentType && operation.responses) {
    const mediaTypes = Object.entries(operation.responses).filter(([key, value]) => {
      const code = parseInt(key, 10);
      return code >= 200 && code < 300 && (0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_0__["default"])(value.content);
    }).reduce((acc, [, value]) => acc.concat(Object.keys(value.content)), []);
    if (mediaTypes.length > 0) {
      req.headers.accept = mediaTypes.join(', ');
    }
  }

  // for OAS3: add requestBody to request
  if (requestBody) {
    if (requestContentType) {
      if (requestBodyMediaTypes.indexOf(requestContentType) > -1) {
        // only attach body if the requestBody has a definition for the
        // contentType that has been explicitly set
        if (requestContentType === 'application/x-www-form-urlencoded' || requestContentType === 'multipart/form-data') {
          if (typeof requestBody === 'object') {
            const encoding = requestBodyDef.content[requestContentType]?.encoding ?? {};
            req.form = {};
            Object.keys(requestBody).forEach(k => {
              let value;
              try {
                value = JSON.parse(requestBody[k]);
              } catch {
                value = requestBody[k];
              }
              req.form[k] = {
                value,
                encoding: encoding[k] || {}
              };
            });
          } else if (typeof requestBody === 'string') {
            const encoding = requestBodyDef.content[requestContentType]?.encoding ?? {};
            try {
              req.form = {};
              const form = JSON.parse(requestBody);
              Object.entries(form).forEach(([key, value]) => {
                req.form[key] = {
                  value,
                  encoding: encoding[key] || {}
                };
              });
            } catch {
              req.form = requestBody;
            }
          } else {
            req.form = requestBody;
          }
        } else {
          req.body = requestBody;
        }
      }
    } else {
      req.body = requestBody;
    }
  }
  return req;
}

// Add security values, to operations - that declare their need on them
// Adapted from the Swagger2 implementation
function applySecurities({
  request,
  securities = {},
  operation = {},
  spec
}) {
  const result = {
    ...request
  };
  const {
    authorized = {}
  } = securities;
  const security = operation.security || spec.security || [];
  const isAuthorized = authorized && !!Object.keys(authorized).length;
  const securityDef = spec?.components?.securitySchemes || {};
  result.headers = result.headers || {};
  result.query = result.query || {};
  if (!Object.keys(securities).length || !isAuthorized || !security || Array.isArray(operation.security) && !operation.security.length) {
    return request;
  }
  security.forEach(securityObj => {
    Object.keys(securityObj).forEach(key => {
      const auth = authorized[key];
      const schema = securityDef[key];
      if (!auth) {
        return;
      }
      const value = auth.value || auth;
      const {
        type
      } = schema;
      if (auth) {
        if (type === 'apiKey') {
          if (schema.in === 'query') {
            result.query[schema.name] = value;
          }
          if (schema.in === 'header') {
            result.headers[schema.name] = value;
          }
          if (schema.in === 'cookie') {
            result.cookies[schema.name] = value;
          }
        } else if (type === 'http') {
          if (/^basic$/i.test(schema.scheme)) {
            const username = value.username || '';
            const password = value.password || '';
            const encoded = (0,_helpers_btoa_node_js__WEBPACK_IMPORTED_MODULE_1__["default"])(`${username}:${password}`);
            result.headers.Authorization = `Basic ${encoded}`;
          }
          if (/^bearer$/i.test(schema.scheme)) {
            result.headers.Authorization = `Bearer ${value}`;
          }
        } else if (type === 'oauth2' || type === 'openIdConnect') {
          const token = auth.token || {};
          const tokenName = schema['x-tokenName'] || 'access_token';
          const tokenValue = token[tokenName];
          let tokenType = token.token_type;
          if (!tokenType || tokenType.toLowerCase() === 'bearer') {
            tokenType = 'Bearer';
          }
          result.headers.Authorization = `${tokenType} ${tokenValue}`;
        }
      }
    });
  });
  return result;
}

/***/ },

/***/ 27986
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (/* binding */ serialize)
/* harmony export */ });
/*
  Serializer that serializes according to a media type instead of OpenAPI's
  `style` + `explode` constructs.
*/

function serialize(value, mediaType) {
  if (mediaType.includes('application/json')) {
    if (typeof value === 'string') {
      // Assume the user has a JSON string
      return value;
    }
    if (Array.isArray(value)) {
      value = value.map(v => {
        try {
          return JSON.parse(v);
        } catch (e) {
          return v;
        }
      });
    }
    return JSON.stringify(value);
  }
  return String(value);
}

/***/ },

/***/ 42276
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   cookie: () => (/* binding */ cookie),
/* harmony export */   header: () => (/* binding */ header),
/* harmony export */   path: () => (/* binding */ path),
/* harmony export */   query: () => (/* binding */ query)
/* harmony export */ });
/* harmony import */ var openapi_path_templating__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(61546);
/* harmony import */ var _style_serializer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33838);
/* harmony import */ var _content_serializer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27986);
/* harmony import */ var _helpers_cookie_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(48009);




function path({
  req,
  value,
  parameter,
  baseURL
}) {
  const {
    name,
    style,
    explode,
    content
  } = parameter;
  if (value === undefined) return;
  const pathname = req.url.replace(baseURL, '');
  let resolvedPathname;
  if (content) {
    const effectiveMediaType = Object.keys(content)[0];
    resolvedPathname = (0,openapi_path_templating__WEBPACK_IMPORTED_MODULE_0__.resolve)(pathname, {
      [name]: value
    }, {
      encoder: val => (0,_style_serializer_js__WEBPACK_IMPORTED_MODULE_1__.encodeCharacters)((0,_content_serializer_js__WEBPACK_IMPORTED_MODULE_2__["default"])(val, effectiveMediaType))
    });
  } else {
    resolvedPathname = (0,openapi_path_templating__WEBPACK_IMPORTED_MODULE_0__.resolve)(pathname, {
      [name]: value
    }, {
      encoder: val => (0,_style_serializer_js__WEBPACK_IMPORTED_MODULE_1__["default"])({
        key: parameter.name,
        value: val,
        style: style || 'simple',
        explode: explode ?? false,
        escape: 'reserved'
      })
    });
  }
  req.url = baseURL + resolvedPathname;
}
function query({
  req,
  value,
  parameter
}) {
  req.query = req.query || {};
  if (value !== undefined && parameter.content) {
    const effectiveMediaType = Object.keys(parameter.content)[0];
    const serializedValue = (0,_content_serializer_js__WEBPACK_IMPORTED_MODULE_2__["default"])(value, effectiveMediaType);
    if (serializedValue) {
      req.query[parameter.name] = serializedValue;
    } else if (parameter.allowEmptyValue) {
      const paramName = parameter.name;
      req.query[paramName] = req.query[paramName] || {};
      req.query[paramName].allowEmptyValue = true;
    }
    return;
  }
  if (value === false) {
    value = 'false';
  }
  if (value === 0) {
    value = '0';
  }
  if (value) {
    const {
      style,
      explode,
      allowReserved
    } = parameter;
    req.query[parameter.name] = {
      value,
      serializationOption: {
        style,
        explode,
        allowReserved
      }
    };
  } else if (parameter.allowEmptyValue && value !== undefined) {
    const paramName = parameter.name;
    req.query[paramName] = req.query[paramName] || {};
    req.query[paramName].allowEmptyValue = true;
  }
}
const PARAMETER_HEADER_BLACKLIST = ['accept', 'authorization', 'content-type'];
function header({
  req,
  parameter,
  value
}) {
  req.headers = req.headers || {};
  if (PARAMETER_HEADER_BLACKLIST.indexOf(parameter.name.toLowerCase()) > -1) {
    return;
  }
  if (value !== undefined && parameter.content) {
    const effectiveMediaType = Object.keys(parameter.content)[0];
    req.headers[parameter.name] = (0,_content_serializer_js__WEBPACK_IMPORTED_MODULE_2__["default"])(value, effectiveMediaType);
    return;
  }
  if (value !== undefined && !(Array.isArray(value) && value.length === 0)) {
    req.headers[parameter.name] = (0,_style_serializer_js__WEBPACK_IMPORTED_MODULE_1__["default"])({
      key: parameter.name,
      value,
      style: parameter.style || 'simple',
      explode: typeof parameter.explode === 'undefined' ? false : parameter.explode,
      escape: false
    });
  }
}
function cookie({
  req,
  parameter,
  value
}) {
  const {
    name: cookieName
  } = parameter;
  req.headers = req.headers || {};
  if (value !== undefined && parameter.content) {
    const effectiveMediaType = Object.keys(parameter.content)[0];
    const cookieValue = (0,_content_serializer_js__WEBPACK_IMPORTED_MODULE_2__["default"])(value, effectiveMediaType);
    req.headers.Cookie = (0,_helpers_cookie_js__WEBPACK_IMPORTED_MODULE_3__.serialize)({
      [cookieName]: cookieValue
    });
    return;
  }
  if (value !== undefined && !(Array.isArray(value) && value.length === 0)) {
    const serializedValue = (0,_style_serializer_js__WEBPACK_IMPORTED_MODULE_1__["default"])({
      key: parameter.name,
      value,
      escape: false,
      style: parameter.style || 'form',
      explode: parameter.explode ?? false
    });
    const cookieValue = Array.isArray(value) && parameter.explode ? `${cookieName}=${serializedValue}` : serializedValue;
    req.headers.Cookie = (0,_helpers_cookie_js__WEBPACK_IMPORTED_MODULE_3__.serialize)({
      [cookieName]: cookieValue
    });
  }
}

/***/ },

/***/ 33838
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (/* binding */ stylize),
/* harmony export */   encodeCharacters: () => (/* binding */ encodeCharacters),
/* harmony export */   valueEncoder: () => (/* binding */ valueEncoder)
/* harmony export */ });
const isRfc3986Reserved = char => ":/?#[]@!$&'()*+,;=".indexOf(char) > -1;
const isRfc3986Unreserved = char => /^[a-z0-9\-._~]+$/i.test(char);

// eslint-disable-next-line default-param-last
function encodeCharacters(str, characterSet = 'reserved') {
  // In ES6 you can do this quite easily by using the new ... spread operator.
  // This causes the string iterator (another new ES6 feature) to be used internally,
  // and because that iterator is designed to deal with
  // code points rather than UCS-2/UTF-16 code units.
  return [...str].map(char => {
    if (isRfc3986Unreserved(char)) {
      return char;
    }
    if (isRfc3986Reserved(char) && characterSet === 'unsafe') {
      return char;
    }
    const encoder = new TextEncoder();
    const encoded = Array.from(encoder.encode(char)).map(byte => `0${byte.toString(16).toUpperCase()}`.slice(-2)).map(encodedByte => `%${encodedByte}`).join('');
    return encoded;
  }).join('');
}
function stylize(config) {
  const {
    value
  } = config;
  if (Array.isArray(value)) {
    return encodeArray(config);
  }
  if (typeof value === 'object') {
    return encodeObject(config);
  }
  return encodePrimitive(config);
}
function valueEncoder(value, escape = false) {
  if (Array.isArray(value) || value !== null && typeof value === 'object') {
    value = JSON.stringify(value);
  } else if (typeof value === 'number' || typeof value === 'boolean') {
    value = String(value);
  }
  if (escape && typeof value === 'string' && value.length > 0) {
    return encodeCharacters(value, escape);
  }
  return value ?? '';
}
function encodeArray({
  key,
  value,
  style,
  explode,
  escape
}) {
  if (style === 'simple') {
    return value.map(val => valueEncoder(val, escape)).join(',');
  }
  if (style === 'label') {
    return `.${value.map(val => valueEncoder(val, escape)).join('.')}`;
  }
  if (style === 'matrix') {
    return value.map(val => valueEncoder(val, escape)).reduce((prev, curr) => {
      if (!prev || explode) {
        return `${prev || ''};${key}=${curr}`;
      }
      return `${prev},${curr}`;
    }, '');
  }
  if (style === 'form') {
    const after = explode ? `&${key}=` : ',';
    return value.map(val => valueEncoder(val, escape)).join(after);
  }
  if (style === 'spaceDelimited') {
    const after = explode ? `${key}=` : '';
    return value.map(val => valueEncoder(val, escape)).join(` ${after}`);
  }
  if (style === 'pipeDelimited') {
    const after = explode ? `${key}=` : '';
    return value.map(val => valueEncoder(val, escape)).join(`|${after}`);
  }
  return undefined;
}
function encodeObject({
  key,
  value,
  style,
  explode,
  escape
}) {
  const valueKeys = Object.keys(value);
  if (style === 'simple') {
    return valueKeys.reduce((prev, curr) => {
      const val = valueEncoder(value[curr], escape);
      const middleChar = explode ? '=' : ',';
      const prefix = prev ? `${prev},` : '';
      return `${prefix}${curr}${middleChar}${val}`;
    }, '');
  }
  if (style === 'label') {
    return valueKeys.reduce((prev, curr) => {
      const val = valueEncoder(value[curr], escape);
      const middleChar = explode ? '=' : '.';
      const prefix = prev ? `${prev}.` : '.';
      return `${prefix}${curr}${middleChar}${val}`;
    }, '');
  }
  if (style === 'matrix' && explode) {
    return valueKeys.reduce((prev, curr) => {
      const val = valueEncoder(value[curr], escape);
      const prefix = prev ? `${prev};` : ';';
      return `${prefix}${curr}=${val}`;
    }, '');
  }
  if (style === 'matrix') {
    // no explode
    return valueKeys.reduce((prev, curr) => {
      const val = valueEncoder(value[curr], escape);
      const prefix = prev ? `${prev},` : `;${key}=`;
      return `${prefix}${curr},${val}`;
    }, '');
  }
  if (style === 'form') {
    return valueKeys.reduce((prev, curr) => {
      const val = valueEncoder(value[curr], escape);
      const prefix = prev ? `${prev}${explode ? '&' : ','}` : '';
      const separator = explode ? '=' : ',';
      return `${prefix}${curr}${separator}${val}`;
    }, '');
  }
  return undefined;
}
function encodePrimitive({
  key,
  value,
  style,
  escape
}) {
  if (style === 'simple') {
    return valueEncoder(value, escape);
  }
  if (style === 'label') {
    return `.${valueEncoder(value, escape)}`;
  }
  if (style === 'matrix') {
    return `;${key}=${valueEncoder(value, escape)}`;
  }
  if (style === 'form') {
    return valueEncoder(value, escape);
  }
  if (style === 'deepObject') {
    return valueEncoder(value, escape);
  }
  return undefined;
}

/***/ },

/***/ 77768
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   applySecurities: () => (/* binding */ applySecurities),
/* harmony export */   "default": () => (/* binding */ buildRequest)
/* harmony export */ });
/* harmony import */ var _helpers_btoa_node_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39687);


// This function runs after the common function,
// `src/execute/index.js#buildRequest`
function buildRequest(options, req) {
  const {
    spec,
    operation,
    securities,
    requestContentType,
    responseContentType,
    attachContentTypeForEmptyPayload
  } = options;
  // Add securities, which are applicable
  req = applySecurities({
    request: req,
    securities,
    operation,
    spec
  });
  if (req.body || req.form || attachContentTypeForEmptyPayload) {
    // all following conditionals are Swagger2 only
    if (requestContentType) {
      req.headers['Content-Type'] = requestContentType;
    } else if (Array.isArray(operation.consumes)) {
      [req.headers['Content-Type']] = operation.consumes;
    } else if (Array.isArray(spec.consumes)) {
      [req.headers['Content-Type']] = spec.consumes;
    } else if (operation.parameters && operation.parameters.filter(p => p.type === 'file').length) {
      req.headers['Content-Type'] = 'multipart/form-data';
    } else if (operation.parameters && operation.parameters.filter(p => p.in === 'formData').length) {
      req.headers['Content-Type'] = 'application/x-www-form-urlencoded';
    }
  } else if (requestContentType) {
    const isBodyParamPresent = operation.parameters && operation.parameters.filter(p => p.in === 'body').length > 0;
    const isFormDataParamPresent = operation.parameters && operation.parameters.filter(p => p.in === 'formData').length > 0;
    if (isBodyParamPresent || isFormDataParamPresent) {
      req.headers['Content-Type'] = requestContentType;
    }
  }
  if (!responseContentType && Array.isArray(operation.produces) && operation.produces.length > 0) {
    req.headers.accept = operation.produces.join(', ');
  }
  return req;
}

// Add security values, to operations - that declare their need on them
function applySecurities({
  request,
  securities = {},
  operation = {},
  spec
}) {
  const result = {
    ...request
  };
  const {
    authorized = {},
    specSecurity = []
  } = securities;
  const security = operation.security || specSecurity;
  const isAuthorized = authorized && !!Object.keys(authorized).length;
  const securityDef = spec.securityDefinitions;
  result.headers = result.headers || {};
  result.query = result.query || {};
  if (!Object.keys(securities).length || !isAuthorized || !security || Array.isArray(operation.security) && !operation.security.length) {
    return request;
  }
  security.forEach(securityObj => {
    Object.keys(securityObj).forEach(key => {
      const auth = authorized[key];
      if (!auth) {
        return;
      }
      const {
        token
      } = auth;
      const value = auth.value || auth;
      const schema = securityDef[key];
      const {
        type
      } = schema;
      const tokenName = schema['x-tokenName'] || 'access_token';
      const oauthToken = token && token[tokenName];
      let tokenType = token && token.token_type;
      if (auth) {
        if (type === 'apiKey') {
          const inType = schema.in === 'query' ? 'query' : 'headers';
          result[inType] = result[inType] || {};
          result[inType][schema.name] = value;
        } else if (type === 'basic') {
          if (value.header) {
            result.headers.authorization = value.header;
          } else {
            const username = value.username || '';
            const password = value.password || '';
            value.base64 = (0,_helpers_btoa_node_js__WEBPACK_IMPORTED_MODULE_0__["default"])(`${username}:${password}`);
            result.headers.authorization = `Basic ${value.base64}`;
          }
        } else if (type === 'oauth2' && oauthToken) {
          tokenType = !tokenType || tokenType.toLowerCase() === 'bearer' ? 'Bearer' : tokenType;
          result.headers.authorization = `${tokenType} ${oauthToken}`;
        }
      }
    });
  });
  return result;
}

/***/ },

/***/ 90520
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var openapi_path_templating__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(61546);


// These functions will update the request.
// They'll be given {req, value, paramter, spec, operation}.

/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
  body: bodyBuilder,
  header: headerBuilder,
  query: queryBuilder,
  path: pathBuilder,
  formData: formDataBuilder
});

// Add the body to the request
function bodyBuilder({
  req,
  value
}) {
  if (value !== undefined) {
    req.body = value;
  }
}

// Add a form data object.
function formDataBuilder({
  req,
  value,
  parameter
}) {
  if (value === false && parameter.type === 'boolean') {
    value = 'false';
  }
  if (value === 0 && ['number', 'integer'].indexOf(parameter.type) > -1) {
    value = '0';
  }
  if (value) {
    req.form = req.form || {};
    req.form[parameter.name] = {
      collectionFormat: parameter.collectionFormat,
      value
    };
  } else if (parameter.allowEmptyValue && value !== undefined) {
    req.form = req.form || {};
    const paramName = parameter.name;
    req.form[paramName] = req.form[paramName] || {};
    req.form[paramName].allowEmptyValue = true;
  }
}

// Add a header to the request
function headerBuilder({
  req,
  parameter,
  value
}) {
  req.headers = req.headers || {};
  if (typeof value !== 'undefined') {
    req.headers[parameter.name] = value;
  }
}

// Replace path paramters, with values ( ie: the URL )
function pathBuilder({
  req,
  value,
  parameter,
  baseURL
}) {
  if (value !== undefined) {
    const pathname = req.url.replace(baseURL, '');
    const resolvedPathname = (0,openapi_path_templating__WEBPACK_IMPORTED_MODULE_0__.resolve)(pathname, {
      [parameter.name]: value
    });
    req.url = baseURL + resolvedPathname;
  }
}

// Add a query to the `query` object, which will later be stringified into the URL's search
function queryBuilder({
  req,
  value,
  parameter
}) {
  req.query = req.query || {};
  if (value === false && parameter.type === 'boolean') {
    value = 'false';
  }
  if (value === 0 && ['number', 'integer'].indexOf(parameter.type) > -1) {
    value = '0';
  }
  if (value) {
    req.query[parameter.name] = {
      collectionFormat: parameter.collectionFormat,
      value
    };
  } else if (parameter.allowEmptyValue && value !== undefined) {
    const paramName = parameter.name;
    req.query[paramName] = req.query[paramName] || {};
    req.query[paramName].allowEmptyValue = true;
  }
}

/***/ },

/***/ 34399
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _abortcontroller_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(42701);

if (typeof globalThis.AbortController === 'undefined') {
  globalThis.AbortController = _abortcontroller_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.AbortController;
}
if (typeof globalThis.AbortSignal === 'undefined') {
  globalThis.AbortSignal = _abortcontroller_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.AbortSignal;
}

/***/ },

/***/ 42701
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AbortController: () => (/* binding */ AbortController),
/* harmony export */   AbortSignal: () => (/* binding */ AbortSignal)
/* harmony export */ });
// we're targeting browsers that already support fetch API
const {
  AbortController,
  AbortSignal
} = globalThis;


/***/ },

/***/ 39687
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* eslint-disable no-undef, no-restricted-globals */

const globalObject = (() => {
  // new standardized access to the global object
  if (typeof globalThis !== 'undefined') {
    return globalThis;
  }

  // WebWorker specific access
  if (typeof self !== 'undefined') {
    return self;
  }
  return window;
})();
const {
  btoa
} = globalObject;
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (btoa);

/***/ },

/***/ 48009
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   serialize: () => (/* binding */ serialize),
/* harmony export */   valuePercentEncoder: () => (/* binding */ valuePercentEncoder)
/* harmony export */ });
/* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24454);
/* harmony import */ var _swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2211);


const eqSignPE = '%3D';
const ampersandPE = '%26';
const valuePercentEncoder = cookieValue => (0,_swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__.cookieValueStrictPercentEncoder)(cookieValue).replace(/[=&]/gu, match => match === '=' ? eqSignPE : ampersandPE);
const serialize = (cookiePairs, options = {}) => {
  const defaultOptions = {
    encoders: {
      name: _swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__.identity,
      value: valuePercentEncoder
    },
    validators: {
      name: _swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__.cookieNameLenientValidator,
      value: _swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__.cookieValueStrictValidator
    }
  };
  return (0,_swaggerexpert_cookie__WEBPACK_IMPORTED_MODULE_1__.serializeCookie)(cookiePairs, (0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])(defaultOptions, options));
};

/***/ },

/***/ 28686
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (/* binding */ eachOperation)
/* harmony export */ });
// iterate over each operation, and fire a callback with details
// `find=true` will stop iterating, when the cb returns truthy
function eachOperation(spec, cb, find) {
  if (!spec || typeof spec !== 'object' || !spec.paths || typeof spec.paths !== 'object') {
    return null;
  }
  const {
    paths
  } = spec;

  // Iterate over the spec, collecting operations
  // eslint-disable-next-line no-restricted-syntax, guard-for-in
  for (const pathName in paths) {
    // eslint-disable-next-line no-restricted-syntax, guard-for-in
    for (const method in paths[pathName]) {
      if (method.toUpperCase() === 'PARAMETERS') {
        continue; // eslint-disable-line no-continue
      }
      const operation = paths[pathName][method];
      if (!operation || typeof operation !== 'object') {
        continue; // eslint-disable-line no-continue
      }
      const operationObj = {
        spec,
        pathName,
        method: method.toUpperCase(),
        operation
      };
      const cbValue = cb(operationObj);
      if (find && cbValue) {
        return operationObj;
      }
    }
  }
  return undefined;
}

/***/ },

/***/ 29641
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28683);

if (typeof globalThis.fetch === 'undefined') {
  globalThis.fetch = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.fetch;
}
if (typeof globalThis.Headers === 'undefined') {
  globalThis.Headers = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.Headers;
}
if (typeof globalThis.Request === 'undefined') {
  globalThis.Request = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.Request;
}
if (typeof globalThis.Response === 'undefined') {
  globalThis.Response = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.Response;
}
if (typeof globalThis.FormData === 'undefined') {
  globalThis.FormData = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.FormData;
}
if (typeof globalThis.File === 'undefined') {
  globalThis.File = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.File;
}
if (typeof globalThis.Blob === 'undefined') {
  globalThis.Blob = _fetch_ponyfill_browser_js__WEBPACK_IMPORTED_MODULE_0__.Blob;
}

/***/ },

/***/ 28683
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Blob: () => (/* binding */ Blob),
/* harmony export */   File: () => (/* binding */ File),
/* harmony export */   FormData: () => (/* binding */ FormData),
/* harmony export */   Headers: () => (/* binding */ Headers),
/* harmony export */   Request: () => (/* binding */ Request),
/* harmony export */   Response: () => (/* binding */ Response),
/* harmony export */   fetch: () => (/* binding */ fetch)
/* harmony export */ });
// we're targeting browsers that already support fetch API
const {
  fetch,
  Response,
  Headers,
  Request,
  FormData,
  File,
  Blob
} = globalThis;


/***/ },

/***/ 71356
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "defaul