honoka/lib/honoka.cjs.js

Just a fetch() API wrapper for both Browser and Node.js.

/**
 * honoka v0.5.2
 * (c) 2020 kokororin
 * Released under the MIT License.
 * https://github.com/kokororin/honoka#readme
 */

'use strict';

var support = {
  searchParams: 'URLSearchParams' in self,
  iterable: 'Symbol' in self && 'iterator' in Symbol,
  blob: 'FileReader' in self && 'Blob' in self && function () {
    try {
      new Blob();
      return true;
    } catch (e) {
      return false;
    }
  }(),
  formData: 'FormData' in self,
  arrayBuffer: 'ArrayBuffer' in self
};

function isDataView(obj) {
  return obj && DataView.prototype.isPrototypeOf(obj);
}

if (support.arrayBuffer) {
  var viewClasses = ['[object Int8Array]', '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Int16Array]', '[object Uint16Array]', '[object Int32Array]', '[object Uint32Array]', '[object Float32Array]', '[object Float64Array]'];

  var isArrayBufferView = ArrayBuffer.isView || function (obj) {
    return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
  };
}

function normalizeName(name) {
  if (typeof name !== 'string') {
    name = String(name);
  }

  if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
    throw new TypeError('Invalid character in header field name');
  }

  return name.toLowerCase();
}

function normalizeValue(value) {
  if (typeof value !== 'string') {
    value = String(value);
  }

  return value;
} // Build a destructive iterator for the value list


function iteratorFor(items) {
  var iterator = {
    next: function () {
      var value = items.shift();
      return {
        done: value === undefined,
        value: value
      };
    }
  };

  if (support.iterable) {
    iterator[Symbol.iterator] = function () {
      return iterator;
    };
  }

  return iterator;
}

function Headers(headers) {
  this.map = {};

  if (headers instanceof Headers) {
    headers.forEach(function (value, name) {
      this.append(name, value);
    }, this);
  } else if (Array.isArray(headers)) {
    headers.forEach(function (header) {
      this.append(header[0], header[1]);
    }, this);
  } else if (headers) {
    Object.getOwnPropertyNames(headers).forEach(function (name) {
      this.append(name, headers[name]);
    }, this);
  }
}

Headers.prototype.append = function (name, value) {
  name = normalizeName(name);
  value = normalizeValue(value);
  var oldValue = this.map[name];
  this.map[name] = oldValue ? oldValue + ', ' + value : value;
};

Headers.prototype['delete'] = function (name) {
  delete this.map[normalizeName(name)];
};

Headers.prototype.get = function (name) {
  name = normalizeName(name);
  return this.has(name) ? this.map[name] : null;
};

Headers.prototype.has = function (name) {
  return this.map.hasOwnProperty(normalizeName(name));
};

Headers.prototype.set = function (name, value) {
  this.map[normalizeName(name)] = normalizeValue(value);
};

Headers.prototype.forEach = function (callback, thisArg) {
  for (var name in this.map) {
    if (this.map.hasOwnProperty(name)) {
      callback.call(thisArg, this.map[name], name, this);
    }
  }
};

Headers.prototype.keys = function () {
  var items = [];
  this.forEach(function (value, name) {
    items.push(name);
  });
  return iteratorFor(items);
};

Headers.prototype.values = function () {
  var items = [];
  this.forEach(function (value) {
    items.push(value);
  });
  return iteratorFor(items);
};

Headers.prototype.entries = function () {
  var items = [];
  this.forEach(function (value, name) {
    items.push([name, value]);
  });
  return iteratorFor(items);
};

if (support.iterable) {
  Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
}

function consumed(body) {
  if (body.bodyUsed) {
    return Promise.reject(new TypeError('Already read'));
  }

  body.bodyUsed = true;
}

function fileReaderReady(reader) {
  return new Promise(function (resolve, reject) {
    reader.onload = function () {
      resolve(reader.result);
    };

    reader.onerror = function () {
      reject(reader.error);
    };
  });
}

function readBlobAsArrayBuffer(blob) {
  var reader = new FileReader();
  var promise = fileReaderReady(reader);
  reader.readAsArrayBuffer(blob);
  return promise;
}

function readBlobAsText(blob) {
  var reader = new FileReader();
  var promise = fileReaderReady(reader);
  reader.readAsText(blob);
  return promise;
}

function readArrayBufferAsText(buf) {
  var view = new Uint8Array(buf);
  var chars = new Array(view.length);

  for (var i = 0; i < view.length; i++) {
    chars[i] = String.fromCharCode(view[i]);
  }

  return chars.join('');
}

