move packages to src

src/assets/javascripts/api.js

@@ -0,0 +1,110 @@
+"use strict";
+
+(function() {
+  var xfetch = function(resource, init) {
+    init = init || {}
+    if (['post', 'put', 'delete'].indexOf(init.method) !== -1) {
+      init['headers'] = init['headers'] || {}
+      init['headers']['x-requested-by'] = 'yarr'
+    }
+    return fetch(resource, init)
+  }
+  var api = function(method, endpoint, data) {
+    var headers = {'Content-Type': 'application/json'}
+    return xfetch(endpoint, {
+      method: method,
+      headers: headers,
+      body: JSON.stringify(data),
+    })
+  }
+
+  var json = function(res) {
+    return res.json()
+  }
+
+  var param = function(query) {
+    if (!query) return ''
+    return '?' + Object.keys(query).map(function(key) {
+      return encodeURIComponent(key) + '=' + encodeURIComponent(query[key])
+    }).join('&')
+  }
+
+  window.api = {
+    feeds: {
+      list: function() {
+        return api('get', './api/feeds').then(json)
+      },
+      create: function(data) {
+        return api('post', './api/feeds', data).then(json)
+      },
+      update: function(id, data) {
+        return api('put', './api/feeds/' + id, data)
+      },
+      delete: function(id) {
+        return api('delete', './api/feeds/' + id)
+      },
+      list_items: function(id) {
+        return api('get', './api/feeds/' + id + '/items').then(json)
+      },
+      refresh: function() {
+        return api('post', './api/feeds/refresh')
+      },
+      list_errors: function() {
+        return api('get', './api/feeds/errors').then(json)
+      },
+    },
+    folders: {
+      list: function() {
+        return api('get', './api/folders').then(json)
+      },
+      create: function(data) {
+        return api('post', './api/folders', data).then(json)
+      },
+      update: function(id, data) {
+        return api('put', './api/folders/' + id, data)
+      },
+      delete: function(id) {
+        return api('delete', './api/folders/' + id)
+      },
+      list_items: function(id) {
+        return api('get', './api/folders/' + id + '/items').then(json)
+      }
+    },
+    items: {
+      list: function(query) {
+        return api('get', './api/items' + param(query)).then(json)
+      },
+      update: function(id, data) {
+        return api('put', './api/items/' + id, data)
+      },
+      mark_read: function(query) {
+        return api('put', './api/items' + param(query))
+      },
+    },
+    settings: {
+      get: function() {
+        return api('get', './api/settings').then(json)
+      },
+      update: function(data) {
+        return api('put', './api/settings', data)
+      },
+    },
+    status: function() {
+      return api('get', './api/status').then(json)
+    },
+    upload_opml: function(form) {
+      return xfetch('./opml/import', {
+        method: 'post',
+        body: new FormData(form),
+      })
+    },
+    logout: function() {
+      return api('post', './logout')
+    },
+    crawl: function(url) {
+      return xfetch('./page?url=' + url).then(function(res) {
+        return res.text()
+      })
+    }
+  }
+})()

src/assets/javascripts/app.js

