diff --git a/chrome/content/zotero/xpcom/feedReader.js b/chrome/content/zotero/xpcom/feedReader.js
index 66022bab14..2326d7e385 100644
--- a/chrome/content/zotero/xpcom/feedReader.js
+++ b/chrome/content/zotero/xpcom/feedReader.js
@@ -53,16 +53,15 @@
  * @method {void} terminate Stops retrieving/parsing the feed. Data parsed up
  *   to this point is still available.
  */
-Zotero.FeedReader = function(url) {
+Zotero.FeedReader = function (url) {
 	if (!url) throw new Error("Feed URL must be supplied");
-
 	
 	this._url = url;
 	this._feedItems = [Zotero.Promise.defer()];
 	this._feedProcessed = Zotero.Promise.defer();
-
+	
 	let feedFetched = Zotero.Promise.defer();
-	feedFetched.promise.then(function(feed) {
+	feedFetched.promise.then(function (feed) {
 		let info = {};
 		
 		info.title = feed.title ? feed.title.plainText() : '';
@@ -93,7 +92,7 @@ Zotero.FeedReader = function(url) {
 		if (issn) info.ISSN = issn;
 		
 		let isbn = Zotero.FeedReader._getFeedField(feed, 'isbn', 'prism')
-			|| Zotero.FeedReader._getFeedField(feed, 'isbn')
+			|| Zotero.FeedReader._getFeedField(feed, 'isbn');
 		if (isbn) info.ISBN = isbn;
 		
 		let language = Zotero.FeedReader._getFeedField(feed, 'language', 'dc')
@@ -105,11 +104,11 @@ Zotero.FeedReader = function(url) {
 		
 		this._feedProperties = info;
 		this._feed = feed;
-	}.bind(this)).then(function(){
+	}.bind(this)).then(function () {
 		let items = this._feed.items;
 		if (items && items.length) {
-			for (let i=0; i<items.length; i++) {
-				let item = items.queryElementAt(i, Components.interfaces.nsIFeedEntry);
+			for (let i = 0; i < items.length; i++) {
+				let item = items[i];
 				if (!item) continue;
 				
 				let feedItem = Zotero.FeedReader._getFeedItem(item, this._feedProperties);
@@ -121,47 +120,88 @@ Zotero.FeedReader = function(url) {
 			}
 		}
 		this._feedProcessed.resolve();
-	}.bind(this)).catch(function(e) {
+	}.bind(this)).catch(function (e) {
 		Zotero.debug("Feed processing failed " + e.message);
 		this._feedProcessed.reject(e);
-	}.bind(this)).finally(function() {
+	// eslint-disable-next-line newline-per-chained-call
+	}.bind(this)).finally(function () {
 		// Make sure the last promise gets resolved to null
 		let lastItem = this._feedItems[this._feedItems.length - 1];
 		lastItem.resolve(null);
 	}.bind(this));
 	
-	// Set up asynchronous feed processor
-	let feedProcessor = Components.classes["@mozilla.org/feed-processor;1"]
-		.createInstance(Components.interfaces.nsIFeedProcessor);
+	// The feed processor and related modules assume a content window environment, so we'll simulate
+	// one via a sandbox in a parent window. You might think we could jump straight to
+	// `hiddenDOMWindow` as a parent window, since it does indeed exist on all platforms...
+	// However, when loading scripts into the `hiddenDOMWindow` on Windows and Linux, they get
+	// stuck in some lazily parsed state which bizarrely drops function prototypes. To avoid this,
+	// we prefer other parent windows first, which work fine on all platforms.
+	let parentWindow = Services.wm.getMostRecentWindow("navigator:browser");
+	if (!parentWindow) {
+		parentWindow = Services.ww.activeWindow;
+	}
+	// Use the hidden DOM window on macOS with the main window closed
+	if (!parentWindow) {
+		parentWindow = Services.appShell.hiddenDOMWindow;
+	}
+	if (!parentWindow) {
+		this.terminate("Parent window not available for feed reader");
+		return;
+	}
+	
+	const sandbox = new Cu.Sandbox(parentWindow, {
+		sandboxPrototype: parentWindow,
+		sandboxName: "Feed Processor",
+	});
+	sandbox.Zotero = {
+		debug: Components.utils.exportFunction(Zotero.debug, sandbox),
+	};
 
-	let feedUrl = Services.io.newURI(url, null, null);
+	Services.scriptloader.loadSubScript("resource://zotero/feeds/FeedProcessor.js", sandbox);
+	Services.scriptloader.loadSubScript("resource://zotero/feeds/SAXXMLReader.js", sandbox);
+	
+	// Set up asynchronous feed processor
+	const { FeedProcessor } = sandbox;
+	const feedProcessor = new FeedProcessor();
+	if (!feedProcessor.parseAsync) {
+		this.terminate("Feed processor failed to load in parent window");
+		return;
+	}
+
+	// Borrow web utils to fetch feed content
+	const { fetch, URL } = parentWindow;
+	
+	// Pass along the URL
+	const feedUrl = new URL(url);
 	feedProcessor.parseAsync(null, feedUrl);
 	
+	/*
+	 * MDN suggests that we could use nsIFeedProgressListener to handle the feed
+	 * as it gets loaded, but this is actually not implemented (as of 32.0.3),
+	 * so we have to load the whole feed and handle it in handleResult.
+	 */
 	feedProcessor.listener = {
-		/*
-		 * MDN suggests that we could use nsIFeedProgressListener to handle the feed
-		 * as it gets loaded, but this is actually not implemented (as of 32.0.3),
-		 * so we have to load the whole feed and handle it in handleResult.
-		 */
 		handleResult: (result) => {
 			if (!result.doc) {
 				this.terminate("No Feed");
 				return;
 			}
-			
-			let newFeed = result.doc.QueryInterface(Components.interfaces.nsIFeed);
-			feedFetched.resolve(newFeed);
+			feedFetched.resolve(result.doc);
 		}
 	};
 	
-	Zotero.debug("FeedReader: Fetching feed from " + feedUrl.spec);
+	Zotero.debug("FeedReader: Fetching feed from " + feedUrl);
 	
-	this._channel = Services.io.newChannelFromURI2(feedUrl, null, 
-		Services.scriptSecurityManager.getSystemPrincipal(), null, 
-		Ci.nsILoadInfo.SEC_NORMAL, Ci.nsIContentPolicy.TYPE_OTHER);
-	this._channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
-	this._channel.asyncOpen(feedProcessor, null); // Sends an HTTP request
-}
+	// Fetch and start processing
+	fetch(feedUrl, {
+		cache: "no-store",
+	}).then((response) => {
+		return feedProcessor.onResponseAvailable(response);
+	}).catch((e) => {
+		Zotero.debug(e);
+		this.terminate("Processing failed");
+	});
+};
 
 /*
  * The constructor initiates async feed processing, but _feedProcessed
@@ -175,7 +215,7 @@ Zotero.FeedReader.prototype.process = Zotero.Promise.coroutine(function* () {
  * Terminate feed processing at any given time
  * @param {String} status Reason for terminating processing
  */
-Zotero.FeedReader.prototype.terminate = function(status) {
+Zotero.FeedReader.prototype.terminate = function (status) {
 	Zotero.debug("FeedReader: Terminating feed reader (" + status + ")");
 	
 	// Reject feed promise if not resolved yet
@@ -195,19 +235,14 @@ Zotero.FeedReader.prototype.terminate = function(status) {
 		er.handledRejection = true;
 		lastItem.reject(er);
 	}
-	
-	// Close feed connection
-	if (this._channel.isPending()) {
-		this._channel.cancel(Components.results.NS_BINDING_ABORTED);
-	}
 };
 
 Zotero.defineProperty(Zotero.FeedReader.prototype, 'feedProperties', {
-	get: function(){ 
+	get: function () {
 		if (!this._feedProperties) {
-			throw new Error("Feed has not been resolved yet. Try calling FeedReader#process first")
+			throw new Error("Feed has not been resolved yet. Try calling FeedReader#process first");
 		}
-		return this._feedProperties
+		return this._feedProperties;
 	}
 });
 
@@ -220,18 +255,19 @@ Zotero.defineProperty(Zotero.FeedReader.prototype, 'feedProperties', {
  * for termination.
  */
 Zotero.defineProperty(Zotero.FeedReader.prototype, 'ItemIterator', {
-	get: function() {
+	get: function () {
 		let items = this._feedItems;
+		// eslint-disable-next-line consistent-this
 		let feedReader = this;
 		
-		let iterator = function() {
+		let iterator = function () {
 			if (!feedReader._feedProperties) {
-				throw new Error("Feed has not been resolved yet. Try calling FeedReader#process first")
+				throw new Error("Feed has not been resolved yet. Try calling FeedReader#process first");
 			}
 			this.index = 0;
 		};
 		
-		iterator.prototype.next = function() {
+		iterator.prototype.next = function () {
 			let item = items[this.index++];
 			return {
 				value: item ? item.promise : null,
@@ -239,23 +275,23 @@ Zotero.defineProperty(Zotero.FeedReader.prototype, 'ItemIterator', {
 			};
 		};
 		
-		iterator.prototype.last = function() {
-			return items[items.length-1];
-		}
+		iterator.prototype.last = function () {
+			return items[items.length - 1];
+		};
 		
 		return iterator;
 	}
-}, {lazy: true});
+}, { lazy: true });
 
 
 /*****************************
  * Item processing functions *
  *****************************/
- 	 
+
 /**
  * Determine item type based on item data
  */
-Zotero.FeedReader._guessItemType = function(item) {
+Zotero.FeedReader._guessItemType = function (item) {
 	// Default to journalArticle
 	item.itemType = 'journalArticle';
 	
@@ -288,40 +324,38 @@ Zotero.FeedReader._guessItemType = function(item) {
 /*
  * Fetch creators from given field of a feed entry
  */
-Zotero.FeedReader._processCreators = function(feedEntry, field, role) {
+Zotero.FeedReader._processCreators = function (feedEntry, field, role) {
 	let names = [],
 		nameStr;
 	try {
 		let personArr = feedEntry[field]; // Seems like this part can throw if there is no author data in the feed
-		for (let i=0; i<personArr.length; i++) {
-			let person = personArr.queryElementAt(i, Components.interfaces.nsIFeedPerson);
+		for (let i = 0; i < personArr.length; i++) {
+			let person = personArr[i];
 			if (!person || !person.name) continue;
 			
 			let name = Zotero.Utilities.cleanTags(Zotero.Utilities.trimInternal(person.name));
 			if (!name) continue;
 			
 			let commas = name.split(',').length - 1,
-					other = name.split(/\s(?:and|&)\s|;/).length - 1,
-					separators = commas + other;
-			if (personArr.length == 1 &&
+				other = name.split(/\s(?:and|&)\s|;/).length - 1;
+			if (personArr.length == 1
 				// Has typical name separators
-				(other || commas > 1
-				// If only one comma and first part has more than one space,
-				// it's probably not lastName, firstName
+				&& (other || commas > 1
+					// If only one comma and first part has more than one space,
+					// it's probably not lastName, firstName
 					|| (commas == 1 && name.split(/\s*,/)[0].indexOf(' ') != -1)
 				)
 			) {
 				// Probably multiple authors listed in a single field
 				nameStr = name;
 				break; // For clarity. personArr.length == 1 anyway
-			} else {
+			}
+			else {
 				names.push(name);
 			}
 		}
-	} 
-	catch(e) {
-		if (e.result != Components.results.NS_ERROR_FAILURE) throw e;
-		
+	}
+	catch (e) {
 		if (field != 'authors') return [];
 		
 		// ieeexplore places these in "authors"... sigh
@@ -335,7 +369,7 @@ Zotero.FeedReader._processCreators = function(feedEntry, field, role) {
 	}
 	
 	let creators = [];
-	for (let i=0; i<names.length; i++) {
+	for (let i = 0; i < names.length; i++) {
 		let creator = Zotero.Utilities.cleanAuthor(
 			names[i],
 			role,
@@ -352,22 +386,22 @@ Zotero.FeedReader._processCreators = function(feedEntry, field, role) {
 		creators.push(creator);
 	}
 	return creators;
-}
+};
 
 /*
  * Parse feed entry into a Zotero item
  */
-Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
+Zotero.FeedReader._getFeedItem = function (feedEntry, feedInfo) {
 	// ID is not required, but most feeds have these and we have to rely on them
 	// to handle updating properly
 	// Can probably fall back to links on missing id - unlikely to change
 	if (!feedEntry.id && !feedEntry.link) {
 		Zotero.debug("FeedReader: Feed item missing an ID or link - discarding");
-		return;
+		return null;
 	}
 	
 	let item = {
-		guid: feedEntry.id || feedEntry.link.spec
+		guid: feedEntry.id || feedEntry.link.href
 	};
 			
 	if (feedEntry.title) item.title = Zotero.FeedReader._getRichText(feedEntry.title, 'title');
@@ -387,14 +421,14 @@ Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
 		}
 	}
 	
-	if (feedEntry.link) item.url = feedEntry.link.spec;
+	if (feedEntry.link) item.url = feedEntry.link.href;
 	
 	if (feedEntry.rights) item.rights = Zotero.FeedReader._getRichText(feedEntry.rights, 'rights');
 	
 	item.creators = Zotero.FeedReader._processCreators(feedEntry, 'authors', 'author');
 	if (!item.creators.length) {
 		// Use feed authors as item author. Maybe not the best idea.
-		for (let i=0; i<feedInfo.creators.length; i++) {
+		for (let i = 0; i < feedInfo.creators.length; i++) {
 			if (feedInfo.creators[i].creatorType != 'author') continue;
 			item.creators.push(feedInfo.creators[i]);
 		}
@@ -426,27 +460,26 @@ Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
 	let startPage = Zotero.FeedReader._getFeedField(feedEntry, 'startPage');
 	let endPage = Zotero.FeedReader._getFeedField(feedEntry, 'endPage');
 	if (startPage || endPage) {
-		item.pages = ( startPage || '' )
-			+ ( endPage && startPage ? '–' : '' )
-			+ ( endPage || '' );
+		item.pages = (startPage || '')
+			+ (endPage && startPage ? '–' : '')
+			+ (endPage || '');
 	}
 	
 	let issn = Zotero.FeedReader._getFeedField(feedEntry, 'issn', 'prism');
 	if (issn) item.ISSN = issn;
 	
 	let isbn = Zotero.FeedReader._getFeedField(feedEntry, 'isbn', 'prism')
-		|| Zotero.FeedReader._getFeedField(feedEntry, 'isbn')
+		|| Zotero.FeedReader._getFeedField(feedEntry, 'isbn');
 	if (isbn) item.ISBN = isbn;
 	
 	let identifier = Zotero.FeedReader._getFeedField(feedEntry, 'identifier', 'dc');
 	if (identifier) {
-		let cleanId = Zotero.Utilities.cleanDOI(identifier);
-		if (cleanId) {
-			if (!item.DOI) item.DOI = cleanId;
-		} else if (cleanId = Zotero.Utilities.cleanISBN(identifier)) {
-			if (!item.ISBN) item.ISBN = cleanId;
-		} else if (cleanId = Zotero.Utilities.cleanISSN(identifier)) {
-			if (!item.ISSN) item.ISSN = cleanId;
+		for (let type of ['DOI', 'ISBN', 'ISSN']) {
+			let cleanId = Zotero.Utilities[`clean${type}`](identifier);
+			if (cleanId) {
+				if (!item[type]) item[type] = cleanId;
+				break;
+			}
 		}
 	}
 	
@@ -465,7 +498,7 @@ Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
 	/** Incorporate missing values from feed metadata **/
 	
 	let supplementFields = ['publicationTitle', 'ISSN', 'publisher', 'rights', 'language'];
-	for (let i=0; i<supplementFields.length; i++) {
+	for (let i = 0; i < supplementFields.length; i++) {
 		let field = supplementFields[i];
 		if (!item[field] && feedInfo[field]) {
 			item[field] = feedInfo[field];
@@ -477,7 +510,7 @@ Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
 	item.enclosedItems = Zotero.FeedReader._getEnclosedItems(feedEntry);
 	
 	return item;
-}
+};
 
 /*********************
  * Utility functions *
@@ -485,7 +518,7 @@ Zotero.FeedReader._getFeedItem = function(feedEntry, feedInfo) {
 /*
  * Convert HTML-formatted text to Zotero-compatible formatting
  */
-Zotero.FeedReader._getRichText = function(feedText, field) {
+Zotero.FeedReader._getRichText = function (feedText, field) {
 	let domDiv = Zotero.Utilities.Internal.getDOMDocument().createElement("div");
 	let domFragment = feedText.createDocumentFragment(domDiv);
 	return Zotero.Utilities.dom2text(domFragment, field);
@@ -497,37 +530,37 @@ Zotero.FeedReader._getRichText = function(feedText, field) {
 // Properties are stored internally as ns+name, but only some namespaces are
 // supported. Others are just "null"
 let ns = {
-	'prism': 'null',
-	'dc': 'dc:'
-}
-Zotero.FeedReader._getFeedField = function(feedEntry, field, namespace) {
+	prism: 'null',
+	dc: 'dc:'
+};
+Zotero.FeedReader._getFeedField = function (feedEntry, field, namespace) {
 	let prefix = namespace ? ns[namespace] || 'null' : '';
-	try {
-		return feedEntry.fields.getPropertyAsAUTF8String(prefix+field);
-	} catch(e) {}
+	if (feedEntry.fields[prefix + field]) {
+		return feedEntry.fields[prefix + field];
+	}
 	
-	try {
-		if (namespace && !ns[namespace]) {
-			prefix = namespace + ':';
-			return feedEntry.fields.getPropertyAsAUTF8String(prefix+field);
+	if (namespace && !ns[namespace]) {
+		prefix = namespace + ':';
+		if (feedEntry.fields[prefix + field]) {
+			return feedEntry.fields[prefix + field];
 		}
-	} catch(e) {}
+	}
 	
-	return;
-}
+	return null;
+};
 
-Zotero.FeedReader._getEnclosedItems = function(feedEntry) {
+Zotero.FeedReader._getEnclosedItems = function (feedEntry) {
 	var enclosedItems = [];
 	
 	if (feedEntry.enclosures) {
 		for (let i = 0; i < feedEntry.enclosures.length; i++) {
-			let elem = feedEntry.enclosures.queryElementAt(0, Components.interfaces.nsIPropertyBag2);
-			if (elem.get('url')) {
-				let enclosedItem = {url: elem.get('url'), contentType: elem.get('type') || ''};
+			let elem = feedEntry.enclosures[0];
+			if (elem.url) {
+				let enclosedItem = { url: elem.url, contentType: elem.type || '' };
 				enclosedItems.push(enclosedItem);
 			}
 		}
 	}
 	
 	return enclosedItems;
-}
+};
diff --git a/resource/feeds/FeedProcessor.js b/resource/feeds/FeedProcessor.js
new file mode 100644
index 0000000000..96a6427d8b
--- /dev/null
+++ b/resource/feeds/FeedProcessor.js
@@ -0,0 +1,1634 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* eslint-disable quote-props */
+/* globals SAXXMLReader */
+
+"use strict";
+
+function LOG(str) {
+	Zotero.debug("Feed Processor: " + str);
+}
+
+const XMLNS = "http://www.w3.org/XML/1998/namespace";
+const RSS090NS = "http://my.netscape.com/rdf/simple/0.9/";
+
+/** *** Some general utils *****/
+function strToURI(link, base) {
+	base = base || undefined;
+	try {
+		return new URL(link, base);
+	}
+	catch (e) {
+		return null;
+	}
+}
+
+function isArray(a) {
+	return isObject(a) && a.constructor == Array;
+}
+
+function isObject(a) {
+	return (a && typeof a == "object") || isFunction(a);
+}
+
+function isFunction(a) {
+	return typeof a == "function";
+}
+
+function stripTags(someHTML) {
+	return someHTML.replace(/<[^>]+>/g, "");
+}
+
+/**
+ * Searches through an array of links and returns a JS array
+ * of matching property bags.
+ */
+const IANA_URI = "http://www.iana.org/assignments/relation/";
+function findAtomLinks(rel, links) {
+	var rvLinks = [];
+	for (var i = 0; i < links.length; ++i) {
+		var linkElement = links[i];
+		// atom:link MUST have @href
+		if (linkElement.href) {
+			var relAttribute = null;
+			if (linkElement.rel) {
+				relAttribute = linkElement.rel;
+			}
+			if ((!relAttribute && rel == "alternate") || relAttribute == rel) {
+				rvLinks.push(linkElement);
+				continue;
+			}
+			// catch relations specified by IANA URI
+			if (relAttribute == IANA_URI + rel) {
+				rvLinks.push(linkElement);
+			}
+		}
+	}
+	return rvLinks;
+}
+
+function xmlEscape(s) {
+	s = s.replace(/&/g, "&amp;");
+	s = s.replace(/>/g, "&gt;");
+	s = s.replace(/</g, "&lt;");
+	s = s.replace(/"/g, "&quot;");
+	s = s.replace(/'/g, "&apos;");
+	return s;
+}
+
+function makePropGetter(key) {
+	return function(bag) {
+		return bag[key];
+	};
+}
+
+const RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+// namespace map
+var gNamespaces = {
+	"http://webns.net/mvcb/": "admin",
+	"http://backend.userland.com/rss": "",
+	"http://blogs.law.harvard.edu/tech/rss": "",
+	"http://www.w3.org/2005/Atom": "atom",
+	"http://purl.org/atom/ns#": "atom03",
+	"http://purl.org/rss/1.0/modules/content/": "content",
+	"http://purl.org/dc/elements/1.1/": "dc",
+	"http://purl.org/dc/terms/": "dcterms",
+	"http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
+	"http://purl.org/rss/1.0/": "rss1",
+	"http://my.netscape.com/rdf/simple/0.9/": "rss1",
+	"http://wellformedweb.org/CommentAPI/": "wfw",
+	"http://purl.org/rss/1.0/modules/wiki/": "wiki",
+	"http://www.w3.org/XML/1998/namespace": "xml",
+	"http://search.yahoo.com/mrss/": "media",
+	"http://search.yahoo.com/mrss": "media",
+};
+
+// We allow a very small set of namespaces in XHTML content,
+// for attributes only
+var gAllowedXHTMLNamespaces = {
+	"http://www.w3.org/XML/1998/namespace": "xml",
+	// if someone ns qualifies XHTML, we have to prefix it to avoid an
+	// attribute collision.
+	"http://www.w3.org/1999/xhtml": "xhtml",
+};
+
+// Implements nsIFeedResult
+function FeedResult() {}
+FeedResult.prototype = {
+	bozo: false,
+	doc: null,
+	version: null,
+	headers: null,
+	uri: null,
+	stylesheet: null,
+};
+
+// Implements nsIFeed, nsIFeedContainer
+function Feed() {
+	this.subtitle = null;
+	this.title = null;
+	this.items = [];
+	this.link = null;
+	this.id = null;
+	this.generator = null;
+	this.authors = [];
+	this.contributors = [];
+	this.baseURI = null;
+	this.enclosureCount = 0;
+	this.type = Feed.TYPE_FEED;
+}
+
+Feed.TYPE_FEED = 0;
+Feed.TYPE_AUDIO = 1;
+Feed.TYPE_IMAGE = 2;
+Feed.TYPE_VIDEO = 4;
+
+Feed.prototype = {
+	searchLists: {
+		title: ["title", "rss1:title", "atom03:title", "atom:title"],
+		subtitle: [
+			"description",
+			"dc:description",
+			"rss1:description",
+			"atom03:tagline",
+			"atom:subtitle",
+		],
+		items: ["items", "atom03_entries", "entries"],
+		id: ["atom:id", "rdf:about"],
+		generator: ["generator"],
+		authors: ["authors"],
+		contributors: ["contributors"],
+		link: [["link", strToURI], ["rss1:link", strToURI]],
+		categories: ["categories", "dc:subject"],
+		rights: ["atom03:rights", "atom:rights"],
+		cloud: ["cloud"],
+		image: ["image", "rss1:image", "atom:logo"],
+		textInput: ["textInput", "rss1:textinput"],
+		skipDays: ["skipDays"],
+		skipHours: ["skipHours"],
+		updated: [
+			"pubDate",
+			"lastBuildDate",
+			"atom03:modified",
+			"dc:date",
+			"dcterms:modified",
+			"atom:updated",
+		],
+	},
+	
+	normalize: function () {
+		fieldsToObj(this, this.searchLists);
+		if (this.skipDays) {
+			this.skipDays = this.skipDays.days;
+		}
+		if (this.skipHours) {
+			this.skipHours = this.skipHours.hours;
+		}
+		
+		if (this.updated) {
+			this.updated = dateParse(this.updated);
+		}
+		
+		// Assign Atom link if needed
+		if (this.fields.links) {
+			this._atomLinksToURI();
+		}
+		
+		this._calcEnclosureCountAndFeedType();
+		
+		// Resolve relative image links
+		if (this.image && this.image.url) {
+			this._resolveImageLink();
+		}
+		
+		this._resetBagMembersToRawText([this.searchLists.subtitle, this.searchLists.title]);
+	},
+	
+	_calcEnclosureCountAndFeedType: function () {
+		var entriesWithEnclosures = 0;
+		var audioCount = 0;
+		var imageCount = 0;
+		var videoCount = 0;
+		var otherCount = 0;
+		
+		for (var i = 0; i < this.items.length; ++i) {
+			var entry = this.items[i];
+			
+			if (entry.enclosures && entry.enclosures.length > 0) {
+				++entriesWithEnclosures;
+				
+				for (var e = 0; e < entry.enclosures.length; ++e) {
+					var enc = entry.enclosures[e];
+					if (enc.type) {
+						var enctype = enc.type;
+						
+						if (/^audio/.test(enctype)) {
+							++audioCount;
+						}
+						else if (/^image/.test(enctype)) {
+							++imageCount;
+						}
+						else if (/^video/.test(enctype)) {
+							++videoCount;
+						}
+						else {
+							++otherCount;
+						}
+					}
+					else {
+						++otherCount;
+					}
+				}
+			}
+		}
+		
+		var feedtype = Feed.TYPE_FEED;
+		
+		// For a feed to be marked as TYPE_VIDEO, TYPE_AUDIO and TYPE_IMAGE,
+		// we enforce two things:
+		//
+		//    1. all entries must have at least one enclosure
+		//    2. all enclosures must be video for TYPE_VIDEO, audio for TYPE_AUDIO or image
+		//       for TYPE_IMAGE
+		//
+		// Otherwise it's a TYPE_FEED.
+		if (entriesWithEnclosures == this.items.length && otherCount == 0) {
+			if (audioCount > 0 && !videoCount && !imageCount) {
+				feedtype = Feed.TYPE_AUDIO;
+			}
+			else if (imageCount > 0 && !audioCount && !videoCount) {
+				feedtype = Feed.TYPE_IMAGE;
+			}
+			else if (videoCount > 0 && !audioCount && !imageCount) {
+				feedtype = Feed.TYPE_VIDEO;
+			}
+		}
+		
+		this.type = feedtype;
+		this.enclosureCount = otherCount + videoCount + audioCount + imageCount;
+	},
+	
+	_atomLinksToURI: function () {
+		var links = this.fields.links;
+		var alternates = findAtomLinks("alternate", links);
+		if (alternates.length > 0) {
+			var href = alternates[0].href;
+			var base;
+			if (alternates[0]["xml:base"]) {
+				base = alternates[0]["xml:base"];
+			}
+			this.link = this._resolveURI(href, base);
+		}
+	},
+	
+	_resolveImageLink: function () {
+		var base;
+		if (this.image["xml:base"]) {
+			base = this.image["xml:base"];
+		}
+		var url = this._resolveURI(this.image.url, base);
+		if (url) {
+			this.image.url = url.href;
+		}
+	},
+	
+	_resolveURI: function (linkSpec, baseSpec) {
+		var uri = null;
+		try {
+			var base = baseSpec ? strToURI(baseSpec, this.baseURI) : this.baseURI;
+			uri = strToURI(linkSpec, base);
+		}
+		catch (e) {
+			LOG(e);
+		}
+
+		return uri;
+	},
+	
+	// reset the bag to raw contents, not text constructs
+	_resetBagMembersToRawText: function (fieldLists) {
+		for (var i = 0; i < fieldLists.length; i++) {
+			for (var j = 0; j < fieldLists[i].length; j++) {
+				if (this.fields[fieldLists[i][j]]) {
+					var textConstruct = this.fields[fieldLists[i][j]];
+					this.fields[fieldLists[i][j]] = textConstruct.text;
+				}
+			}
+		}
+	},
+};
+
+// Implements nsIFeedEntry, nsIFeedContainer
+function Entry() {
+	this.summary = null;
+	this.content = null;
+	this.title = null;
+	this.fields = {};
+	this.link = null;
+	this.id = null;
+	this.baseURI = null;
+	this.updated = null;
+	this.published = null;
+	this.authors = [];
+	this.contributors = [];
+}
+
+Entry.prototype = {
+	fields: null,
+	enclosures: null,
+	mediaContent: null,
+	
+	searchLists: {
+		title: ["title", "rss1:title", "atom03:title", "atom:title"],
+		link: [["link", strToURI], ["rss1:link", strToURI]],
+		id: [
+			["guid", makePropGetter("guid")],
+			"rdf:about",
+			"atom03:id",
+			"atom:id",
+		],
+		authors: ["authors"],
+		contributors: ["contributors"],
+		summary: [
+			"description",
+			"rss1:description",
+			"dc:description",
+			"atom03:summary",
+			"atom:summary",
+		],
+		content: ["content:encoded", "atom03:content", "atom:content"],
+		rights: ["atom03:rights", "atom:rights"],
+		published: ["pubDate", "atom03:issued", "dcterms:issued", "atom:published"],
+		updated: [
+			"pubDate",
+			"atom03:modified",
+			"dc:date",
+			"dcterms:modified",
+			"atom:updated",
+		],
+	},
+	
+	normalize: function () {
+		fieldsToObj(this, this.searchLists);
+		
+		// Assign Atom link if needed
+		if (this.fields.links) {
+			this._atomLinksToURI();
+		}
+		
+		// Populate enclosures array
+		this._populateEnclosures();
+		
+		// The link might be a guid w/ permalink=true
+		if (!this.link && this.fields.guid) {
+			var guid = this.fields.guid;
+			var isPermaLink = true;
+			
+			if (guid.isPermaLink) {
+				isPermaLink = guid.isPermaLink.toLowerCase() != "false";
+			}
+			
+			if (guid && isPermaLink) {
+				this.link = strToURI(guid.guid);
+			}
+		}
+		
+		if (this.updated) {
+			this.updated = dateParse(this.updated);
+		}
+		if (this.published) {
+			this.published = dateParse(this.published);
+		}
+		
+		this._resetBagMembersToRawText([
+			this.searchLists.content,
+			this.searchLists.summary,
+			this.searchLists.title,
+		]);
+	},
+	
+	_populateEnclosures: function () {
+		if (this.fields.links) {
+			this._atomLinksToEnclosures();
+		}
+		
+		// Add RSS2 enclosure to enclosures
+		if (this.fields.enclosure) {
+			this._enclosureToEnclosures();
+		}
+		
+		// Add media:content to enclosures
+		if (this.fields.mediacontent) {
+			this._mediaToEnclosures("mediacontent");
+		}
+		
+		// Add media:thumbnail to enclosures
+		if (this.fields.mediathumbnail) {
+			this._mediaToEnclosures("mediathumbnail");
+		}
+		
+		// Add media:content in media:group to enclosures
+		if (this.fields.mediagroup) {
+			this._mediaToEnclosures("mediagroup", "mediacontent");
+		}
+	},
+	
+	__enclosureMap: null,
+	
+	_addToEnclosures: function (newEnc) {
+		// items we add to the enclosures array get displayed in the FeedWriter and
+		// they must have non-empty urls.
+		if (!newEnc.url || newEnc.url == "") {
+			return;
+		}
+		
+		if (this.__enclosureMap === null) {
+			this.__enclosureMap = {};
+		}
+		
+		var previousEnc = this.__enclosureMap[newEnc.url];
+		
+		if (previousEnc != undefined) {
+			if (!previousEnc.type && newEnc.type) {
+				previousEnc.type = newEnc.type;
+			}
+			
+			if (!previousEnc.length && newEnc.length) {
+				previousEnc.length = newEnc.length;
+			}
+			
+			return;
+		}
+		
+		if (this.enclosures === null) {
+			this.enclosures = [];
+		}
+		
+		this.enclosures.push(newEnc);
+		this.__enclosureMap[newEnc.url] = newEnc;
+	},
+	
+	_atomLinksToEnclosures: function () {
+		var links = this.fields.links;
+		var encLinks = findAtomLinks("enclosure", links);
+		if (encLinks.length == 0) {
+			return;
+		}
+		
+		for (var i = 0; i < encLinks.length; ++i) {
+			var link = encLinks[i];
+			
+			// an enclosure must have an href
+			if (!link.href) {
+				return;
+			}
+			
+			var enc = {};
+			
+			// copy Atom bits over to equivalent enclosure bits
+			enc.url = link.href;
+			if (link.type) {
+				enc.type = link.type;
+			}
+			if (link.length) {
+				enc.length = link.length;
+			}
+			
+			this._addToEnclosures(enc);
+		}
+	},
+	
+	_enclosureToEnclosures: function () {
+		var enc = this.fields.enclosure;
+
+		if (!enc.url) {
+			return;
+		}
+
+		this._addToEnclosures(enc);
+	},
+	
+	_mediaToEnclosures: function (mediaType, contentType) {
+		var content;
+		
+		// If a contentType is specified, the mediaType is a simple propertybag,
+		// and the contentType is an array inside it.
+		if (contentType) {
+			var group = this.fields[mediaType];
+			content = group[contentType];
+		}
+		else {
+			content = this.fields[mediaType];
+		}
+		
+		for (var i = 0; i < content.length; ++i) {
+			var contentElement = content[i];
+			
+			// media:content don't require url, but if it's not there, we should
+			// skip it.
+			if (!contentElement.url) {
+				continue;
+			}
+			
+			var enc = {};
+			
+			// copy media:content bits over to equivalent enclosure bits
+			enc.url = contentElement.url;
+			if (contentElement.type) {
+				enc.type = contentElement.type;
+			}
+			else if (mediaType == "mediathumbnail") {
+				// thumbnails won't have a type, but default to image types
+				enc.type = "image/*";
+				enc.thumbnail = true;
+			}
+			
+			if (contentElement.fileSize) {
+				enc.length = contentElement.fileSize;
+			}
+			
+			this._addToEnclosures(enc);
+		}
+	},
+};
+
+Entry.prototype._atomLinksToURI = Feed.prototype._atomLinksToURI;
+Entry.prototype._resolveURI = Feed.prototype._resolveURI;
+Entry.prototype._resetBagMembersToRawText = Feed.prototype._resetBagMembersToRawText;
+
+// TextConstruct represents and element that could contain (X)HTML
+// Implements nsIFeedTextConstruct
+function TextConstruct() {
+	this.lang = null;
+	this.base = null;
+	this.type = "text";
+	this.text = null;
+}
+
+TextConstruct.prototype = {
+	plainText: function () {
+		if (this.type != "text") {
+			return stripTags(this.text);
+		}
+		return this.text;
+	},
+	
+	createDocumentFragment: function (element) {
+		if (this.type == "text") {
+			const doc = element.ownerDocument;
+			const docFragment = doc.createDocumentFragment();
+			const node = doc.createTextNode(this.text);
+			docFragment.appendChild(node);
+			return docFragment;
+		}
+		
+		let parserType;
+		if (this.type == "xhtml") {
+			parserType = "application/xhtml+xml";
+		}
+		else if (this.type == "html") {
+			parserType = "text/html";
+		}
+		else {
+			return null;
+		}
+		
+		const parsedDoc = new DOMParser().parseFromString(this.text, parserType);
+		return parsedDoc.documentElement;
+	},
+};
+
+// Generator represents the software that produced the feed
+// Implements nsIFeedGenerator, nsIFeedElementBase
+function Generator() {
+	this.lang = null;
+	this.agent = null;
+	this.version = null;
+	this.uri = null;
+	
+	// nsIFeedElementBase
+	this._attributes = null;
+	this.baseURI = null;
+}
+
+Generator.prototype = {
+	get attributes() {
+		return this._attributes;
+	},
+	
+	set attributes(value) {
+		this._attributes = value;
+		this.version = (this._attributes.getNamedItemNS("", "version") || {}).value;
+		var uriAttribute = (this._attributes.getNamedItemNS("", "uri") || {}).value
+			|| (this._attributes.getNamedItemNS("", "url") || {}).value;
+		this.uri = strToURI(uriAttribute, this.baseURI);
+		
+		// RSS1
+		uriAttribute = (this._attributes.getNamedItemNS(RDF_NS, "resource") || {}).value;
+		if (uriAttribute) {
+			this.agent = uriAttribute;
+			this.uri = strToURI(uriAttribute, this.baseURI);
+		}
+	},
+};
+
+// Implements nsIFeedPerson, nsIFeedElementBase
+function Person() {
+	this.name = null;
+	this.uri = null;
+	this.email = null;
+	
+	// nsIFeedElementBase
+	this.attributes = null;
+	this.baseURI = null;
+}
+
+/**
+ * Map a list of fields into properties on a container.
+ *
+ * @param container An nsIFeedContainer
+ * @param fields A list of fields to search for. List members can
+ *               be a list, in which case the second member is
+ *               transformation function (like parseInt).
+ */
+function fieldsToObj(container, fields) {
+	var props, prop, field, searchList;
+	for (var key in fields) {
+		searchList = fields[key];
+		for (var i = 0; i < searchList.length; ++i) {
+			props = searchList[i];
+			prop = null;
+			field = isArray(props) ? props[0] : props;
+			prop = container.fields[field];
+			if (prop) {
+				prop = isArray(props) ? props[1](prop) : prop;
+				container[key] = prop;
+			}
+		}
+	}
+}
+
+// create a generator element
+function atomGenerator(s, generator) {
+	generator.agent = s.trim();
+	return generator;
+}
+
+// post-process atom:logo to create an RSS2-like structure
+function atomLogo(s, logo) {
+	logo.url = s.trim();
+}
+
+// post-process an RSS category, map it to the Atom fields.
+function rssCatTerm(s, cat) {
+	// add slash handling?
+	cat.term = s.trim();
+	return cat;
+}
+
+// post-process a GUID
+function rssGuid(s, guid) {
+	guid.guid = s.trim();
+	return guid;
+}
+
+// post-process an RSS author element
+//
+// It can contain a field like this:
+//
+//  <author>lawyer@boyer.net (Lawyer Boyer)</author>
+//
+// or, delightfully, a field like this:
+//
+//  <dc:creator>Simon St.Laurent (mailto:simonstl@simonstl.com)</dc:creator>
+//
+// We want to split this up and assign it to corresponding Atom
+// fields.
+//
+function rssAuthor(s, author) {
+	// check for RSS2 string format
+	var chars = s.trim();
+	var matches = chars.match(/(.*)\((.*)\)/);
+	var emailCheck
+		= /^([a-zA-Z0-9_.-])+@(([a-zA-Z0-9-])+\.)+([a-zA-Z0-9]{2,4})+$/;
+	if (matches) {
+		var match1 = matches[1].trim();
+		var match2 = matches[2].trim();
+		if (match2.indexOf("mailto:") == 0) {
+			match2 = match2.substring(7);
+		}
+		if (emailCheck.test(match1)) {
+			author.email = match1;
+			author.name = match2;
+		}
+		else if (emailCheck.test(match2)) {
+			author.email = match2;
+			author.name = match1;
+		}
+		else {
+			// put it back together
+			author.name = match1 + " (" + match2 + ")";
+		}
+	}
+	else {
+		author.name = chars;
+		if (chars.indexOf("@")) {
+			author.email = chars;
+		}
+	}
+	return author;
+}
+
+/**
+ * Tries parsing a string through the JavaScript Date object.
+ * @param aDateString
+ *        A string that is supposedly an RFC822 or RFC3339 date.
+ * @return A Date.toUTCString, or null if the string can't be parsed.
+ */
+function dateParse(aDateString) {
+	let dateString = aDateString.trim();
+	// Without bug 682781 fixed, JS won't parse an RFC822 date with a Z for the
+	// timezone, so convert to -00:00 which works for any date format.
+	dateString = dateString.replace(/z$/i, "-00:00");
+	let date = new Date(dateString);
+	if (!isNaN(date)) {
+		return date.toUTCString();
+	}
+	return null;
+}
+
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+
+// The XHTMLHandler handles inline XHTML found in things like atom:summary
+function XHTMLHandler(processor, isAtom) {
+	this._buf = "";
+	this._processor = processor;
+	this._depth = 0;
+	this._isAtom = isAtom;
+	// a stack of lists tracking in-scope namespaces
+	this._inScopeNS = [];
+}
+
+// The fidelity can be improved here, to allow handling of stuff like
+// SVG and MathML. XXX
+XHTMLHandler.prototype = {
+	
+	// look back up at the declared namespaces
+	// we always use the same prefixes for our safe stuff
+	_isInScope: function (ns) {
+		for (var i in this._inScopeNS) {
+			for (var uri in this._inScopeNS[i]) {
+				if (this._inScopeNS[i][uri] == ns) {
+					return true;
+				}
+			}
+		}
+		return false;
+	},
+	
+	startDocument: function () {
+	},
+	endDocument: function () {
+	},
+	startElement: function (namespace, localName, qName, attributes) {
+		++this._depth;
+		this._inScopeNS.push([]);
+		
+		// RFC4287 requires XHTML to be wrapped in a div that is *not* part of
+		// the content. This prevents people from screwing up namespaces, but
+		// we need to skip it here.
+		if (this._isAtom && this._depth == 1 && localName == "div") {
+			return;
+		}
+		
+		// If it's an XHTML element, record it. Otherwise, it's ignored.
+		if (namespace == XHTML_NS) {
+			this._buf += "<" + localName;
+			var uri;
+			for (var i = 0; i < attributes.length; ++i) {
+				uri = attributes.item(i).namespaceURI;
+				// XHTML attributes aren't in a namespace
+				if (uri == "") {
+					this._buf += (" " + attributes.item(i).localName + "='"
+						+ xmlEscape(attributes.item(i).value) + "'");
+				}
+				else {
+					// write a small set of allowed attribute namespaces
+					var prefix = gAllowedXHTMLNamespaces[uri];
+					if (prefix) {
+						// The attribute value we'll attempt to write
+						var attributeValue = xmlEscape(attributes.item(i).value);
+						
+						// it's an allowed attribute NS.
+						// write the attribute
+						this._buf += (" " + prefix + ":"
+													+ attributes.item(i).localName
+													+ "='" + attributeValue + "'");
+						
+						// write an xmlns declaration if necessary
+						if (prefix != "xml" && !this._isInScope(uri)) {
+							this._inScopeNS[this._inScopeNS.length - 1].push(uri);
+							this._buf += " xmlns:" + prefix + "='" + uri + "'";
+						}
+					}
+				}
+			}
+			this._buf += ">";
+		}
+	},
+	endElement: function (uri, localName, qName) {
+		--this._depth;
+		this._inScopeNS.pop();
+		
+		// We need to skip outer divs in Atom. See comment in startElement.
+		if (this._isAtom && this._depth == 0 && localName == "div") {
+			return;
+		}
+		
+		// When we peek too far, go back to the main processor
+		if (this._depth < 0) {
+			this._processor.returnFromXHTMLHandler(this._buf.trim(), uri, localName, qName);
+			return;
+		}
+		// If it's an XHTML element, record it. Otherwise, it's ignored.
+		if (uri == XHTML_NS) {
+			this._buf += "</" + localName + ">";
+		}
+	},
+	characters: function (data) {
+		this._buf += xmlEscape(data);
+	},
+	processingInstruction: function () {
+	},
+};
+
+/**
+ * The ExtensionHandler deals with elements we haven't explicitly
+ * added to our transition table in the FeedProcessor.
+ */
+function ExtensionHandler(processor) {
+	this._buf = "";
+	this._depth = 0;
+	this._hasChildElements = false;
+	
+	// The FeedProcessor
+	this._processor = processor;
+	
+	// Fields of the outermost extension element.
+	this._localName = null;
+	this._uri = null;
+	this._qName = null;
+	this._attrs = null;
+}
+
+ExtensionHandler.prototype = {
+	startDocument: function () {
+	},
+	endDocument: function () {
+	},
+	startElement: function (uri, localName, qName, attrs) {
+		++this._depth;
+		
+		if (this._depth == 1) {
+			this._uri = uri;
+			this._localName = localName;
+			this._qName = qName;
+			this._attrs = attrs;
+		}
+		
+		// if we descend into another element, we won't send text
+		this._hasChildElements = (this._depth > 1);
+	},
+	endElement: function (_uri, _localName, _qName) {
+		--this._depth;
+		if (this._depth == 0) {
+			var text = this._hasChildElements ? null : this._buf.trim();
+			this._processor.returnFromExtHandler(this._uri, this._localName, text, this._attrs);
+		}
+	},
+	characters: function (data) {
+		if (!this._hasChildElements) {
+			this._buf += data;
+		}
+	},
+	processingInstruction: function () {
+	},
+};
+
+
+/**
+ * ElementInfo is a simple container object that describes
+ * some characteristics of a feed element. For example, it
+ * says whether an element can be expected to appear more
+ * than once inside a given entry or feed.
+ */
+function ElementInfo(fieldName, containerClass, closeFunc, isArray) {
+	this.fieldName = fieldName;
+	this.containerClass = containerClass;
+	this.closeFunc = closeFunc;
+	this.isArray = isArray;
+	this.isWrapper = false;
+}
+
+/**
+ * FeedElementInfo represents a feed element, usually the root.
+ */
+function FeedElementInfo(fieldName, feedVersion) {
+	this.isWrapper = false;
+	this.fieldName = fieldName;
+	this.feedVersion = feedVersion;
+}
+
+/**
+ * Some feed formats include vestigial wrapper elements that we don't
+ * want to include in our object model, but we do need to keep track
+ * of during parsing.
+ */
+function WrapperElementInfo(fieldName) {
+	this.isWrapper = true;
+	this.fieldName = fieldName;
+}
+
+/** *** The Processor *****/
+// Implements nsIFeedProcessor, nsISAXContentHandler, nsISAXErrorHandler,
+//            nsIStreamListener, nsIRequestObserver
+function FeedProcessor() {
+	this._reader = new SAXXMLReader();
+	this._buf = "";
+	this._feed = {};
+	this._handlerStack = [];
+	this._xmlBaseStack = []; // sparse array keyed to nesting depth
+	this._depth = 0;
+	this._state = "START";
+	this._result = null;
+	this._extensionHandler = null;
+	this._xhtmlHandler = null;
+	this._haveSentResult = false;
+	
+	// The nsIFeedResultListener waiting for the parse results
+	this.listener = null;
+	
+	// These elements can contain (X)HTML or plain text.
+	// We keep a table here that contains their default treatment
+	this._textConstructs = {
+		"atom:title": "text",
+		"atom:summary": "text",
+		"atom:rights": "text",
+		"atom:content": "text",
+		"atom:subtitle": "text",
+		"description": "html",
+		"rss1:description": "html",
+		"dc:description": "html",
+		"content:encoded": "html",
+		"title": "text",
+		"rss1:title": "text",
+		"atom03:title": "text",
+		"atom03:tagline": "text",
+		"atom03:summary": "text",
+		"atom03:content": "text"
+	};
+	this._stack = [];
+	
+	this._trans = {
+		"START": {
+			// If we hit a root RSS element, treat as RSS2.
+			"rss": new FeedElementInfo("RSS2", "rss2"),
+			
+			// If we hit an RDF element, if could be RSS1, but we can't
+			// verify that until we hit a rss1:channel element.
+			"rdf:RDF": new WrapperElementInfo("RDF"),
+			
+			// If we hit a Atom 1.0 element, treat as Atom 1.0.
+			"atom:feed": new FeedElementInfo("Atom", "atom"),
+			
+			// Treat as Atom 0.3
+			"atom03:feed": new FeedElementInfo("Atom03", "atom03"),
+		},
+		
+		/** ******* RSS2 **********/
+		"IN_RSS2": {
+			"channel": new WrapperElementInfo("channel"),
+		},
+		
+		"IN_CHANNEL": {
+			"item": new ElementInfo("items", Entry, null, true),
+			"managingEditor": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:creator": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:author": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:contributor": new ElementInfo("contributors", Person, rssAuthor, true),
+			"category": new ElementInfo("categories", null, rssCatTerm, true),
+			"cloud": new ElementInfo("cloud", null, null, false),
+			"image": new ElementInfo("image", null, null, false),
+			"textInput": new ElementInfo("textInput", null, null, false),
+			"skipDays": new ElementInfo("skipDays", null, null, false),
+			"skipHours": new ElementInfo("skipHours", null, null, false),
+			"generator": new ElementInfo("generator", Generator, atomGenerator, false),
+		},
+		
+		"IN_ITEMS": {
+			"author": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:creator": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:author": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:contributor": new ElementInfo("contributors", Person, rssAuthor, true),
+			"category": new ElementInfo("categories", null, rssCatTerm, true),
+			"enclosure": new ElementInfo("enclosure", null, null, false),
+			"media:content": new ElementInfo("mediacontent", null, null, true),
+			"media:group": new ElementInfo("mediagroup", null, null, false),
+			"media:thumbnail": new ElementInfo("mediathumbnail", null, null, true),
+			"guid": new ElementInfo("guid", null, rssGuid, false),
+		},
+		
+		"IN_SKIPDAYS": {
+			"day": new ElementInfo("days", null, null, true),
+		},
+		
+		"IN_SKIPHOURS": {
+			"hour": new ElementInfo("hours", null, null, true),
+		},
+		
+		"IN_MEDIAGROUP": {
+			"media:content": new ElementInfo("mediacontent", null, null, true),
+			"media:thumbnail": new ElementInfo("mediathumbnail", null, null, true),
+		},
+		
+		/** ******* RSS1 **********/
+		"IN_RDF": {
+			// If we hit a rss1:channel, we can verify that we have RSS1
+			"rss1:channel": new FeedElementInfo("rdf_channel", "rss1"),
+			"rss1:image": new ElementInfo("image", null, null, false),
+			"rss1:textinput": new ElementInfo("textInput", null, null, false),
+			"rss1:item": new ElementInfo("items", Entry, null, true),
+		},
+		
+		"IN_RDF_CHANNEL": {
+			"admin:generatorAgent": new ElementInfo("generator", Generator, null, false),
+			"dc:creator": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:author": new ElementInfo("authors", Person, rssAuthor, true),
+			"dc:contributor": new ElementInfo("contributors", Person, rssAuthor, true),
+		},
+		
+		/** ******* ATOM 1.0 **********/
+		"IN_ATOM": {
+			"atom:author": new ElementInfo("authors", Person, null, true),
+			"atom:generator": new ElementInfo("generator", Generator, atomGenerator, false),
+			"atom:contributor": new ElementInfo("contributors", Person, null, true),
+			"atom:link": new ElementInfo("links", null, null, true),
+			"atom:logo": new ElementInfo("atom:logo", null, atomLogo, false),
+			"atom:entry": new ElementInfo("entries", Entry, null, true),
+		},
+		
+		"IN_ENTRIES": {
+			"atom:author": new ElementInfo("authors", Person, null, true),
+			"atom:contributor": new ElementInfo("contributors", Person, null, true),
+			"atom:link": new ElementInfo("links", null, null, true),
+		},
+		
+		/** ******* ATOM 0.3 **********/
+		"IN_ATOM03": {
+			"atom03:author": new ElementInfo("authors", Person, null, true),
+			"atom03:contributor": new ElementInfo("contributors", Person, null, true),
+			"atom03:link": new ElementInfo("links", null, null, true),
+			"atom03:entry": new ElementInfo("atom03_entries", Entry, null, true),
+			"atom03:generator": new ElementInfo("generator", Generator, atomGenerator, false),
+		},
+		
+		"IN_ATOM03_ENTRIES": {
+			"atom03:author": new ElementInfo("authors", Person, null, true),
+			"atom03:contributor": new ElementInfo("contributors", Person, null, true),
+			"atom03:link": new ElementInfo("links", null, null, true),
+			"atom03:entry": new ElementInfo("atom03_entries", Entry, null, true),
+		},
+	};
+}
+
+// See startElement for a long description of how feeds are processed.
+FeedProcessor.prototype = {
+	// Set ourselves as the SAX handler, and set the base URI
+	_init: function (uri) {
+		this._reader.contentHandler = this;
+		this._reader.errorHandler = this;
+		this._result = new FeedResult();
+		if (uri) {
+			this._result.uri = uri;
+			this._reader.baseURI = uri;
+			this._xmlBaseStack[0] = uri;
+		}
+	},
+	
+	// This function is called once we figure out what type of feed
+	// we're dealing with. Some feed types require digging a bit further
+	// than the root.
+	_docVerified: function (version) {
+		this._result.doc = new Feed();
+		this._result.doc.baseURI
+			= this._xmlBaseStack[this._xmlBaseStack.length - 1];
+		this._result.doc.fields = this._feed;
+		this._result.version = version;
+	},
+	
+	// When we're done with the feed, let the listener know what
+	// happened.
+	_sendResult: function () {
+		this._haveSentResult = true;
+		try {
+			// Can be null when a non-feed is fed to us
+			if (this._result.doc) {
+				this._result.doc.normalize();
+			}
+		}
+		catch (e) {
+			LOG("FIXME: " + e);
+		}
+		
+		try {
+			if (this.listener !== null) {
+				this.listener.handleResult(this._result);
+			}
+		}
+		finally {
+			this._result = null;
+		}
+	},
+	
+	// Parsing functions
+	parseAsync: function (requestObserver, uri) {
+		this._init(uri);
+		this._reader.parseAsync(requestObserver);
+	},
+	
+	// Fetch API
+	
+	onResponseAvailable(response) {
+		return this._reader.onResponseAvailable(response);
+	},
+	
+	// nsISAXErrorHandler
+	
+	// We only care about fatal errors. When this happens, we may have
+	// parsed through the feed metadata and some number of entries. The
+	// listener can still show some of that data if it wants, and we'll
+	// set the bozo bit to indicate we were unable to parse all the way
+	// through.
+	fatalError: function () {
+		this._result.bozo = true;
+		// XXX need to QI to FeedProgressListener
+		if (!this._haveSentResult) {
+			this._sendResult();
+		}
+	},
+	
+	// nsISAXContentHandler
+	
+	startDocument: function () {
+		// LOG("----------");
+	},
+	
+	endDocument: function () {
+		if (!this._haveSentResult) {
+			this._sendResult();
+		}
+	},
+	
+	// The transitions defined above identify elements that contain more
+	// than just text. For example RSS items contain many fields, and so
+	// do Atom authors. The only commonly used elements that contain
+	// mixed content are Atom Text Constructs of type="xhtml", which we
+	// delegate to another handler for cleaning. That leaves a couple
+	// different types of elements to deal with: those that should occur
+	// only once, such as title elements, and those that can occur
+	// multiple times, such as the RSS category element and the Atom
+	// link element. Most of the RSS1/DC elements can occur multiple
+	// times in theory, but in practice, the only ones that do have
+	// analogues in Atom.
+	//
+	// Some elements are also groups of attributes or sub-elements,
+	// while others are simple text fields. For the most part, we don't
+	// have to pay explicit attention to the simple text elements,
+	// unless we want to post-process the resulting string to transform
+	// it into some richer object like a Date or URI.
+	//
+	// Elements that have more sophisticated content models still end up
+	// being dictionaries, whether they are based on attributes like RSS
+	// cloud, sub-elements like Atom author, or even items and
+	// entries. These elements are treated as "containers". It's
+	// theoretically possible for a container to have an attribute with
+	// the same universal name as a sub-element, but none of the feed
+	// formats allow this by default, and I don't of any extension that
+	// works this way.
+	//
+	startElement: function (uri, localName, qName, attributes) {
+		this._buf = "";
+		++this._depth;
+		var elementInfo;
+		
+		// LOG("<" + localName + ">");
+		
+		// Check for xml:base
+		var base = (attributes.getNamedItemNS(XMLNS, "base") || {}).value;
+		if (base) {
+			this._xmlBaseStack[this._depth]
+				= strToURI(base, this._xmlBaseStack[this._xmlBaseStack.length - 1]);
+		}
+		
+		// To identify the element we're dealing with, we look up the
+		// namespace URI in our gNamespaces dictionary, which will give us
+		// a "canonical" prefix for a namespace URI. For example, this
+		// allows Dublin Core "creator" elements to be consistently mapped
+		// to "dc:creator", for easy field access by consumer code. This
+		// strategy also happens to shorten up our state table.
+		var key = this._prefixForNS(uri) + localName;
+		
+		// Check to see if we need to hand this off to our XHTML handler.
+		// The elements we're dealing with will look like this:
+		//
+		// <title type="xhtml">
+		//   <div xmlns="http://www.w3.org/1999/xhtml">
+		//     A title with <b>bold</b> and <i>italics</i>.
+		//   </div>
+		// </title>
+		//
+		// When it returns in returnFromXHTMLHandler, the handler should
+		// give us back a string like this:
+		//
+		//    "A title with <b>bold</b> and <i>italics</i>."
+		//
+		// The Atom spec explicitly says the div is not part of the content,
+		// and explicitly allows whitespace collapsing.
+		//
+		if ((this._result.version == "atom" || this._result.version == "atom03")
+				&& this._textConstructs[key]) {
+			var type = (attributes.getNamedItemNS("", "type") || {}).value;
+			if (type && type.includes("xhtml")) {
+				this._xhtmlHandler
+					= new XHTMLHandler(this, (this._result.version == "atom"));
+				this._reader.contentHandler = this._xhtmlHandler;
+				return;
+			}
+		}
+		
+		// Check our current state, and see if that state has a defined
+		// transition. For example, this._trans["atom:entry"]["atom:author"]
+		// will have one, and it tells us to add an item to our authors array.
+		if (this._trans[this._state] && this._trans[this._state][key]) {
+			elementInfo = this._trans[this._state][key];
+		}
+		else {
+			// If we don't have a transition, hand off to extension handler
+			this._extensionHandler = new ExtensionHandler(this);
+			this._reader.contentHandler = this._extensionHandler;
+			this._extensionHandler.startElement(uri, localName, qName, attributes);
+			return;
+		}
+		
+		// This distinguishes wrappers like 'channel' from elements
+		// we'd actually like to do something with (which will test true).
+		this._handlerStack[this._depth] = elementInfo;
+		if (elementInfo.isWrapper) {
+			this._state = "IN_" + elementInfo.fieldName.toUpperCase();
+			this._stack.push([this._feed, this._state]);
+		}
+		else if (elementInfo.feedVersion) {
+			this._state = "IN_" + elementInfo.fieldName.toUpperCase();
+			
+			// Check for the older RSS2 variants
+			if (elementInfo.feedVersion == "rss2") {
+				elementInfo.feedVersion = this._findRSSVersion(attributes);
+			}
+			else if (uri == RSS090NS) {
+				elementInfo.feedVersion = "rss090";
+			}
+			
+			this._docVerified(elementInfo.feedVersion);
+			this._stack.push([this._feed, this._state]);
+			this._mapAttributes(this._feed, attributes);
+		}
+		else {
+			this._state = this._processComplexElement(elementInfo, attributes);
+		}
+	},
+	
+	// In the endElement handler, we decrement the stack and look
+	// for cleanup/transition functions to execute. The second part
+	// of the state transition works as above in startElement, but
+	// the state we're looking for is prefixed with an underscore
+	// to distinguish endElement events from startElement events.
+	endElement: function (_uri, _localName, _qName) {
+		var elementInfo = this._handlerStack[this._depth];
+		// LOG("</" + localName + ">");
+		if (elementInfo && !elementInfo.isWrapper) {
+			this._closeComplexElement(elementInfo);
+		}
+		
+		// cut down xml:base context
+		if (this._xmlBaseStack.length == this._depth + 1) {
+			this._xmlBaseStack = this._xmlBaseStack.slice(0, this._depth);
+		}
+		
+		// our new state is whatever is at the top of the stack now
+		if (this._stack.length > 0) {
+			this._state = this._stack[this._stack.length - 1][1];
+		}
+		this._handlerStack = this._handlerStack.slice(0, this._depth);
+		--this._depth;
+	},
+	
+	// Buffer up character data. The buffer is cleared with every
+	// opening element.
+	characters: function (data) {
+		this._buf += data;
+	},
+	
+	processingInstruction: function (target, data) {
+		if (target == "xml-stylesheet") {
+			var hrefAttribute = data.match(/href=["'](.*?)["']/);
+			if (hrefAttribute && hrefAttribute.length == 2) {
+				this._result.stylesheet = strToURI(hrefAttribute[1], this._result.uri);
+			}
+		}
+	},
+	
+	// end of nsISAXContentHandler
+	
+	// Handle our more complicated elements--those that contain
+	// attributes and child elements.
+	_processComplexElement: function (elementInfo, attributes) {
+		var obj;
+		
+		// If the container is an entry/item, it'll need to have its
+		// more esoteric properties put in the 'fields' property bag.
+		const Class = elementInfo.containerClass;
+		if (Class == Entry) {
+			obj = new Class();
+			obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
+			this._mapAttributes(obj.fields, attributes);
+		}
+		else if (elementInfo.containerClass) {
+			obj = new Class();
+			obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
+			obj.attributes = attributes; // just set the SAX attributes
+		}
+		else {
+			obj = {};
+			this._mapAttributes(obj, attributes);
+		}
+		
+		// We should have a container/propertyBag that's had its
+		// attributes processed. Now we need to attach it to its
+		// container.
+		var newProp;
+		
+		// First we'll see what's on top of the stack.
+		var container = this._stack[this._stack.length - 1][0];
+		
+		// Check to see if it has the property
+		var prop = container[elementInfo.fieldName];
+		
+		if (elementInfo.isArray) {
+			if (!prop) {
+				container[elementInfo.fieldName] = [];
+			}
+			
+			newProp = container[elementInfo.fieldName];
+			newProp.push(obj);
+			
+			// If new object is an nsIFeedContainer, we want to deal with
+			// its member nsIPropertyBag instead.
+			if (obj.fields) {
+				newProp = obj.fields;
+			}
+		}
+		else {
+			// If it doesn't, set it.
+			if (!prop) {
+				container[elementInfo.fieldName] = obj;
+			}
+			newProp = container[elementInfo.fieldName];
+		}
+		
+		// make our new state name, and push the property onto the stack
+		var newState = "IN_" + elementInfo.fieldName.toUpperCase();
+		this._stack.push([newProp, newState, obj]);
+		return newState;
+	},
+	
+	// Sometimes we need reconcile the element content with the object
+	// model for a given feed. We use helper functions to do the
+	// munging, but we need to identify array types here, so the munging
+	// happens only to the last element of an array.
+	_closeComplexElement: function (elementInfo) {
+		var stateTuple = this._stack.pop();
+		var container = stateTuple[0];
+		var containerParent = stateTuple[2];
+		var element = null;
+		
+		// If it's an array and we have to post-process,
+		// grab the last element
+		if (isArray(container)) {
+			element = container[container.length - 1];
+		}
+		else {
+			element = container;
+		}
+		
+		// Run the post-processing function if there is one.
+		if (elementInfo.closeFunc) {
+			element = elementInfo.closeFunc(this._buf, element);
+		}
+		
+		// If an nsIFeedContainer was on top of the stack,
+		// we need to normalize it
+		if (elementInfo.containerClass == Entry) {
+			containerParent.normalize();
+		}
+		
+		// If it's an array, re-set the last element
+		if (isArray(container)) {
+			container[container.length - 1] = element;
+		}
+	},
+	
+	_prefixForNS: function (uri) {
+		if (!uri) {
+			return "";
+		}
+		var prefix = gNamespaces[uri];
+		if (prefix) {
+			return prefix + ":";
+		}
+		if (uri.toLowerCase().indexOf("http://backend.userland.com") == 0) {
+			return "";
+		}
+		return null;
+	},
+	
+	_mapAttributes: function (bag, attributes) {
+		// Cycle through the attributes, and set our properties using the
+		// prefix:localNames we find in our namespace dictionary.
+		for (var i = 0; i < attributes.length; ++i) {
+			var key = this._prefixForNS(attributes.item(i).namespaceURI) + attributes.item(i).localName;
+			var val = attributes.item(i).value;
+			bag[key] = val;
+		}
+	},
+	
+	// Only for RSS2esque formats
+	_findRSSVersion: function (attributes) {
+		var versionAttr = (attributes.getNamedItemNS("", "version") || {}).value.trim();
+		var versions = {
+			"0.91": "rss091",
+			"0.92": "rss092",
+			"0.93": "rss093",
+			"0.94": "rss094"
+		};
+		if (versions[versionAttr]) {
+			return versions[versionAttr];
+		}
+		if (versionAttr.substr(0, 2) != "2.") {
+			return "rssUnknown";
+		}
+		return "rss2";
+	},
+	
+	// unknown element values are returned here. See startElement above
+	// for how this works.
+	returnFromExtHandler: function (uri, localName, chars, attributes) {
+		--this._depth;
+		
+		// take control of the SAX events
+		this._reader.contentHandler = this;
+		if (localName === null && chars === null) {
+			return;
+		}
+		
+		// we don't take random elements inside rdf:RDF
+		if (this._state == "IN_RDF") {
+			return;
+		}
+		
+		// Grab the top of the stack
+		var top = this._stack[this._stack.length - 1];
+		if (!top) {
+			return;
+		}
+		
+		var container = top[0];
+		// Grab the last element if it's an array
+		if (isArray(container)) {
+			var contract = this._handlerStack[this._depth].containerClass;
+			// check if it's something specific, but not an entry
+			if (contract && contract != Entry) {
+				var el = container[container.length - 1];
+				if (contract != Person) {
+					return; // don't know about this interface
+				}
+				
+				let propName = localName;
+				var prefix = gNamespaces[uri];
+				
+				// synonyms
+				if (
+					(uri == ""
+						|| prefix
+						&& ((prefix.indexOf("atom") > -1)
+							|| (prefix.indexOf("rss") > -1)))
+					&& (propName == "url" || propName == "href")
+				) {
+					propName = "uri";
+				}
+				
+				try {
+					if (el[propName] !== "undefined") {
+						var propValue = chars;
+						// convert URI-bearing values to an nsIURI
+						if (propName == "uri") {
+							var base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
+							propValue = strToURI(chars, base);
+						}
+						el[propName] = propValue;
+					}
+				}
+				catch (e) {
+					// ignore XPConnect errors
+				}
+				// the rest of the function deals with entry- and feed-level stuff
+				return;
+			}
+			container = container[container.length - 1];
+		}
+		
+		// Make the buffer our new property
+		var propName = this._prefixForNS(uri) + localName;
+		
+		// But, it could be something containing HTML. If so,
+		// we need to know about that.
+		if (this._textConstructs[propName]
+				&& this._handlerStack[this._depth].containerClass !== null) {
+			var newProp = new TextConstruct();
+			newProp.text = chars;
+			// Look up the default type in our table
+			var type = this._textConstructs[propName];
+			var typeAttribute = (attributes.getNamedItemNS("", "type") || {}).value;
+			if (this._result.version == "atom" && typeAttribute) {
+				type = typeAttribute;
+			}
+			else if (this._result.version == "atom03" && typeAttribute) {
+				if (typeAttribute.toLowerCase().includes("xhtml")) {
+					type = "xhtml";
+				}
+				else if (typeAttribute.toLowerCase().includes("html")) {
+					type = "html";
+				}
+				else if (typeAttribute.toLowerCase().includes("text")) {
+					type = "text";
+				}
+			}
+			
+			// If it's rss feed-level description, it's not supposed to have html
+			if (this._result.version.includes("rss")
+					&& this._handlerStack[this._depth].containerClass != Entry) {
+				type = "text";
+			}
+			newProp.type = type;
+			newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
+			container[propName] = newProp;
+		}
+		else {
+			container[propName] = chars;
+		}
+	},
+	
+	// Sometimes, we'll hand off SAX handling duties to an XHTMLHandler
+	// (see above) that will scrape out non-XHTML stuff, normalize
+	// namespaces, and remove the wrapper div from Atom 1.0. When the
+	// XHTMLHandler is done, it'll callback here.
+	returnFromXHTMLHandler: function (chars, uri, localName, qName) {
+		// retake control of the SAX content events
+		this._reader.contentHandler = this;
+		
+		// Grab the top of the stack
+		var top = this._stack[this._stack.length - 1];
+		if (!top) {
+			return;
+		}
+		var container = top[0];
+		
+		// Assign the property
+		var newProp = new TextConstruct();
+		newProp.text = chars;
+		newProp.type = "xhtml";
+		newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
+		container[this._prefixForNS(uri) + localName] = newProp;
+		
+		// XHTML will cause us to peek too far. The XHTML handler will
+		// send us an end element to call. RFC4287-valid feeds allow a
+		// more graceful way to handle this. Unfortunately, we can't count
+		// on compliance at this point.
+		this.endElement(uri, localName, qName);
+	},
+};
+
+if (typeof module == "object") {
+	module.exports = FeedProcessor;
+}
diff --git a/resource/feeds/SAXXMLReader.js b/resource/feeds/SAXXMLReader.js
new file mode 100644
index 0000000000..b1cf4413eb
--- /dev/null
+++ b/resource/feeds/SAXXMLReader.js
@@ -0,0 +1,140 @@
+/*
+    ***** BEGIN LICENSE BLOCK *****
+
+    Copyright © 2021 Corporation for Digital Scholarship
+                     Vienna, Virginia, USA
+                     https://www.zotero.org
+
+    This file is part of Zotero.
+
+    Zotero is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Zotero is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+
+    ***** END LICENSE BLOCK *****
+*/
+
+"use strict";
+
+/**
+ * This implements `nsISAXXMLReader` using content-accessible APIs, such as `DOMParser` and
+ * `TreeWalker`. It should be usable in any web platform environment that supports those standard
+ * APIs.
+ * 
+ * Note that while this class implements a SAX-style API (which usually implies streaming style
+ * parsing for documents of any length), this class actually uses whole document parsing internally.
+ * Instead, `DOMParser` reads the entire document and this walks the resulting DOM. Thus, this class
+ * is mainly useful only for smaller documents where it's useful to conform to SAX-style API to
+ * support existing code.
+ * 
+ * Higher-level components are notified of XML content via the `nsISAXContentHandler` and
+ * `nsISAXErrorHandler` interfaces as this reader walks through the XML content.
+ */
+class SAXXMLReader {
+	constructor() {
+		this.contentHandler = null;
+		this.errorHandler = null;
+		this.baseURI = null;
+		this._data = null;
+		this._walker = null;
+	}
+	
+	// nsISAXXMLReader
+	
+	parseAsync(requestObserver) {
+		if (requestObserver) {
+			throw new Error("requestObserver argument parseAsync is not currently supported");
+		}
+	}
+	
+	// Fetch API
+
+	async onResponseAvailable(response) {
+		if (!response.ok) {
+			throw new Error("Unable to fetch data");
+		}
+		this._data = await response.text();
+		this._parseAndNotify();
+	}
+	
+	// Parsing and notification
+	
+	_parseAndNotify() {
+		if (!this.contentHandler) {
+			return;
+		}
+		
+		const doc = new DOMParser().parseFromString(this._data, "text/xml");
+		this._walker = doc.createTreeWalker(doc.documentElement);
+		
+		this.contentHandler.startDocument();
+		this._walk();
+		this.contentHandler.endDocument();
+		
+		this._data = null;
+		this._walker = null;
+	}
+	
+	_walk() {
+		const node = this._walker.currentNode;
+		
+		switch (node.nodeType) {
+			// ELEMENT_NODE
+			case 1: {
+				this.contentHandler.startElement(
+					node.namespaceURI,
+					node.localName,
+					"", // qualifed names are not used
+					node.attributes,
+				);
+				
+				// Try to move down
+				if (this._walker.firstChild()) {
+					this._walk();
+					// Move up
+					this._walker.parentNode();
+				}
+				
+				this.contentHandler.endElement(
+					node.namespaceURI,
+					node.localName,
+					"", // qualifed names are not used
+				);
+				break;
+			}
+			// TEXT_NODE
+			case 3: {
+				this.contentHandler.characters(node.data);
+				break;
+			}
+			// CDATA_SECTION_NODE
+			case 4: {
+				this.contentHandler.characters(node.data);
+				break;
+			}
+			// PROCESSING_INSTRUCTION_NODE
+			case 7: {
+				this.contentHandler.processingInstruction(node.target, node.data);
+				break;
+			}
+		}
+
+		// Try to move across
+		if (this._walker.nextSibling()) {
+			this._walk();
+		}
+	}
+}
+
+if (typeof module == "object") {
+	module.exports = SAXXMLReader;
+}
diff --git a/resource/feeds/nsIFeed.idl b/resource/feeds/nsIFeed.idl
new file mode 100644
index 0000000000..c1156016a9
--- /dev/null
+++ b/resource/feeds/nsIFeed.idl
@@ -0,0 +1,85 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFeedContainer.idl"
+
+interface nsIArray;
+interface nsIFeedGenerator;
+
+/**
+ * An nsIFeed represents a single Atom or RSS feed.
+ */
+[scriptable, uuid(3b8aae33-80e2-4efa-99c8-a6c5b99f76ea)]
+interface nsIFeed : nsIFeedContainer
+{
+	/** 
+	* Uses description, subtitle, and extensions
+	* to generate a summary. 
+	*/
+	attribute nsIFeedTextConstruct subtitle;
+
+	// All content classifies as a "feed" - it is the transport.
+	const unsigned long TYPE_FEED = 0;
+	const unsigned long TYPE_AUDIO = 1;
+	const unsigned long TYPE_IMAGE = 2;
+	const unsigned long TYPE_VIDEO = 4;
+
+	/**
+	* The type of feed. For example, a podcast would be TYPE_AUDIO.
+	*/
+	readonly attribute unsigned long type;
+	
+	/**
+	* The total number of enclosures found in the feed.
+	*/
+	attribute long enclosureCount;
+
+	/**
+	* The items or entries in feed.
+	*/
+	attribute nsIArray items;
+
+	/**
+	* No one really knows what cloud is for.
+	*
+	* It supposedly enables some sort of interaction with an XML-RPC or
+	* SOAP service.
+	*/
+	attribute nsIWritablePropertyBag2 cloud;
+
+	/**
+	* Information about the software that produced the feed.
+	*/
+	attribute nsIFeedGenerator generator;
+
+	/**
+	* An image url and some metadata (as defined by RSS2).
+	*
+	*/
+	attribute nsIWritablePropertyBag2 image;
+
+	/**
+	* No one really knows what textInput is for.
+	*
+	* See
+	* <http://www.cadenhead.org/workbench/news/2894/rss-joy-textinput>
+	* for more details.
+	*/
+	attribute nsIWritablePropertyBag2 textInput;
+
+	/**
+	* Days to skip fetching. This field was supposed to designate
+	* intervals for feed fetching. It's not generally implemented. For
+	* example, if this array contained "Monday", aggregators should not
+	* fetch the feed on Mondays.
+	*/
+	attribute nsIArray skipDays;
+
+ /**
+	* Hours to skip fetching. This field was supposed to designate
+	* intervals for feed fetching. It's not generally implemented. See
+	* <http://blogs.law.harvard.edu/tech/rss> for more information.
+	*/
+	attribute nsIArray skipHours;
+};
diff --git a/resource/feeds/nsIFeedContainer.idl b/resource/feeds/nsIFeedContainer.idl
new file mode 100644
index 0000000000..00bc32cbfe
--- /dev/null
+++ b/resource/feeds/nsIFeedContainer.idl
@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFeedElementBase.idl"
+
+interface nsIURI;
+interface nsIWritablePropertyBag2;
+interface nsIArray;
+interface nsIFeedTextConstruct;
+
+/**
+ * A shared base for feeds and items, which are pretty similar,
+ * but they have some divergent attributes and require
+ * different convenience methods.
+ */ 
+[scriptable, uuid(577a1b4c-b3d4-4c76-9cf8-753e6606114f)]
+interface nsIFeedContainer : nsIFeedElementBase
+{
+	/**
+	* Many feeds contain an ID distinct from their URI, and
+	* entries have standard fields for this in all major formats.
+	*/
+	attribute AString id;
+
+	/**
+	* The fields found in the document. Common Atom
+	* and RSS fields are normalized. This includes some namespaced
+	* extensions such as dc:subject and content:encoded. 
+	* Consumers can avoid normalization by checking the feed type
+	* and accessing specific fields.
+	*
+	* Common namespaces are accessed using prefixes, like get("dc:subject");.
+	*/
+	attribute nsIWritablePropertyBag2 fields;
+
+	/**
+	 * Sometimes there's no title, or the title contains markup, so take
+	 * care in decoding the attribute.
+	 */
+	attribute nsIFeedTextConstruct title;
+
+	/**
+	* Returns the primary link for the feed or entry.
+	*/
+	attribute nsIURI link;
+
+	/**
+	* Returns all links for a feed or entry.
+	*/
+	attribute nsIArray links;
+
+	/**
+	* Returns the categories found in a feed or entry.
+	*/
+	attribute nsIArray categories;
+
+	/**
+	 * The rights or license associated with a feed or entry.
+	 */
+	attribute nsIFeedTextConstruct rights;
+
+	/**
+	 * A list of nsIFeedPersons that authored the feed.
+	 */
+	attribute nsIArray authors;
+
+	/**
+	 * A list of nsIFeedPersons that contributed to the feed.
+	 */
+	attribute nsIArray contributors;
+
+	/**
+	 * The date the feed was updated, in RFC822 form. Parsable by JS
+	 * and mail code.
+	 */
+	attribute AString updated;
+
+	/**
+	* Syncs a container's fields with its convenience attributes.
+	*/
+	void normalize();
+};
diff --git a/resource/feeds/nsIFeedElementBase.idl b/resource/feeds/nsIFeedElementBase.idl
new file mode 100644
index 0000000000..a8364160ca
--- /dev/null
+++ b/resource/feeds/nsIFeedElementBase.idl
@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsISAXAttributes;
+interface nsIURI;
+
+/**
+ *  An nsIFeedGenerator represents the software used to create a feed.
+ */ 
+[scriptable, uuid(5215291e-fa0a-40c2-8ce7-e86cd1a1d3fa)]
+interface nsIFeedElementBase : nsISupports
+{
+	/**
+	 * The attributes found on the element. Most interfaces provide convenience
+	 * accessors for their standard fields, so this useful only when looking for
+	 * an extension.
+	 */
+	attribute nsISAXAttributes attributes;
+
+	/**
+	 * The baseURI for the Entry or Feed.
+	 */
+	attribute nsIURI baseURI;
+};
diff --git a/resource/feeds/nsIFeedEntry.idl b/resource/feeds/nsIFeedEntry.idl
new file mode 100644
index 0000000000..88778e9966
--- /dev/null
+++ b/resource/feeds/nsIFeedEntry.idl
@@ -0,0 +1,45 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFeedContainer.idl"
+interface nsIArray;
+
+/**
+ * An nsIFeedEntry represents an Atom or RSS entry/item. Summary
+ * and/or full-text content may be available, but callers will have to
+ * check both.
+ */
+[scriptable, uuid(31bfd5b4-8ff5-4bfd-a8cb-b3dfbd4f0a5b)]
+interface nsIFeedEntry : nsIFeedContainer {
+
+	/**
+	* Uses description, subtitle, summary, content and extensions
+	* to generate a summary. 
+	* 
+	*/
+	attribute nsIFeedTextConstruct summary;
+
+	/**
+	 * The date the entry was published, in RFC822 form. Parsable by JS
+	 * and mail code.
+	 */
+	attribute AString published;
+
+	/**
+	* Uses atom:content and content:encoded to provide
+	* a 'full text' view of an entry.
+	*
+	*/
+	attribute nsIFeedTextConstruct content;
+
+	/**
+	* Enclosures are podcasts, photocasts, etc.
+	*/
+	attribute nsIArray enclosures;
+
+	/**
+	* Enclosures, etc. that might be displayed inline.
+	*/
+	attribute nsIArray mediaContent;
+};
diff --git a/resource/feeds/nsIFeedGenerator.idl b/resource/feeds/nsIFeedGenerator.idl
new file mode 100644
index 0000000000..4ec956543f
--- /dev/null
+++ b/resource/feeds/nsIFeedGenerator.idl
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFeedElementBase.idl"
+
+interface nsIURI;
+
+/**
+ *  An nsIFeedGenerator represents the software used to create a feed.
+ */ 
+[scriptable, uuid(0fecd56b-bd92-481b-a486-b8d489cdd385)]
+interface nsIFeedGenerator : nsIFeedElementBase
+{
+	/**
+	 * The name of the software.
+	 */
+	attribute AString agent;
+
+	/**
+	 * The version of the software.
+	 */
+	attribute AString version;
+
+	/**
+	 * A URI associated with the software.
+	 */
+	attribute nsIURI uri;
+};
diff --git a/resource/feeds/nsIFeedListener.idl b/resource/feeds/nsIFeedListener.idl
new file mode 100644
index 0000000000..8bca4b716a
--- /dev/null
+++ b/resource/feeds/nsIFeedListener.idl
@@ -0,0 +1,86 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+interface nsIFeedResult;
+interface nsIFeedEntry;
+
+/**
+ * nsIFeedResultListener defines a callback used when feed processing
+ * completes.
+ */
+[scriptable, uuid(4d2ebe88-36eb-4e20-bcd1-997b3c1f24ce)]
+interface nsIFeedResultListener : nsISupports 
+{
+	/** 
+	* Always called, even after an error. There could be new feed-level
+	* data available at this point, if it followed or was interspersed
+	* with the items. Fire-and-Forget implementations only need this.
+	* 
+	* @param result
+	*        An object implementing nsIFeedResult representing the feed 
+	*        and its metadata. 
+	*/
+	void handleResult(in nsIFeedResult result);
+};
+
+
+/**
+ * nsIFeedProgressListener defines callbacks used during feed
+ * processing.
+ */
+[scriptable, uuid(ebfd5de5-713c-40c0-ad7c-f095117fa580)]
+interface nsIFeedProgressListener : nsIFeedResultListener {
+  
+	/**
+	* ReportError will be called in the event of fatal
+	* XML errors, or if the document is not a feed. The bozo 
+	* bit will be set if the error was due to a fatal error. 
+	* 
+	* @param errorText
+	*        A short description of the error.
+	* @param lineNumber
+	*        The line on which the error occurred.
+	*/
+	void reportError(in AString errorText, in long lineNumber, 
+						  in boolean bozo);
+	
+	/**
+	* StartFeed will be called as soon as a reasonable start to
+	* a feed is detected. 
+	*  
+	* @param result
+	*        An object implementing nsIFeedResult representing the feed 
+	*        and its metadata. At this point, the result has version 
+	*        information.
+	*/
+	void handleStartFeed(in nsIFeedResult result);
+
+	/**
+	* Called when the first entry/item is encountered. In Atom, all
+	* feed data is required to preceed the entries. In RSS, the data
+	* usually does. If the type is one of the entry/item-only types,
+	* this event will not be called.
+	*
+	* @param result
+	*        An object implementing nsIFeedResult representing the feed 
+	*        and its metadata. At this point, the result will likely have
+	*        most of its feed-level metadata.
+	*/
+	void handleFeedAtFirstEntry(in nsIFeedResult result); 
+
+	/**
+	* Called after each entry/item. If the document is a standalone
+	* item or entry, this HandleFeedAtFirstEntry will not have been
+	* called. Also, this entry's parent field will be null.
+	* 
+	* @param entry
+	*        An object implementing nsIFeedEntry that represents the latest
+	*        entry encountered.
+	* @param result
+	*        An object implementing nsIFeedResult representing the feed 
+	*        and its metadata. 
+	*/
+	void handleEntry(in nsIFeedEntry entry, in nsIFeedResult result);
+};
diff --git a/resource/feeds/nsIFeedPerson.idl b/resource/feeds/nsIFeedPerson.idl
new file mode 100644
index 0000000000..77de267f60
--- /dev/null
+++ b/resource/feeds/nsIFeedPerson.idl
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIFeedElementBase.idl"
+
+interface nsIURI;
+
+/**
+ *  An nsIFeedPerson represents an author or contributor of a feed.
+ */ 
+[scriptable, uuid(29cbd45f-f2d3-4b28-b557-3ab7a61ecde4)]
+interface nsIFeedPerson : nsIFeedElementBase
+{
+	/**
+	 * The name of the person.
+	 */
+	attribute AString name;
+
+	/**
+	 * An email address associated with the person.
+	 */
+	attribute AString email;
+
+	/**
+	 * A URI associated with the person (e.g. a homepage).
+	 */
+	attribute nsIURI uri;
+};
diff --git a/resource/feeds/nsIFeedProcessor.idl b/resource/feeds/nsIFeedProcessor.idl
new file mode 100644
index 0000000000..483dfe656b
--- /dev/null
+++ b/resource/feeds/nsIFeedProcessor.idl
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIStreamListener.idl"
+
+interface nsIURI;
+interface nsIFeedResultListener;
+interface nsIInputStream;
+
+/**
+ * An nsIFeedProcessor parses feeds, triggering callbacks based on
+ * their contents.
+ */
+[scriptable, uuid(8a0b2908-21b0-45d7-b14d-30df0f92afc7)]
+interface nsIFeedProcessor : nsIStreamListener {
+
+	/**
+	 * The listener that will respond to feed events. 
+	 */
+	attribute nsIFeedResultListener listener;
+
+	// Level is where to listen for the extension, a constant: FEED,
+	// ENTRY, BOTH.
+	//
+	// XXX todo void registerExtensionHandler(in
+	// nsIFeedExtensionHandler, in long level);
+	
+	/**
+	 * Parse a feed asynchronously. The caller must then call the
+	 * nsIFeedProcessor's nsIStreamListener methods to drive the
+	 * parse. Do not call the other parse methods during an asynchronous
+	 * parse.
+	 *
+	 * @param requestObserver The observer to notify on start/stop. This
+	 *                        argument can be null.
+	 * @param uri The base URI.
+	 */
+	void parseAsync(in nsIRequestObserver requestObserver, in nsIURI uri);
+};
diff --git a/resource/feeds/nsIFeedResult.idl b/resource/feeds/nsIFeedResult.idl
new file mode 100644
index 0000000000..327d553d98
--- /dev/null
+++ b/resource/feeds/nsIFeedResult.idl
@@ -0,0 +1,59 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+interface nsIFeedContainer;
+interface nsIProperties;
+interface nsIURI;
+
+/**
+ * The nsIFeedResult interface provides access to HTTP and parsing
+ * metadata for a feed or entry.
+ */
+[scriptable, uuid(7a180b78-0f46-4569-8c22-f3d720ea1c57)]
+interface nsIFeedResult : nsISupports {
+	 
+	/** 
+	* The Feed parser will set the bozo bit when a feed triggers a fatal
+	* error during XML parsing. There may be entries and feed metadata
+	* that were parsed before the error.  Thanks to Tim Bray for
+	* suggesting this terminology.
+	* <http://www.tbray.org/ongoing/When/200x/2004/01/11/PostelPilgrim>
+	*/
+	attribute boolean bozo;
+	
+	/**
+	* The parsed feed or entry. 
+	*
+	* Will be null if a non-feed is processed.
+	*/
+	attribute nsIFeedContainer doc;
+
+	/** 
+	* The address from which the feed was fetched. 
+	*/
+	attribute nsIURI uri;
+
+	/** 
+	* Feed Version: 
+	* atom, rss2, rss09, rss091, rss091userland, rss092, rss1, atom03, 
+	* atomEntry, rssItem
+	*
+	* Will be null if a non-feed is processed.
+	*/
+	attribute AString version;
+
+	/**
+	* An XSLT stylesheet available to transform the source of the
+	* feed. Some feeds include this information in a processing
+	* instruction. It's generally intended for clients with specific
+	* feed capabilities.
+	*/
+	attribute nsIURI stylesheet;
+
+	/**
+	* HTTP response headers that accompanied the feed. 
+	*/
+	attribute nsIProperties headers;
+};
diff --git a/resource/feeds/nsIFeedTextConstruct.idl b/resource/feeds/nsIFeedTextConstruct.idl
new file mode 100644
index 0000000000..893611b05b
--- /dev/null
+++ b/resource/feeds/nsIFeedTextConstruct.idl
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+
+webidl DocumentFragment;
+webidl Element;
+
+/**
+ * nsIFeedTextConstructs represent feed text fields that can contain
+ * one of text, HTML, or XHTML. Some extension elements also have "type"
+ * parameters, and this interface could be used there as well.
+ */ 
+[scriptable, uuid(fc97a2a9-d649-4494-931e-db81a156c873)]
+interface nsIFeedTextConstruct : nsISupports 
+{
+	/**
+	 * If the text construct contains (X)HTML, relative references in
+	 * the content should be resolved against this base URI.
+	 */
+	attribute nsIURI base;
+
+	/**
+	 * The language of the text. For example, "en-US" for US English.
+	 */
+	attribute AString lang;
+
+	/**
+	 * One of "text", "html", or "xhtml". If the type is (x)html, a '<'
+	 * character represents markup. To display that character, an escape
+	 * such as &lt; must be used. If the type is "text", the '<'
+	 * character represents the character itself, and such text should
+	 * not be embedded in markup without escaping it first.
+	 */
+	attribute AString type;
+
+	/**
+	 * The content of the text construct.
+	 */
+	attribute AString text;
+
+	/**
+	 * Returns the text of the text construct, with all markup stripped 
+	 * and all entities decoded. If the type attribute's value is "text",
+	 * this function returns the value of the text attribute unchanged.
+	 */
+	AString plainText();
+
+	/**
+	 * Return an nsIDocumentFragment containing the text and markup.
+	 */
+	DocumentFragment createDocumentFragment(in Element element);
+};
+ 
diff --git a/scripts/config.js b/scripts/config.js
index db27240dc9..6cef46e04a 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -50,6 +50,8 @@ const symlinkFiles = [
 	'resource/ace/theme-chrome.js',
 	'resource/ace/theme-monokai.js',
 	'resource/ace/worker-javascript.js',
+	// Feed *.idl files are for documentation only
+	'!resource/feeds/*.idl',
 	'update.rdf',
 	'!chrome/skin/default/zotero/**/*.scss'
 ];
diff --git a/test/content/runtests.js b/test/content/runtests.js
index 3ba7bfa6f3..714537a6f1 100644
--- a/test/content/runtests.js
+++ b/test/content/runtests.js
@@ -210,12 +210,13 @@ var assert = chai.assert,
 
 // Set up tests to run
 var run = ZoteroUnit.runTests;
-if(run && ZoteroUnit.tests) {
+if (run && ZoteroUnit.tests) {
 	function getTestFilename(test) {
-		// Allow foo, fooTest, fooTest.js, and tests/fooTest.js
+		// Remove any directory prefixes e.g. tests/fooTest.js, test/tests/fooTest.js
+		test = test.split(/[/\\]/).pop();
+		// Allow foo, fooTest, fooTest.js 
 		test = test.replace(/\.js$/, "");
 		test = test.replace(/Test$/, "");
-		test = test.replace(/^tests[/\\]/, "");
 		return test + "Test.js";
 	}
 	
@@ -284,4 +285,4 @@ if(run) {
 			return mocha.run();
 		})
 	};
-}
\ No newline at end of file
+}
diff --git a/test/tests/data/feedCDATA.rss b/test/tests/data/feedCDATA.rss
new file mode 100644
index 0000000000..8809b806ab
--- /dev/null
+++ b/test/tests/data/feedCDATA.rss
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Extracted from https://science.sciencemag.org/rss/current.xml -->
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+	xmlns="http://purl.org/rss/1.0/"
+	xmlns:content="http://purl.org/rss/1.0/modules/content/"
+	xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
+	xmlns:dc="http://purl.org/dc/elements/1.1/"
+	xmlns:syn="http://purl.org/rss/1.0/modules/syndication/"
+	xmlns:prism="http://purl.org/rss/1.0/modules/prism/"
+	xmlns:admin="http://webns.net/mvcb/">
+	<channel rdf:about="http://science.sciencemag.org">
+		<title>Science current issue</title>
+		<link>http://science.sciencemag.org</link>
+		<description>Science RSS feed -- current issue</description>
+		<prism:eIssn>1095-9203</prism:eIssn>
+		<prism:coverDisplayDate>May 21 2021 12:00:00:000AM</prism:coverDisplayDate>
+		<prism:publicationName>Science</prism:publicationName>
+		<prism:issn>0036-8075</prism:issn>
+		<items>
+			<rdf:Seq>
+				<rdf:li rdf:resource="http://science.sciencemag.org/cgi/content/short/372/6544/769?rss=1" />
+				<rdf:li rdf:resource="http://science.sciencemag.org/cgi/content/short/372/6544/770?rss=1" />
+			</rdf:Seq>
+		</items>
+		<image rdf:resource="http://science.sciencemag.org/icons/banner/title.gif" />
+	</channel>
+	<image rdf:about="http://science.sciencemag.org/icons/banner/title.gif">
+		<title>Science</title>
+		<url>http://science.sciencemag.org/icons/banner/title.gif</url>
+		<link>http://science.sciencemag.org</link>
+	</image>
+	<item rdf:about="http://science.sciencemag.org/cgi/content/short/372/6544/769?rss=1">
+		<title><![CDATA["The Descent of Man," 150 years on]]></title>
+		<link>http://science.sciencemag.org/cgi/content/short/372/6544/769?rss=1</link>
+		<description><![CDATA[]]></description>
+		<dc:creator><![CDATA[Fuentes, A.]]></dc:creator>
+		<dc:date>2021-05-20T10:40:55-07:00</dc:date>
+		<dc:identifier>info:doi/10.1126/science.abj4606</dc:identifier>
+		<dc:identifier>hwp:resource-id:sci;372/6544/769</dc:identifier>
+		<dc:publisher>American Association for the Advancement of Science</dc:publisher>
+		<dc:subject><![CDATA[Editorials]]></dc:subject>
+		<dc:title><![CDATA["The Descent of Man," 150 years on]]></dc:title>
+		<prism:publicationDate>2021-05-21</prism:publicationDate>
+		<prism:section>editorial</prism:section>
+		<prism:volume>372</prism:volume>
+		<prism:number>6544</prism:number>
+		<prism:startingPage>769</prism:startingPage>
+		<prism:endingPage>769</prism:endingPage>
+	</item>
+	<item rdf:about="http://science.sciencemag.org/cgi/content/short/372/6544/770?rss=1">
+		<title><![CDATA[News at a glance]]></title>
+		<link>http://science.sciencemag.org/cgi/content/short/372/6544/770?rss=1</link>
+		<description><![CDATA[]]></description>
+		<dc:creator><![CDATA[]]></dc:creator>
+		<dc:date>2021-05-20T10:40:55-07:00</dc:date>
+		<dc:identifier>info:doi/10.1126/science.372.6544.770</dc:identifier>
+		<dc:identifier>hwp:resource-id:sci;372/6544/770</dc:identifier>
+		<dc:publisher>American Association for the Advancement of Science</dc:publisher>
+		<dc:subject><![CDATA[Scientific Community]]></dc:subject>
+		<dc:title><![CDATA[News at a glance]]></dc:title>
+		<prism:publicationDate>2021-05-21</prism:publicationDate>
+		<prism:section>In Brief</prism:section>
+		<prism:volume>372</prism:volume>
+		<prism:number>6544</prism:number>
+		<prism:startingPage>770</prism:startingPage>
+		<prism:endingPage>772</prism:endingPage>
+	</item>
+</rdf:RDF>
diff --git a/test/tests/data/feedMedia.xml b/test/tests/data/feedMedia.xml
new file mode 100644
index 0000000000..e9452ad740
--- /dev/null
+++ b/test/tests/data/feedMedia.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Extracted from https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml -->
+<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:nyt="http://www.nytimes.com/namespaces/rss/2.0" version="2.0">
+  <channel>
+    <title>NYT &gt; Top Stories</title>
+    <link>https://www.nytimes.com</link>
+    <atom:link href="https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml" rel="self" type="application/rss+xml"></atom:link>
+    <description></description>
+    <language>en-us</language>
+    <copyright>Copyright 2021 The New York Times Company</copyright>
+    <lastBuildDate>Wed, 16 Jun 2021 19:30:15 +0000</lastBuildDate>
+    <pubDate>Wed, 16 Jun 2021 19:20:47 +0000</pubDate>
+    <item>
+      <title>In Pictures: President Biden’s Trip to Europe</title>
+      <link>https://www.nytimes.com/2021/06/10/world/europe/biden-europe-pictures.html</link>
+      <guid isPermaLink="true">https://www.nytimes.com/2021/06/10/world/europe/biden-europe-pictures.html</guid>
+      <atom:link href="https://www.nytimes.com/2021/06/10/world/europe/biden-europe-pictures.html" rel="standout"></atom:link>
+      <description>The president is in Cornwall, England, to meet with other leaders of wealthy democracies.</description>
+      <pubDate>Wed, 16 Jun 2021 18:53:17 +0000</pubDate>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_per">Biden, Joseph R Jr</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_per">Johnson, Boris</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_per">Biden, Jill Tracy Jacobs</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_org">Group of Seven</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_org">North Atlantic Treaty Organization</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/des">Coronavirus (2019-nCoV)</category>
+      <category domain="http://www.nytimes.com/namespaces/keywords/nyt_geo">Europe</category>
+      <media:content height="151" medium="image" url="https://static01.nyt.com/images/2021/06/16/world/16biden-photos1/16biden-photos1-moth.jpg" width="151"></media:content>
+      <media:credit>Doug Mills/The New York Times</media:credit>
+    </item>
+  </channel>
+</rss>
diff --git a/test/tests/data/feedRichText.rss b/test/tests/data/feedRichText.rss
new file mode 100644
index 0000000000..dd1073b595
--- /dev/null
+++ b/test/tests/data/feedRichText.rss
@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<!-- Lifted from http://cyber.law.harvard.edu/rss/examples/rss2sample.xml -->
+<rss version="2.0">
+   <channel>
+      <title>Liftoff News</title>
+      <link>http://liftoff.msfc.nasa.gov/</link>
+      <description>Liftoff to Space Exploration.</description>
+      <language>en-us</language>
+      <pubDate>Tue, 10 Jun 2003 04:00:00 GMT</pubDate>
+      <lastBuildDate>Tue, 10 Jun 2003 09:41:01 GMT</lastBuildDate>
+      <docs>http://blogs.law.harvard.edu/tech/rss</docs>
+      <generator>Weblog Editor 2.0</generator>
+      <managingEditor>editor@example.com</managingEditor>
+      <webMaster>webmaster@example.com</webMaster>
+      <item>
+         <title>Encoded &quot;entity&quot;</title>
+         <link>http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp</link>
+         <description>They take a crash course in language &amp; protocol.</description>
+         <pubDate>Tue, 03 Jun 2003 09:39:21 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/06/03.html#item573</guid>
+      </item>
+      <item>
+         <title>Embedded &lt;b&gt;tags&lt;/b&gt;</title>
+         <link>http://liftoff.msfc.nasa.gov/news/2003/news-VASIMR.asp</link>
+         <description>The proposed &lt;b&gt;VASIMR&lt;/b&gt; engine would do that.</description>
+         <pubDate>Tue, 27 May 2003 08:37:32 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/05/27.html#item571</guid>
+      </item>
+   </channel>
+</rss>
diff --git a/test/tests/feedReaderTest.js b/test/tests/feedReaderTest.js
index 6eaceab270..402c0675a7 100644
--- a/test/tests/feedReaderTest.js
+++ b/test/tests/feedReaderTest.js
@@ -30,21 +30,23 @@ describe("Zotero.FeedReader", function () {
 		language: 'en'
 	};
 	
+	var richTextRSSFeedURL = getTestDataUrl("feedRichText.rss");
+	var cdataRSSFeedURL = getTestDataUrl("feedCDATA.rss");
 	var atomFeedURL = getTestDataUrl("feed.atom");
-	var atomFeedInfo = {
-		title: 'Incircular nets and confocal conics',
-		updated: new Date("Tue, 10 Jun 2003 09:41:01 GMT"),
-		creators: [{
-			firstName: '',
-			lastName: 'editor@example.com',
-			creatorType: 'author',
-			fieldMode: 1
-		}],
-		language: 'en-us'
-	};
+	var mediaFeedURL = getTestDataUrl("feedMedia.xml");
 	
-	after(function* () {
-		yield clearFeeds();
+	var win;
+	
+	before(async function() {
+		// Browser window is needed as parent window to load the feed reader scripts.
+		win = await loadBrowserWindow();
+	});
+
+	after(async function() {
+		if (win) {
+			win.close();
+		}
+		await clearFeeds();
 	});
 
 	describe('FeedReader()', function () {
@@ -200,5 +202,51 @@ describe("Zotero.FeedReader", function () {
 			while(item = yield itemIterator.next().value);
 			assert.isNull(item);
 		});
+		
+		it('should decode entities', async () => {
+			const fr = new Zotero.FeedReader(richTextRSSFeedURL);
+			await fr.process();
+			const itemIterator = new fr.ItemIterator();
+			const item = await itemIterator.next().value;
+			
+			assert.equal(item.title, `Encoded "entity"`);
+			assert.equal(item.abstractNote, "They take a crash course in language & protocol.");
+		});
+
+		it('should remove tags', async () => {
+			const fr = new Zotero.FeedReader(richTextRSSFeedURL);
+			await fr.process();
+			const itemIterator = new fr.ItemIterator();
+			let item;
+			for (let i = 0; i < 2; i++) {
+				// eslint-disable-next-line no-await-in-loop
+				item = await itemIterator.next().value;
+			}
+			
+			// The entry title is text only, so tags are just more text.
+			assert.equal(item.title, "Embedded <b>tags</b>");
+			// The entry description is XHTML, so tags are removed there.
+			assert.equal(item.abstractNote, "The proposed VASIMR engine would do that.");
+		});
+
+		it('should parse CDATA as text', async () => {
+			const fr = new Zotero.FeedReader(cdataRSSFeedURL);
+			await fr.process();
+			const itemIterator = new fr.ItemIterator();
+			const item = await itemIterator.next().value;
+			
+			assert.equal(item.title, `"The Descent of Man," 150 years on`);
+			assert.equal(item.creators[0].lastName, "Fuentes");
+		});
+
+		it('should parse enclosed media', async () => {
+			const fr = new Zotero.FeedReader(mediaFeedURL);
+			await fr.process();
+			const itemIterator = new fr.ItemIterator();
+			const item = await itemIterator.next().value;
+			
+			assert.equal(item.enclosedItems.length, 1);
+			assert.equal(item.enclosedItems[0].url, "https://static01.nyt.com/images/2021/06/16/world/16biden-photos1/16biden-photos1-moth.jpg");
+		});
 	});
-})
\ No newline at end of file
+})
diff --git a/test/tests/feedTest.js b/test/tests/feedTest.js
index 15e7937983..6766f47ea0 100644
--- a/test/tests/feedTest.js
+++ b/test/tests/feedTest.js
@@ -311,8 +311,11 @@ describe("Zotero.Feed", function() {
 		var feed, scheduleNextFeedCheck;
 		var feedUrl = getTestDataUrl("feed.rss");
 		var modifiedFeedUrl = getTestDataUrl("feedModified.rss");
+		var win;
 		
-		before(function() {
+		before(async function() {
+			// Browser window is needed as parent window to load the feed reader scripts.
+			win = await loadBrowserWindow();
 			scheduleNextFeedCheck = sinon.stub(Zotero.Feeds, 'scheduleNextFeedCheck').resolves();
 		});
 		
@@ -328,6 +331,9 @@ describe("Zotero.Feed", function() {
 		});
 		
 		after(function() {
+			if (win) {
+				win.close();
+			}
 			scheduleNextFeedCheck.restore();
 		});