function bufferClone(buf) {
  if (buf.slice) {
    return buf.slice(0);
  } else {
    var view = new Uint8Array(buf.byteLength);
    view.set(new Uint8Array(buf));
    return view.buffer;
  }
}

function Body() {
  this.bodyUsed = false;

  this._initBody = function (body) {
    this._bodyInit = body;

    if (!body) {
      this._bodyText = '';
    } else if (typeof body === 'string') {
      this._bodyText = body;
    } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
      this._bodyBlob = body;
    } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
      this._bodyFormData = body;
    } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
      this._bodyText = body.toString();
    } else if (support.arrayBuffer && support.blob && isDataView(body)) {
      this._bodyArrayBuffer = bufferClone(body.buffer); // IE 10-11 can't handle a DataView body.

      this._bodyInit = new Blob([this._bodyArrayBuffer]);
    } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
      this._bodyArrayBuffer = bufferClone(body);
    } else {
      this._bodyText = body = Object.prototype.toString.call(body);
    }

    if (!this.headers.get('content-type')) {
      if (typeof body === 'string') {
        this.headers.set('content-type', 'text/plain;charset=UTF-8');
      } else if (this._bodyBlob && this._bodyBlob.type) {
        this.headers.set('content-type', this._bodyBlob.type);
      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
        this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
      }
    }
  };

  if (support.blob) {
    this.blob = function () {
      var rejected = consumed(this);

      if (rejected) {
        return rejected;
      }

      if (this._bodyBlob) {
        return Promise.resolve(this._bodyBlob);
      } else if (this._bodyArrayBuffer) {
        return Promise.resolve(new Blob([this._bodyArrayBuffer]));
      } else if (this._bodyFormData) {
        throw new Error('could not read FormData body as blob');
      } else {
        return Promise.resolve(new Blob([this._bodyText]));
      }
    };

    this.arrayBuffer = function () {
      if (this._bodyArrayBuffer) {
        return consumed(this) || Promise.resolve(this._bodyArrayBuffer);
      } else {
        return this.blob().then(readBlobAsArrayBuffer);
      }
    };
  }

  this.text = function () {
    var rejected = consumed(this);

    if (rejected) {
      return rejected;
    }

    if (this._bodyBlob) {
      return readBlobAsText(this._bodyBlob);
    } else if (this._bodyArrayBuffer) {
      return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
    } else if (this._bodyFormData) {
      throw new Error('could not read FormData body as text');
    } else {
      return Promise.resolve(this._bodyText);
    }
  };

  if (support.formData) {
    this.formData = function () {
      return this.text().then(decode);
    };
  }

  this.json = function () {
    return this.text().then(JSON.parse);
  };

  return this;
} // HTTP methods whose capitalization should be normalized


var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];

function normalizeMethod(method) {
  var upcased = method.toUpperCase();
  return methods.indexOf(upcased) > -1 ? upcased : method;
}

function Request(input, options) {
  options = options || {};
  var body = options.body;

  if (input instanceof Request) {
    if (input.bodyUsed) {
      throw new TypeError('Already read');
    }

    this.url = input.url;
    this.credentials = input.credentials;

    if (!options.headers) {
      this.headers = new Headers(input.headers);
    }

    this.method = input.method;
    this.mode = input.mode;
    this.signal = input.signal;

    if (!body && input._bodyInit != null) {
      body = input._bodyInit;
      input.bodyUsed = true;
    }
  } else {
    this.url = String(input);
  }

  this.credentials = options.credentials || this.credentials || 'same-origin';

  if (options.headers || !this.headers) {
    this.headers = new Headers(options.headers);
  }

  this.method = normalizeMethod(options.method || this.method || 'GET');
  this.mode = options.mode || this.mode || null;
  this.signal = options.signal || this.signal;
  this.referrer = null;

  if ((this.method === 'GET' || this.method === 'HEAD') && body) {
    throw new TypeError('Body not allowed for GET or HEAD requests');
  }

  this._initBody(body);
}

Request.prototype.clone = function () {
  return new Request(this, {
    body: this._bodyInit
  });
};

function decode(body) {
  var form = new FormData();
  body.trim().split('&').forEach(function (bytes) {
    if (bytes) {
      var split = bytes.split('=');
      var name = split.shift().replace(/\+/g, ' ');
      var value = split.join('=').replace(/\+/g, ' ');
      form.append(decodeURIComponent(name), decodeURIComponent(value));
    }
  });
  return form;
}

