planning

node_modules/decap-cms-lib-util/dist/decap-cms-lib-util.js.LICENSE.txt

@@ -0,0 +1,15 @@
+/*!
+    localForage -- Offline Storage, Improved
+    Version 1.10.0
+    https://localforage.github.io/localForage
+    (c) 2013-2017 Mozilla, Apache License 2.0
+*/
+
+/**
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.9.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2017
+ * @license MIT
+ */

node_modules/decap-cms-lib-util/dist/esm/API.js

@@ -0,0 +1,333 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PreviewState = void 0;
+exports.apiRequest = apiRequest;
+exports.endpointConstants = exports.apiRoots = void 0;
+exports.getDefaultBranchName = getDefaultBranchName;
+exports.getPreviewStatus = getPreviewStatus;
+exports.isPreviewContext = isPreviewContext;
+exports.parseResponse = parseResponse;
+exports.readFile = readFile;
+exports.readFileMetadata = readFileMetadata;
+exports.requestWithBackoff = requestWithBackoff;
+exports.throwOnConflictingBranches = throwOnConflictingBranches;
+var _asyncLock = require("./asyncLock");
+var _unsentRequest = _interopRequireDefault(require("./unsentRequest"));
+var _APIError = _interopRequireDefault(require("./APIError"));
+const _excluded = ["token", "backend"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+class RateLimitError extends _extendableBuiltin(Error) {
+  constructor(message, resetSeconds) {
+    super(message);
+    _defineProperty(this, "resetSeconds", void 0);
+    if (resetSeconds < 0) {
+      this.resetSeconds = 1;
+    } else if (resetSeconds > 60 * 60) {
+      this.resetSeconds = 60 * 60;
+    } else {
+      this.resetSeconds = resetSeconds;
+    }
+  }
+}
+async function parseJsonResponse(response) {
+  const json = await response.json();
+  if (!response.ok) {
+    return Promise.reject(json);
+  }
+  return json;
+}
+function parseResponse(response) {
+  const contentType = response.headers.get('Content-Type');
+  if (contentType && contentType.match(/json/)) {
+    return parseJsonResponse(response);
+  }
+  const textPromise = response.text().then(text => {
+    if (!response.ok) return Promise.reject(text);
+    return text;
+  });
+  return textPromise;
+}
+async function requestWithBackoff(api, req, attempt = 1) {
+  if (api.rateLimiter) {
+    await api.rateLimiter.acquire();
+  }
+  try {
+    const builtRequest = await api.buildRequest(req);
+    const requestFunction = api.requestFunction || _unsentRequest.default.performRequest;
+    const response = await requestFunction(builtRequest);
+    if (response.status === 429) {
+      // GitLab/Bitbucket too many requests
+      const text = await response.text().catch(() => 'Too many requests');
+      throw new Error(text);
+    } else if (response.status === 403) {
+      // GitHub too many requests
+      const json = await response.json().catch(() => ({
+        message: ''
+      }));
+      if (json.message.match('API rate limit exceeded')) {
+        const now = new Date();
+        const nextWindowInSeconds = response.headers.has('X-RateLimit-Reset') ? parseInt(response.headers.get('X-RateLimit-Reset')) : now.getTime() / 1000 + 60;
+        throw new RateLimitError(json.message, nextWindowInSeconds);
+      }
+      response.json = () => Promise.resolve(json);
+    }
+    return response;
+  } catch (err) {
+    if (attempt > 5 || err.message === "Can't refresh access token when using implicit auth") {
+      throw err;
+    } else {
+      if (!api.rateLimiter) {
+        const timeout = err.resetSeconds || attempt * attempt;
+        console.log(`Pausing requests for ${timeout} ${attempt === 1 ? 'second' : 'seconds'} due to fetch failures:`, err.message);
+        api.rateLimiter = (0, _asyncLock.asyncLock)();
+        api.rateLimiter.acquire();
+        setTimeout(() => {
+          var _api$rateLimiter;
+          (_api$rateLimiter = api.rateLimiter) === null || _api$rateLimiter === void 0 ? void 0 : _api$rateLimiter.release();
+          api.rateLimiter = undefined;
+          console.log(`Done pausing requests`);
+        }, 1000 * timeout);
+      }
+      return requestWithBackoff(api, req, attempt + 1);
+    }
+  }
+}
+
+// Options is an object which contains all the standard network request properties
+// for modifying HTTP requests and may contains `params` property
+
+// RequestConfig contains all the standard properties of a Request object and
+// several custom properties:
+// - "headers" property is an object whose properties and values are string types
+// - `token` property to allow passing tokens for users using a private repo.
+// - `params` property for customizing response
+// - `backend`(compulsory) to specify which backend to be used: Github, Gitlab etc.
+
+const apiRoots = exports.apiRoots = {
+  github: 'https://api.github.com',
+  gitlab: 'https://gitlab.com/api/v4',
+  bitbucket: 'https://api.bitbucket.org/2.0'
+};
+const endpointConstants = exports.endpointConstants = {
+  singleRepo: {
+    bitbucket: '/repositories',
+    github: '/repos',
+    gitlab: '/projects'
+  }
+};
+const api = {
+  buildRequest(req) {
+    return req;
+  }
+};
+function constructUrlWithParams(url, params) {
+  if (params) {
+    const paramList = [];
+    for (const key in params) {
+      paramList.push(`${key}=${encodeURIComponent(params[key])}`);
+    }
+    if (paramList.length) {
+      url += `?${paramList.join('&')}`;
+    }
+  }
+  return url;
+}
+async function constructRequestHeaders(headerConfig) {
+  const {
+    token,
+    headers
+  } = headerConfig;
+  const baseHeaders = _objectSpread({
+    'Content-Type': 'application/json; charset=utf-8'
+  }, headers);
+  if (token) {
+    baseHeaders['Authorization'] = `Bearer ${token}`;
+  }
+  return Promise.resolve(baseHeaders);
+}
+function handleRequestError(error, responseStatus, backend) {
+  throw new _APIError.default(error.message, responseStatus, backend);
+}
+async function apiRequest(path, config, parser = response => parseResponse(response)) {
+  var _config$apiRoot;
+  const {
+      token,
+      backend
+    } = config,
+    props = _objectWithoutProperties(config, _excluded);
+  const options = _objectSpread({
+    cache: 'no-cache'
+  }, props);
+  const headers = await constructRequestHeaders({
+    headers: options.headers || {},
+    token
+  });
+  const baseUrl = (_config$apiRoot = config.apiRoot) !== null && _config$apiRoot !== void 0 ? _config$apiRoot : apiRoots[backend];
+  const url = constructUrlWithParams(`${baseUrl}${path}`, options.params);
+  let responseStatus = 500;
+  try {
+    const req = _unsentRequest.default.fromFetchArguments(url, _objectSpread(_objectSpread({}, options), {}, {
+      headers
+    }));
+    const response = await requestWithBackoff(api, req);
+    responseStatus = response.status;
+    const parsedResponse = await parser(response);
+    return parsedResponse;
+  } catch (error) {
+    return handleRequestError(error, responseStatus, backend);
+  }
+}
+async function getDefaultBranchName(configs) {
+  let apiPath;
+  const {
+    token,
+    backend,
+    repo,
+    apiRoot
+  } = configs;
+  switch (backend) {
+    case 'gitlab':
+      {
+        apiPath = `/projects/${encodeURIComponent(repo)}`;
+        break;
+      }
+    case 'bitbucket':
+      {
+        apiPath = `/repositories/${repo}`;
+        break;
+      }
+    default:
+      {
+        apiPath = `/repos/${repo}`;
+      }
+  }
+  const repoInfo = await apiRequest(apiPath, {
+    token,
+    backend,
+    apiRoot
+  });
+  let defaultBranchName;
+  if (backend === 'bitbucket') {
+    const {
+      mainbranch: {
+        name
+      }
+    } = repoInfo;
+    defaultBranchName = name;
+  } else {
+    const {
+      default_branch
+    } = repoInfo;
+    defaultBranchName = default_branch;
+  }
+  return defaultBranchName;
+}
+async function readFile(id, fetchContent, localForage, isText) {
+  const key = id ? isText ? `gh.${id}` : `gh.${id}.blob` : null;
+  const cached = key ? await localForage.getItem(key) : null;
+  if (cached) {
+    return cached;
+  }
+  const content = await fetchContent();
+  if (key) {
+    await localForage.setItem(key, content);
+  }
+  return content;
+}
+function getFileMetadataKey(id) {
+  return `gh.${id}.meta`;
+}
+async function readFileMetadata(id, fetchMetadata, localForage) {
+  const key = id ? getFileMetadataKey(id) : null;
+  const cached = key && (await localForage.getItem(key));
+  if (cached) {
+    return cached;
+  }
+  const metadata = await fetchMetadata();
+  if (key) {
+    await localForage.setItem(key, metadata);
+  }
+  return metadata;
+}
+
+/**
+ * Keywords for inferring a status that will provide a deploy preview URL.
+ */
+const PREVIEW_CONTEXT_KEYWORDS = ['deploy'];
+
+/**
+ * Check a given status context string to determine if it provides a link to a
+ * deploy preview. Checks for an exact match against `previewContext` if given,
+ * otherwise checks for inclusion of a value from `PREVIEW_CONTEXT_KEYWORDS`.
+ */
+function isPreviewContext(context, previewContext) {
+  if (previewContext) {
+    return context === previewContext;
+  }
+  return PREVIEW_CONTEXT_KEYWORDS.some(keyword => context.includes(keyword));
+}
+let PreviewState = exports.PreviewState = /*#__PURE__*/function (PreviewState) {
+  PreviewState["Other"] = "other";
+  PreviewState["Success"] = "success";
+  return PreviewState;
+}({});
+/**
+ * Retrieve a deploy preview URL from an array of statuses. By default, a
+ * matching status is inferred via `isPreviewContext`.
+ */
+function getPreviewStatus(statuses, previewContext) {
+  return statuses.find(({
+    context
+  }) => {
+    return isPreviewContext(context, previewContext);
+  });
+}
+function getConflictingBranches(branchName) {
+  // for cms/posts/post-1, conflicting branches are cms/posts, cms
+  const parts = branchName.split('/');
+  parts.pop();
+  const conflictingBranches = parts.reduce((acc, _, index) => {
+    acc = [...acc, parts.slice(0, index + 1).join('/')];
+    return acc;
+  }, []);
+  return conflictingBranches;
+}
+async function throwOnConflictingBranches(branchName, getBranch, apiName) {
+  const possibleConflictingBranches = getConflictingBranches(branchName);
+  const conflictingBranches = await Promise.all(possibleConflictingBranches.map(b => getBranch(b).then(b => b.name).catch(() => '')));
+  const conflictingBranch = conflictingBranches.filter(Boolean)[0];
+  if (conflictingBranch) {
+    throw new _APIError.default(`Failed creating branch '${branchName}' since there is already a branch named '${conflictingBranch}'. Please delete the '${conflictingBranch}' branch and try again`, 500, apiName);
+  }
+}

node_modules/decap-cms-lib-util/dist/esm/APIError.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.API_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const API_ERROR = exports.API_ERROR = 'API_ERROR';
+class APIError extends _extendableBuiltin(Error) {
+  constructor(message, status, api, meta = {}) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    _defineProperty(this, "status", void 0);
+    _defineProperty(this, "api", void 0);
+    _defineProperty(this, "meta", void 0);
+    this.message = message;
+    this.status = status;
+    this.api = api;
+    this.name = API_ERROR;
+    this.meta = meta;
+  }
+}
+exports.default = APIError;

