@myoc/excalidraw 0.20.1 → 0.21.0

package/dist/dev/{chunk-EYSZ36MK.js → chunk-RCINQZKB.js}

@@ -1,7 +1,7 @@
 // <define:import.meta.env>
-var define_import_meta_env_default = { MODE: "development", VITE_APP_BACKEND_V2_GET_URL: "https://json-dev.excalidraw.com/api/v2/", VITE_APP_BACKEND_V2_POST_URL: "https://json-dev.excalidraw.com/api/v2/post/", VITE_APP_LIBRARY_URL: "https://libraries.excalidraw.com", VITE_APP_LIBRARY_BACKEND: "https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries", VITE_APP_WS_SERVER_URL: "http://localhost:3002", VITE_APP_PLUS_LP: "https://plus.excalidraw.com", VITE_APP_PLUS_APP: "http://localhost:3000", VITE_APP_AI_BACKEND: "http://localhost:3016", VITE_APP_FIREBASE_CONFIG: '{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}', VITE_APP_DEV_DISABLE_LIVE_RELOAD: "", VITE_APP_ENABLE_TRACKING: "true", FAST_REFRESH: "false", VITE_APP_PORT: "3001", VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX: "", VITE_APP_COLLAPSE_OVERLAY: "true", VITE_APP_ENABLE_ESLINT: "true", VITE_APP_ENABLE_PWA: "false", VITE_APP_PLUS_EXPORT_PUBLIC_KEY: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm2g5T+Rub6Kbf1Mf57t0\n7r2zeHuVg4dla3r5ryXMswtzz6x767octl6oLThn33mQsPSy3GKglFZoCTXJR4ij\nba8SxB04sL/N8eRrKja7TFWjCVtRwTTfyy771NYYNFVJclkxHyE5qw4m27crHF1y\nUNWEjuqNMi/lwAErS9fFa2oJlWyT8U7zzv/5kQREkxZI6y9v0AF3qcbsy2731FnD\ns9ChJvOUW9toIab2gsIdrKW8ZNpu084ZFVKb6LNjvIXI1Se4oMTHeszXzNptzlot\nkdxxjOoaQMAyfljFSot1F1FlU6MQlag7UnFGvFjRHN1JI5q4K+n3a67DX+TMyRqS\nHQIDAQAB", VITE_APP_DISABLE_PREVENT_UNLOAD: "", PKG_NAME: "@myoc/excalidraw", PKG_VERSION: "0.20.0", DEV: true };
+var define_import_meta_env_default = { MODE: "development", VITE_APP_BACKEND_V2_GET_URL: "https://json-dev.excalidraw.com/api/v2/", VITE_APP_BACKEND_V2_POST_URL: "https://json-dev.excalidraw.com/api/v2/post/", VITE_APP_LIBRARY_URL: "https://libraries.excalidraw.com", VITE_APP_LIBRARY_BACKEND: "https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries", VITE_APP_WS_SERVER_URL: "http://localhost:3002", VITE_APP_PLUS_LP: "https://plus.excalidraw.com", VITE_APP_PLUS_APP: "http://localhost:3000", VITE_APP_AI_BACKEND: "http://localhost:3016", VITE_APP_FIREBASE_CONFIG: '{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}', VITE_APP_DEV_DISABLE_LIVE_RELOAD: "", VITE_APP_ENABLE_TRACKING: "true", FAST_REFRESH: "false", VITE_APP_PORT: "3001", VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX: "", VITE_APP_COLLAPSE_OVERLAY: "true", VITE_APP_ENABLE_ESLINT: "true", VITE_APP_ENABLE_PWA: "false", VITE_APP_PLUS_EXPORT_PUBLIC_KEY: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm2g5T+Rub6Kbf1Mf57t0\n7r2zeHuVg4dla3r5ryXMswtzz6x767octl6oLThn33mQsPSy3GKglFZoCTXJR4ij\nba8SxB04sL/N8eRrKja7TFWjCVtRwTTfyy771NYYNFVJclkxHyE5qw4m27crHF1y\nUNWEjuqNMi/lwAErS9fFa2oJlWyT8U7zzv/5kQREkxZI6y9v0AF3qcbsy2731FnD\ns9ChJvOUW9toIab2gsIdrKW8ZNpu084ZFVKb6LNjvIXI1Se4oMTHeszXzNptzlot\nkdxxjOoaQMAyfljFSot1F1FlU6MQlag7UnFGvFjRHN1JI5q4K+n3a67DX+TMyRqS\nHQIDAQAB", VITE_APP_DISABLE_PREVENT_UNLOAD: "", PKG_NAME: "@myoc/excalidraw", PKG_VERSION: "0.20.1", DEV: true };
 
 export {
   define_import_meta_env_default
 };
-//# sourceMappingURL=chunk-EYSZ36MK.js.map
+//# sourceMappingURL=chunk-RCINQZKB.js.map

package/dist/dev/{chunk-JBD373VY.js → chunk-TYPY4HGC.js}

@@ -1,6 +1,6 @@
 import {
   define_import_meta_env_default
-} from "./chunk-EYSZ36MK.js";
+} from "./chunk-RCINQZKB.js";
 import {
   __publicField
 } from "./chunk-XDFCUUT6.js";
@@ -866,6 +866,7 @@ import {
   CJK_HAND_DRAWN_FALLBACK_FONT,
   WINDOWS_EMOJI_FALLBACK_FONT,
   getFontFamilyFallbacks,
+  isGoogleFontFamily as isGoogleFontFamily2,
   FONT_SIZES
 } from "@excalidraw/common";
 import { getContainerElement } from "@excalidraw/element";
@@ -874,71 +875,14 @@ import { containsCJK } from "@excalidraw/element";
 import {
   FONT_METADATA,
   getFontString,
+  registerFontMetadata,
+  unregisterFontMetadata,
   PromisePool,
   promiseTry as promiseTry3
 } from "@excalidraw/common";
 import { ShapeCache } from "@excalidraw/element";
 import { isTextElement } from "@excalidraw/element";
 
-// fonts/Cascadia/CascadiaCode-Regular.woff2
-var CascadiaCode_Regular_default = "./fonts/Cascadia/CascadiaCode-Regular.woff2";
-
-// fonts/Cascadia/index.ts
-var CascadiaFontFaces = [
-  {
-    uri: CascadiaCode_Regular_default
-  }
-];
-
-// fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2
-var ComicShanns_Regular_279a7b317d12eb88de06167bd672b4b4_default = "./fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2";
-
-// fonts/ComicShanns/ComicShanns-Regular-6e066e8de2ac57ea9283adb9c24d7f0c.woff2
-var ComicShanns_Regular_6e066e8de2ac57ea9283adb9c24d7f0c_default = "./fonts/ComicShanns/ComicShanns-Regular-6e066e8de2ac57ea9283adb9c24d7f0c.woff2";
-
-// fonts/ComicShanns/ComicShanns-Regular-dc6a8806fa96795d7b3be5026f989a17.woff2
-var ComicShanns_Regular_dc6a8806fa96795d7b3be5026f989a17_default = "./fonts/ComicShanns/ComicShanns-Regular-dc6a8806fa96795d7b3be5026f989a17.woff2";
-
-// fonts/ComicShanns/ComicShanns-Regular-fcb0fc02dcbee4c9846b3e2508668039.woff2
-var ComicShanns_Regular_fcb0fc02dcbee4c9846b3e2508668039_default = "./fonts/ComicShanns/ComicShanns-Regular-fcb0fc02dcbee4c9846b3e2508668039.woff2";
-
-// fonts/ComicShanns/index.ts
-var ComicShannsFontFaces = [
-  {
-    uri: ComicShanns_Regular_279a7b317d12eb88de06167bd672b4b4_default,
-    descriptors: {
-      unicodeRange: "U+20-7e,U+a1-a6,U+a8,U+ab-ac,U+af-b1,U+b4,U+b8,U+bb-bc,U+bf-cf,U+d1-d7,U+d9-de,U+e0-ef,U+f1-f7,U+f9-ff,U+131,U+152-153,U+2c6,U+2da,U+2dc,U+2013-2014,U+2018-201a,U+201c-201d,U+2020-2022,U+2026,U+2039-203a,U+2044,U+20ac,U+2191,U+2193,U+2212"
-    }
-  },
-  {
-    uri: ComicShanns_Regular_fcb0fc02dcbee4c9846b3e2508668039_default,
-    descriptors: {
-      unicodeRange: "U+100-10f,U+112-125,U+128-130,U+134-137,U+139-13c,U+141-148,U+14c-151,U+154-161,U+164-165,U+168-17f,U+1bf,U+1f7,U+218-21b,U+237,U+1e80-1e85,U+1ef2-1ef3,U+a75b"
-    }
-  },
-  {
-    uri: ComicShanns_Regular_dc6a8806fa96795d7b3be5026f989a17_default,
-    descriptors: {
-      unicodeRange: "U+2c7,U+2d8-2d9,U+2db,U+2dd,U+315,U+2190,U+2192,U+2200,U+2203-2204,U+2264-2265,U+f6c3"
-    }
-  },
-  {
-    uri: ComicShanns_Regular_6e066e8de2ac57ea9283adb9c24d7f0c_default,
-    descriptors: { unicodeRange: "U+3bb" }
-  }
-];
-
-// fonts/Emoji/index.ts
-import { LOCAL_FONT_PROTOCOL } from "@excalidraw/common";
-var EmojiFontFaces = [
-  {
-    uri: LOCAL_FONT_PROTOCOL
-  }
-];
-
-// fonts/ExcalidrawFontFace.ts
-import { promiseTry as promiseTry2, LOCAL_FONT_PROTOCOL as LOCAL_FONT_PROTOCOL2 } from "@excalidraw/common";
-
 // subset/subset-main.ts
 import { isServerEnv, promiseTry } from "@excalidraw/common";
 
@@ -1083,6 +1027,10 @@ var subsetWoff2GlyphsByCodepoints = async (arrayBuffer, codePoints) => {
     }
   });
 };
