@liiift-studio/sanity-font-manager 2.3.19 → 2.4.0

package/src/utils/generateKeywords.js

@@ -1,185 +1,185 @@
-// Builds weight and italic keyword lists with abbreviation expansions for parsing font subfamily names
-
-const coreWeights = ["Hairline", "ExtraThin", "Thin", "Mager", "Maigre", "ExtraLight", "Light", "Chiaro", "Lite", "Leicht", "Demi", "Book", "Buch", "Regular", "Normal", "Medium", "Stark", "Thick", "Kräftig", "Viertelfett", "Halbfett", "Dreiviertelfett", "Dark", "Bold", "Neretto", "Gras", "Fett", "Extrafett", "Black", "Nero", "Heavy", "Nerissimo", "Ultra", "Fat", "Poster"];
-const modifiers = ["Demi", "Semi", "Extra", "Ultra", "Super", "Plus"];
-
-const coreItalics = ["Italic", "Slant", "Oblique", "Cursive", "Rotalic", "Reverse", "Crab Claw", "Crabclaw", "South Paw", "Southpaw", "Backwards", "Backslant", "Backslanted", "Back Slant"];
-
-/** All known abbreviation-to-canonical-name mappings, sorted alphabetically */
-const alternativeSpelling = {
-	Backslant: ["Bsl"],
-	Backwards: ["Bck"],
-	Black: ["Blak", "Blk"],
-	Bold: ["Bd", "Bld"], // B omitted — too ambiguous
-	Condensed: ["Cond", "Cnd"],
-	Crabclaw: ["Crab", "Claw"],
-	Cursive: ["Cur"],
-	Dark: ["Drk"],
-	Expanded: ["Exp"],
-	Extra: ["Xt", "Xtra", "Xtr", "X"], // X omitted as standalone — too ambiguous
-	ExtraBlack: ["Xblk", "XBlk", "Xblck", "XBlck"],
-	ExtraBold: ["Xbd", "XBd", "Xbld", "XBld", "Xbold", "XBold", "ExBold", "Exbold", "Exbd", "ExBd", "Exbld", "ExBld"],
-	ExtraCondensed: ["XCond", "Xcnd"],
-	ExtraExpanded: ["XExp"],
-	ExtraLight: ["Xlight", "XLight", "Xlt", "XLt", "Xlgt", "XLgt", "Xl", "XL", "Xlght", "XLght"],
-	ExtraThin: ["Xthin", "Xthn", "Xth", "XThin", "XThn", "XTh", "XT"],
-	Extended: ["Ext"],
-	Hairline: ["Hl", "Hln", "Hlnn", "Hlnne", "Hlnnne"],
-	Italic: ["Ital", "It"],
-	Light: ["Lt", "Lght"],
-	Medium: ["Med", "Md", "md", "med"],
-	Oblique: ["Obl"],
-	Plus: ["Pls"],
-	Regular: ["Reg", "Rg"],
-	Reverse: ["Rev"],
-	Rotalic: ["Rot"],
-	SemiBold: ["SmBd", "Sb", "Sbd", "Sbld", "Sbold", "Semibd", "SemiBd", "Semibld", "SemiBld", "semiBd", "semiBld"],
-	Slant: ["Sl"],
-	Southpaw: ["South", "Paw"],
-	Super: ["Supr"],
-	Thin: ["Thn"],
-	Ultra: ["Ult", "Ultre", "Ul", "Ulta"],
-	XX: ["XXt", "XXtra", "XXtr", "XX"],
-	XXBlack: ["XXblk", "XXBlk", "XXblck", "XXBlck"],
-	XXLight: ["XXlight", "XXLight", "XXlt", "XXLt", "XXlgt", "XXLgt", "XXl", "XXL", "XXlght", "XXLght"],
-	XXX: ["XXXt", "XXXtra", "XXXtr", "XXX"],
-	XXXLight: ["XXXlight", "XXXLight", "XXXlt", "XXXLt", "XXXlgt", "XXXLgt", "XXXl", "XXXL", "XXXlght", "XXXLght"],
-};
-
-/** Maps an abbreviated font name word back to its canonical weight/style name */
-export function reverseSpellingLookup(str) {
-	// Exact match first to avoid partial collisions
-	let exactMatch = "";
-	Object.keys(alternativeSpelling).forEach(function (key) {
-		alternativeSpelling[key].forEach(function (alternative) {
-			if (str === alternative) {
-				exactMatch = key;
-			}
-		});
-	});
-	if (exactMatch) return exactMatch;
-
-	// Fall back to longest word-boundary match
-	let result = "";
-	let longestMatch = 0;
-	Object.keys(alternativeSpelling).forEach(function (key) {
-		alternativeSpelling[key].forEach(function (alternative) {
-			const regex = new RegExp(`\\b${alternative}\\b`);
-			if (regex.test(str) && alternative.length > longestMatch) {
-				result = key;
-				longestMatch = alternative.length;
-			}
-		});
-	});
-	return result;
-}
-
-/** Expands each word in a string from abbreviation to its canonical weight/style name */
-export function expandAbbreviations(str) {
-	if (!str) return str;
-	return str.split(' ')
-		.map(word => {
-			const expanded = reverseSpellingLookup(word);
-			return expanded || word;
-		})
-		.join(' ');
-}
-
-/** Removes weight and style keywords from a string, returning only the remainder */
-export function removeWeightNames(str) {
-	if (!str) return str;
-	return str.split(' ')
-		.map(word => {
-			coreWeights.forEach((weight) => {
-				if (word === weight) word = "";
-				modifiers.forEach((modifier) => {
-					if (word === modifier || modifier + weight === word) word = "";
-				});
-			});
-			const expanded = reverseSpellingLookup(word);
-			if (expanded) return "";
-			return word;
-		})
-		.join(' ')
-		.trim();
-}
-
-/** Generates comprehensive weight and italic keyword lists including all alternative spellings */
-export function generateStyleKeywords() {
-	let weightKeywordList = [];
-	let italicKeywordList = [];
-
-	// Start with all core weights
-	weightKeywordList = [...coreWeights];
-
-	// Add all modifier + weight combinations
-	modifiers.forEach(modifier => {
-		coreWeights.forEach(weight => {
-			weightKeywordList.push(modifier + weight);
-		});
-	});
-
-	// Add standalone modifiers
-	weightKeywordList = [...weightKeywordList, ...modifiers];
-
-	// Set up italic keywords
-	italicKeywordList = [...coreItalics];
-
-	// Expand weight list with alternative spellings
-	weightKeywordList = weightKeywordList.map(function (el) {
-		var newEls = [];
-		Object.keys(alternativeSpelling).forEach(function (key) {
-			if (el.indexOf(key) !== -1) {
-				alternativeSpelling[key].forEach(function (alternative) {
-					let newSpelling = el.replace(key, alternative);
-					newEls.push(newSpelling);
-					Object.keys(alternativeSpelling).forEach(function (key2) {
-						if (newSpelling.indexOf(key2) !== -1) {
-							alternativeSpelling[key2].forEach(function (alternative2) {
-								let newSpelling2 = newSpelling.replace(key2, alternative2);
-								newEls.push(newSpelling2);
-								Object.keys(alternativeSpelling).forEach(function (key3) {
-									if (newSpelling2.indexOf(key3) !== -1) {
-										alternativeSpelling[key3].forEach(function (alternative3) {
-											newEls.push(newSpelling2.replace(key3, alternative3));
-										});
-									}
-								});
-							});
-						}
-					});
-				});
-			}
-		});
-		newEls.push(el);
-		return newEls;
-	}).reduce(function (a, b) {
-		return a.concat(b);
-	});
-
-	// Expand italic list with alternative spellings
-	italicKeywordList = italicKeywordList.map(function (el) {
-		var newEls = [];
-		Object.keys(alternativeSpelling).forEach(function (key) {
-			if (el.indexOf(key) !== -1) {
-				alternativeSpelling[key].forEach(function (alternative) {
-					newEls.push(el.replace(key, alternative));
-				});
-			}
-		});
-		newEls.push(el);
-		return newEls;
-	}).reduce(function (a, b) {
-		return a.concat(b);
-	});
-
-	// Sort longest to shortest so more specific matches win
-	weightKeywordList = weightKeywordList.sort((a, b) => b.length - a.length);
-	italicKeywordList = italicKeywordList.sort((a, b) => b.length - a.length);
-
-	// Deduplicate
-	weightKeywordList = weightKeywordList.filter((item, pos) => weightKeywordList.indexOf(item) === pos);
-	italicKeywordList = italicKeywordList.filter((item, pos) => italicKeywordList.indexOf(item) === pos);
-
-	return { weightKeywordList, italicKeywordList };
-}
+// Builds weight and italic keyword lists with abbreviation expansions for parsing font subfamily names
+
+const coreWeights = ["Hairline", "ExtraThin", "Thin", "Mager", "Maigre", "ExtraLight", "Light", "Chiaro", "Lite", "Leicht", "Demi", "Book", "Buch", "Regular", "Normal", "Medium", "Stark", "Thick", "Kräftig", "Viertelfett", "Halbfett", "Dreiviertelfett", "Dark", "Bold", "Neretto", "Gras", "Fett", "Extrafett", "Black", "Nero", "Heavy", "Nerissimo", "Ultra", "Fat", "Poster"];
+const modifiers = ["Demi", "Semi", "Extra", "Ultra", "Super", "Plus"];
+
+const coreItalics = ["Italic", "Slant", "Oblique", "Cursive", "Rotalic", "Reverse", "Crab Claw", "Crabclaw", "South Paw", "Southpaw", "Backwards", "Backslant", "Backslanted", "Back Slant"];
+
+/** All known abbreviation-to-canonical-name mappings, sorted alphabetically */
+const alternativeSpelling = {
+	Backslant: ["Bsl"],
+	Backwards: ["Bck"],
+	Black: ["Blak", "Blk"],
+	Bold: ["Bd", "Bld"], // B omitted — too ambiguous
+	Condensed: ["Cond", "Cnd"],
+	Crabclaw: ["Crab", "Claw"],
+	Cursive: ["Cur"],
+	Dark: ["Drk"],
+	Expanded: ["Exp"],
+	Extra: ["Xt", "Xtra", "Xtr", "X"], // X omitted as standalone — too ambiguous
+	ExtraBlack: ["Xblk", "XBlk", "Xblck", "XBlck"],
+	ExtraBold: ["Xbd", "XBd", "Xbld", "XBld", "Xbold", "XBold", "ExBold", "Exbold", "Exbd", "ExBd", "Exbld", "ExBld"],
+	ExtraCondensed: ["XCond", "Xcnd"],
+	ExtraExpanded: ["XExp"],
+	ExtraLight: ["Xlight", "XLight", "Xlt", "XLt", "Xlgt", "XLgt", "Xl", "XL", "Xlght", "XLght"],
+	ExtraThin: ["Xthin", "Xthn", "Xth", "XThin", "XThn", "XTh", "XT"],
+	Extended: ["Ext"],
+	Hairline: ["Hl", "Hln", "Hlnn", "Hlnne", "Hlnnne"],
+	Italic: ["Ital", "It"],
+	Light: ["Lt", "Lght"],
+	Medium: ["Med", "Md", "md", "med"],
+	Oblique: ["Obl"],
+	Plus: ["Pls"],
+	Regular: ["Reg", "Rg"],
+	Reverse: ["Rev"],
+	Rotalic: ["Rot"],
+	SemiBold: ["SmBd", "Sb", "Sbd", "Sbld", "Sbold", "Semibd", "SemiBd", "Semibld", "SemiBld", "semiBd", "semiBld"],
+	Slant: ["Sl"],
+	Southpaw: ["South", "Paw"],
+	Super: ["Supr"],
+	Thin: ["Thn"],
+	Ultra: ["Ult", "Ultre", "Ul", "Ulta"],
+	XX: ["XXt", "XXtra", "XXtr", "XX"],
+	XXBlack: ["XXblk", "XXBlk", "XXblck", "XXBlck"],
+	XXLight: ["XXlight", "XXLight", "XXlt", "XXLt", "XXlgt", "XXLgt", "XXl", "XXL", "XXlght", "XXLght"],
+	XXX: ["XXXt", "XXXtra", "XXXtr", "XXX"],
+	XXXLight: ["XXXlight", "XXXLight", "XXXlt", "XXXLt", "XXXlgt", "XXXLgt", "XXXl", "XXXL", "XXXlght", "XXXLght"],
+};
+
+/** Maps an abbreviated font name word back to its canonical weight/style name */
+export function reverseSpellingLookup(str) {
+	// Exact match first to avoid partial collisions
+	let exactMatch = "";
+	Object.keys(alternativeSpelling).forEach(function (key) {
+		alternativeSpelling[key].forEach(function (alternative) {
+			if (str === alternative) {
+				exactMatch = key;
+			}
+		});
+	});
+	if (exactMatch) return exactMatch;
+
+	// Fall back to longest word-boundary match
+	let result = "";
+	let longestMatch = 0;
+	Object.keys(alternativeSpelling).forEach(function (key) {
+		alternativeSpelling[key].forEach(function (alternative) {
+			const regex = new RegExp(`\\b${alternative}\\b`);
+			if (regex.test(str) && alternative.length > longestMatch) {
+				result = key;
+				longestMatch = alternative.length;
+			}
+		});
+	});
+	return result;
+}
+
+/** Expands each word in a string from abbreviation to its canonical weight/style name */
+export function expandAbbreviations(str) {
+	if (!str) return str;
+	return str.split(' ')
+		.map(word => {
+			const expanded = reverseSpellingLookup(word);
+			return expanded || word;
+		})
+		.join(' ');
+}
+
+/** Removes weight and style keywords from a string, returning only the remainder */
+export function removeWeightNames(str) {
+	if (!str) return str;
+	return str.split(' ')
+		.map(word => {
+			coreWeights.forEach((weight) => {
+				if (word === weight) word = "";
+				modifiers.forEach((modifier) => {
+					if (word === modifier || modifier + weight === word) word = "";
+				});
+			});
+			const expanded = reverseSpellingLookup(word);
+			if (expanded) return "";
+			return word;
+		})
+		.join(' ')
+		.trim();
+}
+
+/** Generates comprehensive weight and italic keyword lists including all alternative spellings */
+export function generateStyleKeywords() {
+	let weightKeywordList = [];
+	let italicKeywordList = [];
+
+	// Start with all core weights
+	weightKeywordList = [...coreWeights];
+
+	// Add all modifier + weight combinations
+	modifiers.forEach(modifier => {
+		coreWeights.forEach(weight => {
+			weightKeywordList.push(modifier + weight);
+		});
+	});
+
+	// Add standalone modifiers
+	weightKeywordList = [...weightKeywordList, ...modifiers];
+
+	// Set up italic keywords
+	italicKeywordList = [...coreItalics];
+
+	// Expand weight list with alternative spellings
+	weightKeywordList = weightKeywordList.map(function (el) {
+		var newEls = [];
+		Object.keys(alternativeSpelling).forEach(function (key) {
+			if (el.indexOf(key) !== -1) {
+				alternativeSpelling[key].forEach(function (alternative) {
+					let newSpelling = el.replace(key, alternative);
+					newEls.push(newSpelling);
+					Object.keys(alternativeSpelling).forEach(function (key2) {
+						if (newSpelling.indexOf(key2) !== -1) {
+							alternativeSpelling[key2].forEach(function (alternative2) {
+								let newSpelling2 = newSpelling.replace(key2, alternative2);
+								newEls.push(newSpelling2);
+								Object.keys(alternativeSpelling).forEach(function (key3) {
+									if (newSpelling2.indexOf(key3) !== -1) {
+										alternativeSpelling[key3].forEach(function (alternative3) {
+											newEls.push(newSpelling2.replace(key3, alternative3));
+										});
+									}
+								});
+							});
+						}
+					});
+				});
+			}
+		});
+		newEls.push(el);
+		return newEls;
+	}).reduce(function (a, b) {
+		return a.concat(b);
+	});
+
+	// Expand italic list with alternative spellings
+	italicKeywordList = italicKeywordList.map(function (el) {
+		var newEls = [];
+		Object.keys(alternativeSpelling).forEach(function (key) {
+			if (el.indexOf(key) !== -1) {
+				alternativeSpelling[key].forEach(function (alternative) {
+					newEls.push(el.replace(key, alternative));
+				});
+			}
+		});
+		newEls.push(el);
+		return newEls;
+	}).reduce(function (a, b) {
+		return a.concat(b);
+	});
+
+	// Sort longest to shortest so more specific matches win
+	weightKeywordList = weightKeywordList.sort((a, b) => b.length - a.length);
+	italicKeywordList = italicKeywordList.sort((a, b) => b.length - a.length);
+
+	// Deduplicate
+	weightKeywordList = weightKeywordList.filter((item, pos) => weightKeywordList.indexOf(item) === pos);
+	italicKeywordList = italicKeywordList.filter((item, pos) => italicKeywordList.indexOf(item) === pos);
+
+	return { weightKeywordList, italicKeywordList };
+}

