@liiift-studio/sanity-font-manager 2.2.0

package/dist/index.mjs

@@ -0,0 +1,3622 @@
+// src/components/BatchUploadFonts.jsx
+import React4, { useCallback, useState as useState2, useMemo as useMemo2, useRef, useEffect } from "react";
+import { Card, Box as Box2, Flex as Flex3, Grid, Text as Text4, Label, Switch, Button as Button2, Spinner, Tooltip, Stack as Stack2 } from "@sanity/ui";
+import { ControlsIcon, InfoOutlineIcon, TrashIcon, UploadIcon, WarningOutlineIcon } from "@sanity/icons";
+import { useFormValue as useFormValue2 } from "sanity";
+
+// src/hooks/useSanityClient.js
+import { useMemo } from "react";
+import { useClient } from "sanity";
+function useSanityClient() {
+  const client = useClient({ apiVersion: "2021-10-23" });
+  return useMemo(() => client, [client]);
+}
+
+// src/utils/processFontFiles.js
+import * as fontkit from "fontkit";
+import { nanoid } from "nanoid";
+
+// src/utils/generateKeywords.js
+var coreWeights = ["Hairline", "ExtraThin", "Thin", "Mager", "Maigre", "ExtraLight", "Light", "Chiaro", "Lite", "Leicht", "Demi", "Book", "Buch", "Regular", "Normal", "Medium", "Stark", "Thick", "Kr\xE4ftig", "Viertelfett", "Halbfett", "Dreiviertelfett", "Dark", "Bold", "Neretto", "Gras", "Fett", "Extrafett", "Black", "Nero", "Heavy", "Nerissimo", "Ultra", "Fat", "Poster"];
+var modifiers = ["Demi", "Semi", "Extra", "Ultra", "Super", "Plus"];
+var coreItalics = ["Italic", "Slant", "Oblique", "Cursive", "Rotalic", "Reverse", "Crab Claw", "Crabclaw", "South Paw", "Southpaw", "Backwards", "Backslant", "Backslanted", "Back Slant"];
+var 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"]
+};
+function reverseSpellingLookup(str) {
+  let exactMatch = "";
+  Object.keys(alternativeSpelling).forEach(function(key) {
+    alternativeSpelling[key].forEach(function(alternative) {
+      if (str === alternative) {
+        exactMatch = key;
+      }
+    });
+  });
+  if (exactMatch) return exactMatch;
+  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;
+}
+function expandAbbreviations(str) {
+  if (!str) return str;
+  return str.split(" ").map((word) => {
+    const expanded = reverseSpellingLookup(word);
+    return expanded || word;
+  }).join(" ");
+}
+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();
+}
+function generateStyleKeywords() {
+  let weightKeywordList = [];
+  let italicKeywordList = [];
+  weightKeywordList = [...coreWeights];
+  modifiers.forEach((modifier) => {
+    coreWeights.forEach((weight) => {
+      weightKeywordList.push(modifier + weight);
+    });
+  });
+  weightKeywordList = [...weightKeywordList, ...modifiers];
+  italicKeywordList = [...coreItalics];
+  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);
+  });
+  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);
+  });
+  weightKeywordList = weightKeywordList.sort((a, b) => b.length - a.length);
+  italicKeywordList = italicKeywordList.sort((a, b) => b.length - a.length);
+  weightKeywordList = weightKeywordList.filter((item, pos) => weightKeywordList.indexOf(item) === pos);
+  italicKeywordList = italicKeywordList.filter((item, pos) => italicKeywordList.indexOf(item) === pos);
+  return { weightKeywordList, italicKeywordList };
+}
+
+// src/utils/sanitizeForSanityId.js
+import slugify from "slugify";
+function sanitizeForSanityId(str) {
+  if (!str || typeof str !== "string") {
+    return "font-" + Date.now();
+  }
+  let sanitized = str.toLowerCase().trim();
+  sanitized = sanitized.replace(/\+/g, "plus");
+  sanitized = sanitized.replace(/&/g, "and");
+  sanitized = sanitized.replace(/@/g, "at");
+  sanitized = slugify(sanitized, {
+    replacement: "-",
+    remove: /[^\w\s-]/g,
+    lower: true,
+    strict: true,
+    locale: "en",
+    trim: true
+  });
+  sanitized = sanitized.replace(/[^a-z0-9\-_]/g, "-");
+  sanitized = sanitized.replace(/-+/g, "-");
+  sanitized = sanitized.replace(/^[-_]+|[-_]+$/g, "");
+  if (sanitized && !/^[a-z_]/.test(sanitized)) {
+    sanitized = "font_" + sanitized;
+  }
+  if (!sanitized) {
+    sanitized = "font_" + Date.now();
+  }
+  if (sanitized.length > 128) {
+    const hash = Math.random().toString(36).substring(2, 8);
+    sanitized = sanitized.substring(0, 120) + "_" + hash;
+  }
+  if (!/^[a-z_][a-z0-9\-_]*$/.test(sanitized)) {
+    console.warn(`ID sanitization produced invalid result: "${sanitized}", using fallback`);
+    sanitized = "font_" + Date.now();
+  }
+  return sanitized;
+}
+
+// src/utils/processFontFiles.js
+var 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);
+  });
+};
+var processFontFiles = async (files, title, weightKeywordList, italicKeywordList, setStatus, preserveShortenedNames = false, preserveFileNames = false) => {
+  let failedFiles = [];
+  let subfamilies = {};
+  let fontsObjects = {};
+  let newPreferredStyle = { weight: -100, style: "Italic", _ref: "" };
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const fontBuffer = await readFontFile(file);
+    const font = fontkit.create(fontBuffer);
+    console.log("File name: ", file.name);
+    if (file.name.endsWith(".woff2") || file.name.endsWith(".woff")) {
+      await handleWebfontMetadata(file, font, files);
+    }
+    const { weightName, subfamilyName, fontTitle, style, italicKW, variableFont } = extractFontMetadata(
+      font,
+      title,
+      weightKeywordList,
+      italicKeywordList,
+      preserveShortenedNames
+    );
+    const id = sanitizeForSanityId(fontTitle);
+    let originalFilename = null;
+    if (preserveFileNames) {
+      originalFilename = file.name.replace(/\.(ttf|otf|woff2?|eot|svg)$/i, "");
+    }
+    logFontInfo(id, fontTitle, font, file.name, subfamilyName, style, weightName, variableFont, italicKW);
+    subfamilies[id] = subfamilyName;
+    if (fontsObjects[id]) {
+      fontsObjects[id].files = [...fontsObjects[id].files, file];
+      if (preserveFileNames && originalFilename) {
+        fontsObjects[id].originalFilename = originalFilename;
+      }
+    } else {
+      fontsObjects[id] = createFontObject(
+        id,
+        fontTitle,
+        title,
+        font,
+        variableFont,
+        weightName,
+        subfamilyName,
+        file,
+        preserveFileNames ? originalFilename : null
+      );
+    }
+  }
+  fontsObjects = sortFontObjects(fontsObjects);
+  const uniqueSubfamilies = [...new Set(Object.values(subfamilies))];
+  console.log("Subfamilies:", subfamilies);
+  console.log("Unique subfamilies:", uniqueSubfamilies, uniqueSubfamilies.length);
+  console.log("Font objects:", fontsObjects);
+  return { fontsObjects, subfamilies, uniqueSubfamilies, newPreferredStyle, failedFiles };
+};
+var handleWebfontMetadata = async (file, font, files) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  if (!((_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.fullName) || ((_d = (_c = font == null ? void 0 : font.name) == null ? void 0 : _c.records) == null ? void 0 : _d.fullName) === "" || !/^[A-Z0-9]+$/.test((_f = (_e = font == null ? void 0 : font.name) == null ? void 0 : _e.records) == null ? void 0 : _f.fullName)) {
+    const ttfFile = files.find((f) => f.name === file.name.replace(".woff2", ".ttf").replace(".woff", ".ttf"));
+    if (ttfFile) {
+      const ttfFileBuffer = await readFontFile(ttfFile);
+      const ttfFileData = fontkit.create(ttfFileBuffer);
+      if (ttfFileData) font.name.records = (_g = ttfFileData == null ? void 0 : ttfFileData.name) == null ? void 0 : _g.records;
+    }
+  }
+};
+var extractFontMetadata = (font, title, weightKeywordList, italicKeywordList, preserveShortenedNames = false) => {
+  var _a, _b, _c, _d, _e, _f;
+  let weightName = extractWeightName(font, italicKeywordList);
+  if (!preserveShortenedNames) {
+    weightName = expandAbbreviations(weightName);
+  }
+  if ((weightName === "" || weightName.toLowerCase() === "roman") && ((_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.fullName)) {
+    weightName = extractWeightFromFullName(font, title);
+    if (!preserveShortenedNames) {
+      weightName = expandAbbreviations(weightName);
+    }
+  }
+  const variableFont = (font == null ? void 0 : font.variationAxes) && Object.keys(font.variationAxes).length > 0;
+  let subfamilyName = ((_f = (_e = (_d = (_c = font == null ? void 0 : font.name) == null ? void 0 : _c.records) == null ? void 0 : _d.fullName) == null ? void 0 : _e.en) == null ? void 0 : _f.replace(title.trim(), "").trim()) || font.subfamilyName.trim().replace(title.trim(), "").trim();
+  if (!preserveShortenedNames) {
+    subfamilyName = expandAbbreviations(subfamilyName);
+  }
+  let fontTitle = font == null ? void 0 : font.fullName.trim();
+  let style = (font == null ? void 0 : font.italicAngle) !== 0 || (font == null ? void 0 : font.fullName.toLowerCase().includes("italic")) ? "Italic" : "Regular";
+  const italicKW = processItalicKeywords(font, fontTitle, italicKeywordList);
+  subfamilyName = processSubfamilyName(subfamilyName, weightKeywordList, italicKW, preserveShortenedNames);
+  fontTitle = formatFontTitle(fontTitle, preserveShortenedNames);
+  subfamilyName = subfamilyName === "" ? "Regular" : subfamilyName.replace(/\s+/g, " ").trim();
+  if (subfamilyName !== "") {
+    weightName = weightName.replace(`${subfamilyName} `, "").replace(` ${subfamilyName}`, "").trim();
+  }
+  if (variableFont) {
+    if (!fontTitle.toLowerCase().includes("vf")) {
+      fontTitle = fontTitle + " VF";
+    }
+    subfamilyName = "";
+  }
+  if (!(variableFont && fontTitle.toLowerCase().includes("italic"))) {
+    fontTitle = addItalicToFontTitle(font, fontTitle, italicKW, style, preserveShortenedNames);
+  }
+  return { weightName, subfamilyName, fontTitle, style, italicKW, variableFont };
+};
+var extractWeightName = (font, italicKW) => {
+  var _a, _b, _c, _d;
+  let weightName = ((_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.preferredSubfamily) || ((_d = (_c = font == null ? void 0 : font.name) == null ? void 0 : _c.records) == null ? void 0 : _d.fontSubfamily);
+  if (typeof weightName === "object") {
+    weightName = (weightName == null ? void 0 : weightName.en) || (weightName.constructor === Object ? weightName[Object.keys(weightName)[0]] : null);
+  }
+  if ((font == null ? void 0 : font.variationAxes) && Object.keys(font.variationAxes).length > 0) {
+    return "Variable";
+  }
+  if (italicKW) {
+    italicKW.forEach((keyword) => {
+      const kwRegex = new RegExp(`\\b${keyword.trim()}\\b`, "i");
+      if (kwRegex.test(weightName)) {
+        weightName = weightName.replace(kwRegex, "").trim();
+      }
+    });
+  }
+  return weightName == null ? void 0 : weightName.toString().replace("Italic", "").replace("It", "").replace("Slanted", "").replace("Slant", "").replace("Backslant", "").trim();
+};
+var extractWeightFromFullName = (font, title) => {
+  var _a, _b;
+  let weightName = (_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.fullName;
+  weightName = (weightName == null ? void 0 : weightName.en) ? weightName.en : (weightName == null ? void 0 : weightName.constructor) === Object ? weightName[Object.keys(weightName)[0]] : weightName;
+  weightName = weightName == null ? void 0 : weightName.replace(title + " ", "").replace(title, "").trim();
+  weightName = weightName == null ? void 0 : weightName.replace("Italic", "").replace("It", "").replace("Slanted", "").replace("Slant", "").trim();
+  return weightName;
+};
+var processSubfamilyName = (subfamilyName, weightKeywordList, italicKeywordList, preserveShortenedNames = false) => {
+  weightKeywordList.forEach((keyword) => {
+    const kwRegex = new RegExp(`\\b${keyword.trim()}\\b`, "i");
+    if (kwRegex.test(subfamilyName)) {
+      subfamilyName = subfamilyName.replace(kwRegex, "").trim();
+    }
+    subfamilyName = removeWeightNames(subfamilyName) || subfamilyName;
+    if (!preserveShortenedNames) {
+      subfamilyName = expandAbbreviations(subfamilyName);
+    }
+  });
+  italicKeywordList.forEach((keyword) => {
+    const kwRegex = new RegExp(`\\b${keyword.trim()}\\b`, "i");
+    if (kwRegex.test(subfamilyName)) {
+      subfamilyName = subfamilyName.replace(kwRegex, "").trim();
+    }
+  });
+  return subfamilyName;
+};
+var processItalicKeywords = (font, fontTitle, italicKeywordList) => {
+  let italicKW = [];
+  italicKeywordList.forEach((keyword) => {
+    const kw = keyword.trim();
+    const kwRegex = new RegExp(`\\b${kw}\\b`, "i");
+    if (kwRegex.test(fontTitle)) {
+      fontTitle = fontTitle.replace(kwRegex, "").trim();
+      italicKW.push(kw);
+    }
+    if ((font == null ? void 0 : font.fullName) && typeof font.fullName === "string" && font.fullName.toLowerCase().includes(kw.toLowerCase())) {
+      if (!italicKW.includes(kw)) italicKW.push(kw);
+    }
+  });
+  return italicKW;
+};
+var formatFontTitle = (fontTitle, preserveShortenedNames = false) => {
+  const hasItalic = fontTitle.toLowerCase().includes("italic");
+  fontTitle = fontTitle.replace(/-/g, " ");
+  return fontTitle.replace(/\s+/g, " ").trim().split(" ").map((word) => {
+    if (hasItalic && word.toLowerCase() === "italic") return "Italic";
+    let fullWord = word;
+    if (!preserveShortenedNames) {
+      fullWord = reverseSpellingLookup(word) || word;
+    }
+    return fullWord[0].toUpperCase() + fullWord.slice(1);
+  }).join(" ");
+};
+var addItalicToFontTitle = (font, fontTitle, italicKW, style, preserveShortenedNames = false) => {
+  const hasItalicAngle = (font == null ? void 0 : font.italicAngle) !== 0;
+  const hasItalicInName = font == null ? void 0 : font.fullName.toLowerCase().includes("italic");
+  if (italicKW.length > 0 || hasItalicAngle || hasItalicInName) {
+    italicKW = [...new Set(italicKW)];
+    if (italicKW.length === 0 && (hasItalicAngle || hasItalicInName)) {
+      italicKW = ["Italic"];
+    }
+    if (!preserveShortenedNames) {
+      italicKW = italicKW.map((item) => reverseSpellingLookup(item) || item);
+    }
+    italicKW = [...new Set(italicKW)];
+    if (italicKW.length > 1 && italicKW.includes("Italic")) {
+      italicKW = ["Italic"];
+    }
+    const fontTitleLower = fontTitle.toLowerCase();
+    italicKW = italicKW.filter((keyword) => {
+      const keywordLower = keyword.toLowerCase();
+      const kwRegex = new RegExp(`\\b${keywordLower}\\b`);
+      const isSubstring = fontTitleLower.split(" ").some(
+        (word) => word.includes(keywordLower) || keywordLower.includes(word)
+      );
+      return !kwRegex.test(fontTitleLower) && !isSubstring;
+    });
+    if (italicKW.length > 0) {
+      fontTitle = fontTitle.trim() + " " + italicKW.join(" ");
+    }
+  }
+  return fontTitle;
+};
+var createFontObject = (id, fontTitle, title, font, variableFont, weightName, subfamilyName, file, originalFilename = null) => {
+  const fontObject = {
+    _key: nanoid(),
+    _id: id,
+    title: fontTitle,
+    slug: { _type: "slug", current: id },
+    typefaceName: title,
+    style: (font == null ? void 0 : font.italicAngle) !== 0 || (font == null ? void 0 : font.fullName.toLowerCase().includes("italic")) ? "Italic" : "Regular",
+    variableFont,
+    weightName,
+    subfamily: subfamilyName,
+    normalWeight: true,
+    weight: Number(determineWeight(font, weightName)),
+    fileInput: {},
+    files: [file],
+    fontKit: font
+  };
+  if (originalFilename) {
+    fontObject.originalFilename = originalFilename;
+  }
+  return fontObject;
+};
+var determineWeight = (font, weightName) => {
+  var _a;
+  if ((_a = font["OS/2"]) == null ? void 0 : _a.usWeightClass) {
+    return Number(font["OS/2"].usWeightClass);
+  }
+  const wn = (weightName == null ? void 0 : weightName.toLowerCase()) || "";
+  if (/hairline|extra thin|extrathin/.test(wn)) return 100;
+  if (/thin|extra light|extralight/.test(wn)) return 200;
+  if (/light|book/.test(wn)) return 300;
+  if (/regular|normal/.test(wn)) return 400;
+  if (/medium/.test(wn)) return 500;
+  if (/semi bold|semibold/.test(wn)) return 600;
+  if (/extra bold|extrabold/.test(wn)) return 800;
+  if (/bold/.test(wn)) return 700;
+  if (/black|ultra/.test(wn)) return 900;
+  return 400;
+};
+var sortFontObjects = (fontsObjects) => {
+  return Object.fromEntries(
+    Object.entries(fontsObjects).sort((a, b) => {
+      const weightA = Number(a[1].weight);
+      const weightB = Number(b[1].weight);
+      if (weightA === weightB) {
+        if (a[1].style === "Regular" && b[1].style === "Italic") return -1;
+        if (a[1].style === "Italic" && b[1].style === "Regular") return 1;
+        return 0;
+      }
+      return weightA - weightB;
+    })
+  );
+};
+var logFontInfo = (id, fontTitle, font, fileName, subfamilyName, style, weightName, variableFont, italicKW) => {
+  console.log("=== Font Info ====");
+  console.log("Font id: ", id);
+  console.log("Font title: ", fontTitle);
+  console.log("Fontkit fullName: ", font.fullName);
+  console.log("Fontkit family name: ", font.familyName);
+  console.log("File name: ", fileName);
+  console.log("Subfamily: ", subfamilyName);
+  console.log("Style: ", style);
+  console.log("Weight: ", weightName);
+  console.log("Variable: ", variableFont);
+  console.log("italicKW: ", italicKW);
+  console.log("Font italic angle: ", (font == null ? void 0 : font.italicAngle) !== 0 || (font == null ? void 0 : font.fullName.toLowerCase().includes("italic")) ? "Italic" : "Regular");
+  console.log("=======");
+};
+
+// src/utils/uploadFontFiles.js
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/utils/generateCssFile.js
+import base64 from "base-64";
+import { Buffer } from "buffer";
+import * as fontkit2 from "fontkit";
+function _arrayBufferToBase64(buffer) {
+  var binary = "";
+  var bytes = new Uint8Array(buffer);
+  var len = bytes.byteLength;
+  for (var i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return base64.encode(binary);
+}
+function buildVFDescriptors(font) {
+  const cssAxes = {};
+  const skipped = [];
+  try {
+    const va = font.variationAxes;
+    if (!va) return { descriptors: "", skipped: [] };
+    for (const [tag, axis] of Object.entries(va)) {
+      const lo = Math.min(axis.min, axis.max);
+      const hi = Math.max(axis.min, axis.max);
+      if (lo === hi) {
+        skipped.push(tag);
+        continue;
+      }
+      if (tag === "wght") {
+        cssAxes["font-weight"] = `${lo} ${hi}`;
+      } else if (tag === "wdth") {
+        cssAxes["font-stretch"] = `${lo}% ${hi}%`;
+      } else if (tag === "slnt") {
+        cssAxes["font-style"] = `oblique ${lo}deg ${hi}deg`;
+      } else if (tag === "ital" && !cssAxes["font-style"]) {
+        if (hi > 0) cssAxes["font-style"] = "italic";
+        else skipped.push(tag);
+      } else {
+        skipped.push(tag);
+      }
+    }
+  } catch (_) {
+  }
+  const descriptors = Object.entries(cssAxes).map(([k, v]) => `${k}:${v}`).join(";") + (Object.keys(cssAxes).length ? ";" : "");
+  return { descriptors, skipped };
+}
+var FALLBACK_STACKS = {
+  "sans-serif": "local('Arial'), local('Helvetica Neue'), local('Roboto'), local('Liberation Sans')",
+  "serif": "local('Georgia'), local('Times New Roman'), local('Times')",
+  "monospace": "local('Courier New'), local('Courier'), local('Menlo'), local('Monaco')",
+  // Display and script fonts have no universally suitable system fallback; default to sans-serif
+  "default": "local('Arial'), local('Helvetica Neue'), local('Roboto'), local('Liberation Sans')"
+};
+var FAMILY_CLASS_MAP = {
+  1: "serif",
+  2: "serif",
+  3: "serif",
+  4: "serif",
+  5: "serif",
+  7: "serif",
+  8: "sans-serif"
+};
+function detectFontCategory(font) {
+  var _a, _b;
+  try {
+    const familyClass = ((_b = (_a = font._tables) == null ? void 0 : _a["OS/2"]) == null ? void 0 : _b.sFamilyClass) ?? 0;
+    const highByte = familyClass >> 8 & 255;
+    return FAMILY_CLASS_MAP[highByte] ?? "default";
+  } catch {
+    return "default";
+  }
+}
+function calcFallbackData(arrayBuffer) {
+  try {
+    let font = fontkit2.create(Buffer.from(arrayBuffer));
+    let upm = font.unitsPerEm;
+    let category = detectFontCategory(font);
+    return {
+      fallbackSrc: FALLBACK_STACKS[category],
+      ascentOverride: `${(font.ascent / upm * 100).toFixed(2)}%`,
+      descentOverride: `${(Math.abs(font.descent) / upm * 100).toFixed(2)}%`,
+      lineGapOverride: `${(font.lineGap / upm * 100).toFixed(2)}%`
+    };
+  } catch (err) {
+    console.error("Failed to extract fallback font data:", err);
+    return {
+      fallbackSrc: FALLBACK_STACKS["default"],
+      ascentOverride: "100%",
+      descentOverride: "0%",
+      lineGapOverride: "0%"
+    };
+  }
+}
+async function generateCssFile({
+  woff2File,
+  fileInput,
+  language = null,
+  fileName,
+  fontName,
+  variableFont,
+  weight,
+  style = "Normal",
+  client
+}) {
+  try {
+    let arrayBuffer = await woff2File.arrayBuffer();
+    let b64 = _arrayBufferToBase64(arrayBuffer);
+    let fontkitFont = fontkit2.create(Buffer.from(arrayBuffer));
+    let { fallbackSrc, ascentOverride, descentOverride, lineGapOverride } = calcFallbackData(arrayBuffer);
+    let cssString;
+    if (variableFont) {
+      let { descriptors, skipped } = buildVFDescriptors(fontkitFont);
+      let skipComment = skipped.length ? `/* axes present but have no @font-face descriptor: ${skipped.join(", ")}` + (skipped.includes("opsz") ? " \u2014 add font-optical-sizing:auto to your element CSS" : "") + " */" : "";
+      cssString = `${skipComment}@font-face{font-family:'${fontName}';src:url(data:application/font-woff2;charset=utf-8;base64,${b64})format('woff2-variations');${descriptors}font-display:swap;}`;
+    } else {
+      let fontStyle = style === "Italic" ? "italic" : "normal";
+      cssString = `@font-face{font-family:'${fontName}';src:url(data:application/font-woff2;charset=utf-8;base64,${b64})format('woff2');font-weight:${weight};font-style:${fontStyle};font-display:swap;}`;
+    }
+    let fallbackCssString = `@font-face{font-family:'${fontName} Fallback';src:${fallbackSrc};ascent-override:${ascentOverride};descent-override:${descentOverride};line-gap-override:${lineGapOverride};}`;
+    let uploadBuffer = Buffer.from(cssString + fallbackCssString, "utf-8");
+    let doc = await client.assets.upload("file", uploadBuffer, { filename: fileName + ".css" });
+    let newFileInput = language == null ? {
+      ...fileInput,
+      css: {
+        _type: "file",
+        asset: {
+          _type: "reference",
+          _ref: doc._id
+        }
+      }
+    } : {
+      ...fileInput,
+      [language]: {
+        ...fileInput[language],
+        css: {
+          _type: "file",
+          asset: {
+            _type: "reference",
+            _ref: doc._id
+          }
+        }
+      }
+    };
+    return newFileInput;
+  } catch (err) {
+    console.error(err);
+    throw err;
+  }
+}
+
+// src/utils/generateFontData.js
+import { Buffer as Buffer2 } from "buffer";
+import * as fontkit3 from "fontkit";
+async function generateFontData({ fileInput, url, fontKit, fontId, client, commit = true }) {
+  var _a;
+  if (fontId.startsWith("drafts.")) {
+    fontId = fontId.replace("drafts.", "");
+  }
+  console.log("generate-font-data ", fontId, commit);
+  let srcUrl;
+  if (!url || url == null) {
+    srcUrl = await client.fetch(`*[_id == $id]{url}`, { id: fileInput.ttf.asset._ref });
+    console.log("src url ", srcUrl);
+    srcUrl = srcUrl[0].url;
+  } else {
+    srcUrl = url;
+  }
+  let font = fontKit;
+  if (!fontKit || fontKit == null) {
+    let buffer = await fetch(srcUrl);
+    buffer = await buffer.arrayBuffer();
+    buffer = Buffer2.from(buffer);
+    font = fontkit3.create(buffer);
+  }
+  let variableAxes;
+  try {
+    variableAxes = font.variationAxes;
+  } catch (err) {
+    console.error("err: ", err);
+  }
+  let variableInstances;
+  try {
+    variableInstances = font.namedVariations;
+  } catch (e) {
+    console.log("variable instances 2 error : ", e.message);
+    let fvar = (_a = font == null ? void 0 : font.fvar) == null ? void 0 : _a.instance;
+    fvar == null ? void 0 : fvar.forEach((fv) => {
+      var _a2, _b, _c, _d, _e, _f;
+      if ((fv == null ? void 0 : fv.nameID) === 2) fv.name = (_c = (_b = (_a2 = font == null ? void 0 : font._tables) == null ? void 0 : _a2.name) == null ? void 0 : _b.records) == null ? void 0 : _c.fontSubfamily;
+      if ((fv == null ? void 0 : fv.nameID) === 17) fv.name = (_f = (_e = (_d = font == null ? void 0 : font._tables) == null ? void 0 : _d.name) == null ? void 0 : _e.records) == null ? void 0 : _f.preferredSubfamily;
+    });
+    variableInstances = {};
+    fvar.forEach((v) => {
+      let key = v.name;
+      if (typeof key === "object") {
+        key = Object.values(key)[0];
+      }
+      let coordKeys = Object.keys(variableAxes);
+      let coord = {};
+      coordKeys.forEach((ck, ckIndex) => {
+        coord[ck] = v.coord[ckIndex];
+      });
+      variableInstances[key] = coord;
+    });
+  }
+  console.log("font : ", font);
+  console.log("variable instances : ", variableInstances);
+  console.log("variable axes : ", variableAxes);
+  let opentypeFeatures = font.availableFeatures;
+  let glyphCount = font.numGlyphs;
+  let characterSet = font.characterSet;
+  let metaData = {
+    postscriptName: font.postscriptName,
+    fullName: font.fullName,
+    familyName: font.familyName,
+    subfamilyName: font.subfamilyName,
+    copyright: font.copyright,
+    version: font.version.replaceAll("Version ", ""),
+    genDate: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let metrics = {
+    unitsPerEm: font.unitsPerEm,
+    ascender: font.ascent,
+    descender: font.descent,
+    lineGap: font.lineGap,
+    underlinePosition: font.underlinePosition,
+    underlineThickness: font.underlineThickness,
+    italicAngle: font.italicAngle,
+    capHeight: font.capHeight,
+    xHeight: font.xHeight,
+    boundingBox: font.bbox
+  };
+  let variableFont = false;
+  if (variableAxes && variableAxes != null && Object.keys(variableAxes).length > 0 && variableInstances && variableInstances != null && Object.keys(variableInstances).length > 0) {
+    variableFont = true;
+  }
+  let patch = {
+    metrics,
+    metaData,
+    variableFont,
+    variableAxes: JSON.stringify(variableAxes),
+    variableInstances: JSON.stringify(variableInstances),
+    glyphCount,
+    opentypeFeatures: { chars: opentypeFeatures },
+    characterSet: { chars: characterSet }
+  };
+  console.log("data : ", patch);
+  if (commit) patch = await client.patch(fontId).set(patch).commit({ autoGenerateArrayKeys: true });
+  return patch;
+}
+
+// src/utils/parseVariableFontInstances.js
+import { nanoid as nanoid2 } from "nanoid";
+var parseVariableFontInstances = async (font, client) => {
+  if (!font.variableFont || !font.variableInstances) return [];
+  let variableInstances;
+  try {
+    variableInstances = JSON.parse(font.variableInstances);
+  } catch (err) {
+    console.error("Error parsing variable instances:", err);
+    variableInstances = {};
+  }
+  if (Object.keys(variableInstances).length === 0) return [];
+  let staticFonts;
+  const typeface = await client.fetch(
+    `*[_type == 'typeface' && title == $typefaceName][0]{
+			'fonts': styles.fonts[]-> {
+				_id,
+				title,
+				subfamily,
+				style,
+				weight,
+				weightName,
+				metaData,
+				variableFont
+			}
+		}`,
+    { typefaceName: font.typefaceName }
+  );
+  if ((typeface == null ? void 0 : typeface.fonts) && typeface.fonts.length > 0) {
+    staticFonts = typeface.fonts.filter((f) => !f.variableFont);
+    console.log("Using curated typeface fonts list:", staticFonts.length, "fonts");
+  } else {
+    console.warn("Typeface not found or no fonts in curated list, falling back to all fonts query");
+    staticFonts = await client.fetch(
+      `*[_type == 'font' && typefaceName == $typefaceName && variableFont != true]{
+				_id,
+				title,
+				subfamily,
+				style,
+				weight,
+				weightName,
+				metaData
+			}`,
+      { typefaceName: font.typefaceName }
+    );
+  }
+  console.log("Variable font instances:", Object.keys(variableInstances));
+  console.log("Available static fonts:", staticFonts.map((sf) => sf.title));
+  const instanceMappings = [];
+  Object.keys(variableInstances).forEach((instanceName) => {
+    let matchingFont = null;
+    matchingFont = staticFonts.find((sf) => sf.title === instanceName);
+    if (!matchingFont && staticFonts.some((sf) => {
+      var _a;
+      return (_a = sf.metaData) == null ? void 0 : _a.fullName;
+    })) {
+      matchingFont = staticFonts.find((sf) => {
+        var _a, _b, _c, _d;
+        if (!((_a = sf.metaData) == null ? void 0 : _a.fullName)) return false;
+        let fullName = sf.metaData.fullName;
+        const WORDS_TO_REMOVE = ["VF", "var", "variable", "VAR", "vf"];
+        const variableName = (_c = (_b = font.metaData) == null ? void 0 : _b.familyName) == null ? void 0 : _c.replace(new RegExp(`\\b(${WORDS_TO_REMOVE.join("|")})\\b`, "gi"), "").replace(/\s{2,}/g, " ").trim();
+        if (variableName && fullName.startsWith(variableName)) {
+          fullName = fullName.substring(variableName.length).trim();
+        }
+        if (variableName) {
+          const words = variableName.split(/\s+/).map((w) => w.trim()).filter(Boolean);
+          if (words.length > 0) {
+            const regex = new RegExp(`\\b(${words.join("|")})\\b`, "gi");
+            const stripped = fullName.replace(regex, "").replace(/\s{2,}/g, " ").trim();
+            if (stripped !== "") fullName = stripped;
+          }
+        }
+        if (fullName.startsWith(font.typefaceName)) {
+          fullName = fullName.substring(font.typefaceName.length).trim();
+        }
+        if (((_d = sf.style) == null ? void 0 : _d.toLowerCase()) === "italic" && !fullName.toLowerCase().endsWith("italic") && !fullName.toLowerCase().endsWith("slanted")) {
+          fullName = fullName + " Italic";
+        }
+        if (fullName.trim().toLowerCase().endsWith("regular")) {
+          if (instanceName.trim().toLowerCase() + " regular" === fullName.trim().toLowerCase()) return true;
+        }
+        if (fullName.trim().toLowerCase().startsWith("regular")) {
+          if ("regular " + instanceName.trim().toLowerCase() === fullName.trim().toLowerCase()) return true;
+        }
+        if (fullName.trim().toLowerCase().endsWith("italic")) {
+          if (instanceName.trim().toLowerCase().endsWith("italic")) {
+            const k = instanceName.trim().toLowerCase().slice(0, -6).trim() + " regular italic";
+            if (k === fullName.trim().toLowerCase()) return true;
+          }
+        }
+        return fullName.trim().toLowerCase() === instanceName.trim().toLowerCase();
+      });
+    }
+    if (!matchingFont) {
+      const expandedName = instanceName.split(" ").map((word) => expandAbbreviations(word)).join(" ");
+      matchingFont = staticFonts.find((sf) => {
+        const nameWithoutTypeface = sf.title.replace(font.typefaceName, "").trim();
+        return nameWithoutTypeface === expandedName;
+      });
+    }
+    if (!matchingFont) {
+      const isItalic = instanceName.toLowerCase().includes("italic");
+      const weightTerms = [
+        { term: "thin", weight: "100" },
+        { term: "extralight", weight: "200" },
+        { term: "extra light", weight: "200" },
+        { term: "light", weight: "300" },
+        { term: "regular", weight: "400" },
+        { term: "normal", weight: "400" },
+        { term: "medium", weight: "500" },
+        { term: "semibold", weight: "600" },
+        { term: "semi bold", weight: "600" },
+        { term: "bold", weight: "700" },
+        { term: "extrabold", weight: "800" },
+        { term: "extra bold", weight: "800" },
+        { term: "black", weight: "900" },
+        { term: "heavy", weight: "900" }
+      ];
+      let instanceWeight = "400";
+      for (const { term, weight } of weightTerms) {
+        if (instanceName.toLowerCase().includes(term)) {
+          instanceWeight = weight;
+          break;
+        }
+      }
+      matchingFont = staticFonts.find(
+        (sf) => sf.weight === instanceWeight && (isItalic && sf.style === "Italic" || !isItalic && sf.style === "Regular")
+      );
+    }
+    if (!matchingFont) {
+      matchingFont = staticFonts.find((sf) => {
+        if (!sf.weightName) return false;
+        const cleanInstance = instanceName.toLowerCase().replace(/italic/i, "").trim();
+        const cleanWeight = sf.weightName.toLowerCase().replace(/italic/i, "").trim();
+        return cleanInstance === cleanWeight;
+      });
+    }
+    if (!matchingFont && staticFonts.some((sf) => {
+      var _a;
+      return (_a = sf.metaData) == null ? void 0 : _a.fullName;
+    })) {
+      matchingFont = staticFonts.find((sf) => {
+        var _a;
+        if (!((_a = sf.metaData) == null ? void 0 : _a.fullName)) return false;
+        const typefacePattern = new RegExp(`^${font.typefaceName}\\s+`, "i");
+        const stylePart = sf.metaData.fullName.replace(typefacePattern, "").trim();
+        return instanceName.toLowerCase() === stylePart.toLowerCase();
+      });
+    }
+    console.log(`Instance "${instanceName}" matched with:`, matchingFont ? matchingFont.title : "No match found");
+    instanceMappings.push({
+      key: instanceName,
+      value: matchingFont ? { _type: "reference", _ref: matchingFont._id, _weak: true } : null,
+      _key: nanoid2()
+    });
+  });
+  return instanceMappings;
+};
+var parseVariableFontInstances_default = parseVariableFontInstances;
+
+// src/utils/uploadFontFiles.js
+var uploadFontFiles = async (fontsObjects, subfamilies, client, inputPrice, stylesObject, setStatus, setError) => {
+  let fontRefs = [];
+  let variableRefs = [];
+  let failedFiles = [];
+  const fontObjectKeys = Object.keys(fontsObjects);
+  for (let i = 0; i < fontObjectKeys.length; i++) {
+    const id = fontObjectKeys[i];
+    const fontObject = fontsObjects[id];
+    const files = fontObject.files;
+    const fontKit = fontObject.fontKit;
+    let newFileInput = fontObject.fileInput;
+    fontObject.subfamily = subfamilies[id] ? subfamilies[id] : "";
+    fontObject.price = Number(inputPrice) ? Number(inputPrice) : 0;
+    if (fontObject.price > 0) fontObject.sell = true;
+    for (let j = 0; j < files.length; j++) {
+      const file = files[j];
+      const fileType = determineFileType(file);
+      console.log(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Uploading font file: ${fontObject._id}.${fileType}`);
+      setStatus(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Uploading font file: ${fontObject._id}.${fileType}`);
+      try {
+        const baseAsset = await client.assets.upload("file", file, { filename: fontObject._id + "." + fileType });
+        newFileInput[fileType] = {
+          _type: "file",
+          asset: { _ref: baseAsset._id, _type: "reference" }
+        };
+        if (fileType === "woff2") {
+          console.log(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Generating CSS for: ${fontObject.title}`);
+          setStatus(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Generating CSS for: ${fontObject.title}`);
+          newFileInput = await generateCssFile({
+            woff2File: file,
+            fileInput: newFileInput,
+            fontName: fontObject.title,
+            fileName: fontObject._id,
+            variableFont: fontObject.variableFont,
+            weight: fontObject.weight,
+            client,
+            style: fontObject.style
+          });
+        }
+        if (fileType === "ttf") {
+          console.log(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Generating font data for: ${fontObject.title}`);
+          setStatus(`[${i + 1}/${fontObjectKeys.length}][${j + 1}/${files.length}] Generating font data for: ${fontObject.title}`);
+          const metadata = await generateFontData({
+            fontId: fontObject._id,
+            url: baseAsset.url,
+            fontKit,
+            client,
+            commit: false
+          });
+          Object.assign(fontObject, metadata);
+        }
+      } catch (err) {
+        console.error("Error uploading font: ", fontObject.title, err.message);
+        setStatus("Error uploading font: " + err.message);
+        setError(true);
+        failedFiles.push({ name: file.name, fk: fontKit });
+        continue;
+      }
+      fontObject.fileInput = newFileInput;
+      fontsObjects[id] = fontObject;
+    }
+  }
+  console.log("Creating/updating Sanity font documents:", fontsObjects);
+  for (let i = 0; i < fontObjectKeys.length; i++) {
+    const fontId = fontObjectKeys[i];
+    const font = fontsObjects[fontId];
+    const fontRef = await createOrUpdateFontDocument(font, client, setError);
+    if (fontRef) {
+      if (!font.variableFont) {
+        addToFontRefs(fontRef, font, fontRefs, stylesObject);
+      } else {
+        addToVariableRefs(fontRef, font, variableRefs, stylesObject);
+      }
+      console.log(`[${i + 1}/${fontObjectKeys.length}] ${fontRef._ref} created`);
+      setStatus(`[${i + 1}/${fontObjectKeys.length}] ${fontRef._ref} created`);
+    }
+  }
+  return { fontRefs, variableRefs, failedFiles };
+};
+var determineFileType = (file) => {
+  if (file.name.endsWith(".otf")) return "otf";
+  if (file.name.endsWith(".ttf")) return "ttf";
+  if (file.name.endsWith(".woff")) return "woff";
+  if (file.name.endsWith(".woff2")) return "woff2";
+  if (file.name.endsWith(".eot")) return "eot";
+  if (file.name.endsWith(".svg")) return "svg";
+  return "";
+};
+var createOrUpdateFontDocument = async (font, client, setError) => {
+  try {
+    const existingFont = await client.fetch(
+      `*[_type == 'font' && _id == $fontId]{
+				fileInput,
+				description,
+				metaData,
+				metrics,
+				opentypeFeatures,
+				characterSet,
+				subfamily,
+				scriptFileInput,
+				variableInstanceReferences
+			}`,
+      { fontId: font._id }
+    ).then((res) => res[0]);
+    const { files, fontKit } = font;
+    delete font.files;
+    delete font.fontKit;
+    delete font.originalFilename;
+    if (font.variableFont && font.variableInstances) {
+      const instanceMappings = await parseVariableFontInstances(font, client);
+      if (instanceMappings.length > 0) {
+        font.variableInstanceReferences = instanceMappings;
+      }
+    }
+    let fontResponse;
+    if (existingFont) {
+      fontResponse = await updateExistingFont(font, existingFont, client);
+    } else {
+      fontResponse = await createNewFont(font, client);
+    }
+    return {
+      _key: nanoid3(),
+      _type: "reference",
+      _ref: fontResponse._id,
+      _weak: true
+    };
+  } catch (e) {
+    console.error("Error creating font: ", font.title, font.subfamily, e);
+    setError(true);
+    return null;
+  }
+};
+var updateExistingFont = async (font, existingFont, client) => {
+  if (existingFont.fileInput) {
+    const newFileInput = { ...font.fileInput };
+    Object.keys(existingFont.fileInput).forEach((key) => {
+      if (!newFileInput[key]) newFileInput[key] = existingFont.fileInput[key];
+    });
+    font.fileInput = newFileInput;
+  }
+  font.metaData = !(font == null ? void 0 : font.metaData) || Object.keys((font == null ? void 0 : font.metaData) || {}).length === 0 ? (existingFont == null ? void 0 : existingFont.metaData) || {} : font.metaData;
+  font.metrics = !(font == null ? void 0 : font.metrics) || Object.keys((font == null ? void 0 : font.metrics) || {}).length === 0 ? (existingFont == null ? void 0 : existingFont.metrics) || {} : font.metrics;
+  font.opentypeFeatures = !(font == null ? void 0 : font.opentypeFeatures) || Object.keys((font == null ? void 0 : font.opentypeFeatures) || {}).length === 0 ? (existingFont == null ? void 0 : existingFont.opentypeFeatures) || {} : font.opentypeFeatures;
+  font.characterSet = !(font == null ? void 0 : font.characterSet) || Object.keys((font == null ? void 0 : font.characterSet) || {}).length === 0 ? (existingFont == null ? void 0 : existingFont.characterSet) || {} : font.characterSet;
+  font.scriptFileInput = (existingFont == null ? void 0 : existingFont.scriptFileInput) || {};
+  cleanMetadataValues(font);
+  if (font.variableFont && (existingFont == null ? void 0 : existingFont.variableInstanceReferences) && (!font.variableInstanceReferences || font.variableInstanceReferences.length === 0)) {
+    font.variableInstanceReferences = existingFont.variableInstanceReferences;
+  }
+  console.log("Updating existing font: ", font._id, font.title);
+  const patchObject = {
+    fileInput: font.fileInput,
+    subfamily: font.subfamily,
+    weight: font.weight
+  };
+  if (font.variableInstanceReferences) {
+    patchObject.variableInstanceReferences = font.variableInstanceReferences;
+  }
+  return await client.patch(font._id).set(patchObject).commit();
+};
+var createNewFont = async (font, client) => {
+  console.log("Creating new font: ", font._id, font.title);
+  if (font.metaData) cleanMetadataValues(font);
+  const newDocument = {
+    _key: nanoid3(),
+    _id: font._id,
+    _type: "font",
+    ...font
+  };
+  return await client.createOrReplace(newDocument);
+};
+var cleanMetadataValues = (font) => {
+  if (!font.metaData) return;
+  Object.keys(font.metaData).forEach((key) => {
+    if (font.metaData[key] == null) {
+      font.metaData[key] = "";
+    } else {
+      font.metaData[key] = font.metaData[key].replace(/[-]/g, "");
+    }
+  });
+};
+var addToFontRefs = (fontRef, font, fontRefs, stylesObject) => {
+  if (stylesObject.fonts && stylesObject.fonts.length > 0) {
+    const fontExists = stylesObject.fonts.findIndex((f) => f._ref === fontRef._ref);
+    const inFontRefs = fontRefs.findIndex((f) => f._ref === fontRef._ref);
+    if (fontExists === -1 && inFontRefs === -1) fontRefs.push(fontRef);
+  } else {
+    fontRefs.push(fontRef);
+  }
+};
+var addToVariableRefs = (fontRef, font, variableRefs, stylesObject) => {
+  var _a;
+  if ((_a = stylesObject == null ? void 0 : stylesObject.variableFont) == null ? void 0 : _a.length) {
+    const vfExists = stylesObject.variableFont.findIndex((f) => f._ref === fontRef._ref);
+    const inVariableRefs = variableRefs.findIndex((f) => f._ref === fontRef._ref);
+    if (vfExists === -1 && inVariableRefs === -1 && font.variableFont) variableRefs.push(fontRef);
+  } else {
+    variableRefs.push(fontRef);
+  }
+};
+
+// src/utils/updateTypefaceDocument.js
+import { nanoid as nanoid4 } from "nanoid";
+var updateTypefaceDocument = async (doc_id, fontRefs, variableRefs, subfamilies, uniqueSubfamilies, subfamiliesArray, preferredStyleRef, newPreferredStyle, stylesObject, client, setStatus, setError) => {
+  console.log("Updating typeface document with new fonts:", { fontRefs, variableRefs, subfamilies, uniqueSubfamilies });
+  setStatus("Updating typeface references...");
+  let patch = {
+    styles: {
+      fonts: stylesObject.fonts ? [...stylesObject.fonts, ...fontRefs] : [...fontRefs],
+      subfamilies: uniqueSubfamilies.length > 1 ? uniqueSubfamilies : [],
+      variableFont: (stylesObject == null ? void 0 : stylesObject.variableFont) ? [...stylesObject.variableFont, ...variableRefs] : [...variableRefs]
+    }
+  };
+  setStatus("Organising font subfamilies...");
+  subfamiliesArray = subfamiliesArray || [];
+  uniqueSubfamilies.forEach((subfamilyName) => {
+    if (!subfamiliesArray.find((sf) => sf.title === subfamilyName)) {
+      subfamiliesArray.push({
+        title: subfamilyName,
+        _key: nanoid4(),
+        _type: "object",
+        fonts: []
+      });
+    }
+  });
+  if (subfamiliesArray.length > 0) {
+    Object.entries(subfamilies).forEach(([id, subfamilyName]) => {
+      if (id.toLowerCase().includes("vf")) return;
+      const subfamilyIndex = subfamiliesArray.findIndex((sf) => sf.title === subfamilyName);
+      if (subfamilyIndex !== -1) {
+        subfamiliesArray[subfamilyIndex].fonts.push({
+          _ref: id,
+          _key: nanoid4(),
+          _type: "reference",
+          _weak: true
+        });
+      }
+    });
+    subfamiliesArray = subfamiliesArray.map((subfamily) => ({
+      ...subfamily,
+      fonts: subfamily.fonts.filter(
+        (font, index, self) => index === self.findIndex((f) => f._ref === font._ref)
+      )
+    }));
+  }
+  patch.styles.subfamilies = subfamiliesArray;
+  await updatePreferredStyle(doc_id, preferredStyleRef, newPreferredStyle, patch, client);
+  console.log("doc_id: ", doc_id);
+  console.log("Typeface patch: ", patch);
+  console.log("New preferred style: ", newPreferredStyle);
+  console.log("SubfamiliesArray:", subfamiliesArray);
+  try {
+    await client.patch(doc_id).set(patch).commit();
+    console.log(`Updated document: ${doc_id}`);
+    if (doc_id.startsWith("drafts.")) {
+      await updatePublishedDocument(doc_id, patch, client);
+    }
+  } catch (err) {
+    console.error("Error updating document:", err.message);
+    setStatus("Error updating typeface");
+    setError(true);
+  }
+};
+var updatePreferredStyle = async (doc_id, preferredStyleRef, newPreferredStyle, patch, client) => {
+  var _a;
+  if ((preferredStyleRef == null ? void 0 : preferredStyleRef._ref) && preferredStyleRef._ref !== "" && preferredStyleRef._ref !== null && newPreferredStyle._ref !== preferredStyleRef._ref) {
+    const prefStyleResult = await client.fetch(
+      `*[_id == $docId]{ preferredStyle->{ weight, style, _id } }`,
+      { docId: doc_id }
+    );
+    const prefStyle = (_a = prefStyleResult[0]) == null ? void 0 : _a.preferredStyle;
+    if (!(prefStyle == null ? void 0 : prefStyle.weight) || prefStyle === null || prefStyle.weight < newPreferredStyle.weight) {
+      patch.preferredStyle = {
+        _type: "reference",
+        _ref: newPreferredStyle._ref,
+        _weak: true
+      };
+    }
+  }
+};
+var updatePublishedDocument = async (doc_id, patch, client) => {
+  const publishedId = doc_id.replace("drafts.", "");
+  const publishedDoc = await client.fetch(`*[_id == $publishedId]`, { publishedId }).then((res) => res[0]);
+  if (publishedDoc) {
+    await client.patch(publishedId).set(patch).commit();
+    console.log(`Updated published document: ${publishedId}`);
+  } else {
+    console.log(`No published document found for ${publishedId}, skipping`);
+  }
+};
+
+// src/utils/regenerateFontData.js
+import * as fontkit4 from "fontkit";
+var renameFontDocuments = async ({
+  client,
+  typefaceName,
+  slug,
+  weightKeywordList,
+  italicKeywordList,
+  preserveShortenedNames = false,
+  setStatus,
+  setError
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  try {
+    if (!typefaceName) {
+      setStatus("Typeface needs a title");
+      setError(true);
+      console.error("Typeface needs title");
+      return { success: false, message: "Typeface needs title" };
+    }
+    setStatus("Fetching font documents...");
+    const slugCurrent = (slug == null ? void 0 : slug.current) || typefaceName;
+    const query = await client.fetch(
+      `*[_type == "typeface" && slug.current == $slugCurrent][0]{
+				"fonts": styles.fonts[]->{ _id, title, subfamily, fileInput, style, weight, _key }
+			}`,
+      { slugCurrent }
+    );
+    const fontDocuments = (query == null ? void 0 : query.fonts) || [];
+    if (fontDocuments.length === 0) {
+      setStatus("No font documents found for this typeface");
+      setError(true);
+      return { success: false, message: "No font documents found for this typeface" };
+    }
+    setStatus(`Found ${fontDocuments.length} font documents to process...`);
+    let updatedCount = 0;
+    let skippedCount = 0;
+    let errorCount = 0;
+    for (let i = 0; i < fontDocuments.length; i++) {
+      const fontDoc = fontDocuments[i];
+      setStatus(`Processing font ${i + 1}/${fontDocuments.length}: ${fontDoc.title}`);
+      if (!((_c = (_b = (_a = fontDoc.fileInput) == null ? void 0 : _a.ttf) == null ? void 0 : _b.asset) == null ? void 0 : _c._ref) && !((_f = (_e = (_d = fontDoc.fileInput) == null ? void 0 : _d.otf) == null ? void 0 : _e.asset) == null ? void 0 : _f._ref)) {
+        console.log(`Skipping ${fontDoc.title} \u2014 no TTF or OTF file found`);
+        skippedCount++;
+        continue;
+      }
+      try {
+        let file;
+        let ttfAsset;
+        let otfAsset;
+        if ((_i = (_h = (_g = fontDoc.fileInput) == null ? void 0 : _g.ttf) == null ? void 0 : _h.asset) == null ? void 0 : _i._ref) {
+          ttfAsset = await client.getDocument(fontDoc.fileInput.ttf.asset._ref);
+        }
+        if (!(ttfAsset == null ? void 0 : ttfAsset.url)) {
+          if ((_l = (_k = (_j = fontDoc.fileInput) == null ? void 0 : _j.otf) == null ? void 0 : _k.asset) == null ? void 0 : _l._ref) {
+            otfAsset = await client.getDocument(fontDoc.fileInput.otf.asset._ref);
+          }
+          if (!(otfAsset == null ? void 0 : otfAsset.url)) {
+            console.log(`Skipping ${fontDoc.title} \u2014 no TTF or OTF URL`);
+            skippedCount++;
+            continue;
+          }
+          setStatus(`Fetching OTF file for ${fontDoc.title}...`);
+          const res = await fetch(otfAsset.url);
+          file = await res.blob();
+        } else {
+          setStatus(`Fetching TTF file for ${fontDoc.title}...`);
+          const res = await fetch(ttfAsset.url);
+          file = await res.blob();
+        }
+        const fontBuffer = await readFontFile(file);
+        const font = fontkit4.create(fontBuffer);
+        const { weightName, subfamilyName, fontTitle } = extractFontMetadata(
+          font,
+          typefaceName,
+          weightKeywordList,
+          italicKeywordList,
+          preserveShortenedNames
+        );
+        const slugValue = fontTitle.toLowerCase().replace(/\s+/g, "-");
+        setStatus(`Updating font ${i + 1}/${fontDocuments.length}: ${fontTitle}`);
+        await client.patch(fontDoc._id).set({
+          title: fontTitle,
+          slug: { _type: "slug", current: slugValue },
+          weightName,
+          subfamily: subfamilyName
+        }).commit();
+        updatedCount++;
+      } catch (err) {
+        console.error(`Error processing ${fontDoc.title}:`, err);
+        errorCount++;
+      }
+    }
+    const resultMessage = `Renamed ${updatedCount} of ${fontDocuments.length} font documents (${skippedCount} skipped, ${errorCount} errors)`;
+    setStatus(resultMessage);
+    return {
+      success: true,
+      message: resultMessage,
+      stats: { total: fontDocuments.length, updated: updatedCount, skipped: skippedCount, errors: errorCount }
+    };
+  } catch (err) {
+    console.error("Error renaming font documents:", err);
+    setError(true);
+    setStatus(`Error: ${err.message}`);
+    return { success: false, message: `Error: ${err.message}` };
+  }
+};
+
+// src/utils/updateFontPrices.js
+var updateFontPrices = async ({
+  client,
+  title,
+  slug,
+  inputPrice,
+  doc_id,
+  setStatus,
+  setError
+}) => {
+  var _a, _b;
+  try {
+    if (!title) {
+      setStatus("Typeface needs a title");
+      setError(true);
+      console.error("Typeface needs title");
+      return { success: false, message: "Typeface needs title" };
+    }
+    if (!(slug == null ? void 0 : slug.current)) {
+      setStatus("Typeface needs a slug");
+      setError(true);
+      console.error("Typeface needs slug");
+      return { success: false, message: "Typeface needs slug" };
+    }
+    const price = Number(inputPrice);
+    if (isNaN(price)) {
+      setStatus("Invalid price value");
+      setError(true);
+      console.error("Invalid price value");
+      return { success: false, message: "Invalid price value" };
+    }
+    setStatus("Fetching typeface document...");
+    const typeface = await client.fetch(
+      `*[_type == "typeface" && slug.current == $slug][0]`,
+      { slug: slug.current }
+    );
+    if (!typeface) {
+      setStatus("Typeface not found");
+      setError(true);
+      console.error("Typeface not found");
+      return { success: false, message: "Typeface not found" };
+    }
+    if (!((_b = (_a = typeface.styles) == null ? void 0 : _a.fonts) == null ? void 0 : _b.length)) {
+      setStatus("No fonts found in typeface");
+      setError(true);
+      console.error("No fonts found in typeface");
+      return { success: false, message: "No fonts found in typeface" };
+    }
+    const fontRefs = typeface.styles.fonts;
+    setStatus(`Updating prices for ${fontRefs.length} fonts...`);
+    let updatedCount = 0;
+    for (let i = 0; i < fontRefs.length; i++) {
+      try {
+        await client.patch(fontRefs[i]._ref).set({ price, sell: price > 0 }).commit();
+        updatedCount++;
+        setStatus(`Updated ${updatedCount}/${fontRefs.length} fonts...`);
+      } catch (err) {
+        console.error(`Error updating font ${fontRefs[i]._ref}:`, err);
+      }
+    }
+    const successMessage = `Successfully updated prices for ${updatedCount} fonts to $${price}`;
+    setStatus(successMessage);
+    console.log(successMessage);
+    return { success: true, message: successMessage, updatedCount };
+  } catch (err) {
+    const errorMessage = `Error: ${err.message}`;
+    console.error("Error updating font prices:", err);
+    setError(true);
+    setStatus(errorMessage);
+    return { success: false, message: errorMessage };
+  }
+};
+
+// src/components/StatusDisplay.jsx
+import React from "react";
+import { Flex, Text } from "@sanity/ui";
+var StatusDisplay = ({ status, error, action }) => {
+  return /* @__PURE__ */ React.createElement(Flex, { paddingTop: 1, paddingBottom: 3, align: "center", justify: "space-between" }, /* @__PURE__ */ React.createElement(Flex, { align: "center", gap: 2 }, /* @__PURE__ */ React.createElement(Text, { size: 1 }, "Status:"), /* @__PURE__ */ React.createElement(Text, { size: 1, style: { color: error ? "red" : "green" } }, status)), action && action);
+};
+var StatusDisplay_default = StatusDisplay;
+
+// src/components/PriceInput.jsx
+import React2 from "react";
+import { Flex as Flex2, Text as Text2 } from "@sanity/ui";
+var PriceInput = ({ inputPrice, handleInputChange }) => /* @__PURE__ */ React2.createElement(Flex2, { align: "center", gap: 2 }, /* @__PURE__ */ React2.createElement(Text2, { size: 1, muted: true }, "Price:"), /* @__PURE__ */ React2.createElement(Text2, { size: 1, muted: true }, "$"), /* @__PURE__ */ React2.createElement(
+  "input",
+  {
+    value: inputPrice,
+    onChange: handleInputChange,
+    type: "number",
+    style: { textAlign: "end", padding: "5px", maxWidth: "75px" }
+  }
+), /* @__PURE__ */ React2.createElement(Text2, { size: 1, muted: true }, "per style"));
+var PriceInput_default = PriceInput;
+
+// src/components/RegenerateSubfamiliesComponent.jsx
+import React3, { useState } from "react";
+import { nanoid as nanoid5 } from "nanoid";
+import { Button, Text as Text3, Stack, Box } from "@sanity/ui";
+import { useFormValue } from "sanity";
+var RegenerateSubfamiliesComponent = () => {
+  const [status, setStatus] = useState("");
+  const [ready, setReady] = useState(true);
+  const [error, setError] = useState(false);
+  const client = useSanityClient();
+  const doc_id = useFormValue(["_id"]);
+  const title = useFormValue(["title"]);
+  const slug = useFormValue(["slug"]);
+  const stylesObject = useFormValue(["styles"]) || { fonts: [], variableFont: [] };
+  const handleClick = () => {
+    regenerateSubfamilies({ title, stylesObject, slug, doc_id, client, setStatus, setReady, setError });
+  };
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, status && /* @__PURE__ */ React3.createElement(Box, { padding: 3, style: { borderRadius: "4px", marginBottom: "10px" } }, /* @__PURE__ */ React3.createElement(Text3, { size: 1, style: { color: error ? "red" : "green" } }, status)), /* @__PURE__ */ React3.createElement(Button, { mode: "ghost", tone: "primary", width: "fill", padding: 3, onClick: handleClick, disabled: !ready }, /* @__PURE__ */ React3.createElement(Stack, { space: 2 }, /* @__PURE__ */ React3.createElement(Text3, { align: "center" }, "Regenerate Subfamilies"))));
+};
+var regenerateSubfamilies = async ({ title, stylesObject, slug, doc_id, client, setStatus, setReady, setError }) => {
+  try {
+    setStatus("Regenerating subfamilies...");
+    setReady(false);
+    setError(false);
+    const allFonts = await fetchFonts(title, slug, client);
+    if (!allFonts || allFonts.length === 0) {
+      setStatus("No fonts found for this typeface");
+      setReady(true);
+      setError(true);
+      return;
+    }
+    console.log("Found fonts:", allFonts.length);
+    setStatus(`Found ${allFonts.length} fonts. Processing...`);
+    const subfamilies = groupFontsBySubfamily(allFonts);
+    const newSubfamiliesArray = createSubfamiliesArray(subfamilies);
+    console.log("New subfamilies:", newSubfamiliesArray);
+    setStatus(`Created ${newSubfamiliesArray.length} subfamily groups`);
+    await updateTypefaceSubfamilies(doc_id, stylesObject, newSubfamiliesArray, client, setStatus, setError);
+    setStatus("Subfamilies regenerated successfully");
+  } catch (e) {
+    console.error(e.message);
+    setStatus("Error regenerating subfamilies");
+    setError(true);
+  }
+  setReady(true);
+};
+var fetchFonts = async (title, slug, client) => {
+  const slugCurrent = (slug == null ? void 0 : slug.current) || title;
+  const query = await client.fetch(
+    `*[_type == "typeface" && slug.current == $slugCurrent][0]{
+			"fonts": styles.fonts[]->{ _id, title, subfamily, style, weight, _key }
+		}`,
+    { slugCurrent }
+  );
+  return (query == null ? void 0 : query.fonts) || [];
+};
+var groupFontsBySubfamily = (fonts) => {
+  const subfamilies = {};
+  fonts.forEach((font) => {
+    var _a;
+    if ((_a = font.title) == null ? void 0 : _a.includes("VF")) {
+      subfamilies[`VF_${font.title}`] = [font];
+    } else {
+      const subfamilyName = font.subfamily ? expandAbbreviations(font.subfamily) : "Regular";
+      if (!subfamilies[subfamilyName]) subfamilies[subfamilyName] = [];
+      subfamilies[subfamilyName].push(font);
+    }
+  });
+  return subfamilies;
+};
+var createSubfamiliesArray = (subfamilies) => {
+  return Object.keys(subfamilies).map((subfamilyName) => ({
+    title: subfamilyName,
+    _key: nanoid5(),
+    _type: "object",
+    fonts: subfamilies[subfamilyName].map((font) => ({
+      _ref: font._id,
+      _key: nanoid5(),
+      _type: "reference",
+      _weak: true
+    }))
+  }));
+};
+var updateTypefaceSubfamilies = async (doc_id, stylesObject, newSubfamiliesArray, client, setStatus, setError) => {
+  const patch = {
+    styles: {
+      ...stylesObject,
+      subfamilies: newSubfamiliesArray
+    }
+  };
+  try {
+    await client.patch(doc_id).set(patch).commit();
+    console.log(`Updated document: ${doc_id}`);
+    if (doc_id.startsWith("drafts.")) {
+      const publishedId = doc_id.replace("drafts.", "");
+      const publishedDoc = await client.fetch(`*[_id == $publishedId]`, { publishedId }).then((res) => res[0]);
+      if (publishedDoc) {
+        await client.patch(publishedId).set(patch).commit();
+        console.log(`Updated published document: ${publishedId}`);
+      } else {
+        console.log(`No published document found for ${publishedId}, skipping`);
+      }
+    }
+  } catch (err) {
+    console.error("Error updating document:", err.message);
+    setStatus("Error regenerating subfamilies");
+    setError(true);
+  }
+};
+
+// src/components/BatchUploadFonts.jsx
+var ACCEPTED_EXTENSIONS = ["ttf", "otf", "woff", "woff2", "eot", "svg"];
+var formatElapsed = (s) => {
+  const m = Math.floor(s / 60);
+  const sec = s % 60;
+  return m > 0 ? `${m}m ${sec}s` : `${sec}s`;
+};
+var BatchUploadFonts = () => {
+  const [status, setStatus] = useState2("ready");
+  const [ready, setReady] = useState2(true);
+  const [inputPrice, setInputPrice] = useState2("0");
+  const [error, setError] = useState2(false);
+  const [preserveShortenedNames, setPreserveShortenedNames] = useState2(true);
+  const [preserveFileNames, setPreserveFileNames] = useState2(false);
+  const [showUtilities, setShowUtilities] = useState2(false);
+  const [pendingFiles, setPendingFiles] = useState2([]);
+  const [isDragging, setIsDragging] = useState2(false);
+  const [elapsedSeconds, setElapsedSeconds] = useState2(0);
+  const fileInputRef = useRef(null);
+  const elapsedTimerRef = useRef(null);
+  const wakeLockRef = useRef(null);
+  const client = useSanityClient();
+  const doc_id = useFormValue2(["_id"]);
+  const title = useFormValue2(["title"]);
+  const preferredStyleRef = useFormValue2(["preferredStyle"]);
+  const slug = useFormValue2(["slug"]);
+  const stylesObject = useFormValue2(["styles"]) || { fonts: [], variableFont: [] };
+  const subfamiliesArray = (stylesObject == null ? void 0 : stylesObject.subfamilies) || [];
+  const { weightKeywordList, italicKeywordList } = useMemo2(() => generateStyleKeywords(), []);
+  useEffect(() => {
+    if (ready !== true) {
+      setElapsedSeconds(0);
+      elapsedTimerRef.current = setInterval(() => {
+        setElapsedSeconds((s) => s + 1);
+      }, 1e3);
+    } else {
+      clearInterval(elapsedTimerRef.current);
+    }
+    return () => clearInterval(elapsedTimerRef.current);
+  }, [ready]);
+  useEffect(() => {
+    if (ready !== true) {
+      const handler = (e) => {
+        e.preventDefault();
+        e.returnValue = "";
+      };
+      window.addEventListener("beforeunload", handler);
+      return () => window.removeEventListener("beforeunload", handler);
+    }
+  }, [ready]);
+  useEffect(() => {
+    var _a;
+    if (ready !== true) {
+      (_a = navigator.wakeLock) == null ? void 0 : _a.request("screen").then((lock) => {
+        wakeLockRef.current = lock;
+      }).catch(() => {
+      });
+    } else if (wakeLockRef.current) {
+      wakeLockRef.current.release().catch(() => {
+      });
+      wakeLockRef.current = null;
+    }
+  }, [ready]);
+  const validateInputs = (title2, inputPrice2) => {
+    const price = Number(inputPrice2);
+    if (!title2) {
+      setStatus("Typeface needs a title");
+      setError(true);
+      return false;
+    }
+    if (isNaN(price) || typeof price !== "number") {
+      setStatus("Invalid price \u2014 please refresh and try again");
+      setError(true);
+      return false;
+    }
+    return true;
+  };
+  const sortFilesByType = (files) => {
+    if (!files) return [];
+    const typeOrder = ["ttf", "otf", "eot", "svg", "woff", "woff2"];
+    return Array.from(files).sort((a, b) => {
+      const aIndex = typeOrder.indexOf(a.name.split(".").pop().toLowerCase());
+      const bIndex = typeOrder.indexOf(b.name.split(".").pop().toLowerCase());
+      if (aIndex === bIndex) return a.name.localeCompare(b.name);
+      return aIndex - bIndex;
+    });
+  };
+  const filterFontFiles = (files) => Array.from(files).filter((f) => ACCEPTED_EXTENSIONS.includes(f.name.split(".").pop().toLowerCase()));
+  const handleCompletionStatus = (failedFiles, setError2, setStatus2) => {
+    if (failedFiles.length > 0) {
+      console.error("Failed uploads:", {
+        files: failedFiles,
+        names: failedFiles.map((f) => f.name),
+        metadata: failedFiles.map((f) => {
+          var _a, _b;
+          return (_b = (_a = f == null ? void 0 : f.fk) == null ? void 0 : _a.name) == null ? void 0 : _b.records;
+        })
+      });
+      setError2(true);
+      setStatus2(`Upload completed with errors. Failed files: ${failedFiles.map((f) => f.name).join(", ")}`);
+    } else {
+      setError2(false);
+      setStatus2("Upload completed successfully");
+    }
+  };
+  const handleFileSelect = useCallback((e) => {
+    const files = filterFontFiles(e.target.files);
+    if (files.length > 0) setPendingFiles((prev) => [...prev, ...files]);
+    e.target.value = "";
+  }, []);
+  const handleRemoveFile = useCallback((file) => {
+    setPendingFiles((prev) => prev.filter((f) => f !== file));
+  }, []);
+  const handleDragEnter = useCallback((e) => {
+    e.preventDefault();
+    setIsDragging(true);
+  }, []);
+  const handleDragOver = useCallback((e) => {
+    e.preventDefault();
+  }, []);
+  const handleDragLeave = useCallback((e) => {
+    e.preventDefault();
+    setIsDragging(false);
+  }, []);
+  const handleDrop = useCallback((e) => {
+    e.preventDefault();
+    setIsDragging(false);
+    const files = filterFontFiles(e.dataTransfer.files);
+    if (files.length > 0) setPendingFiles((prev) => [...prev, ...files]);
+  }, []);
+  const handleConfirmUpload = useCallback(async () => {
+    try {
+      setStatus("Uploading font files...");
+      setReady("upload");
+      setError(false);
+      if (!validateInputs(title, inputPrice)) {
+        setReady(true);
+        return false;
+      }
+      const sortedFiles = sortFilesByType(pendingFiles);
+      setPendingFiles([]);
+      const { fontsObjects, subfamilies, uniqueSubfamilies, newPreferredStyle, failedFiles } = await processFontFiles(
+        sortedFiles,
+        title,
+        weightKeywordList,
+        italicKeywordList,
+        setStatus,
+        preserveShortenedNames,
+        preserveFileNames
+      );
+      const { fontRefs, variableRefs } = await uploadFontFiles(
+        fontsObjects,
+        subfamilies,
+        client,
+        inputPrice,
+        stylesObject,
+        setStatus,
+        setError
+      );
+      await updateTypefaceDocument(
+        doc_id,
+        fontRefs,
+        variableRefs,
+        subfamilies,
+        uniqueSubfamilies,
+        subfamiliesArray,
+        preferredStyleRef,
+        newPreferredStyle,
+        stylesObject,
+        client,
+        setStatus,
+        setError
+      );
+      handleCompletionStatus(failedFiles, setError, setStatus);
+    } catch (e) {
+      console.error(e.message);
+      setError(true);
+      setStatus("Error uploading font");
+    }
+    setReady(true);
+    setError(false);
+  }, [pendingFiles, stylesObject, title, slug, doc_id, inputPrice, weightKeywordList, italicKeywordList, client, preferredStyleRef, subfamiliesArray, preserveShortenedNames, preserveFileNames]);
+  const handleRenameExistingFonts = useCallback(async () => {
+    try {
+      setStatus("Processing font documents...");
+      setReady("rename");
+      setError(false);
+      if (!title) {
+        setStatus("Typeface needs a title");
+        setError(true);
+        setReady(true);
+        return false;
+      }
+      const result = await renameFontDocuments({
+        client,
+        typefaceName: title,
+        slug,
+        weightKeywordList,
+        italicKeywordList,
+        preserveShortenedNames,
+        setStatus,
+        setError
+      });
+      if (!result.success) setError(true);
+    } catch (err) {
+      console.error("Error renaming font documents:", err);
+      setError(true);
+      setStatus(`Error: ${err.message}`);
+    }
+    setReady(true);
+  }, [title, client, slug, weightKeywordList, italicKeywordList, preserveShortenedNames]);
+  const handleChangeFontPrice = useCallback(async () => {
+    setStatus("Updating font prices...");
+    setReady("price");
+    setError(false);
+    await updateFontPrices({ client, title, slug, inputPrice, doc_id, setStatus, setError });
+    setReady(true);
+  }, [title, slug, client, doc_id, inputPrice]);
+  const handleRegenerateCssFiles = useCallback(async () => {
+    var _a, _b, _c, _d;
+    try {
+      setStatus("Regenerating CSS files...");
+      setReady("css");
+      setError(false);
+      if (!title) {
+        setStatus("Typeface needs a title");
+        setError(true);
+        setReady(true);
+        return false;
+      }
+      if (!(slug == null ? void 0 : slug.current)) {
+        setStatus("Typeface needs a slug");
+        setError(true);
+        setReady(true);
+        return false;
+      }
+      const typeface = await client.fetch(
+        `*[_type == "typeface" && slug.current == $slug][0]`,
+        { slug: slug.current }
+      );
+      if (!typeface) {
+        setStatus("Typeface not found");
+        setError(true);
+        setReady(true);
+        return false;
+      }
+      if (!((_b = (_a = typeface.styles) == null ? void 0 : _a.fonts) == null ? void 0 : _b.length)) {
+        setStatus("No fonts found in typeface");
+        setError(true);
+        setReady(true);
+        return false;
+      }
+      const fontRefs = typeface.styles.fonts;
+      setStatus(`Regenerating CSS for ${fontRefs.length} fonts...`);
+      let updatedCount = 0;
+      let errorCount = 0;
+      for (let i = 0; i < fontRefs.length; i++) {
+        try {
+          const fontDoc = await client.fetch(`*[_id == $id][0]`, { id: fontRefs[i]._ref });
+          if (!fontDoc) {
+            errorCount++;
+            continue;
+          }
+          if (!((_d = (_c = fontDoc.fileInput) == null ? void 0 : _c.woff2) == null ? void 0 : _d.asset)) {
+            errorCount++;
+            continue;
+          }
+          const woff2Asset = await client.fetch(`*[_id == $id][0]`, { id: fontDoc.fileInput.woff2.asset._ref });
+          if (!(woff2Asset == null ? void 0 : woff2Asset.url)) {
+            errorCount++;
+            continue;
+          }
+          const woff2Response = await fetch(woff2Asset.url);
+          const woff2Blob = await woff2Response.blob();
+          const woff2File = new File([woff2Blob], `${fontDoc._id}.woff2`, { type: "font/woff2" });
+          setStatus(`Regenerating CSS for font ${i + 1}/${fontRefs.length}: ${fontDoc.title}`);
+          const updatedFileInput = await generateCssFile({
+            woff2File,
+            fileInput: fontDoc.fileInput,
+            fileName: fontDoc._id,
+            fontName: fontDoc.title,
+            variableFont: fontDoc.variableFont || false,
+            weight: fontDoc.weight || 400,
+            client,
+            style: fontDoc.style || "normal"
+          });
+          await client.patch(fontRefs[i]._ref).set({ fileInput: updatedFileInput }).commit();
+          updatedCount++;
+          setStatus(`Regenerated CSS for ${updatedCount}/${fontRefs.length} fonts...`);
+        } catch (err) {
+          console.error(`Error regenerating CSS for font ${fontRefs[i]._ref}:`, err);
+          errorCount++;
+        }
+      }
+      const successMessage = `Successfully regenerated CSS for ${updatedCount} fonts${errorCount > 0 ? ` (${errorCount} errors)` : ""}`;
+      setStatus(successMessage);
+      if (errorCount > 0) setError(true);
+    } catch (err) {
+      console.error("Error regenerating CSS files:", err);
+      setError(true);
+      setStatus(`Error: ${err.message}`);
+    }
+    setReady(true);
+  }, [title, slug, client]);
+  const handleInputChange = (e) => {
+    setInputPrice(e.target.value);
+    setError(false);
+    setStatus("ready");
+  };
+  const renderTooltipLabel = (label, description) => /* @__PURE__ */ React4.createElement(
+    Tooltip,
+    {
+      content: /* @__PURE__ */ React4.createElement(Box2, { padding: 2, style: { maxWidth: 260 } }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, style: { lineHeight: 1.6 } }, description)),
+      placement: "top",
+      portal: true
+    },
+    /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 1, style: { cursor: "default" } }, /* @__PURE__ */ React4.createElement(Label, null, label), /* @__PURE__ */ React4.createElement(InfoOutlineIcon, { style: { opacity: 0.5, display: "block" } }))
+  );
+  const renderProcessing = () => /* @__PURE__ */ React4.createElement(Stack2, { space: 3, paddingY: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 3 }, /* @__PURE__ */ React4.createElement(Spinner, null), /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true }, status)), /* @__PURE__ */ React4.createElement(Card, { tone: "caution", border: true, radius: 2, padding: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { align: "center", justify: "space-between", gap: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(WarningOutlineIcon, { style: { flexShrink: 0 } }), /* @__PURE__ */ React4.createElement(Text4, { size: 1, weight: "semibold" }, "Do not close or reload this tab")), /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true, style: { flexShrink: 0 } }, formatElapsed(elapsedSeconds)))));
+  const renderDropZone = () => /* @__PURE__ */ React4.createElement(
+    Box2,
+    {
+      onDragEnter: handleDragEnter,
+      onDragOver: handleDragOver,
+      onDragLeave: handleDragLeave,
+      onDrop: handleDrop,
+      style: {
+        border: `2px dashed ${isDragging ? "var(--card-focus-ring-color)" : "var(--card-border-color)"}`,
+        borderRadius: 4,
+        padding: "28px 16px",
+        textAlign: "center",
+        background: isDragging ? "rgba(100, 153, 255, 0.06)" : "transparent",
+        transition: "border-color 0.12s, background 0.12s",
+        cursor: "default"
+      }
+    },
+    /* @__PURE__ */ React4.createElement(
+      "input",
+      {
+        ref: fileInputRef,
+        type: "file",
+        multiple: true,
+        hidden: true,
+        accept: ".ttf,.otf,.woff,.woff2,.eot,.svg",
+        onChange: handleFileSelect
+      }
+    ),
+    /* @__PURE__ */ React4.createElement(Stack2, { space: 3 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true }, isDragging ? "Release to add files" : "Drop font files here"), /* @__PURE__ */ React4.createElement(Flex3, { justify: "center" }, /* @__PURE__ */ React4.createElement(
+      Button2,
+      {
+        mode: "ghost",
+        tone: "primary",
+        fontSize: 1,
+        padding: 2,
+        text: "Browse files",
+        onClick: () => {
+          var _a;
+          return (_a = fileInputRef.current) == null ? void 0 : _a.click();
+        }
+      }
+    )))
+  );
+  const renderFileList = () => {
+    const sorted = sortFilesByType(pendingFiles);
+    return /* @__PURE__ */ React4.createElement(Stack2, { space: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { align: "center", justify: "space-between" }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true }, pendingFiles.length, " file", pendingFiles.length === 1 ? "" : "s", " selected"), /* @__PURE__ */ React4.createElement(
+      Button2,
+      {
+        mode: "bleed",
+        tone: "default",
+        fontSize: 1,
+        padding: 1,
+        text: "Clear all",
+        onClick: () => setPendingFiles([])
+      }
+    )), /* @__PURE__ */ React4.createElement(Box2, { style: { maxHeight: "260px", overflowY: "auto", display: "flex", flexDirection: "column", gap: "4px" } }, sorted.map((file, i) => {
+      const ext = file.name.split(".").pop().toUpperCase();
+      return /* @__PURE__ */ React4.createElement(Card, { key: `${file.name}-${file.size}-${i}`, border: true, radius: 1, paddingX: 2, paddingY: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { justify: "space-between", align: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(Flex3, { gap: 3, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React4.createElement(
+        Text4,
+        {
+          size: 0,
+          style: { fontFamily: "monospace", minWidth: "2.5rem", flexShrink: 0 }
+        },
+        ext
+      ), /* @__PURE__ */ React4.createElement(Box2, { style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, /* @__PURE__ */ React4.createElement(Text4, { size: 1 }, file.name))), /* @__PURE__ */ React4.createElement(
+        Button2,
+        {
+          mode: "bleed",
+          tone: "critical",
+          icon: TrashIcon,
+          padding: 2,
+          onClick: () => handleRemoveFile(file)
+        }
+      )));
+    })), /* @__PURE__ */ React4.createElement(
+      Box2,
+      {
+        onDragEnter: handleDragEnter,
+        onDragOver: handleDragOver,
+        onDragLeave: handleDragLeave,
+        onDrop: handleDrop,
+        style: {
+          border: `2px dashed ${isDragging ? "var(--card-focus-ring-color)" : "var(--card-border-color)"}`,
+          borderRadius: 4,
+          padding: "10px 16px",
+          textAlign: "center",
+          background: isDragging ? "rgba(100, 153, 255, 0.06)" : "transparent",
+          transition: "border-color 0.12s, background 0.12s"
+        }
+      },
+      /* @__PURE__ */ React4.createElement(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          multiple: true,
+          hidden: true,
+          accept: ".ttf,.otf,.woff,.woff2,.eot,.svg",
+          onChange: handleFileSelect
+        }
+      ),
+      /* @__PURE__ */ React4.createElement(Flex3, { align: "center", justify: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true }, isDragging ? "Release to add" : "Drop more files or"), /* @__PURE__ */ React4.createElement(
+        Button2,
+        {
+          mode: "bleed",
+          tone: "primary",
+          fontSize: 1,
+          padding: 1,
+          text: "browse",
+          onClick: () => {
+            var _a;
+            return (_a = fileInputRef.current) == null ? void 0 : _a.click();
+          }
+        }
+      ))
+    ), /* @__PURE__ */ React4.createElement(
+      Button2,
+      {
+        mode: "ghost",
+        tone: "primary",
+        icon: UploadIcon,
+        text: `Upload ${pendingFiles.length} Font${pendingFiles.length === 1 ? "" : "s"}`,
+        style: { width: "100%" },
+        onClick: handleConfirmUpload
+      }
+    ));
+  };
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, title && title !== "" && slug && slug !== "" && /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(
+    StatusDisplay_default,
+    {
+      status,
+      error,
+      action: /* @__PURE__ */ React4.createElement(
+        Button2,
+        {
+          mode: showUtilities ? "default" : "ghost",
+          tone: "primary",
+          icon: ControlsIcon,
+          text: "Utilities",
+          fontSize: 1,
+          padding: 2,
+          onClick: () => setShowUtilities((v) => !v)
+        }
+      )
+    }
+  ), /* @__PURE__ */ React4.createElement(Card, { border: true, padding: 2, shadow: 1, radius: 2 }, showUtilities ? /* @__PURE__ */ React4.createElement(Stack2, { space: 4, marginTop: 2 }, /* @__PURE__ */ React4.createElement(Stack2, { space: 2 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, weight: "semibold", style: { lineHeight: 1.6 } }, "Regenerate Subfamilies"), /* @__PURE__ */ React4.createElement(RegenerateSubfamiliesComponent, null)), /* @__PURE__ */ React4.createElement(Stack2, { space: 3 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, weight: "semibold", style: { lineHeight: 1.6 } }, "Rename Fonts (name table, Full Name)"), /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(
+    Switch,
+    {
+      checked: preserveShortenedNames,
+      onChange: (e) => setPreserveShortenedNames(e.target.checked)
+    }
+  ), renderTooltipLabel(
+    "Preserve shortened names",
+    'Abbreviations in font names are kept as-is (e.g. "XNarrow" stays "XNarrow", "Bd" stays "Bd").'
+  )), ready === "rename" ? renderProcessing() : /* @__PURE__ */ React4.createElement(Button2, { mode: "ghost", tone: "primary", text: "Rename Existing Fonts", style: { width: "100%" }, onClick: handleRenameExistingFonts, disabled: ready !== true })), /* @__PURE__ */ React4.createElement(Stack2, { space: 3 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, weight: "semibold", style: { lineHeight: 1.6 } }, "Update Font Prices"), ready === "price" ? renderProcessing() : /* @__PURE__ */ React4.createElement(Stack2, { space: 2 }, /* @__PURE__ */ React4.createElement(PriceInput_default, { inputPrice, handleInputChange }), /* @__PURE__ */ React4.createElement(Button2, { mode: "ghost", tone: "primary", text: "Update All Font Prices", style: { width: "100%" }, onClick: handleChangeFontPrice, disabled: ready !== true }))), /* @__PURE__ */ React4.createElement(Stack2, { space: 3 }, /* @__PURE__ */ React4.createElement(Text4, { size: 1, weight: "semibold", style: { lineHeight: 1.6 } }, "Regenerate CSS"), /* @__PURE__ */ React4.createElement(Text4, { size: 1, muted: true, style: { lineHeight: 1.6 } }, "Rebuilds the CSS @font-face files for all fonts in the typeface fonts list."), ready === "css" ? renderProcessing() : /* @__PURE__ */ React4.createElement(Button2, { mode: "ghost", tone: "primary", text: "Regenerate CSS Files", style: { width: "100%" }, onClick: handleRegenerateCssFiles, disabled: ready !== true }))) : ready ? /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(Grid, { columns: [2], gap: 4, marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Box2, null, /* @__PURE__ */ React4.createElement(PriceInput_default, { inputPrice, handleInputChange })), /* @__PURE__ */ React4.createElement(Stack2, { space: 3 }, /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(
+    Switch,
+    {
+      checked: preserveShortenedNames,
+      onChange: (e) => setPreserveShortenedNames(e.target.checked)
+    }
+  ), renderTooltipLabel(
+    "Preserve shortened names",
+    'Abbreviations in font names are kept as-is (e.g. "XNarrow" stays "XNarrow", "Bd" stays "Bd").'
+  )), /* @__PURE__ */ React4.createElement(Flex3, { align: "center", gap: 2 }, /* @__PURE__ */ React4.createElement(
+    Switch,
+    {
+      checked: preserveFileNames,
+      onChange: (e) => setPreserveFileNames(e.target.checked)
+    }
+  ), renderTooltipLabel(
+    "Preserve file names",
+    "Original filename capitalisation is used for asset naming instead of the normalised font title."
+  )))), /* @__PURE__ */ React4.createElement(Box2, { marginTop: 3 }, pendingFiles.length === 0 ? renderDropZone() : renderFileList())) : renderProcessing())));
+};
+
+// src/components/GenerateCollectionsPairsComponent.jsx
+import React5, { useCallback as useCallback2, useState as useState3 } from "react";
+import { Stack as Stack3, Grid as Grid2, Flex as Flex4, Text as Text5, Button as Button3, Card as Card2, Spinner as Spinner2 } from "@sanity/ui";
+import { useFormValue as useFormValue3 } from "sanity";
+import slugify2 from "slugify";
+import { nanoid as nanoid6 } from "nanoid";
+var GenerateCollectionsPairsComponent = () => {
+  const [status, setStatus] = useState3("ready");
+  const [ready, setReady] = useState3(true);
+  const [collectionPrice, setCollectionPrice] = useState3(
+    process.env.SANITY_STUDIO_DEFAULT_COLLECTION_PRICE || 20
+  );
+  const [pairPrice, setPairPrice] = useState3(
+    process.env.SANITY_STUDIO_DEFAULT_PAIR_PRICE || 75
+  );
+  const client = useSanityClient();
+  const doc_id = useFormValue3(["_id"]);
+  const title = useFormValue3(["title"]);
+  const slug = useFormValue3(["slug"]);
+  const stylesObject = useFormValue3(["styles"]);
+  const createSanityCollection = useCallback2(async (fontsList, collectionSlug, newTitle) => {
+    const newSlug = collectionSlug.toLowerCase().trim();
+    const fontRefs = fontsList.map((font) => ({
+      _key: nanoid6(),
+      _type: "reference",
+      _ref: font._id ?? font._ref,
+      _weak: true
+    }));
+    let preferredStyle = { weight: fontsList[0].weight, style: fontsList[0].style, _ref: fontsList[0]._ref };
+    fontsList.forEach((font) => {
+      if (Number(font.weight) < Number(preferredStyle.weight)) return;
+      if (Number(font.weight) === Number(preferredStyle.weight) && preferredStyle.style === "Italic" && font.style === "Regular") {
+        preferredStyle = { weight: font.weight, style: font.style, _ref: font._id };
+      } else if (Number(font.weight) > Number(preferredStyle.weight)) {
+        preferredStyle = { weight: font.weight, style: font.style, _ref: font._id };
+      }
+    });
+    const price = (collectionPrice ? Number(collectionPrice) : 0) * fontRefs.length;
+    await client.createOrReplace({
+      _key: nanoid6(),
+      _id: newSlug,
+      _type: "collection",
+      state: "active",
+      type: "collection",
+      preferredStyle: { _type: "reference", _ref: preferredStyle._ref, _weak: true },
+      title: newTitle,
+      slug: { _type: "slug", current: newSlug },
+      fonts: fontRefs,
+      price
+    }).catch((err) => {
+      console.error("Error creating collection:", err.message);
+    });
+    return { _ref: newSlug, _type: "reference", _weak: true, _key: nanoid6() };
+  }, [collectionPrice, client]);
+  const createSanityPair = useCallback2(async (pair, pairSlug, newTitle) => {
+    const newSlug = pairSlug.toLowerCase().trim();
+    const fontRefs = pair.map((font) => ({
+      _key: nanoid6(),
+      _type: "reference",
+      _ref: font._id,
+      _weak: true
+    }));
+    await client.createOrReplace({
+      _key: nanoid6(),
+      _id: newSlug,
+      _type: "pair",
+      preferredStyle: { _type: "reference", _ref: fontRefs[0]._ref, _weak: true },
+      title: newTitle,
+      slug: { _type: "slug", current: newSlug },
+      fonts: fontRefs,
+      price: pairPrice ? Number(pairPrice) : 0
+    }).catch((err) => {
+      console.error("Error creating pair:", err.message);
+    });
+    return { _ref: newSlug, _type: "reference", _weak: true, _key: nanoid6() };
+  }, [pairPrice, client]);
+  const handleGenerateCollections = useCallback2(async () => {
+    setStatus("Generating collections...");
+    setReady(false);
+    try {
+      const result = await client.fetch(
+        `*[_type == "typeface" && _id == $id]{ "fonts": styles.fonts[] -> }[0]`,
+        { id: doc_id }
+      );
+      const sanityFonts = (result == null ? void 0 : result.fonts) ?? [];
+      const subfamilies = (stylesObject == null ? void 0 : stylesObject.subfamilies) ?? [];
+      const totalCollections = subfamilies.length + 3;
+      const fullFamily = [], uprights = [], italics = [];
+      for (const font of sanityFonts) {
+        fullFamily.push(font);
+        if (font.style === "Regular") uprights.push(font);
+        else italics.push(font);
+      }
+      const typefacePatch = [];
+      if (fullFamily.length > 1) {
+        setStatus(`[1/${totalCollections}] Generating full family collection`);
+        typefacePatch.push(await createSanityCollection(fullFamily, `${slug.current}-full-family`, `${title} Full Family`));
+      }
+      if (uprights.length > 1) {
+        setStatus(`[2/${totalCollections}] Generating uprights collection`);
+        const ref = await createSanityCollection(uprights, `${slug.current}-uprights`, `${title} Uprights`);
+        if (ref) typefacePatch.push(ref);
+      }
+      if (italics.length > 1) {
+        setStatus(`[3/${totalCollections}] Generating italics collection`);
+        const ref = await createSanityCollection(italics, `${slug.current}-italics`, `${title} Italics`);
+        if (ref) typefacePatch.push(ref);
+      }
+      for (let i = 0; i < subfamilies.length; i++) {
+        setStatus(`[${i + 4}/${totalCollections}] Generating ${subfamilies[i].title} collection`);
+        const ref = await createSanityCollection(
+          subfamilies[i].fonts,
+          `${slug.current}-${slugify2(subfamilies[i].title)}-family`,
+          `${title} ${subfamilies[i].title} Family`
+        );
+        if (ref) typefacePatch.push(ref);
+      }
+      await client.patch(doc_id).set({ styles: { ...stylesObject, collections: typefacePatch } }).commit();
+      setStatus("Collections generated");
+    } catch (err) {
+      console.error("Error generating collections:", err);
+      setStatus("Error generating collections");
+    }
+    setReady(true);
+  }, [doc_id, title, slug, stylesObject, collectionPrice, client, createSanityCollection]);
+  const handleGeneratePairs = useCallback2(async () => {
+    var _a;
+    setStatus("Generating pairs...");
+    setReady(false);
+    try {
+      const result = await client.fetch(
+        `*[_type == "typeface" && _id == $id]{ "fonts": styles.fonts[] -> }[0]`,
+        { id: doc_id }
+      );
+      const sanityFonts = (result == null ? void 0 : result.fonts) ?? [];
+      const regular = [], italic = [];
+      for (const font of sanityFonts) {
+        if (font.style === "Regular") regular.push(font);
+        else italic.push(font);
+      }
+      const pairs = [];
+      for (const reg of regular) {
+        for (const ita of italic) {
+          if (ita.subfamily === reg.subfamily && ita.weight === reg.weight && ita.weightName === reg.weightName) {
+            pairs.push([reg, ita]);
+          }
+        }
+      }
+      const typefacePatch = [];
+      for (let i = 0; i < pairs.length; i++) {
+        const [reg] = pairs[i];
+        let pairSlug, pairTitle;
+        if (reg.subfamily && reg.subfamily !== "") {
+          if (reg.subfamily === "Regular") {
+            pairSlug = `${slug.current}-${slugify2(reg.weightName)}s`;
+            pairTitle = `${title} ${reg.weightName}s`;
+          } else {
+            pairSlug = `${slug.current}-${slugify2(reg.subfamily)}-${slugify2(reg.weightName)}s`;
+            pairTitle = `${title} ${reg.subfamily} ${reg.weightName}s`;
+          }
+        } else {
+          pairSlug = `${slug.current}-${slugify2(reg.weightName)}s`;
+          pairTitle = `${title} ${reg.weightName}s`;
+        }
+        setStatus(`[${i + 1}/${pairs.length}] Generating ${pairTitle}`);
+        const ref = await createSanityPair(pairs[i], pairSlug, pairTitle);
+        if (ref) typefacePatch.push(ref);
+      }
+      const preferredStyle = ((_a = regular[0]) == null ? void 0 : _a._id) ?? "";
+      await client.patch(doc_id).set({
+        preferredStyle: { _ref: preferredStyle, _type: "reference", _weak: true },
+        styles: { ...stylesObject, pairs: typefacePatch }
+      }).commit();
+      setStatus("Pairs generated");
+    } catch (err) {
+      console.error("Error generating pairs:", err);
+      setStatus("Error generating pairs");
+    }
+    setReady(true);
+  }, [doc_id, title, slug, stylesObject, pairPrice, client, createSanityPair]);
+  if (!title || !slug) return null;
+  return /* @__PURE__ */ React5.createElement(Stack3, { space: 2 }, /* @__PURE__ */ React5.createElement(StatusDisplay_default, { status, error: false }), /* @__PURE__ */ React5.createElement(Card2, { border: true, padding: 2, shadow: 1, radius: 2 }, ready ? /* @__PURE__ */ React5.createElement(Stack3, { space: 3 }, /* @__PURE__ */ React5.createElement(Grid2, { columns: [2], gap: 4, marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React5.createElement(Stack3, { space: 2 }, /* @__PURE__ */ React5.createElement(Text5, { size: 1, muted: true }, "Collection price / font"), /* @__PURE__ */ React5.createElement(Flex4, { align: "center", gap: 2 }, /* @__PURE__ */ React5.createElement(Text5, { size: 1, muted: true }, "$"), /* @__PURE__ */ React5.createElement(
+    "input",
+    {
+      value: collectionPrice,
+      onChange: (e) => setCollectionPrice(e.target.value),
+      type: "number",
+      style: { textAlign: "end", padding: "5px", maxWidth: "75px" }
+    }
+  ))), /* @__PURE__ */ React5.createElement(Stack3, { space: 2 }, /* @__PURE__ */ React5.createElement(Text5, { size: 1, muted: true }, "Pair price"), /* @__PURE__ */ React5.createElement(Flex4, { align: "center", gap: 2 }, /* @__PURE__ */ React5.createElement(Text5, { size: 1, muted: true }, "$"), /* @__PURE__ */ React5.createElement(
+    "input",
+    {
+      value: pairPrice,
+      onChange: (e) => setPairPrice(e.target.value),
+      type: "number",
+      style: { textAlign: "end", padding: "5px", maxWidth: "75px" }
+    }
+  )))), /* @__PURE__ */ React5.createElement(Button3, { mode: "ghost", tone: "primary", text: "Generate Collections", style: { width: "100%" }, onClick: handleGenerateCollections }), /* @__PURE__ */ React5.createElement(Button3, { mode: "ghost", tone: "primary", text: "Generate Pairs", style: { width: "100%" }, onClick: handleGeneratePairs })) : /* @__PURE__ */ React5.createElement(Flex4, { align: "center", justify: "center", gap: 3, padding: 4 }, /* @__PURE__ */ React5.createElement(Spinner2, null), /* @__PURE__ */ React5.createElement(Text5, { muted: true, size: 1 }, status))));
+};
+
+// src/components/UpdateScriptsComponent.jsx
+import React6, { useState as useState4, useCallback as useCallback3, useRef as useRef2, useEffect as useEffect2 } from "react";
+import { Stack as Stack4, Text as Text6, Button as Button4 } from "@sanity/ui";
+import { useFormValue as useFormValue4, set } from "sanity";
+var UpdateScriptsComponent = (props) => {
+  const { onChange } = props;
+  const client = useSanityClient();
+  const scripts = useFormValue4(["scripts"]) || [];
+  const fonts = useFormValue4(["styles", "fonts"]);
+  const isReadyRef = useRef2(false);
+  const [message, setMessage] = useState4("");
+  useEffect2(() => {
+    const timer = setTimeout(() => {
+      isReadyRef.current = true;
+    }, 100);
+    return () => clearTimeout(timer);
+  }, []);
+  const updateFromFonts = useCallback3(async () => {
+    if (!fonts || fonts.length === 0) {
+      setMessage("No fonts found to extract scripts from");
+      return;
+    }
+    const fontRefs = fonts.map((font) => font._ref);
+    let result;
+    try {
+      result = await client.fetch(
+        `*[_type == "font" && _id in $fontRefs]{ _id, scriptFileInput }`,
+        { fontRefs }
+      );
+    } catch (err) {
+      console.error("Failed to fetch font documents:", err);
+      setMessage("Error updating scripts: " + err.message);
+      return;
+    }
+    const newScripts = result.reduce((acc, font) => {
+      if (!(font == null ? void 0 : font.scriptFileInput)) return acc;
+      for (const language of Object.keys(font.scriptFileInput)) {
+        if (!acc.includes(language)) acc.push(language);
+      }
+      return acc;
+    }, []);
+    if (isReadyRef.current) onChange(set(newScripts));
+    setMessage("Scripts updated");
+  }, [onChange, fonts, client]);
+  return /* @__PURE__ */ React6.createElement(Stack4, { space: 3 }, /* @__PURE__ */ React6.createElement(
+    Button4,
+    {
+      mode: "ghost",
+      tone: "primary",
+      width: "fill",
+      text: "Update Scripts from Font Files",
+      onClick: updateFromFonts
+    }
+  ), message && /* @__PURE__ */ React6.createElement(Text6, { size: 1, style: { color: "green" } }, message), props.renderDefault(props));
+};
+
+// src/components/SingleUploaderTool.jsx
+import React7, { useState as useState5, useEffect as useEffect3, useCallback as useCallback4, useMemo as useMemo3 } from "react";
+import { Button as Button5, Grid as Grid3, Stack as Stack5, Flex as Flex5, Box as Box3, Text as Text7, Card as Card3 } from "@sanity/ui";
+import { TrashIcon as TrashIcon2, ControlsIcon as ControlsIcon2 } from "@sanity/icons";
+import { useFormValue as useFormValue5, set as set2, unset } from "sanity";
+import { Buffer as Buffer3 } from "buffer";
+import * as fontkit5 from "fontkit";
+
+// src/utils/generateFontFile.js
+async function generateFontFile({
+  srcUrl,
+  language = null,
+  filename,
+  codes,
+  documentId,
+  documentTitle,
+  documentVariableFont,
+  documentStyle,
+  documentWeight,
+  fileInput
+}) {
+  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-fonts",
+      language,
+      srcUrl,
+      filename,
+      documentId,
+      documentTitle,
+      documentVariableFont,
+      documentStyle,
+      documentWeight,
+      fileInput,
+      codes
+    })
+  }).catch((e) => {
+    console.error(e.message);
+    return -1;
+  });
+  return 1;
+}
+
+// src/utils/generateSubset.js
+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;
+}
+
+// src/components/SingleUploaderTool.jsx
+var SingleUploaderTool = (props) => {
+  var _a, _b, _c, _d;
+  const client = useSanityClient();
+  const { elementProps: { ref }, onChange } = props;
+  const [message, setMessage] = useState5("");
+  const [status, setStatus] = useState5("ready");
+  const [error, setError] = useState5(false);
+  const [filenames, setFilenames] = useState5({});
+  const [showAdvanced, setShowAdvanced] = useState5(false);
+  const fileInput = useFormValue5(["fileInput"]);
+  const doc_id = useFormValue5(["_id"]);
+  const doc_title = useFormValue5(["title"]);
+  const doc_typefaceName = useFormValue5(["typefaceName"]);
+  const doc_variableFont = useFormValue5(["variableFont"]);
+  const doc_weight = useFormValue5(["weight"]);
+  const doc_style = useFormValue5(["style"]);
+  const doc_slug = useFormValue5(["slug"]);
+  const doc_metaData = useFormValue5(["metaData"]);
+  const { weightKeywordList, italicKeywordList } = useMemo3(() => generateStyleKeywords(), []);
+  useEffect3(() => {
+    handleSetFilenames();
+  }, [fileInput]);
+  const handleSetFilenames = useCallback4(async () => {
+    var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+    const woff2WebRef = ((_b2 = (_a2 = fileInput == null ? void 0 : fileInput.woff2_web) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref) ?? null;
+    const woff2SubsetRef = ((_d2 = (_c2 = fileInput == null ? void 0 : fileInput.woff2_subset) == null ? void 0 : _c2.asset) == null ? void 0 : _d2._ref) ?? null;
+    const assetIds = [
+      (_f = (_e = fileInput == null ? void 0 : fileInput.ttf) == null ? void 0 : _e.asset) == null ? void 0 : _f._ref,
+      (_h = (_g = fileInput == null ? void 0 : fileInput.otf) == null ? void 0 : _g.asset) == null ? void 0 : _h._ref,
+      (_j = (_i = fileInput == null ? void 0 : fileInput.woff) == null ? void 0 : _i.asset) == null ? void 0 : _j._ref,
+      (_l = (_k = fileInput == null ? void 0 : fileInput.woff2) == null ? void 0 : _k.asset) == null ? void 0 : _l._ref,
+      (_n = (_m = fileInput == null ? void 0 : fileInput.eot) == null ? void 0 : _m.asset) == null ? void 0 : _n._ref,
+      (_p = (_o = fileInput == null ? void 0 : fileInput.svg) == null ? void 0 : _o.asset) == null ? void 0 : _p._ref,
+      (_r = (_q = fileInput == null ? void 0 : fileInput.css) == null ? void 0 : _q.asset) == null ? void 0 : _r._ref,
+      woff2WebRef,
+      woff2SubsetRef
+    ].filter(Boolean);
+    if (assetIds.length === 0) {
+      setFilenames({});
+      return;
+    }
+    const assetData = await client.fetch(
+      `*[_id in $assetIds]{ _id, originalFilename }`,
+      { assetIds }
+    );
+    const fontNames = assetData.reduce((acc, cur) => {
+      if (cur.originalFilename.endsWith(".ttf")) acc.ttf = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".otf")) acc.otf = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".woff2") && cur._id === woff2WebRef) acc.woff2_web = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".woff2") && cur._id === woff2SubsetRef) acc.woff2_subset = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".woff2")) acc.woff2 = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".woff")) acc.woff = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".eot")) acc.eot = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".svg")) acc.svg = cur.originalFilename;
+      else if (cur.originalFilename.endsWith(".css")) acc.css = cur.originalFilename;
+      return acc;
+    }, {});
+    setFilenames(fontNames);
+  }, [fileInput, client]);
+  const handleGenerateCssFile = useCallback4(async () => {
+    var _a2, _b2;
+    setMessage("Building CSS: " + doc_title + ".css");
+    setStatus("Building CSS file");
+    setError(false);
+    try {
+      const woff2AssetRef = (_b2 = (_a2 = fileInput == null ? void 0 : fileInput.woff2) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref;
+      if (!woff2AssetRef) throw new Error("No woff2 file available");
+      const [woff2Asset] = await client.fetch(
+        `*[_id == $id]{ originalFilename, url }`,
+        { id: woff2AssetRef }
+      );
+      const blob = await (await fetch(woff2Asset.url)).blob();
+      const newFileInput = await generateCssFile({
+        woff2File: blob,
+        fileInput,
+        fontName: doc_title,
+        fileName: woff2Asset.originalFilename.replace(".woff2", ""),
+        variableFont: doc_variableFont,
+        weight: doc_weight,
+        client
+      });
+      setMessage("CSS built");
+      setStatus("CSS built successfully");
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+      onChange(set2(newFileInput));
+    } catch (err) {
+      console.error("Error building CSS file:", err);
+      setMessage("Error building CSS file: " + err.message);
+      setStatus("Error building CSS file");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, onChange, doc_title, doc_variableFont, doc_weight, client]);
+  const handleGenerateFontFile = useCallback4(async (code, sourceFile) => {
+    var _a2;
+    const isMissing = Array.isArray(code);
+    const label = code === "all" ? "all font files" : isMissing ? "missing files" : code + " file";
+    setMessage(`Building ${label}...`);
+    setStatus(`Building ${label}`);
+    setError(false);
+    try {
+      const url = `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_a2 = sourceFile == null ? void 0 : sourceFile.asset) == null ? void 0 : _a2._ref.replace("file-", "").replace("-", ".")}`;
+      const codes = code === "all" ? ["otf", "woff", "woff2", "eot", "svg", "data"] : isMissing ? code : [code];
+      await generateFontFile({
+        codes,
+        srcUrl: url,
+        filename: doc_slug.current,
+        documentId: doc_id,
+        documentTitle: doc_title,
+        documentVariableFont: doc_variableFont,
+        documentStyle: doc_style,
+        documentWeight: doc_weight,
+        fileInput,
+        client
+      });
+      setMessage("Files built");
+      setStatus("Files built successfully");
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error("Error building font files:", err);
+      setMessage("Error building font files: " + err.message);
+      setStatus("Error building font files");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [doc_id, doc_title, doc_variableFont, doc_style, doc_weight, doc_slug, fileInput, client]);
+  const handleGenerateFontData = useCallback4(async () => {
+    var _a2, _b2;
+    setMessage("Building font data...");
+    setStatus("Building font data");
+    setError(false);
+    try {
+      if (!((_b2 = (_a2 = fileInput == null ? void 0 : fileInput.ttf) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref)) {
+        setMessage("Error: TTF file is required for font data generation");
+        setStatus("Error: TTF file is required");
+        setError(true);
+        setTimeout(() => {
+          setMessage("");
+          setStatus("ready");
+          setError(false);
+        }, 2e3);
+        return;
+      }
+      const [ttfAsset] = await client.fetch(
+        `*[_id == $id]{ url }`,
+        { id: fileInput.ttf.asset._ref }
+      );
+      if (!(ttfAsset == null ? void 0 : ttfAsset.url)) throw new Error("Could not fetch TTF file URL");
+      const arrayBuffer = await (await fetch(ttfAsset.url)).arrayBuffer();
+      const font = fontkit5.create(Buffer3.from(arrayBuffer));
+      const { weightName, subfamilyName, style, variableFont } = extractFontMetadata(
+        font,
+        doc_typefaceName,
+        weightKeywordList,
+        italicKeywordList
+      );
+      const weight = determineWeight(font, weightName);
+      await client.patch(doc_id).set({ weightName, subfamily: subfamilyName, style, variableFont, weight }).commit();
+      const fontData = await generateFontData({
+        url: ttfAsset.url,
+        fontKit: font,
+        fontId: doc_id,
+        client,
+        commit: true
+      });
+      if (variableFont && fontData.variableInstances) {
+        const fontObj = {
+          _id: doc_id,
+          typefaceName: doc_typefaceName,
+          variableFont,
+          variableInstances: fontData.variableInstances
+        };
+        const instanceMappings = await parseVariableFontInstances(fontObj, client);
+        if (instanceMappings.length > 0) {
+          await client.patch(doc_id).set({ variableInstanceReferences: instanceMappings }).commit();
+        }
+      }
+      setMessage("Font data built successfully");
+      setStatus("Font data built successfully");
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error("Error building font data:", err);
+      setMessage("Error building font data: " + err.message);
+      setStatus("Error building font data");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, doc_id, doc_typefaceName, client, weightKeywordList, italicKeywordList]);
+  const handleGenerateSubsetAndWeb = useCallback4(async () => {
+    var _a2, _b2;
+    try {
+      const woff2AssetRef = (_b2 = (_a2 = fileInput == null ? void 0 : fileInput.woff2) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref;
+      if (!woff2AssetRef) throw new Error("No woff2 file available");
+      setMessage("Building WEB + SUBSET files...");
+      setStatus("Building WEB + SUBSET");
+      setError(false);
+      const [woff2Asset] = await client.fetch(
+        `*[_id == $id]{ originalFilename, url }`,
+        { id: woff2AssetRef }
+      );
+      await generateSubset({
+        woff2Url: woff2Asset.url,
+        filename: doc_slug.current,
+        documentId: doc_id,
+        documentTitle: doc_title,
+        documentVariableFont: doc_variableFont,
+        documentStyle: doc_style,
+        documentWeight: doc_weight
+      });
+      setMessage("WEB + SUBSET building in background");
+      setStatus("Building in background");
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 4e3);
+    } catch (err) {
+      console.error("Error building WEB + SUBSET:", err);
+      setMessage("Error: " + err.message);
+      setStatus("Error building WEB + SUBSET");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, doc_id, doc_title, doc_variableFont, doc_style, doc_weight, doc_slug, client]);
+  const handleUploadTopLevelFile = useCallback4(async (event, fieldName) => {
+    try {
+      const file = event.target.files[0];
+      if (!file) return;
+      const ext = file.name.split(".").pop();
+      const filename = `${doc_slug.current}-${fieldName}.${ext}`;
+      setMessage(`Uploading ${fieldName}...`);
+      setStatus(`Uploading ${fieldName}`);
+      setError(false);
+      const asset = await client.assets.upload("file", file, { filename });
+      const newFileInput = {
+        ...fileInput,
+        [fieldName]: { _type: "file", asset: { _ref: asset._id, _type: "reference" } }
+      };
+      onChange(set2(newFileInput));
+      setMessage(`${fieldName} uploaded`);
+      setStatus(`${fieldName} uploaded successfully`);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error(`Error uploading ${fieldName}:`, err);
+      setMessage("Error: " + err.message);
+      setStatus(`Error uploading ${fieldName}`);
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, onChange, doc_slug, client]);
+  const handleUpload = useCallback4(async (event, code) => {
+    try {
+      const file = event.target.files[0];
+      if (!file) {
+        setMessage("No file selected");
+        setStatus("No file selected");
+        setError(true);
+        return;
+      }
+      const ext = file.name.split(".").pop();
+      const filename = doc_slug.current + "." + ext;
+      setMessage("Uploading: " + filename);
+      setStatus("Uploading: " + filename);
+      setError(false);
+      const asset = await client.assets.upload("file", file, { filename });
+      let newFileInput = {
+        ...fileInput,
+        [code]: { _type: "file", asset: { _ref: asset._id, _type: "reference" } }
+      };
+      setMessage(filename + " uploaded");
+      setStatus(filename + " uploaded successfully");
+      if (code === "woff2") {
+        setMessage("Building CSS: " + doc_title + ".css");
+        setStatus("Building CSS file");
+        newFileInput = await generateCssFile({
+          woff2File: file,
+          fileInput: newFileInput,
+          fontName: doc_title,
+          fileName: filename.replace(".woff2", ""),
+          variableFont: doc_variableFont,
+          weight: doc_weight,
+          style: doc_style || "Normal",
+          client
+        });
+        setMessage(doc_title + ".css built");
+        setStatus("CSS file built successfully");
+      }
+      if (code === "ttf") {
+        const fontBuffer = await readFontFile(file);
+        const font = fontkit5.create(fontBuffer);
+        const { weightName, subfamilyName, style, variableFont } = extractFontMetadata(
+          font,
+          doc_typefaceName,
+          weightKeywordList,
+          italicKeywordList
+        );
+        const weight = determineWeight(font, weightName);
+        const normalizedId = doc_id.startsWith("drafts.") ? doc_id.replace("drafts.", "") : doc_id;
+        await client.patch(normalizedId).set({ weightName, subfamily: subfamilyName, style, variableFont, weight }).commit();
+      }
+      onChange(set2(newFileInput));
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error("Error uploading file:", err);
+      setMessage("Error uploading file: " + err.message);
+      setStatus("Error uploading file");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, onChange, doc_title, doc_typefaceName, doc_variableFont, doc_weight, doc_slug, doc_id, client, weightKeywordList, italicKeywordList]);
+  const handleDelete = useCallback4(async (code) => {
+    var _a2, _b2;
+    try {
+      setMessage(`Deleting ${code} file...`);
+      setStatus(`Deleting ${code} file`);
+      setError(false);
+      const asset = (_b2 = (_a2 = fileInput[code]) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref;
+      if (!asset) {
+        setMessage(`No ${code} file to delete`);
+        setStatus(`No ${code} file to delete`);
+        setError(true);
+        return;
+      }
+      onChange(unset([code]));
+      await client.delete(asset);
+      setMessage(`${code} file deleted`);
+      setStatus(`${code} file deleted successfully`);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error("Error deleting asset:", err);
+      setMessage("WARNING: " + err.message);
+      setStatus("Error deleting asset");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, onChange, client]);
+  const handleDeleteTopLevel = useCallback4(async (fieldName) => {
+    var _a2, _b2;
+    try {
+      setMessage(`Deleting ${fieldName}...`);
+      setStatus(`Deleting ${fieldName}`);
+      setError(false);
+      const asset = (_b2 = (_a2 = fileInput == null ? void 0 : fileInput[fieldName]) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref;
+      if (!asset) {
+        setMessage(`No ${fieldName} file to delete`);
+        setStatus(`No ${fieldName} file to delete`);
+        setError(true);
+        return;
+      }
+      onChange(unset([fieldName]));
+      await client.delete(asset);
+      setMessage(`${fieldName} deleted`);
+      setStatus(`${fieldName} deleted successfully`);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error(`Error deleting ${fieldName}:`, err);
+      setMessage("Error: " + err.message);
+      setStatus(`Error deleting ${fieldName}`);
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, onChange, client]);
+  const handleDeleteAll = useCallback4(async () => {
+    try {
+      setMessage("Deleting all files and metadata...");
+      setStatus("Deleting all files and metadata");
+      setError(false);
+      onChange(unset([]));
+      await client.patch(doc_id).set({
+        characterSet: { chars: [] },
+        glyphCount: 0,
+        metaData: void 0,
+        metrics: void 0,
+        normalWeight: void 0,
+        price: 0,
+        sell: false,
+        style: "Normal",
+        variableAxes: void 0,
+        variableFont: false,
+        weight: 400,
+        variableInstances: void 0
+      }).commit();
+      const allAssets = Object.keys(fileInput).filter((k) => k !== "documentInfo").map((k) => {
+        var _a2, _b2;
+        return (_b2 = (_a2 = fileInput[k]) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref;
+      }).filter(Boolean);
+      for (const assetRef of allAssets) {
+        try {
+          await client.delete(assetRef);
+        } catch (e) {
+          console.error("Error deleting asset:", e.message);
+        }
+      }
+      setMessage("All files and metadata deleted");
+      setStatus("All files and metadata deleted successfully");
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+      }, 2e3);
+    } catch (err) {
+      console.error("Error deleting all files:", err);
+      setMessage("Delete error: " + err.message);
+      setStatus("Error deleting all files");
+      setError(true);
+      setTimeout(() => {
+        setMessage("");
+        setStatus("ready");
+        setError(false);
+      }, 3e3);
+    }
+  }, [fileInput, doc_id, onChange, client]);
+  const renderFontSection = (format, buildSource = null) => {
+    var _a2, _b2;
+    const formatUpper = format.toUpperCase();
+    const hasFile = !!((_b2 = (_a2 = fileInput == null ? void 0 : fileInput[format]) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref);
+    const fileUrl = hasFile ? `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${fileInput[format].asset._ref.replace("file-", "").replace("-", ".")}` : null;
+    return /* @__PURE__ */ React7.createElement(Card3, { border: true, radius: 1, paddingX: 2, paddingY: 3 }, /* @__PURE__ */ React7.createElement(Flex5, { justify: "space-between", align: "center", gap: 2 }, /* @__PURE__ */ React7.createElement(Flex5, { gap: 3, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React7.createElement(Text7, { size: 0, style: { fontFamily: "monospace", minWidth: "2.5rem", flexShrink: 0, opacity: hasFile ? 1 : 0.5 } }, formatUpper), hasFile ? /* @__PURE__ */ React7.createElement(Box3, { style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, /* @__PURE__ */ React7.createElement("a", { href: fileUrl, target: "_blank", rel: "noreferrer" }, (filenames == null ? void 0 : filenames[format]) || "File")) : /* @__PURE__ */ React7.createElement(Text7, { size: 1, muted: true }, "\u2014")), status === "ready" && /* @__PURE__ */ React7.createElement(Flex5, { gap: 1, align: "center", style: { flexShrink: 0 } }, buildSource && (fileInput == null ? void 0 : fileInput[buildSource]) && /* @__PURE__ */ React7.createElement(Button5, { mode: "ghost", tone: "primary", fontSize: 1, padding: 2, onClick: () => handleGenerateFontFile(format, fileInput[buildSource]), text: "Build" }), /* @__PURE__ */ React7.createElement(Button5, { as: "label", mode: "ghost", tone: "primary", fontSize: 1, padding: 2, style: { cursor: "pointer" } }, /* @__PURE__ */ React7.createElement(Text7, { size: 1 }, "Upload"), /* @__PURE__ */ React7.createElement("input", { ref, type: "file", hidden: true, onChange: (e) => handleUpload(e, format) })), hasFile && /* @__PURE__ */ React7.createElement(Button5, { mode: "bleed", tone: "critical", icon: TrashIcon2, padding: 2, onClick: () => handleDelete(format) }))));
+  };
+  const renderTopLevelAssetSection = (label, fieldName, assetRef, filename, onBuild) => {
+    const hasFile = !!assetRef;
+    const fileUrl = hasFile ? `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${assetRef.replace("file-", "").replace("-", ".")}` : null;
+    return /* @__PURE__ */ React7.createElement(Card3, { border: true, radius: 1, paddingX: 2, paddingY: 3 }, /* @__PURE__ */ React7.createElement(Flex5, { justify: "space-between", align: "center", gap: 2 }, /* @__PURE__ */ React7.createElement(Flex5, { gap: 3, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React7.createElement(Text7, { size: 0, style: { fontFamily: "monospace", minWidth: "2.5rem", flexShrink: 0, opacity: hasFile ? 1 : 0.5 } }, label), hasFile ? /* @__PURE__ */ React7.createElement(Box3, { style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, /* @__PURE__ */ React7.createElement("a", { href: fileUrl, target: "_blank", rel: "noreferrer" }, filename || "File")) : /* @__PURE__ */ React7.createElement(Text7, { size: 1, muted: true }, "\u2014")), status === "ready" && /* @__PURE__ */ React7.createElement(Flex5, { gap: 1, align: "center", style: { flexShrink: 0 } }, onBuild && (fileInput == null ? void 0 : fileInput.woff2) && /* @__PURE__ */ React7.createElement(Button5, { mode: "ghost", tone: "primary", fontSize: 1, padding: 2, onClick: onBuild, text: "Build" }), /* @__PURE__ */ React7.createElement(Button5, { as: "label", mode: "ghost", tone: "primary", fontSize: 1, padding: 2, style: { cursor: "pointer" } }, /* @__PURE__ */ React7.createElement(Text7, { size: 1 }, "Upload"), /* @__PURE__ */ React7.createElement("input", { type: "file", hidden: true, onChange: (e) => handleUploadTopLevelFile(e, fieldName) })), hasFile && /* @__PURE__ */ React7.createElement(Button5, { mode: "bleed", tone: "critical", icon: TrashIcon2, padding: 2, onClick: () => handleDeleteTopLevel(fieldName) }))));
+  };
+  const renderCssSection = () => {
+    var _a2, _b2;
+    const hasFile = !!((_b2 = (_a2 = fileInput == null ? void 0 : fileInput.css) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref);
+    const fileUrl = hasFile ? `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${fileInput.css.asset._ref.replace("file-", "").replace("-", ".")}` : null;
+    return /* @__PURE__ */ React7.createElement(Card3, { border: true, radius: 1, paddingX: 2, paddingY: 3 }, /* @__PURE__ */ React7.createElement(Flex5, { justify: "space-between", align: "center", gap: 2 }, /* @__PURE__ */ React7.createElement(Flex5, { gap: 3, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React7.createElement(Text7, { size: 0, style: { fontFamily: "monospace", minWidth: "2.5rem", flexShrink: 0, opacity: hasFile ? 1 : 0.5 } }, "CSS"), hasFile ? /* @__PURE__ */ React7.createElement(Box3, { style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, /* @__PURE__ */ React7.createElement("a", { href: fileUrl, target: "_blank", rel: "noreferrer" }, (filenames == null ? void 0 : filenames.css) || "File")) : /* @__PURE__ */ React7.createElement(Text7, { size: 1, muted: true }, "\u2014")), status === "ready" && /* @__PURE__ */ React7.createElement(Flex5, { gap: 1, align: "center", style: { flexShrink: 0 } }, (fileInput == null ? void 0 : fileInput.woff2) && /* @__PURE__ */ React7.createElement(Button5, { mode: "ghost", tone: "primary", fontSize: 1, padding: 2, onClick: () => handleGenerateCssFile(), text: "Build" }), hasFile && /* @__PURE__ */ React7.createElement(Button5, { mode: "bleed", tone: "critical", icon: TrashIcon2, padding: 2, onClick: () => handleDelete("css") }))));
+  };
+  const renderDataSection = () => /* @__PURE__ */ React7.createElement(Card3, { border: true, radius: 1, paddingX: 2, paddingY: 3 }, /* @__PURE__ */ React7.createElement(Flex5, { justify: "space-between", align: "center", gap: 2 }, /* @__PURE__ */ React7.createElement(Flex5, { gap: 3, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React7.createElement(Text7, { size: 0, style: { fontFamily: "monospace", minWidth: "2.5rem", flexShrink: 0, opacity: (doc_metaData == null ? void 0 : doc_metaData.version) ? 1 : 0.5 } }, "DATA"), (doc_metaData == null ? void 0 : doc_metaData.version) ? /* @__PURE__ */ React7.createElement(Text7, { size: 1 }, "v", doc_metaData.version, " ", /* @__PURE__ */ React7.createElement(Text7, { as: "span", size: 1, muted: true }, "(", doc_metaData.genDate, ")")) : /* @__PURE__ */ React7.createElement(Text7, { size: 1, muted: true }, "\u2014")), status === "ready" && (fileInput == null ? void 0 : fileInput.ttf) && /* @__PURE__ */ React7.createElement(Flex5, { gap: 1, align: "center", style: { flexShrink: 0 } }, /* @__PURE__ */ React7.createElement(Button5, { mode: "ghost", tone: "primary", fontSize: 1, padding: 2, onClick: () => handleGenerateFontData(), text: "Build" }))));
+  return /* @__PURE__ */ React7.createElement(Stack5, { space: 2 }, /* @__PURE__ */ React7.createElement(
+    StatusDisplay_default,
+    {
+      status,
+      error,
+      action: /* @__PURE__ */ React7.createElement(
+        Button5,
+        {
+          mode: "bleed",
+          icon: ControlsIcon2,
+          padding: 2,
+          tone: showAdvanced ? "primary" : "default",
+          title: "Show advanced file formats",
+          onClick: () => setShowAdvanced((v) => !v)
+        }
+      )
+    }
+  ), renderFontSection("ttf"), status === "ready" && (fileInput == null ? void 0 : fileInput.ttf) && /* @__PURE__ */ React7.createElement(Grid3, { columns: [2], gap: 2 }, /* @__PURE__ */ React7.createElement(
+    Button5,
+    {
+      mode: "ghost",
+      tone: "primary",
+      onClick: () => handleGenerateFontFile("all", fileInput.ttf),
+      text: "Rebuild All from TTF",
+      style: { width: "100%" }
+    }
+  ), /* @__PURE__ */ React7.createElement(
+    Button5,
+    {
+      mode: "ghost",
+      tone: "primary",
+      onClick: () => {
+        var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j;
+        const missing = [
+          !((_b2 = (_a2 = fileInput == null ? void 0 : fileInput.otf) == null ? void 0 : _a2.asset) == null ? void 0 : _b2._ref) && "otf",
+          !((_d2 = (_c2 = fileInput == null ? void 0 : fileInput.woff) == null ? void 0 : _c2.asset) == null ? void 0 : _d2._ref) && "woff",
+          !((_f = (_e = fileInput == null ? void 0 : fileInput.woff2) == null ? void 0 : _e.asset) == null ? void 0 : _f._ref) && "woff2",
+          !((_h = (_g = fileInput == null ? void 0 : fileInput.eot) == null ? void 0 : _g.asset) == null ? void 0 : _h._ref) && "eot",
+          !((_j = (_i = fileInput == null ? void 0 : fileInput.svg) == null ? void 0 : _i.asset) == null ? void 0 : _j._ref) && "svg",
+          !(doc_metaData == null ? void 0 : doc_metaData.version) && "data"
+        ].filter(Boolean);
+        handleGenerateFontFile(missing, fileInput.ttf);
+      },
+      text: "Build Missing",
+      style: { width: "100%" }
+    }
+  )), renderFontSection("otf", "woff"), renderFontSection("woff", "ttf"), renderFontSection("woff2", "ttf"), showAdvanced && renderTopLevelAssetSection("WEB", "woff2_web", (_b = (_a = fileInput == null ? void 0 : fileInput.woff2_web) == null ? void 0 : _a.asset) == null ? void 0 : _b._ref, filenames == null ? void 0 : filenames.woff2_web, handleGenerateSubsetAndWeb), showAdvanced && renderTopLevelAssetSection("SUBSET", "woff2_subset", (_d = (_c = fileInput == null ? void 0 : fileInput.woff2_subset) == null ? void 0 : _c.asset) == null ? void 0 : _d._ref, filenames == null ? void 0 : filenames.woff2_subset, handleGenerateSubsetAndWeb), showAdvanced && renderFontSection("eot", "ttf"), showAdvanced && renderFontSection("svg", "ttf"), renderCssSection(), showAdvanced && renderDataSection(), status === "ready" && ((fileInput == null ? void 0 : fileInput.ttf) || (fileInput == null ? void 0 : fileInput.otf) || (fileInput == null ? void 0 : fileInput.woff) || (fileInput == null ? void 0 : fileInput.woff2)) && /* @__PURE__ */ React7.createElement(Button5, { mode: "ghost", tone: "critical", onClick: () => handleDeleteAll(), text: "Delete All", style: { width: "100%" } }));
+};
+
+// src/components/UploadScriptsComponent.jsx
+import React9, { useCallback as useCallback5, useEffect as useEffect4, useMemo as useMemo4, useState as useState6 } from "react";
+import { Button as Button6, Flex as Flex6, Grid as Grid4, Stack as Stack6, Text as Text8, TextInput, MenuButton, Menu, MenuItem, Select } from "@sanity/ui";
+import * as fontkit6 from "fontkit";
+import slugify3 from "slugify";
+import { useFormValue as useFormValue6 } from "sanity";
+import { nanoid as nanoid7 } from "nanoid";
+
+// src/utils/utils.js
+import React8 from "react";
+var HtmlDescription = ({ children }) => {
+  return children || "";
+};
+var SCRIPTS = (process.env.SANITY_STUDIO_SCRIPTS || "").split(",").map((script) => script.trim()).filter(Boolean);
+var SCRIPTS_OBJECT = SCRIPTS.map((script) => {
+  return { title: script[0].toUpperCase() + script.slice(1), value: script };
+});
+
+// src/components/UploadScriptsComponent.jsx
+var UploadScriptsComponent = (props) => {
+  const { elementProps: { ref } } = props;
+  const client = useSanityClient();
+  const [selectedScript, setSelectedScript] = useState6("");
+  const [status, setStatus] = React9.useState("");
+  const [ready, setReady] = React9.useState(true);
+  let doc_id = useFormValue6(["_id"]);
+  const title = useFormValue6(["title"]);
+  const slug = useFormValue6(["slug"]);
+  const scripts = useFormValue6(["scripts"]) || [];
+  const stylesObject = useFormValue6(["styles"]);
+  let subfamiliesArray = (stylesObject == null ? void 0 : stylesObject.subfamilies) || [];
+  const { weightKeywordList, italicKeywordList } = useMemo4(
+    () => generateStyleKeywords(),
+    []
+  );
+  const readFontFile3 = (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);
+    });
+  };
+  const handleUpload = useCallback5(async (event, script) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    setReady(false);
+    try {
+      let failedFiles = [];
+      console.log("handle upload ", title, script);
+      setStatus("uploading fonts files.. ");
+      if (!title) {
+        console.error("typeface needs title");
+        return;
+      }
+      let fontRefs = [];
+      let variableRefs = [];
+      let subfamilies = {};
+      let fontsObjects = {};
+      for (var i = 0; i < event.target.files.length; i++) {
+        const file = event.target.files[i];
+        const fontBuffer = await readFontFile3(file);
+        const font = fontkit6.create(fontBuffer);
+        console.log("reading font : ", font.fullName + " " + file.name, font.name.records);
+        let weightName = ((_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.preferredSubfamily) ? (_d = (_c = font == null ? void 0 : font.name) == null ? void 0 : _c.records) == null ? void 0 : _d.preferredSubfamily : (_f = (_e = font == null ? void 0 : font.name) == null ? void 0 : _e.records) == null ? void 0 : _f.fontSubfamily;
+        weightName = (weightName == null ? void 0 : weightName.en) ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
+        weightName = weightName == null ? void 0 : weightName.replace("Italic", "").replace("It", "").trim();
+        if ((weightName == "" || weightName.toLowerCase() == "roman") && ((_h = (_g = font == null ? void 0 : font.name) == null ? void 0 : _g.records) == null ? void 0 : _h.fullName)) {
+          weightName = (_j = (_i = font == null ? void 0 : font.name) == null ? void 0 : _i.records) == null ? void 0 : _j.fullName;
+          weightName = (weightName == null ? void 0 : weightName.en) ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
+          weightName = weightName == null ? void 0 : weightName.replace(title + " ", "").replace(title, "").trim();
+          weightName = weightName == null ? void 0 : weightName.replace("Italic", "").replace("It", "").trim();
+        }
+        let variableFont = (font == null ? void 0 : font.variationAxes) && Object.keys(font.variationAxes).length > 0 ? true : false;
+        let subfamilyName = font.familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), "").trim();
+        let fontTitle = font == null ? void 0 : font.fullName;
+        let style = (font == null ? void 0 : font.italicAngle) !== 0 || (font == null ? void 0 : font.fullName.toLowerCase().includes("italic")) ? "Italic" : "Regular";
+        if (fontTitle.toLowerCase().trim().includes(script)) {
+          fontTitle = fontTitle.toLowerCase().trim().replace(script, "").trim();
+          fontTitle = fontTitle.split(" ").map((word) => {
+            if (word == "") return;
+            return word;
+          }).filter((word) => word != void 0).join(" ");
+        }
+        weightKeywordList.forEach((keyword) => {
+          const kw = keyword.trim();
+          if (subfamilyName.includes(kw)) subfamilyName = subfamilyName.replace(kw, "").trim();
+        });
+        let italicKW = [];
+        italicKeywordList.forEach((keyword) => {
+          const kw = keyword.toLowerCase().trim();
+          if (subfamilyName.includes(kw)) {
+            subfamilyName = subfamilyName.replace(kw, "");
+          }
+          if (fontTitle.includes(kw)) {
+            fontTitle = fontTitle.replace(kw, "");
+            italicKW.push(kw.charAt(0).toUpperCase() + kw.slice(1));
+          }
+        });
+        fontTitle = fontTitle.replace(/-/g, " ");
+        fontTitle = fontTitle.trim().split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+        if (subfamilyName.trim().includes(script)) {
+          subfamilyName = subfamilyName.trim().replace(script, "").trim();
+        }
+        subfamilyName = subfamilyName.trim();
+        subfamilyName = subfamilyName == "" ? "Regular" : subfamilyName.split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+        if (subfamilyName !== "") {
+          weightName = weightName.replace(`${subfamilyName} `, "").replace(` ${subfamilyName}`, "").trim();
+        }
+        if (variableFont && !fontTitle.toLowerCase().trim().endsWith(" vf")) fontTitle = fontTitle + " VF";
+        if (italicKW.length > 0) {
+          italicKW = italicKW.map((item) => reverseSpellingLookup(item));
+          fontTitle = fontTitle + italicKW.join(" ");
+          style = "Italic";
+        }
+        let id = slugify3(fontTitle.toLowerCase().trim());
+        console.log("=== Font Info ====");
+        console.log(" ");
+        console.log("font id : ", id);
+        console.log("font title : ", fontTitle);
+        console.log("fontkit fullName : ", font.fullName);
+        console.log("fontkit family name: ", font.familyName);
+        console.log("file name : ", file.name);
+        console.log("subfamily : ", subfamilyName);
+        console.log("style : ", style);
+        console.log("weight : ", weightName);
+        console.log("variable : ", variableFont);
+        console.log("italicKW ", italicKW);
+        console.log(" ");
+        console.log("=======");
+        subfamilies[id] = subfamilyName;
+        if (fontsObjects[id]) {
+          fontsObjects[id].files = [...fontsObjects[id].files, file];
+        } else {
+          let fontObject = {
+            _key: nanoid7(),
+            _id: id,
+            title: fontTitle,
+            slug: { _type: "slug", current: id },
+            typefaceName: title,
+            // Change to match Typeface Document
+            style: (font == null ? void 0 : font.italicAngle) !== 0 || (font == null ? void 0 : font.fullName.toLowerCase().includes("italic")) ? "Italic" : "Regular",
+            variableFont,
+            weightName,
+            normalWeight: true,
+            // TODO : check if weight is normal ??
+            weight: ((_k = font["OS/2"]) == null ? void 0 : _k.usWeightClass) ? Number((_l = font["OS/2"]) == null ? void 0 : _l.usWeightClass) : /hairline|extra thin|extrathin/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 100 : /thin|extra light|extralight/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 200 : /light|book/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 300 : /regular|normal/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 400 : /medium/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 500 : /semi bold|semibold/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 600 : /bold/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 700 : /extra bold|extrabold/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 800 : /black|ultra/.test(weightName == null ? void 0 : weightName.toLowerCase()) ? 900 : 400,
+            files: [file],
+            fontKit: font,
+            scriptFileInput: { [script]: {} }
+          };
+          fontsObjects[id] = fontObject;
+        }
+      }
+      let uniqueSubfamiles = [...new Set(Object.values(subfamilies))];
+      console.log("Subfamilies : ", subfamilies, uniqueSubfamiles, uniqueSubfamiles.length);
+      console.log("fontsObjects : ", fontsObjects);
+      for (var i = 0; i < Object.keys(fontsObjects).length; i++) {
+        let id = Object.keys(fontsObjects)[i];
+        let fontObject = fontsObjects[id];
+        let files = fontObject.files;
+        let newFileInput = fontObject.scriptFileInput[script];
+        console.log(fontObject.title, " : subfamily : ", subfamilies[id]);
+        if (uniqueSubfamiles.length > 1) fontObject.subfamily = subfamilies[id];
+        else fontObject.subfamily = "";
+        fontObject.price = process.env.SANITY_STUDIO_DEFAULT_STYLE_PRICE || 40;
+        if (fontObject.price > 0) fontObject.sell = true;
+        for (var j = 0; j < files.length; j++) {
+          let file = files[j];
+          let fileType = "";
+          if (file.name.endsWith(".otf")) fileType = "otf";
+          else if (file.name.endsWith(".ttf")) fileType = "ttf";
+          else if (file.name.endsWith(".woff")) fileType = "woff";
+          else if (file.name.endsWith(".woff2")) fileType = "woff2";
+          else if (file.name.endsWith(".eot")) fileType = "eot";
+          else if (file.name.endsWith(".svg")) fileType = "svg";
+          console.log("uploading font file : ", fontObject._id + "." + fileType);
+          const filename = fontObject._id + "-" + script;
+          let fontTitle = fontObject.title + " " + script;
+          fontTitle = fontTitle.split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+          let baseAsset = await client.assets.upload("file", file, { filename: filename + "." + fileType }).catch((err) => {
+            console.error("error uploading font: ", fontObject.title);
+            setStatus("error uploading font " + err.message);
+          });
+          newFileInput[fileType] = {
+            _type: "file",
+            asset: {
+              _ref: baseAsset._id,
+              _type: "reference"
+            }
+          };
+          console.log("newFileInput", newFileInput);
+          if (file.name.endsWith(".woff2")) {
+            console.log("generating css file for: ", fontObject.title);
+            setStatus("generating css file for: " + fontObject.title);
+            newFileInput = await generateCssFile({
+              woff2File: file,
+              fileInput: newFileInput,
+              // script: script,
+              fontName: fontTitle,
+              fileName: filename,
+              variableFont: fontObject.variableFont,
+              weight: fontObject.weight,
+              client
+            });
+          }
+          fontObject.scriptFileInput[script] = newFileInput;
+          fontsObjects[id] = fontObject;
+        }
+      }
+      console.log("creating sanity fonts", fontsObjects);
+      for (var i = 0; i < Object.keys(fontsObjects).length; i++) {
+        let fontId = Object.keys(fontsObjects)[i];
+        let font = fontsObjects[fontId];
+        let existingFont = await client.fetch(
+          `*[_type == 'font' && _id == $fontId]{
+						fileInput,
+						description,
+						metaData,
+						metrics,
+						opentypeFeatures,
+						characterSet,
+						subfamily,
+						scriptFileInput,
+					}`,
+          { fontId: font._id }
+        );
+        existingFont = existingFont[0];
+        let fontResponse;
+        let files = font.files;
+        let fontKit = font.fontKit;
+        delete font.files;
+        delete font.fontKit;
+        console.log("creating font : ", font);
+        try {
+          if (existingFont && existingFont != null) {
+            if (existingFont.scriptFileInput && existingFont.scriptFileInput != null) {
+              let newFileInput = { ...font.scriptFileInput };
+              Object.keys(existingFont.scriptFileInput).forEach((key) => {
+                if (!newFileInput[key]) {
+                  newFileInput[key] = existingFont.scriptFileInput[key];
+                }
+              });
+              font.scriptFileInput = newFileInput;
+            }
+            fontResponse = await client.patch(font._id).set({ scriptFileInput: font.scriptFileInput }).commit();
+          } else {
+            fontResponse = await client.createOrReplace({
+              _key: nanoid7(),
+              _id: font._id,
+              _type: "font",
+              ...font
+            });
+          }
+        } catch (e) {
+          console.error("error creating font: ", font.title, font.subfamily);
+          failedFiles = [...failedFiles, ...files.map((file) => {
+            return { name: file.name, fk: fontKit };
+          })];
+          continue;
+        }
+        const fontRef = { _key: nanoid7(), _type: "reference", _ref: fontResponse._id, _weak: true };
+        console.log("font response : ", fontResponse);
+        console.log("existing styles object : ", stylesObject);
+        if (!font.variableFont) {
+          if (stylesObject.fonts && stylesObject.fonts.length > 0) {
+            let fontExists = stylesObject.fonts.findIndex((font2) => font2._ref == fontResponse._id);
+            let inFontRefs = fontRefs.findIndex((font2) => font2._ref == fontResponse._id);
+            if (fontExists == -1 && inFontRefs == -1) {
+              fontRefs.push(fontRef);
+            }
+          } else {
+            fontRefs.push(fontRef);
+          }
+        }
+        if (font.variableFont) {
+          if (stylesObject.variableFont && stylesObject.variableFont.length > 0) {
+            let vfExists = stylesObject.variableFont.findIndex((font2) => font2._ref == fontResponse._id);
+            let inVariableRefs = variableRefs.findIndex((font2) => font2._ref == fontResponse._id);
+            if (vfExists == -1 && inVariableRefs == -1 && font.variableFont) {
+              variableRefs.push(fontRef);
+            }
+          } else {
+            variableRefs.push(fontRef);
+          }
+        }
+        console.log(fontResponse._id, " created!");
+      }
+      console.log("updating styles refs (fonts, variable fonts, subfamilies) ", fontRefs, variableRefs, subfamilies, uniqueSubfamiles);
+      setStatus("Updating font references...");
+      let newStylesObject = stylesObject.fonts ? { ...stylesObject, fonts: [...stylesObject.fonts, ...fontRefs] } : { ...stylesObject, fonts: [...fontRefs] };
+      if (uniqueSubfamiles.length > 1) {
+        newStylesObject.subfamilies = uniqueSubfamiles;
+      } else {
+        newStylesObject.subfamilies = [];
+      }
+      newStylesObject.variableFont = (stylesObject == null ? void 0 : stylesObject.variableFont) ? [...stylesObject == null ? void 0 : stylesObject.variableFont, ...variableRefs] : [...variableRefs];
+      let patch = { styles: newStylesObject };
+      subfamiliesArray = subfamiliesArray ? subfamiliesArray : [];
+      console.log("new styles obj : ", newStylesObject);
+      console.log("existing subfamily list : ", subfamiliesArray);
+      console.log("unique subfamilies ", uniqueSubfamiles);
+      subfamiliesArray = [...subfamiliesArray, ...uniqueSubfamiles].filter((sf, index, self) => {
+        return self.indexOf(sf) === index;
+      });
+      patch.styles.subfamilies = subfamiliesArray;
+      console.log("doc_id : ", doc_id);
+      console.log("typeface patch : ", patch);
+      let includedScripts = [script, ...scripts].filter((lang, index, self) => {
+        return self.indexOf(lang) === index;
+      });
+      patch.scripts = includedScripts;
+      console.log("included scripts : ", includedScripts);
+      if (doc_id.startsWith("drafts.")) {
+        await client.patch(doc_id).set(patch).commit().catch((err) => {
+          console.error("error patching styles: ", err.message);
+          setStatus("error patching styles " + err.message);
+        });
+        doc_id = doc_id.replace("drafts.", "");
+      }
+      await client.patch(doc_id).set(patch).commit().catch((err) => {
+        console.error("error patching styles: ", err.message);
+        setStatus("error patching styles");
+      });
+      console.log("success");
+      if (failedFiles.length > 0) {
+        console.log("failed files : ", failedFiles);
+        const names = failedFiles.map((file) => file.name);
+        console.log("names : ", failedFiles.map((file) => {
+          var _a2, _b2;
+          return (_b2 = (_a2 = file == null ? void 0 : file.fk) == null ? void 0 : _a2.name) == null ? void 0 : _b2.records;
+        }));
+        setStatus("fonts uploaded with errors. Failed files : " + names.join(", "));
+      } else {
+        setStatus("fonts uploaded!");
+      }
+      setStatus("fonts uploaded!");
+    } catch (e) {
+      console.error(e);
+      setStatus("error uploading font " + e.message);
+    }
+    setReady(true);
+  }, [title, slug, doc_id]);
+  return /* @__PURE__ */ React9.createElement(Stack6, null, !ready && /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement("br", null), status, /* @__PURE__ */ React9.createElement("br", null), /* @__PURE__ */ React9.createElement("br", null)), ready && /* @__PURE__ */ React9.createElement(Stack6, null, /* @__PURE__ */ React9.createElement(Grid4, { columns: !!(selectedScript && selectedScript !== "") ? 2 : 1, gap: 2 }, /* @__PURE__ */ React9.createElement(
+    Select,
+    {
+      id: "menu-button-example",
+      onChange: (e) => setSelectedScript(e.target.value)
+    },
+    /* @__PURE__ */ React9.createElement("option", { key: "script-none", value: "" }, " "),
+    SCRIPTS.map(
+      (script, i) => {
+        var _a;
+        return /* @__PURE__ */ React9.createElement("option", { key: "script-" + i, value: script }, ((_a = script[0]) == null ? void 0 : _a.toUpperCase()) + script.slice(1));
+      }
+    )
+  ), !!(selectedScript && selectedScript !== "") && /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement("label", { htmlFor: "upload-scripts-file" }, /* @__PURE__ */ React9.createElement(
+    Button6,
+    {
+      style: { pointerEvents: "none" },
+      text: "Upload (ttf/otf/woff/woff2/etc..)"
+    }
+  )), /* @__PURE__ */ React9.createElement(
+    "input",
+    {
+      ref,
+      name: "upload-scripts-file",
+      id: "upload-scripts-file",
+      type: "file",
+      multiple: true,
+      hidden: true,
+      onChange: (event) => handleUpload(event, selectedScript)
+    }
+  )))));
+};
+
+// src/components/FontScriptUploaderComponent.jsx
+import React10, { useState as useState7, useEffect as useEffect5, useCallback as useCallback6 } from "react";
+import { Stack as Stack7, Flex as Flex7, Text as Text9, Button as Button7 } from "@sanity/ui";
+import { useFormValue as useFormValue7, set as set3, unset as unset2 } from "sanity";
+var FontScriptUploaderComponent = (props) => {
+  const client = useSanityClient();
+  const {
+    elementProps: { ref },
+    onChange,
+    value = ""
+  } = props;
+  const [expanded, setExpanded] = useState7(SCRIPTS.reduce((acc, language) => ({ ...acc, [language]: true }), {}));
+  const [message, setMessage] = useState7({});
+  const [status, setStatus] = useState7("ready");
+  const [filenames, setFilenames] = useState7({});
+  let scriptFileInput = useFormValue7(["scriptFileInput"]) || [];
+  let fileInput = useFormValue7(["fileInput"]);
+  let doc_id = useFormValue7(["_id"]);
+  let doc_title = useFormValue7(["title"]);
+  let doc_variableFont = useFormValue7(["variableFont"]);
+  let doc_weight = useFormValue7(["weight"]);
+  let doc_style = useFormValue7(["style"]);
+  let doc_slug = useFormValue7(["slug"]);
+  useEffect5(() => {
+    if (!scriptFileInput || Object.keys(scriptFileInput).length === 0) return;
+    handleSetFilenames();
+  }, [scriptFileInput]);
+  const handleSetFilenames = useCallback6(async () => {
+    console.log("Set font names ", scriptFileInput);
+    let allIds = [];
+    const assetIds = SCRIPTS.reduce((acc, language) => {
+      if (scriptFileInput[language]) {
+        let newFileInput = Object.keys(scriptFileInput[language]).reduce((ftacc, filetype) => {
+          var _a, _b, _c, _d, _e, _f;
+          if (!((_b = (_a = scriptFileInput[language][filetype]) == null ? void 0 : _a.asset) == null ? void 0 : _b._ref)) return ftacc;
+          allIds.push((_d = (_c = scriptFileInput[language][filetype]) == null ? void 0 : _c.asset) == null ? void 0 : _d._ref);
+          return { ...ftacc, [filetype]: (_f = (_e = scriptFileInput[language][filetype]) == null ? void 0 : _e.asset) == null ? void 0 : _f._ref };
+        }, {});
+        acc[language] = newFileInput;
+      }
+      return acc;
+    }, {});
+    let assetData = await client.fetch(`*[_id in $allIds] {
+			_id,
+			originalFilename
+		}`, { allIds });
+    assetData = assetData.reduce((acc, asset) => {
+      let ref2 = asset._id;
+      return { ...acc, [ref2]: asset.originalFilename };
+    }, {});
+    let fontNames = {};
+    SCRIPTS.forEach((language) => {
+      if (assetIds[language]) {
+        Object.keys(assetIds[language]).forEach((filetype) => {
+          let ref2 = assetIds[language][filetype];
+          fontNames[language] = { ...fontNames[language], [filetype]: assetData[ref2] };
+        });
+      }
+    });
+    setFilenames(fontNames);
+  }, [scriptFileInput]);
+  const handleGenerateCssFile = useCallback6(async (language) => {
+    var _a, _b, _c;
+    setMessage({ ...message, [language]: "Generating css: " + doc_title + ".css" });
+    const woff2AssetRef = (_c = (_b = (_a = scriptFileInput[language]) == null ? void 0 : _a.woff2) == null ? void 0 : _b.asset) == null ? void 0 : _c._ref;
+    let [woff2Buffer] = await client.fetch(
+      `*[_id == $id]{ originalFilename, url }`,
+      { id: woff2AssetRef }
+    );
+    let blob = await fetch(woff2Buffer.url);
+    blob = await blob.blob();
+    let newFileInput = await generateCssFile({
+      woff2File: blob,
+      fileInput: scriptFileInput,
+      language,
+      fontName: doc_title,
+      fileName: woff2Buffer.originalFilename.replace(".woff2", ""),
+      variableFont: doc_variableFont,
+      weight: doc_weight,
+      style: doc_style,
+      client
+    });
+    setMessage({ ...message, [language]: "CSS generated!" });
+    setTimeout(() => {
+      setMessage({});
+    }, 2e3);
+    onChange(set3(newFileInput));
+  }, [scriptFileInput, onChange, doc_title, doc_variableFont]);
+  const handleGenerateFontFile = useCallback6(async (code, sourceFile, language) => {
+    var _a;
+    setMessage({ ...message, [language]: "Generating files: ", code });
+    let url = `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_a = sourceFile == null ? void 0 : sourceFile.asset) == null ? void 0 : _a._ref.replace("file-", "").replace("-", ".")}`;
+    console.log("Handle generate font file ", code, sourceFile, url);
+    if (code === "all") {
+      await generateFontFile({
+        codes: ["otf", "woff", "woff2", "eot", "svg"],
+        language,
+        srcUrl: url,
+        filename: doc_slug.current + "-" + language,
+        documentId: doc_id,
+        documentTitle: doc_title,
+        documentVariableFont: doc_variableFont,
+        documentStyle: doc_style,
+        documentWeight: doc_weight,
+        fileInput: scriptFileInput
+      });
+    } else {
+      await generateFontFile({
+        codes: [code],
+        language,
+        srcUrl: url,
+        filename: doc_slug.current + "-" + language,
+        documentId: doc_id,
+        documentTitle: doc_title,
+        documentVariableFont: doc_variableFont,
+        documentStyle: doc_style,
+        documentWeight: doc_weight,
+        fileInput: scriptFileInput
+      });
+    }
+    setMessage({ ...message, [language]: "Files generated!" });
+    setTimeout(() => {
+      setMessage({});
+    }, 2e3);
+  }, []);
+  const handleUpload = useCallback6(async (event, language, code) => {
+    console.log("Handle upload ", scriptFileInput, language, code);
+    let file = event.target.files[0];
+    let filename = doc_slug.current + "-" + language + "." + file.name.split(".").pop();
+    setMessage({ ...message, [language]: "Uploading: " + filename });
+    var asset = await client.assets.upload("file", file, { filename });
+    let langObj = scriptFileInput[language] ? { ...scriptFileInput[language] } : {};
+    let newFileInput = {
+      ...scriptFileInput,
+      [language]: {
+        ...langObj,
+        [code]: {
+          _type: "file",
+          asset: {
+            _ref: asset._id,
+            _type: "reference"
+          }
+        }
+      }
+    };
+    let id = doc_id;
+    if (id.startsWith("drafts.")) {
+      id = id.replace("drafts.", "");
+    }
+    setMessage({ ...message, [language]: filename + " uploaded!" });
+    setTimeout(() => {
+      setMessage({});
+    }, 2e3);
+    if (code === "woff2") {
+      console.log("woff2");
+      setMessage({ ...message, [language]: "Generating Css: " + doc_title + ".css" });
+      newFileInput = await generateCssFile({
+        woff2File: file,
+        fileInput: newFileInput,
+        language,
+        fontName: doc_title + "-" + language,
+        fileName: filename.replace(".woff2", ""),
+        variableFont: doc_variableFont,
+        weight: doc_weight,
+        style: doc_style,
+        client
+      });
+      setMessage({ ...message, [language]: "" + doc_title + ".css generated!" });
+    }
+    onChange(set3(newFileInput));
+  }, [scriptFileInput, onChange, doc_title, doc_variableFont, doc_slug]);
+  const handleDelete = useCallback6(async (code, language) => {
+    var _a, _b;
+    console.log("Delete : ", code, language);
+    setMessage({ ...message, [language]: `deleting ${language} ${code}` });
+    const asset = (_b = (_a = scriptFileInput[language][code]) == null ? void 0 : _a.asset) == null ? void 0 : _b._ref;
+    let newFileInput = { ...scriptFileInput };
+    delete newFileInput[language][code];
+    onChange(unset2([language, code]));
+    await client.delete(asset).then((result) => {
+      setMessage({ ...message, [language]: "deleted asset: ", result });
+      setTimeout(() => {
+        setMessage({});
+      }, 2e3);
+    }).catch((e) => {
+      console.error("Error deleting asset: ", e.message);
+      setMessage({ ...message, [language]: "WARNING: " + e.message });
+    });
+  }, [doc_id, scriptFileInput, onChange]);
+  const handleDeleteAll = useCallback6(async (language) => {
+    var _a, _b;
+    setMessage({ ...message, [language]: "deleting..." });
+    onChange(unset2([language]));
+    console.log("Delete all : ", scriptFileInput[language]);
+    for (var i = 0; i < Object.keys(scriptFileInput[language]).length; i++) {
+      let refKey = Object.keys(scriptFileInput[language])[i];
+      if (refKey == "documentInfo") return;
+      const asset = (_b = (_a = scriptFileInput[language][refKey]) == null ? void 0 : _a.asset) == null ? void 0 : _b._ref;
+      try {
+        await client.delete(asset).then((result) => {
+          setMessage({ ...message, [language]: "deleted asset: ", result });
+          setTimeout(() => {
+            setMessage({});
+          }, 2e3);
+        });
+      } catch (e) {
+        console.error("Error deleting asset: ", e.message);
+      }
+    }
+  }, [scriptFileInput]);
+  return /* @__PURE__ */ React10.createElement(Stack7, { space: 4 }, SCRIPTS && scriptFileInput && SCRIPTS.map((language, i) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa, _ta, _ua, _va, _wa, _xa, _ya, _za, _Aa, _Ba, _Ca, _Da, _Ea, _Fa, _Ga;
+    return /* @__PURE__ */ React10.createElement(Stack7, { space: 2, key: "language-" + i, style: { borderBottom: "1px solid var(--card-border-color)", paddingBottom: 8 } }, /* @__PURE__ */ React10.createElement(Flex7, { gap: 2 }, /* @__PURE__ */ React10.createElement(Text9, { weight: "semibold" }, ((_a = language[0]) == null ? void 0 : _a.toUpperCase()) + language.slice(1)), message && message[language] && message[language] !== "" && /* @__PURE__ */ React10.createElement(Text9, { style: { color: "green" } }, message[language])), expanded[language] && /* @__PURE__ */ React10.createElement(Stack7, { space: 2 }, /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "TTF:\xA0", !((_d = (_c = (_b = scriptFileInput[language]) == null ? void 0 : _b.ttf) == null ? void 0 : _c.asset) == null ? void 0 : _d._ref) ? ((_e = filenames[language]) == null ? void 0 : _e.ttf) ? /* @__PURE__ */ React10.createElement("b", null, filenames[language].ttf) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_h = (_g = (_f = scriptFileInput[language]) == null ? void 0 : _f.ttf) == null ? void 0 : _g.asset) == null ? void 0 : _h._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_i = filenames[language]) == null ? void 0 : _i.ttf) ? /* @__PURE__ */ React10.createElement("b", null, filenames[language].ttf) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: (event) => handleUpload(event, language, "ttf") })), ((_j = value[language]) == null ? void 0 : _j.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("ttf", language) }, "\xD7"))), status === "ready" && ((_k = value[language]) == null ? void 0 : _k.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("all", value[language].ttf, language) }, "Regenerate Files from TTF"), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "OTF:\xA0", !((_n = (_m = (_l = scriptFileInput[language]) == null ? void 0 : _l.otf) == null ? void 0 : _m.asset) == null ? void 0 : _n._ref) ? ((_o = filenames[language]) == null ? void 0 : _o.otf) ? /* @__PURE__ */ React10.createElement("b", null, (_p = filenames[language]) == null ? void 0 : _p.otf) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_s = (_r = (_q = scriptFileInput[language]) == null ? void 0 : _q.otf) == null ? void 0 : _r.asset) == null ? void 0 : _s._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_t = filenames[language]) == null ? void 0 : _t.otf) ? /* @__PURE__ */ React10.createElement("b", null, (_u = filenames[language]) == null ? void 0 : _u.otf) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_v = value[language]) == null ? void 0 : _v.woff) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("otf", value[language].woff, language) }, "Build"), /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: async (event) => handleUpload(event, language, "otf") })), ((_w = value[language]) == null ? void 0 : _w.otf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("otf", language) }, "\xD7"))), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "WOFF:\xA0", !((_z = (_y = (_x = scriptFileInput[language]) == null ? void 0 : _x.woff) == null ? void 0 : _y.asset) == null ? void 0 : _z._ref) ? ((_A = filenames[language]) == null ? void 0 : _A.woff) ? /* @__PURE__ */ React10.createElement("b", null, (_B = filenames[language]) == null ? void 0 : _B.woff) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_E = (_D = (_C = scriptFileInput[language]) == null ? void 0 : _C.woff) == null ? void 0 : _D.asset) == null ? void 0 : _E._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_F = filenames[language]) == null ? void 0 : _F.woff) ? /* @__PURE__ */ React10.createElement("b", null, (_G = filenames[language]) == null ? void 0 : _G.woff) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_H = value[language]) == null ? void 0 : _H.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("woff", value[language].ttf, language) }, "Build"), /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: async (event) => handleUpload(event, language, "woff") })), ((_I = value[language]) == null ? void 0 : _I.woff) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("woff", language) }, "\xD7"))), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "WOFF2:\xA0", !((_L = (_K = (_J = scriptFileInput[language]) == null ? void 0 : _J.woff2) == null ? void 0 : _K.asset) == null ? void 0 : _L._ref) ? ((_M = filenames[language]) == null ? void 0 : _M.woff2) ? /* @__PURE__ */ React10.createElement("b", null, (_N = filenames[language]) == null ? void 0 : _N.woff2) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_Q = (_P = (_O = scriptFileInput[language]) == null ? void 0 : _O.woff2) == null ? void 0 : _P.asset) == null ? void 0 : _Q._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_R = filenames[language]) == null ? void 0 : _R.woff2) ? /* @__PURE__ */ React10.createElement("b", null, (_S = filenames[language]) == null ? void 0 : _S.woff2) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_T = value[language]) == null ? void 0 : _T.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("woff2", value[language].ttf, language) }, "Build"), /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: async (event) => handleUpload(event, language, "woff2") })), ((_U = value[language]) == null ? void 0 : _U.woff2) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("woff2", language) }, "\xD7"))), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "EOT:\xA0", !((_X = (_W = (_V = scriptFileInput[language]) == null ? void 0 : _V.eot) == null ? void 0 : _W.asset) == null ? void 0 : _X._ref) ? ((_Y = filenames[language]) == null ? void 0 : _Y.eot) ? /* @__PURE__ */ React10.createElement("b", null, (_Z = filenames[language]) == null ? void 0 : _Z.eot) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_aa = (_$ = (__ = scriptFileInput[language]) == null ? void 0 : __.eot) == null ? void 0 : _$.asset) == null ? void 0 : _aa._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_ba = filenames[language]) == null ? void 0 : _ba.eot) ? /* @__PURE__ */ React10.createElement("b", null, (_ca = filenames[language]) == null ? void 0 : _ca.eot) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_da = value[language]) == null ? void 0 : _da.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("eot", value[language].ttf, language) }, "Build"), /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: async (event) => handleUpload(event, language, "eot") })), ((_ea = value[language]) == null ? void 0 : _ea.eot) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("eot", language) }, "\xD7"))), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "SVG:\xA0", !((_ha = (_ga = (_fa = scriptFileInput[language]) == null ? void 0 : _fa.svg) == null ? void 0 : _ga.asset) == null ? void 0 : _ha._ref) ? ((_ia = filenames[language]) == null ? void 0 : _ia.svg) ? /* @__PURE__ */ React10.createElement("b", null, (_ja = filenames[language]) == null ? void 0 : _ja.svg) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_ma = (_la = (_ka = scriptFileInput[language]) == null ? void 0 : _ka.svg) == null ? void 0 : _la.asset) == null ? void 0 : _ma._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_na = filenames[language]) == null ? void 0 : _na.svg) ? /* @__PURE__ */ React10.createElement("b", null, (_oa = filenames[language]) == null ? void 0 : _oa.svg) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_pa = value[language]) == null ? void 0 : _pa.ttf) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateFontFile("svg", value[language].ttf, language) }, "Build"), /* @__PURE__ */ React10.createElement("label", null, /* @__PURE__ */ React10.createElement(Button7, { as: "span", mode: "ghost" }, "Upload"), /* @__PURE__ */ React10.createElement("input", { ref, type: "file", style: { display: "none" }, onChange: async (event) => handleUpload(event, language, "svg") })), ((_qa = value[language]) == null ? void 0 : _qa.svg) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("svg", language) }, "\xD7"))), /* @__PURE__ */ React10.createElement(Flex7, { justify: "space-between", align: "center" }, /* @__PURE__ */ React10.createElement(Text9, null, "CSS:\xA0", !((_ta = (_sa = (_ra = scriptFileInput[language]) == null ? void 0 : _ra.css) == null ? void 0 : _sa.asset) == null ? void 0 : _ta._ref) ? ((_ua = filenames[language]) == null ? void 0 : _ua.css) ? /* @__PURE__ */ React10.createElement("b", null, (_va = filenames[language]) == null ? void 0 : _va.css) : /* @__PURE__ */ React10.createElement("b", null, "Empty") : /* @__PURE__ */ React10.createElement("a", { href: `https://cdn.sanity.io/files/${process.env.SANITY_STUDIO_PROJECT_ID}/${process.env.SANITY_STUDIO_DATASET}/${(_ya = (_xa = (_wa = scriptFileInput[language]) == null ? void 0 : _wa.css) == null ? void 0 : _xa.asset) == null ? void 0 : _ya._ref.replace("file-", "").replace("-", ".")}`, target: "_blank" }, ((_za = filenames[language]) == null ? void 0 : _za.css) ? /* @__PURE__ */ React10.createElement("b", null, (_Aa = filenames[language]) == null ? void 0 : _Aa.css) : /* @__PURE__ */ React10.createElement("b", null, "File"))), status === "ready" && /* @__PURE__ */ React10.createElement(Flex7, { gap: 1 }, ((_Ba = value[language]) == null ? void 0 : _Ba.woff2) && /* @__PURE__ */ React10.createElement(Button7, { mode: "default", onClick: () => handleGenerateCssFile(language) }, "Build"), ((_Ca = value[language]) == null ? void 0 : _Ca.css) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDelete("css", language) }, "\xD7"))), status === "ready" && (((_Da = value[language]) == null ? void 0 : _Da.ttf) || ((_Ea = value[language]) == null ? void 0 : _Ea.otf) || ((_Fa = value[language]) == null ? void 0 : _Fa.woff) || ((_Ga = value[language]) == null ? void 0 : _Ga.woff2)) && /* @__PURE__ */ React10.createElement(Button7, { mode: "ghost", tone: "critical", onClick: () => handleDeleteAll(language), style: { width: "100%" } }, "Delete All")));
+  }));
+};
+
+// src/components/UploadButton.jsx
+import React11, { forwardRef } from "react";
+import { Button as Button8, Text as Text10 } from "@sanity/ui";
+var UploadButton = forwardRef(({ handleUpload }, ref) => {
+  return /* @__PURE__ */ React11.createElement(
+    Button8,
+    {
+      mode: "ghost",
+      tone: "primary",
+      width: "fill",
+      padding: 3,
+      style: { position: "relative" }
+    },
+    /* @__PURE__ */ React11.createElement(Text10, { align: "center" }, "Upload (ttf/otf/woff/woff2/etc...)"),
+    /* @__PURE__ */ React11.createElement(
+      "input",
+      {
+        ref,
+        type: "file",
+        multiple: true,
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          width: "100%",
+          height: "100%",
+          opacity: 0,
+          cursor: "pointer"
+        },
+        onChange: handleUpload
+      }
+    )
+  );
+});
+UploadButton.displayName = "UploadButton";
+var UploadButton_default = UploadButton;
+
+// src/utils/getEmptyFontKit.js
+import * as fontkit7 from "fontkit";
+import slugify4 from "slugify";
+async function getEmptyFontKit({ title, files, weightKeywordList, italicKeywordList }) {
+  var _a, _b, _c, _d, _e, _f;
+  let fontNames = {};
+  let subfamilies = {};
+  for (var i = 0; i < files.length; i++) {
+    const file = files[i];
+    const fontBuffer = await readFontFile2(file);
+    const font = fontkit7.create(fontBuffer);
+    let weightName = ((_b = (_a = font == null ? void 0 : font.name) == null ? void 0 : _a.records) == null ? void 0 : _b.preferredSubfamily) ? (_d = (_c = font == null ? void 0 : font.name) == null ? void 0 : _c.records) == null ? void 0 : _d.preferredSubfamily : (_f = (_e = font == null ? void 0 : font.name) == null ? void 0 : _e.records) == null ? void 0 : _f.fontSubfamily;
+    weightName = (weightName == null ? void 0 : weightName.en) ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
+    let variableFont = (font == null ? void 0 : font.variationAxes) && Object.keys(font.variationAxes).length > 0 ? true : false;
+    let subfamilyName = font.familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), "").trim();
+    let fontTitle = font == null ? void 0 : 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 = slugify4(fontTitle.toLowerCase().trim());
+    if (variableFont && !id.endsWith("-vf")) {
+      id = id + "-vf";
+      fontTitle = fontTitle + " VF";
+    }
+    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);
+}
+var readFontFile2 = (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);
+  });
+};
+export {
+  BatchUploadFonts,
+  FontScriptUploaderComponent,
+  GenerateCollectionsPairsComponent,
+  HtmlDescription,
+  PriceInput_default as PriceInput,
+  RegenerateSubfamiliesComponent,
+  SCRIPTS,
+  SCRIPTS_OBJECT,
+  SingleUploaderTool,
+  StatusDisplay_default as StatusDisplay,
+  UpdateScriptsComponent,
+  UploadButton_default as UploadButton,
+  UploadScriptsComponent,
+  addItalicToFontTitle,
+  createFontObject,
+  determineWeight,
+  expandAbbreviations,
+  extractFontMetadata,
+  extractWeightFromFullName,
+  extractWeightName,
+  formatFontTitle,
+  generateCssFile,
+  generateFontData,
+  generateFontFile,
+  generateStyleKeywords,
+  generateSubset,
+  getEmptyFontKit,
+  logFontInfo,
+  parseVariableFontInstances_default as parseVariableFontInstances,
+  processFontFiles,
+  processItalicKeywords,
+  processSubfamilyName,
+  readFontFile,
+  removeWeightNames,
+  renameFontDocuments,
+  reverseSpellingLookup,
+  sanitizeForSanityId,
+  sortFontObjects,
+  updateFontPrices,
+  updateTypefaceDocument,
+  uploadFontFiles,
+  useSanityClient
+};