@edrlab/thorium-web 1.1.2 → 1.1.4

package/dist/{chunk-IRA4ZKAX.mjs → chunk-VN44OJDD.mjs}

@@ -126,8 +126,307 @@ var createPreferences = (params) => {
       }
     }
   }
+  if (params.settings?.keys?.fontFamily) {
+    const fontFamilyPref = params.settings.keys.fontFamily;
+    const languageMap = /* @__PURE__ */ new Map();
+    Object.entries(fontFamilyPref).forEach(([collectionName, collectionData]) => {
+      if (collectionName === "default") return;
+      const supportedLangs = "supportedLanguages" in collectionData ? collectionData.supportedLanguages : null;
+      if (supportedLangs && Array.isArray(supportedLangs)) {
+        supportedLangs.forEach((lang) => {
+          if (!languageMap.has(lang)) {
+            languageMap.set(lang, []);
+          }
+          languageMap.get(lang).push(collectionName);
+        });
+      }
+    });
+    languageMap.forEach((collections, language) => {
+      if (collections.length > 1) {
+        console.warn(`Language "${language}" is supported by multiple font collections: ${collections.join(", ")}. This may cause ambiguous font selection. Consider consolidating to a single collection per language.`);
+      }
+    });
+  }
   return params;
 };
+
+// src/preferences/helpers/buildThemeObject.ts
+var buildThemeObject = ({
+  theme,
+  themeKeys,
+  systemThemes,
+  colorScheme
+}) => {
+  if (!theme) {
+    return {};
+  }
+  if (theme === "auto" && colorScheme && systemThemes) {
+    theme = colorScheme === "dark" /* dark */ ? systemThemes.dark : systemThemes.light;
+  }
+  let themeProps = {};
+  const themeToken = themeKeys[theme];
+  if (themeToken) {
+    themeProps = {
+      backgroundColor: themeToken.background,
+      textColor: themeToken.text,
+      linkColor: themeToken.link,
+      selectionBackgroundColor: themeToken.select,
+      selectionTextColor: themeToken.onSelect,
+      visitedColor: themeToken.visited
+    };
+  } else {
+    console.warn(`Theme key "${String(theme)}" not found in themeKeys.`);
+    themeProps = {
+      backgroundColor: null,
+      textColor: null,
+      linkColor: null,
+      selectionBackgroundColor: null,
+      selectionTextColor: null,
+      visitedColor: null
+    };
+  }
+  return themeProps;
+};
+
+// src/preferences/helpers/fontPref/bunnyFonts.ts
+var DEFAULT_FALLBACK = "sans-serif";
+var createDefinitionsFromBunnyFonts = (params) => {
+  const { cssUrl, options } = params;
+  const { fallbacks, order, labels } = options || {};
+  const processedUrl = cssUrl.includes("@import") ? cssUrl.match(/@import\s+url\(['"]?([^'")]+)['"]?\)/i)?.[1] || cssUrl : cssUrl.includes("href=") ? cssUrl.match(/href=["']([^"']+)["']/)?.[1] || cssUrl : cssUrl;
+  const url = new URL(processedUrl);
+  if (!url.hostname.includes("fonts.bunny.net")) {
+    throw new Error("Invalid Bunny Fonts URL");
+  }
+  const familyParam = url.searchParams.get("family");
+  if (!familyParam) {
+    throw new Error("No family parameter found in Bunny Fonts URL");
+  }
+  const fontEntries = familyParam.split("|").map((familyStr) => {
+    const [familyName, weightsStr = ""] = familyStr.split(":");
+    if (!familyName) {
+      throw new Error(`Invalid font family format: ${familyStr}`);
+    }
+    const weightStyles = /* @__PURE__ */ new Map();
+    if (weightsStr) {
+      weightsStr.split(",").forEach((weightStr) => {
+        const isItalic = weightStr.endsWith("i");
+        const weightValue = parseInt(isItalic ? weightStr.slice(0, -1) : weightStr, 10);
+        if (!isNaN(weightValue)) {
+          if (!weightStyles.has(weightValue)) {
+            weightStyles.set(weightValue, /* @__PURE__ */ new Set());
+          }
+          weightStyles.get(weightValue)?.add(isItalic ? "italic" : "normal");
+        }
+      });
+    }
+    const weights = Array.from(weightStyles.keys()).sort((a, b) => a - b);
+    const hasItalic = Array.from(weightStyles.values()).some((styles2) => styles2.has("italic"));
+    const styles = hasItalic ? ["normal", "italic"] : ["normal"];
+    const fontId = familyName;
+    const familyDisplayName = familyName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    return [
+      fontId,
+      {
+        id: fontId,
+        name: familyDisplayName,
+        ...labels?.[fontId] && { label: labels[fontId] },
+        source: {
+          type: "custom",
+          provider: "bunny"
+        },
+        spec: {
+          family: familyDisplayName,
+          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK],
+          weights: {
+            type: "static",
+            values: weights.length ? weights : [400]
+          },
+          styles
+        }
+      }
+    ];
+  });
+  const result = Object.fromEntries(fontEntries);
+  if (order && order.length > 0) {
+    const orderedResult = {};
+    order.forEach((fontId) => {
+      if (result[fontId]) {
+        orderedResult[fontId] = result[fontId];
+      }
+    });
+    Object.entries(result).forEach(([fontId, definition]) => {
+      if (!orderedResult[fontId]) {
+        orderedResult[fontId] = definition;
+      }
+    });
+    return orderedResult;
+  }
+  return result;
+};
+
+// src/preferences/helpers/fontPref/googleFonts.ts
+var DEFAULT_FALLBACK2 = "sans-serif";
+var DEFAULT_WIDTH_STEP = 20;
+var DEFAULT_WEIGHT_STEP = 20;
+var createDefinitionsFromGoogleFonts = (params) => {
+  const { cssUrl, options } = params;
+  const { widthStep = DEFAULT_WIDTH_STEP, weightStep = DEFAULT_WEIGHT_STEP, display, labels, fallbacks, order } = options || {};
+  const processedUrl = cssUrl.includes("@import") ? cssUrl.match(/@import\s+url\(['"]?([^'")]+)['"]?\)/i)?.[1] || cssUrl : cssUrl.includes("href=") ? cssUrl.match(/href=["']([^"']+)["']/)?.[1] || cssUrl : cssUrl;
+  const url = new URL(processedUrl);
+  if (!url.hostname.includes("fonts.googleapis.com")) {
+    throw new Error("Invalid Google Fonts URL");
+  }
+  const familyParams = url.searchParams.getAll("family");
+  if (familyParams.length === 0) {
+    throw new Error("No family parameter found in Google Fonts URL");
+  }
+  const families = familyParams.map((familyParam) => {
+    const decodedFamily = decodeURIComponent(familyParam);
+    const [familyName, axesStr] = decodedFamily.split(":");
+    if (!familyName) {
+      throw new Error(`Invalid family format: ${familyParam}`);
+    }
+    const family = {
+      name: familyName.replace(/\+/g, " "),
+      styles: ["normal"],
+      weights: { type: "static", values: [400] }
+      // Default weight
+    };
+    let hasExplicitWeights = false;
+    if (axesStr) {
+      const [axisNames, valuesStr] = axesStr.split("@");
+      if (axisNames && valuesStr) {
+        const axes = axisNames.split(",");
+        const variations = valuesStr.split(";");
+        variations.forEach((variation) => {
+          const values = variation.split(",");
+          axes.forEach((axis, index) => {
+            const value = values[index];
+            if (!value) return;
+            switch (axis) {
+              case "ital":
+                if (value === "1") {
+                  family.styles = Array.from(/* @__PURE__ */ new Set([...family.styles, "italic"]));
+                }
+                break;
+              case "wght":
+                if (value.includes("..")) {
+                  const [min, max] = value.split("..").map(Number);
+                  if (!isNaN(min) && !isNaN(max)) {
+                    family.weights = {
+                      type: "variable",
+                      min,
+                      max,
+                      step: weightStep
+                    };
+                  }
+                } else {
+                  const weight = Number(value);
+                  if (!isNaN(weight) && family.weights.type === "static") {
+                    const currentWeights = family.weights.values;
+                    const newWeights = !hasExplicitWeights ? [weight] : Array.from(/* @__PURE__ */ new Set([...currentWeights, weight])).sort((a, b) => a - b);
+                    family.weights = {
+                      type: "static",
+                      values: newWeights
+                    };
+                    hasExplicitWeights = true;
+                  }
+                }
+                break;
+              case "wdth":
+                if (value.includes("..")) {
+                  const [min, max] = value.split("..").map(Number);
+                  if (!isNaN(min) && !isNaN(max)) {
+                    family.widths = {
+                      min,
+                      max,
+                      step: widthStep
+                    };
+                  }
+                }
+                break;
+            }
+          });
+        });
+      }
+    }
+    return family;
+  });
+  const fontEntries = families.map((family) => {
+    const fontId = family.name.toLowerCase().replace(/\s+/g, "-");
+    return [
+      fontId,
+      {
+        id: fontId,
+        name: family.name,
+        ...labels?.[fontId] && { label: labels[fontId] },
+        source: { type: "custom", provider: "google" },
+        spec: {
+          family: family.name,
+          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK2],
+          weights: family.weights,
+          styles: family.styles,
+          ...family.widths && { widths: family.widths },
+          ...display && { display }
+        }
+      }
+    ];
+  });
+  if (order && order.length > 0) {
+    const orderedEntries = [];
+    const fontMap = new Map(fontEntries);
+    for (const fontId of order) {
+      const fontEntry = fontMap.get(fontId);
+      if (fontEntry) {
+        orderedEntries.push([fontId, fontEntry]);
+        fontMap.delete(fontId);
+      }
+    }
+    for (const [fontId, fontEntry] of fontMap.entries()) {
+      orderedEntries.push([fontId, fontEntry]);
+    }
+    return Object.fromEntries(orderedEntries);
+  }
+  return Object.fromEntries(fontEntries);
+};
+
+// src/preferences/helpers/fontPref/localFonts.ts
+var createDefinitionFromStaticFonts = (params) => {
+  const { id, name, files, family, label, fallbacks = ["sans-serif"] } = params;
+  if (!files || files.length === 0) {
+    throw new Error("No files provided to infer font specification");
+  }
+  if (!files.every((file) => file.weight !== void 0)) {
+    throw new Error("All files must have explicit weights for static font specification inference");
+  }
+  const weights = Array.from(new Set(files.map((file) => file.weight))).sort((a, b) => a - b);
+  const styles = Array.from(new Set(files.map((file) => file.style)));
+  const source = {
+    type: "custom",
+    provider: "local",
+    variant: "static",
+    files
+  };
+  const spec = {
+    family: family || name,
+    fallbacks,
+    weights: {
+      type: "static",
+      values: weights
+    },
+    styles
+  };
+  return {
+    id,
+    name,
+    ...label && { label },
+    source,
+    spec
+  };
+};
+
+// src/preferences/models/const.ts
 var defaultActionKeysObject = {
   visibility: "partially" /* partially */,
   shortcut: null
@@ -159,13 +458,134 @@ var defaultSpacingPresetsOrder = [
   "balanced" /* balanced */,
   "loose" /* loose */
 ];
-var defaultFontFamilyOptions = {
-  publisher: null,
-  oldStyle: fontStacks.RS__oldStyleTf,
-  modern: fontStacks.RS__modernTf,
-  sans: fontStacks.RS__sansTf,
-  humanist: fontStacks.RS__humanistTf,
-  monospace: fontStacks.RS__monospaceTf
+var readiumCSSFontCollection = {
+  oldStyle: {
+    id: "oldStyle",
+    name: "Old Style",
+    label: "reader.preferences.fontFamily.oldStyle.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__oldStyleTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  modern: {
+    id: "modern",
+    name: "Modern",
+    label: "reader.preferences.fontFamily.modern.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__modernTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  sans: {
+    id: "sans",
+    name: "Sans",
+    label: "reader.preferences.fontFamily.sans",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__sansTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  humanist: {
+    id: "humanist",
+    name: "Humanist",
+    label: "reader.preferences.fontFamily.humanist.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__humanistTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  monospace: {
+    id: "monospace",
+    name: "Monospace",
+    label: "reader.preferences.fontFamily.monospace",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__monospaceTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  }
+};
+var defaultFontCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Atkinson+Hyperlegible+Next:ital,wght@0,200..800;1,200..800&family=Literata:ital,opsz,wght@0,7..72,200..900;1,7..72,200..900",
+    options: {
+      order: ["literata", "atkinson-hyperlegible-next"],
+      fallbacks: {
+        "literata": ["serif"],
+        "atkinson-hyperlegible-next": ["sans-serif"]
+      }
+    }
+  }),
+  luciole: createDefinitionFromStaticFonts({
+    id: "luciole",
+    name: "Luciole",
+    files: [
+      { path: "/fonts/Luciole/Luciole-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/Luciole/Luciole-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/Luciole/Luciole-Bold.woff2", weight: 700, style: "normal" },
+      { path: "/fonts/Luciole/Luciole-BoldItalic.woff2", weight: 700, style: "italic" }
+    ]
+  }),
+  ...readiumCSSFontCollection,
+  iAWriterDuo: createDefinitionFromStaticFonts({
+    id: "iAWriterDuo",
+    name: "iA Writer Duo",
+    label: "iA Writer Duospace",
+    fallbacks: ["monospace"],
+    files: [
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Bold.woff2", weight: 700, style: "normal" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-BoldItalic.woff2", weight: 700, style: "italic" }
+    ]
+  }),
+  openDyslexic: createDefinitionFromStaticFonts({
+    id: "openDyslexic",
+    name: "Open Dyslexic",
+    files: [
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Regular.otf", weight: 400, style: "normal" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Italic.otf", weight: 400, style: "italic" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Bold.otf", weight: 700, style: "normal" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-BoldItalic.otf", weight: 700, style: "italic" }
+    ]
+  }),
+  accessibleDfA: createDefinitionFromStaticFonts({
+    id: "accessibleDfA",
+    name: "Accessible DfA",
+    files: [
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Bold.woff2", weight: 700, style: "normal" }
+    ]
+  })
+};
+var tamilCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Anek+Tamil:wght@100..800&family=Catamaran:wght@100..900&family=Hind+Madurai:wght@400;700&family=Mukta+Malar:wght@400;700&family=Noto+Sans+Tamil:wght@100..900&family=Noto+Serif+Tamil:ital,wght@0,100..900;1,100..900",
+    options: {
+      order: ["noto-sans-tamil", "noto-serif-tamil", "anek-tamil", "catamaran", "hind-madurai", "mukta-malar"],
+      labels: {
+        "noto-sans-tamil": "Noto Sans",
+        "noto-serif-tamil": "Noto Serif",
+        "anek-tamil": "\u0B85\u0BA9\u0BC7\u0B95\u0BCD \u0BA4\u0BAE\u0BBF\u0BB4\u0BCD",
+        "catamaran": "\u0B95\u0B9F\u0BCD\u0B9F\u0BC1\u0BAE\u0BB0\u0BA9\u0BCD",
+        "mukta-malar": "\u0BAE\u0BC1\u0B95\u0BCD\u0BA4 \u0BAE\u0BB2\u0BB0\u0BCD"
+      },
+      fallbacks: {
+        "noto-serif-tamil": ["serif"]
+      }
+    }
+  })
 };
 var defaultParagraphSpacing = {
   variant: "numberField" /* numberField */,
@@ -721,6 +1141,13 @@ var defaultPreferences = createPreferences({
       "spacingGroup" /* spacingGroup */
     ],
     keys: {
+      ["fontFamily" /* fontFamily */]: {
+        default: defaultFontCollection,
+        tamil: {
+          supportedLanguages: ["ta"],
+          fonts: tamilCollection
+        }
+      },
       ["letterSpacing" /* letterSpacing */]: defaultLetterSpacing,
       ["lineHeight" /* lineHeight */]: {
         allowUnset: false,
@@ -732,10 +1159,14 @@ var defaultPreferences = createPreferences({
       ["zoom" /* zoom */]: defaultZoom
     },
     text: {
-      header: "previous" /* previous */
+      header: "previous" /* previous */,
+      main: defaultTextSettingsMain,
+      subPanel: defaultTextSettingsSubpanel
     },
     spacing: {
       header: "previous" /* previous */,
+      main: defaultSpacingSettingsMain,
+      subPanel: defaultSpacingSettingsSubpanel,
       presets: {
         reflowOrder: defaultSpacingPresetsOrder,
         webPubOrder: defaultSpacingPresetsOrder,
@@ -820,51 +1251,396 @@ function ThPreferencesProvider({
   return /* @__PURE__ */ jsx(ThPreferencesContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(ThDirectionSetter, { direction: preferences.direction, children }) });
 }
 
-// src/preferences/helpers/buildThemeObject.ts
-var buildThemeObject = ({
-  theme,
-  themeKeys,
-  systemThemes,
-  colorScheme
+// src/preferences/services/createBunnyFontResources.ts
+var buildBunnyFontsUrl = ({
+  family,
+  weights,
+  styles = ["normal"]
 }) => {
-  if (!theme) {
-    return {};
+  if (weights.type !== "static") {
+    throw new Error("Bunny Fonts only supports static fonts");
   }
-  if (theme === "auto" && colorScheme && systemThemes) {
-    theme = colorScheme === "dark" /* dark */ ? systemThemes.dark : systemThemes.light;
+  const weightValues = weights.values;
+  const variants = /* @__PURE__ */ new Set();
+  for (const weight of weightValues) {
+    variants.add(weight.toString());
+    if (styles.includes("italic")) {
+      variants.add(`${weight}i`);
+    }
   }
-  let themeProps = {};
-  const themeToken = themeKeys[theme];
-  if (themeToken) {
-    themeProps = {
-      backgroundColor: themeToken.background,
-      textColor: themeToken.text,
-      linkColor: themeToken.link,
-      selectionBackgroundColor: themeToken.select,
-      selectionTextColor: themeToken.onSelect,
-      visitedColor: themeToken.visited
-    };
+  const variantList = Array.from(variants).sort();
+  const familyParam = family.replace(/ /g, "-").toLowerCase();
+  const variantParam = variantList.join(",");
+  return `https://fonts.bunny.net/css?family=${familyParam}:${variantParam}`;
+};
+var createBunnyFontResources = (font) => {
+  if (font.source.type !== "custom" || font.source.provider !== "bunny" || font.spec.weights.type !== "static") {
+    return null;
+  }
+  const { family, weights, styles } = font.spec;
+  const url = buildBunnyFontsUrl({
+    family,
+    weights,
+    styles
+  });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    url
+  };
+};
+
+// src/preferences/services/createGoogleFontResources.ts
+var buildGoogleFontsV2Url = ({
+  family,
+  weights,
+  styles = ["normal"],
+  widths,
+  display = "block",
+  text
+}) => {
+  if (text) {
+    return `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}&text=${encodeURIComponent(text)}`;
+  }
+  const hasItalic = styles.includes("italic");
+  const hasWidth = !!widths;
+  const weightValues = weights.type === "static" ? weights.values.join(",") : `${weights.min}..${weights.max}`;
+  const widthValues = hasWidth && widths ? `${widths.min}..${widths.max}` : void 0;
+  const familyParam = family.replace(/ /g, "+");
+  let axesParam;
+  if (hasItalic && hasWidth) {
+    const variants = [
+      `0,${widthValues},${weightValues}`,
+      // normal
+      `1,${widthValues},${weightValues}`
+      // italic
+    ];
+    axesParam = `:ital,wdth,wght@${variants.join(";")}`;
+  } else if (hasItalic) {
+    const variants = [
+      `0,${weightValues}`,
+      // normal
+      `1,${weightValues}`
+      // italic
+    ];
+    axesParam = `:ital,wght@${variants.join(";")}`;
+  } else if (hasWidth) {
+    axesParam = `:wdth,wght@${widthValues},${weightValues}`;
   } else {
-    console.warn(`Theme key "${String(theme)}" not found in themeKeys.`);
-    themeProps = {
-      backgroundColor: null,
-      textColor: null,
-      linkColor: null,
-      selectionBackgroundColor: null,
-      selectionTextColor: null,
-      visitedColor: null
-    };
+    axesParam = `:wght@${weightValues}`;
   }
-  return themeProps;
+  const displayParam = display ? `&display=${display}` : "";
+  return `https://fonts.googleapis.com/css2?family=${familyParam}${axesParam}${displayParam}`;
+};
+var createGoogleFontResources = (font, text) => {
+  if (font.source.type !== "custom" || font.source.provider !== "google") {
+    return null;
+  }
+  const { family, weights, display, styles, widths } = font.spec;
+  const url = buildGoogleFontsV2Url({
+    family,
+    weights,
+    display,
+    styles,
+    widths,
+    text
+  });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    url
+  };
 };
+
+// src/preferences/services/createLocalFontResources.ts
+var getFontFormat = (path) => {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "woff":
+      return "woff";
+    case "woff2":
+      return "woff2";
+    case "ttf":
+      return "truetype";
+    case "otf":
+      return "opentype";
+    case "eot":
+      return "embedded-opentype";
+    case "svg":
+      return "svg";
+    default:
+      return "woff2";
+  }
+};
+var createLocalFontResources = (font) => {
+  if (font.source.type !== "custom" || font.source.provider !== "local") {
+    return null;
+  }
+  const { family, weights, display, widths } = font.spec;
+  const fontFiles = font.source.files || [];
+  const cssContent = fontFiles.map((fontFile) => {
+    const format = getFontFormat(fontFile.path);
+    const fontUrl = new URL(fontFile.path, window.location.origin).toString();
+    const isVariable = font.source.type === "custom" && font.source.provider === "local" && "variant" in font.source && font.source.variant === "variable";
+    const rules = [
+      `@font-face {`,
+      `  font-family: "${family}";`,
+      `  src: url("${fontUrl}") format("${format}");`
+    ];
+    if (isVariable && weights.type === "variable") {
+      rules.push(`  font-weight: ${weights.min} ${weights.max};`);
+    } else if ("weight" in fontFile) {
+      rules.push(`  font-weight: ${fontFile.weight};`);
+    }
+    if ("style" in fontFile) {
+      rules.push(`  font-style: ${fontFile.style};`);
+    }
+    if (isVariable && widths) {
+      rules.push(`  font-stretch: ${widths.min}% ${widths.max}%;`);
+    }
+    if (display) {
+      rules.push(`  font-display: ${display};`);
+    } else {
+      rules.push(`  font-display: block;`);
+    }
+    return rules.join("\n") + "\n}";
+  }).filter(Boolean).join("\n\n");
+  const blob = new Blob([cssContent], { type: "text/css" });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    blob
+  };
+};
+
+// src/preferences/services/fonts.ts
+var createFontService = (fontFamilyPref) => {
+  const allSupportedLanguages = [];
+  const parsedFonts = /* @__PURE__ */ new Map();
+  const bunnyFonts = /* @__PURE__ */ new Map();
+  const googleFonts = /* @__PURE__ */ new Map();
+  const localFonts = /* @__PURE__ */ new Map();
+  const resolveFontLanguage = (bcp47Tag, direction = "ltr") => {
+    if (!bcp47Tag) return "default";
+    if (allSupportedLanguages.includes(bcp47Tag)) {
+      return bcp47Tag;
+    }
+    const parts = bcp47Tag.split(/[-_]/);
+    const language = parts[0].toLowerCase();
+    const scriptOrRegion = parts[1]?.toLowerCase();
+    if (scriptOrRegion) {
+      const langScriptOrRegion = `${language}-${scriptOrRegion}`;
+      if (allSupportedLanguages.includes(langScriptOrRegion)) {
+        return langScriptOrRegion;
+      }
+    }
+    if (language === "ja" && !scriptOrRegion) {
+      if (direction === "rtl" && allSupportedLanguages.includes("ja-v")) {
+        return "ja-v";
+      }
+      if (allSupportedLanguages.includes("ja")) {
+        return "ja";
+      }
+    }
+    const shouldFilter = language === "mn" && (scriptOrRegion === "mong" || scriptOrRegion === "cyrl") || language === "zh" && (scriptOrRegion === "hant" || scriptOrRegion === "tw" || scriptOrRegion === "hk");
+    if (!shouldFilter && allSupportedLanguages.includes(language)) {
+      return language;
+    }
+    return "default";
+  };
+  Object.entries(fontFamilyPref).forEach(([collectionName, collectionData]) => {
+    const fontCollection = "fonts" in collectionData ? collectionData.fonts : collectionData;
+    if ("supportedLanguages" in collectionData) {
+      const reducedLanguages = collectionData.supportedLanguages.map((lang) => {
+        const parts = lang.split(/[-_]/);
+        const language = parts[0].toLowerCase();
+        const scriptOrRegion = parts[1]?.toLowerCase();
+        return scriptOrRegion ? `${language}-${scriptOrRegion}` : language;
+      });
+      allSupportedLanguages.push(...reducedLanguages);
+    }
+    bunnyFonts.set(collectionName, []);
+    googleFonts.set(collectionName, []);
+    localFonts.set(collectionName, []);
+    const collectionBunnyFonts = bunnyFonts.get(collectionName);
+    const collectionGoogleFonts = googleFonts.get(collectionName);
+    const collectionLocalFonts = localFonts.get(collectionName);
+    Object.entries(fontCollection).forEach(([id, font]) => {
+      const fontFamily = font.spec.family;
+      let fontStack = fontFamily;
+      if (font.source.type === "custom") {
+        switch (font.source.provider) {
+          case "bunny":
+            collectionBunnyFonts.push(font);
+            break;
+          case "google":
+            collectionGoogleFonts.push(font);
+            break;
+          case "local":
+            collectionLocalFonts.push(font);
+            break;
+        }
+      }
+      const wrapIfNeeded = (name) => {
+        const trimmed = name.trim();
+        if (!trimmed) return "";
+        if (trimmed.includes(" ") && !/^['"].*['"]$/.test(trimmed)) {
+          return `"${trimmed}"`;
+        }
+        return trimmed;
+      };
+      const wrappedFontFamily = wrapIfNeeded(fontFamily);
+      if (font.spec.fallbacks?.length) {
+        const uniqueFallbacks = [...new Set(
+          font.spec.fallbacks.filter((fallback) => fallback.toLowerCase() !== fontFamily.toLowerCase()).map(wrapIfNeeded)
+        )];
+        if (uniqueFallbacks.length > 0) {
+          fontStack = [wrappedFontFamily, ...uniqueFallbacks].join(", ");
+        }
+      }
+      parsedFonts.set(id, {
+        fontStack: fontStack || wrappedFontFamily,
+        fontFamily: wrappedFontFamily,
+        weights: font.spec.weights || null,
+        widths: font.spec.widths || null
+      });
+    });
+  });
+  const defaultBunnyFonts = bunnyFonts.get("default") || [];
+  const defaultGoogleFonts = googleFonts.get("default") || [];
+  const defaultLocalFonts = localFonts.get("default") || [];
+  const processFonts = (bunnyFontsList, googleFontsList, localFontsList, optimize = false) => {
+    const result = {
+      allowedDomains: [],
+      prepend: [],
+      append: []
+    };
+    const bunnyResources = bunnyFontsList.map((font) => createBunnyFontResources(font)).filter((resource) => resource !== null);
+    if (bunnyResources.length > 0) {
+      result.allowedDomains.push(
+        "https://fonts.bunny.net"
+      );
+      result.prepend.push(
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.bunny.net"
+        }
+      );
+      result.append.push(...bunnyResources);
+    }
+    const googleResources = googleFontsList.map((font) => createGoogleFontResources(font, optimize ? font.name : void 0)).filter((resource) => resource !== null);
+    if (googleResources.length > 0) {
+      result.allowedDomains.push(
+        "https://fonts.googleapis.com",
+        "https://fonts.gstatic.com"
+      );
+      result.prepend.push(
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.googleapis.com"
+        },
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.gstatic.com",
+          attributes: { crossOrigin: "anonymous" }
+        }
+      );
+      result.append.push(...googleResources);
+    }
+    const localResources = localFontsList.map(createLocalFontResources).filter((resource) => resource !== null);
+    if (localResources.length > 0) {
+      result.allowedDomains.push(window.location.origin);
+      result.append.push(...localResources);
+    }
+    return result.append.length > 0 ? result : null;
+  };
+  const getInjectables = (options, optimize = false) => {
+    if (options && "key" in options) {
+      const { key } = options;
+      if (!key || !(key in fontFamilyPref)) {
+        return null;
+      }
+      return processFonts(bunnyFonts.get(key) || [], googleFonts.get(key) || [], localFonts.get(key) || [], optimize);
+    }
+    if (options && "language" in options) {
+      const { language: publicationLanguage } = options;
+      for (const [collectionName, collectionData] of Object.entries(fontFamilyPref)) {
+        if (collectionName === "default") continue;
+        const supportedLangs = "supportedLanguages" in collectionData ? collectionData.supportedLanguages : null;
+        if (supportedLangs && Array.isArray(supportedLangs) && publicationLanguage && supportedLangs.includes(publicationLanguage)) {
+          return processFonts(bunnyFonts.get(collectionName) || [], googleFonts.get(collectionName) || [], localFonts.get(collectionName) || [], optimize);
+        }
+      }
+    }
+    return processFonts(defaultBunnyFonts, defaultGoogleFonts, defaultLocalFonts, optimize);
+  };
+  const getFontMetadata = (fontId) => {
+    const parsed = parsedFonts.get(fontId);
+    return parsed || { fontStack: null, fontFamily: null, weights: null, widths: null };
+  };
+  const getFontCollection = (options) => {
+    if (options && "key" in options) {
+      const { key } = options;
+      if (!key || !(key in fontFamilyPref)) {
+        return fontFamilyPref.default;
+      }
+      if (key === "default") {
+        return fontFamilyPref.default;
+      }
+      const prefRecord = fontFamilyPref;
+      const collection = prefRecord[key];
+      if (collection && "fonts" in collection) {
+        return collection.fonts;
+      }
+      return fontFamilyPref.default;
+    }
+    if (options && "language" in options) {
+      const { language: publicationLanguage } = options;
+      for (const [collectionName, collectionData] of Object.entries(fontFamilyPref)) {
+        if (collectionName === "default") continue;
+        const collection = "fonts" in collectionData ? collectionData : { fonts: collectionData };
+        const supportedLangs = "supportedLanguages" in collection ? collection.supportedLanguages : null;
+        if (supportedLangs?.includes(publicationLanguage)) {
+          return collection.fonts;
+        }
+      }
+      return fontFamilyPref.default;
+    }
+    return fontFamilyPref.default;
+  };
+  return {
+    getInjectables,
+    getFontMetadata,
+    getFontCollection,
+    resolveFontLanguage
+  };
+};
+
+// src/preferences/hooks/usePreferences.ts
 function usePreferences() {
   const context = useContext(ThPreferencesContext);
   if (!context) {
     throw new Error("usePreferences must be used within a ThPreferencesProvider");
   }
+  const fontService = createFontService(context.preferences.settings.keys.fontFamily);
   return {
     preferences: context.preferences,
-    updatePreferences: context.updatePreferences
+    updatePreferences: context.updatePreferences,
+    getFontInjectables: (options, optimize) => {
+      return fontService.getInjectables(options, optimize);
+    },
+    getFontsList: (options) => {
+      return fontService.getFontCollection(options);
+    },
+    getFontMetadata: (fontId) => {
+      return fontService.getFontMetadata(fontId);
+    },
+    resolveFontLanguage: (bcp47Tag, direction) => {
+      return fontService.resolveFontLanguage(bcp47Tag, direction);
+    }
   };
 }
 
@@ -996,6 +1772,6 @@ var useTheming = ({
   };
 };
 
-export { ThMemoryPreferencesAdapter, ThPreferencesContext, ThPreferencesProvider, buildThemeObject, createPreferences, defaultActionKeysObject, defaultFontFamilyOptions, defaultLetterSpacing, defaultLineHeights, defaultParagraphIndent, defaultParagraphSpacing, defaultPreferences, defaultPreferencesContextValue, defaultSpacingPresets, defaultSpacingPresetsOrder, defaultSpacingSettingsMain, defaultSpacingSettingsSubpanel, defaultTextSettingsMain, defaultTextSettingsSubpanel, defaultWordSpacing, defaultZoom, prefixString, usePreferenceKeys, usePreferences, useTheming };
-//# sourceMappingURL=chunk-IRA4ZKAX.mjs.map
-//# sourceMappingURL=chunk-IRA4ZKAX.mjs.map
+export { ThMemoryPreferencesAdapter, ThPreferencesContext, ThPreferencesProvider, buildThemeObject, createDefinitionFromStaticFonts, createDefinitionsFromBunnyFonts, createDefinitionsFromGoogleFonts, createPreferences, defaultActionKeysObject, defaultFontCollection, defaultLetterSpacing, defaultLineHeights, defaultParagraphIndent, defaultParagraphSpacing, defaultPreferences, defaultPreferencesContextValue, defaultSpacingPresets, defaultSpacingPresetsOrder, defaultSpacingSettingsMain, defaultSpacingSettingsSubpanel, defaultTextSettingsMain, defaultTextSettingsSubpanel, defaultWordSpacing, defaultZoom, prefixString, readiumCSSFontCollection, tamilCollection, usePreferenceKeys, usePreferences, useTheming };
+//# sourceMappingURL=chunk-VN44OJDD.mjs.map
+//# sourceMappingURL=chunk-VN44OJDD.mjs.map