@plitzi/sdk-shared 0.33.2 → 0.34.1

package/dist/store/index.mjs

@@ -1,6 +1,9 @@
 import e, { DEFAULT_RENDER_SETTINGS as t, useRenderOverride as n } from "./renderSettings.mjs";
-import { createStoreHook as r } from "@plitzi/nexus/react";
+import r from "./actionRuns/actionRunsStore.mjs";
+import { cancelActionRun as i, clearActionRuns as a, recordActionProgress as o, recordActionRun as s, registerActionCanceller as c, releaseActionCanceller as l, updateActionRun as u } from "./actionRuns/actionRunsRecorder.mjs";
+import d from "./actionRuns/useActionRuns.mjs";
+import { createStoreHook as f } from "@plitzi/nexus/react";
 //#region src/store/index.ts
-var { useStore: i, useStoreSync: a, useStoreGetter: o, useStoreSetter: s } = r(), { useStore: c, useStoreSync: l, useStoreGetter: u, useStoreSetter: d } = r(), { useStore: f, useStoreSync: p, useStoreGetter: m, useStoreSetter: h } = r();
+var { useStore: p, useStoreSync: m, useStoreGetter: h, useStoreSetter: g } = f(), { useStore: _, useStoreSync: v, useStoreGetter: y, useStoreSetter: b } = f(), { useStore: x, useStoreSync: S, useStoreGetter: C, useStoreSetter: w } = f();
 //#endregion
-export { t as DEFAULT_RENDER_SETTINGS, f as useBuilderStore, m as useBuilderStoreGetter, h as useBuilderStoreSetter, p as useBuilderStoreSync, i as useCommonStore, o as useCommonStoreGetter, s as useCommonStoreSetter, a as useCommonStoreSync, n as useRenderOverride, e as useRenderSettings, c as useSdkStore, u as useSdkStoreGetter, d as useSdkStoreSetter, l as useSdkStoreSync };
+export { t as DEFAULT_RENDER_SETTINGS, r as actionRunsStore, i as cancelActionRun, a as clearActionRuns, o as recordActionProgress, s as recordActionRun, c as registerActionCanceller, l as releaseActionCanceller, u as updateActionRun, d as useActionRuns, x as useBuilderStore, C as useBuilderStoreGetter, w as useBuilderStoreSetter, S as useBuilderStoreSync, p as useCommonStore, h as useCommonStoreGetter, g as useCommonStoreSetter, m as useCommonStoreSync, n as useRenderOverride, e as useRenderSettings, _ as useSdkStore, y as useSdkStoreGetter, b as useSdkStoreSetter, v as useSdkStoreSync };

package/dist/store/renderSettings.d.ts

@@ -21,6 +21,9 @@ export declare const useRenderOverride: (overrides: RenderSettings) => {
         renderMode: import('..').RenderMode;
         environment: import('..').Environment;
         isHydrating: boolean;
+        hydrated: boolean;
+        overQuota: boolean;
+        testAttributes: boolean;
     };
 };
 export default useRenderSettings;

package/dist/store/renderSettings.mjs