package/src/utils/generateSubset.js

@@ -1,45 +1,45 @@
-// Requests DS-WEB fingerprinted WOFF2 and display subset generation from an existing WOFF2 via fontWorker
-// The server subsets the WOFF2 directly — no TTF conversion involved.
-
-/**
- * Calls fontWorker to generate a display subset WOFF2 and subset CSS from an existing WOFF2 URL.
- * Patches fileInput.woff2_subset and fileInput.css_subset on the Sanity document directly.
- * @param {object} params
- * @param {string} params.woff2Url - CDN URL of the existing WOFF2 to subset
- * @param {string} params.filename - base filename (no extension) for the generated assets
- * @param {string} params.documentId
- * @param {string} params.documentTitle
- * @param {boolean} params.documentVariableFont
- * @param {string} params.documentStyle
- * @param {string} params.documentWeight
- * @returns {Promise<number>} 1 on success, -1 on network error
- */
-export default async function generateSubset({
-	woff2Url,
-	filename,
-	documentId,
-	documentTitle,
-	documentVariableFont,
-	documentStyle,
-	documentWeight,
-}) {
-	await fetch(`${process.env.SANITY_STUDIO_SITE_URL}/api/sanity/fontWorker`, {
-		method: 'POST',
-		mode: 'no-cors',
-		headers: { 'Content-Type': 'application/json' },
-		body: JSON.stringify({
-			code: 'generate-subset',
-			woff2Url,
-			filename,
-			documentId,
-			documentTitle,
-			documentVariableFont,
-			documentStyle,
-			documentWeight,
-		})
-	}).catch(e => {
-		console.warn('Subset generation call failed:', e.message);
-		return -1;
-	});
-	return 1;
-}
+// Requests DS-WEB fingerprinted WOFF2 and display subset generation from an existing WOFF2 via fontWorker
+// The server subsets the WOFF2 directly — no TTF conversion involved.
+
+/**
+ * Calls fontWorker to generate a display subset WOFF2 and subset CSS from an existing WOFF2 URL.
+ * Patches fileInput.woff2_subset and fileInput.css_subset on the Sanity document directly.
+ * @param {object} params
+ * @param {string} params.woff2Url - CDN URL of the existing WOFF2 to subset
+ * @param {string} params.filename - base filename (no extension) for the generated assets
+ * @param {string} params.documentId
+ * @param {string} params.documentTitle
+ * @param {boolean} params.documentVariableFont
+ * @param {string} params.documentStyle
+ * @param {string} params.documentWeight
+ * @returns {Promise<number>} 1 on success, -1 on network error
+ */
+export default async function generateSubset({
+	woff2Url,
+	filename,
+	documentId,
+	documentTitle,
+	documentVariableFont,
+	documentStyle,
+	documentWeight,
+}) {
+	await fetch(`${process.env.SANITY_STUDIO_SITE_URL}/api/sanity/fontWorker`, {
+		method: 'POST',
+		mode: 'no-cors',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({
+			code: 'generate-subset',
+			woff2Url,
+			filename,
+			documentId,
+			documentTitle,
+			documentVariableFont,
+			documentStyle,
+			documentWeight,
+		})
+	}).catch(e => {
+		console.warn('Subset generation call failed:', e.message);
+		return -1;
+	});
+	return 1;
+}