function parseHeaders(rawHeaders) {
  var headers = new Headers(); // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
  // https://tools.ietf.org/html/rfc7230#section-3.2

  var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
  preProcessedHeaders.split(/\r?\n/).forEach(function (line) {
    var parts = line.split(':');
    var key = parts.shift().trim();

    if (key) {
      var value = parts.join(':').trim();
      headers.append(key, value);
    }
  });
  return headers;
}

Body.call(Request.prototype);
function Response(bodyInit, options) {
  if (!options) {
    options = {};
  }

  this.type = 'default';
  this.status = options.status === undefined ? 200 : options.status;
  this.ok = this.status >= 200 && this.status < 300;
  this.statusText = 'statusText' in options ? options.statusText : 'OK';
  this.headers = new Headers(options.headers);
  this.url = options.url || '';

  this._initBody(bodyInit);
}
Body.call(Response.prototype);

Response.prototype.clone = function () {
  return new Response(this._bodyInit, {
    status: this.status,
    statusText: this.statusText,
    headers: new Headers(this.headers),
    url: this.url
  });
};

Response.error = function () {
  var response = new Response(null, {
    status: 0,
    statusText: ''
  });
  response.type = 'error';
  return response;
};

var redirectStatuses = [301, 302, 303, 307, 308];

Response.redirect = function (url, status) {
  if (redirectStatuses.indexOf(status) === -1) {
    throw new RangeError('Invalid status code');
  }

  return new Response(null, {
    status: status,
    headers: {
      location: url
    }
  });
};

var DOMException = self.DOMException;

try {
  new DOMException();
} catch (err) {
  DOMException = function (message, name) {
    this.message = message;
    this.name = name;
    var error = Error(message);
    this.stack = error.stack;
  };

  DOMException.prototype = Object.create(Error.prototype);
  DOMException.prototype.constructor = DOMException;
}

function fetch$1(input, init) {
  return new Promise(function (resolve, reject) {
    var request = new Request(input, init);

    if (request.signal && request.signal.aborted) {
      return reject(new DOMException('Aborted', 'AbortError'));
    }

    var xhr = new XMLHttpRequest();

    function abortXhr() {
      xhr.abort();
    }

    xhr.onload = function () {
      var options = {
        status: xhr.status,
        statusText: xhr.statusText,
        headers: parseHeaders(xhr.getAllResponseHeaders() || '')
      };
      options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
      var body = 'response' in xhr ? xhr.response : xhr.responseText;
      resolve(new Response(body, options));
    };

    xhr.onerror = function () {
      reject(new TypeError('Network request failed'));
    };

    xhr.ontimeout = function () {
      reject(new TypeError('Network request failed'));
    };

    xhr.onabort = function () {
      reject(new DOMException('Aborted', 'AbortError'));
    };

    xhr.open(request.method, request.url, true);

    if (request.credentials === 'include') {
      xhr.withCredentials = true;
    } else if (request.credentials === 'omit') {
      xhr.withCredentials = false;
    }

    if ('responseType' in xhr && support.blob) {
      xhr.responseType = 'blob';
    }

    request.headers.forEach(function (value, name) {
      xhr.setRequestHeader(name, value);
    });

    if (request.signal) {
      request.signal.addEventListener('abort', abortXhr);

      xhr.onreadystatechange = function () {
        // DONE (success or failure)
        if (xhr.readyState === 4) {
          request.signal.removeEventListener('abort', abortXhr);
        }
      };
    }

    xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
  });
}
fetch$1.polyfill = true;

if (!self.fetch) {
  self.fetch = fetch$1;
  self.Headers = Headers;
  self.Request = Request;
  self.Response = Response;
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i];
  }

  return arr2;
}

var arrayLikeToArray = _arrayLikeToArray;

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return arrayLikeToArray(arr);
}

var arrayWithoutHoles = _arrayWithoutHoles;

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}

var iterableToArray = _iterableToArray;

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(n);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
}

var unsupportedIterableToArray = _unsupportedIterableToArray;

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

var nonIterableSpread = _nonIterableSpread;

function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
}