node_modules/decap-cms-lib-util/dist/esm/APIUtils.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MERGE_COMMIT_MESSAGE = exports.DEFAULT_PR_BODY = exports.CMS_BRANCH_PREFIX = void 0;
+exports.branchFromContentKey = branchFromContentKey;
+exports.contentKeyFromBranch = contentKeyFromBranch;
+exports.generateContentKey = generateContentKey;
+exports.isCMSLabel = isCMSLabel;
+exports.labelToStatus = labelToStatus;
+exports.parseContentKey = parseContentKey;
+exports.statusToLabel = statusToLabel;
+const CMS_BRANCH_PREFIX = exports.CMS_BRANCH_PREFIX = 'cms';
+const DEFAULT_PR_BODY = exports.DEFAULT_PR_BODY = 'Automatically generated by Decap CMS';
+const MERGE_COMMIT_MESSAGE = exports.MERGE_COMMIT_MESSAGE = 'Automatically generated. Merged on Decap CMS.';
+const DEFAULT_DECAP_CMS_LABEL_PREFIX = 'decap-cms/';
+function getLabelPrefix(labelPrefix) {
+  return labelPrefix || DEFAULT_DECAP_CMS_LABEL_PREFIX;
+}
+function isCMSLabel(label, labelPrefix) {
+  return label.startsWith(getLabelPrefix(labelPrefix));
+}
+function labelToStatus(label, labelPrefix) {
+  return label.slice(getLabelPrefix(labelPrefix).length);
+}
+function statusToLabel(status, labelPrefix) {
+  return `${getLabelPrefix(labelPrefix)}${status}`;
+}
+function generateContentKey(collectionName, slug) {
+  return `${collectionName}/${slug}`;
+}
+function parseContentKey(contentKey) {
+  const index = contentKey.indexOf('/');
+  return {
+    collection: contentKey.slice(0, index),
+    slug: contentKey.slice(index + 1)
+  };
+}
+function contentKeyFromBranch(branch) {
+  return branch.slice(`${CMS_BRANCH_PREFIX}/`.length);
+}
+function branchFromContentKey(contentKey) {
+  return `${CMS_BRANCH_PREFIX}/${contentKey}`;
+}

node_modules/decap-cms-lib-util/dist/esm/AccessTokenError.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ACCESS_TOKEN_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const ACCESS_TOKEN_ERROR = exports.ACCESS_TOKEN_ERROR = 'ACCESS_TOKEN_ERROR';
+class AccessTokenError extends _extendableBuiltin(Error) {
+  constructor(message) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    this.message = message;
+    this.name = ACCESS_TOKEN_ERROR;
+  }
+}
+exports.default = AccessTokenError;

