Mendeley import

Accept Mendeley SQLite databases via File → Import… and perform a
direct import, including collections, timestamps, notes, attachments,
and extracted annotations.

When a Mendeley database is present, File → Import… shows a wizard that
lets you choose between a file and Mendeley for the source, and choosing
the latter shows a list of available databases in the Mendeley data
directory.

Known fields that aren't valid for a type are stored in Extra.

Files in the Mendeley 'Downloaded' folder are stored. Files elsewhere
are linked.

chrome/content/zotero/fileInterface.js

@@ -23,6 +23,8 @@
     ***** END LICENSE BLOCK *****
 */
 
+Components.utils.import("resource://gre/modules/osfile.jsm")
+
 /****Zotero_File_Exporter****
  **
  * A class to handle exporting of items, collections, or the entire library
@@ -206,10 +208,117 @@ var Zotero_File_Interface = new function() {
 		}
 	}
 	
+	
+	this.startImport = async function () {
+		// Show the wizard if a Mendeley database is found
+		var mendeleyDBs = await this.findMendeleyDatabases();
+		var showWizard = !!mendeleyDBs.length;
+		if (showWizard) {
+			this.showImportWizard();
+		}
+		// Otherwise just show the filepicker
+		else {
+			await this.importFile(null, true);
+		}
+	}
+	
+	
+	this.getMendeleyDirectory = function () {
+		Components.classes["@mozilla.org/net/osfileconstantsservice;1"]
+			.getService(Components.interfaces.nsIOSFileConstantsService)
+			.init();
+		var path = OS.Constants.Path.homeDir;
+		if (Zotero.isMac) {
+			path = OS.Path.join(path, 'Library', 'Application Support', 'Mendeley Desktop');
+		}
+		else if (Zotero.isWin) {
+			path = OS.Path.join(path, 'AppData', 'Local', 'Mendeley Ltd', 'Desktop');
+		}
+		else if (Zotero.isLinux) {
+			path = OS.Path.join(path, '.local', 'share', 'data', 'Mendeley Ltd.', 'Mendeley Desktop');
+		}
+		else {
+			throw new Error("Invalid platform");
+		}
+		return path;
+	};
+	
+	
+	this.findMendeleyDatabases = async function () {
+		var dbs = [];
+		try {
+			var dir = this.getMendeleyDirectory();
+			if (!await OS.File.exists(dir)) {
+				Zotero.debug(`${dir} does not exist`);
+				return dbs;
+			}
+			await Zotero.File.iterateDirectory(dir, function* (iterator) {
+				while (true) {
+					let entry = yield iterator.next();
+					if (entry.isDir) continue;
+					// online.sqlite, counterintuitively, is the default database before you sign in
+					if (entry.name == 'online.sqlite' || entry.name.endsWith('@www.mendeley.com.sqlite')) {
+						dbs.push({
+							name: entry.name,
+							path: entry.path,
+							lastModified: null,
+							size: null
+						});
+					}
+				}
+			});
+			for (let i = 0; i < dbs.length; i++) {
+				let dbPath = OS.Path.join(dir, dbs[i].name);
+				let info = await OS.File.stat(dbPath);
+				dbs[i].size = info.size;
+				dbs[i].lastModified = info.lastModificationDate;
+			}
+			dbs.sort((a, b) => {
+				return b.lastModified - a.lastModified;
+			});
+		}
+		catch (e) {
+			Zotero.logError(e);
+		}
+		return dbs;
+	};
+	
+	
+	this.showImportWizard = function () {
+		try {
+			let win = Services.ww.openWindow(null, "chrome://zotero/content/import/importWizard.xul",
+				"importFile", "chrome,dialog=yes,centerscreen,width=600,height=400", null);
+		}
+		catch (e) {
+			Zotero.debug(e, 1);
+			throw e;
+		}
+	};
+	
+	
 	/**
 	 * Creates Zotero.Translate instance and shows file picker for file import
+	 *
+	 * @param {Object} options
+	 * @param {nsIFile|string|null} [options.file=null] - File to import, or none to show a filepicker
+	 * @param {Boolean} [options.createNewCollection=false] - Put items in a new collection
+	 * @param {Function} [options.onBeforeImport] - Callback to receive translation object, useful
+	 *     for displaying progress in a different way. This also causes an error to be throw
+	 *     instead of shown in the main window.
 	 */