var toConsumableArray = _toConsumableArray;

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var _typeof_1 = createCommonjsModule(function (module) {
function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    module.exports = _typeof = function _typeof(obj) {
      return typeof obj;
    };
  } else {
    module.exports = _typeof = function _typeof(obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

module.exports = _typeof;
});

var hasOwn = Object.prototype.hasOwnProperty;
var toString = Object.prototype.toString;

var foreach = function forEach(obj, fn, ctx) {
  if (toString.call(fn) !== '[object Function]') {
    throw new TypeError('iterator must be a function');
  }

  var l = obj.length;

  if (l === +l) {
    for (var i = 0; i < l; i++) {
      fn.call(ctx, obj[i], i, obj);
    }
  } else {
    for (var k in obj) {
      if (hasOwn.call(obj, k)) {
        fn.call(ctx, obj[k], k, obj);
      }
    }
  }
};

var hasOwn$1 = Object.prototype.hasOwnProperty;

var arrayReduce = function (xs, f, acc) {
  var hasAcc = arguments.length >= 3;
  if (hasAcc && xs.reduce) return xs.reduce(f, acc);
  if (xs.reduce) return xs.reduce(f);

  for (var i = 0; i < xs.length; i++) {
    if (!hasOwn$1.call(xs, i)) continue;

    if (!hasAcc) {
      acc = xs[i];
      hasAcc = true;
      continue;
    }

    acc = f(acc, xs[i], i);
  }

  return acc;
};

var isPlainObj = value => {
  if (Object.prototype.toString.call(value) !== '[object Object]') {
    return false;
  }

  const prototype = Object.getPrototypeOf(value);
  return prototype === null || prototype === Object.prototype;
};

const {
  hasOwnProperty
} = Object.prototype;
const {
  propertyIsEnumerable
} = Object;

const defineProperty = (obj, name, value) => Object.defineProperty(obj, name, {
  value,
  writable: true,
  enumerable: true,
  configurable: true
});

const globalThis$1 = commonjsGlobal;
const defaultMergeOpts = {
  concatArrays: false,
  ignoreUndefined: false
};

const getEnumerableOwnPropertyKeys = value => {
  const keys = [];

  for (const key in value) {
    if (hasOwnProperty.call(value, key)) {
      keys.push(key);
    }
  }
  /* istanbul ignore else  */


  if (Object.getOwnPropertySymbols) {
    const symbols = Object.getOwnPropertySymbols(value);

    for (const symbol of symbols) {
      if (propertyIsEnumerable.call(value, symbol)) {
        keys.push(symbol);
      }
    }
  }

  return keys;
};

function clone(value) {
  if (Array.isArray(value)) {
    return cloneArray(value);
  }

  if (isPlainObj(value)) {
    return cloneOptionObject(value);
  }

  return value;
}

function cloneArray(array) {
  const result = array.slice(0, 0);
  getEnumerableOwnPropertyKeys(array).forEach(key => {
    defineProperty(result, key, clone(array[key]));
  });
  return result;
}

function cloneOptionObject(obj) {
  const result = Object.getPrototypeOf(obj) === null ? Object.create(null) : {};
  getEnumerableOwnPropertyKeys(obj).forEach(key => {
    defineProperty(result, key, clone(obj[key]));
  });
  return result;
}
/**
 * @param {*} merged already cloned
 * @param {*} source something to merge
 * @param {string[]} keys keys to merge
 * @param {Object} config Config Object
 * @returns {*} cloned Object
 */


const mergeKeys = (merged, source, keys, config) => {
  keys.forEach(key => {
    if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
      return;
    } // Do not recurse into prototype chain of merged


    if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
      defineProperty(merged, key, merge(merged[key], source[key], config));
    } else {
      defineProperty(merged, key, clone(source[key]));
    }
  });
  return merged;
};
/**
 * @param {*} merged already cloned
 * @param {*} source something to merge
 * @param {Object} config Config Object
 * @returns {*} cloned Object
 *
 * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
 */


const concatArrays = (merged, source, config) => {
  let result = merged.slice(0, 0);
  let resultIndex = 0;
  [merged, source].forEach(array => {
    const indices = []; // `result.concat(array)` with cloning

    for (let k = 0; k < array.length; k++) {
      if (!hasOwnProperty.call(array, k)) {
        continue;
      }

      indices.push(String(k));

      if (array === merged) {
        // Already cloned
        defineProperty(result, resultIndex++, array[k]);
      } else {
        defineProperty(result, resultIndex++, clone(array[k]));
      }
    } // Merge non-index keys


    result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config);
  });
  return result;
};
/**
 * @param {*} merged already cloned
 * @param {*} source something to merge
 * @param {Object} config Config Object
 * @returns {*} cloned Object
 */