node_modules/decap-cms-lib-util/dist/esm/Cursor.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CURSOR_COMPATIBILITY_SYMBOL = void 0;
+var _immutable = require("immutable");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function jsToMap(obj) {
+  if (obj === undefined) {
+    return (0, _immutable.Map)();
+  }
+  const immutableObj = (0, _immutable.fromJS)(obj);
+  if (!_immutable.Map.isMap(immutableObj)) {
+    throw new Error('Object must be equivalent to a Map.');
+  }
+  return immutableObj;
+}
+const knownMetaKeys = (0, _immutable.Set)(['index', 'page', 'count', 'pageSize', 'pageCount', 'usingOldPaginationAPI', 'extension', 'folder', 'depth']);
+function filterUnknownMetaKeys(meta) {
+  return meta.filter((_v, k) => knownMetaKeys.has(k));
+}
+
+/*
+  createCursorMap takes one of three signatures:
+  - () -> cursor with empty actions, data, and meta
+  - (cursorMap: <object/Map with optional actions, data, and meta keys>) -> cursor
+  - (actions: <array/List>, data: <object/Map>, meta: <optional object/Map>) -> cursor
+*/
+function createCursorStore(...args) {
+  const {
+    actions,
+    data,
+    meta
+  } = args.length === 1 ? jsToMap(args[0]).toObject() : {
+    actions: args[0],
+    data: args[1],
+    meta: args[2]
+  };
+  return (0, _immutable.Map)({
+    // actions are a Set, rather than a List, to ensure an efficient .has
+    actions: (0, _immutable.Set)(actions),
+    // data and meta are Maps
+    data: jsToMap(data),
+    meta: jsToMap(meta).update(filterUnknownMetaKeys)
+  });
+}
+function hasAction(store, action) {
+  return store.hasIn(['actions', action]);
+}
+function getActionHandlers(store, handler) {
+  return store.get('actions', (0, _immutable.Set)()).toMap().map(action => handler(action));
+}
+
+// The cursor logic is entirely functional, so this class simply
+// provides a chainable interface
+class Cursor {
+  static create(...args) {
+    return new Cursor(...args);
+  }
+  constructor(...args) {
+    _defineProperty(this, "store", void 0);
+    _defineProperty(this, "actions", void 0);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _defineProperty(this, "data", void 0);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _defineProperty(this, "meta", void 0);
+    if (args[0] instanceof Cursor) {
+      return args[0];
+    }
+    this.store = createCursorStore(...args);
+    this.actions = this.store.get('actions');
+    this.data = this.store.get('data');
+    this.meta = this.store.get('meta');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateStore(...args) {
+    return new Cursor(this.store.update(...args));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateInStore(...args) {
+    return new Cursor(this.store.updateIn(...args));
+  }
+  hasAction(action) {
+    return hasAction(this.store, action);
+  }
+  addAction(action) {
+    return this.updateStore('actions', actions => actions.add(action));
+  }
+  removeAction(action) {
+    return this.updateStore('actions', actions => actions.delete(action));
+  }
+  setActions(actions) {
+    return this.updateStore(store => store.set('actions', (0, _immutable.Set)(actions)));
+  }
+  mergeActions(actions) {
+    return this.updateStore('actions', oldActions => oldActions.union(actions));
+  }
+  getActionHandlers(handler) {
+    return getActionHandlers(this.store, handler);
+  }
+  setData(data) {
+    return new Cursor(this.store.set('data', jsToMap(data)));
+  }
+  mergeData(data) {
+    return new Cursor(this.store.mergeIn(['data'], jsToMap(data)));
+  }
+  wrapData(data) {
+    return this.updateStore('data', oldData => jsToMap(data).set('wrapped_cursor_data', oldData));
+  }
+  unwrapData() {
+    return [this.store.get('data').delete('wrapped_cursor_data'), this.updateStore('data', data => data.get('wrapped_cursor_data'))];
+  }
+  clearData() {
+    return this.updateStore('data', () => (0, _immutable.Map)());
+  }
+  setMeta(meta) {
+    return this.updateStore(store => store.set('meta', jsToMap(meta)));
+  }
+  mergeMeta(meta) {
+    return this.updateStore(store => store.update('meta', oldMeta => oldMeta.merge(jsToMap(meta))));
+  }
+}
+
+// This is a temporary hack to allow cursors to be added to the
+// interface between backend.js and backends without modifying old
+// backends at all. This should be removed in favor of wrapping old
+// backends with a compatibility layer, as part of the backend API
+// refactor.
+exports.default = Cursor;
+const CURSOR_COMPATIBILITY_SYMBOL = exports.CURSOR_COMPATIBILITY_SYMBOL = Symbol('cursor key for compatibility with old backends');

node_modules/decap-cms-lib-util/dist/esm/EditorialWorkflowError.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.EDITORIAL_WORKFLOW_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const EDITORIAL_WORKFLOW_ERROR = exports.EDITORIAL_WORKFLOW_ERROR = 'EDITORIAL_WORKFLOW_ERROR';
+class EditorialWorkflowError extends _extendableBuiltin(Error) {
+  constructor(message, notUnderEditorialWorkflow) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    _defineProperty(this, "notUnderEditorialWorkflow", void 0);
+    this.message = message;
+    this.notUnderEditorialWorkflow = notUnderEditorialWorkflow;
+    this.name = EDITORIAL_WORKFLOW_ERROR;
+  }
+}
+exports.default = EditorialWorkflowError;

node_modules/decap-cms-lib-util/dist/esm/asyncLock.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncLock = asyncLock;
+var _semaphore = _interopRequireDefault(require("semaphore"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncLock() {
+  let lock = (0, _semaphore.default)(1);
+  function acquire(timeout = 15000) {
+    const promise = new Promise(resolve => {
+      // this makes sure a caller doesn't gets stuck forever awaiting on the lock
+      const timeoutId = setTimeout(() => {
+        // we reset the lock in that case to allow future consumers to use it without being blocked
+        lock = (0, _semaphore.default)(1);
+        resolve(false);
+      }, timeout);
+      lock.take(() => {
+        clearTimeout(timeoutId);
+        resolve(true);
+      });
+    });
+    return promise;
+  }
+  function release() {
+    try {
+      // suppress too many calls to leave error
+      lock.leave();
+    } catch (e) {
+      // calling 'leave' too many times might not be good behavior
+      // but there is no reason to completely fail on it
+      if (e.message !== 'leave called too many times.') {
+        throw e;
+      } else {
+        console.warn('leave called too many times.');
+        lock = (0, _semaphore.default)(1);
+      }
+    }
+  }
+  return {
+    acquire,
+    release
+  };
+}

node_modules/decap-cms-lib-util/dist/esm/backendUtil.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterByExtension = filterByExtension;
+exports.getAllResponses = getAllResponses;
+exports.getPathDepth = getPathDepth;
+exports.parseLinkHeader = parseLinkHeader;
+exports.parseResponse = parseResponse;
+exports.responseParser = responseParser;
+var _map2 = _interopRequireDefault(require("lodash/fp/map"));
+var _fromPairs2 = _interopRequireDefault(require("lodash/fromPairs"));
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
+var _immutable = require("immutable");
+var _unsentRequest = _interopRequireDefault(require("./unsentRequest"));
+var _APIError = _interopRequireDefault(require("./APIError"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function filterByExtension(file, extension) {
+  const path = (file === null || file === void 0 ? void 0 : file.path) || '';
+  return path.endsWith(extension.startsWith('.') ? extension : `.${extension}`);
+}
+function catchFormatErrors(format, formatter) {
+  return res => {
+    try {
+      return formatter(res);
+    } catch (err) {
+      throw new Error(`Response cannot be parsed into the expected format (${format}): ${err.message}`);
+    }
+  };
+}
+const responseFormatters = (0, _immutable.fromJS)({
+  json: async res => {
+    const contentType = res.headers.get('Content-Type') || '';
+    if (!contentType.startsWith('application/json') && !contentType.startsWith('text/json')) {
+      throw new Error(`${contentType} is not a valid JSON Content-Type`);
+    }
+    return res.json();
+  },
+  text: async res => res.text(),
+  blob: async res => res.blob()
+}).mapEntries(([format, formatter]) => [format, catchFormatErrors(format, formatter)]);
+async function parseResponse(res, {
+  expectingOk = true,
+  format = 'text',
+  apiName = ''
+}) {
+  let body;
+  try {
+    const formatter = responseFormatters.get(format, false);
+    if (!formatter) {
+      throw new Error(`${format} is not a supported response format.`);
+    }
+    body = await formatter(res);
+  } catch (err) {
+    throw new _APIError.default(err.message, res.status, apiName);
+  }
+  if (expectingOk && !res.ok) {
+    var _body$error;
+    const isJSON = format === 'json';
+    const message = isJSON ? body.message || body.msg || ((_body$error = body.error) === null || _body$error === void 0 ? void 0 : _body$error.message) : body;
+    throw new _APIError.default(isJSON && message ? message : body, res.status, apiName);
+  }
+  return body;
+}
+function responseParser(options) {
+  return res => parseResponse(res, options);
+}
+function parseLinkHeader(header) {
+  if (!header) {
+    return {};
+  }
+  return (0, _flow2.default)([linksString => linksString.split(','), (0, _map2.default)(str => str.trim().split(';')), (0, _map2.default)(([linkStr, keyStr]) => [keyStr.match(/rel="(.*?)"/)[1], linkStr.trim().match(/<(.*?)>/)[1].replace(/\+/g, '%20')]), _fromPairs2.default])(header);
+}
+async function getAllResponses(url, options = {}, linkHeaderRelName, nextUrlProcessor) {
+  const maxResponses = 30;
+  let responseCount = 1;
+  let req = _unsentRequest.default.fromFetchArguments(url, options);
+  const pageResponses = [];
+  while (req && responseCount < maxResponses) {
+    const pageResponse = await _unsentRequest.default.performRequest(req);
+    const linkHeader = pageResponse.headers.get('Link');
+    const nextURL = linkHeader && parseLinkHeader(linkHeader)[linkHeaderRelName];
+    const {
+      headers = {}
+    } = options;
+    req = nextURL && _unsentRequest.default.fromFetchArguments(nextUrlProcessor(nextURL), {
+      headers
+    });
+    pageResponses.push(pageResponse);
+    responseCount++;
+  }
+  return pageResponses;
+}
+function getPathDepth(path) {
+  const depth = path.split('/').length;
+  return depth;
+}

node_modules/decap-cms-lib-util/dist/esm/getBlobSHA.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jsSha = require("js-sha256");
+var _default = blob => new Promise((resolve, reject) => {
+  const fr = new FileReader();
+  fr.onload = ({
+    target
+  }) => resolve((0, _jsSha.sha256)((target === null || target === void 0 ? void 0 : target.result) || ''));
+  fr.onerror = err => {
+    fr.abort();
+    reject(err);
+  };
+  fr.readAsArrayBuffer(blob);
+});
+exports.default = _default;

node_modules/decap-cms-lib-util/dist/esm/git-lfs.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPointerFile = createPointerFile;
+exports.getLargeMediaFilteredMediaFiles = getLargeMediaFilteredMediaFiles;
+exports.getLargeMediaPatternsFromGitAttributesFile = void 0;
+exports.getPointerFileForMediaFileObj = getPointerFileForMediaFileObj;
+exports.parsePointerFile = void 0;
+var _map2 = _interopRequireDefault(require("lodash/fp/map"));
+var _fromPairs2 = _interopRequireDefault(require("lodash/fp/fromPairs"));
+var _flow2 = _interopRequireDefault(require("lodash/fp/flow"));
+var _filter2 = _interopRequireDefault(require("lodash/fp/filter"));
+var _getBlobSHA = _interopRequireDefault(require("./getBlobSHA"));
+const _excluded = ["size", "oid"]; //
+// Pointer file parsing
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function splitIntoLines(str) {
+  return str.split('\n');
+}
+function splitIntoWords(str) {
+  return str.split(/\s+/g);
+}
+function isNonEmptyString(str) {
+  return str !== '';
+}
+const withoutEmptyLines = (0, _flow2.default)([(0, _map2.default)(str => str.trim()), (0, _filter2.default)(isNonEmptyString)]);
+const parsePointerFile = exports.parsePointerFile = (0, _flow2.default)([splitIntoLines, withoutEmptyLines, (0, _map2.default)(splitIntoWords), _fromPairs2.default, _ref => {
+  let {
+      size,
+      oid
+    } = _ref,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return _objectSpread({
+    size: parseInt(size),
+    sha: oid === null || oid === void 0 ? void 0 : oid.split(':')[1]
+  }, rest);
+}]);
+
+//
+// .gitattributes file parsing
+
+function removeGitAttributesCommentsFromLine(line) {
+  return line.split('#')[0];
+}
+function parseGitPatternAttribute(attributeString) {
+  // There are three kinds of attribute settings:
+  // - a key=val pair sets an attribute to a specific value
+  // - a key without a value and a leading hyphen sets an attribute to false
+  // - a key without a value and no leading hyphen sets an attribute
+  //   to true
+  if (attributeString.includes('=')) {
+    return attributeString.split('=');
+  }
+  if (attributeString.startsWith('-')) {
+    return [attributeString.slice(1), false];
+  }
+  return [attributeString, true];
+}
+const parseGitPatternAttributes = (0, _flow2.default)([(0, _map2.default)(parseGitPatternAttribute), _fromPairs2.default]);
+const parseGitAttributesPatternLine = (0, _flow2.default)([splitIntoWords, ([pattern, ...attributes]) => [pattern, parseGitPatternAttributes(attributes)]]);
+const parseGitAttributesFileToPatternAttributePairs = (0, _flow2.default)([splitIntoLines, (0, _map2.default)(removeGitAttributesCommentsFromLine), withoutEmptyLines, (0, _map2.default)(parseGitAttributesPatternLine)]);
+const getLargeMediaPatternsFromGitAttributesFile = exports.getLargeMediaPatternsFromGitAttributesFile = (0, _flow2.default)([parseGitAttributesFileToPatternAttributePairs, (0, _filter2.default)(([, attributes]) => attributes.filter === 'lfs' && attributes.diff === 'lfs' && attributes.merge === 'lfs'), (0, _map2.default)(([pattern]) => pattern)]);
+function createPointerFile({
+  size,
+  sha
+}) {
+  return `\
+version https://git-lfs.github.com/spec/v1
+oid sha256:${sha}
+size ${size}
+`;
+}
+async function getPointerFileForMediaFileObj(client, fileObj, path) {
+  const {
+    name,
+    size
+  } = fileObj;
+  const sha = await (0, _getBlobSHA.default)(fileObj);
+  await client.uploadResource({
+    sha,
+    size
+  }, fileObj);
+  const pointerFileString = createPointerFile({
+    sha,
+    size
+  });
+  const pointerFileBlob = new Blob([pointerFileString]);
+  const pointerFile = new File([pointerFileBlob], name, {
+    type: 'text/plain'
+  });
+  const pointerFileSHA = await (0, _getBlobSHA.default)(pointerFile);
+  return {
+    fileObj: pointerFile,
+    size: pointerFileBlob.size,
+    sha: pointerFileSHA,
+    raw: pointerFileString,
+    path
+  };
+}
+async function getLargeMediaFilteredMediaFiles(client, mediaFiles) {
+  return await Promise.all(mediaFiles.map(async mediaFile => {
+    const {
+      fileObj,
+      path
+    } = mediaFile;
+    const fixedPath = path.startsWith('/') ? path.slice(1) : path;
+    if (!client.matchPath(fixedPath)) {
+      return mediaFile;
+    }
+    const pointerFileDetails = await getPointerFileForMediaFileObj(client, fileObj, path);
+    return _objectSpread(_objectSpread({}, mediaFile), pointerFileDetails);
+  }));
+}

node_modules/decap-cms-lib-util/dist/esm/implementation.js

@@ -0,0 +1,304 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.allEntriesByFolder = allEntriesByFolder;
+exports.blobToFileObj = blobToFileObj;
+exports.entriesByFiles = entriesByFiles;
+exports.entriesByFolder = entriesByFolder;
+exports.getLocalTree = getLocalTree;
+exports.getMediaAsBlob = getMediaAsBlob;
+exports.getMediaDisplayURL = getMediaDisplayURL;
+exports.persistLocalTree = persistLocalTree;
+exports.runWithLock = runWithLock;
+exports.unpublishedEntries = unpublishedEntries;
+var _sortBy2 = _interopRequireDefault(require("lodash/sortBy"));
+var _unionBy2 = _interopRequireDefault(require("lodash/unionBy"));
+var _semaphore = _interopRequireDefault(require("semaphore"));
+var _path = require("./path");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const MAX_CONCURRENT_DOWNLOADS = 10;
+async function fetchFiles(files, readFile, readFileMetadata, apiName) {
+  const sem = (0, _semaphore.default)(MAX_CONCURRENT_DOWNLOADS);
+  const promises = [];
+  files.forEach(file => {
+    promises.push(new Promise(resolve => sem.take(async () => {
+      try {
+        const [data, fileMetadata] = await Promise.all([readFile(file.path, file.id, {
+          parseText: true
+        }), readFileMetadata(file.path, file.id)]);
+        resolve({
+          file: _objectSpread(_objectSpread({}, file), fileMetadata),
+          data: data
+        });
+        sem.leave();
+      } catch (error) {
+        sem.leave();
+        console.error(`failed to load file from ${apiName}: ${file.path}`);
+        resolve({
+          error: true
+        });
+      }
+    })));
+  });
+  return Promise.all(promises).then(loadedEntries => loadedEntries.filter(loadedEntry => !loadedEntry.error));
+}
+async function entriesByFolder(listFiles, readFile, readFileMetadata, apiName) {
+  const files = await listFiles();
+  return fetchFiles(files, readFile, readFileMetadata, apiName);
+}
+async function entriesByFiles(files, readFile, readFileMetadata, apiName) {
+  return fetchFiles(files, readFile, readFileMetadata, apiName);
+}
+async function unpublishedEntries(listEntriesKeys) {
+  try {
+    const keys = await listEntriesKeys();
+    return keys;
+  } catch (error) {
+    if (error.message === 'Not Found') {
+      return Promise.resolve([]);
+    }
+    throw error;
+  }
+}
+function blobToFileObj(name, blob) {
+  const options = name.match(/.svg$/) ? {
+    type: 'image/svg+xml'
+  } : {};
+  return new File([blob], name, options);
+}
+async function getMediaAsBlob(path, id, readFile) {
+  let blob;
+  if (path.match(/.svg$/)) {
+    const text = await readFile(path, id, {
+      parseText: true
+    });
+    blob = new Blob([text], {
+      type: 'image/svg+xml'
+    });
+  } else {
+    blob = await readFile(path, id, {
+      parseText: false
+    });
+  }
+  return blob;
+}
+async function getMediaDisplayURL(displayURL, readFile, semaphore) {
+  const {
+    path,
+    id
+  } = displayURL;
+  return new Promise((resolve, reject) => semaphore.take(() => getMediaAsBlob(path, id, readFile).then(blob => URL.createObjectURL(blob)).then(resolve, reject).finally(() => semaphore.leave())));
+}
+async function runWithLock(lock, func, message) {
+  try {
+    const acquired = await lock.acquire();
+    if (!acquired) {
+      console.warn(message);
+    }
+    const result = await func();
+    return result;
+  } finally {
+    lock.release();
+  }
+}
+const LOCAL_KEY = 'git.local';
+function getLocalKey({
+  branch,
+  folder,
+  extension,
+  depth
+}) {
+  return `${LOCAL_KEY}.${branch}.${folder}.${extension}.${depth}`;
+}
+async function persistLocalTree({
+  localForage,
+  localTree,
+  branch,
+  folder,
+  extension,
+  depth
+}) {
+  await localForage.setItem(getLocalKey({
+    branch,
+    folder,
+    extension,
+    depth
+  }), localTree);
+}
+async function getLocalTree({
+  localForage,
+  branch,
+  folder,
+  extension,
+  depth
+}) {
+  const localTree = await localForage.getItem(getLocalKey({
+    branch,
+    folder,
+    extension,
+    depth
+  }));
+  return localTree;
+}
+async function getDiffFromLocalTree({
+  branch,
+  localTree,
+  folder,
+  getDifferences,
+  filterFile,
+  getFileId
+}) {
+  const diff = await getDifferences(branch.sha, localTree.head);
+  const diffFiles = diff.filter(d => {
+    var _d$oldPath, _d$newPath;
+    return ((_d$oldPath = d.oldPath) === null || _d$oldPath === void 0 ? void 0 : _d$oldPath.startsWith(folder)) || ((_d$newPath = d.newPath) === null || _d$newPath === void 0 ? void 0 : _d$newPath.startsWith(folder));
+  }).reduce((acc, d) => {
+    if (d.status === 'renamed') {
+      acc.push({
+        path: d.oldPath,
+        name: (0, _path.basename)(d.oldPath),
+        deleted: true
+      });
+      acc.push({
+        path: d.newPath,
+        name: (0, _path.basename)(d.newPath),
+        deleted: false
+      });
+    } else if (d.status === 'deleted') {
+      acc.push({
+        path: d.oldPath,
+        name: (0, _path.basename)(d.oldPath),
+        deleted: true
+      });
+    } else {
+      acc.push({
+        path: d.newPath || d.oldPath,
+        name: (0, _path.basename)(d.newPath || d.oldPath),
+        deleted: false
+      });
+    }
+    return acc;
+  }, []).filter(filterFile);
+  const diffFilesWithIds = await Promise.all(diffFiles.map(async file => {
+    if (!file.deleted) {
+      const id = await getFileId(file.path);
+      return _objectSpread(_objectSpread({}, file), {}, {
+        id
+      });
+    } else {
+      return _objectSpread(_objectSpread({}, file), {}, {
+        id: ''
+      });
+    }
+  }));
+  return diffFilesWithIds;
+}
+async function allEntriesByFolder({
+  listAllFiles,
+  readFile,
+  readFileMetadata,
+  apiName,
+  branch,
+  localForage,
+  folder,
+  extension,
+  depth,
+  getDefaultBranch,
+  isShaExistsInBranch,
+  getDifferences,
+  getFileId,
+  filterFile,
+  customFetch
+}) {
+  async function listAllFilesAndPersist() {
+    const files = await listAllFiles(folder, extension, depth);
+    const branch = await getDefaultBranch();
+    await persistLocalTree({
+      localForage,
+      localTree: {
+        head: branch.sha,
+        files: files.map(f => ({
+          id: f.id,
+          path: f.path,
+          name: (0, _path.basename)(f.path)
+        }))
+      },
+      branch: branch.name,
+      depth,
+      extension,
+      folder
+    });
+    return files;
+  }
+  async function listFiles() {
+    const localTree = await getLocalTree({
+      localForage,
+      branch,
+      folder,
+      extension,
+      depth
+    });
+    if (localTree) {
+      const branch = await getDefaultBranch();
+      // if the branch was forced pushed the local tree sha can be removed from the remote tree
+      const localTreeInBranch = await isShaExistsInBranch(branch.name, localTree.head);
+      if (!localTreeInBranch) {
+        console.log(`Can't find local tree head '${localTree.head}' in branch '${branch.name}', rebuilding local tree`);
+        return listAllFilesAndPersist();
+      }
+      const diff = await getDiffFromLocalTree({
+        branch,
+        localTree,
+        folder,
+        extension,
+        depth,
+        getDifferences,
+        getFileId,
+        filterFile
+      }).catch(e => {
+        console.log('Failed getting diff from local tree:', e);
+        return null;
+      });
+      if (!diff) {
+        console.log(`Diff is null, rebuilding local tree`);
+        return listAllFilesAndPersist();
+      }
+      if (diff.length === 0) {
+        // return local copy
+        return localTree.files;
+      } else {
+        const deleted = diff.reduce((acc, d) => {
+          acc[d.path] = d.deleted;
+          return acc;
+        }, {});
+        const newCopy = (0, _sortBy2.default)((0, _unionBy2.default)(diff.filter(d => !deleted[d.path]), localTree.files.filter(f => !deleted[f.path]), file => file.path), file => file.path);
+        await persistLocalTree({
+          localForage,
+          localTree: {
+            head: branch.sha,
+            files: newCopy
+          },
+          branch: branch.name,
+          depth,
+          extension,
+          folder
+        });
+        return newCopy;
+      }
+    } else {
+      return listAllFilesAndPersist();
+    }
+  }
+  const files = await listFiles();
+  if (customFetch) {
+    return await customFetch(files);
+  }
+  return await fetchFiles(files, readFile, readFileMetadata, apiName);
+}

node_modules/decap-cms-lib-util/dist/esm/index.js

@@ -0,0 +1,409 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "APIError", {
+  enumerable: true,
+  get: function () {
+    return _APIError.default;
+  }
+});
+Object.defineProperty(exports, "AccessTokenError", {
+  enumerable: true,
+  get: function () {
+    return _AccessTokenError.default;
+  }
+});
+Object.defineProperty(exports, "CMS_BRANCH_PREFIX", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.CMS_BRANCH_PREFIX;
+  }
+});
+Object.defineProperty(exports, "CURSOR_COMPATIBILITY_SYMBOL", {
+  enumerable: true,
+  get: function () {
+    return _Cursor.CURSOR_COMPATIBILITY_SYMBOL;
+  }
+});
+Object.defineProperty(exports, "Cursor", {
+  enumerable: true,
+  get: function () {
+    return _Cursor.default;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_PR_BODY", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.DEFAULT_PR_BODY;
+  }
+});
+exports.DecapCmsLibUtil = void 0;
+Object.defineProperty(exports, "EDITORIAL_WORKFLOW_ERROR", {
+  enumerable: true,
+  get: function () {
+    return _EditorialWorkflowError.EDITORIAL_WORKFLOW_ERROR;
+  }
+});
+Object.defineProperty(exports, "EditorialWorkflowError", {
+  enumerable: true,
+  get: function () {
+    return _EditorialWorkflowError.default;
+  }
+});
+Object.defineProperty(exports, "MERGE_COMMIT_MESSAGE", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.MERGE_COMMIT_MESSAGE;
+  }
+});
+Object.defineProperty(exports, "PreviewState", {
+  enumerable: true,
+  get: function () {
+    return _API.PreviewState;
+  }
+});
+Object.defineProperty(exports, "allEntriesByFolder", {
+  enumerable: true,
+  get: function () {
+    return _implementation.allEntriesByFolder;
+  }
+});
+Object.defineProperty(exports, "asyncLock", {
+  enumerable: true,
+  get: function () {
+    return _asyncLock.asyncLock;
+  }
+});
+Object.defineProperty(exports, "basename", {
+  enumerable: true,
+  get: function () {
+    return _path.basename;
+  }
+});
+Object.defineProperty(exports, "blobToFileObj", {
+  enumerable: true,
+  get: function () {
+    return _implementation.blobToFileObj;
+  }
+});
+Object.defineProperty(exports, "branchFromContentKey", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.branchFromContentKey;
+  }
+});
+Object.defineProperty(exports, "contentKeyFromBranch", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.contentKeyFromBranch;
+  }
+});
+Object.defineProperty(exports, "createPointerFile", {
+  enumerable: true,
+  get: function () {
+    return _gitLfs.createPointerFile;
+  }
+});
+Object.defineProperty(exports, "entriesByFiles", {
+  enumerable: true,
+  get: function () {
+    return _implementation.entriesByFiles;
+  }
+});
+Object.defineProperty(exports, "entriesByFolder", {
+  enumerable: true,
+  get: function () {
+    return _implementation.entriesByFolder;
+  }
+});
+Object.defineProperty(exports, "fileExtension", {
+  enumerable: true,
+  get: function () {
+    return _path.fileExtension;
+  }
+});
+Object.defineProperty(exports, "fileExtensionWithSeparator", {
+  enumerable: true,
+  get: function () {
+    return _path.fileExtensionWithSeparator;
+  }
+});
+Object.defineProperty(exports, "filterByExtension", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.filterByExtension;
+  }
+});
+Object.defineProperty(exports, "flowAsync", {
+  enumerable: true,
+  get: function () {
+    return _promise.flowAsync;
+  }
+});
+Object.defineProperty(exports, "generateContentKey", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.generateContentKey;
+  }
+});
+Object.defineProperty(exports, "getAllResponses", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.getAllResponses;
+  }
+});
+Object.defineProperty(exports, "getBlobSHA", {
+  enumerable: true,
+  get: function () {
+    return _getBlobSHA.default;
+  }
+});
+Object.defineProperty(exports, "getDefaultBranchName", {
+  enumerable: true,
+  get: function () {
+    return _API.getDefaultBranchName;
+  }
+});
+Object.defineProperty(exports, "getLargeMediaFilteredMediaFiles", {
+  enumerable: true,
+  get: function () {
+    return _gitLfs.getLargeMediaFilteredMediaFiles;
+  }
+});
+Object.defineProperty(exports, "getLargeMediaPatternsFromGitAttributesFile", {
+  enumerable: true,
+  get: function () {
+    return _gitLfs.getLargeMediaPatternsFromGitAttributesFile;
+  }
+});
+Object.defineProperty(exports, "getMediaAsBlob", {
+  enumerable: true,
+  get: function () {
+    return _implementation.getMediaAsBlob;
+  }
+});
+Object.defineProperty(exports, "getMediaDisplayURL", {
+  enumerable: true,
+  get: function () {
+    return _implementation.getMediaDisplayURL;
+  }
+});
+Object.defineProperty(exports, "getPathDepth", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.getPathDepth;
+  }
+});
+Object.defineProperty(exports, "getPointerFileForMediaFileObj", {
+  enumerable: true,
+  get: function () {
+    return _gitLfs.getPointerFileForMediaFileObj;
+  }
+});
+Object.defineProperty(exports, "getPreviewStatus", {
+  enumerable: true,
+  get: function () {
+    return _API.getPreviewStatus;
+  }
+});
+Object.defineProperty(exports, "isAbsolutePath", {
+  enumerable: true,
+  get: function () {
+    return _path.isAbsolutePath;
+  }
+});
+Object.defineProperty(exports, "isCMSLabel", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.isCMSLabel;
+  }
+});
+Object.defineProperty(exports, "isPreviewContext", {
+  enumerable: true,
+  get: function () {
+    return _API.isPreviewContext;
+  }
+});
+Object.defineProperty(exports, "labelToStatus", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.labelToStatus;
+  }
+});
+Object.defineProperty(exports, "loadScript", {
+  enumerable: true,
+  get: function () {
+    return _loadScript.default;
+  }
+});
+Object.defineProperty(exports, "localForage", {
+  enumerable: true,
+  get: function () {
+    return _localForage.default;
+  }
+});
+Object.defineProperty(exports, "onlySuccessfulPromises", {
+  enumerable: true,
+  get: function () {
+    return _promise.onlySuccessfulPromises;
+  }
+});
+Object.defineProperty(exports, "parseContentKey", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.parseContentKey;
+  }
+});
+Object.defineProperty(exports, "parseLinkHeader", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.parseLinkHeader;
+  }
+});
+Object.defineProperty(exports, "parsePointerFile", {
+  enumerable: true,
+  get: function () {
+    return _gitLfs.parsePointerFile;
+  }
+});
+Object.defineProperty(exports, "parseResponse", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.parseResponse;
+  }
+});
+Object.defineProperty(exports, "readFile", {
+  enumerable: true,
+  get: function () {
+    return _API.readFile;
+  }
+});
+Object.defineProperty(exports, "readFileMetadata", {
+  enumerable: true,
+  get: function () {
+    return _API.readFileMetadata;
+  }
+});
+Object.defineProperty(exports, "requestWithBackoff", {
+  enumerable: true,
+  get: function () {
+    return _API.requestWithBackoff;
+  }
+});
+Object.defineProperty(exports, "responseParser", {
+  enumerable: true,
+  get: function () {
+    return _backendUtil.responseParser;
+  }
+});
+Object.defineProperty(exports, "runWithLock", {
+  enumerable: true,
+  get: function () {
+    return _implementation.runWithLock;
+  }
+});
+Object.defineProperty(exports, "statusToLabel", {
+  enumerable: true,
+  get: function () {
+    return _APIUtils.statusToLabel;
+  }
+});
+Object.defineProperty(exports, "then", {
+  enumerable: true,
+  get: function () {
+    return _promise.then;
+  }
+});
+Object.defineProperty(exports, "throwOnConflictingBranches", {
+  enumerable: true,
+  get: function () {
+    return _API.throwOnConflictingBranches;
+  }
+});
+Object.defineProperty(exports, "unpublishedEntries", {
+  enumerable: true,
+  get: function () {
+    return _implementation.unpublishedEntries;
+  }
+});
+Object.defineProperty(exports, "unsentRequest", {
+  enumerable: true,
+  get: function () {
+    return _unsentRequest.default;
+  }
+});
+var _APIError = _interopRequireDefault(require("./APIError"));
+var _Cursor = _interopRequireWildcard(require("./Cursor"));
+var _EditorialWorkflowError = _interopRequireWildcard(require("./EditorialWorkflowError"));
+var _AccessTokenError = _interopRequireDefault(require("./AccessTokenError"));
+var _localForage = _interopRequireDefault(require("./localForage"));
+var _path = require("./path");
+var _promise = require("./promise");
+var _unsentRequest = _interopRequireDefault(require("./unsentRequest"));
+var _backendUtil = require("./backendUtil");
+var _loadScript = _interopRequireDefault(require("./loadScript"));
+var _getBlobSHA = _interopRequireDefault(require("./getBlobSHA"));
+var _asyncLock = require("./asyncLock");
+var _implementation = require("./implementation");
+var _API = require("./API");
+var _APIUtils = require("./APIUtils");
+var _gitLfs = require("./git-lfs");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DecapCmsLibUtil = exports.DecapCmsLibUtil = {
+  APIError: _APIError.default,
+  Cursor: _Cursor.default,
+  CURSOR_COMPATIBILITY_SYMBOL: _Cursor.CURSOR_COMPATIBILITY_SYMBOL,
+  EditorialWorkflowError: _EditorialWorkflowError.default,
+  EDITORIAL_WORKFLOW_ERROR: _EditorialWorkflowError.EDITORIAL_WORKFLOW_ERROR,
+  localForage: _localForage.default,
+  basename: _path.basename,
+  fileExtensionWithSeparator: _path.fileExtensionWithSeparator,
+  fileExtension: _path.fileExtension,
+  onlySuccessfulPromises: _promise.onlySuccessfulPromises,
+  flowAsync: _promise.flowAsync,
+  then: _promise.then,
+  unsentRequest: _unsentRequest.default,
+  filterByExtension: _backendUtil.filterByExtension,
+  parseLinkHeader: _backendUtil.parseLinkHeader,
+  parseResponse: _backendUtil.parseResponse,
+  responseParser: _backendUtil.responseParser,
+  loadScript: _loadScript.default,
+  getBlobSHA: _getBlobSHA.default,
+  getPathDepth: _backendUtil.getPathDepth,
+  entriesByFiles: _implementation.entriesByFiles,
+  entriesByFolder: _implementation.entriesByFolder,
+  unpublishedEntries: _implementation.unpublishedEntries,
+  getMediaDisplayURL: _implementation.getMediaDisplayURL,
+  getMediaAsBlob: _implementation.getMediaAsBlob,
+  readFile: _API.readFile,
+  readFileMetadata: _API.readFileMetadata,
+  CMS_BRANCH_PREFIX: _APIUtils.CMS_BRANCH_PREFIX,
+  generateContentKey: _APIUtils.generateContentKey,
+  isCMSLabel: _APIUtils.isCMSLabel,
+  labelToStatus: _APIUtils.labelToStatus,
+  statusToLabel: _APIUtils.statusToLabel,
+  DEFAULT_PR_BODY: _APIUtils.DEFAULT_PR_BODY,
+  MERGE_COMMIT_MESSAGE: _APIUtils.MERGE_COMMIT_MESSAGE,
+  isPreviewContext: _API.isPreviewContext,
+  getPreviewStatus: _API.getPreviewStatus,
+  runWithLock: _implementation.runWithLock,
+  PreviewState: _API.PreviewState,
+  parseContentKey: _APIUtils.parseContentKey,
+  createPointerFile: _gitLfs.createPointerFile,
+  getLargeMediaFilteredMediaFiles: _gitLfs.getLargeMediaFilteredMediaFiles,
+  getLargeMediaPatternsFromGitAttributesFile: _gitLfs.getLargeMediaPatternsFromGitAttributesFile,
+  parsePointerFile: _gitLfs.parsePointerFile,
+  getPointerFileForMediaFileObj: _gitLfs.getPointerFileForMediaFileObj,
+  branchFromContentKey: _APIUtils.branchFromContentKey,
+  contentKeyFromBranch: _APIUtils.contentKeyFromBranch,
+  blobToFileObj: _implementation.blobToFileObj,
+  requestWithBackoff: _API.requestWithBackoff,
+  getDefaultBranchName: _API.getDefaultBranchName,
+  allEntriesByFolder: _implementation.allEntriesByFolder,
+  AccessTokenError: _AccessTokenError.default,
+  throwOnConflictingBranches: _API.throwOnConflictingBranches
+};