-	this.importFile = Zotero.Promise.coroutine(function* (file, createNewCollection) {
+	this.importFile = Zotero.Promise.coroutine(function* (options = {}) {
+		if (!options) {
+			options = {};
+		}
+		if (typeof options == 'string' || options instanceof Components.interfaces.nsIFile) {
+			Zotero.debug("WARNING: importFile() now takes a single options object -- update your code");
+			options = { file: options };
+		}
+		
+		var file = options.file ? Zotero.File.pathToFile(options.file) : null;
+		var createNewCollection = options.createNewCollection;
+		var onBeforeImport = options.onBeforeImport;
+		
 		if(createNewCollection === undefined) {
 			createNewCollection = true;
 		} else if(!createNewCollection) {
@@ -231,21 +340,51 @@ var Zotero_File_Interface = new function() {
 			fp.appendFilters(nsIFilePicker.filterAll);
 			
 			var collation = Zotero.getLocaleCollation();
-			translators.sort((a, b) => collation.compareString(1, a.label, b.label))
-			for (let translator of translators) {
-				fp.appendFilter(translator.label, "*." + translator.target);
+			
+			// Add Mendeley DB, which isn't a translator
+			let mendeleyFilter = {
+				label: "Mendeley Database", // TODO: Localize
+				target: "*.sqlite"
+			};
+			let filters = [...translators];
+			filters.push(mendeleyFilter);
+			
+			filters.sort((a, b) => collation.compareString(1, a.label, b.label));
+			for (let filter of filters) {
+				fp.appendFilter(filter.label, "*." + filter.target);
 			}
 			
 			var rv = fp.show();
+			Zotero.debug(rv);
 			if (rv !== nsIFilePicker.returnOK && rv !== nsIFilePicker.returnReplace) {
 				return false;
 			}
 			
 			file = fp.file;
+			
+			Zotero.debug(`File is ${file.path}`);
 		}
-
+		
+		var defaultNewCollectionPrefix = Zotero.getString("fileInterface.imported");
+		
+		// Check if the file is an SQLite database
+		var sample = yield Zotero.File.getSample(file.path);
+		if (Zotero.MIME.sniffForMIMEType(sample) == 'application/x-sqlite3'
+				// Blacklist the current Zotero database, which would cause a hang
+				&& file.path != Zotero.DataDirectory.getDatabase()) {
+			// Mendeley import doesn't use the real translation architecture, but we create a
+			// translation object with the same interface
+			translation = yield _getMendeleyTranslation();
+			defaultNewCollectionPrefix = "Mendeley Import";
+		}
+		
 		translation.setLocation(file);
-		yield _finishImport(translation, createNewCollection);
+		return _finishImport({
+			translation,
+			createNewCollection,
+			defaultNewCollectionPrefix,
+			onBeforeImport
+		});
 	});
 	
 	
@@ -287,17 +426,31 @@ var Zotero_File_Interface = new function() {
 	});
 	
 	
-	var _finishImport = Zotero.Promise.coroutine(function* (translation, createNewCollection) {
+	var _finishImport = Zotero.Promise.coroutine(function* (options) {
+		var t = performance.now();
+		
+		var translation = options.translation;
+		var createNewCollection = options.createNewCollection;
+		var defaultNewCollectionPrefix = options.defaultNewCollectionPrefix;
+		var onBeforeImport = options.onBeforeImport;
+		
+		var showProgressWindow = !onBeforeImport;
+		
 		let translators = yield translation.getTranslators();
-
-		if(!translators.length) {
-			var ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
-									.getService(Components.interfaces.nsIPromptService);
-			var buttonFlags = (ps.BUTTON_POS_0) * (ps.BUTTON_TITLE_OK)
-								+ (ps.BUTTON_POS_1) * (ps.BUTTON_TITLE_IS_STRING);
-			var index = ps.confirmEx(
+		
+		// Unrecognized file
+		if (!translators.length) {
+			if (onBeforeImport) {
+				yield onBeforeImport(false);
+			}
+			
+			let ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
+				.getService(Components.interfaces.nsIPromptService);
+			let buttonFlags = ps.BUTTON_POS_0 * ps.BUTTON_TITLE_OK
+				+ ps.BUTTON_POS_1 * ps.BUTTON_TITLE_IS_STRING;
+			let index = ps.confirmEx(
 				null,
-				"",
+				Zotero.getString('general.error'),
 				Zotero.getString("fileInterface.unsupportedFormat"),
 				buttonFlags,
 				null,
@@ -305,17 +458,17 @@ var Zotero_File_Interface = new function() {
 				null, null, {}
 			);
 			if (index == 1) {
-				ZoteroPane_Local.loadURI("http://zotero.org/support/kb/importing");
+				Zotero.launchURL("https://www.zotero.org/support/kb/importing");
 			}
-			return;
+			return false;
 		}
-
+		
 		let importCollection = null, libraryID = Zotero.Libraries.userLibraryID;
 		try {
 			libraryID = ZoteroPane.getSelectedLibraryID();
 			importCollection = ZoteroPane.getSelectedCollection();
 		} catch(e) {}
-
+		
 		if(createNewCollection) {
 			// Create a new collection to take imported items
 			let collectionName;
@@ -330,8 +483,9 @@ var Zotero_File_Interface = new function() {
 						break;
 					}
 				}
-			} else {
-				collectionName = Zotero.getString("fileInterface.imported")+" "+(new Date()).toLocaleString();
+			}
+			else {
+				collectionName = defaultNewCollectionPrefix + " " + (new Date()).toLocaleString();
 			}
 			importCollection = new Zotero.Collection;
 			importCollection.libraryID = libraryID;
@@ -342,22 +496,29 @@ var Zotero_File_Interface = new function() {
 		translation.setTranslator(translators[0]);
 		
 		// Show progress popup
-		var progressWin = new Zotero.ProgressWindow({
-			closeOnClick: false
-		});
-		progressWin.changeHeadline(Zotero.getString('fileInterface.importing'));
-		var icon = 'chrome://zotero/skin/treesource-unfiled' + (Zotero.hiDPI ? "@2x" : "") + '.png';
-		let progress = new progressWin.ItemProgress(
-			icon, translation.path ? OS.Path.basename(translation.path) : translators[0].label
-		);
-		progressWin.show();
+		var progressWin;
+		var progress;
+		if (showProgressWindow) {
+			progressWin = new Zotero.ProgressWindow({
+				closeOnClick: false
+			});
+			progressWin.changeHeadline(Zotero.getString('fileInterface.importing'));
+			let icon = 'chrome://zotero/skin/treesource-unfiled' + (Zotero.hiDPI ? "@2x" : "") + '.png';
+			progress = new progressWin.ItemProgress(
+				icon, translation.path ? OS.Path.basename(translation.path) : translators[0].label
+			);
+			progressWin.show();
+			
+			translation.setHandler("itemDone",  function () {
+				progress.setProgress(translation.getProgress());
+			});
+			
+			yield Zotero.Promise.delay(0);
+		}
+		else {
+			yield onBeforeImport(translation);
+		}
 		
-		translation.setHandler("itemDone",  function () {
-			progress.setProgress(translation.getProgress());
-		});
-
-		yield Zotero.Promise.delay(0);
-
 		let failed = false;
 		try {
 			yield translation.translate({
@@ -365,6 +526,10 @@ var Zotero_File_Interface = new function() {
 				collections: importCollection ? [importCollection.id] : null
 			});
 		} catch(e) {
+			if (!showProgressWindow) {
+				throw e;
+			}
+			
 			progressWin.close();
 			Zotero.logError(e);
 			Zotero.alert(
@@ -372,26 +537,62 @@ var Zotero_File_Interface = new function() {
 				Zotero.getString('general.error'),
 				Zotero.getString("fileInterface.importError")
 			);
-			return;
+			return false;
 		}
 		
-		// Show popup on completion
 		var numItems = translation.newItems.length;
-		progressWin.changeHeadline(Zotero.getString('fileInterface.importComplete'));
-		if (numItems == 1) {
-			var icon = translation.newItems[0].getImageSrc();
+		
+		// Show popup on completion
+		if (showProgressWindow) {
+			progressWin.changeHeadline(Zotero.getString('fileInterface.importComplete'));
+			let icon;
+			if (numItems == 1) {
+				icon = translation.newItems[0].getImageSrc();
+			}
+			else {
+				icon = 'chrome://zotero/skin/treesource-unfiled' + (Zotero.hiDPI ? "@2x" : "") + '.png';
+			}
+			let text = Zotero.getString(`fileInterface.itemsWereImported`, numItems, numItems);
+			progress.setIcon(icon);
+			progress.setText(text);
+			// For synchronous translators, which don't update progress
+			progress.setProgress(100);
+			progressWin.startCloseTimer(5000);
 		}
-		else {
-			var icon = 'chrome://zotero/skin/treesource-unfiled' + (Zotero.hiDPI ? "@2x" : "") + '.png';
-		}
-		var text = Zotero.getString(`fileInterface.itemsWereImported`, numItems, numItems);
-		progress.setIcon(icon);
-		progress.setText(text);
-		// For synchronous translators, which don't update progress
-		progress.setProgress(100);
-		progressWin.startCloseTimer(5000);
+		
+		Zotero.debug(`Imported ${numItems} item(s) in ${performance.now() - t} ms`);
+		
+		return true;
 	});
 	
+	
+	var _getMendeleyTranslation = async function () {
+		if (true) {
+			Components.utils.import("chrome://zotero/content/import/mendeley/mendeleyImport.js");
+		}
+		// TEMP: Load uncached from ~/zotero-client for development
+		else {
+			Components.utils.import("resource://gre/modules/FileUtils.jsm");
+			let file = FileUtils.getDir("Home", []);
+			file = OS.Path.join(
+				file.path,
+				'zotero-client', 'chrome', 'content', 'zotero', 'import', 'mendeley', 'mendeleyImport.js'
+			);
+			let fileURI = OS.Path.toFileURI(file);
+			let xmlhttp = await Zotero.HTTP.request(
+				'GET',
+				fileURI,
+				{
+					dontCache: true,
+					responseType: 'text'
+				}
+			);
+			eval(xmlhttp.response);
+		}
+		return new Zotero_Import_Mendeley();
+	}
+	
+	
 	/**
 	 * Creates a bibliography from a collection or saved search
 	 */

chrome/content/zotero/import/importWizard.js

@@ -0,0 +1,202 @@
+var Zotero_Import_Wizard = {
+	_wizard: null,
+	_dbs: null,
+	_file: null,
+	_translation: null,
+	
+	
+	init: function () {
+		this._wizard = document.getElementById('import-wizard');
+		
+		Zotero.Translators.init(); // async
+	},
+	
+	
+	onModeChosen: async function () {
+		var wizard = this._wizard;
+		
+		this._disableCancel();
+		wizard.canRewind = false;
+		wizard.canAdvance = false;
+		
+		var mode = document.getElementById('import-source').selectedItem.id;
+		try {
+			switch (mode) {
+			case 'radio-import-source-file':
+				await this.doImport();
+				break;
+				
+			case 'radio-import-source-mendeley':
+				this._dbs = await Zotero_File_Interface.findMendeleyDatabases();
+				// This shouldn't happen, because we only show the wizard if there are databases
+				if (!this._dbs.length) {
+					throw new Error("No databases found");
+				}
+				if (this._dbs.length > 1 || true) {
+					this._populateFileList(this._dbs);
+					document.getElementById('file-options-header').textContent
+						= Zotero.getString('fileInterface.chooseAppDatabaseToImport', 'Mendeley')
+					wizard.goTo('page-file-options');
+					wizard.canRewind = true;
+					this._enableCancel();
+				}
+				break;
+			
+			default:
+				throw new Error(`Unknown mode ${mode}`);
+			}
+		}
+		catch (e) {
+			this._onDone(
+				Zotero.getString('general.error'),
+				Zotero.getString('fileInterface.importError'),
+				true
+			);
+			throw e;
+		}
+	},
+	
+	
+	onFileSelected: async function () {
+		this._wizard.canAdvance = true;
+	},
+	
+	
+	onFileChosen: async function () {
+		var index = document.getElementById('file-list').selectedIndex;
+		this._file = this._dbs[index].path;
+		this._disableCancel();
+		this._wizard.canRewind = false;
+		this._wizard.canAdvance = false;
+		await this.doImport();
+	},
+	
+	
+	onBeforeImport: async function (translation) {
+		// Unrecognized translator
+		if (!translation) {
+			// Allow error dialog to be displayed, and then close window
+			setTimeout(function () {
+				window.close();
+			});
+			return;
+		}
+		
+		this._translation = translation;
+		
+		// Switch to progress pane
+		this._wizard.goTo('page-progress');
+		var pm = document.getElementById('import-progressmeter');
+		
+		translation.setHandler('itemDone', function () {
+			pm.value = translation.getProgress();
+		});
+	},
+	
+	
+	doImport: async function () {
+		try {
+			let result = await Zotero_File_Interface.importFile({
+				file: this._file,
+				onBeforeImport: this.onBeforeImport.bind(this)
+			});
+			
+			// Cancelled by user or due to error
+			if (!result) {
+				window.close();
+				return;
+			}
+			
+			let numItems = this._translation.newItems.length;
+			this._onDone(
+				Zotero.getString('fileInterface.importComplete'),
+				Zotero.getString(`fileInterface.itemsWereImported`, numItems, numItems)
+			);
+		}
+		catch (e) {
+			this._onDone(
+				Zotero.getString('general.error'),
+				Zotero.getString('fileInterface.importError'),
+				true
+			);
+			throw e;
+		}
+	},
+	
+	
+	reportError: function () {
+		Zotero.getActiveZoteroPane().reportErrors();
+		window.close();
+	},
+	
+	
+	_populateFileList: async function (files) {
+		var listbox = document.getElementById('file-list');
+		
+		// Remove existing entries
+		var items = listbox.getElementsByTagName('listitem');
+		for (let item of items) {
+			listbox.removeChild(item);
+		}
+		
+		for (let file of files) {
+			let li = document.createElement('listitem');
+			
+			let name = document.createElement('listcell');
+			// Simply filenames
+			let nameStr = file.name
+				.replace(/\.sqlite$/, '')
+				.replace(/@www\.mendeley\.com$/, '');
+			if (nameStr == 'online') {
+				nameStr = Zotero.getString('dataDir.default', 'online.sqlite');
+			}
+			name.setAttribute('label', nameStr + ' ');
+			li.appendChild(name);
+			
+			let lastModified = document.createElement('listcell');
+			lastModified.setAttribute('label', file.lastModified.toLocaleString() + ' ');
+			li.appendChild(lastModified);
+			
+			let size = document.createElement('listcell');
+			size.setAttribute(
+				'label',
+				Zotero.getString('general.nMegabytes', (file.size / 1024 / 1024).toFixed(1)) + ' '
+			);
+			li.appendChild(size);
+			
+			listbox.appendChild(li);
+		}
+		
+		if (files.length == 1) {
+			listbox.selectedIndex = 0;
+		}
+	},
+	
+	
+	_enableCancel: function () {
+		this._wizard.getButton('cancel').disabled = false;
+	},
+	
+	
+	_disableCancel: function () {
+		this._wizard.getButton('cancel').disabled = true;
+	},
+	
+	
+	_onDone: function (label, description, showReportErrorButton) {
+		var wizard = this._wizard;
+		wizard.getPageById('page-done').setAttribute('label', label);
+		document.getElementById('result-description').textContent = description;
+		
+		if (showReportErrorButton) {
+			let button = document.getElementById('result-report-error');
+			button.setAttribute('label', Zotero.getString('errorReport.reportError'));
+			button.hidden = false;
+		}
+		
+		// When done, move to last page and allow closing
+		wizard.canAdvance = true;
+		wizard.goTo('page-done');
+		wizard.canRewind = false;
+	}
+};

chrome/content/zotero/import/importWizard.xul

@@ -0,0 +1,62 @@
+<?xml version="1.0"?>
+
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+<?xml-stylesheet href="chrome://zotero/skin/importWizard.css" type="text/css"?>
+
+<!DOCTYPE window SYSTEM "chrome://zotero/locale/zotero.dtd">
+
+<wizard id="import-wizard"
+		xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+		title="&zotero.import;"
+		onload="Zotero_Import_Wizard.init()">
+	
+	<script src="../include.js"/>
+	<script src="../fileInterface.js"/>
+	<script src="importWizard.js"/>
+	
+	<wizardpage pageid="page-start"
+			label="&zotero.import.whereToImportFrom;"
+			next="page-progress"
+			onpageadvanced="Zotero_Import_Wizard.onModeChosen(); return false;">
+		<radiogroup id="import-source">
+			<radio id="radio-import-source-file" label="&zotero.import.source.file;"/>
+			<radio id="radio-import-source-mendeley" label="Mendeley"/>
+		</radiogroup>
+	</wizardpage>
+	
+	<wizardpage pageid="page-file-options"
+			next="page-progress"
+			onpagerewound="var w = document.getElementById('import-wizard'); w.goTo('page-start'); w.canAdvance = true; return false;"
+			onpageadvanced="Zotero_Import_Wizard.onFileChosen()">
+		<description id="file-options-header"/>
+		<listbox id="file-list" onselect="Zotero_Import_Wizard.onFileSelected()">
+			<listhead>
+				<listheader label="&zotero.import.database;"/>
+				<listheader label="&zotero.import.lastModified;"/>
+				<listheader label="&zotero.import.size;"/>
+			</listhead>
+			
+			<listcols>
+				<listcol flex="1"/>
+				<listcol/>
+				<listcol/>
+			</listcols>
+		</listbox>
+	</wizardpage>
+	
+	<wizardpage pageid="page-progress"
+			label="&zotero.import.importing;"
+			onpageshow="document.getElementById('import-wizard').canRewind = false;"
+			next="page-done">
+		<progressmeter id="import-progressmeter" mode="determined"/>
+	</wizardpage>
+	
+	<wizardpage pageid="page-done">
+		<description id="result-description"/>
+		<hbox>
+			<button id="result-report-error"
+				oncommand="Zotero_Import_Wizard.reportError()"
+				hidden="true"/>
+		</hbox>
+	</wizardpage>
+</wizard>

chrome/content/zotero/import/mendeley/mendeleyImport.js

@@ -0,0 +1,830 @@
+var EXPORTED_SYMBOLS = ["Zotero_Import_Mendeley"];
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/osfile.jsm");
+Services.scriptloader.loadSubScript("chrome://zotero/content/include.js");
+
+var Zotero_Import_Mendeley = function () {
+	this.newItems = [];
+	
+	this._db;
+	this._file;
+	this._itemDone;
+	this._progress = 0;
+	this._progressMax;
+};
+
+Zotero_Import_Mendeley.prototype.setLocation = function (file) {
+	this._file = file.path || file;
+};
+
+Zotero_Import_Mendeley.prototype.setHandler = function (name, handler) {
+	switch (name) {
+	case 'itemDone':
+		this._itemDone = handler;
+		break;
+	}
+};
+
+Zotero_Import_Mendeley.prototype.getProgress = function () {
+	return this._progress / this._progressMax * 100;
+};
+
+Zotero_Import_Mendeley.prototype.getTranslators = async function () {
+	return [{
+		label: Zotero.getString('fileInterface.appDatabase', 'Mendeley')
+	}];
+};
+
+Zotero_Import_Mendeley.prototype.setTranslator = function () {};
+
+Zotero_Import_Mendeley.prototype.translate = async function (options) {
+	if (true) {
+		Services.scriptloader.loadSubScript("chrome://zotero/content/import/mendeley/mendeleySchemaMap.js");
+	}
+	// TEMP: Load uncached from ~/zotero-client for development
+	else {
+		Components.utils.import("resource://gre/modules/FileUtils.jsm");
+		let file = FileUtils.getDir("Home", []);
+		file = OS.Path.join(file.path, 'zotero-client', 'chrome', 'content', 'zotero', 'import', 'mendeley', 'mendeleySchemaMap.js');
+		let fileURI = OS.Path.toFileURI(file);
+		let xmlhttp = await Zotero.HTTP.request(
+			'GET',
+			fileURI,
+			{
+				dontCache: true,
+				responseType: 'text'
+			}
+		);
+		eval(xmlhttp.response);
+	}
+	
+	const libraryID = options.libraryID || Zotero.Libraries.userLibraryID;
+	const { key: rootCollectionKey } = options.collections
+		? Zotero.Collections.getLibraryAndKeyFromID(options.collections[0])
+		: {};
+	
+	// TODO: Get appropriate version based on schema version
+	const mapVersion = 83;
+	map = map[mapVersion];
+	
+	const mendeleyGroupID = 0;
+	
+	// Disable syncing while we're importing
+	var resumeSync = Zotero.Sync.Runner.delayIndefinite();
+	
+	this._db = new Zotero.DBConnection(this._file);
+	
+	try {
+		if (!await this._isValidDatabase()) {
+			throw new Error("Not a valid Mendeley database");
+		}
+		
+		// Collections
+		let folders = await this._getFolders(mendeleyGroupID);
+		let collectionJSON = this._foldersToAPIJSON(folders, rootCollectionKey);
+		let folderKeys = this._getFolderKeys(collectionJSON);
+		await this._saveCollections(libraryID, collectionJSON);
+		
+		//
+		// Items
+		//
+		let documents = await this._getDocuments(mendeleyGroupID);
+		this._progressMax = documents.length;
+		// Get various attributes mapped to document ids
+		let urls = await this._getDocumentURLs(mendeleyGroupID);
+		let creators = await this._getDocumentCreators(mendeleyGroupID, map.creatorTypes);
+		let tags = await this._getDocumentTags(mendeleyGroupID);
+		let collections = await this._getDocumentCollections(
+			mendeleyGroupID,
+			documents,
+			rootCollectionKey,
+			folderKeys
+		);
+		let files = await this._getDocumentFiles(mendeleyGroupID);
+		let annotations = await this._getDocumentAnnotations(mendeleyGroupID);
+		for (let document of documents) {
+			// Save each document with its attributes
+			let itemJSON = await this._documentToAPIJSON(
+				map,
+				document,
+				urls.get(document.id),
+				creators.get(document.id),
+				tags.get(document.id),
+				collections.get(document.id),
+				annotations.get(document.id)
+			);
+			let documentIDMap = await this._saveItems(libraryID, itemJSON);
+			// Save the document's attachments and extracted annotations for any of them
+			let docFiles = files.get(document.id);
+			if (docFiles) {
+				await this._saveFilesAndAnnotations(
+					docFiles,
+					libraryID,
+					documentIDMap.get(document.id),
+					annotations.get(document.id)
+				);
+			}
+			this.newItems.push(Zotero.Items.get(documentIDMap.get(document.id)));
+			this._progress++;
+			if (this._itemDone) {
+				this._itemDone();
+			}
+		}
+	}
+	finally {
+		try {
+			await this._db.closeDatabase();
+		}
+		catch (e) {
+			Zotero.logError(e);
+		}
+		
+		resumeSync();
+	}
+};
+
+Zotero_Import_Mendeley.prototype._isValidDatabase = async function () {
+	var tables = [
+		'DocumentContributors',
+		'DocumentFiles',
+		'DocumentFolders',
+		'DocumentKeywords',
+		'DocumentTags',
+		'DocumentUrls',
+		'Documents',
+		'Files',
+		'Folders',
+		'RemoteDocuments',
+		'RemoteFolders'
+	];
+	for (let table of tables) {
+		if (!await this._db.tableExists(table)) {
+			return false;
+		}
+	}
+	return true;
+};
+
+//
+// Collections
+//
+Zotero_Import_Mendeley.prototype._getFolders = async function (groupID) {
+	return this._db.queryAsync(
+		`SELECT F.*, RF.remoteUuid FROM Folders F `
+			+ `JOIN RemoteFolders RF ON (F.id=RF.folderId) `
+			+ `WHERE groupId=?`,
+		groupID
+	);
+};
+
+/**
+ * Get flat array of collection API JSON with parentCollection set
+ *
+ * The returned objects include an extra 'id' property for matching collections to documents.
+ */
+Zotero_Import_Mendeley.prototype._foldersToAPIJSON = function (folderRows, parentKey) {
+	var maxDepth = 50;
+	return this._getFolderDescendents(-1, parentKey, folderRows, maxDepth);
+};
+
+Zotero_Import_Mendeley.prototype._getFolderDescendents = function (folderID, folderKey, folderRows, maxDepth) {
+	if (maxDepth == 0) return []
+	var descendents = [];
+	var children = folderRows
+		.filter(f => f.parentId == folderID)
+		.map(f => {
+			let c = {
+				folderID: f.id,
+				remoteUUID: f.remoteUuid,
+				key: Zotero.DataObjectUtilities.generateKey(),
+				name: f.name,
+				parentCollection: folderKey
+			};
+			if (f.remoteUuid) {
+				c.relations = {
+					'mendeleyDB:remoteFolderUUID': f.remoteUuid
+				};
+			}
+			return c;
+		});
+	
+	for (let child of children) {
+		descendents.push(
+			child,
+			...this._getFolderDescendents(child.folderID, child.key, folderRows, maxDepth - 1)
+		);
+	}
+	return descendents;
+};
+
+Zotero_Import_Mendeley.prototype._getFolderKeys = function (collections) {
+	var map = new Map();
+	for (let collection of collections) {
+		map.set(collection.folderID, collection.key);
+	}
+	return map;
+};
+
+/**
+ * @param {Integer} libraryID
+ * @param {Object[]} json
+ */
+Zotero_Import_Mendeley.prototype._saveCollections = async function (libraryID, json) {
+	var idMap = new Map();
+	for (let collectionJSON of json) {
+		let collection = new Zotero.Collection;
+		collection.libraryID = libraryID;
+		if (collectionJSON.key) {
+			collection.key = collectionJSON.key;
+			await collection.loadPrimaryData();
+		}
+		
+		// Remove external ids before saving
+		let toSave = Object.assign({}, collectionJSON);
+		delete toSave.folderID;
+		delete toSave.remoteUUID;
+		
+		collection.fromJSON(toSave);
+		await collection.saveTx({
+			skipSelect: true
+		});
+		idMap.set(collectionJSON.folderID, collection.id);
+	}
+	return idMap;
+};
+
+
+//
+// Items
+//
+Zotero_Import_Mendeley.prototype._getDocuments = async function (groupID) {
+	return this._db.queryAsync(
+		`SELECT D.*, RD.remoteUuid FROM Documents D `
+			+ `JOIN RemoteDocuments RD ON (D.id=RD.documentId) `
+			+ `WHERE groupId=? AND inTrash='false'`,
+		groupID
+	);
+};
+
+/**
+ * Get a Map of document ids to arrays of URLs
+ */
+Zotero_Import_Mendeley.prototype._getDocumentURLs = async function (groupID) {
+	var rows = await this._db.queryAsync(
+		`SELECT documentId, CAST(url AS TEXT) AS url FROM DocumentUrls DU `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=? ORDER BY position`,
+		groupID
+	);
+	var map = new Map();
+	for (let row of rows) {
+		let docURLs = map.get(row.documentId);
+		if (!docURLs) docURLs = [];
+		docURLs.push(row.url);
+		map.set(row.documentId, docURLs);
+	}
+	return map;
+};
+
+/**
+ * Get a Map of document ids to arrays of creator API JSON
+ *
+ * @param {Integer} groupID
+ * @param {Object} creatorTypeMap - Mapping of Mendeley creator types to Zotero creator types
+ */
+Zotero_Import_Mendeley.prototype._getDocumentCreators = async function (groupID, creatorTypeMap) {
+	var rows = await this._db.queryAsync(
+		`SELECT * FROM DocumentContributors `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=?`,
+		groupID
+	);
+	var map = new Map();
+	for (let row of rows) {
+		let docCreators = map.get(row.documentId);
+		if (!docCreators) docCreators = [];
+		docCreators.push(this._makeCreator(
+			creatorTypeMap[row.contribution] || 'author',
+			row.firstNames,
+			row.lastName
+		));
+		map.set(row.documentId, docCreators);
+	}
+	return map;
+};
+
+/**
+ * Get a Map of document ids to arrays of tag API JSON
+ */
+Zotero_Import_Mendeley.prototype._getDocumentTags = async function (groupID) {
+	var rows = await this._db.queryAsync(
+		// Manual tags
+		`SELECT documentId, tag, 0 AS type FROM DocumentTags `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=? `
+			+ `UNION `
+			// Automatic tags
+			+ `SELECT documentId, keyword AS tag, 1 AS type FROM DocumentKeywords `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=?`,
+		[groupID, groupID]
+	);
+	var map = new Map();
+	for (let row of rows) {
+		let docTags = map.get(row.documentId);
+		if (!docTags) docTags = [];
+		docTags.push({
+			tag: row.tag,
+			type: row.type
+		});
+		map.set(row.documentId, docTags);
+	}
+	return map;
+};
+
+/**
+ * Get a Map of document ids to arrays of collection keys
+ */
+Zotero_Import_Mendeley.prototype._getDocumentCollections = async function (groupID, documents, rootCollectionKey, folderKeys) {
+	var rows = await this._db.queryAsync(
+		`SELECT documentId, folderId FROM DocumentFolders DF `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=?`,
+		groupID
+	);
+	var map = new Map(
+		// Add all documents to root collection if specified
+		documents.map(d => [d.id, rootCollectionKey ? [rootCollectionKey] : []])
+	);
+	for (let row of rows) {
+		let keys = map.get(row.documentId);
+		keys.push(folderKeys.get(row.folderId));
+		map.set(row.documentId, keys);
+	}
+	return map;
+};
+
+/**
+ * Get a Map of document ids to file metadata
+ */
+Zotero_Import_Mendeley.prototype._getDocumentFiles = async function (groupID) {
+	var rows = await this._db.queryAsync(
+		`SELECT documentId, hash, remoteFileUuid, localUrl FROM DocumentFiles `
+			+ `JOIN Files USING (hash) `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=?`,
+		groupID
+	);
+	var map = new Map();
+	for (let row of rows) {
+		let docFiles = map.get(row.documentId);
+		if (!docFiles) docFiles = [];
+		docFiles.push({
+			hash: row.hash,
+			uuid: row.remoteFileUuid,
+			fileURL: row.localUrl
+		});
+		map.set(row.documentId, docFiles);
+	}
+	return map;
+};
+
+/**
+ * Get a Map of document ids to arrays of annotations
+ */
+Zotero_Import_Mendeley.prototype._getDocumentAnnotations = async function (groupID) {
+	var rows = await this._db.queryAsync(
+		`SELECT documentId, uuid, fileHash, page, note, color `
+			+ `FROM FileNotes `
+			+ `JOIN RemoteDocuments USING (documentId) `
+			+ `WHERE groupId=? `
+			+ `ORDER BY page, y, x`,
+		groupID
+	);
+	var map = new Map();
+	for (let row of rows) {
+		let docAnnotations = map.get(row.documentId);
+		if (!docAnnotations) docAnnotations = [];
+		docAnnotations.push({
+			uuid: row.uuid,
+			hash: row.fileHash,
+			note: row.note,
+			page: row.page,
+			color: row.color
+		});
+		map.set(row.documentId, docAnnotations);
+	}
+	return map;
+};
+
+/**
+ * Create API JSON array with item and any child attachments or notes
+ */
+Zotero_Import_Mendeley.prototype._documentToAPIJSON = async function (map, documentRow, urls, creators, tags, collections, annotations) {
+	var parent = {
+		key: Zotero.DataObjectUtilities.generateKey()
+	};
+	var children = [];
+	
+	parent.itemType = map.itemTypes[documentRow.type];
+	if (!parent.itemType) {
+		Zotero.warn(`Unmapped item type ${documentRow.type}`);
+	}
+	if (!parent.itemType || parent.itemType == 'document') {
+		parent.itemType = this._guessItemType(documentRow);
+		Zotero.debug(`Guessing type ${parent.itemType}`);
+	}
+	var itemTypeID = Zotero.ItemTypes.getID(parent.itemType);
+	
+	for (let [mField, zField] of Object.entries(map.fields)) {
+		// If not mapped, skip
+		if (!zField) {
+			continue;
+		}
+		let val = documentRow[mField];
+		// If no value, skip
+		if (!val) {
+			continue;
+		}
+		
+		if (typeof zField == 'string') {
+			this._processField(parent, children, zField, val);
+		}
+		// Function embedded in map file
+		else if (typeof zField == 'function') {
+			let [field, val] = zField(documentRow[mField], parent);
+			this._processField(parent, children, field, val);
+		}
+	}
+	
+	// URLs
+	if (urls) {
+		for (let i = 0; i < urls.length; i++) {
+			let url = urls[i];
+			let isPDF = url.includes('pdf');
+			if (i == 0 && !isPDF) {
+				parent.url = url;
+			}
+			else {
+				children.push({
+					itemType: 'attachment',
+					parentItem: parent.key,
+					linkMode: 'linked_url',
+					url,
+					title: isPDF ? 'PDF' : '',
+					contentType: isPDF ? 'application/pdf' : ''
+				});
+			}
+		}
+	}
+	
+	// Combine date parts if present
+	if (documentRow.year) {
+		parent.date = documentRow.year.toString().substr(0, 4).padStart(4, '0');
+		if (documentRow.month) {
+			parent.date += '-' + documentRow.month.toString().substr(0, 2).padStart(2, '0');
+			if (documentRow.day) {
+				parent.date += '-' + documentRow.day.toString().substr(0, 2).padStart(2, '0');
+			}
+		}
+	}
+	
+	for (let field in parent) {
+		switch (field) {
+		case 'itemType':
+		case 'key':
+		case 'parentItem':
+		case 'note':
+		case 'creators':
+		case 'dateAdded':
+		case 'dateModified':
+			continue;
+		}
+		
+		// Move unknown/invalid fields to Extra
+		let fieldID = Zotero.ItemFields.getID(field)
+			&& Zotero.ItemFields.getFieldIDFromTypeAndBase(parent.itemType, field);
+		if (!fieldID) {
+			Zotero.warn(`Moving '${field}' to Extra for type ${parent.itemType}`);
+			parent.extra = this._addExtraField(parent.extra, field, parent[field]);
+			delete parent[field];
+			continue;
+		}
+		let newField = Zotero.ItemFields.getName(fieldID);
+		if (field != newField) {
+			parent[newField] = parent[field];
+			delete parent[field];
+		}
+	}
+	
+	if (!parent.dateModified) {
+		parent.dateModified = parent.dateAdded;
+	}
+	
+	if (creators) {
+		// Add main creators before any added by fields (e.g., seriesEditor)
+		parent.creators = [...creators, ...(parent.creators || [])];
+		
+		// If item type has a different primary type, use that for author to prevent a warning
+		let primaryCreatorType = Zotero.CreatorTypes.getName(
+			Zotero.CreatorTypes.getPrimaryIDForType(itemTypeID)
+		);
+		if (primaryCreatorType != 'author') {
+			for (let creator of parent.creators) {
+				if (creator.creatorType == 'author') {
+					creator.creatorType = primaryCreatorType;
+				}
+			}
+		}
+		
+		for (let creator of parent.creators) {
+			// seriesEditor isn't valid on some item types (e.g., book)
+			if (creator.creatorType == 'seriesEditor'
+					&& !Zotero.CreatorTypes.isValidForItemType(
+							Zotero.CreatorTypes.getID('seriesEditor'), itemTypeID)) {
+				creator.creatorType = 'editor';
+			}
+		}
+	}
+	if (tags) parent.tags = tags;
+	if (collections) parent.collections = collections;
+	
+	// Copy date added/modified to child item
+	var parentDateAdded = parent.dateAdded;
+	var parentDateModified = parent.dateModified;
+	for (let child of children) {
+		child.dateAdded = parentDateAdded;
+		child.dateModified = parentDateModified;
+	}
+	
+	// Don't set an explicit key if no children
+	if (!children.length) {
+		delete parent.key;
+	}
+	
+	parent.relations = {
+		'mendeleyDB:documentUUID': documentRow.uuid.replace(/^\{/, '').replace(/\}$/, '')
+	};
+	if (documentRow.remoteUuid) {
+		parent.relations['mendeleyDB:remoteDocumentUUID'] = documentRow.remoteUuid;
+	}
+	
+	parent.documentID = documentRow.id;
+	
+	var json = [parent, ...children];
+	//Zotero.debug(json);
+	return json;
+};
+
+/**
+ * Try to figure out item type based on available fields
+ */
+Zotero_Import_Mendeley.prototype._guessItemType = function (documentRow) {
+	if (documentRow.issn || documentRow.issue) {
+		return 'journalArticle';
+	}
+	if (documentRow.isbn) {
+		return 'book';
+	}
+	return 'document';
+};
+
+Zotero_Import_Mendeley.prototype._extractSubfield = function (field) {
+	var sub = field.match(/([a-z]+)\[([^\]]+)]/);
+	return sub ? { field: sub[1], subfield: sub[2] } : { field };
+};
+
+Zotero_Import_Mendeley.prototype._processField = function (parent, children, zField, val) {
+	var { field, subfield } = this._extractSubfield(zField);
+	if (subfield) {
+		// Combine 'city' and 'country' into 'place'
+		if (field == 'place') {
+			if (subfield == 'city') {
+				parent.place = val + (parent.place ? ', ' + parent.place : '');
+			}
+			else if (subfield == 'country') {
+				parent.place = (parent.place ? ', ' + parent.place : '') + val;
+			}
+		}
+		// Convert some item fields as creators
+		else if (field == 'creator') {
+			if (!parent.creators) {
+				parent.creators = [];
+			}
+			parent.creators.push(this._makeCreator(subfield, null, val));
+		}
+		else if (field == 'extra') {
+			parent.extra = this._addExtraField(parent.extra, subfield, val);
+		}
+		// Functions
+		else if (field == 'func') {
+			// Convert unix timestamps to ISO dates
+			if (subfield.startsWith('fromUnixtime')) {
+				let [, zField] = subfield.split(':');
+				parent[zField] = Zotero.Date.dateToISO(new Date(val));
+			}
+			// If 'pages' isn't valid for itemType, use 'numPages' instead
+			else if (subfield == 'pages') {
+				let itemTypeID = Zotero.ItemTypes.getID(parent.itemType);
+				if (!Zotero.ItemFields.isValidForType('pages', itemTypeID)
+						&& Zotero.ItemFields.isValidForType('numPages', itemTypeID)) {
+					zField = 'numPages';
+				}
+				else {
+					zField = 'pages';
+				}
+				parent[zField] = val;
+			}
+			// Notes become child items
+			else if (subfield == 'note') {
+				children.push({
+					parentItem: parent.key,
+					itemType: 'note',
+					note: this._convertNote(val)
+				});
+			}
+			else {
+				Zotero.warn(`Unknown function subfield: ${subfield}`);
+				return;
+			}
+		}
+		else {
+			Zotero.warn(`Unknown field: ${field}[${subfield}]`);
+		}
+	}
+	else {
+		// These are added separately so that they're available for notes
+		if (zField == 'dateAdded' || zField == 'dateModified') {
+			return;
+		}
+		parent[zField] = val;
+	}
+};
+
+Zotero_Import_Mendeley.prototype._makeCreator = function (creatorType, firstName, lastName) {
+	var creator = { creatorType };
+	if (firstName) {
+		creator.firstName = firstName;
+		creator.lastName = lastName;
+	}
+	else {
+		creator.name = lastName;
+	}
+	return creator;
+};
+
+Zotero_Import_Mendeley.prototype._addExtraField = function (extra, field, val) {
+	// Strip the field if it appears at the beginning of the value (to avoid "DOI: DOI: 10...")
+	if (typeof val == 'string') {
+		val = val.replace(new RegExp(`^${field}:\s*`, 'i'), "");
+	}
+	extra = extra ? extra + '\n' : '';
+	if (field != 'arXiv') {
+		field = field[0].toUpperCase() + field.substr(1);
+		field = field.replace(/([a-z])([A-Z][a-z])/, "$1 $2");
+	}
+	return extra + `${field}: ${val}`;
+};
+
+Zotero_Import_Mendeley.prototype._convertNote = function (note) {
+	return note
+		// Add newlines after <br>
+		.replace(/<br\s*\/>/g, '<br\/>\n')
+		//
+		// Legacy pre-HTML stuff
+		//
+		// <m:linebreak>
+		.replace(/<m:linebreak><\/m:linebreak>/g, '<br/>')
+		// <m:bold>
+		.replace(/<(\/)?m:bold>/g, '<$1b>')
+		// <m:italic>
+		.replace(/<(\/)?m:italic>/g, '<$1i>')
+		// <m:center>
+		.replace(/<m:center>/g, '<p style="text-align: center;">')
+		.replace(/<\/m:center>/g, '</p>')
+		// <m:underline>
+		.replace(/<m:underline>/g, '<span style="text-decoration: underline;">')
+		.replace(/<\/m:underline>/g, '</span>');
+};
+
+Zotero_Import_Mendeley.prototype._saveItems = async function (libraryID, json) {
+	var idMap = new Map();
+	await Zotero.DB.executeTransaction(async function () {
+		for (let itemJSON of json) {
+			let item = new Zotero.Item;
+			item.libraryID = libraryID;
+			if (itemJSON.key) {
+				item.key = itemJSON.key;
+				await item.loadPrimaryData();
+			}
+			
+			// Remove external id before save
+			let toSave = Object.assign({}, itemJSON);
+			delete toSave.documentID;
+			
+			item.fromJSON(toSave);
+			await item.save({
+				skipSelect: true,
+				skipDateModifiedUpdate: true
+			});
+			if (itemJSON.documentID) {
+				idMap.set(itemJSON.documentID, item.id);
+			}
+		}
+	}.bind(this));
+	return idMap;
+};
+
+/**
+ * Saves attachments and extracted annotations for a given document
+ */
+Zotero_Import_Mendeley.prototype._saveFilesAndAnnotations = async function (files, libraryID, parentItemID, annotations) {
+	for (let file of files) {
+		try {
+			if (!file.fileURL) continue;
+			
+			let path = OS.Path.fromFileURI(file.fileURL);
+			
+			let attachment;
+			if (await OS.File.exists(path)) {
+				let options = {
+					libraryID,
+					parentItemID,
+					file: path
+				};
+				// If file is in Mendeley downloads folder, import it
+				if (OS.Path.dirname(path).endsWith(OS.Path.join('Mendeley Desktop', 'Downloaded'))) {
+					attachment = await Zotero.Attachments.importFromFile(options);
+				}
+				// Otherwise link it
+				else {
+					attachment = await Zotero.Attachments.linkFromFile(options);
+				}
+				attachment.relations = {
+					'mendeleyDB:fileHash': file.hash,
+					'mendeleyDB:fileUUID': file.uuid
+				};
+				await attachment.saveTx({
+					skipSelect: true
+				});
+			}
+			else {
+				Zotero.warn(path + " not found -- not importing");
+			}
+			
+			if (annotations) {
+				await this._saveAnnotations(
+					// We have annotations from all files for this document, so limit to just those on
+					// this file
+					annotations.filter(a => a.hash == file.hash),
+					parentItemID,
+					attachment ? attachment.id : null
+				);
+			}
+		}
+		catch (e) {
+			Zotero.logError(e);
+		}
+	}
+}
+
+Zotero_Import_Mendeley.prototype._saveAnnotations = async function (annotations, parentItemID, attachmentItemID) {
+	if (!annotations.length) return;
+	var noteStrings = [];
+	var parentItem = Zotero.Items.get(parentItemID);
+	var libraryID = parentItem.libraryID;
+	if (attachmentItemID) {
+		var attachmentItem = Zotero.Items.get(attachmentItemID);
+		var attachmentURIPath = Zotero.API.getLibraryPrefix(libraryID) + '/items/' + attachmentItem.key;
+	}
+	
+	for (let annotation of annotations) {
+		if (!annotation.note || !annotation.note.trim()) continue;
+		
+		let linkStr;
+		let linkText = `note on p. ${annotation.page}`;
+		if (attachmentItem) {
+			let url = `zotero://open-pdf/${attachmentURIPath}?page=${annotation.page}`;
+			linkStr = `<a href="${url}">${linkText}</a>`;
+		}
+		else {
+			linkStr = linkText;
+		}
+		
+		noteStrings.push(
+			Zotero.Utilities.text2html(annotation.note.trim())
+				+ `<p class="pdf-link" style="margin-top: -0.5em; margin-bottom: 2em; font-size: .9em; text-align: right;">(${linkStr})</p>`
+		);
+	}
+	
+	if (!noteStrings.length) return;
+	
+	let note = new Zotero.Item('note');
+	note.libraryID = libraryID;
+	note.parentItemID = parentItemID;
+	note.setNote('<h1>' + Zotero.getString('extractedAnnotations') + '</h1>\n' + noteStrings.join('\n'));
+	return note.saveTx({
+		skipSelect: true
+	});
+};

chrome/content/zotero/import/mendeley/mendeleySchemaMap.js

@@ -0,0 +1,102 @@
+var map = {
+	83: {
+		itemTypes: {
+			Bill: "bill",
+			Book: "book",
+			BookSection: "bookSection",
+			Case: "case",
+			ComputerProgram: "computerProgram",
+			ConferenceProceedings: "conferencePaper",
+			EncyclopediaArticle: "encyclopediaArticle",
+			Film: "film",
+			Generic: "document",
+			JournalArticle: "journalArticle",
+			MagazineArticle: "magazineArticle",
+			NewspaperArticle: "newspaperArticle",
+			Patent: "patent",
+			Report: "report",
+			Statute: "statute",
+			TelevisionBroadcast: "tvBroadcast",
+			Thesis: "thesis",
+			WebPage: "webpage",
+			WorkingPaper: "report"
+		},
+		fields: {
+			id: "",
+			uuid: "",
+			reviewedArticle: "",
+			revisionNumber: "",
+			publisher: "publisher",
+			reprintEdition: "",
+			series: "seriesTitle",
+			seriesNumber: "seriesNumber",
+			sections: "section",
+			seriesEditor: "creator[seriesEditor]", // falls back to editor if necessary
+			owner: "",
+			pages: "func[pages]",
+			month: "", // handled explicitly
+			originalPublication: "",
+			publication: "publicationTitle",
+			publicLawNumber: "publicLawNumber",
+			pmid: "extra[PMID]",
+			sourceType: "",
+			session: "session",
+			shortTitle: "shortTitle",
+			volume: "volume",
+			year: "", // handled explicitly
+			userType: "type",
+			country: "place[country]",
+			dateAccessed: "accessDate",
+			committee: "committee",
+			counsel: "creator[counsel]",
+			doi: "DOI",
+			edition: "edition",
+			day: "", // handled explicitly
+			department: "",
+			citationKey: "citationKey", // put in Extra
+			city: "place[city]",
+			chapter: "",
+			codeSection: "section",
+			codeVolume: "codeVolume",
+			code: "code",
+			codeNumber: "codeNumber",
+			issue: "issue",
+			language: "language",
+			isbn: "ISBN",
+			issn: "ISSN",
+			length: "",
+			medium: "medium",
+			lastUpdate: "",
+			legalStatus: "legalStatus",
+			hideFromMendeleyWebIndex: "",
+			institution: "publisher",
+			genre: "genre",
+			internationalTitle: "",
+			internationalUserType: "",
+			internationalAuthor: "",
+			internationalNumber: "",
+			deletionPending: "",
+			favourite: "", // tag?
+			confirmed: "", // tag?
+			deduplicated: "",
+			read: "", // tag?
+			type: "", // item type handled separately
+			title: "title",
+			privacy: "",
+			applicationNumber: "applicationNumber",
+			arxivId: "extra[arXiv]",
+			advisor: "",
+			articleColumn: "",
+			modified: "func[fromUnixtime:dateModified]",
+			abstract: "abstractNote",
+			added: "func[fromUnixtime:dateAdded]",
+			note: "func[note]",
+			importer: ""
+		},
+		creatorTypes: {
+			DocumentAuthor: "author",
+			DocumentEditor: "editor",
+			DocumentTranslator: "translator"
+		}
+	}
+};

chrome/content/zotero/xpcom/data/collection.js

@@ -712,7 +712,7 @@ Zotero.Collection.prototype.toJSON = function (options = {}) {
 	
 	obj.name = this.name;
 	obj.parentCollection = this.parentKey ? this.parentKey : false;
-	obj.relations = {}; // TEMP
+	obj.relations = this.getRelations();
 	
 	return this._postToJSON(env);
 }

chrome/content/zotero/xpcom/data/dataObject.js

@@ -285,7 +285,7 @@ Zotero.DataObject.prototype._setParentKey = function(key) {
 /**
  * Returns all relations of the object
  *
- * @return {Object} - Object with predicates as keys and arrays of URIs as values
+ * @return {Object} - Object with predicates as keys and arrays of values
  */
 Zotero.DataObject.prototype.getRelations = function () {
 	this._requireData('relations');
@@ -410,7 +410,7 @@ Zotero.DataObject.prototype.setRelations = function (newRelations) {
 	
 	// Limit predicates to letters and colons for now
 	for (let p in newRelations) {
-		if (!/[a-z]+:[a-z]+/.test(p)) {
+		if (!/^[a-z]+:[a-z]+$/i.test(p)) {
 			throw new Error(`Invalid relation predicate '${p}'`);
 		}
 	}

chrome/content/zotero/xpcom/data/relations.js

@@ -32,7 +32,8 @@ Zotero.Relations = new function () {
 	
 	this._namespaces = {
 		dc: 'http://purl.org/dc/elements/1.1/',
-		owl: 'http://www.w3.org/2002/07/owl#'
+		owl: 'http://www.w3.org/2002/07/owl#',
+		mendeleyDB: 'http://zotero.org/namespaces/mendeleyDB#'
 	};
 	
 	var _types = ['collection', 'item'];

chrome/content/zotero/xpcom/mime.js

@@ -47,8 +47,9 @@ Zotero.MIME = new function(){
 		["\uFFFDPNG", 'image/png', 0],
 		["JFIF", 'image/jpeg'],
 		["FLV", "video/x-flv", 0],
-		["\u0000\u0000\u0001\u0000", "image/vnd.microsoft.icon", 0]
-		
+		["\u0000\u0000\u0001\u0000", "image/vnd.microsoft.icon", 0],
+		["\u0053\u0051\u004C\u0069\u0074\u0065\u0020\u0066"
+			+ "\u006F\u0072\u006D\u0061\u0074\u0020\u0033\u0000", "application/x-sqlite3", 0]
 	];
 	
 	var _extensions = {

chrome/content/zotero/zoteroPane.xul

@@ -49,7 +49,7 @@
 	
 	<commandset id="mainCommandSet">
 		<command id="cmd_zotero_reportErrors" oncommand="ZoteroPane_Local.reportErrors();"/>
-		<command id="cmd_zotero_import" oncommand="Zotero_File_Interface.importFile();"/>
+		<command id="cmd_zotero_import" oncommand="Zotero_File_Interface.startImport();"/>
 		<command id="cmd_zotero_importFromClipboard" oncommand="Zotero_File_Interface.importFromClipboard();"/>
 		<command id="cmd_zotero_exportLibrary" oncommand="Zotero_File_Interface.exportFile();"/>
 		<command id="cmd_zotero_advancedSearch" oncommand="ZoteroPane_Local.openAdvancedSearchWindow();"/>

chrome/locale/en-US/zotero/zotero.dtd

@@ -202,6 +202,14 @@
 
 <!ENTITY zotero.progress.title							"Progress">
 
+<!ENTITY zotero.import                                 "Import">
+<!ENTITY zotero.import.whereToImportFrom               "Where do you want to import from?">
+<!ENTITY zotero.import.source.file                     "A file (BibTeX, RIS, Zotero RDF, etc.)">
+<!ENTITY zotero.import.importing                       "Importing…">
+<!ENTITY zotero.import.database                        "Database">
+<!ENTITY zotero.import.lastModified                    "Last Modified">
+<!ENTITY zotero.import.size                            "Size">
+
 <!ENTITY zotero.exportOptions.title						"Export…">
 <!ENTITY zotero.exportOptions.format.label				"Format:">
 <!ENTITY zotero.exportOptions.translatorOptions.label	"Translator Options">

chrome/locale/en-US/zotero/zotero.properties

@@ -69,6 +69,7 @@ general.processing      = Processing
 general.submitted      = Submitted
 general.thanksForHelpingImprove = Thanks for helping to improve %S!
 general.describeProblem			= Briefly describe the problem:
+general.nMegabytes                 = %S MB
 
 general.operationInProgress = A Zotero operation is currently in progress.
 general.operationInProgress.waitUntilFinished = Please wait until it has finished.
@@ -688,10 +689,12 @@ fileInterface.importComplete = Import Complete
 fileInterface.itemsWereImported = %1$S item was imported;%1$S items were imported
 fileInterface.itemsExported		= Exporting items…
 fileInterface.import			= Import
+fileInterface.chooseAppDatabaseToImport = Choose the %S database to import
 fileInterface.export			= Export
 fileInterface.exportedItems		= Exported Items
 fileInterface.imported 			= Imported
 fileInterface.unsupportedFormat = The selected file is not in a supported format.
+fileInterface.appDatabase      = %S Database
 fileInterface.viewSupportedFormats = View Supported Formats…
 fileInterface.untitledBibliography = Untitled Bibliography
 fileInterface.bibliographyHTMLTitle = Bibliography
@@ -1075,6 +1078,7 @@ rtfScan.rtf							= Rich Text Format (.rtf)
 rtfScan.saveTitle					= Select a location in which to save the formatted file
 rtfScan.scannedFileSuffix			= (Scanned)
 
+extractedAnnotations               = Extracted Annotations
 
 file.accessError.theFileCannotBeCreated = The file '%S' cannot be created.
 file.accessError.theFileCannotBeUpdated = The file '%S' cannot be updated.

chrome/skin/default/zotero/importWizard.css

@@ -0,0 +1,44 @@
+.wizard-header-label {
+	font-size: 16px;
+	font-weight: bold;
+}
+
+/* Start */
+wizard[currentpageid="page-start"] .wizard-header-label {
+	padding-top: 24px;
+}
+
+wizard[currentpageid="page-start"] .wizard-page-box {
+	margin-top: -2px;
+	padding-top: 0;
+}
+
+radiogroup {
+	font-size: 14px;
+	margin-top: 4px;
+}
+
+radio {
+	padding-top: 5px;
+}
+
+/* File options */
+wizard[currentpageid="page-file-options"] .wizard-header {
+	display: none;
+}
+
+#file-options-header {
+	font-size: 15px;
+	font-weight: bold;
+	margin-bottom: 6px;
+}
+
+listbox, #result-description {
+	font-size: 13px;
+}
+
+#result-report-error {
+	margin-top: 13px;
+	margin-left: 0;
+	font-size: 13px;
+}