function merge(merged, source, config) {
  if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
    return concatArrays(merged, source, config);
  }

  if (!isPlainObj(source) || !isPlainObj(merged)) {
    return clone(source);
  }

  return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
}

var mergeOptions = function (...options) {
  const config = merge(clone(defaultMergeOpts), this !== globalThis$1 && this || {}, defaultMergeOpts);
  let merged = {
    _: {}
  };

  for (const option of options) {
    if (option === undefined) {
      continue;
    }

    if (!isPlainObj(option)) {
      throw new TypeError('`' + option + '` is not an Option Object');
    }

    merged = merge(merged, {
      _: option
    }, config);
  }

  return merged._;
};

// Copyright Joyent, Inc. and other Node contributors.

var stringifyPrimitive = function (v) {
  switch (typeof v) {
    case 'string':
      return v;

    case 'boolean':
      return v ? 'true' : 'false';

    case 'number':
      return isFinite(v) ? v : '';

    default:
      return '';
  }
};

var encode = function (obj, sep, eq, name) {
  sep = sep || '&';
  eq = eq || '=';

  if (obj === null) {
    obj = undefined;
  }

  if (typeof obj === 'object') {
    return Object.keys(obj).map(function (k) {
      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;

      if (Array.isArray(obj[k])) {
        return obj[k].map(function (v) {
          return ks + encodeURIComponent(stringifyPrimitive(v));
        }).join(sep);
      } else {
        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
      }
    }).join(sep);
  }

  if (!name) return '';
  return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));
};

var methods$1 = ['get', 'delete', 'head', 'options', 'post', 'put', 'patch'];

var spaceChars = " \\s\xA0";
var symbolRegex = /([[\]().?/*{}+$^:])/g;
function trimStart(str) {
  var charlist = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : spaceChars;
  charlist = (charlist + '').replace(symbolRegex, '$1');
  var re = new RegExp("^[".concat(charlist, "]+"), 'g');
  return String(str).replace(re, '');
}
function trimEnd(str) {
  var charlist = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : spaceChars;
  charlist = (charlist + '').replace(symbolRegex, '\\$1');
  var re = new RegExp("[".concat(charlist, "]+$"), 'g');
  return String(str).replace(re, '');
}
function isObject(value) {
  return value !== null && _typeof_1(value) === 'object';
}
function isString(value) {
  return typeof value === 'string';
}
function isFormData(value) {
  return typeof FormData !== 'undefined' && value instanceof FormData;
}
function isNode() {
  if (typeof global.process !== 'undefined' &&
  /* istanbul ignore next */
  global.process.versions &&
  /* istanbul ignore next */
  global.process.versions.node) {
    /* istanbul ignore next */
    return true;
  }

  return false;
}
function isAbsoluteURL(url) {
  return /^(?:[a-z]+:)?\/\//i.test(url);
}
function buildURL(url, params) {
  if (!params) {
    return url;
  }

  var uris = [];
  foreach(params, function (value, key) {
    if (isObject(value)) {
      value = JSON.stringify(value);
    }

    uris.push("".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value)));
  });
  url += (url.indexOf('?') === -1 ? '?' : '&') + uris.join('&');
  return url;
}
function normalizeHeaders(headers) {
  var ucFirst = function ucFirst(str) {
    str = String(str);
    return str.charAt(0).toUpperCase() + str.substr(1);
  };

  foreach(headers, function (value, key) {
    if (methods$1.indexOf(key) === -1) {
      var normalizedKey = ucFirst(key.toLowerCase().replace('_', '-').replace(/-(\w)/g, function ($0, $1) {
        return '-' + ucFirst($1);
      }));
      delete headers[key];
      headers[normalizedKey] = value;
    }
  });
}

var defaults = {
  baseURL: '',
  timeout: 0,
  method: 'get',
  headers: {},
  dataType: 'auto',
  expectedStatus: function expectedStatus(status) {
    return status >= 200 && status < 400;
  }
}; // set the default content-type of request methods

foreach(['delete', 'get', 'head'], function (method) {
  defaults.headers[method] = {};
});
foreach(['post', 'put', 'patch'], function (method) {
  defaults.headers[method] = {
    'Content-Type': 'application/json'
  };
});

var interceptors = {};
var container = [];

interceptors.register = function (interceptor) {
  container.push(interceptor);
  return function () {
    var index = container.indexOf(interceptor);

    if (index >= 0) {
      container.splice(index, 1);
    }
  };
};