+var getWoff2FontMetrics = async (arrayBuffer) => {
+  const { getWoff2FontMetrics: getWoff2FontMetrics2 } = await lazyLoadSharedSubsetChunk();
+  return getWoff2FontMetrics2(arrayBuffer);
+};
 var subsetWorker = null;
 var subsetShared = null;
 var lazyLoadWorkerSubsetChunk = async () => {
@@ -1109,11 +1057,70 @@ var getOrCreateWorkerPool = () => {
   return workerPool;
 };
 
+// fonts/Cascadia/CascadiaCode-Regular.woff2
+var CascadiaCode_Regular_default = "./fonts/Cascadia/CascadiaCode-Regular.woff2";
+
+// fonts/Cascadia/index.ts
+var CascadiaFontFaces = [
+  {
+    uri: CascadiaCode_Regular_default
+  }
+];
+
+// fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2
+var ComicShanns_Regular_279a7b317d12eb88de06167bd672b4b4_default = "./fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2";
+
+// fonts/ComicShanns/ComicShanns-Regular-6e066e8de2ac57ea9283adb9c24d7f0c.woff2
+var ComicShanns_Regular_6e066e8de2ac57ea9283adb9c24d7f0c_default = "./fonts/ComicShanns/ComicShanns-Regular-6e066e8de2ac57ea9283adb9c24d7f0c.woff2";
+
+// fonts/ComicShanns/ComicShanns-Regular-dc6a8806fa96795d7b3be5026f989a17.woff2
+var ComicShanns_Regular_dc6a8806fa96795d7b3be5026f989a17_default = "./fonts/ComicShanns/ComicShanns-Regular-dc6a8806fa96795d7b3be5026f989a17.woff2";
+
+// fonts/ComicShanns/ComicShanns-Regular-fcb0fc02dcbee4c9846b3e2508668039.woff2
+var ComicShanns_Regular_fcb0fc02dcbee4c9846b3e2508668039_default = "./fonts/ComicShanns/ComicShanns-Regular-fcb0fc02dcbee4c9846b3e2508668039.woff2";
+
+// fonts/ComicShanns/index.ts
+var ComicShannsFontFaces = [
+  {
+    uri: ComicShanns_Regular_279a7b317d12eb88de06167bd672b4b4_default,
+    descriptors: {
+      unicodeRange: "U+20-7e,U+a1-a6,U+a8,U+ab-ac,U+af-b1,U+b4,U+b8,U+bb-bc,U+bf-cf,U+d1-d7,U+d9-de,U+e0-ef,U+f1-f7,U+f9-ff,U+131,U+152-153,U+2c6,U+2da,U+2dc,U+2013-2014,U+2018-201a,U+201c-201d,U+2020-2022,U+2026,U+2039-203a,U+2044,U+20ac,U+2191,U+2193,U+2212"
+    }
+  },
+  {
+    uri: ComicShanns_Regular_fcb0fc02dcbee4c9846b3e2508668039_default,
+    descriptors: {
+      unicodeRange: "U+100-10f,U+112-125,U+128-130,U+134-137,U+139-13c,U+141-148,U+14c-151,U+154-161,U+164-165,U+168-17f,U+1bf,U+1f7,U+218-21b,U+237,U+1e80-1e85,U+1ef2-1ef3,U+a75b"
+    }
+  },
+  {
+    uri: ComicShanns_Regular_dc6a8806fa96795d7b3be5026f989a17_default,
+    descriptors: {
+      unicodeRange: "U+2c7,U+2d8-2d9,U+2db,U+2dd,U+315,U+2190,U+2192,U+2200,U+2203-2204,U+2264-2265,U+f6c3"
+    }
+  },
+  {
+    uri: ComicShanns_Regular_6e066e8de2ac57ea9283adb9c24d7f0c_default,
+    descriptors: { unicodeRange: "U+3bb" }
+  }
+];
+
+// fonts/Emoji/index.ts
+import { LOCAL_FONT_PROTOCOL } from "@excalidraw/common";
+var EmojiFontFaces = [
+  {
+    uri: LOCAL_FONT_PROTOCOL
+  }
+];
+
 // fonts/ExcalidrawFontFace.ts
+import { promiseTry as promiseTry2, LOCAL_FONT_PROTOCOL as LOCAL_FONT_PROTOCOL2 } from "@excalidraw/common";
 var _ExcalidrawFontFace = class _ExcalidrawFontFace {
-  constructor(family, uri, descriptors) {
+  constructor(family, uri, descriptors, mustEmbed = false) {
     __publicField(this, "urls");
     __publicField(this, "fontFace");
+    __publicField(this, "mustEmbed");
+    this.mustEmbed = mustEmbed;
     this.urls = _ExcalidrawFontFace.createUrls(uri);
     const sources = this.urls.map((url) => `url(${url}) ${_ExcalidrawFontFace.getFormat(url)}`).join(", ");
     this.fontFace = new FontFace(family, sources, {
@@ -1135,9 +1142,12 @@ var _ExcalidrawFontFace = class _ExcalidrawFontFace {
     const codepoints = Array.from(characters).map(
       (char) => char.codePointAt(0)
     );
-    return this.getContent(codepoints).then(
-      (content) => `@font-face { font-family: ${this.fontFace.family}; src: url(${content}); }`
-    );
+    return this.getContent(codepoints).then((content) => {
+      if (!content) {
+        return "";
+      }
+      return `@font-face { font-family: ${this.fontFace.family}; src: url(${content}); }`;
+    });
   }
   /**
    * Tries to fetch woff2 content, based on the registered urls (from first to last, treated as fallbacks).
@@ -1165,6 +1175,9 @@ var _ExcalidrawFontFace = class _ExcalidrawFontFace {
       `Failed to fetch font family "${this.fontFace.family}"`,
       JSON.stringify(errorMessages, void 0, 2)
     );
+    if (this.mustEmbed) {
+      return "";
+    }
     return this.urls.length ? this.urls[this.urls.length - 1].toString() : "";
   }
   fetchFont(url) {
@@ -2980,6 +2993,150 @@ var XiaolaiFontFaces = [
   }
 ];
 
+// fonts/googleFonts.ts
+import {
+  getGoogleFontFamilyName,
+  isGoogleFontFamily,
+  toGoogleFontFamily
+} from "@excalidraw/common";
+var GOOGLE_FONTS_CSS_URL = "https://fonts.googleapis.com/css2";
+var DEFAULT_GOOGLE_FONT_WEIGHT = 400;
+var parseGoogleFontId = (fontId) => {
+  if (!isGoogleFontFamily(fontId)) {
+    return null;
+  }
+  const name = getGoogleFontFamilyName(fontId);
+  const match = name.match(/^(.+)@(\d{1,4})$/);
+  if (!match) {
+    return { family: name, weight: DEFAULT_GOOGLE_FONT_WEIGHT };
+  }
+  return { family: match[1], weight: Number(match[2]) };
+};
+var formatGoogleFontId = (family, weight = DEFAULT_GOOGLE_FONT_WEIGHT) => toGoogleFontFamily(
+  weight === DEFAULT_GOOGLE_FONT_WEIGHT ? family : `${family}@${weight}`
+);
+var cssSources;
+var failedCssSources = /* @__PURE__ */ new Set();
+var setGoogleFontCssSources = (sources) => {
+  cssSources = sources;
+};
+var getCssSources = (family) => {
+  const sources = cssSources?.(family);
+  return sources?.length ? sources : [GOOGLE_FONTS_CSS_URL];
+};
+var getAvailableCssSources = (family) => {
+  const sources = getCssSources(family);
+  const available = sources.filter((source) => !failedCssSources.has(source));
+  return available.length ? available : sources;
+};
+var markGoogleFontSourceFailed = (family, source) => {
+  failedCssSources.add(source);
+  return getCssSources(family).some((x) => !failedCssSources.has(x));
+};
+var getGoogleFontCssUrl = (family, weight = DEFAULT_GOOGLE_FONT_WEIGHT, source = GOOGLE_FONTS_CSS_URL) => {
+  const url = new URL(source);
+  url.searchParams.set("family", `${family}:wght@${weight}`);
+  url.searchParams.set("display", "swap");
+  return url;
+};
+var getCssProperty = (css, property) => {
+  const match = css.match(
+    new RegExp(`(?:^|;)\\s*${property}\\s*:\\s*([^;]+)`, "i")
+  );
+  return match?.[1]?.trim();
+};
+var resolveWoff2Url = (src, base) => {
+  try {
+    const url = new URL(src, base);
+    if (url.protocol !== "https:" && url.protocol !== "http:" || !url.pathname.endsWith(".woff2")) {
+      return null;
+    }
+    return url.href;
+  } catch {
+    return null;
+  }
+};
+var parseGoogleFontFaceCss = (css, base) => {
+  const descriptors = [];
+  const fontFaceRegex = /@font-face\s*\{([^}]+)\}/gi;
+  let match;
+  while (match = fontFaceRegex.exec(css)) {
+    const body = match[1];
+    const src = getCssProperty(body, "src");
+    const rawUrl = src?.match(/url\((['"]?)([^'")]+)\1\)/i)?.[2];
+    const url = rawUrl && resolveWoff2Url(rawUrl, base);
+    if (!url) {
+      continue;
+    }
+    const weight = getCssProperty(body, "font-weight") || "400";
+    const style = getCssProperty(body, "font-style") || "normal";
+    const unicodeRange = getCssProperty(body, "unicode-range");
+    descriptors.push({
+      uri: url,
+      mustEmbed: true,
+      descriptors: {
+        weight,
+        style,
+        ...unicodeRange ? { unicodeRange } : {}
+      }
+    });
+  }
+  return descriptors;
+};
+var getInternalCssFamily = (fontId) => {
+  const name = getGoogleFontFamilyName(fontId);
+  return /^[\p{L}\p{N}_ -]+$/u.test(name) ? name : JSON.stringify(name);
+};
+var SourceFailure = class extends Error {
+};
+var fetchGoogleFontFaces = async (fontId, family, weight, source) => {
+  const cssUrl = getGoogleFontCssUrl(family, weight, source);
+  let response;
+  try {
+    response = await fetch(cssUrl, {
+      cache: "force-cache",
+      headers: { Accept: "text/css" }
+    });
+  } catch (error) {
+    throw new SourceFailure(String(error), { cause: error });
+  }
+  if (!response.ok) {
+    const ErrorType = response.status >= 500 || response.status === 429 ? SourceFailure : Error;
+    throw new ErrorType(
+      `Google Fonts CSS request failed for "${fontId}": ${response.status} ${response.statusText}`
+    );
+  }
+  const descriptors = parseGoogleFontFaceCss(await response.text(), cssUrl);
+  if (!descriptors.length) {
+    throw new Error(`Google Fonts returned no WOFF2 faces for "${fontId}"`);
+  }
+  const cssFamily = getInternalCssFamily(fontId);
+  return descriptors.map(
+    ({ uri, descriptors: descriptors2, mustEmbed }) => new ExcalidrawFontFace(cssFamily, uri, descriptors2, mustEmbed)
+  );
+};
+var loadGoogleFontFaces = async (fontId) => {
+  const { family, weight } = parseGoogleFontId(fontId);
+  let lastError;
+  for (const source of getAvailableCssSources(family)) {
+    try {
+      const fontFaces = await fetchGoogleFontFaces(
+        fontId,
+        family,
+        weight,
+        source
+      );
+      return { fontFaces, source };
+    } catch (error) {
+      lastError = error;
+      if (error instanceof SourceFailure) {
+        failedCssSources.add(source);
+      }
+    }
+  }
+  throw lastError;
+};
+
 // fonts/Fonts.ts
 var _Fonts = class _Fonts {
   constructor(scene) {
@@ -3037,6 +3194,15 @@ var _Fonts = class _Fonts {
       );
       return _Fonts.loadFontFaces(sceneFamilies, charsPerFamily);
     });
+    /** Load a family for picker previews and invalidate text rendered with a fallback. */
+    __publicField(this, "loadFontFamily", async (fontFamily, characters) => {
+      const charsPerFamily = /* @__PURE__ */ new Map([
+        [fontFamily, new Set(Array.from(characters))]
+      ]);
+      const fontFaces = await _Fonts.loadFontFaces([fontFamily], charsPerFamily);
+      this.onLoaded(fontFaces);
+      return fontFaces;
+    });
     this.scene = scene;
   }
   static get registered() {
@@ -3066,16 +3232,29 @@ var _Fonts = class _Fonts {
       const characters = _Fonts.getCharacters(charsPerFamily, familyWithCJK);
       if (containsCJK(characters)) {
         const family = FONT_FAMILY_FALLBACKS[CJK_HAND_DRAWN_FALLBACK_FONT];
-        charsPerFamily[family] = new Set(characters);
+        charsPerFamily.set(family, new Set(characters));
         families.unshift(FONT_FAMILY_FALLBACKS[CJK_HAND_DRAWN_FALLBACK_FONT]);
       }
     }
+    await _Fonts.loadFontFaces(families, charsPerFamily);
     const iterator = _Fonts.fontFacesStylesGenerator(families, charsPerFamily);
     const concurrency = 3;
     const fontFaces = await new PromisePool(iterator, concurrency).all();
     return Array.from(new Set(fontFaces));
   }
   static async loadFontFaces(fontFamilies, charsPerFamily) {
+    await Promise.all(
+      fontFamilies.filter(isGoogleFontFamily2).map(async (fontFamily) => {
+        try {
+          await _Fonts.registerGoogleFont(fontFamily);
+        } catch (error) {
+          console.error(
+            `Failed to register Google Font "${fontFamily}"`,
+            error
+          );
+        }
+      })
+    );
     for (const { fontFaces: fontFaces2, metadata } of _Fonts.registered.values()) {
       if (metadata.local) {
         continue;
@@ -3101,9 +3280,16 @@ var _Fonts = class _Fonts {
       if (!window.document.fonts.check(font, text)) {
         yield promiseTry3(async () => {
           try {
-            const fontFaces = await window.document.fonts.load(font, text);
-            return [index, fontFaces];
+            return await _Fonts.loadFontFacesForFamily(
+              fontFamily,
+              font,
+              text,
+              index
+            );
           } catch (e) {
+            if (isGoogleFontFamily2(fontFamily)) {
+              _Fonts.resetGoogleFont(fontFamily);
+            }
             console.error(
               `Failed to load font "${font}" from urls "${_Fonts.registered.get(fontFamily)?.fontFaces.map((x) => x.urls)}"`,
               e
@@ -3113,6 +3299,28 @@ var _Fonts = class _Fonts {
       }
     }
   }
+  static async loadFontFacesForFamily(fontFamily, font, text, index) {
+    while (true) {
+      try {
+        const fontFaces = await window.document.fonts.load(font, text);
+        if (isGoogleFontFamily2(fontFamily)) {
+          await _Fonts.loadGoogleFontMetrics(fontFamily, fontFaces);
+        }
+        return [index, fontFaces];
+      } catch (error) {
+        const source = _Fonts.googleFontSources.get(fontFamily);
+        const parsed = parseGoogleFontId(fontFamily);
+        if (!parsed || !source || !markGoogleFontSourceFailed(parsed.family, source)) {
+          throw error;
+        }
+        _Fonts.resetGoogleFont(fontFamily);
+        await _Fonts.registerGoogleFont(fontFamily);
+        for (const { fontFace } of _Fonts.registered.get(fontFamily)?.fontFaces ?? []) {
+          window.document.fonts.add(fontFace);
+        }
+      }
+    }
+  }
   static *fontFacesStylesGenerator(families, charsPerFamily) {
     for (const [familyIndex, family] of families.entries()) {
       const { fontFaces, metadata } = _Fonts.registered.get(family) ?? {};
@@ -3161,7 +3369,7 @@ var _Fonts = class _Fonts {
       this.registered.set(fontFamily, {
         metadata,
         fontFaces: fontFacesDecriptors.map(
-          ({ uri, descriptors }) => new ExcalidrawFontFace(family, uri, descriptors)
+          ({ uri, descriptors, mustEmbed }) => new ExcalidrawFontFace(family, uri, descriptors, mustEmbed)
         )
       });
     }
@@ -3209,16 +3417,16 @@ var _Fonts = class _Fonts {
    * Get all the unique characters per font family for the given scene.
    */
   static getCharsPerFamily(elements) {
-    const charsPerFamily = {};
+    const charsPerFamily = /* @__PURE__ */ new Map();
     for (const element of elements) {
       if (!isTextElement(element)) {
         continue;
       }
       for (const char of element.originalText) {
-        if (!charsPerFamily[element.fontFamily]) {
-          charsPerFamily[element.fontFamily] = /* @__PURE__ */ new Set();
+        if (!charsPerFamily.has(element.fontFamily)) {
+          charsPerFamily.set(element.fontFamily, /* @__PURE__ */ new Set());
         }
-        charsPerFamily[element.fontFamily].add(char);
+        charsPerFamily.get(element.fontFamily).add(char);
       }
     }
     return charsPerFamily;
@@ -3227,7 +3435,7 @@ var _Fonts = class _Fonts {
    * Get characters for a given family.
    */
   static getCharacters(charsPerFamily, family) {
-    return charsPerFamily[family] ? Array.from(charsPerFamily[family]).join("") : "";
+    return charsPerFamily.get(family) ? Array.from(charsPerFamily.get(family)).join("") : "";
   }
   /**
    * Get all registered font families.
@@ -3239,6 +3447,10 @@ var _Fonts = class _Fonts {
 // it's ok to track fonts across multiple instances only once, so let's use
 // a static member to reduce memory footprint
 __publicField(_Fonts, "loadedFontsCache", /* @__PURE__ */ new Set());
+__publicField(_Fonts, "googleFontPromises", /* @__PURE__ */ new Map());
+__publicField(_Fonts, "googleFontMetrics", /* @__PURE__ */ new Set());
+/** CSS source each registered Google font was loaded from. */
+__publicField(_Fonts, "googleFontSources", /* @__PURE__ */ new Map());
 __publicField(_Fonts, "_registered");
 __publicField(_Fonts, "_initialized", false);
 /**
@@ -3249,6 +3461,88 @@ __publicField(_Fonts, "loadElementsFonts", async (elements) => {
   const charsPerFamily = _Fonts.getCharsPerFamily(elements);
   return _Fonts.loadFontFaces(fontFamilies, charsPerFamily);
 });
+__publicField(_Fonts, "registerGoogleFont", async (fontFamily) => {
+  if (!isGoogleFontFamily2(fontFamily) || _Fonts.registered.has(fontFamily)) {
+    return;
+  }
+  let promise = _Fonts.googleFontPromises.get(fontFamily);
+  if (!promise) {
+    promise = loadGoogleFontFaces(fontFamily).then(
+      ({ fontFaces, source }) => {
+        if (!fontFaces.length) {
+          throw new Error(
+            `Google Fonts returned no font faces for "${fontFamily}"`
+          );
+        }
+        _Fonts.registered.set(fontFamily, {
+          metadata: FONT_METADATA[FONT_FAMILY.Excalifont],
+          fontFaces
+        });
+        _Fonts.googleFontSources.set(fontFamily, source);
+      }
+    );
+    _Fonts.googleFontPromises.set(fontFamily, promise);
+  }
+  try {
+    await promise;
+  } catch (error) {
+    if (_Fonts.googleFontPromises.get(fontFamily) === promise) {
+      _Fonts.googleFontPromises.delete(fontFamily);
+    }
+    throw error;
+  }
+});
+__publicField(_Fonts, "resetGoogleFont", (fontFamily) => {
+  if (!isGoogleFontFamily2(fontFamily)) {
+    return;
+  }
+  const registered = _Fonts.registered.get(fontFamily);
+  if (registered) {
+    for (const { fontFace } of registered.fontFaces) {
+      window.document.fonts.delete(fontFace);
+      _Fonts.loadedFontsCache.delete(
+        `${fontFace.family}-${fontFace.style}-${fontFace.weight}-${fontFace.unicodeRange}`
+      );
+    }
+    _Fonts.registered.delete(fontFamily);
+  }
+  _Fonts.googleFontPromises.delete(fontFamily);
+  _Fonts.googleFontMetrics.delete(fontFamily);
+  _Fonts.googleFontSources.delete(fontFamily);
+  unregisterFontMetadata(fontFamily);
+});
+__publicField(_Fonts, "loadGoogleFontMetrics", async (fontFamily, loadedFaces) => {
+  if (!isGoogleFontFamily2(fontFamily) || _Fonts.googleFontMetrics.has(fontFamily)) {
+    return;
+  }
+  const registered = _Fonts.registered.get(fontFamily);
+  const loadedFace = registered?.fontFaces.find(
+    (candidate) => loadedFaces.includes(candidate.fontFace)
+  );
+  const url = loadedFace?.urls.find((candidate) => candidate instanceof URL);
+  if (!registered || !loadedFace || !(url instanceof URL)) {
+    return;
+  }
+  try {
+    const metrics = await getWoff2FontMetrics(
+      await loadedFace.fetchFont(url)
+    );
+    const metadata = {
+      ...registered.metadata,
+      metrics: {
+        unitsPerEm: metrics.unitsPerEm,
+        ascender: metrics.ascender,
+        descender: metrics.descender,
+        lineHeight: metrics.lineHeight
+      }
+    };
+    registered.metadata = metadata;
+    registerFontMetadata(fontFamily, metadata);
+    _Fonts.googleFontMetrics.add(fontFamily);
+  } catch (error) {
+    console.error(`Failed to parse metrics for "${fontFamily}"`, error);
+  }
+});
 var Fonts = _Fonts;
 
 // renderer/staticScene.ts
@@ -5455,7 +5749,7 @@ var parseFileContents = async (blob) => {
   let contents;
   if (blob.type === MIME_TYPES6.png) {
     try {
-      return await (await import("./data/image-KRZO2CVW.js")).decodePngMetadata(blob);
+      return await (await import("./data/image-LHOOLEDU.js")).decodePngMetadata(blob);
     } catch (error) {
       if (error.message === "INVALID") {
         throw new ImageSceneDataError(
@@ -5858,6 +6152,11 @@ export {
   ImageSceneDataError,
   UnsupportedImageFileTypeError,
   ExcalidrawError,
+  DEFAULT_GOOGLE_FONT_WEIGHT,
+  parseGoogleFontId,
+  formatGoogleFontId,
+  setGoogleFontCssSources,
+  parseGoogleFontFaceCss,
   Fonts,
   getDefaultAppState,
   isEraserActive,
@@ -5906,4 +6205,4 @@ export {
   createFile,
   normalizeFile
 };
-//# sourceMappingURL=chunk-JBD373VY.js.map
+//# sourceMappingURL=chunk-TYPY4HGC.js.map