5etools-utils 0.3.0 → 0.4.0

package/lib/Api.js

@@ -1,9 +1,19 @@
 import {JsonTester} from "./TestJson.js";
-import * as Um from "./UtilMisc.js";
+import Um from "./UtilMisc.js";
 import * as Uf from "./UtilFs.js";
+import {BrewIndexGenerator} from "./BrewIndexGenerator.js";
+import {BrewCleaner} from "./BrewCleaner.js";
+import {BrewTimestamper} from "./BrewTimestamper.js";
+import {SITE_SOURCES} from "./UtilSources.js";
+import {getCleanJson} from "./UtilClean.js";
 
 export {
 	JsonTester,
 	Um,
 	Uf,
+	BrewIndexGenerator,
+	BrewCleaner,
+	BrewTimestamper,
+	SITE_SOURCES,
+	getCleanJson,
 };

package/lib/BrewCleaner.js

@@ -0,0 +1,126 @@
+// Adapted from 5etools `clean-jsons.js`
+// ===
+
+import * as fs from "fs";
+import * as Uf from "./UtilFs.js";
+import Um from "./UtilMisc.js";
+import {getCleanJson} from "./UtilClean.js";
+import {SITE_SOURCES} from "./UtilSources.js";
+
+class BrewCleaner {
+	static _IS_FAIL_SLOW = !!process.env.FAIL_SLOW;
+	static _SITE_SOURCES = new Set(SITE_SOURCES);
+
+	static _RUN_TIMESTAMP = Math.floor(Date.now() / 1000);
+	static _MAX_TIMESTAMP = 9999999999;
+
+	static _CONTENT_KEY_BLOCKLIST = new Set(["$schema", "_meta", "siteVersion"]);
+
+	static _RE_INVALID_WINDOWS_CHARS = /[<>:"/\\|?*]/g;
+
+	static _ALL_SOURCES_JSON_LOWER = new Set();
+
+	static _cleanFolder (folder) {
+		const ALL_ERRORS = [];
+
+		const files = Uf.listJsonFiles(folder);
+		for (const file of files) {
+			let contents = Uf.readJSON(file);
+
+			if (this._RE_INVALID_WINDOWS_CHARS.test(file.split("/").slice(1).join("/"))) {
+				ALL_ERRORS.push(`${file} contained invalid characters!`);
+				if (!this._IS_FAIL_SLOW) break;
+			}
+
+			if (!file.endsWith(".json")) {
+				ALL_ERRORS.push(`${file} had invalid extension! Should be ".json" (case-sensitive).`);
+				if (!this._IS_FAIL_SLOW) break;
+			}
+
+			// region clean
+			// Ensure _meta is at the top of the file
+			const tmp = {$schema: contents.$schema, _meta: contents._meta};
+			delete contents.$schema;
+			delete contents._meta;
+			Object.assign(tmp, contents);
+			contents = tmp;
+
+			if (contents._meta.dateAdded == null) {
+				Um.warn(`TIMESTAMPS`, `\tFile "${file}" did not have "dateAdded"! Adding one...`);
+				contents._meta.dateAdded = this._RUN_TIMESTAMP;
+			} else if (contents._meta.dateAdded > this._MAX_TIMESTAMP) {
+				Um.warn(`TIMESTAMPS`, `\tFile "${file}" had a "dateAdded" in milliseconds! Converting to seconds...`);
+				contents._meta.dateAdded = Math.round(contents._meta.dateAdded / 1000);
+			}
+
+			if (contents._meta.dateLastModified == null) {
+				Um.warn(`TIMESTAMPS`, `\tFile "${file}" did not have "dateLastModified"! Adding one...`);
+				contents._meta.dateLastModified = this._RUN_TIMESTAMP;
+			} else if (contents._meta.dateLastModified > this._MAX_TIMESTAMP) {
+				Um.warn(`TIMESTAMPS`, `\tFile "${file}" had a "dateLastModified" in milliseconds! Converting to seconds...`);
+				contents._meta.dateLastModified = Math.round(contents._meta.dateLastModified / 1000);
+			}
+
+			(contents._meta.sources || []).forEach(source => {
+				if (source.version != null) return;
+				Um.warn(`VERSION`, `\tFile "${file}" source "${source.json}" did not have "version"! Adding one...`);
+				source.version = "unknown";
+			});
+			// endregion
+
+			// region test
+			const docSourcesJson = contents._meta.sources.map(src => src.json);
+			const duplicateSourcesJson = docSourcesJson.filter(src => this._ALL_SOURCES_JSON_LOWER.has(src.toLowerCase()));
+			if (duplicateSourcesJson.length) {
+				ALL_ERRORS.push(`${file} :: "json" source${duplicateSourcesJson.length === 1 ? "" : "s"} exist in other documents; sources were: ${duplicateSourcesJson.map(src => `"${src}"`).join(", ")}`);
+			}
+			docSourcesJson.forEach(src => this._ALL_SOURCES_JSON_LOWER.add(src.toLowerCase()));
+
+			const validSources = new Set(docSourcesJson);
+			validSources.add("UAClassFeatureVariants"); // Allow CFV UA sources
+
+			Object.keys(contents)
+				.filter(k => !this._CONTENT_KEY_BLOCKLIST.has(k))
+				.forEach(k => {
+					const data = contents[k];
+
+					if (!(data instanceof Array) || !data.forEach) throw new Error(`File "${k}" data was not an array!`);
+
+					if (!data.length) throw new Error(`File "${k}" array is empty!`);
+
+					data.forEach(it => {
+						const source = it.source || (it.inherits ? it.inherits.source : null);
+						if (!source) return ALL_ERRORS.push(`${file} :: ${k} :: "${it.name || it.id}" had no source!`);
+						if (!validSources.has(source) && !this._SITE_SOURCES.has(source)) return ALL_ERRORS.push(`${file} :: ${k} :: "${it.name || it.id}" source "${source}" was not in _meta`);
+					});
+				});
+			// endregion
+
+			if (!this._IS_FAIL_SLOW && ALL_ERRORS.length) break;
+
+			Um.info(`CLEANER`, `\t- "${file}"...`);
+			contents = getCleanJson(contents);
+
+			fs.writeFileSync(file, contents);
+		}
+
+		if (ALL_ERRORS.length) {
+			ALL_ERRORS.forEach(e => console.error(e));
+			throw new Error(`Errors were found. See above.`);
+		}
+
+		return files.length;
+	}
+
+	static run () {
+		let totalFiles = 0;
+		Uf.runOnDirs((dir) => {
+			Um.info(`CLEANER`, `Cleaning dir "${dir}"...`);
+			totalFiles += this._cleanFolder(dir);
+		});
+
+		Um.info(`CLEANER`, `Cleaning complete. Cleaned ${totalFiles} file${totalFiles === 1 ? "" : "s"}.`);
+	}
+}
+
+export {BrewCleaner};

package/lib/BrewIndexGenerator.js

@@ -0,0 +1,173 @@
+import * as fs from "fs";
+import * as Uf from "./UtilFs.js";
+import Um from "./UtilMisc.js";
+
+class _BrewIndex {
+	static _FILE_PATH;
+	static _DISPLAY_NAME;
+
+	_index = {};
+
+	doWrite () {
+		Um.info(`INDEX`, `Saving ${this.constructor._DISPLAY_NAME} index to ${this.constructor._FILE_PATH}`);
+		fs.writeFileSync(`./${this.constructor._FILE_PATH}`, JSON.stringify(this._index), "utf-8");
+	}
+
+	/** @abstract */
+	addToIndex (fileInfo) { throw new Error("Unimplemented!"); }
+}
+
+class _BrewIndexTimestamps extends _BrewIndex {
+	static _FILE_PATH = "_generated/index-timestamps.json";
+	static _DISPLAY_NAME = "timestamp";
+
+	addToIndex (fileInfo) {
+		this._index[fileInfo.cleanName] = {
+			a: fileInfo.contents._meta.dateAdded,
+			m: fileInfo.contents._meta.dateLastModified,
+		};
+	}
+}
+
+class _BrewIndexProps extends _BrewIndex {
+	static _FILE_PATH = "_generated/index-props.json";
+	static _DISPLAY_NAME = "prop";
+
+	addToIndex (fileInfo) {
+		Object.keys(fileInfo.contents)
+			.filter(it => !it.startsWith("_") && it !== "$schema")
+			.forEach(k => {
+				(this._index[k] = this._index[k] || {})[fileInfo.cleanName] = fileInfo.folder;
+			});
+
+		Object.keys(fileInfo.contents._meta.includes || {})
+			.forEach(k => {
+				(this._index[k] = this._index[k] || {})[fileInfo.cleanName] = fileInfo.folder;
+			});
+	}
+}
+
+class _BrewIndexSources extends _BrewIndex {
+	static _FILE_PATH = "_generated/index-sources.json";
+	static _DISPLAY_NAME = "source";
+
+	addToIndex (fileInfo) {
+		(fileInfo.contents._meta.sources || [])
+			.forEach(src => {
+				if (this._index[src.json]) throw new Error(`${fileInfo.name} source "${src.json}" was already in ${this._index[src.json]}`);
+				this._index[src.json] = fileInfo.cleanName;
+			});
+	}
+}
+
+class _BrewIndexMeta extends _BrewIndex {
+	static _FILE_PATH = "_generated/index-meta.json";
+	static _DISPLAY_NAME = "meta";
+
+	addToIndex (fileInfo) {
+		if (!fileInfo.contents._meta.sources?.length) return;
+
+		const fileName = fileInfo.name.split("/").slice(1).join("/");
+
+		if (this._index[fileName]) throw new Error(`Filename "${fileName}" was already in the index!`);
+		this._index[fileName] = {
+			// name
+			n: fileInfo.contents._meta.sources.map(it => it.full).filter(Boolean),
+			// abbreviation
+			a: fileInfo.contents._meta.sources.map(it => it.abbreviation).filter(Boolean),
+			// status
+			s: fileInfo.contents._meta.status,
+		};
+	}
+}
+
+class BrewIndexGenerator {
+	static _DIR_TO_PRIMARY_PROP = {
+		"creature": [
+			"monster",
+		],
+		"book": [
+			"book",
+			"bookData",
+		],
+		"adventure": [
+			"adventure",
+			"adventureData",
+		],
+		"makebrew": [
+			"makebrewCreatureTrait",
+		],
+	};
+
+	static _checkFileContents () {
+		Um.info(`PROP_CHECK`, `Checking file contents...`);
+		const results = [];
+		Uf.runOnDirs((dir) => {
+			if (dir === "collection") return;
+
+			Um.info(`PROP_CHECK`, `Checking dir "${dir}"...`);
+			const dirFiles = fs.readdirSync(dir, "utf8")
+				.filter(file => file.endsWith(".json"));
+
+			dirFiles.forEach(file => {
+				const json = JSON.parse(fs.readFileSync(`${dir}/${file}`, "utf-8"));
+				const props = this._DIR_TO_PRIMARY_PROP[dir] || [dir];
+				props.forEach(prop => {
+					if (!json[prop]) results.push(`${dir}/${file} was missing a "${prop}" property!`);
+				});
+			});
+		});
+
+		if (results.length) {
+			results.forEach(r => Um.error(`PROP_CHECK`, r));
+			throw new Error(`${results.length} file${results.length === 1 ? " was missing a primary prop!" : "s were missing primary props!"} See above for more info.`);
+		}
+
+		Um.info(`PROP_CHECK`, `Complete.`);
+	}
+
+	static _buildDeepIndex () {
+		const indexes = [
+			new _BrewIndexTimestamps(),
+			new _BrewIndexProps(),
+			new _BrewIndexSources(),
+			new _BrewIndexMeta(),
+		];
+
+		Um.info(`INDEX`, `Indexing...`);
+
+		Uf.runOnDirs((folder) => {
+			Um.info(`INDEX`, `Indexing dir "${folder}"...`);
+
+			Uf.listJsonFiles(folder)
+				.map(file => ({
+					folder,
+					name: file,
+					cleanName: file.replace(/#/g, "%23"),
+					contents: Uf.readJSON(file),
+				}))
+				.forEach(fileInfo => {
+					if (!fileInfo.contents._meta) {
+						throw new Error(`File "${fileInfo.name}" did not have metadata!`);
+					}
+
+					if (fileInfo.contents._meta.unlisted) return;
+
+					indexes.forEach(index => index.addToIndex(fileInfo));
+				});
+		});
+
+		fs.mkdirSync("_generated", {recursive: true});
+
+		indexes.forEach(index => index.doWrite());
+	}
+
+	static run () {
+		this._checkFileContents();
+		this._buildDeepIndex();
+		Um.info(`INDEX`, `Complete.`);
+		return null;
+	}
+}
+
+export {BrewIndexGenerator};

package/lib/BrewTimestamper.js

@@ -0,0 +1,102 @@
+import {execFile} from "node:child_process";
+import * as Uf from "./UtilFs.js";
+import Um from "./UtilMisc.js";
+import fs from "fs";
+import hasha from "hasha";
+import {getCleanJson} from "./UtilClean.js";
+
+class BrewTimestamper {
+	static _LOG_TAG = `TIMESTAMPS`;
+
+	static _UPDATE_TYPES = {
+		NONE: 0,
+		HASH: 1,
+		TIMESTAMP: 2,
+	};
+
+	static async _pUpdateDir (dir) {
+		const promises = Uf.listJsonFiles(dir)
+			.map(async file => {
+				const fileData = Uf.readJSON(file, {isIncludeRaw: true});
+
+				if (!fileData.json._meta) {
+					throw new Error(`File "${file}" did not have metadata!`);
+				}
+
+				let updateType = this._UPDATE_TYPES.NONE;
+
+				// We hash the file without `dateAdded`, `dateLastModified`, and `_dateLastModifiedHash` to ensure the hash
+				//   is stable when changing date values.
+				const toHashObj = {...fileData.json};
+				toHashObj._meta = {...toHashObj._meta, dateAdded: undefined, dateLastModified: undefined, _dateLastModifiedHash: undefined};
+				const expectedHash = (await hasha.async(JSON.stringify(toHashObj))).slice(0, 10);
+
+				if (!fileData.json._meta._dateLastModifiedHash) {
+					updateType = this._UPDATE_TYPES.HASH;
+					fileData.json._meta._dateLastModifiedHash = expectedHash;
+				} else if (expectedHash !== fileData.json._meta._dateLastModifiedHash) {
+					// Grab the last commit timestamp from the log.
+					// This is often a "junk" commit generated by cleaning (or indeed, timestamping) the file, but this is
+					//   good enough.
+					const dateLastModified = await new Promise((resolve, reject) => {
+						execFile(
+							"git",
+							["log", "-1", `--format="%ad"`, file],
+							{
+								windowsHide: true,
+							},
+							(err, stdout, stderr) => {
+								if (err) return reject(err);
+								resolve(Math.round(new Date(stdout.trim()).getTime() / 1000));
+							},
+						);
+					});
+
+					if (fileData.json._meta.dateLastModified < dateLastModified) {
+						updateType = this._UPDATE_TYPES.TIMESTAMP;
+						fileData.json._meta.dateLastModified = dateLastModified;
+						fileData.json._meta._dateLastModifiedHash = expectedHash;
+					}
+				}
+
+				if (updateType === this._UPDATE_TYPES.NONE) return;
+
+				const strContents = getCleanJson(fileData.json);
+
+				await new Promise((resolve, reject) => {
+					fs.writeFile(
+						file,
+						strContents,
+						(err) => {
+							if (err) return reject(err);
+							resolve();
+						},
+					);
+				});
+
+				Um.info(
+					this._LOG_TAG,
+					updateType === this._UPDATE_TYPES.HASH
+						? `\t- Updated "_dateLastModifiedHash" for "${file}"...`
+						: `\t- Updated "dateLastModified" for "${file}"...`,
+				);
+			});
+
+		await Promise.all(promises);
+	}
+
+	static async pRun () {
+		await Uf.pRunOnDirs(
+			async (dir) => {
+				Um.info(this._LOG_TAG, `Updating dateLastModified timestamps in dir "${dir}"...`);
+				await this._pUpdateDir(dir);
+			},
+			{
+				isSerial: true,
+			},
+		);
+		Um.info(this._LOG_TAG, "Done!");
+	}
+}
+
+export {BrewTimestamper};

package/lib/TestJson.js

@@ -7,8 +7,8 @@ import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";
 import * as jsonSourceMap from "json-source-map";
 
-import * as uf from "./UtilFs.js";
-import * as um from "./UtilMisc.js";
+import * as Uf from "./UtilFs.js";
+import Um from "./UtilMisc.js";
 import {WorkerList, Deferred} from "./WorkerList.js";
 
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
@@ -23,12 +23,20 @@ class JsonTester {
 
 	constructor (
 		{
-			dirSchema,
+			fnGetSchemaId,
+
+			isBrew = false,
+			dirSchema = null,
 			tagLog = LOG_TAG,
-			fnGetSchemaId = () => "homebrew.json",
 		},
 	) {
-		this._dirSchema = dirSchema;
+		if (isBrew && dirSchema) throw new Error(`"isBrew" and "dirSchema" are mutually exclusive!`);
+		if (!fnGetSchemaId) throw new Error(`"fnGetSchemaId" is required!`);
+
+		this._dirSchema = dirSchema ??
+			(isBrew
+				? path.join(__dirname, "..", "schema", "brew")
+				: path.join(__dirname, "..", "schema", "site"));
 		this._tagLog = tagLog;
 		this._fnGetSchemaId = fnGetSchemaId;
 
@@ -98,7 +106,7 @@ class JsonTester {
 		});
 
 		const error = this._getFileErrors({filePath});
-		um.error(this._tagLog, error);
+		Um.error(this._tagLog, error);
 		out.errors.push(error);
 
 		return out;
@@ -107,10 +115,10 @@ class JsonTester {
 	_doLoadSchema () {
 		if (this._isSchemaLoaded) return;
 
-		uf.listJsonFiles(this._dirSchema)
+		Uf.listJsonFiles(this._dirSchema)
 			.forEach(filePath => {
 				filePath = path.normalize(filePath);
-				const contents = uf.readJSON(filePath);
+				const contents = Uf.readJSON(filePath);
 
 				const relativeFilePath = path.relative(this._dirSchema, filePath)
 					.replace(/\\/g, "/");
@@ -121,12 +129,17 @@ class JsonTester {
 		this._isSchemaLoaded = true;
 	}
 
+	_hasSchema (schemaId) {
+		this._doLoadSchema();
+		return !!this._ajv.schemas[schemaId];
+	}
+
 	getFileErrors ({filePath} = {}) {
 		this._doLoadSchema();
 
-		um.info(this._tagLog, `\tValidating "${filePath}"...`);
+		Um.info(this._tagLog, `\tValidating "${filePath}"...`);
 
-		const data = uf.readJSON(filePath);
+		const data = Uf.readJSON(filePath);
 		this._addImplicits(data);
 
 		const isValid = this._ajv.validate(this._fnGetSchemaId(filePath), data);
@@ -136,7 +149,7 @@ class JsonTester {
 	}
 
 	_doRunOnDir ({isFailFast, dir, errors, errorsFull, ...opts} = {}) {
-		for (const filePath of uf.listJsonFiles(dir, opts)) {
+		for (const filePath of Uf.listJsonFiles(dir, opts)) {
 			const {errors: errorsFile, errorsFull: errorsFullFile} = this.getFileErrors({filePath});
 			errors.push(...errorsFile);
 			errorsFull.push(...errorsFullFile);
@@ -150,7 +163,7 @@ class JsonTester {
 	 * @param [opts.dirBlocklist]
 	 */
 	getErrors (dir, opts = {}) {
-		um.info(this._tagLog, `Validating JSON against schema`);
+		Um.info(this._tagLog, `Validating JSON against schema`);
 
 		const errors = [];
 		const errorsFull = [];
@@ -161,12 +174,12 @@ class JsonTester {
 	}
 
 	getErrorsOnDirs ({isFailFast = false} = {}) {
-		um.info(this._tagLog, `Validating JSON against schema`);
+		Um.info(this._tagLog, `Validating JSON against schema`);
 
 		const errors = [];
 		const errorsFull = [];
 
-		uf.runOnDirs((dir) => {
+		Uf.runOnDirs((dir) => {
 			if (isFailFast && errors.length) return;
 			return this._doRunOnDir({isFailFast, errors, errorsFull, dir});
 		});
@@ -174,19 +187,30 @@ class JsonTester {
 		return {errors, errorsFull};
 	}
 
-	async pGetErrorsOnDirsWorkers ({isFailFast = false} = {}) {
-		um.info(this._tagLog, `Validating JSON against schema`);
+	async pGetErrorsOnDirsWorkers ({isFailFast = false, fileList = null} = {}) {
+		Um.info(this._tagLog, `Validating JSON against schema`);
 
 		const cntWorkers = Math.max(1, os.cpus().length - 1);
 
 		const errors = [];
 		const errorsFull = [];
 
-		const fileQueue = [];
+		const fileQueue = [...(fileList || [])];
 
-		uf.runOnDirs((dir) => {
-			fileQueue.push(...uf.listJsonFiles(dir));
+		if (!fileList) {
+			Uf.runOnDirs((dir) => {
+				fileQueue.push(...Uf.listJsonFiles(dir));
+			});
+		}
+
+		// region Verify that every file path maps to a valid schema
+		fileQueue.forEach(filePath => {
+			const schemaId = this._fnGetSchemaId(filePath);
+			if (!schemaId) throw new Error(`Failed to get schema ID for file path "${filePath}"`);
+			if (!this._hasSchema(schemaId)) throw new Error(`No schema loaded with schema ID "${schemaId}"`);
+			return schemaId;
 		});
+		// endregion
 
 		const workerList = new WorkerList();
 

package/lib/UtilClean.js

@@ -0,0 +1,35 @@
+const _CLEAN_JSON_REPLACEMENTS = {
+	"—": "\\u2014",
+	"–": "\\u2013",
+	"−": "\\u2212",
+	"“": `\\"`,
+	"”": `\\"`,
+	"’": "'",
+	"…": "...",
+	" ": " ", // non-breaking space
+	"ff": "ff",
+	"ffi": "ffi",
+	"ffl": "ffl",
+	"fi": "fi",
+	"fl": "fl",
+	"IJ": "IJ",
+	"ij": "ij",
+	"LJ": "LJ",
+	"Lj": "Lj",
+	"lj": "lj",
+	"NJ": "NJ",
+	"Nj": "Nj",
+	"nj": "nj",
+	"ſt": "ft",
+};
+const _CLEAN_JSON_REPLACEMENT_REGEX = new RegExp(Object.keys(_CLEAN_JSON_REPLACEMENTS).join("|"), "g");
+
+const getCleanJson = (obj) => {
+	obj = `${JSON.stringify(obj, null, "\t")}\n`;
+	obj = obj.replace(_CLEAN_JSON_REPLACEMENT_REGEX, (match) => _CLEAN_JSON_REPLACEMENTS[match]);
+	return obj;
+};
+
+export {
+	getCleanJson,
+};

package/lib/UtilMisc.js

@@ -1,22 +1,41 @@
-function _taggedConsole (fn, tag, ...args) {
-	const expandedTag = tag.padStart(12, " ");
-	fn(`[${expandedTag}]`, ...args);
-}
+class MiscUtil {
+	/* -------------------------------------------- */
 
-function warn (tag, ...args) {
-	_taggedConsole(console.warn, tag, ...args);
-}
+	// region Logging
+	static _taggedConsole (fn, tag, ...args) {
+		const expandedTag = tag.padStart(12, " ");
+		fn(`[${expandedTag}]`, ...args);
+	}
 
-function info (tag, ...args) {
-	_taggedConsole(console.info, tag, ...args);
-}
+	static warn (tag, ...args) { this._taggedConsole(console.warn, tag, ...args); }
+	static info (tag, ...args) { this._taggedConsole(console.info, tag, ...args); }
+	static error (tag, ...args) { this._taggedConsole(console.error, tag, ...args); }
+	// endregion
+
+	/* -------------------------------------------- */
+
+	static get (object, ...path) {
+		if (object == null) return null;
+		for (let i = 0; i < path.length; ++i) {
+			object = object[path[i]];
+			if (object == null) return object;
+		}
+		return object;
+	}
+
+	/* -------------------------------------------- */
+
+	static copyFast (obj) {
+		if ((typeof obj !== "object") || obj == null) return obj;
+
+		if (obj instanceof Array) return obj.map(MiscUtil.copyFast);
+
+		const cpy = {};
+		for (const k of Object.keys(obj)) cpy[k] = MiscUtil.copyFast(obj[k]);
+		return cpy;
+	}
 
-function error (tag, ...args) {
-	_taggedConsole(console.error, tag, ...args);
+	/* -------------------------------------------- */
 }
 
-export {
-	warn,
-	info,
-	error,
-};
+export default MiscUtil;