interceptors.clear = function () {
  container.length = 0;
};

interceptors.get = function () {
  return container;
};

function honoka(url) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  options = mergeOptions(defaults, options);
  options.method = options.method.toLowerCase();

  if (typeof url !== 'string') {
    throw new TypeError("Argument 1 expected string but got ".concat(_typeof_1(url)));
  }

  if (!isAbsoluteURL(url)) {
    url = "".concat(trimEnd(options.baseURL, '/'), "/").concat(trimStart(url, '/'));
  }

  if (options.method === 'get' && isObject(options.data)) {
    url = buildURL(url, options.data);
  }

  normalizeHeaders(options.headers); // Set default headers for specified methods

  var methodDefaultHeaders = defaults.headers[options.method];

  if (isObject(methodDefaultHeaders)) {
    options.headers = mergeOptions(methodDefaultHeaders, options.headers);
  }

  foreach(methods$1, function (method) {
    return delete options.headers[method];
  });
  var isContentTypeString = isString(options.headers['Content-Type']);

  if (isContentTypeString && options.headers['Content-Type'].match(/application\/json/i)) {
    options.body = JSON.stringify(options.data);
  } else if (isContentTypeString && options.headers['Content-Type'].match(/application\/x-www-form-urlencoded/i)) {
    options.body = encode(options.data);
  } else if (options.data && options.method !== 'get' && options.method !== 'head') {
    options.body = options.data;
  }

  if (isFormData(options.data) || isContentTypeString && options.headers['Content-Type'].match(/multipart\/form-data/i)) {
    delete options.headers['Content-Type'];
  } // parse interceptors


  var reversedInterceptors = arrayReduce(interceptors.get(), function (array, interceptor) {
    return [interceptor].concat(toConsumableArray(array));
  }, []);

  if (!options.ignoreInterceptors) {
    foreach(reversedInterceptors, function (interceptor) {
      if (interceptor.request) {
        var interceptedOptions = interceptor.request(options);

        if (isObject(interceptedOptions)) {
          options = interceptedOptions;
        } else {
          throw new Error('Apply request interceptor failed, please check your interceptor');
        }
      }
    });
  }

  return new Promise(function (resolve, reject) {
    if (options.timeout > 0) {
      setTimeout(function () {
        reject(new Error('Request timeout'));
      }, options.timeout);
    }

    fetch(url, options).then(function (response) {
      var clonedResponse = response.clone();
      var data;

      switch (options.dataType.toLowerCase()) {
        case 'arraybuffer':
          data = clonedResponse.arrayBuffer();
          break;

        case 'blob':
          data = clonedResponse.blob();
          break;

        case 'json':
          data = clonedResponse.json();
          break;

        case 'buffer':
          if (!isNode()) {
            reject(new Error('"buffer" is not supported in browser'));
          }

          data = clonedResponse.buffer();
          break;

        case 'text':
        default:
          data = clonedResponse.text();
          break;

        case '':
        case 'auto':
          data = clonedResponse.text();
          break;
      }

      response.data = data;
      return response;
    }).then(function (response) {
      response.data.then(function (data) {
        var clonedResponse = response.clone();
        response.data = data;

        if (options.dataType.toLowerCase() === '' || options.dataType.toLowerCase() === 'auto') {
          var contentType = response.headers.get('Content-Type');

          if (contentType && contentType.match(/application\/json/i)) {
            response.data = JSON.parse(response.data);
          }
        }

        if (!options.ignoreInterceptors) {
          for (var i = 0; i < reversedInterceptors.length; i++) {
            var interceptor = reversedInterceptors[i];

            if (interceptor.response) {
              var interceptedResponse = interceptor.response(response);

              if (interceptedResponse instanceof Error) {
                reject(interceptedResponse);
                break;
              } else if (interceptedResponse) {
                response = interceptedResponse;
              } else {
                reject(new Error('Apply response interceptor failed, please check your interceptor'));
              }
            }
          }
        }

        if (options.expectedStatus(clonedResponse.status)) {
          resolve(response);
        } else {
          reject(new Error("Unexpected status code: ".concat(clonedResponse.status)));
        }
      });
    })["catch"](reject);
  });
}

honoka.defaults = defaults;
honoka.interceptors = interceptors; // Let's export the library version

honoka.version = "0.5.2"; // Provide aliases for supported request methods

foreach(methods$1, function (method) {
  honoka[method] = function (url) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    options.method = method;
    return honoka(url, options);
  };
});

module.exports = honoka;