@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-ytjvpbm2.js

@@ -0,0 +1,736 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  persistFont,
+  persistedFont
+} from "./index-3b3at80h.js";
+import {
+  familyStack,
+  fontStyle,
+  googleFontNaming,
+  localFontNaming,
+  singleQuoteFamily,
+  stableJson
+} from "./index-fn1chkkd.js";
+import {
+  servedRelease
+} from "./index-tqn2qnnn.js";
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  onExtensionHostReset,
+  registerResponseFinalizers
+} from "./index-zqpqyg8p.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+
+// src/compat/next/font/runtime.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import { existsSync, readFileSync } from "fs";
+import { copyFile, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var fontRuntimeGlobal = globalThis;
+var sharedAcrossInstances = (key, create) => fontRuntimeGlobal[key] ??= create();
+var fontStorage = sharedAcrossInstances(Symbol.for("pnext.compat.font.storage"), () => new AsyncLocalStorage);
+var allowedDisplayValues = new Set(["auto", "block", "swap", "fallback", "optional"]);
+var require2 = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/compat/next/font/runtime.ts").href);
+var googleCssCache = new Map;
+var googleFontFileCache = new Map;
+var resolvedFontCache = sharedAcrossInstances(Symbol.for("pnext.compat.font.resolved"), () => new Map);
+var googleMetadataCache;
+var declaredFonts = sharedAcrossInstances(Symbol.for("pnext.compat.font.declared"), () => new Map);
+async function prewarmFonts(config, options = {}) {
+  if (process.env.PNEXT_PREWARM_FONTS === "0" || declaredFonts.size === 0)
+    return;
+  await Promise.allSettled([...declaredFonts.values()].map((font) => resolveFont(font, { config, dev: options.dev })));
+}
+function runWithFontScope(callback) {
+  registerFontFinalizerOnce();
+  return fontStorage.run({ fonts: new Map }, callback);
+}
+var FONT_HEADER_PRELOADS = Symbol.for("pnext.compat.font.headerPreloads");
+async function fontAssets(config, options = {}) {
+  const scope = fontStorage.getStore();
+  if (!scope || scope.fonts.size === 0)
+    return { css: "", preloads: [] };
+  const resolved = await Promise.all([...scope.fonts.values()].map((font) => resolveFont(font, { config, dev: options.dev })));
+  const preloads = dedupePreloads(resolved.flatMap((font) => font.preloads));
+  stashHeaderPreloads(preloads);
+  if (resolved.some((font) => font.sizeAdjust))
+    scope.sizeAdjust = true;
+  const usesFonts = resolved.some((font) => font.usesFonts);
+  return {
+    css: resolved.map((font) => font.css).filter(Boolean).join(`
+`),
+    preloads: preloads.length > 0 ? options.dev ? preloads : [] : usesFonts ? [fontPreconnect()] : []
+  };
+}
+function fontPreloadDomScript() {
+  return `<script>(function(){try{function a(){var seen={},ls=document.querySelectorAll('link[as="font"]');` + "for(var i=0;i<ls.length;i++)seen[ls[i].href]=1;" + "for(var i=0;i<document.styleSheets.length;i++){var rules;try{rules=document.styleSheets[i].cssRules}catch(e){continue}if(!rules)continue;" + "for(var j=0;j<rules.length;j++){var r=rules[j];if(!(r.type===5))continue;" + `var m=/url\\((?:"|')?([^"')\\s]*\\.p\\.woff2)/.exec(r.cssText);if(!m)continue;` + "var u;try{u=new URL(m[1],location.href).href}catch(e){continue}if(seen[u])continue;seen[u]=1;" + 'var l=document.createElement("link");l.rel="preload";l.as="font";l.type="font/woff2";l.setAttribute("crossorigin","");l.href=u;document.head.appendChild(l)}}}' + 'document.readyState==="loading"?document.addEventListener("DOMContentLoaded",a):a()}catch(e){}})();</script>';
+}
+function fontSizeAdjustMeta() {
+  return fontStorage.getStore()?.sizeAdjust === true ? '<meta name="next-size-adjust" content=""/>' : "";
+}
+function stashHeaderPreloads(preloads) {
+  if (preloads.length === 0)
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const compat = unit.compat ??= {};
+  const existing = compat[FONT_HEADER_PRELOADS] ?? [];
+  compat[FONT_HEADER_PRELOADS] = dedupePreloads([...existing, ...preloads]);
+}
+function takeFontHeaderPreloads() {
+  const unit = getWorkUnit();
+  const compat = unit?.compat;
+  if (!compat)
+    return [];
+  const preloads = compat[FONT_HEADER_PRELOADS] ?? [];
+  compat[FONT_HEADER_PRELOADS] = undefined;
+  return preloads;
+}
+var fontFinalizerRegistered = false;
+onExtensionHostReset(() => fontFinalizerRegistered = false);
+function registerFontFinalizerOnce() {
+  if (fontFinalizerRegistered)
+    return;
+  fontFinalizerRegistered = true;
+  registerResponseFinalizers((ctx) => {
+    const preloads = takeFontHeaderPreloads();
+    if (preloads.length === 0)
+      return;
+    const value = preloads.map(fontLinkHeaderValue).join(", ");
+    const existing = ctx.headers.get("link");
+    ctx.headers.set("link", existing ? `${existing}, ${value}` : value);
+  });
+}
+function fontLinkHeaderValue(link) {
+  const parts = [`<${link.url}>`, `rel=${link.rel}`];
+  if (link.as)
+    parts.push(`as=${link.as}`);
+  if (link.type)
+    parts.push(`type=${link.type}`);
+  parts.push('crossorigin=""');
+  return parts.join("; ");
+}
+function googleFont(family) {
+  return (options = {}) => {
+    const naming = googleFontNaming(family, options);
+    const { className, variable, fontFamily, hash, style, hasVariable } = naming;
+    const definition = {
+      className,
+      family: fontFamily,
+      key: `google:${stableJson({ family, options })}`,
+      style,
+      variable,
+      hasVariable,
+      resolve: (context) => resolveGoogleFont(context, {
+        className,
+        family,
+        fontFamily,
+        hash,
+        options,
+        variable
+      })
+    };
+    return fontObject(definition);
+  };
+}
+var localFont = Object.assign((options) => localFontWithFile(inferLocalFontCallerFile())(options), { withFile: localFontWithFile });
+function localFontWithFile(callerFile, family) {
+  return (options) => {
+    const naming = localFontNaming(callerFile, options);
+    if (family) {
+      naming.fontFamily = family;
+      naming.style = fontStyle(family, options, options.fallback ?? []);
+    }
+    const { className, variable, fontFamily, hash, style, hasVariable } = naming;
+    const definition = {
+      className,
+      family: fontFamily,
+      key: `local:${stableJson({ callerFile, options })}`,
+      style,
+      variable,
+      hasVariable,
+      resolve: (context) => resolveLocalFont(context, {
+        callerFile,
+        className,
+        fontFamily,
+        hash,
+        options,
+        variable
+      })
+    };
+    return fontObject(definition);
+  };
+}
+function fontObject(definition) {
+  declaredFonts.set(definition.key, definition);
+  const descriptors = {
+    className: {
+      enumerable: true,
+      get() {
+        registerFont(definition);
+        return definition.className;
+      }
+    },
+    style: {
+      enumerable: true,
+      get() {
+        registerFont(definition);
+        return definition.style;
+      }
+    }
+  };
+  if (definition.hasVariable) {
+    descriptors.variable = {
+      enumerable: true,
+      get() {
+        registerFont(definition);
+        return definition.variable;
+      }
+    };
+  }
+  return Object.defineProperties({}, descriptors);
+}
+function registerFont(definition) {
+  fontStorage.getStore()?.fonts.set(definition.key, definition);
+}
+async function releaseFonts(config) {
+  const fonts = {};
+  for (const font of declaredFonts.values()) {
+    const { sources: _sources, ...resolved } = await resolveFont(font, { config });
+    fonts[font.key] = resolved;
+  }
+  return fonts;
+}
+async function resolveFont(definition, context) {
+  const released = servedRelease()?.fonts?.[definition.key];
+  if (released)
+    return released;
+  const key = `${context.config.outPath}:${context.dev ? "dev" : "build"}:${definition.key}`;
+  let resolved = resolvedFontCache.get(key);
+  if (!resolved) {
+    resolved = resolveThroughCache(definition, context, key);
+    resolvedFontCache.set(key, resolved);
+  }
+  const font = await resolved;
+  if (font.files.every((file) => existsSync(file)))
+    return font;
+  const fresh = resolveAndPersist(definition, context, key);
+  resolvedFontCache.set(key, fresh);
+  return fresh;
+}
+async function resolveThroughCache(definition, context, key) {
+  if (!context.dev)
+    return definition.resolve(context);
+  const persisted = await persistedFont(context.config, key);
+  if (persisted)
+    return persisted;
+  return resolveAndPersist(definition, context, key);
+}
+function resolveAndPersist(definition, context, key) {
+  const resolved = definition.resolve(context);
+  if (context.dev) {
+    resolved.then((font) => persistFont(context.config, key, font)).catch(() => {
+      return;
+    });
+  }
+  return resolved;
+}
+async function resolveGoogleFont(context, request) {
+  const metadata = googleMetadata()[request.family];
+  if (!metadata)
+    throw new Error(`Unknown font \`${request.family}\``);
+  const options = normalizeGoogleOptions(request.family, metadata, request.options);
+  const adjustFontFallback = options.adjustFontFallback;
+  const url = googleFontsUrl(request.family, googleFontAxes(metadata, options), options.display);
+  const css = (await googleCss(url, request.family, Boolean(context.dev))).split("body {", 1)[0] ?? "";
+  const fontFiles = findGoogleFontFiles(css, options.preload ? options.subsets : undefined);
+  const emitted = await Promise.all(fontFiles.map(async (fontFile) => ({
+    ...fontFile,
+    emitted: await emitRemoteFontFile(context, fontFile.googleFontFileUrl, {
+      preload: fontFile.preloadFontFile,
+      adjustFontFallback
+    })
+  })));
+  let rewrittenCss = css;
+  for (const item of emitted) {
+    rewrittenCss = rewrittenCss.replaceAll(item.googleFontFileUrl, item.emitted.url);
+  }
+  const stack = familyStack(request.fontFamily, options.fallback, adjustFontFallback);
+  const scopedCss = [
+    rewriteFontFamily(rewrittenCss, request.family, request.fontFamily),
+    adjustFontFallback ? fallbackFaceCss(request.fontFamily) : "",
+    classRule(request.className, stack, singleCssValue(options.weights), singleCssValue(options.styles)),
+    request.options.variable ? variableRule(request.variable, customProperty(request.options.variable), stack) : ""
+  ].filter(Boolean).join(`
+`);
+  return {
+    usesFonts: emitted.length > 0,
+    sizeAdjust: adjustFontFallback,
+    css: scopedCss,
+    preloads: emitted.filter((item) => item.preloadFontFile).map((item) => fontPreload(item.emitted.url, item.emitted.type)),
+    files: emitted.map((item) => item.emitted.file)
+  };
+}
+async function resolveLocalFont(context, request) {
+  const display = validateDisplay(request.options.display ?? "swap");
+  const adjustFontFallback = request.options.declarations?.some((item) => item.prop === "font-family") ? false : true;
+  const preload = request.options.preload !== false;
+  const sources = normalizeLocalSources(request.options, request.callerFile && path.resolve(context.config.root, request.callerFile));
+  const emitted = await Promise.all(sources.map(async (source) => ({
+    ...source,
+    emitted: await emitLocalFontFile(context, source.file, { preload, adjustFontFallback })
+  })));
+  const stack = familyStack(request.fontFamily, request.options.fallback ?? [], adjustFontFallback);
+  const declarations = request.options.declarations ?? [];
+  const faceCss = emitted.map((source) => [
+    "@font-face{",
+    `font-family:${singleQuoteFamily(request.fontFamily)};`,
+    `src:url("${source.emitted.url}") format("${fontFormat(source.emitted.ext)}");`,
+    `font-display:${display};`,
+    source.weight ?? request.options.weight ? `font-weight:${cssIdentifier(source.weight ?? request.options.weight ?? "")};` : "",
+    source.style ?? request.options.style ? `font-style:${cssIdentifier(source.style ?? request.options.style ?? "")};` : "",
+    ...declarations.map((item) => `${cssProperty(item.prop)}:${cssDeclarationValue(item.value)};`),
+    "}"
+  ].filter(Boolean).join(""));
+  return {
+    usesFonts: emitted.length > 0,
+    sizeAdjust: adjustFontFallback,
+    css: [
+      ...faceCss,
+      adjustFontFallback ? fallbackFaceCss(request.fontFamily) : "",
+      classRule(request.className, stack, request.options.weight, request.options.style),
+      request.options.variable ? variableRule(request.variable, customProperty(request.options.variable), stack) : ""
+    ].filter(Boolean).join(`
+`),
+    preloads: preload ? emitted.map((item) => fontPreload(item.emitted.url, item.emitted.type)) : [],
+    files: emitted.map((item) => item.emitted.file),
+    sources: emitted.map((source) => source.file)
+  };
+}
+function normalizeGoogleOptions(family, metadata, options) {
+  const display = validateDisplay(options.display ?? "swap");
+  const preload = options.preload ?? true;
+  const subsets = options.subsets;
+  if (metadata.subsets.length === 0) {} else if (preload) {
+    if (!subsets) {
+      throw new Error(`Preload is enabled but no subsets were specified for font \`${family}\`. ` + `Please specify subsets or disable preloading.`);
+    }
+    for (const subset of subsets) {
+      if (!metadata.subsets.includes(subset)) {
+        throw new Error(`Unknown subset \`${subset}\` for font \`${family}\`.`);
+      }
+    }
+  }
+  const weights = uniqueArray(options.weight ? arrayValue(options.weight) : []);
+  if (weights.length === 0) {
+    if (metadata.weights.includes("variable"))
+      weights.push("variable");
+    else
+      throw new Error(`Missing weight for font \`${family}\`.`);
+  }
+  if (weights.length > 1 && weights.includes("variable")) {
+    throw new Error(`Unexpected \`variable\` in weight array for font \`${family}\`.`);
+  }
+  for (const weight of weights) {
+    if (!metadata.weights.includes(weight))
+      throw new Error(`Unknown weight \`${weight}\` for font \`${family}\`.`);
+  }
+  const styles = uniqueArray(options.style ? arrayValue(options.style) : []);
+  if (styles.length === 0)
+    styles.push(metadata.styles.length === 1 ? metadata.styles[0] ?? "normal" : "normal");
+  for (const style of styles) {
+    if (!metadata.styles.includes(style))
+      throw new Error(`Unknown style \`${style}\` for font \`${family}\`.`);
+  }
+  if (options.axes) {
+    if (!metadata.weights.includes("variable") || weights[0] !== "variable") {
+      throw new Error("Axes can only be defined for variable fonts.");
+    }
+    const definableAxes = (metadata.axes ?? []).map((axis) => axis.tag).filter((tag) => tag !== "wght");
+    for (const axis of options.axes) {
+      if (!definableAxes.includes(axis))
+        throw new Error(`Invalid axes value \`${axis}\` for font \`${family}\`.`);
+    }
+  }
+  return {
+    axes: options.axes,
+    adjustFontFallback: options.adjustFontFallback ?? true,
+    display,
+    fallback: options.fallback ?? [],
+    preload: metadata.subsets.length === 0 ? false : preload,
+    styles,
+    subsets,
+    variable: options.variable,
+    weights
+  };
+}
+function googleFontAxes(metadata, options) {
+  const hasItalic = options.styles.includes("italic");
+  const hasNormal = options.styles.includes("normal");
+  const ital = hasItalic ? [...hasNormal ? ["0"] : [], "1"] : undefined;
+  if (options.weights[0] !== "variable") {
+    return {
+      ital,
+      wght: options.weights,
+      variableAxes: undefined
+    };
+  }
+  let weightAxis;
+  const variableAxes = [];
+  for (const axis of metadata.axes ?? []) {
+    if (axis.tag === "wght")
+      weightAxis = `${axis.min}..${axis.max}`;
+    else if (options.axes?.includes(axis.tag))
+      variableAxes.push([axis.tag, `${axis.min}..${axis.max}`]);
+  }
+  return {
+    ital,
+    wght: weightAxis ? [weightAxis] : undefined,
+    variableAxes: variableAxes.length > 0 ? variableAxes : undefined
+  };
+}
+function googleFontsUrl(family, axes, display) {
+  const variants = [];
+  if (axes.wght) {
+    for (const wght of axes.wght) {
+      if (!axes.ital) {
+        variants.push([["wght", wght], ...axes.variableAxes ?? []]);
+      } else {
+        for (const ital of axes.ital)
+          variants.push([["ital", ital], ["wght", wght], ...axes.variableAxes ?? []]);
+      }
+    }
+  } else if (axes.variableAxes) {
+    variants.push([...axes.variableAxes]);
+  }
+  if (axes.variableAxes) {
+    for (const variant of variants) {
+      variant.sort(([a], [b]) => {
+        const aLower = a.charCodeAt(0) > 96;
+        const bLower = b.charCodeAt(0) > 96;
+        if (aLower && !bLower)
+          return -1;
+        if (bLower && !aLower)
+          return 1;
+        return a > b ? 1 : -1;
+      });
+    }
+  }
+  let url = `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}`;
+  const firstVariant = variants[0];
+  if (firstVariant) {
+    url += `:${firstVariant.map(([key]) => key).join(",")}@${variants.map((variant) => variant.map(([, value]) => value).join(",")).sort(sortFontVariantValues).join(";")}`;
+  }
+  return `${url}&display=${display}`;
+}
+async function googleCss(url, family, dev) {
+  let cached = googleCssCache.get(url);
+  if (!cached) {
+    cached = fetchGoogleCss(url, family, dev);
+    googleCssCache.set(url, cached);
+  }
+  return cached;
+}
+async function fetchGoogleCss(url, family, dev) {
+  const mocked = mockedGoogleResponse(url);
+  if (typeof mocked === "string")
+    return mocked;
+  const response = await fetch(url, {
+    headers: {
+      "user-agent": "Mozilla/5.0 AppleWebKit/537.36 Chrome/120 Safari/537.36"
+    }
+  });
+  if (!response.ok) {
+    const message = `Failed to fetch font \`${family}\` from Google Fonts: ${response.status} ${response.statusText}`;
+    throw new Error(dev ? `${message}. Use NEXT_FONT_GOOGLE_MOCKED_RESPONSES for offline tests.` : message);
+  }
+  return response.text();
+}
+function findGoogleFontFiles(css, subsetsToPreload) {
+  const fontFiles = [];
+  let currentSubset = "";
+  for (const line of css.split(`
+`)) {
+    const subset = /\/\* (.+?) \*\//.exec(line)?.[1];
+    if (subset) {
+      currentSubset = subset;
+      continue;
+    }
+    const googleFontFileUrl = /src: url\((.+?)\)/.exec(line)?.[1];
+    if (!googleFontFileUrl || fontFiles.some((file) => file.googleFontFileUrl === googleFontFileUrl))
+      continue;
+    fontFiles.push({
+      googleFontFileUrl,
+      preloadFontFile: Boolean(subsetsToPreload?.includes(currentSubset))
+    });
+  }
+  return fontFiles;
+}
+async function emitRemoteFontFile(context, url, emit) {
+  let cached = googleFontFileCache.get(url);
+  if (!cached) {
+    cached = fetchFontFile(url);
+    googleFontFileCache.set(url, cached);
+  }
+  const bytes = await cached;
+  return emitFontBytes(context, bytes, fontExt(url), emit);
+}
+async function fetchFontFile(url) {
+  const mocked = mockedGoogleResponse(url);
+  if (mocked instanceof Uint8Array)
+    return mocked;
+  if (typeof mocked === "string")
+    return new TextEncoder().encode(mocked);
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`Failed to fetch font file from \`${url}\`.`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function emitLocalFontFile(context, file, emit) {
+  const bytes = await readFile(file);
+  return emitFontBytes(context, bytes, fontExt(file), emit, file);
+}
+async function emitFontBytes(context, bytes, ext, emit, sourceFile) {
+  const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+  const filename = `${hash}${emit.adjustFontFallback ? "-s" : ""}${emit.preload ? ".p" : ""}.${ext}`;
+  const mediaSegments = ["_next", "static", "media"];
+  const outDir = path.join(context.config.outPath, "public", ...mediaSegments);
+  const file = path.join(outDir, filename);
+  const asset = {
+    ext,
+    file,
+    type: fontMimeType(ext),
+    url: `/${mediaSegments.join("/")}/${filename}`
+  };
+  if (existsSync(file))
+    return asset;
+  await mkdir(outDir, { recursive: true });
+  if (sourceFile)
+    await copyFile(sourceFile, file);
+  else
+    await writeFile(file, bytes);
+  return asset;
+}
+function normalizeLocalSources(options, callerFile) {
+  if (!callerFile)
+    throw new Error("next/font/local requires PNext server source transforms.");
+  const values = Array.isArray(options.src) ? options.src : [options.src];
+  return values.map((value) => {
+    const item = typeof value === "string" ? { path: value } : value;
+    if (!item.path)
+      throw new Error("next/font/local src entries require a path.");
+    const file = path.resolve(path.dirname(callerFile), item.path);
+    if (!existsSync(file))
+      throw new Error(`Font file not found: ${item.path}`);
+    return { file, style: item.style, weight: item.weight };
+  });
+}
+function inferLocalFontCallerFile() {
+  const stack = new Error().stack;
+  if (!stack)
+    return;
+  for (const line of stack.split(`
+`)) {
+    const file = stackFrameFile(line);
+    if (!file)
+      continue;
+    if (file.replace(/\\/g, "/").includes("/src/compat/next/font/"))
+      continue;
+    return originalSourceFile(file);
+  }
+  return;
+}
+function stackFrameFile(line) {
+  const match = /\(?((?:file:\/\/)?\/[^():]+\.[cm]?[jt]sx?|(?:file:\/\/)?\/[^():]+\.mjs):\d+:\d+\)?/.exec(line);
+  const file = match?.[1];
+  if (!file)
+    return;
+  return file.startsWith("file://") ? fileURLToPath(file) : file;
+}
+function originalSourceFile(file) {
+  const source = sourceComment(file);
+  if (!source)
+    return file;
+  const normalized = source.replace(/\\/g, "/");
+  if (normalized.startsWith("file://"))
+    return fileURLToPath(normalized);
+  if (path.isAbsolute(normalized))
+    return existsSync(normalized) ? normalized : file;
+  const nodeModulesIndex = normalized.indexOf("node_modules/");
+  const relative = nodeModulesIndex === -1 ? normalized : normalized.slice(nodeModulesIndex);
+  const candidate = path.resolve(compiledProjectRoot(file), relative);
+  return existsSync(candidate) ? candidate : file;
+}
+function sourceComment(file) {
+  if (!existsSync(file))
+    return;
+  const firstLine = readFileSync(file, "utf8").split(/\r?\n/, 1)[0]?.trim();
+  return /^\/\/\s+(.+)$/.exec(firstLine ?? "")?.[1];
+}
+function compiledProjectRoot(file) {
+  const marker = `${path.sep}.pnext${path.sep}`;
+  const index = file.indexOf(marker);
+  return index === -1 ? process.cwd() : file.slice(0, index);
+}
+function googleMetadata() {
+  if (!googleMetadataCache) {
+    googleMetadataCache = loadGoogleMetadata();
+  }
+  return googleMetadataCache;
+}
+function loadGoogleMetadata() {
+  const override = process.env.PNEXT_FONT_GOOGLE_METADATA;
+  if (override) {
+    const metadata2 = readGoogleMetadataFile(override);
+    if (metadata2)
+      return metadata2;
+    throw new Error(`Invalid Google font metadata file: ${override}`);
+  }
+  const metadata = tryLoadGoogleMetadata("next-font/google/font-data.json") ?? tryLoadGoogleMetadata("next-font");
+  if (metadata)
+    return metadata;
+  throw new Error("next/font/google requires Google font metadata. Install `next-font`.");
+}
+function tryLoadGoogleMetadata(specifier) {
+  try {
+    const loaded = require2(specifier);
+    const metadata = "googleFontsMetadata" in loaded ? loaded.googleFontsMetadata : ("default" in loaded) ? loaded.default : loaded;
+    return isGoogleMetadata(metadata) ? metadata : undefined;
+  } catch {
+    return;
+  }
+}
+function readGoogleMetadataFile(file) {
+  const metadata = JSON.parse(readFileSync(file, "utf8"));
+  return isGoogleMetadata(metadata) ? metadata : undefined;
+}
+function isGoogleMetadata(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const inter = value.Inter;
+  return Boolean(inter && Array.isArray(inter.weights) && Array.isArray(inter.styles) && Array.isArray(inter.subsets));
+}
+function mockedGoogleResponse(url) {
+  const mockFile = process.env.NEXT_FONT_GOOGLE_MOCKED_RESPONSES;
+  if (!mockFile)
+    return;
+  const mocked = require2(mockFile);
+  const value = mocked[url];
+  if (value === undefined)
+    throw new Error(`Missing mocked response for URL: ${url}`);
+  if (typeof value === "string" && value.startsWith("/") && existsSync(value)) {
+    return new Uint8Array(readFileSync(value));
+  }
+  return value;
+}
+function rewriteFontFamily(css, originalFamily, scopedFamily) {
+  const familyPattern = escapeRegex(originalFamily);
+  return css.replace(new RegExp(`font-family:\\s*(["']?)${familyPattern}\\1`, "g"), `font-family:${singleQuoteFamily(scopedFamily)}`);
+}
+function fallbackFaceCss(family) {
+  return `@font-face{font-family:${singleQuoteFamily(`${family} Fallback`)};src:local("Arial");}`;
+}
+function classRule(className, familyStack2, weight, style) {
+  return [
+    `.${className}{font-family:${familyStack2};`,
+    weight && !isRangeValue(weight) ? `font-weight:${cssIdentifier(weight)};` : "",
+    style && !isRangeValue(style) ? `font-style:${cssIdentifier(style)};` : "",
+    "}"
+  ].join("");
+}
+function variableRule(className, variable, familyStack2) {
+  return `.${className}{${variable}:${familyStack2};}`;
+}
+function fontPreload(url, type) {
+  return { rel: "preload", url, as: "font", type, crossOrigin: "" };
+}
+function fontPreconnect() {
+  return { rel: "preconnect", url: "/", crossOrigin: "" };
+}
+function dedupePreloads(preloads) {
+  const seen = new Set;
+  return preloads.filter((preload) => {
+    if (seen.has(preload.url))
+      return false;
+    seen.add(preload.url);
+    return true;
+  });
+}
+function validateDisplay(value) {
+  if (!allowedDisplayValues.has(value))
+    throw new Error(`Invalid font display value \`${value}\`.`);
+  return value;
+}
+function fontExt(value) {
+  return /\.(woff2?|eot|ttf|otf)(?:[?#]|$)/.exec(value)?.[1] ?? "woff2";
+}
+function fontMimeType(ext) {
+  if (ext === "woff")
+    return "font/woff";
+  if (ext === "ttf")
+    return "font/ttf";
+  if (ext === "otf")
+    return "font/otf";
+  if (ext === "eot")
+    return "application/vnd.ms-fontobject";
+  return "font/woff2";
+}
+function fontFormat(ext) {
+  if (ext === "ttf")
+    return "truetype";
+  if (ext === "otf")
+    return "opentype";
+  return ext;
+}
+function singleCssValue(values) {
+  return values.length === 1 ? values[0] : undefined;
+}
+function isRangeValue(value) {
+  return value.trim().includes(" ");
+}
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function uniqueArray(items) {
+  return [...new Set(items)];
+}
+function customProperty(value) {
+  if (!/^--[-_a-zA-Z0-9]+$/.test(value))
+    throw new Error(`Invalid font variable name: ${value}`);
+  return value;
+}
+function cssIdentifier(value) {
+  if (!/^[-_a-zA-Z0-9. ]+$/.test(value))
+    throw new Error(`Invalid font option value: ${value}`);
+  return value;
+}
+function cssProperty(value) {
+  if (!/^[-_a-zA-Z0-9]+$/.test(value))
+    throw new Error(`Invalid CSS property: ${value}`);
+  return value;
+}
+function cssDeclarationValue(value) {
+  if (/[;{}]/.test(value))
+    throw new Error(`Invalid CSS declaration value: ${value}`);
+  return value;
+}
+function sortFontVariantValues(a, b) {
+  if (a.includes(",") && b.includes(",")) {
+    const [aPrefix, aSuffix] = a.split(",", 2);
+    const [bPrefix, bSuffix] = b.split(",", 2);
+    return aPrefix === bPrefix ? parseInt(aSuffix ?? "0", 10) - parseInt(bSuffix ?? "0", 10) : parseInt(aPrefix ?? "0", 10) - parseInt(bPrefix ?? "0", 10);
+  }
+  return parseInt(a, 10) - parseInt(b, 10);
+}
+
+export { prewarmFonts, runWithFontScope, fontAssets, fontPreloadDomScript, fontSizeAdjustMeta, takeFontHeaderPreloads, registerFontFinalizerOnce, fontLinkHeaderValue, googleFont, localFont, localFontWithFile, releaseFonts };