@@ -6,27 +6,39 @@ var n = {
 	debugMode: !1,
 	renderMode: "raw",
 	environment: "main",
-	isHydrating: !1
+	isHydrating: !1,
+	hydrated: !1,
+	overQuota: !1,
+	testAttributes: !0
 }, r = () => {
-	let [[r, i, a, o, s]] = e([
+	let [[r, i, a, o, s, c, l, u]] = e([
 		"render.previewMode",
 		"render.debugMode",
 		"render.renderMode",
 		"render.environment",
-		"render.isHydrating"
+		"render.isHydrating",
+		"render.hydrated",
+		"render.overQuota",
+		"render.testAttributes"
 	]);
 	return t(() => ({
 		previewMode: r ?? n.previewMode,
 		debugMode: i ?? n.debugMode,
 		renderMode: a ?? n.renderMode,
 		environment: o ?? n.environment,
-		isHydrating: s ?? n.isHydrating
+		isHydrating: s ?? n.isHydrating,
+		hydrated: c ?? n.hydrated,
+		overQuota: l ?? n.overQuota,
+		testAttributes: u ?? n.testAttributes
 	}), [
 		r,
 		i,
 		a,
 		o,
-		s
+		s,
+		c,
+		l,
+		u
 	]);
 }, i = (e) => {
 	let n = r();

package/dist/store/tracing/tracingCollector.d.ts

@@ -2,7 +2,7 @@ import { PropChange } from '../../types';
 import { ProfilerOnRenderCallback } from 'react';
 declare const tracingCollector: {
     onRender: ProfilerOnRenderCallback;
-    linkParent: (id: string, parentId: string | undefined) => void;
+    linkParent: (id: string, parentId: string | undefined, elementId: string) => void;
     recordProps: (id: string, changes: PropChange[]) => void;
     recordStoreChange: (change: {
         path: string | undefined;

package/dist/store/tracing/tracingCollector.mjs

@@ -2,32 +2,33 @@ import { previewValue as e } from "./preview.mjs";
 import t from "./tracingStore.mjs";
 import { createRecorder as n } from "@plitzi/nexus";
 //#region src/store/tracing/tracingCollector.ts
-var r = n({ max: 30 }), i = [], a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = !0, l = 0, u = /* @__PURE__ */ new Map(), d = !1, f = !1, p = 0, m = !1, h = !1, g = typeof requestAnimationFrame == "function" ? (e) => {
+var r = n({ max: 30 }), i = [], a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = !0, u = 0, d = /* @__PURE__ */ new Map(), f = !1, p = !1, m = 0, h = !1, g = !1, _ = typeof requestAnimationFrame == "function" ? (e) => {
 	requestAnimationFrame(e);
 } : (e) => {
 	setTimeout(e, 16);
-}, _ = () => {
+}, v = () => {
 	let e = {};
-	for (let [t, n] of s) e[t] = {
+	for (let [t, n] of c) e[t] = {
 		parentId: o.get(t),
-		baseDuration: n
+		baseDuration: n,
+		elementId: s.get(t) ?? t
 	};
 	return e;
-}, v = () => {
-	c && (c = !1, t.setState("tree", _())), t.setState("hydrated", h), t.setState("commits", i);
 }, y = () => {
-	h || (h = !0, f && t.setState("hydrated", !0));
+	l && (l = !1, t.setState("tree", v())), t.setState("hydrated", g), t.setState("commits", i);
 }, b = () => {
-	if (m = !1, a.size > 0) {
+	g || (g = !0, p && t.setState("hydrated", !0));
+}, x = () => {
+	if (h = !1, a.size > 0) {
 		let e = [...a.values()].sort((e, t) => e.timestamp - t.timestamp);
 		a.clear(), i = [...i, ...e], i.length > 200 && (i = i.slice(i.length - 200));
 	}
-	f && v();
-}, x = (e, t) => {
-	(!o.has(e) || o.get(e) !== t) && (c = !0), o.set(e, t);
-}, S = () => {
-	let t = r.entriesSince(l);
-	l = r.lastSeq();
+	p && y();
+}, S = (e, t, n) => {
+	(!o.has(e) || o.get(e) !== t) && (l = !0), o.size >= 2e4 && !o.has(e) && (o.clear(), s.clear(), c.clear(), l = !0), o.set(e, t), s.set(e, n);
+}, C = () => {
+	let t = r.entriesSince(u);
+	u = r.lastSeq();
 	let n = /* @__PURE__ */ new Map();
 	for (let e of t) {
 		if (e.path === void 0) continue;
@@ -41,45 +42,46 @@ var r = n({ max: 30 }), i = [], a = /* @__PURE__ */ new Map(), o = /* @__PURE__
 		path: t,
 		preview: `${e(n.prev)} → ${e(n.next)}`
 	}));
-}, C = {
-	onRender: (e, n, r, i, l, f) => {
-		d || (d = !0, t.setState("enabled", !0)), s.has(e) || (c = !0), s.set(e, i);
-		let h = u.get(e);
-		u.delete(e);
-		let _ = {
+}, w = {
+	onRender: (e, n, r, i, u, p) => {
+		f || (f = !0, t.setState("enabled", !0)), c.has(e) || (l = !0), c.set(e, i);
+		let g = d.get(e);
+		d.delete(e);
+		let v = {
 			id: e,
+			elementId: s.get(e) ?? e,
 			parentId: o.get(e),
 			phase: n,
 			actualDuration: r,
 			baseDuration: i,
-			changedProps: h
-		}, v = a.get(f);
-		v ? (v.elements.push(_), v.elementCount += 1, v.duration = Math.max(v.duration, r)) : (p += 1, a.set(f, {
-			commitId: p,
-			timestamp: f,
+			changedProps: g
+		}, y = a.get(p);
+		y ? (y.elements.push(v), y.elementCount += 1, y.duration = Math.max(y.duration, r)) : (m += 1, a.set(p, {
+			commitId: m,
+			timestamp: p,
 			duration: r,
 			elementCount: 1,
-			elements: [_],
-			causes: S()
-		})), m || (m = !0, g(b));
+			elements: [v],
+			causes: C()
+		})), h || (h = !0, _(x));
 	},
-	linkParent: x,
+	linkParent: S,
 	recordProps: (e, t) => {
-		u.set(e, t);
+		d.set(e, t);
 	},
 	recordStoreChange: (e) => {
 		r.record(e);
 	},
-	setHydrated: y,
+	setHydrated: b,
 	start: () => {
-		f = !0, b(), v();
+		p = !0, x(), y();
 	},
 	stop: () => {
-		f = !1;
+		p = !1;
 	},
 	clear: () => {
-		i = [], a.clear(), l = r.lastSeq(), u.clear(), p = 0, c = !0, v();
+		i = [], a.clear(), u = r.lastSeq(), d.clear(), m = 0, l = !0, y();
 	}
 };
 //#endregion
-export { C as default };
+export { w as default };

package/dist/store/tracing/tracingStore.d.ts

@@ -1,5 +1,18 @@
 import { TracingState } from '../../types';
 export declare const MAX_COMMITS = 200;
+/**
+ * How many element INSTANCES the accumulated tree may hold before it is started over.
+ *
+ * The tree is keyed per instance — a list of ninety rows is ninety nodes — and nothing ever removes one: an element
+ * that unmounts leaves its entry behind, because the collector hears about renders and never about teardowns. Across
+ * a long session of navigating between dense pages that grows without bound, which on the page it is most worth
+ * profiling is the thing that eventually takes the tab down.
+ *
+ * Cleared wholesale rather than pruned, because there is no cheap way to know which entry is stale: the tree is
+ * written on the hot path, once per element per render, and an LRU touch there costs more than the leak. Losing it
+ * costs one commit's worth of hatched ancestors and then rebuilds from the next render.
+ */
+export declare const MAX_TREE_NODES = 20000;
 export declare const MAX_CAUSES = 30;
 export declare const createTracingState: () => TracingState;
 declare const tracingStore: import('@plitzi/nexus').StoreApi<TracingState>;

package/dist/store/tracing/tracingStore.mjs

@@ -1,10 +1,10 @@
 import { createStore as e } from "@plitzi/nexus";
 //#region src/store/tracing/tracingStore.ts
-var t = 200, n = () => ({
+var t = 200, n = 2e4, r = 30, i = () => ({
 	enabled: !1,
 	hydrated: !1,
 	commits: [],
 	tree: {}
-}), r = e(n(), { id: "tracing" });
+}), a = e(i(), { id: "tracing" });
 //#endregion
-export { t as MAX_COMMITS, n as createTracingState, r as default };
+export { r as MAX_CAUSES, t as MAX_COMMITS, n as MAX_TREE_NODES, i as createTracingState, a as default };

package/dist/style/fontAssets.d.ts

@@ -0,0 +1,12 @@
+import { Asset } from '../types/PluginTypes';
+import { FontHead } from '../types/StyleTypes';
+/**
+ * The manifest's stylesheets as the asset rail describes them, for the one surface that renders into a document of
+ * its own: the builder canvas, and the SDK's own iframe render mode. Its `<head>` is reachable only through the rail, so what the SSR template writes and
+ * what a client-only render appends to `document.head` has to arrive there as assets instead.
+ *
+ * Only the stylesheets. The preconnects and preloads are there to save a visitor a round trip on a cold cache, and
+ * the canvas has neither — while `@font-face` blocks cannot ride a `<link>` at all, so they travel with the style
+ * the frame already writes into a `<style>` of its own.
+ */
+export declare const fontLinkAssets: (head: FontHead) => Record<string, Asset>;

package/dist/style/fontAssets.mjs

@@ -0,0 +1,18 @@
+//#region src/style/fontAssets.ts
+var e = (e) => e.links.filter((e) => e.rel === "stylesheet").reduce((e, t, n) => {
+	let r = `font-${n}`;
+	return {
+		...e,
+		[r]: {
+			type: "link",
+			id: r,
+			params: {
+				href: t.href,
+				type: "text/css",
+				rel: "stylesheet"
+			}
+		}
+	};
+}, {});
+//#endregion
+export { e as fontLinkAssets };

package/dist/style/fontValidation.d.ts

@@ -0,0 +1,8 @@
+import { SpaceFont } from '../types/StyleTypes';
+export declare class FontValidationError extends Error {
+}
+/**
+ * Parses and normalizes a manifest entry. Throws {@link FontValidationError} with a message meant to be read by
+ * whoever sent the value — a person in the Fonts panel, or an agent that will try again.
+ */
+export declare const parseSpaceFont: (value: unknown) => SpaceFont;

package/dist/style/fontValidation.mjs

@@ -0,0 +1,107 @@
+import { isSafeFontUrl as e } from "./fonts.mjs";
+//#region src/style/fontValidation.ts
+var t = /* @__PURE__ */ new Set([
+	"system",
+	"google",
+	"remote",
+	"hosted"
+]), n = /* @__PURE__ */ new Set([
+	"auto",
+	"block",
+	"swap",
+	"fallback",
+	"optional"
+]), r = /* @__PURE__ */ new Set(["woff2", "woff"]), i = 100, a = (e) => {
+	for (let t = 0; t < e.length; t += 1) {
+		let n = e.charCodeAt(t);
+		if (n < 32 || n === 127) return !0;
+	}
+	return !1;
+}, o = class extends Error {}, s = (e) => {
+	throw new o(e);
+}, c = (e) => typeof e == "object" && !!e && !Array.isArray(e), l = (e) => {
+	if (typeof e != "string") return s("font.family must be a string");
+	let t = e.trim();
+	return t ? t.length > i ? s(`font.family cannot be longer than ${i} characters`) : a(t) ? s("font.family cannot contain control characters") : t : s("font.family cannot be empty");
+}, u = (e) => {
+	if (e === void 0) return [400];
+	if (!Array.isArray(e) || e.length === 0) return s("font.weights must be a non-empty list of numbers");
+	let t = e.map((e) => typeof e != "number" || !Number.isInteger(e) || e < 1 || e > 1e3 ? s("font.weights must hold whole numbers between 1 and 1000") : e);
+	return [...new Set(t)].sort((e, t) => e - t);
+}, d = (e) => {
+	if (e === void 0) return ["normal"];
+	if (!Array.isArray(e) || e.length === 0) return s("font.styles must be a non-empty list");
+	let t = e.map((e) => e !== "normal" && e !== "italic" ? s("font.styles may only hold \"normal\" or \"italic\"") : e);
+	return [...new Set(t)];
+}, f = (e, t) => {
+	if (!c(e)) return s(`font.files[${t}] must be an object`);
+	let { weight: n, style: i, format: a, unicodeRange: o } = e;
+	if (typeof n != "number" || !Number.isInteger(n) || n < 1 || n > 1e3) return s(`font.files[${t}].weight must be a whole number between 1 and 1000`);
+	if (i !== "normal" && i !== "italic") return s(`font.files[${t}].style must be "normal" or "italic"`);
+	if (typeof a != "string" || !r.has(a)) return s(`font.files[${t}].format must be "woff2" or "woff"`);
+	let l = {
+		weight: n,
+		style: i,
+		format: a
+	};
+	if (o !== void 0) {
+		if (typeof o != "string") return s(`font.files[${t}].unicodeRange must be a string`);
+		l.unicodeRange = o;
+	}
+	return l;
+}, p = (e, t) => typeof e != "string" || !e ? s(`font.files[${t}].path must be a non-empty string`) : e.includes("://") || e.startsWith("/") ? s(`font.files[${t}].path must be relative to the font store, not a URL`) : e.split("/").includes("..") ? s(`font.files[${t}].path cannot climb out of the font store`) : e, m = (e) => !Array.isArray(e) || e.length === 0 ? s("font.files must be a non-empty list") : e, h = (r) => {
+	if (!c(r)) return s("a font must be an object");
+	let { source: i, fallback: a, display: o, preload: h } = r;
+	if (typeof i != "string" || !t.has(i)) return s("font.source must be one of: system, google, remote, hosted");
+	if (typeof a != "string" || !a.trim()) return s("font.fallback is required: it is what renders until the face arrives");
+	if (o !== void 0 && (typeof o != "string" || !n.has(o))) return s("font.display must be one of: auto, block, swap, fallback, optional");
+	if (h !== void 0 && typeof h != "boolean") return s("font.preload must be a boolean");
+	let g = {
+		family: l(r.family),
+		fallback: a.trim(),
+		weights: u(r.weights),
+		styles: d(r.styles),
+		...o === void 0 ? {} : { display: o },
+		...h === void 0 ? {} : { preload: h }
+	};
+	if (i === "system") return {
+		...g,
+		source: "system"
+	};
+	if (i === "google") {
+		let { subsets: e } = r;
+		return e !== void 0 && (!Array.isArray(e) || e.some((e) => typeof e != "string")) ? s("font.subsets must be a list of strings") : {
+			...g,
+			source: "google",
+			...e === void 0 ? {} : { subsets: e }
+		};
+	}
+	if (i === "remote") {
+		let { stylesheet: t, files: n } = r;
+		return t === void 0 && n === void 0 ? s("a remote font needs either a stylesheet URL or the font files themselves") : t === void 0 ? {
+			...g,
+			source: "remote",
+			files: m(n).map((t, n) => {
+				let r = f(t, n), { url: i } = t;
+				return typeof i != "string" || !e(i) ? s(`font.files[${n}].url must be an https URL with no credentials in it`) : {
+					...r,
+					url: i
+				};
+			})
+		} : typeof t != "string" || !e(t) ? s("font.stylesheet must be an https URL with no credentials in it") : {
+			...g,
+			source: "remote",
+			stylesheet: t
+		};
+	}
+	return {
+		...g,
+		source: "hosted",
+		files: m(r.files).map((e, t) => ({
+			...f(e, t),
+			path: p(e.path, t)
+		}))
+	};
+};
+//#endregion
+export { o as FontValidationError, h as parseSpaceFont };

package/dist/style/fonts.d.ts

@@ -0,0 +1,74 @@
+import { FontHead, GoogleFont, SpaceFont, SystemFont } from '../types/StyleTypes';
+/**
+ * The stacks every visitor already has, which is why they are a constant and not rows in each
+ * space document: they cost no bytes, they cannot be uploaded or removed, and a picker that did
+ * not offer them would make "no web font at all" an option nobody could choose.
+ *
+ * The weights are what a system face can be relied on for; anything else is synthesized by the
+ * browser, which is the effect this whole manifest exists to make visible rather than accidental.
+ */
+export declare const SYSTEM_FONTS: SystemFont[];
+/** What a space can actually name: what it declared, over the stacks that are always there. A
+ *  family declared by the space wins, so a space may upload its own "Arial" and mean it. */
+export declare const availableFonts: (fonts: SpaceFont[]) => SpaceFont[];
+/**
+ * A URL out of a space document is a URL a person typed, and it is about to become a `href` or a
+ * `@font-face` src. Nothing but plain https gets through: `javascript:` and `data:` are script in
+ * a link's clothing, and credentials in the authority are a password published to every visitor.
+ */
+export declare const isSafeFontUrl: (value: string) => boolean;
+/** What a `font-family` declaration should say for this font: the family, then what renders until
+ *  it arrives. Quoted unless the name is a single bare identifier, which is what CSS asks for. */
+export declare const fontFamilyStack: (font: SpaceFont) => string;
+/** The family a `font-family` value leads with — the one the manifest is keyed by. The rest of the value is the
+ *  fallback chain, which names nothing this space has to load. */
+export declare const primaryFamily: (value: string) => string;
+/**
+ * One `css2` request for every Google family in the manifest.
+ *
+ * The axis tuples have to be listed in ascending order or the API answers 400, and the families
+ * are sorted for a reason of our own: the URL is a cache key, and two spaces with the same fonts
+ * in a different order should not be two entries in every CDN between here and the visitor.
+ *
+ * `subsets` is deliberately NOT sent. The v1 API took `subset=`; css2 answers with the full set of
+ * unicode-range-split faces and lets the browser fetch only the ranges a page actually uses, which
+ * is strictly better. The field stays on the manifest because mirroring (which downloads files
+ * rather than linking them) does have to know which ranges to keep.
+ */
+export declare const googleCss2Url: (fonts: GoogleFont[]) => string;
+/**
+ * The stylesheet that draws family NAMES in their own typeface — the font picker, and nothing else.
+ *
+ * `text` is what makes it cheap: Google returns faces covering only those glyphs, a few hundred
+ * bytes for a whole list. It is also what makes it useless for a page, so this never renders one.
+ */
+export declare const googleTextSubsetUrl: (families: string[], text: string) => string;
+/**
+ * The `resolveUrl` every surface passes to {@link fontsToHead}: a store-relative path, joined to wherever THIS
+ * deployment serves font files from. `/fonts` by default, which is a self-hosted server serving its own; a cloud
+ * deployment passes its CDN prefix. One joining rule, because the SSR document, the client and the static export
+ * have to agree on the URL down to the slash or they fetch the same face twice.
+ */
+export declare const fontUrlResolver: (baseUrl?: string) => (path: string) => string;
+/**
+ * The families a stylesheet CHOOSES, which is not the same as every family it mentions and not the same as the
+ * ones it loads — that second gap is the whole reason the manifest exists.
+ *
+ * One family per declaration: the rest of a stack is the fallback chain, and a chain is not a choice. Declaring
+ * `SFMono-Regular` because it appears third in a monospace stack would fill a space's manifest with families
+ * nobody picked and nothing should fetch.
+ *
+ * A declaration whose lead is a generic (`sans-serif`, `ui-monospace`) contributes nothing: the browser already
+ * has it. So does one built from a variable — what `var(--font-heading)` resolves to is a fact about the
+ * variables, and the variable's own value is scanned in its place.
+ */
+export declare const familiesInCss: (css: string) => string[];
+/**
+ * Everything a document has to carry so the manifest's families actually render.
+ *
+ * Pure on purpose: SSR writes it into a template, the client writes it into `document.head`, the
+ * builder canvas writes it into its iframe and the static export bakes it in. They disagree about
+ * where a hosted file lives and about nothing else, which is what `resolveUrl` is for — a
+ * store-relative path becomes a CDN URL, a local `/fonts/*` URL, or whatever the export needs.
+ */
+export declare const fontsToHead: (fonts: SpaceFont[], resolveUrl: (path: string) => string) => FontHead;

package/dist/style/fonts.mjs

@@ -0,0 +1,198 @@
+//#region src/style/fonts.ts
+var e = "https://fonts.googleapis.com", t = {
+	woff2: "font/woff2",
+	woff: "font/woff"
+}, n = [
+	{
+		source: "system",
+		family: "system-ui",
+		fallback: "-apple-system, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Arial",
+		fallback: "Helvetica, sans-serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Verdana",
+		fallback: "Geneva, sans-serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Trebuchet MS",
+		fallback: "Helvetica, sans-serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Georgia",
+		fallback: "\"Times New Roman\", serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Times New Roman",
+		fallback: "Times, serif",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "Courier New",
+		fallback: "ui-monospace, monospace",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	},
+	{
+		source: "system",
+		family: "ui-monospace",
+		fallback: "SFMono-Regular, Menlo, Consolas, monospace",
+		weights: [400, 700],
+		styles: ["normal", "italic"]
+	}
+], r = (e) => {
+	let t = new Set(e.map((e) => e.family));
+	return [...e, ...n.filter((e) => !t.has(e.family))];
+}, i = (e) => {
+	try {
+		let t = new URL(e);
+		return t.protocol === "https:" && !t.username && !t.password;
+	} catch {
+		return !1;
+	}
+}, a = (e) => {
+	try {
+		return new URL(e).origin;
+	} catch {
+		return;
+	}
+}, o = {
+	"<": "\\3c ",
+	">": "\\3e "
+}, s = (e) => `"${e.replace(/[\\"<>]/g, (e) => o[e] ?? `\\${e}`)}"`, c = /^U\+[0-9A-Fa-f?]{1,6}(-[0-9A-Fa-f]{1,6})?(\s*,\s*U\+[0-9A-Fa-f?]{1,6}(-[0-9A-Fa-f]{1,6})?)*$/, l = (e) => /^[a-zA-Z][a-zA-Z0-9-]*$/.test(e), u = (e) => {
+	let t = l(e.family) ? e.family : s(e.family);
+	return e.fallback ? `${t}, ${e.fallback}` : t;
+}, d = (e) => (e.split(",")[0] ?? "").trim().replace(/^['"]|['"]$/g, "").trim(), f = (e) => {
+	let t = [...new Set(e.weights)].filter((e) => Number.isFinite(e)).sort((e, t) => e - t);
+	return t.length > 0 ? t : [400];
+}, p = (e) => encodeURIComponent(e).replace(/%20/g, "+"), m = (t) => {
+	let n = [...t].sort((e, t) => e.family.localeCompare(t.family)).map((e) => {
+		let t = f(e);
+		if (!e.styles.includes("italic")) return `family=${p(e.family)}:wght@${t.join(";")}`;
+		let n = [0, 1].flatMap((e) => t.map((t) => `${e},${t}`));
+		return `family=${p(e.family)}:ital,wght@${n.join(";")}`;
+	}), r = [...new Set(t.map((e) => e.display ?? "swap"))], i = r.length === 1 ? r[0] : "swap";
+	return `${e}/css2?${n.join("&")}&display=${i}`;
+}, h = (t, n) => `${e}/css2?${[...t].sort((e, t) => e.localeCompare(t)).map((e) => `family=${p(e)}`).join("&")}&text=${encodeURIComponent(n)}&display=swap`, g = "/fonts", _ = (e = g) => (t) => `${e.replace(/\/+$/, "")}/${t.replace(/^\/+/, "")}`, v = /* @__PURE__ */ new Set([
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui",
+	"ui-serif",
+	"ui-sans-serif",
+	"ui-monospace",
+	"ui-rounded",
+	"math",
+	"emoji",
+	"fangsong",
+	"inherit",
+	"initial",
+	"revert",
+	"revert-layer",
+	"unset"
+]), y = (e) => {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.matchAll(/font-family\s*:\s*([^;}]+)/g)) {
+		let e = n[1];
+		if (e.includes("var(")) continue;
+		let r = d(e);
+		r && !v.has(r.toLowerCase()) && t.add(r);
+	}
+	return [...t];
+}, b = (e, t) => [
+	"@font-face{",
+	`font-family:${s(e.family)};`,
+	`font-style:${t.style === "italic" ? "italic" : "normal"};`,
+	`font-weight:${Number.parseInt(String(t.weight), 10) || 400};`,
+	`font-display:${e.display ?? "swap"};`,
+	`src:url(${s(t.url)}) format(${s(t.format)});`,
+	t.unicodeRange && c.test(t.unicodeRange) ? `unicode-range:${t.unicodeRange};` : "",
+	"}"
+].join(""), x = (n, r) => {
+	let o = [], s = [], c = [], l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = (e, t) => {
+		e && (u.add(e), l.set(e, (l.get(e) ?? !1) || t));
+	}, f = n.filter((e) => e.source === "google");
+	if (f.length > 0) {
+		let t = m(f);
+		d(e, !1), d("https://fonts.gstatic.com", !0), f.some((e) => e.preload) && s.push({
+			href: t,
+			rel: "preload",
+			as: "style"
+		}), o.push({
+			href: t,
+			rel: "stylesheet"
+		});
+	}
+	return n.forEach((e) => {
+		if (e.source === "remote" && e.stylesheet && i(e.stylesheet)) {
+			d(a(e.stylesheet), !1), e.preload && s.push({
+				href: e.stylesheet,
+				rel: "preload",
+				as: "style"
+			}), o.push({
+				href: e.stylesheet,
+				rel: "stylesheet"
+			});
+			return;
+		}
+		if (e.source === "remote" && e.files) {
+			e.files.filter((e) => i(e.url)).forEach((n) => {
+				d(a(n.url), !0), c.push(b(e, {
+					...n,
+					url: n.url
+				})), e.preload && s.push({
+					href: n.url,
+					rel: "preload",
+					as: "font",
+					type: t[n.format],
+					crossorigin: !0
+				});
+			});
+			return;
+		}
+		e.source === "hosted" && e.files.forEach((n) => {
+			let i = r(n.path);
+			d(a(i), !0), c.push(b(e, {
+				...n,
+				url: i
+			})), e.preload && s.push({
+				href: i,
+				rel: "preload",
+				as: "font",
+				type: t[n.format],
+				crossorigin: !0
+			});
+		});
+	}), {
+		preconnect: [...l].map(([e, t]) => t ? {
+			href: e,
+			crossorigin: t
+		} : { href: e }),
+		links: [...s, ...o],
+		faces: c.join(""),
+		origins: [...u]
+	};
+};
+//#endregion
+export { n as SYSTEM_FONTS, r as availableFonts, y as familiesInCss, u as fontFamilyStack, _ as fontUrlResolver, x as fontsToHead, m as googleCss2Url, h as googleTextSubsetUrl, i as isSafeFontUrl, d as primaryFamily };