@@ -0,0 +1,608 @@
+'use strict';
+
+var TITLE = document.title
+
+function authenticated() {
+  return /auth=.+/g.test(document.cookie)
+
+}
+
+var FONTS = [
+  "Arial",
+  "Courier New",
+  "Georgia",
+  "Times New Roman",
+  "Verdana",
+]
+
+var debounce = function(callback, wait) {
+  var timeout
+  return function() {
+    var ctx = this, args = arguments
+    clearTimeout(timeout)
+    timeout = setTimeout(function() {
+      callback.apply(ctx, args)
+    }, wait)
+  }
+}
+
+var sanitize = function(content, base) {
+  // WILD: `item.link` may be a relative link (or some nonsense)
+  try { new URL(base) } catch(err) { base = null }
+
+  var sanitizer = new DOMPurify
+  sanitizer.addHook('afterSanitizeAttributes', function(node) {
+    // set all elements owning target to target=_blank
+    if ('target' in node)
+      node.setAttribute('target', '_blank')
+    // set non-HTML/MathML links to xlink:show=new
+    if (!node.hasAttribute('target') && (node.hasAttribute('xlink:href') || node.hasAttribute('href')))
+      node.setAttribute('xlink:show', 'new')
+
+    // set absolute urls
+    if (base && node.attributes.href && node.attributes.href.value)
+      node.href = new URL(node.attributes.href.value, base).toString()
+    if (base && node.attributes.src && node.attributes.src.value)
+      node.src = new URL(node.attributes.src.value, base).toString()
+  })
+  return sanitizer.sanitize(content, {FORBID_TAGS: ['style'], FORBID_ATTR: ['style', 'class']})
+}
+
+Vue.use(VueLazyload)
+
+Vue.directive('scroll', {
+  inserted: function(el, binding) {
+    el.addEventListener('scroll', debounce(function(event) {
+      binding.value(event, el)
+    }, 200))
+  },
+})
+
+Vue.component('drag', {
+  props: ['width'],
+  template: '<div class="drag"></div>',
+  mounted: function() {
+    var self = this
+    var startX = undefined
+    var initW = undefined
+    var onMouseMove = function(e) {
+      var offset = e.clientX - startX
+      var newWidth = initW + offset
+      self.$emit('resize', newWidth)
+    }
+    var onMouseUp = function(e) {
+      document.removeEventListener('mousemove', onMouseMove)
+      document.removeEventListener('mouseup', onMouseUp)
+    }
+    this.$el.addEventListener('mousedown', function(e) {
+      startX = e.clientX
+      initW = self.width
+      document.addEventListener('mousemove', onMouseMove)
+      document.addEventListener('mouseup', onMouseUp)
+    })
+  },
+})
+
+function dateRepr(d) {
+  var sec = (new Date().getTime() - d.getTime()) / 1000
+  var neg = sec < 0
+  var out = ''
+
+  sec = Math.abs(sec)
+  if (sec < 2700)  // less than 45 minutes
+    out = Math.round(sec / 60) + 'm'
+  else if (sec < 86400)  // less than 24 hours
+    out = Math.round(sec / 3600) + 'h'
+  else if (sec < 604800)  // less than a week
+    out = Math.round(sec / 86400) + 'd'
+  else
+    out = d.toLocaleDateString(undefined, {year: "numeric", month: "long", day: "numeric"})
+
+  if (neg) return '-' + out
+  return out
+}
+
+Vue.component('relative-time', {
+  props: ['val'],
+  data: function() {
+    var d = new Date(this.val)
+    return {
+      'date': d,
+      'formatted': dateRepr(d),
+      'interval': null,
+    }
+  },
+  template: '<time :datetime="val">{{ formatted }}</time>',
+  mounted: function() {
+    this.interval = setInterval(function() {
+      this.formatted = dateRepr(this.date)
+    }.bind(this), 600000)  // every 10 minutes
+  },
+  destroyed: function() {
+    clearInterval(this.interval)
+  },
+})
+
+var vm = new Vue({
+  created: function() {
+    this.refreshFeeds()
+    this.refreshStats()
+  },
+  mounted: function() {
+    this.$root.$on('bv::modal::hidden', function(bvEvent, modalId) {
+      if (vm.settings == 'create') {
+        vm.feedNewChoice = []
+        vm.feedNewChoiceSelected = ''
+      }
+    })
+  },
+  data: function() {
+    return {
+      'filterSelected': undefined,
+      'folders': [],
+      'feeds': [],
+      'feedSelected': undefined,
+      'feedListWidth': undefined,
+      'feedNewChoice': [],
+      'feedNewChoiceSelected': '',
+      'items': [],
+      'itemsPage': {
+        'cur': 1,
+        'num': 1,
+      },
+      'itemSelected': null,
+      'itemSelectedDetails': {},
+      'itemSelectedReadability': '',
+      'itemSearch': '',
+      'itemSortNewestFirst': undefined,
+      'itemListWidth': undefined,
+
+      'filteredFeedStats': {},
+      'filteredFolderStats': {},
+      'filteredTotalStats': null,
+
+      'settings': 'create',
+      'loading': {
+        'feeds': 0,
+        'newfeed': false,
+        'items': false,
+        'readability': false,
+      },
+      'fonts': FONTS,
+      'feedStats': {},
+      'theme': {
+        'name': 'light',
+        'font': '',
+        'size': 1,
+      },
+      'refreshRate': undefined,
+      'authenticated': authenticated(),
+      'feed_errors': {},
+    }
+  },
+  computed: {
+    foldersWithFeeds: function() {
+      var feedsByFolders = this.feeds.reduce(function(folders, feed) {
+        if (!folders[feed.folder_id])
+          folders[feed.folder_id] = [feed]
+        else
+          folders[feed.folder_id].push(feed)
+        return folders
+      }, {})
+      var folders = this.folders.slice().map(function(folder) {
+        folder.feeds = feedsByFolders[folder.id]
+        return folder
+      })
+      folders.push({id: null, feeds: feedsByFolders[null]})
+      return folders
+    },
+    feedsById: function() {
+      return this.feeds.reduce(function(acc, feed) { acc[feed.id] = feed; return acc }, {})
+    },
+    itemsById: function() {
+      return this.items.reduce(function(acc, item) { acc[item.id] = item; return acc }, {})
+    },
+    itemSelectedContent: function() {
+      if (!this.itemSelected) return ''
+
+      if (this.itemSelectedReadability)
+        return this.itemSelectedReadability
+
+      var content = ''
+      if (this.itemSelectedDetails.content)
+        content = this.itemSelectedDetails.content
+      else if (this.itemSelectedDetails.description)
+        content = this.itemSelectedDetails.description
+
+      return sanitize(content, this.itemSelectedDetails.link)
+    },
+  },
+  watch: {
+    'theme': {
+      deep: true,
+      handler: function(theme) {
+        document.body.classList.value = 'theme-' + theme.name
+        api.settings.update({
+          theme_name: theme.name,
+          theme_font: theme.font,
+          theme_size: theme.size,
+        })
+      },
+    },
+    'feedStats': {
+      deep: true,
+      handler: debounce(function() {
+        var title = TITLE
+        var unreadCount = Object.values(this.feedStats).reduce(function(acc, stat) {
+          return acc + stat.unread
+        }, 0)
+        if (unreadCount) {
+          title += ' ('+unreadCount+')'
+        }
+        document.title = title
+        this.computeStats()
+      }, 500),
+    },
+    'filterSelected': function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({filter: newVal}).then(this.refreshItems.bind(this))
+      this.itemSelected = null
+      this.computeStats()
+    },
+    'feedSelected': function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({feed: newVal}).then(this.refreshItems.bind(this))
+      this.itemSelected = null
+      if (this.$refs.itemlist) this.$refs.itemlist.scrollTop = 0
+    },
+    'itemSelected': function(newVal, oldVal) {
+      this.itemSelectedReadability = ''
+      if (newVal === null) {
+        this.itemSelectedDetails = null
+        return
+      }
+      if (this.$refs.content) this.$refs.content.scrollTop = 0
+
+      this.itemSelectedDetails = this.itemsById[newVal]
+      if (this.itemSelectedDetails.status == 'unread') {
+        this.itemSelectedDetails.status = 'read'
+        this.feedStats[this.itemSelectedDetails.feed_id].unread -= 1
+        api.items.update(this.itemSelectedDetails.id, {status: this.itemSelectedDetails.status})
+      }
+    },
+    'itemSearch': debounce(function(newVal) {
+      this.refreshItems()
+    }, 500),
+    'itemSortNewestFirst': function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({sort_newest_first: newVal}).then(this.refreshItems.bind(this))
+    },
+    'feedListWidth': debounce(function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({feed_list_width: newVal})
+    }, 1000),
+    'itemListWidth': debounce(function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({item_list_width: newVal})
+    }, 1000),
+    'refreshRate': function(newVal, oldVal) {
+      if (oldVal === undefined) return  // do nothing, initial setup
+      api.settings.update({refresh_rate: newVal})
+    },
+  },
+  methods: {
+    refreshStats: function(loopMode) {
+      api.status().then(function(data) {
+        if (loopMode && !vm.itemSelected) vm.refreshItems()
+
+        vm.loading.feeds = data.running
+        if (data.running) {
+          setTimeout(vm.refreshStats.bind(vm, true), 500)
+        }
+        vm.feedStats = data.stats.reduce(function(acc, stat) {
+          acc[stat.feed_id] = stat
+          return acc
+        }, {})
+      })
+    },
+    getItemsQuery: function() {
+      var query = {}
+      if (this.feedSelected) {
+        var parts = this.feedSelected.split(':', 2)
+        var type = parts[0]
+        var guid = parts[1]
+        if (type == 'feed') {
+          query.feed_id = guid
+        } else if (type == 'folder') {
+          query.folder_id = guid
+        }
+      }
+      if (this.filterSelected) {
+        query.status = this.filterSelected
+      }
+      if (this.itemSearch) {
+        query.search = this.itemSearch
+      }
+      if (!this.itemSortNewestFirst) {
+        query.oldest_first = true
+      }
+      return query
+    },
+    refreshFeeds: function() {
+      return Promise
+        .all([api.folders.list(), api.feeds.list()])
+        .then(function(values) {
+          vm.folders = values[0]
+          vm.feeds = values[1]
+        })
+    },
+    refreshItems: function() {
+      if (this.feedSelected === null) {
+        vm.items = []
+        vm.itemsPage = {'cur': 1, 'num': 1}
+        return
+      }
+      var query = this.getItemsQuery()
+      this.loading.items = true
+      return api.items.list(query).then(function(data) {
+        vm.items = data.list
+        vm.itemsPage = data.page
+        vm.loading.items = false
+      })
+    },
+    loadMoreItems: function(event, el) {
+      if (this.itemsPage.cur >= this.itemsPage.num) return
+      if (this.loading.items) return
+      var closeToBottom = (el.scrollHeight - el.scrollTop - el.offsetHeight) < 50
+      if (closeToBottom) {
+        this.loading.moreitems = true
+        var query = this.getItemsQuery()
+        query.page = this.itemsPage.cur + 1
+        api.items.list(query).then(function(data) {
+          vm.items = vm.items.concat(data.list)
+          vm.itemsPage = data.page
+          vm.loading.items = false
+        })
+      }
+    },
+    markItemsRead: function() {
+      var query = this.getItemsQuery()
+      api.items.mark_read(query).then(function() {
+        vm.items = []
+        vm.itemsPage = {'cur': 1, 'num': 1}
+        vm.itemSelected = null
+        vm.refreshStats()
+      })
+    },
+    toggleFolderExpanded: function(folder) {
+      folder.is_expanded = !folder.is_expanded
+      api.folders.update(folder.id, {is_expanded: folder.is_expanded})
+    },
+    formatDate: function(datestr) {
+      var options = {
+        year: "numeric", month: "long", day: "numeric",
+        hour: '2-digit', minute: '2-digit',
+      }
+      return new Date(datestr).toLocaleDateString(undefined, options)
+    },
+    moveFeed: function(feed, folder) {
+      var folder_id = folder ? folder.id : null
+      api.feeds.update(feed.id, {folder_id: folder_id}).then(function() {
+        feed.folder_id = folder_id
+        vm.refreshStats()
+      })
+    },
+    moveFeedToNewFolder: function(feed) {
+      var title = prompt('Enter folder name:')
+      if (!title) return
+      api.folders.create({'title': title}).then(function(folder) {
+        api.feeds.update(feed.id, {folder_id: folder.id}).then(function() {
+          vm.refreshFeeds().then(function() {
+            vm.refreshStats()
+          })
+        })
+      })
+    },
+    createNewFeedFolder: function() {
+      var title = prompt('Enter folder name:')
+      if (!title) return
+      api.folders.create({'title': title}).then(function(result) {
+        vm.refreshFeeds().then(function() {
+          vm.$nextTick(function() {
+            if (vm.$refs.newFeedFolder) {
+              vm.$refs.newFeedFolder.value = result.id
+            }
+          })
+        })
+      })
+    },
+    renameFolder: function(folder) {
+      var newTitle = prompt('Enter new title', folder.title)
+      if (newTitle) {
+        api.folders.update(folder.id, {title: newTitle}).then(function() {
+          folder.title = newTitle
+        })
+      }
+    },
+    deleteFolder: function(folder) {
+      if (confirm('Are you sure you want to delete ' + folder.title + '?')) {
+        api.folders.delete(folder.id).then(function() {
+          if (vm.feedSelected === 'folder:'+folder.id) {
+            vm.items = []
+            vm.feedSelected = ''
+          }
+          vm.refreshStats()
+          vm.refreshFeeds()
+        })
+      }
+    },
+    renameFeed: function(feed) {
+      var newTitle = prompt('Enter new title', feed.title)
+      if (newTitle) {
+        api.feeds.update(feed.id, {title: newTitle}).then(function() {
+          feed.title = newTitle
+        })
+      }
+    },
+    deleteFeed: function(feed) {
+      if (confirm('Are you sure you want to delete ' + feed.title + '?')) {
+        api.feeds.delete(feed.id).then(function() {
+          // unselect feed to prevent reading properties of null in template
+          var isSelected = !vm.feedSelected
+            || (vm.feedSelected === 'feed:'+feed.id
+            || (feed.folder_id && vm.feedSelected === 'folder:'+feed.folder_id));
+          if (isSelected) vm.feedSelected = null
+
+          vm.refreshStats()
+          vm.refreshFeeds()
+        })
+      }
+    },
+    createFeed: function(event) {
+      var form = event.target
+      var data = {
+        url: form.querySelector('input[name=url]').value,
+        folder_id: parseInt(form.querySelector('select[name=folder_id]').value) || null,
+      }
+      if (this.feedNewChoiceSelected) {
+        data.url = this.feedNewChoiceSelected
+      }
+      this.loading.newfeed = true
+      api.feeds.create(data).then(function(result) {
+        if (result.status === 'success') {
+          vm.refreshFeeds()
+          vm.refreshStats()
+          vm.$bvModal.hide('settings-modal')
+        } else if (result.status === 'multiple') {
+          vm.feedNewChoice = result.choice
+          vm.feedNewChoiceSelected = result.choice[0].url
+        } else {
+          alert('No feeds found at the given url.')
+        }
+        vm.loading.newfeed = false
+      })
+    },
+    toggleItemStarred: function(item) {
+      if (item.status == 'starred') {
+        item.status = 'read'
+        this.feedStats[item.feed_id].starred -= 1
+      } else if (item.status != 'starred') {
+        item.status = 'starred'
+        this.feedStats[item.feed_id].starred += 1
+      }
+      api.items.update(item.id, {status: item.status})
+    },
+    toggleItemRead: function(item) {
+      if (item.status == 'unread') {
+        item.status = 'read'
+        this.feedStats[item.feed_id].unread -= 1
+      } else if (item.status == 'read') {
+        item.status = 'unread'
+        this.feedStats[item.feed_id].unread += 1
+      }
+      api.items.update(item.id, {status: item.status})
+    },
+    importOPML: function(event) {
+      var input = event.target
+      var form = document.querySelector('#opml-import-form')
+      this.$refs.menuDropdown.hide()
+      api.upload_opml(form).then(function() {
+        input.value = ''
+        vm.refreshFeeds()
+        vm.refreshStats()
+      })
+    },
+    logout: function() {
+      api.logout().then(function() {
+        document.location.reload()
+      })
+    },
+    getReadable: function(item) {
+      if (this.itemSelectedReadability) {
+        this.itemSelectedReadability = null
+        return
+      }
+      if (item.link) {
+        this.loading.readability = true
+        api.crawl(item.link).then(function(body) {
+          vm.loading.readability = false
+          if (!body.length) return
+          var bodyClean = sanitize(body, item.link)
+          var doc = new DOMParser().parseFromString(bodyClean, 'text/html')
+          var parsed = new Readability(doc).parse()
+          if (parsed && parsed.content) {
+            vm.itemSelectedReadability = parsed.content
+          }
+        })
+      }
+    },
+    showSettings: function(settings) {
+      this.settings = settings
+      this.$bvModal.show('settings-modal')
+
+      if (settings === 'manage') {
+        api.feeds.list_errors().then(function(errors) {
+          vm.feed_errors = errors
+        })
+      }
+    },
+    resizeFeedList: function(width) {
+      this.feedListWidth = Math.min(Math.max(200, width), 700)
+    },
+    resizeItemList: function(width) {
+      this.itemListWidth = Math.min(Math.max(200, width), 700)
+    },
+    resetFeedChoice: function() {
+      this.feedNewChoice = []
+      this.feedNewChoiceSelected = ''
+    },
+    incrFont: function(x) {
+      this.theme.size = +(this.theme.size + (0.1 * x)).toFixed(1)
+    },
+    fetchAllFeeds: function() {
+      api.feeds.refresh().then(this.refreshStats.bind(this))
+    },
+    computeStats: function() {
+      var filter = this.filterSelected
+      if (!filter) {
+        this.filteredFeedStats = {}
+        this.filteredFolderStats = {}
+        this.filteredTotalStats = null
+        return
+      }
+
+      var statsFeeds = {}, statsFolders = {}, statsTotal = 0
+
+      for (var i = 0; i < this.feeds.length; i++) {
+        var feed = this.feeds[i]
+        if (!this.feedStats[feed.id]) continue
+
+        var n = vm.feedStats[feed.id][filter] || 0
+
+        if (!statsFolders[feed.folder_id]) statsFolders[feed.folder_id] = 0
+
+        statsFeeds[feed.id] = n
+        statsFolders[feed.folder_id] += n
+        statsTotal += n
+      }
+
+      this.filteredFeedStats = statsFeeds
+      this.filteredFolderStats = statsFolders
+      this.filteredTotalStats = statsTotal
+    },
+  }
+})
+
+api.settings.get().then(function(data) {
+  vm.feedSelected = data.feed
+  vm.filterSelected = data.filter
+  vm.itemSortNewestFirst = data.sort_newest_first
+  vm.feedListWidth = data.feed_list_width || 300
+  vm.itemListWidth = data.item_list_width || 300
+  vm.theme.name = data.theme_name
+  vm.theme.font = data.theme_font
+  vm.theme.size = data.theme_size
+  vm.refreshRate = data.refresh_rate
+  vm.refreshItems()
+  vm.$mount('#app')
+})