package/src/utils/getEmptyFontKit.js

@@ -1,99 +1,99 @@
-// Returns a zeroed-out fontkit-shaped placeholder object used when no font binary is available
-import * as fontkit from 'fontkit';
-import slugify from 'slugify';
-
-/** Reads font files and returns name/subfamily metadata without writing to Sanity */
-export async function getEmptyFontKit({ title, files, weightKeywordList, italicKeywordList }) {
-
-	let fontNames = {};
-	let subfamilies = {};
-
-	for (var i = 0; i < files.length; i++) {
-
-		const file = files[i];
-		const fontBuffer = await readFontFile(file);
-		const font = fontkit.create(fontBuffer);
-
-		let weightName = font?.name?.records?.preferredSubfamily ? font?.name?.records?.preferredSubfamily : font?.name?.records?.fontSubfamily;
-		weightName = weightName?.en ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
-
-		let variableFont = font?.variationAxes && Object.keys(font.variationAxes).length > 0 ? true : false;
-		let subfamilyName = font.familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), '').trim();
-		let fontTitle = font?.fullName.toLowerCase().trim();
-
-		weightKeywordList.forEach(keyword => {
-			const kw = keyword.toLowerCase().trim();
-
-			if (fontTitle.includes(kw)) {
-				fontTitle = fontTitle.replace(kw, '');
-			}
-			if (subfamilyName.includes(kw)) {
-				subfamilyName = subfamilyName.replace(kw, '');
-			}
-		});
-
-		italicKeywordList.forEach(keyword => {
-			const kw = keyword.toLowerCase().trim();
-
-			if (subfamilyName.includes(kw)) {
-				subfamilyName = subfamilyName.replace(kw, '');
-			}
-			if (fontTitle.includes(kw)) {
-				fontTitle = fontTitle.replace(kw, '');
-			}
-		});
-
-		fontTitle = fontTitle.trim().split(' ').map(word => word[0].toUpperCase() + word.slice(1)).join(' ');
-
-		subfamilyName = subfamilyName.trim();
-		subfamilyName = (subfamilyName == '') ? 'Regular' : subfamilyName.split(' ').map(word => word[0].toUpperCase() + word.slice(1)).join(' ');
-
-
-		let id = slugify(fontTitle.toLowerCase().trim());
-		if (variableFont && !id.endsWith('-vf')) {
-			id = id + '-vf';
-			fontTitle = fontTitle + ' VF';
-		}
-
-		// add subfamily to list
-		if (!subfamilies[id]) {
-			subfamilies[id] = [subfamilyName];
-		} else if (subfamilies[id].indexOf(subfamilyName) == -1) {
-			subfamilies[id] = [...subfamilies[id], subfamilyName];
-		}
-
-		if (!fontNames[id]) {
-			fontNames[id] = [{
-				file: file.name,
-				fullName: font.fullName,
-				familyName: font.familyName,
-				subFamily: subfamilyName,
-			}];
-		} else if (fontNames[id].indexOf(file.name) == -1) {
-			fontNames[id].push({
-				file: file.name,
-				fullName: font.fullName,
-				familyName: font.familyName,
-				subFamily: subfamilyName,
-			})
-		}
-
-
-	}
-
-	console.log('font names : ', fontNames);
-}
-
-/** Reads a font file and returns its content as a Uint8Array */
-const readFontFile = (file) => {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-
-		reader.onload = (event) => {
-			resolve(new Uint8Array(event.target.result));
-		};
-
-		reader.onerror = (error) => { reject(error); };
-		reader.readAsArrayBuffer(file);
-	});
-};
+// Returns a zeroed-out fontkit-shaped placeholder object used when no font binary is available
+import * as fontkit from 'fontkit';
+import slugify from 'slugify';
+
+/** Reads font files and returns name/subfamily metadata without writing to Sanity */
+export async function getEmptyFontKit({ title, files, weightKeywordList, italicKeywordList }) {
+
+	let fontNames = {};
+	let subfamilies = {};
+
+	for (var i = 0; i < files.length; i++) {
+
+		const file = files[i];
+		const fontBuffer = await readFontFile(file);
+		const font = fontkit.create(fontBuffer);
+
+		let weightName = font?.name?.records?.preferredSubfamily ? font?.name?.records?.preferredSubfamily : font?.name?.records?.fontSubfamily;
+		weightName = weightName?.en ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
+
+		let variableFont = font?.variationAxes && Object.keys(font.variationAxes).length > 0 ? true : false;
+		let subfamilyName = font.familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), '').trim();
+		let fontTitle = font?.fullName.toLowerCase().trim();
+
+		weightKeywordList.forEach(keyword => {
+			const kw = keyword.toLowerCase().trim();
+
+			if (fontTitle.includes(kw)) {
+				fontTitle = fontTitle.replace(kw, '');
+			}
+			if (subfamilyName.includes(kw)) {
+				subfamilyName = subfamilyName.replace(kw, '');
+			}
+		});
+
+		italicKeywordList.forEach(keyword => {
+			const kw = keyword.toLowerCase().trim();
+
+			if (subfamilyName.includes(kw)) {
+				subfamilyName = subfamilyName.replace(kw, '');
+			}
+			if (fontTitle.includes(kw)) {
+				fontTitle = fontTitle.replace(kw, '');
+			}
+		});
+
+		fontTitle = fontTitle.trim().split(' ').map(word => word[0].toUpperCase() + word.slice(1)).join(' ');
+
+		subfamilyName = subfamilyName.trim();
+		subfamilyName = (subfamilyName == '') ? 'Regular' : subfamilyName.split(' ').map(word => word[0].toUpperCase() + word.slice(1)).join(' ');
+
+
+		let id = slugify(fontTitle.toLowerCase().trim());
+		if (variableFont && !id.endsWith('-vf')) {
+			id = id + '-vf';
+			fontTitle = fontTitle + ' VF';
+		}
+
+		// add subfamily to list
+		if (!subfamilies[id]) {
+			subfamilies[id] = [subfamilyName];
+		} else if (subfamilies[id].indexOf(subfamilyName) == -1) {
+			subfamilies[id] = [...subfamilies[id], subfamilyName];
+		}
+
+		if (!fontNames[id]) {
+			fontNames[id] = [{
+				file: file.name,
+				fullName: font.fullName,
+				familyName: font.familyName,
+				subFamily: subfamilyName,
+			}];
+		} else if (fontNames[id].indexOf(file.name) == -1) {
+			fontNames[id].push({
+				file: file.name,
+				fullName: font.fullName,
+				familyName: font.familyName,
+				subFamily: subfamilyName,
+			})
+		}
+
+
+	}
+
+	console.log('font names : ', fontNames);
+}
+
+/** Reads a font file and returns its content as a Uint8Array */
+const readFontFile = (file) => {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+
+		reader.onload = (event) => {
+			resolve(new Uint8Array(event.target.result));
+		};
+
+		reader.onerror = (error) => { reject(error); };
+		reader.readAsArrayBuffer(file);
+	});
+};