node_modules/decap-cms-lib-util/dist/esm/loadScript.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadScript;
+/**
+ * Simple script loader that returns a promise.
+ */
+function loadScript(url) {
+  return new Promise((resolve, reject) => {
+    let done = false;
+    const head = document.getElementsByTagName('head')[0];
+    const script = document.createElement('script');
+    script.src = url;
+    script.onload = script.onreadystatechange = function () {
+      if (!done && (!this.readyState || this.readyState === 'loaded' || this.readyState === 'complete')) {
+        done = true;
+        resolve();
+      } else {
+        reject();
+      }
+    };
+    script.onerror = error => reject(error);
+    head.appendChild(script);
+  });
+}

node_modules/decap-cms-lib-util/dist/esm/localForage.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _localforage = _interopRequireDefault(require("localforage"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function localForageTest() {
+  const testKey = 'localForageTest';
+  _localforage.default.setItem(testKey, {
+    expires: Date.now() + 300000
+  }).then(() => {
+    _localforage.default.removeItem(testKey);
+  }).catch(err => {
+    if (err.code === 22) {
+      const message = 'Unable to set localStorage key. Quota exceeded! Full disk?';
+      console.warn(message);
+    }
+    console.log(err);
+  });
+}
+localForageTest();
+var _default = exports.default = _localforage.default;

node_modules/decap-cms-lib-util/dist/esm/path.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.basename = basename;
+exports.fileExtension = fileExtension;
+exports.fileExtensionWithSeparator = fileExtensionWithSeparator;
+exports.isAbsolutePath = isAbsolutePath;
+const absolutePath = new RegExp('^(?:[a-z]+:)?//', 'i');
+function normalizePath(path) {
+  return path.replace(/[\\/]+/g, '/');
+}
+function isAbsolutePath(path) {
+  return absolutePath.test(path);
+}
+
+/**
+ * Return the last portion of a path. Similar to the Unix basename command.
+ * @example Usage example
+ *   path.basename('/foo/bar/baz/asdf/quux.html')
+ *   // returns
+ *   'quux.html'
+ *
+ *   path.basename('/foo/bar/baz/asdf/quux.html', '.html')
+ *   // returns
+ *   'quux'
+ */
+function basename(p, ext = '') {
+  // Special case: Normalize will modify this to '.'
+  if (p === '') {
+    return p;
+  }
+  // Normalize the string first to remove any weirdness.
+  p = normalizePath(p);
+  // Get the last part of the string.
+  const sections = p.split('/');
+  const lastPart = sections[sections.length - 1];
+  // Special case: If it's empty, then we have a string like so: foo/
+  // Meaning, 'foo' is guaranteed to be a directory.
+  if (lastPart === '' && sections.length > 1) {
+    return sections[sections.length - 2];
+  }
+  // Remove the extension, if need be.
+  if (ext.length > 0) {
+    const lastPartExt = lastPart.slice(-ext.length);
+    if (lastPartExt === ext) {
+      return lastPart.slice(0, -ext.length);
+    }
+  }
+  return lastPart;
+}
+
+/**
+ * Return the extension of the path, from the last '.' to end of string in the
+ * last portion of the path. If there is no '.' in the last portion of the path
+ * or the first character of it is '.', then it returns an empty string.
+ * @example Usage example
+ *   path.fileExtensionWithSeparator('index.html')
+ *   // returns
+ *   '.html'
+ */
+function fileExtensionWithSeparator(p) {
+  p = normalizePath(p);
+  const sections = p.split('/');
+  p = sections.pop();
+  // Special case: foo/file.ext/ should return '.ext'
+  if (p === '' && sections.length > 0) {
+    p = sections.pop();
+  }
+  if (p === '..') {
+    return '';
+  }
+  const i = p.lastIndexOf('.');
+  if (i === -1 || i === 0) {
+    return '';
+  }
+  return p.slice(i);
+}
+
+/**
+ * Return the extension of the path, from after the last '.' to end of string in the
+ * last portion of the path. If there is no '.' in the last portion of the path
+ * or the first character of it is '.', then it returns an empty string.
+ * @example Usage example
+ *   path.fileExtension('index.html')
+ *   // returns
+ *   'html'
+ */
+function fileExtension(p) {
+  const ext = fileExtensionWithSeparator(p);
+  return ext === '' ? ext : ext.slice(1);
+}

node_modules/decap-cms-lib-util/dist/esm/promise.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flowAsync = flowAsync;
+exports.onlySuccessfulPromises = onlySuccessfulPromises;
+exports.then = then;
+var _flow = _interopRequireDefault(require("lodash/flow"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function then(fn) {
+  return p => Promise.resolve(p).then(fn);
+}
+const filterPromiseSymbol = Symbol('filterPromiseSymbol');
+function onlySuccessfulPromises(promises) {
+  return Promise.all(promises.map(p => p.catch(() => filterPromiseSymbol))).then(results => results.filter(result => result !== filterPromiseSymbol));
+}
+function wrapFlowAsync(fn) {
+  return async arg => fn(await arg);
+}
+function flowAsync(fns) {
+  return (0, _flow.default)(fns.map(fn => wrapFlowAsync(fn)));
+}

node_modules/decap-cms-lib-util/dist/esm/types/semaphore.d.js

@@ -0,0 +1 @@
+"use strict";

node_modules/decap-cms-lib-util/dist/esm/unsentRequest.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _immutable = require("immutable");
+var _curry = _interopRequireDefault(require("lodash/curry"));
+var _flow = _interopRequireDefault(require("lodash/flow"));
+var _isString = _interopRequireDefault(require("lodash/isString"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function isAbortControllerSupported() {
+  if (typeof window !== 'undefined') {
+    return !!window.AbortController;
+  }
+  return false;
+}
+const timeout = 60;
+function fetchWithTimeout(input, init) {
+  if (init && init.signal || !isAbortControllerSupported()) {
+    return fetch(input, init);
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout * 1000);
+  return fetch(input, _objectSpread(_objectSpread({}, init), {}, {
+    signal: controller.signal
+  })).then(res => {
+    clearTimeout(timeoutId);
+    return res;
+  }).catch(e => {
+    if (e.name === 'AbortError' || e.name === 'DOMException') {
+      throw new Error(`Request timed out after ${timeout} seconds`);
+    }
+    throw e;
+  });
+}
+function decodeParams(paramsString) {
+  return (0, _immutable.List)(paramsString.split('&')).map(s => (0, _immutable.List)(s.split('=')).map(decodeURIComponent)).update(_immutable.Map);
+}
+function fromURL(wholeURL) {
+  const [url, allParamsString] = wholeURL.split('?');
+  return (0, _immutable.Map)(_objectSpread({
+    url
+  }, allParamsString ? {
+    params: decodeParams(allParamsString)
+  } : {}));
+}
+function fromFetchArguments(wholeURL, options) {
+  return fromURL(wholeURL).merge((options ? (0, _immutable.fromJS)(options) : (0, _immutable.Map)()).remove('url').remove('params'));
+}
+function encodeParams(params) {
+  return params.entrySeq().map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&');
+}
+function toURL(req) {
+  return `${req.get('url')}${req.get('params') ? `?${encodeParams(req.get('params'))}` : ''}`;
+}
+function toFetchArguments(req) {
+  return [toURL(req), req.remove('url').remove('params').toJS()];
+}
+function maybeRequestArg(req) {
+  if ((0, _isString.default)(req)) {
+    return fromURL(req);
+  }
+  if (req) {
+    return (0, _immutable.fromJS)(req);
+  }
+  return (0, _immutable.Map)();
+}
+function ensureRequestArg(func) {
+  return req => func(maybeRequestArg(req));
+}
+function ensureRequestArg2(func) {
+  return (arg, req) => func(arg, maybeRequestArg(req));
+}
+
+// This actually performs the built request object
+const performRequest = ensureRequestArg(req => {
+  const args = toFetchArguments(req);
+  return fetchWithTimeout(...args);
+});
+
+// Each of the following functions takes options and returns another
+// function that performs the requested action on a request.
+const getCurriedRequestProcessor = (0, _flow.default)([ensureRequestArg2, _curry.default]);
+function getPropSetFunction(path) {
+  return getCurriedRequestProcessor((val, req) => req.setIn(path, val));
+}
+function getPropMergeFunction(path) {
+  return getCurriedRequestProcessor((obj, req) => req.updateIn(path, (p = (0, _immutable.Map)()) => p.merge(obj)));
+}
+const withMethod = getPropSetFunction(['method']);
+const withBody = getPropSetFunction(['body']);
+const withNoCache = getPropSetFunction(['cache'])('no-cache');
+const withParams = getPropMergeFunction(['params']);
+const withHeaders = getPropMergeFunction(['headers']);
+
+// withRoot sets a root URL, unless the URL is already absolute
+const absolutePath = new RegExp('^(?:[a-z]+:)?//', 'i');
+const withRoot = getCurriedRequestProcessor((root, req) => req.update('url', p => {
+  if (absolutePath.test(p)) {
+    return p;
+  }
+  return root && p && p[0] !== '/' && root[root.length - 1] !== '/' ? `${root}/${p}` : `${root}${p}`;
+}));
+var _default = exports.default = {
+  toURL,
+  fromURL,
+  fromFetchArguments,
+  performRequest,
+  withMethod,
+  withBody,
+  withHeaders,
+  withParams,
+  withRoot,
+  withNoCache,
+  fetchWithTimeout
+};