src/assets/javascripts/fetch.umd.js

@@ -0,0 +1,609 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (factory((global.WHATWGFetch = {})));
+}(this, (function (exports) { 'use strict';
+
+  var global = (typeof self !== 'undefined' && self) || (typeof global !== 'undefined' && global);
+
+  var support = {
+    searchParams: 'URLSearchParams' in global,
+    iterable: 'Symbol' in global && 'iterator' in Symbol,
+    blob:
+      'FileReader' in global &&
+      'Blob' in global &&
+      (function() {
+        try {
+          new Blob();
+          return true
+        } catch (e) {
+          return false
+        }
+      })(),
+    formData: 'FormData' in global,
+    arrayBuffer: 'ArrayBuffer' in global
+  };
+
+  function isDataView(obj) {
+    return obj && DataView.prototype.isPrototypeOf(obj)
+  }
+
+  if (support.arrayBuffer) {
+    var viewClasses = [
+      '[object Int8Array]',
+      '[object Uint8Array]',
+      '[object Uint8ClampedArray]',
+      '[object Int16Array]',
+      '[object Uint16Array]',
+      '[object Int32Array]',
+      '[object Uint32Array]',
+      '[object Float32Array]',
+      '[object Float64Array]'
+    ];
+
+    var isArrayBufferView =
+      ArrayBuffer.isView ||
+      function(obj) {
+        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+      };
+  }
+
+  function normalizeName(name) {
+    if (typeof name !== 'string') {
+      name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+      throw new TypeError('Invalid character in header field name')
+    }
+    return name.toLowerCase()
+  }
+
+  function normalizeValue(value) {
+    if (typeof value !== 'string') {
+      value = String(value);
+    }
+    return value
+  }
+
+  // Build a destructive iterator for the value list
+  function iteratorFor(items) {
+    var iterator = {
+      next: function() {
+        var value = items.shift();
+        return {done: value === undefined, value: value}
+      }
+    };
+
+    if (support.iterable) {
+      iterator[Symbol.iterator] = function() {
+        return iterator
+      };
+    }
+
+    return iterator
+  }
+
+  function Headers(headers) {
+    this.map = {};
+
+    if (headers instanceof Headers) {
+      headers.forEach(function(value, name) {
+        this.append(name, value);
+      }, this);
+    } else if (Array.isArray(headers)) {
+      headers.forEach(function(header) {
+        this.append(header[0], header[1]);
+      }, this);
+    } else if (headers) {
+      Object.getOwnPropertyNames(headers).forEach(function(name) {
+        this.append(name, headers[name]);
+      }, this);
+    }
+  }
+
+  Headers.prototype.append = function(name, value) {
+    name = normalizeName(name);
+    value = normalizeValue(value);
+    var oldValue = this.map[name];
+    this.map[name] = oldValue ? oldValue + ', ' + value : value;
+  };
+
+  Headers.prototype['delete'] = function(name) {
+    delete this.map[normalizeName(name)];
+  };
+
+  Headers.prototype.get = function(name) {
+    name = normalizeName(name);
+    return this.has(name) ? this.map[name] : null
+  };
+
+  Headers.prototype.has = function(name) {
+    return this.map.hasOwnProperty(normalizeName(name))
+  };
+
+  Headers.prototype.set = function(name, value) {
+    this.map[normalizeName(name)] = normalizeValue(value);
+  };
+
+  Headers.prototype.forEach = function(callback, thisArg) {
+    for (var name in this.map) {
+      if (this.map.hasOwnProperty(name)) {
+        callback.call(thisArg, this.map[name], name, this);
+      }
+    }
+  };
+
+  Headers.prototype.keys = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push(name);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.values = function() {
+    var items = [];
+    this.forEach(function(value) {
+      items.push(value);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.entries = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push([name, value]);
+    });
+    return iteratorFor(items)
+  };
+
+  if (support.iterable) {
+    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+  }
+
+  function consumed(body) {
+    if (body.bodyUsed) {
+      return Promise.reject(new TypeError('Already read'))
+    }
+    body.bodyUsed = true;
+  }
+
+  function fileReaderReady(reader) {
+    return new Promise(function(resolve, reject) {
+      reader.onload = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = function() {
+        reject(reader.error);
+      };
+    })
+  }
+
+  function readBlobAsArrayBuffer(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsArrayBuffer(blob);
+    return promise
+  }
+
+  function readBlobAsText(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsText(blob);
+    return promise
+  }
+
+  function readArrayBufferAsText(buf) {
+    var view = new Uint8Array(buf);
+    var chars = new Array(view.length);
+
+    for (var i = 0; i < view.length; i++) {
+      chars[i] = String.fromCharCode(view[i]);
+    }
+    return chars.join('')
+  }
+
+  function bufferClone(buf) {
+    if (buf.slice) {
+      return buf.slice(0)
+    } else {
+      var view = new Uint8Array(buf.byteLength);
+      view.set(new Uint8Array(buf));
+      return view.buffer
+    }
+  }
+
+  function Body() {
+    this.bodyUsed = false;
+
+    this._initBody = function(body) {
+      /*
+        fetch-mock wraps the Response object in an ES6 Proxy to
+        provide useful test harness features such as flush. However, on
+        ES5 browsers without fetch or Proxy support pollyfills must be used;
+        the proxy-pollyfill is unable to proxy an attribute unless it exists
+        on the object before the Proxy is created. This change ensures
+        Response.bodyUsed exists on the instance, while maintaining the
+        semantic of setting Request.bodyUsed in the constructor before
+        _initBody is called.
+      */
+      this.bodyUsed = this.bodyUsed;
+      this._bodyInit = body;
+      if (!body) {
+        this._bodyText = '';
+      } else if (typeof body === 'string') {
+        this._bodyText = body;
+      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+        this._bodyBlob = body;
+      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+        this._bodyFormData = body;
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this._bodyText = body.toString();
+      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+        this._bodyArrayBuffer = bufferClone(body.buffer);
+        // IE 10-11 can't handle a DataView body.
+        this._bodyInit = new Blob([this._bodyArrayBuffer]);
+      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+        this._bodyArrayBuffer = bufferClone(body);
+      } else {
+        this._bodyText = body = Object.prototype.toString.call(body);
+      }
+
+      if (!this.headers.get('content-type')) {
+        if (typeof body === 'string') {
+          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+        } else if (this._bodyBlob && this._bodyBlob.type) {
+          this.headers.set('content-type', this._bodyBlob.type);
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        }
+      }
+    };
+
+    if (support.blob) {
+      this.blob = function() {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return Promise.resolve(this._bodyBlob)
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as blob')
+        } else {
+          return Promise.resolve(new Blob([this._bodyText]))
+        }
+      };
+
+      this.arrayBuffer = function() {
+        if (this._bodyArrayBuffer) {
+          var isConsumed = consumed(this);
+          if (isConsumed) {
+            return isConsumed
+          }
+          if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+            return Promise.resolve(
+              this._bodyArrayBuffer.buffer.slice(
+                this._bodyArrayBuffer.byteOffset,
+                this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+              )
+            )
+          } else {
+            return Promise.resolve(this._bodyArrayBuffer)
+          }
+        } else {
+          return this.blob().then(readBlobAsArrayBuffer)
+        }
+      };
+    }
+
+    this.text = function() {
+      var rejected = consumed(this);
+      if (rejected) {
+        return rejected
+      }
+
+      if (this._bodyBlob) {
+        return readBlobAsText(this._bodyBlob)
+      } else if (this._bodyArrayBuffer) {
+        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+      } else if (this._bodyFormData) {
+        throw new Error('could not read FormData body as text')
+      } else {
+        return Promise.resolve(this._bodyText)
+      }
+    };
+
+    if (support.formData) {
+      this.formData = function() {
+        return this.text().then(decode)
+      };
+    }
+
+    this.json = function() {
+      return this.text().then(JSON.parse)
+    };
+
+    return this
+  }
+
+  // HTTP methods whose capitalization should be normalized
+  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+  function normalizeMethod(method) {
+    var upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method
+  }
+
+  function Request(input, options) {
+    if (!(this instanceof Request)) {
+      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+    }
+
+    options = options || {};
+    var body = options.body;
+
+    if (input instanceof Request) {
+      if (input.bodyUsed) {
+        throw new TypeError('Already read')
+      }
+      this.url = input.url;
+      this.credentials = input.credentials;
+      if (!options.headers) {
+        this.headers = new Headers(input.headers);
+      }
+      this.method = input.method;
+      this.mode = input.mode;
+      this.signal = input.signal;
+      if (!body && input._bodyInit != null) {
+        body = input._bodyInit;
+        input.bodyUsed = true;
+      }
+    } else {
+      this.url = String(input);
+    }
+
+    this.credentials = options.credentials || this.credentials || 'same-origin';
+    if (options.headers || !this.headers) {
+      this.headers = new Headers(options.headers);
+    }
+    this.method = normalizeMethod(options.method || this.method || 'GET');
+    this.mode = options.mode || this.mode || null;
+    this.signal = options.signal || this.signal;
+    this.referrer = null;
+
+    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+      throw new TypeError('Body not allowed for GET or HEAD requests')
+    }
+    this._initBody(body);
+
+    if (this.method === 'GET' || this.method === 'HEAD') {
+      if (options.cache === 'no-store' || options.cache === 'no-cache') {
+        // Search for a '_' parameter in the query string
+        var reParamSearch = /([?&])_=[^&]*/;
+        if (reParamSearch.test(this.url)) {
+          // If it already exists then set the value with the current time
+          this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+        } else {
+          // Otherwise add a new '_' parameter to the end with the current time
+          var reQueryString = /\?/;
+          this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+        }
+      }
+    }
+  }
+
+  Request.prototype.clone = function() {
+    return new Request(this, {body: this._bodyInit})
+  };
+
+  function decode(body) {
+    var form = new FormData();
+    body
+      .trim()
+      .split('&')
+      .forEach(function(bytes) {
+        if (bytes) {
+          var split = bytes.split('=');
+          var name = split.shift().replace(/\+/g, ' ');
+          var value = split.join('=').replace(/\+/g, ' ');
+          form.append(decodeURIComponent(name), decodeURIComponent(value));
+        }
+      });
+    return form
+  }
+
+  function parseHeaders(rawHeaders) {
+    var headers = new Headers();
+    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+    // https://tools.ietf.org/html/rfc7230#section-3.2
+    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
+      var parts = line.split(':');
+      var key = parts.shift().trim();
+      if (key) {
+        var value = parts.join(':').trim();
+        headers.append(key, value);
+      }
+    });
+    return headers
+  }
+
+  Body.call(Request.prototype);
+
+  function Response(bodyInit, options) {
+    if (!(this instanceof Response)) {
+      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+    }
+    if (!options) {
+      options = {};
+    }
+
+    this.type = 'default';
+    this.status = options.status === undefined ? 200 : options.status;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.statusText = 'statusText' in options ? options.statusText : '';
+    this.headers = new Headers(options.headers);
+    this.url = options.url || '';
+    this._initBody(bodyInit);
+  }
+
+  Body.call(Response.prototype);
+
+  Response.prototype.clone = function() {
+    return new Response(this._bodyInit, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: new Headers(this.headers),
+      url: this.url
+    })
+  };
+
+  Response.error = function() {
+    var response = new Response(null, {status: 0, statusText: ''});
+    response.type = 'error';
+    return response
+  };
+
+  var redirectStatuses = [301, 302, 303, 307, 308];
+
+  Response.redirect = function(url, status) {
+    if (redirectStatuses.indexOf(status) === -1) {
+      throw new RangeError('Invalid status code')
+    }
+
+    return new Response(null, {status: status, headers: {location: url}})
+  };
+
+  exports.DOMException = global.DOMException;
+  try {
+    new exports.DOMException();
+  } catch (err) {
+    exports.DOMException = function(message, name) {
+      this.message = message;
+      this.name = name;
+      var error = Error(message);
+      this.stack = error.stack;
+    };
+    exports.DOMException.prototype = Object.create(Error.prototype);
+    exports.DOMException.prototype.constructor = exports.DOMException;
+  }
+
+  function fetch(input, init) {
+    return new Promise(function(resolve, reject) {
+      var request = new Request(input, init);
+
+      if (request.signal && request.signal.aborted) {
+        return reject(new exports.DOMException('Aborted', 'AbortError'))
+      }
+
+      var xhr = new XMLHttpRequest();
+
+      function abortXhr() {
+        xhr.abort();
+      }
+
+      xhr.onload = function() {
+        var options = {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+        };
+        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+        var body = 'response' in xhr ? xhr.response : xhr.responseText;
+        setTimeout(function() {
+          resolve(new Response(body, options));
+        }, 0);
+      };
+
+      xhr.onerror = function() {
+        setTimeout(function() {
+          reject(new TypeError('Network request failed'));
+        }, 0);
+      };
+
+      xhr.ontimeout = function() {
+        setTimeout(function() {
+          reject(new TypeError('Network request failed'));
+        }, 0);
+      };
+
+      xhr.onabort = function() {
+        setTimeout(function() {
+          reject(new exports.DOMException('Aborted', 'AbortError'));
+        }, 0);
+      };
+
+      function fixUrl(url) {
+        try {
+          return url === '' && global.location.href ? global.location.href : url
+        } catch (e) {
+          return url
+        }
+      }
+
+      xhr.open(request.method, fixUrl(request.url), true);
+
+      if (request.credentials === 'include') {
+        xhr.withCredentials = true;
+      } else if (request.credentials === 'omit') {
+        xhr.withCredentials = false;
+      }
+
+      if ('responseType' in xhr) {
+        if (support.blob) {
+          xhr.responseType = 'blob';
+        } else if (
+          support.arrayBuffer &&
+          request.headers.get('Content-Type') &&
+          request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
+        ) {
+          xhr.responseType = 'arraybuffer';
+        }
+      }
+
+      if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+        Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+          xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+        });
+      } else {
+        request.headers.forEach(function(value, name) {
+          xhr.setRequestHeader(name, value);
+        });
+      }
+
+      if (request.signal) {
+        request.signal.addEventListener('abort', abortXhr);
+
+        xhr.onreadystatechange = function() {
+          // DONE (success or failure)
+          if (xhr.readyState === 4) {
+            request.signal.removeEventListener('abort', abortXhr);
+          }
+        };
+      }
+
+      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+    })
+  }
+
+  fetch.polyfill = true;
+
+  if (!global.fetch) {
+    global.fetch = fetch;
+    global.Headers = Headers;
+    global.Request = Request;
+    global.Response = Response;
+  }
+
+  exports.Headers = Headers;
+  exports.Request = Request;
+  exports.Response = Response;
+  exports.fetch = fetch;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));