@iebh/reflib 2.5.8 → 2.6.0

package/README.md

@@ -12,6 +12,7 @@ Compatibility
 
 | Library                | Extension(s)    | Read               | Write              |
 |------------------------|-----------------|--------------------|--------------------|
+| BibTeX                 | `.bib`          | :heavy_check_mark: | :heavy_check_mark: |
 | Comma Separated Values | `.csv`          | :x:                | :x:                |
 | EndNote ENL            | `.enl`          | :heavy_check_mark: | (untested)         |
 | EndNote ENLX           | `.enlx`         | :heavy_check_mark: | :x:                |
@@ -24,6 +25,8 @@ Compatibility
 
 **Notes on different formats**:
 
+* Not all formats are one-to-one translations, some have differing field definitions or type definitions
+* BibTeX support is only provided for "well-formatted" files - i.e. correct use of newlines rather than one-single-line-per-ref, this is to avoid having to implement a full AST parser
 * Medline seems to implement a totally different [publication type system](https://www.nlm.nih.gov/mesh/pubtypes.html) than others. Reflib will attempt to guess the best match, storing the original type in the `medlineType` key. Should the citation library be exported _back_ to Medline / `.nbib` files this key will take precedence to avoid data loss
 
 
@@ -36,40 +39,40 @@ Each reference has the following standardized fields, these are translated from
 
 | Field            | Type            | Description                                                                            |
 |------------------|-----------------|----------------------------------------------------------------------------------------|
-| recNumber        | `number`        | The sorting number of the reference. Not present in RIS files                          |
-| type             | `string`        | A supported [reference type](#reference-types) (e.g. journalArticle)                   |
-| title            | `string`        | The reference's main title                                                             |
-| journal          | `string`        | The reference's secondary title, this is usually the journal for most published papers |
-| authors          | `array<string>` | An array of each Author in the originally specified format                             |
-| date             | `string`        | The raw, internal date of the reference                                                |
-| urls             | `array<string>` | An array of each URL for the reference                                                 |
-| pages            | `string`        | The page reference, usually in the format `123-4`                                      |
-| volume           | `string`        |                                                                                        |
-| number           | `string`        |                                                                                        |
-| isbn             | `string`        |                                                                                        |
-| abstract         | `string`        |                                                                                        |
-| label            | `string`        |                                                                                        |
-| caption          | `string`        |                                                                                        |
-| notes            | `string`        |                                                                                        |
-| address          | `string`        |                                                                                        |
-| researchNotes    | `string`        |                                                                                        |
-| keywords         | `array<string>` | Optional list of keywords that apply to the reference                                  |
-| accessDate       | `string`        |                                                                                        |
-| accession        | `string`        | [Accession numbers spec](https://support.nlm.nih.gov/knowledgebase/article/KA-03434/en-us), can sometimes be the PubMed ID |
-| doi              | `string`        |                                                                                        |
-| section          | `string`        |                                                                                        |
-| language         | `string`        |                                                                                        |
-| researchNotes    | `string`        |                                                                                        |
-| databaseProvider | `string`        |                                                                                        |
-| database         | `string`        |                                                                                        |
-| workType         | `string`        |                                                                                        |
-| custom1          | `string`        |                                                                                        |
-| custom2          | `string`        |                                                                                        |
-| custom3          | `string`        |                                                                                        |
-| custom4          | `string`        |                                                                                        |
-| custom5          | `string`        |                                                                                        |
-| custom6          | `string`        |                                                                                        |
-| custom7          | `string`        |                                                                                        |
+| recNumber        | `Number`        | The sorting number of the reference. Not present in RIS files                          |
+| type             | `String`        | A supported [reference type](#reference-types) (e.g. journalArticle)                   |
+| title            | `String`        | The reference's main title                                                             |
+| journal          | `String`        | The reference's secondary title, this is usually the journal for most published papers |
+| authors          | `Array<String>` | An array of each Author in the originally specified format                             |
+| date             | `String`        | The raw, internal date of the reference                                                |
+| urls             | `Array<String>` | An array of each URL for the reference                                                 |
+| pages            | `String`        | The page reference, usually in the format `123-4`                                      |
+| volume           | `String`        |                                                                                        |
+| number           | `String`        |                                                                                        |
+| isbn             | `String`        |                                                                                        |
+| abstract         | `String`        |                                                                                        |
+| label            | `String`        |                                                                                        |
+| caption          | `String`        |                                                                                        |
+| notes            | `String`        |                                                                                        |
+| address          | `String`        |                                                                                        |
+| researchNotes    | `String`        |                                                                                        |
+| keywords         | `Array<String>` | Optional list of keywords that apply to the reference                                  |
+| accessDate       | `String`        |                                                                                        |
+| accession        | `String`        | [Accession numbers spec](https://support.nlm.nih.gov/knowledgebase/article/KA-03434/en-us), can sometimes be the PubMed ID |
+| doi              | `String`        |                                                                                        |
+| section          | `String`        |                                                                                        |
+| language         | `String`        |                                                                                        |
+| researchNotes    | `String`        |                                                                                        |
+| databaseProvider | `String`        |                                                                                        |
+| database         | `String`        |                                                                                        |
+| workType         | `String`        |                                                                                        |
+| custom1          | `String`        |                                                                                        |
+| custom2          | `String`        |                                                                                        |
+| custom3          | `String`        |                                                                                        |
+| custom4          | `String`        |                                                                                        |
+| custom5          | `String`        |                                                                                        |
+| custom6          | `String`        |                                                                                        |
+| custom7          | `String`        |                                                                                        |
 
 
 Reference Types
@@ -251,7 +254,7 @@ writeStream(moduleId, outputStream, options)
 Available: Node + Browser
 Low level worker of `writeFile()`.
 Return an object with methods to call to write to a given stream.
-The returned object will have a `start()`, `end()` and `write(ref)` function which can be called to write to the original input stream.
+The returned object will have a `start()`, `end()` and `write(ref)` (optional `middle(ref)`) function which can be called to write to the original input stream.
 
 ```javascript
 // Convert a JSON file to EndNoteXML via a stream

package/lib/formats.js

@@ -10,6 +10,14 @@
 * @property {boolean} canWrite Whether the format is supported when writing a citation library
 */
 export let formats = {
+	bibtex: {
+		id: 'bibtex',
+		title: 'BibTeX',
+		titleShort: 'BibTeX',
+		ext: ['.bib'],
+		canRead: true,
+		canWrite: false,
+	},
 	csv: {
 		id: 'csv',
 		title: 'Comma Seperated Values',

package/lib/writeFile.js

@@ -22,8 +22,9 @@ export function writeFile(path, refs, options) {
 
 	return Promise.resolve()
 		.then(()=> writer.start())
-		.then(()=> refs.reduce((chain, ref) => // Write all refs as a series of promises
-			chain.then(()=> writer.write(ref))
+		.then(()=> refs.reduce((chain, ref, refIndex, refs) => chain // Write all refs as a series of promises
+			.then(()=> writer.write(ref))
+			.then(()=> refIndex < refs.length && writer.middle && writer.middle(ref))
 		, Promise.resolve()))
 		.then(()=> writer.end())
 		.then(()=> fileStream.close())

package/modules/bibtex.js

@@ -0,0 +1,365 @@
+import Emitter from '../shared/emitter.js';
+
+/**
+* Lookup enum for the current parser mode we are in
+*
+* @type {Object<Number>}
+*/
+const MODES = {
+	REF: 0,
+	FIELDS: 1,
+	FIELD_START: 2,
+	FIELD_VALUE: 3,
+};
+
+
+/**
+* Parse a BibTeX file from a readable stream
+*
+* @see modules/interface.js
+*
+* @param {Stream} stream The readable stream to accept data from
+* @param {Object} [options] Additional options to use when parsing
+* @param {Boolean} [options.recNumberNumeric=true] Only process the BibTeX ID into a recNumber if its a finite numeric, otherwise disguard
+* @param {Boolean} [options.recNumberRNPrefix=true] Accept `RN${NUMBER}` as recNumber if present
+* @param {Boolean} [options.omitUnkown=false] If true, only keep known reconised fields
+* @param {String} [options.fallbackType='unkown'] Reflib fallback type if the incoming type is unrecognised or unsupported
+* @param {Set<String>} [options.fieldsOverwrite] Set of field names where the value is clobbered rather than appended if discovered more than once
+*
+* @returns {Object} A readable stream analogue defined in `modules/interface.js`
+*/
+export function readStream(stream, options) {
+	let settings = {
+		recNumberNumeric: true,
+		recNumberRNPrefix: true,
+		omitUnknown: false,
+		fallbackType: 'unknown',
+		fieldsOverwrite: new Set(['type']),
+		...options,
+	};
+
+	let emitter = Emitter();
+	let buffer = '';
+	let mode = MODES.REF;
+	let state; // Misc state storage when we're digesting ref data
+	let ref = {}; // Reference item being constructed
+
+	// Queue up the parser in the next tick (so we can return the emitter first)
+	setTimeout(()=> {
+		stream
+			.on('error', e => emitter.emit('error', e))
+			.on('end', ()=> emitter.emit('end'))
+			.on('data', chunkBuffer => {
+				emitter.emit('progress', stream.bytesRead);
+				buffer += chunkBuffer.toString(); // Append incomming data to the partial-buffer we're holding in memory
+
+				while (true) {
+					let match; // Regex storage for match groups
+					if ((mode == MODES.REF) && (match = /^\s*@(?<type>\w+?)\s*\{(?<id>.*?),/s.exec(buffer))) {
+						if (settings.recNumberNumeric && isFinite(match.groups.id)) { // Accept numeric recNumber
+							ref.recNumber = +match.groups.id;
+						} else if (settings.recNumberRNPrefix && /^RN\d+$/.test(match.groups.id)) {
+							ref.recNumber = +match.groups.id.slice(2);
+						} else if (!settings.recNumberNumeric && match.groups.id) { // Non numeric / finite ID - but we're allowed to accept it anyway
+							ref.recNumber = +match.groups.id;
+						} // Implied else - No ID, ignore
+
+						ref.type = match.groups.type;
+						mode = MODES.FIELDS;
+						state = null;
+					} else if (mode == MODES.FIELDS && (match = /^\s*(?<field>\w+?)\s*=\s*/s.exec(buffer))) {
+						mode = MODES.FIELD_START;
+						state = {field: match.groups.field};
+					} else if (mode == MODES.FIELDS && (match = /^\s*\}\s*/s.exec(buffer))) { // End of ref
+						emitter.emit('ref', tidyRef(ref, settings));
+						mode = MODES.REF;
+						ref = {};
+						state = null;
+					} else if (mode == MODES.FIELD_START && (match = /^\s*(?<fieldWrapper>"|{)\s*/.exec(buffer))) {
+						mode = MODES.FIELD_VALUE;
+						state.fieldWrapper = match.groups.fieldWrapper;
+					} else if (
+						// TODO: Note that we use `\r?\n` as delimiters for field values, this is a cheat to avoid having to implement a full AST parser
+						//       This is a hack but since most BibTeX files use properly formatted BibTeX this should work in the majority of cases
+						//       This WILL break if given one continuous line of BibTeX though
+						//       - MC 2026-01-02
+						mode == MODES.FIELD_VALUE
+						&& (
+							(
+								state.fieldWrapper == '{'
+								&& (match = /^(?<value>.+?)(?<!\\%)\}\s*,?\s*$/sm.exec(buffer))
+							)
+							|| (
+								state.fieldWrapper == '"'
+								&& (match = /^(?<value>.+?)"\s*,?\s*$/sm.exec(buffer))
+							)
+						)
+					) {
+						mode = MODES.FIELDS;
+						if (ref[state.field] !== undefined && settings.fieldsOverwrite.has(state.field)) { // Already have content - and we should overwrite
+							ref[state.field] = unescape(match.groups.value);
+						} else if (ref[state.field] !== undefined) { // Already have content - append
+							ref[state.field] += '\n' + unescape(match.groups.value);
+						} else { // Populate initial value
+							ref[state.field] = unescape(match.groups.value);
+						}
+						state = null;
+					} else { // Implied else - No match to buffer, let it fill and process next data block
+						break;
+					}
+
+					// Crop start of buffer to last match
+					buffer = buffer.slice(match[0].length);
+				}
+			})
+	})
+
+	return emitter;
+}
+
+
+/**
+* Tidy up a raw BibTeX reference before emitting
+*
+* @param {Object} ref The input raw ref to tidy
+*
+* @param {Object} settings Optimized settings object for fast access
+*
+* @returns {Object} The tidied ref
+*/
+export function tidyRef(ref, settings) {
+	return Object.fromEntries(
+		Object.entries(ref)
+			.map(([key, val]) => {
+				let rlField = translations.fields.btMap.get(key.toLowerCase());
+
+				if (key == 'type') { // Special conversion for type
+					let rlType = ref.type && translations.types.btMap.get(val.toLowerCase());
+					return rlType
+						? [key, rlType.rl] // Can translate incoming type to Reflib type
+						: [key, settings.fallbackType] // Unknown Reflib type varient
+				} else if (settings.omitUnkown && !rlField) { // Omit unknown fields
+					return;
+				} else if (rlField && rlField.array) { // Field needs array casting
+					return [rlField.rl, val.split(/\n*\s+and\s+/)];
+				} else if (rlField && rlField.rl) { // Known BT field but different RL field
+					return [rlField.rl, val];
+				} else if (!settings.omitUnkown) { // Everything else - add field
+					return [key, val];
+				}
+			})
+			.filter(Boolean) // Remove duds
+	);
+}
+
+
+/**
+* Translate a BibTeX encoded string into a regular JS String
+*
+* @param {String} str Input BibTeX encoded string
+* @returns {String} Regular JS output string
+*/
+export function unescape(str) {
+	return str
+		.replace(/\/\*/g, '\n')
+		.replace(/\{\\\&\}/g, '&')
+		.replace(/\{\\\%\}/g, '%')
+}
+
+
+/**
+* Translate a JS string into a BibTeX encoded string
+*
+* @param {String} str Input regular JS String
+* @returns {String} BibTeX encoded string
+*/
+export function escape(str) {
+	return (''+str)
+		.replace(/\&/g, '{\\&}')
+		.replace(/%/g, '{\\%}')
+}
+
+
+/**
+* Write a RIS file to a writable stream
+*
+* @see modules/interface.js
+*
+* @param {Stream} stream The writable stream to write to
+*
+* @param {Object} [options] Additional options to use when parsing
+* @param {string} [options.defaultType='Misc'] Default citation type to assume when no other type is specified
+* @param {string} [options.delimeter='\r'] How to split multi-line items
+* @param {Boolean} [options.omitUnkown=false] If true, only keep known reconised fields
+* @param {Set} [options.omitFields] Set of special fields to always omit, either because we are ignoring or because we have special treatment for them
+* @param {Boolean} [options.recNumberRNPrefix=true] Rewrite recNumber fields as `RN${NUMBER}`
+*
+* @returns {Object} A writable stream analogue defined in `modules/interface.js`
+*/
+export function writeStream(stream, options) {
+	let settings = {
+		defaultType: 'Misc',
+		delimeter: '\n',
+		omitUnkown: false,
+		omitFields: new Set(['recNumber', 'type']),
+		recNumberRNPrefix: true,
+		...options,
+	};
+
+	return {
+		start() {
+			return Promise.resolve();
+		},
+		write: ref => {
+			// Fetch Reflib type definition
+			let rlType = ref.type && translations.types.rlMap.get(ref.type.toLowerCase());
+			let btType = rlType?.bt || settings.defaultType;
+
+			stream.write(
+				'@' + btType + '{'
+				+ (
+					ref.recNumber && settings.recNumberRNPrefix ? `RN${ref.recNumber},`
+					: ref.recNumber ? `${ref.recNumber},`
+					: ''
+				) + '\n'
+				+ Object.entries(ref)
+					.filter(([key, val]) =>
+						val // We have a non-nullish val
+						&& !settings.omitFields.has(key)
+					)
+					.reduce((buf, [rawKey, rawVal], keyIndex, keys) => {
+						// Fetch Reflib field definition
+						let rlField = translations.fields.rlMap.get(rawKey)
+						if (!rlField && settings.omitUnkown) return buf; // Unknown field mapping - skip if were omitting unknown fields
+
+						let key = rlField ? rlField.bt : rawKey; // Use Reflib->BibTeX field mapping if we have one, otherwise use raw key
+						let val = escape( // Escape input value, either as an Array via join or as a flat string
+							rawKey == 'authors' && Array.isArray(rawVal) ? rawVal.join('\nand ') // Special joining conditions for author field
+							: Array.isArray(rawVal) ? rawVal.join(', ') // Treat other arrays as a CSV
+							: rawVal // Splat everything else as a string
+						);
+
+						return buf + // Return string buffer of ref under construction
+							`${key}={${val}}` // Append ref key=val pair to buffer
+							+ (keyIndex < keys.length-1 ? ',' : '') // Append comma (if non-last)
+							+ '\n' // Finish each field with a newline
+					}, '')
+				+ '}\n'
+			);
+
+			return Promise.resolve();
+		},
+		middle() {
+			stream.write('\n');
+		},
+		end() {
+			return new Promise((resolve, reject) =>
+				stream.end(err => err ? reject(err) : resolve())
+			);
+		},
+	};
+}
+
+
+/**
+* Lookup tables for this module
+* @type {Object}
+* @property {Array<Object>} fields Field translations between Reflib (`rl`) and BibTeX format (`bt`)
+*/
+export let translations = {
+	// Field translations {{{
+	fields: {
+		collection: [
+			// Order by priority (highest at top)
+			{rl: 'address', bt: 'address'},
+			{rl: 'authors', bt: 'author', array: true},
+			{rl: 'doi', bt: 'doi'},
+			{rl: 'edition', bt: 'edition'},
+			{rl: 'editor', bt: 'editor'},
+			{rl: 'journal', bt: 'journal'},
+			{rl: 'notes', bt: 'note'},
+			{rl: 'number', bt: 'number'},
+			{rl: 'pages', bt: 'pages'},
+			{rl: 'title', bt: 'booktitle'},
+			{rl: 'title', bt: 'title'},
+			{rl: 'volume', bt: 'volume'},
+			{rl: 'isbn', bt: 'issn'},
+
+			// Misc
+			{bt: 'month'}, // Combined into {rl:'date'}
+			{bt: 'type'}, // Ignored
+			{bt: 'year'}, // Combined into {rl:'date'}
+
+			// Nonestandard but used anyway
+			{rl: 'abstract', bt: 'abstract'},
+			{rl: 'language', bt: 'language'},
+			{rl: 'keywords', bt: 'keywords', array: true},
+			{rl: 'urls', bt: 'url', array: true},
+
+			// Unknown how to translate these
+			// {bt: 'annote'},
+			// {bt: 'email'},
+			// {bt: 'chapter'},
+			// {bt: 'crossref'},
+			// {bt: 'howpublished'},
+			// {bt: 'institution'},
+			// {bt: 'key'},
+			// {bt: 'organization'},
+			// {bt: 'publisher'},
+			// {bt: 'school'},
+			// {bt: 'series'},
+		],
+		rlMap: new Map(),
+		btMap: new Map(),
+	},
+	// }}}
+	// Ref type translations {{{
+	types: {
+		collection: [
+			// Order by priority (highest at top)
+			{rl: 'journalArticle', bt: 'Article'},
+			{rl: 'book', bt: 'Book'},
+			{rl: 'bookSection', bt: 'InBook'},
+			{rl: 'conferencePaper', bt: 'Conference'},
+			{rl: 'conferenceProceedings', bt: 'InProceedings'},
+			{rl: 'report', bt: 'TechReport'},
+			{rl: 'thesis', bt: 'PHDThesis'},
+			{rl: 'unknown', bt: 'Misc'},
+			{rl: 'unpublished', bt: 'Unpublished'},
+
+			// Type aliases
+			{rl: 'journalArticle', bt: 'Journal Article'},
+
+			// Unknown how to translate these
+			{rl: 'Misc', bt: 'Booklet'},
+			{rl: 'Misc', bt: 'InCollection'},
+			{rl: 'Misc', bt: 'Manual'},
+			{rl: 'Misc', bt: 'MastersThesis'},
+			{rl: 'Misc', bt: 'Proceedings'},
+		],
+		rlMap: new Map(),
+		btMap: new Map(),
+	},
+	// }}}
+};
+
+
+/**
+* @see modules/interface.js
+*/
+export function setup() {
+	// Create lookup object of translations.fields with key as .rl / val as the full object
+	translations.fields.collection.forEach(c => {
+		if (c.rl) translations.fields.rlMap.set(c.rl.toLowerCase(), c);
+		if (c.bt) translations.fields.btMap.set(c.bt, c);
+	});
+
+	// Create lookup object of ref.types with key as .rl / val as the full object
+	translations.types.collection.forEach(c => {
+		// Append each type to the set, accepting the first in each case as the priority
+		let rlLc = c.rl.toLowerCase();
+		let btLc = c.bt.toLowerCase();
+		if (c.rl && !translations.types.rlMap.has(rlLc)) translations.types.rlMap.set(rlLc, c);
+		if (c.bt && !translations.types.btMap.has(btLc)) translations.types.btMap.set(btLc, c);
+	});
+}

package/modules/default.js

@@ -1,3 +1,4 @@
+export * as bibtex from './bibtex.js';
 export * as json from './json.js';
 export * as endnoteEnl from './endnoteEnl.js';
 export * as endnoteEnlX from './endnoteEnlX.js';

package/modules/interface.js

@@ -30,6 +30,7 @@ export function readStream(stream, options) {
 * @returns {Object} An object which exposes methods to call to start, write and end the writing process. All methods MUST return a Promise
 * @property {function<Promise>} start Function to call when beginning to write
 * @property {function<Promise>} write Function called as `(ref)` when writing a single ref
+* @property {function<promise>} [middle] Function to call after `write()` for each reference if the reference is NOT last, this works similar to `Array.prototype.join()`
 * @property {function<Promise>} end Function to call when finishing writing, must resolve its Promise when the stream has closed successfully
 */
 export function writeStream(stream, refs, options) {

package/modules/ris.js

@@ -9,6 +9,8 @@ import Emitter from '../shared/emitter.js';
 * @param {Object} [options] Additional options to use when parsing
 * @param {string} [options.defaultType='report'] Default citation type to assume when no other type is specified
 * @param {string} [options.delimeter='\r'] How to split multi-line items
+* @param {Boolean} [options.convertAbstract=true] If the `fallbackAbstract` field exists but not `abstract` use the former as the latter
+* @param {Boolean} [options.convertCity=true] If the `fallbackCity` field exists but not `city` use the former as the latter
 *
 * @returns {Object} A readable stream analogue defined in `modules/interface.js`
 */
@@ -16,6 +18,8 @@ export function readStream(stream, options) {
 	let settings = {
 		defaultType: 'journalArticle',
 		delimeter: '\r',
+		convertAbtract: true,
+		convertCity: true,
 		...options,
 	};
 
@@ -132,6 +136,7 @@ export function writeStream(stream, options) {
 *
 * @param {string} refString Raw RIS string composing the start -> end of the ref
 * @param {Object} settings Additional settings to pass, this should be initialized + parsed by the calling function for efficiency, see readStream() for full spec
+* @param {Boolean} [settings.convertAbstract=true] If the `fallbackAbstract` field exists but not `abstract` use the former as the latter
 * @returns {ReflibRef} The parsed reference
 */
 export function parseRef(refString, settings) {
@@ -185,6 +190,18 @@ export function parseRef(refString, settings) {
 		delete ref._pageEnd;
 	}
 	// }}}
+	// FallbackAbstract -> Abstract (if the latter is missing) {{{
+	if ((settings.fallbackAbstract ?? true) && ref.fallbackAbstract && !ref.abstract) {
+		ref.abstract = ref.fallbackAbstract;
+		delete ref.fallbackAbstract;
+	}
+	// }}}
+	// FallbackCity -> City (if the latter is missing) {{{
+	if ((settings.fallbackCity ?? true) && ref.fallbackCity && !ref.abstract) {
+		ref.city = ref.fallbackCity;
+		delete ref.fallbackCity;
+	}
+	// }}}
 
 	return ref;
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@iebh/reflib",
-  "version": "2.5.8",
+  "version": "2.6.0",
   "description": "Reference / Citation reference library utilities",
   "scripts": {
-    "lint": "eslint .",
-    "test": "mocha",
+    "lint": "eslint",
+    "test": "testa",
     "test:browser": "cd test/browser && npm run dev",
     "test:watch": "nodemon --exec npm run test"
   },
@@ -20,7 +20,9 @@
   ],
   "author": "Matt Carter <m@ttcarter.com> (https://github.com/hash-bang)",
   "contributors": [
-    "Connor Forbes <cforbes.software@gmail.com> (https://github.com/connorf25)"
+    "Connor Forbes <cforbes.software@gmail.com> (https://github.com/connorf25)",
+    "Irene Priya Jose (https://github.com/s5333384)",
+    "Tian Liang (https://github.com/Octian)"
   ],
   "license": "MIT",
   "bugs": {
@@ -44,22 +46,21 @@
     "htmlparser2/lib/esm/WritableStream": "./modules/shims/WritableStream-browser.js",
     "JSONStream": "./modules/shims/JSONStream-browser.js"
   },
-  "devDependencies": {
-    "@momsfriendlydevco/eslint-config": "^2.3.1",
-    "chai": "^5.2.0",
-    "eslint": "^9.31.0",
-    "mocha": "^11.1.0",
-    "mocha-logger": "^1.0.8",
-    "nodemon": "^3.1.9",
-    "temp": "^0.9.4",
-    "vite-plugin-replace": "^0.1.1"
-  },
   "dependencies": {
     "@iebh/cacx": "^1.0.3",
     "@zip.js/zip.js": "^2.7.57",
     "htmlparser2": "^9.1.0",
     "JSONStream": "^1.3.5",
+    "lodash-es": "^4.17.22",
     "mitt": "^3.0.1",
     "sql.js": "^1.12.0"
+  },
+  "devDependencies": {
+    "@momsfriendlydevco/eslint-config": "^2.3.1",
+    "@momsfriendlydevco/testa": "^1.1.2",
+    "eslint": "^9.31.0",
+    "nodemon": "^3.1.9",
+    "temp": "^0.9.4",
+    "vite-plugin-replace": "^0.1.1"
   }
 }