@storyblok/js 1.0.0

package/dist/storyblok-js.mjs

@@ -0,0 +1,1527 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a2, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a2, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a2, prop, b[prop]);
+    }
+  return a2;
+};
+var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
+let loaded = false;
+const callbacks = [];
+const loadBridge = (src) => {
+  window.storyblokRegisterEvent = (cb) => {
+    if (window.location === window.parent.location) {
+      console.warn("You are not in Draft Mode or in the Visual Editor.");
+      return;
+    }
+    if (!loaded)
+      callbacks.push(cb);
+    else
+      cb();
+  };
+  return new Promise((resolve, reject) => {
+    if (document.getElementById("storyblok-javascript-bridge"))
+      return;
+    const script = document.createElement("script");
+    script.async = true;
+    script.src = src;
+    script.id = "storyblok-javascript-bridge";
+    script.onerror = (error) => reject(error);
+    script.onload = (ev) => {
+      callbacks.forEach((cb) => cb());
+      loaded = true;
+      resolve(ev);
+    };
+    document.getElementsByTagName("head")[0].appendChild(script);
+  });
+};
+var axios$2 = { exports: {} };
+var bind$2 = function bind(fn, thisArg) {
+  return function wrap() {
+    var args = new Array(arguments.length);
+    for (var i2 = 0; i2 < args.length; i2++) {
+      args[i2] = arguments[i2];
+    }
+    return fn.apply(thisArg, args);
+  };
+};
+var bind$1 = bind$2;
+var toString = Object.prototype.toString;
+function isArray(val) {
+  return toString.call(val) === "[object Array]";
+}
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+function isArrayBuffer(val) {
+  return toString.call(val) === "[object ArrayBuffer]";
+}
+function isFormData(val) {
+  return typeof FormData !== "undefined" && val instanceof FormData;
+}
+function isArrayBufferView(val) {
+  var result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && val.buffer instanceof ArrayBuffer;
+  }
+  return result;
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject(val) {
+  if (toString.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate(val) {
+  return toString.call(val) === "[object Date]";
+}
+function isFile(val) {
+  return toString.call(val) === "[object File]";
+}
+function isBlob(val) {
+  return toString.call(val) === "[object Blob]";
+}
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+function isStream(val) {
+  return isObject(val) && isFunction(val.pipe);
+}
+function isURLSearchParams(val) {
+  return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+}
+function trim(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (var i2 = 0, l2 = obj.length; i2 < l2; i2++) {
+      fn.call(null, obj[i2], i2, obj);
+    }
+  } else {
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+function merge() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject(result[key]) && isPlainObject(val)) {
+      result[key] = merge(result[key], val);
+    } else if (isPlainObject(val)) {
+      result[key] = merge({}, val);
+    } else if (isArray(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i2 = 0, l2 = arguments.length; i2 < l2; i2++) {
+    forEach(arguments[i2], assignValue);
+  }
+  return result;
+}
+function extend(a2, b, thisArg) {
+  forEach(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a2[key] = bind$1(val, thisArg);
+    } else {
+      a2[key] = val;
+    }
+  });
+  return a2;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$d = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM
+};
+var utils$c = utils$d;
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$2 = function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$c.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$c.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$c.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$c.forEach(val, function parseValue(v) {
+        if (utils$c.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$c.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode(key) + "=" + encode(v));
+      });
+    });
+    serializedParams = parts.join("&");
+  }
+  if (serializedParams) {
+    var hashmarkIndex = url.indexOf("#");
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+};
+var utils$b = utils$d;
+function InterceptorManager$1() {
+  this.handlers = [];
+}
+InterceptorManager$1.prototype.use = function use(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$1.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$1.prototype.forEach = function forEach2(fn) {
+  utils$b.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager$1;
+var utils$a = utils$d;
+var normalizeHeaderName$1 = function normalizeHeaderName(headers, normalizedName) {
+  utils$a.forEach(headers, function processHeader(value, name2) {
+    if (name2 !== normalizedName && name2.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name2];
+    }
+  });
+};
+var enhanceError$2 = function enhanceError(error, config, code, request2, response) {
+  error.config = config;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request2;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code
+    };
+  };
+  return error;
+};
+var enhanceError$1 = enhanceError$2;
+var createError$2 = function createError(message, config, code, request2, response) {
+  var error = new Error(message);
+  return enhanceError$1(error, config, code, request2, response);
+};
+var createError$1 = createError$2;
+var settle$1 = function settle(resolve, reject, response) {
+  var validateStatus2 = response.config.validateStatus;
+  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
+    resolve(response);
+  } else {
+    reject(createError$1("Request failed with status code " + response.status, response.config, null, response.request, response));
+  }
+};
+var utils$9 = utils$d;
+var cookies$1 = utils$9.isStandardBrowserEnv() ? function standardBrowserEnv() {
+  return {
+    write: function write(name2, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name2 + "=" + encodeURIComponent(value));
+      if (utils$9.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$9.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$9.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name2) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name2) {
+      this.write(name2, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$1 = function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+};
+var combineURLs$1 = function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL2 = isAbsoluteURL$1;
+var combineURLs2 = combineURLs$1;
+var buildFullPath$1 = function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL2(requestedURL)) {
+    return combineURLs2(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$8 = utils$d;
+var ignoreDuplicateOf = [
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent"
+];
+var parseHeaders$1 = function parseHeaders(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i2;
+  if (!headers) {
+    return parsed;
+  }
+  utils$8.forEach(headers.split("\n"), function parser(line) {
+    i2 = line.indexOf(":");
+    key = utils$8.trim(line.substr(0, i2)).toLowerCase();
+    val = utils$8.trim(line.substr(i2 + 1));
+    if (key) {
+      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+        return;
+      }
+      if (key === "set-cookie") {
+        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+      } else {
+        parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+      }
+    }
+  });
+  return parsed;
+};
+var utils$7 = utils$d;
+var isURLSameOrigin$1 = utils$7.isStandardBrowserEnv() ? function standardBrowserEnv2() {
+  var msie = /(msie|trident)/i.test(navigator.userAgent);
+  var urlParsingNode = document.createElement("a");
+  var originURL;
+  function resolveURL(url) {
+    var href = url;
+    if (msie) {
+      urlParsingNode.setAttribute("href", href);
+      href = urlParsingNode.href;
+    }
+    urlParsingNode.setAttribute("href", href);
+    return {
+      href: urlParsingNode.href,
+      protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+      host: urlParsingNode.host,
+      search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+      hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+      hostname: urlParsingNode.hostname,
+      port: urlParsingNode.port,
+      pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+    };
+  }
+  originURL = resolveURL(window.location.href);
+  return function isURLSameOrigin2(requestURL) {
+    var parsed = utils$7.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv2() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+var utils$6 = utils$d;
+var settle2 = settle$1;
+var cookies = cookies$1;
+var buildURL$1 = buildURL$2;
+var buildFullPath2 = buildFullPath$1;
+var parseHeaders2 = parseHeaders$1;
+var isURLSameOrigin = isURLSameOrigin$1;
+var createError2 = createError$2;
+var xhr = function xhrAdapter(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    if (utils$6.isFormData(requestData)) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request2 = new XMLHttpRequest();
+    if (config.auth) {
+      var username = config.auth.username || "";
+      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+      requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+    }
+    var fullPath = buildFullPath2(config.baseURL, config.url);
+    request2.open(config.method.toUpperCase(), buildURL$1(fullPath, config.params, config.paramsSerializer), true);
+    request2.timeout = config.timeout;
+    function onloadend() {
+      if (!request2) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders2(request2.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response;
+      var response = {
+        data: responseData,
+        status: request2.status,
+        statusText: request2.statusText,
+        headers: responseHeaders,
+        config,
+        request: request2
+      };
+      settle2(resolve, reject, response);
+      request2 = null;
+    }
+    if ("onloadend" in request2) {
+      request2.onloadend = onloadend;
+    } else {
+      request2.onreadystatechange = function handleLoad() {
+        if (!request2 || request2.readyState !== 4) {
+          return;
+        }
+        if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request2.onabort = function handleAbort() {
+      if (!request2) {
+        return;
+      }
+      reject(createError2("Request aborted", config, "ECONNABORTED", request2));
+      request2 = null;
+    };
+    request2.onerror = function handleError() {
+      reject(createError2("Network Error", config, null, request2));
+      request2 = null;
+    };
+    request2.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(createError2(timeoutErrorMessage, config, config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request2));
+      request2 = null;
+    };
+    if (utils$6.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request2) {
+      utils$6.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request2.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$6.isUndefined(config.withCredentials)) {
+      request2.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request2.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request2.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request2.upload) {
+      request2.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken) {
+      config.cancelToken.promise.then(function onCanceled(cancel) {
+        if (!request2) {
+          return;
+        }
+        request2.abort();
+        reject(cancel);
+        request2 = null;
+      });
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    request2.send(requestData);
+  });
+};
+var utils$5 = utils$d;
+var normalizeHeaderName2 = normalizeHeaderName$1;
+var enhanceError2 = enhanceError$2;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils$5.isUndefined(headers) && utils$5.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr;
+  }
+  return adapter;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$5.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$5.trim(rawValue);
+    } catch (e2) {
+      if (e2.name !== "SyntaxError") {
+        throw e2;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$3 = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest(data, headers) {
+    normalizeHeaderName2(headers, "Accept");
+    normalizeHeaderName2(headers, "Content-Type");
+    if (utils$5.isFormData(data) || utils$5.isArrayBuffer(data) || utils$5.isBuffer(data) || utils$5.isStream(data) || utils$5.isFile(data) || utils$5.isBlob(data)) {
+      return data;
+    }
+    if (utils$5.isArrayBufferView(data)) {
+      return data.buffer;
+    }
+    if (utils$5.isURLSearchParams(data)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data.toString();
+    }
+    if (utils$5.isObject(data) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data);
+    }
+    return data;
+  }],
+  transformResponse: [function transformResponse(data) {
+    var transitional2 = this.transitional;
+    var silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
+    var forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$5.isString(data) && data.length) {
+      try {
+        return JSON.parse(data);
+      } catch (e2) {
+        if (strictJSONParsing) {
+          if (e2.name === "SyntaxError") {
+            throw enhanceError2(e2, this, "E_JSON_PARSE");
+          }
+          throw e2;
+        }
+      }
+    }
+    return data;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  }
+};
+defaults$3.headers = {
+  common: {
+    "Accept": "application/json, text/plain, */*"
+  }
+};
+utils$5.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults$3.headers[method] = {};
+});
+utils$5.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults$3.headers[method] = utils$5.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults$3;
+var utils$4 = utils$d;
+var defaults$2 = defaults_1;
+var transformData$1 = function transformData(data, headers, fns) {
+  var context = this || defaults$2;
+  utils$4.forEach(fns, function transform(fn) {
+    data = fn.call(context, data, headers);
+  });
+  return data;
+};
+var isCancel$1 = function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$3 = utils$d;
+var transformData2 = transformData$1;
+var isCancel2 = isCancel$1;
+var defaults$1 = defaults_1;
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+}
+var dispatchRequest$1 = function dispatchRequest(config) {
+  throwIfCancellationRequested(config);
+  config.headers = config.headers || {};
+  config.data = transformData2.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$3.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$3.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$1.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+    response.data = transformData2.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel2(reason)) {
+      throwIfCancellationRequested(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData2.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$2 = utils$d;
+var mergeConfig$2 = function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  var valueFromConfig2Keys = ["url", "method", "data"];
+  var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
+  var defaultToConfig2Keys = [
+    "baseURL",
+    "transformRequest",
+    "transformResponse",
+    "paramsSerializer",
+    "timeout",
+    "timeoutMessage",
+    "withCredentials",
+    "adapter",
+    "responseType",
+    "xsrfCookieName",
+    "xsrfHeaderName",
+    "onUploadProgress",
+    "onDownloadProgress",
+    "decompress",
+    "maxContentLength",
+    "maxBodyLength",
+    "maxRedirects",
+    "transport",
+    "httpAgent",
+    "httpsAgent",
+    "cancelToken",
+    "socketPath",
+    "responseEncoding"
+  ];
+  var directMergeKeys = ["validateStatus"];
+  function getMergedValue(target, source2) {
+    if (utils$2.isPlainObject(target) && utils$2.isPlainObject(source2)) {
+      return utils$2.merge(target, source2);
+    } else if (utils$2.isPlainObject(source2)) {
+      return utils$2.merge({}, source2);
+    } else if (utils$2.isArray(source2)) {
+      return source2.slice();
+    }
+    return source2;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      config[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  }
+  utils$2.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(void 0, config2[prop]);
+    }
+  });
+  utils$2.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+  utils$2.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(void 0, config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      config[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  });
+  utils$2.forEach(directMergeKeys, function merge2(prop) {
+    if (prop in config2) {
+      config[prop] = getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      config[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  });
+  var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
+  var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
+    return axiosKeys.indexOf(key) === -1;
+  });
+  utils$2.forEach(otherKeys, mergeDeepProperties);
+  return config;
+};
+const name = "axios";
+const version = "0.21.4";
+const description = "Promise based HTTP client for the browser and node.js";
+const main = "index.js";
+const scripts = {
+  test: "grunt test",
+  start: "node ./sandbox/server.js",
+  build: "NODE_ENV=production grunt build",
+  preversion: "npm test",
+  version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json",
+  postversion: "git push && git push --tags",
+  examples: "node ./examples/server.js",
+  coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+  fix: "eslint --fix lib/**/*.js"
+};
+const repository = {
+  type: "git",
+  url: "https://github.com/axios/axios.git"
+};
+const keywords = [
+  "xhr",
+  "http",
+  "ajax",
+  "promise",
+  "node"
+];
+const author = "Matt Zabriskie";
+const license = "MIT";
+const bugs = {
+  url: "https://github.com/axios/axios/issues"
+};
+const homepage = "https://axios-http.com";
+const devDependencies = {
+  coveralls: "^3.0.0",
+  "es6-promise": "^4.2.4",
+  grunt: "^1.3.0",
+  "grunt-banner": "^0.6.0",
+  "grunt-cli": "^1.2.0",
+  "grunt-contrib-clean": "^1.1.0",
+  "grunt-contrib-watch": "^1.0.0",
+  "grunt-eslint": "^23.0.0",
+  "grunt-karma": "^4.0.0",
+  "grunt-mocha-test": "^0.13.3",
+  "grunt-ts": "^6.0.0-beta.19",
+  "grunt-webpack": "^4.0.2",
+  "istanbul-instrumenter-loader": "^1.0.0",
+  "jasmine-core": "^2.4.1",
+  karma: "^6.3.2",
+  "karma-chrome-launcher": "^3.1.0",
+  "karma-firefox-launcher": "^2.1.0",
+  "karma-jasmine": "^1.1.1",
+  "karma-jasmine-ajax": "^0.1.13",
+  "karma-safari-launcher": "^1.0.0",
+  "karma-sauce-launcher": "^4.3.6",
+  "karma-sinon": "^1.0.5",
+  "karma-sourcemap-loader": "^0.3.8",
+  "karma-webpack": "^4.0.2",
+  "load-grunt-tasks": "^3.5.2",
+  minimist: "^1.2.0",
+  mocha: "^8.2.1",
+  sinon: "^4.5.0",
+  "terser-webpack-plugin": "^4.2.3",
+  typescript: "^4.0.5",
+  "url-search-params": "^0.10.0",
+  webpack: "^4.44.2",
+  "webpack-dev-server": "^3.11.0"
+};
+const browser = {
+  "./lib/adapters/http.js": "./lib/adapters/xhr.js"
+};
+const jsdelivr = "dist/axios.min.js";
+const unpkg = "dist/axios.min.js";
+const typings = "./index.d.ts";
+const dependencies = {
+  "follow-redirects": "^1.14.0"
+};
+const bundlesize = [
+  {
+    path: "./dist/axios.min.js",
+    threshold: "5kB"
+  }
+];
+var require$$0 = {
+  name,
+  version,
+  description,
+  main,
+  scripts,
+  repository,
+  keywords,
+  author,
+  license,
+  bugs,
+  homepage,
+  devDependencies,
+  browser,
+  jsdelivr,
+  unpkg,
+  typings,
+  dependencies,
+  bundlesize
+};
+var pkg = require$$0;
+var validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i2) {
+  validators$1[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i2 < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings = {};
+var currentVerArr = pkg.version.split(".");
+function isOlderVersion(version2, thanVersion) {
+  var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+  var destVer = version2.split(".");
+  for (var i2 = 0; i2 < 3; i2++) {
+    if (pkgVersionArr[i2] > destVer[i2]) {
+      return true;
+    } else if (pkgVersionArr[i2] < destVer[i2]) {
+      return false;
+    }
+  }
+  return false;
+}
+validators$1.transitional = function transitional(validator2, version2, message) {
+  var isDeprecated = version2 && isOlderVersion(version2);
+  function formatMessage(opt, desc) {
+    return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed in " + version2));
+    }
+    if (isDeprecated && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== "object") {
+    throw new TypeError("options must be an object");
+  }
+  var keys = Object.keys(options);
+  var i2 = keys.length;
+  while (i2-- > 0) {
+    var opt = keys[i2];
+    var validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$1 = {
+  isOlderVersion,
+  assertOptions,
+  validators: validators$1
+};
+var utils$1 = utils$d;
+var buildURL2 = buildURL$2;
+var InterceptorManager = InterceptorManager_1;
+var dispatchRequest2 = dispatchRequest$1;
+var mergeConfig$1 = mergeConfig$2;
+var validator = validator$1;
+var validators = validator.validators;
+function Axios$1(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+}
+Axios$1.prototype.request = function request(config) {
+  if (typeof config === "string") {
+    config = arguments[1] || {};
+    config.url = arguments[0];
+  } else {
+    config = config || {};
+  }
+  config = mergeConfig$1(this.defaults, config);
+  if (config.method) {
+    config.method = config.method.toLowerCase();
+  } else if (this.defaults.method) {
+    config.method = this.defaults.method.toLowerCase();
+  } else {
+    config.method = "get";
+  }
+  var transitional2 = config.transitional;
+  if (transitional2 !== void 0) {
+    validator.assertOptions(transitional2, {
+      silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+      forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+      clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
+    }, false);
+  }
+  var requestInterceptorChain = [];
+  var synchronousRequestInterceptors = true;
+  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+    if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+      return;
+    }
+    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+  });
+  var responseInterceptorChain = [];
+  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+  });
+  var promise;
+  if (!synchronousRequestInterceptors) {
+    var chain = [dispatchRequest2, void 0];
+    Array.prototype.unshift.apply(chain, requestInterceptorChain);
+    chain = chain.concat(responseInterceptorChain);
+    promise = Promise.resolve(config);
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+    return promise;
+  }
+  var newConfig = config;
+  while (requestInterceptorChain.length) {
+    var onFulfilled = requestInterceptorChain.shift();
+    var onRejected = requestInterceptorChain.shift();
+    try {
+      newConfig = onFulfilled(newConfig);
+    } catch (error) {
+      onRejected(error);
+      break;
+    }
+  }
+  try {
+    promise = dispatchRequest2(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$1.prototype.getUri = function getUri(config) {
+  config = mergeConfig$1(this.defaults, config);
+  return buildURL2(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+};
+utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios$1.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  Axios$1.prototype[method] = function(url, data, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data
+    }));
+  };
+});
+var Axios_1 = Axios$1;
+function Cancel$1(message) {
+  this.message = message;
+}
+Cancel$1.prototype.toString = function toString2() {
+  return "Cancel" + (this.message ? ": " + this.message : "");
+};
+Cancel$1.prototype.__CANCEL__ = true;
+var Cancel_1 = Cancel$1;
+var Cancel = Cancel_1;
+function CancelToken(executor) {
+  if (typeof executor !== "function") {
+    throw new TypeError("executor must be a function.");
+  }
+  var resolvePromise;
+  this.promise = new Promise(function promiseExecutor(resolve) {
+    resolvePromise = resolve;
+  });
+  var token = this;
+  executor(function cancel(message) {
+    if (token.reason) {
+      return;
+    }
+    token.reason = new Cancel(message);
+    resolvePromise(token.reason);
+  });
+}
+CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken.source = function source() {
+  var cancel;
+  var token = new CancelToken(function executor(c2) {
+    cancel = c2;
+  });
+  return {
+    token,
+    cancel
+  };
+};
+var CancelToken_1 = CancelToken;
+var spread = function spread2(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var isAxiosError = function isAxiosError2(payload) {
+  return typeof payload === "object" && payload.isAxiosError === true;
+};
+var utils = utils$d;
+var bind2 = bind$2;
+var Axios = Axios_1;
+var mergeConfig2 = mergeConfig$2;
+var defaults = defaults_1;
+function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind2(Axios.prototype.request, context);
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, context);
+  return instance;
+}
+var axios$1 = createInstance(defaults);
+axios$1.Axios = Axios;
+axios$1.create = function create(instanceConfig) {
+  return createInstance(mergeConfig2(axios$1.defaults, instanceConfig));
+};
+axios$1.Cancel = Cancel_1;
+axios$1.CancelToken = CancelToken_1;
+axios$1.isCancel = isCancel$1;
+axios$1.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$1.spread = spread;
+axios$1.isAxiosError = isAxiosError;
+axios$2.exports = axios$1;
+axios$2.exports.default = axios$1;
+var axios = axios$2.exports;
+/*!
+ * storyblok-js-client v0.0.0-development
+ * Universal JavaScript SDK for Storyblok's API
+ * (c) 2020-2022 Stobylok Team
+ */
+function e(t) {
+  return typeof t == "number" && (t == t && t !== 1 / 0 && t !== -1 / 0);
+}
+function r(t, r2, s2) {
+  if (!e(r2))
+    throw new TypeError("Expected `limit` to be a finite number");
+  if (!e(s2))
+    throw new TypeError("Expected `interval` to be a finite number");
+  var n2 = [], i2 = [], o2 = 0, a2 = function() {
+    o2++;
+    var e2 = setTimeout(function() {
+      o2--, n2.length > 0 && a2(), i2 = i2.filter(function(t2) {
+        return t2 !== e2;
+      });
+    }, s2);
+    i2.indexOf(e2) < 0 && i2.push(e2);
+    var r3 = n2.shift();
+    r3.resolve(t.apply(r3.self, r3.args));
+  }, l2 = function() {
+    var t2 = arguments, e2 = this;
+    return new Promise(function(s3, i3) {
+      n2.push({ resolve: s3, reject: i3, args: t2, self: e2 }), o2 < r2 && a2();
+    });
+  };
+  return l2.abort = function() {
+    i2.forEach(clearTimeout), i2 = [], n2.forEach(function(t2) {
+      t2.reject(new throttle.AbortError());
+    }), n2.length = 0;
+  }, l2;
+}
+r.AbortError = function() {
+  Error.call(this, "Throttled function aborted"), this.name = "AbortError";
+};
+const s = function(t, e2) {
+  if (!t)
+    return null;
+  let r2 = {};
+  for (let s2 in t) {
+    let n2 = t[s2];
+    e2.indexOf(s2) > -1 && n2 !== null && (r2[s2] = n2);
+  }
+  return r2;
+};
+var n = { nodes: { horizontal_rule: (t) => ({ singleTag: "hr" }), blockquote: (t) => ({ tag: "blockquote" }), bullet_list: (t) => ({ tag: "ul" }), code_block: (t) => ({ tag: ["pre", { tag: "code", attrs: t.attrs }] }), hard_break: (t) => ({ singleTag: "br" }), heading: (t) => ({ tag: "h" + t.attrs.level }), image: (t) => ({ singleTag: [{ tag: "img", attrs: s(t.attrs, ["src", "alt", "title"]) }] }), list_item: (t) => ({ tag: "li" }), ordered_list: (t) => ({ tag: "ol" }), paragraph: (t) => ({ tag: "p" }) }, marks: { bold: () => ({ tag: "b" }), strike: () => ({ tag: "strike" }), underline: () => ({ tag: "u" }), strong: () => ({ tag: "strong" }), code: () => ({ tag: "code" }), italic: () => ({ tag: "i" }), link(t) {
+  const e2 = __spreadValues({}, t.attrs), { linktype: r2 = "url" } = t.attrs;
+  return r2 === "email" && (e2.href = "mailto:" + e2.href), e2.anchor && (e2.href = `${e2.href}#${e2.anchor}`, delete e2.anchor), { tag: [{ tag: "a", attrs: e2 }] };
+}, styled: (t) => ({ tag: [{ tag: "span", attrs: t.attrs }] }) } };
+class i {
+  constructor(t) {
+    t || (t = n), this.marks = t.marks || [], this.nodes = t.nodes || [];
+  }
+  addNode(t, e2) {
+    this.nodes[t] = e2;
+  }
+  addMark(t, e2) {
+    this.marks[t] = e2;
+  }
+  render(t = {}) {
+    if (t.content && Array.isArray(t.content)) {
+      let e2 = "";
+      return t.content.forEach((t2) => {
+        e2 += this.renderNode(t2);
+      }), e2;
+    }
+    return console.warn("The render method must receive an object with a content field, which is an array"), "";
+  }
+  renderNode(t) {
+    let e2 = [];
+    t.marks && t.marks.forEach((t2) => {
+      const r3 = this.getMatchingMark(t2);
+      r3 && e2.push(this.renderOpeningTag(r3.tag));
+    });
+    const r2 = this.getMatchingNode(t);
+    return r2 && r2.tag && e2.push(this.renderOpeningTag(r2.tag)), t.content ? t.content.forEach((t2) => {
+      e2.push(this.renderNode(t2));
+    }) : t.text ? e2.push(function(t2) {
+      const e3 = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }, r3 = /[&<>"']/g, s2 = RegExp(r3.source);
+      return t2 && s2.test(t2) ? t2.replace(r3, (t3) => e3[t3]) : t2;
+    }(t.text)) : r2 && r2.singleTag ? e2.push(this.renderTag(r2.singleTag, " /")) : r2 && r2.html && e2.push(r2.html), r2 && r2.tag && e2.push(this.renderClosingTag(r2.tag)), t.marks && t.marks.slice(0).reverse().forEach((t2) => {
+      const r3 = this.getMatchingMark(t2);
+      r3 && e2.push(this.renderClosingTag(r3.tag));
+    }), e2.join("");
+  }
+  renderTag(t, e2) {
+    if (t.constructor === String)
+      return `<${t}${e2}>`;
+    return t.map((t2) => {
+      if (t2.constructor === String)
+        return `<${t2}${e2}>`;
+      {
+        let r2 = "<" + t2.tag;
+        if (t2.attrs)
+          for (let e3 in t2.attrs) {
+            let s2 = t2.attrs[e3];
+            s2 !== null && (r2 += ` ${e3}="${s2}"`);
+          }
+        return `${r2}${e2}>`;
+      }
+    }).join("");
+  }
+  renderOpeningTag(t) {
+    return this.renderTag(t, "");
+  }
+  renderClosingTag(t) {
+    if (t.constructor === String)
+      return `</${t}>`;
+    return t.slice(0).reverse().map((t2) => t2.constructor === String ? `</${t2}>` : `</${t2.tag}>`).join("");
+  }
+  getMatchingNode(t) {
+    if (typeof this.nodes[t.type] == "function")
+      return this.nodes[t.type](t);
+  }
+  getMatchingMark(t) {
+    if (typeof this.marks[t.type] == "function")
+      return this.marks[t.type](t);
+  }
+}
+const o = (t = 0, e2 = t) => {
+  const r2 = Math.abs(e2 - t) || 0, s2 = t < e2 ? 1 : -1;
+  return ((t2 = 0, e3) => [...Array(t2)].map(e3))(r2, (e3, r3) => r3 * s2 + t);
+}, a = (t, e2, r2) => {
+  const s2 = [];
+  for (const n2 in t) {
+    if (!Object.prototype.hasOwnProperty.call(t, n2))
+      continue;
+    const i2 = t[n2], o2 = r2 ? "" : encodeURIComponent(n2);
+    let l2;
+    l2 = typeof i2 == "object" ? a(i2, e2 ? e2 + encodeURIComponent("[" + o2 + "]") : o2, Array.isArray(i2)) : (e2 ? e2 + encodeURIComponent("[" + o2 + "]") : o2) + "=" + encodeURIComponent(i2), s2.push(l2);
+  }
+  return s2.join("&");
+};
+let l = {}, c = {};
+class StoryblokClient {
+  constructor(e2, s2) {
+    if (!s2) {
+      let t = e2.region ? "-" + e2.region : "", r2 = e2.https === false ? "http" : "https";
+      s2 = e2.oauthToken === void 0 ? `${r2}://api${t}.storyblok.com/v2` : `${r2}://api${t}.storyblok.com/v1`;
+    }
+    let n2 = Object.assign({}, e2.headers), o2 = 5;
+    e2.oauthToken !== void 0 && (n2.Authorization = e2.oauthToken, o2 = 3), e2.rateLimit !== void 0 && (o2 = e2.rateLimit), this.richTextResolver = new i(e2.richTextSchema), typeof e2.componentResolver == "function" && this.setComponentResolver(e2.componentResolver), this.maxRetries = e2.maxRetries || 5, this.throttle = r(this.throttledRequest, o2, 1e3), this.accessToken = e2.accessToken, this.relations = {}, this.links = {}, this.cache = e2.cache || { clear: "manual" }, this.client = axios.create({ baseURL: s2, timeout: e2.timeout || 0, headers: n2, proxy: e2.proxy || false }), e2.responseInterceptor && this.client.interceptors.response.use((t) => e2.responseInterceptor(t));
+  }
+  setComponentResolver(t) {
+    this.richTextResolver.addNode("blok", (e2) => {
+      let r2 = "";
+      return e2.attrs.body.forEach((e3) => {
+        r2 += t(e3.component, e3);
+      }), { html: r2 };
+    });
+  }
+  parseParams(t = {}) {
+    return t.version || (t.version = "published"), t.token || (t.token = this.getToken()), t.cv || (t.cv = c[t.token]), Array.isArray(t.resolve_relations) && (t.resolve_relations = t.resolve_relations.join(",")), t;
+  }
+  factoryParamOptions(t, e2 = {}) {
+    return ((t2 = "") => t2.indexOf("/cdn/") > -1)(t) ? this.parseParams(e2) : e2;
+  }
+  makeRequest(t, e2, r2, s2) {
+    const n2 = this.factoryParamOptions(t, ((t2 = {}, e3 = 25, r3 = 1) => __spreadProps(__spreadValues({}, t2), { per_page: e3, page: r3 }))(e2, r2, s2));
+    return this.cacheResponse(t, n2);
+  }
+  get(t, e2) {
+    let r2 = "/" + t;
+    const s2 = this.factoryParamOptions(r2, e2);
+    return this.cacheResponse(r2, s2);
+  }
+  async getAll(t, e2 = {}, r2) {
+    const s2 = e2.per_page || 25, n2 = "/" + t, i2 = n2.split("/");
+    r2 = r2 || i2[i2.length - 1];
+    const a2 = await this.makeRequest(n2, e2, s2, 1), l2 = Math.ceil(a2.total / s2);
+    return ((t2 = [], e3) => t2.map(e3).reduce((t3, e4) => [...t3, ...e4], []))([a2, ...await (async (t2 = [], e3) => Promise.all(t2.map(e3)))(o(1, l2), async (t2) => this.makeRequest(n2, e2, s2, t2 + 1))], (t2) => Object.values(t2.data[r2]));
+  }
+  post(t, e2) {
+    let r2 = "/" + t;
+    return this.throttle("post", r2, e2);
+  }
+  put(t, e2) {
+    let r2 = "/" + t;
+    return this.throttle("put", r2, e2);
+  }
+  delete(t, e2) {
+    let r2 = "/" + t;
+    return this.throttle("delete", r2, e2);
+  }
+  getStories(t) {
+    return this.get("cdn/stories", t);
+  }
+  getStory(t, e2) {
+    return this.get("cdn/stories/" + t, e2);
+  }
+  setToken(t) {
+    this.accessToken = t;
+  }
+  getToken() {
+    return this.accessToken;
+  }
+  _cleanCopy(t) {
+    return JSON.parse(JSON.stringify(t));
+  }
+  _insertLinks(t, e2) {
+    const r2 = t[e2];
+    r2 && r2.fieldtype == "multilink" && r2.linktype == "story" && typeof r2.id == "string" && this.links[r2.id] ? r2.story = this._cleanCopy(this.links[r2.id]) : r2 && r2.linktype === "story" && typeof r2.uuid == "string" && this.links[r2.uuid] && (r2.story = this._cleanCopy(this.links[r2.uuid]));
+  }
+  _insertRelations(t, e2, r2) {
+    if (r2.indexOf(t.component + "." + e2) > -1) {
+      if (typeof t[e2] == "string")
+        this.relations[t[e2]] && (t[e2] = this._cleanCopy(this.relations[t[e2]]));
+      else if (t[e2].constructor === Array) {
+        let r3 = [];
+        t[e2].forEach((t2) => {
+          this.relations[t2] && r3.push(this._cleanCopy(this.relations[t2]));
+        }), t[e2] = r3;
+      }
+    }
+  }
+  iterateTree(t, e2) {
+    let r2 = (t2) => {
+      if (t2 != null) {
+        if (t2.constructor === Array)
+          for (let e3 = 0; e3 < t2.length; e3++)
+            r2(t2[e3]);
+        else if (t2.constructor === Object) {
+          if (t2._stopResolving)
+            return;
+          for (let s2 in t2)
+            (t2.component && t2._uid || t2.type === "link") && (this._insertRelations(t2, s2, e2), this._insertLinks(t2, s2)), r2(t2[s2]);
+        }
+      }
+    };
+    r2(t.content);
+  }
+  async resolveLinks(t, e2) {
+    let r2 = [];
+    if (t.link_uuids) {
+      const s2 = t.link_uuids.length;
+      let n2 = [];
+      const i2 = 50;
+      for (let e3 = 0; e3 < s2; e3 += i2) {
+        const r3 = Math.min(s2, e3 + i2);
+        n2.push(t.link_uuids.slice(e3, r3));
+      }
+      for (let t2 = 0; t2 < n2.length; t2++) {
+        (await this.getStories({ per_page: i2, language: e2.language, version: e2.version, by_uuids: n2[t2].join(",") })).data.stories.forEach((t3) => {
+          r2.push(t3);
+        });
+      }
+    } else
+      r2 = t.links;
+    r2.forEach((t2) => {
+      this.links[t2.uuid] = __spreadProps(__spreadValues({}, t2), { _stopResolving: true });
+    });
+  }
+  async resolveRelations(t, e2) {
+    let r2 = [];
+    if (t.rel_uuids) {
+      const s2 = t.rel_uuids.length;
+      let n2 = [];
+      const i2 = 50;
+      for (let e3 = 0; e3 < s2; e3 += i2) {
+        const r3 = Math.min(s2, e3 + i2);
+        n2.push(t.rel_uuids.slice(e3, r3));
+      }
+      for (let t2 = 0; t2 < n2.length; t2++) {
+        (await this.getStories({ per_page: i2, language: e2.language, version: e2.version, by_uuids: n2[t2].join(",") })).data.stories.forEach((t3) => {
+          r2.push(t3);
+        });
+      }
+    } else
+      r2 = t.rels;
+    r2.forEach((t2) => {
+      this.relations[t2.uuid] = __spreadProps(__spreadValues({}, t2), { _stopResolving: true });
+    });
+  }
+  async resolveStories(t, e2) {
+    let r2 = [];
+    e2.resolve_relations !== void 0 && e2.resolve_relations.length > 0 && (r2 = e2.resolve_relations.split(","), await this.resolveRelations(t, e2)), ["1", "story", "url"].indexOf(e2.resolve_links) > -1 && await this.resolveLinks(t, e2);
+    for (const t2 in this.relations)
+      this.iterateTree(this.relations[t2], r2);
+    t.story ? this.iterateTree(t.story, r2) : t.stories.forEach((t2) => {
+      this.iterateTree(t2, r2);
+    });
+  }
+  cacheResponse(t, e2, r2) {
+    return r2 === void 0 && (r2 = 0), new Promise(async (s2, n2) => {
+      let i2 = a({ url: t, params: e2 }), o2 = this.cacheProvider();
+      if (this.cache.clear === "auto" && e2.version === "draft" && await this.flushCache(), e2.version === "published" && t != "/cdn/spaces/me") {
+        const t2 = await o2.get(i2);
+        if (t2)
+          return s2(t2);
+      }
+      try {
+        let r3 = await this.throttle("get", t, { params: e2, paramsSerializer: (t2) => a(t2) }), l3 = { data: r3.data, headers: r3.headers };
+        if (r3.headers["per-page"] && (l3 = Object.assign({}, l3, { perPage: parseInt(r3.headers["per-page"]), total: parseInt(r3.headers.total) })), r3.status != 200)
+          return n2(r3);
+        (l3.data.story || l3.data.stories) && await this.resolveStories(l3.data, e2), e2.version === "published" && t != "/cdn/spaces/me" && o2.set(i2, l3), l3.data.cv && (e2.version == "draft" && c[e2.token] != l3.data.cv && this.flushCache(), c[e2.token] = l3.data.cv), s2(l3);
+      } catch (i3) {
+        if (i3.response && i3.response.status === 429 && (r2 += 1) < this.maxRetries)
+          return console.log(`Hit rate limit. Retrying in ${r2} seconds.`), await (l2 = 1e3 * r2, new Promise((t2) => setTimeout(t2, l2))), this.cacheResponse(t, e2, r2).then(s2).catch(n2);
+        n2(i3);
+      }
+      var l2;
+    });
+  }
+  throttledRequest(t, e2, r2) {
+    return this.client[t](e2, r2);
+  }
+  cacheVersions() {
+    return c;
+  }
+  cacheVersion() {
+    return c[this.accessToken];
+  }
+  setCacheVersion(t) {
+    this.accessToken && (c[this.accessToken] = t);
+  }
+  cacheProvider() {
+    switch (this.cache.type) {
+      case "memory":
+        return { get: (t) => l[t], getAll: () => l, set(t, e2) {
+          l[t] = e2;
+        }, flush() {
+          l = {};
+        } };
+      default:
+        return { get() {
+        }, getAll() {
+        }, set() {
+        }, flush() {
+        } };
+    }
+  }
+  async flushCache() {
+    return await this.cacheProvider().flush(), this;
+  }
+}
+var api = (options = {}) => {
+  const { apiOptions } = options;
+  if (!apiOptions.accessToken) {
+    console.error("You need to provide an access token to interact with Storyblok API. Read https://www.storyblok.com/docs/api/content-delivery#topics/authentication");
+    return;
+  }
+  const storyblokApi = new StoryblokClient(apiOptions);
+  return { storyblokApi };
+};
+var editable = (blok) => {
+  if (typeof blok !== "object" || typeof blok._editable === "undefined") {
+    return {};
+  }
+  const options = JSON.parse(blok._editable.replace(/^<!--#storyblok#/, "").replace(/-->$/, ""));
+  return {
+    "data-blok-c": JSON.stringify(options),
+    "data-blok-uid": options.id + "-" + options.uid
+  };
+};
+const useStoryblokBridge = (id, cb, options = {}) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.storyblokRegisterEvent === "undefined") {
+    console.error("Storyblok Bridge is disabled. Please enable it to use it. Read https://github.com/storyblok/storyblok-js");
+    return;
+  }
+  window.storyblokRegisterEvent(() => {
+    const sbBridge = new window.StoryblokBridge(options);
+    sbBridge.on(["input", "published", "change"], (event) => {
+      if (event.action == "input" && event.story.id === id) {
+        cb(event.story);
+      } else {
+        window.location.reload();
+      }
+    });
+  });
+};
+const storyblokInit = (pluginOptions = {}) => {
+  const { bridge, accessToken, use: use2 = [], apiOptions = {} } = pluginOptions;
+  apiOptions.accessToken = apiOptions.accessToken || accessToken;
+  const options = { bridge, apiOptions };
+  let result = {};
+  use2.forEach((pluginFactory) => {
+    result = __spreadValues(__spreadValues({}, result), pluginFactory(options));
+  });
+  if (bridge !== false) {
+    loadBridge("https://app.storyblok.com/f/storyblok-v2-latest.js");
+  }
+  return result;
+};
+export { api as apiPlugin, editable as storyblokEditable, storyblokInit, useStoryblokBridge };