@likec4/diagram 1.59.4 → 1.61.0

package/dist/search/components/styles.css.mjs

@@ -0,0 +1,55 @@
+import { focusable } from "./_shared.css.mjs";
+import { css } from "@likec4/styles/css";
+
+// src/search/components/styles.css.ts
+const input = css({
+	border: "transparent",
+	background: {
+		base: "transparent",
+		_focusWithin: {
+			base: `mantine.gray[4]/55 !important`,
+			_dark: `mantine.dark[5]/55 !important`
+		},
+		_groupHover: {
+			base: "mantine.gray[3]/35",
+			_dark: "mantine.dark[5]/35"
+		}
+	}
+});
+const pickviewBackdrop = css({
+	position: "absolute",
+	inset: "0",
+	width: "100%",
+	height: "100%",
+	backgroundColor: "[rgb(34 34 34 / 0.7)]",
+	zIndex: "[902]",
+	backdropFilter: "auto",
+	backdropBlur: "10px",
+	_light: { backgroundColor: "[rgb(255 255 255 / 0.6)]" }
+});
+const pickview = css({
+	position: "absolute",
+	top: "[2rem]",
+	left: "[50%]",
+	width: "100%",
+	maxWidth: "[600px]",
+	minWidth: "[200px]",
+	transform: "translateX(-50%)",
+	zIndex: "[903]"
+});
+const pickviewGroup = css({
+	marginTop: "2",
+	"& + &": { marginTop: "[32px]" }
+});
+const scrollArea = css({
+	height: ["100%", "100cqh"],
+	"& .mantine-ScrollArea-viewport": {
+		minHeight: "100%",
+		"& > div": {
+			minHeight: "100%",
+			height: "100%"
+		}
+	}
+});
+
+export { input, pickview, pickviewBackdrop, pickviewGroup };

package/dist/search/components/utils.mjs

@@ -0,0 +1,86 @@
+import { __name } from "../../_virtual/_rolldown/runtime.mjs";
+import { createFuzzySearch } from "../fuzzy.mjs";
+import { focusable } from "./_shared.css.mjs";
+import { isFunction } from "remeda";
+import { preferSummary } from "@likec4/core/types";
+
+// src/search/components/utils.ts
+function stopAndPrevent(e) {
+	e.stopPropagation();
+	e.preventDefault();
+}
+function centerY(element) {
+	const rect = element.getBoundingClientRect();
+	return rect.y + Math.floor(rect.height / 2);
+}
+function moveFocusToSearchInput(from) {
+	if (!from) {
+		console.error("moveFocusToSearchInput: from is null or undefined");
+		return;
+	}
+	const root = from.getRootNode();
+	if (!isFunction(root.querySelector)) {
+		console.error("moveFocusToSearchInput: root.querySelector is not a function");
+		return;
+	}
+	let input = root.querySelector("[data-likec4-search-input]");
+	if (input && root.activeElement !== input) {
+		const length = input.value.length;
+		input.focus();
+		input.setSelectionRange(length, length);
+	}
+}
+function focusToFirstFoundElement(from) {
+	if (!from) {
+		console.error("focusToFirstFoundElement: from is null or undefined");
+		return;
+	}
+	const root = from.getRootNode();
+	if (!isFunction(root.querySelector)) {
+		console.error("focusToFirstFoundElement: root.querySelector is not a function");
+		return;
+	}
+	root.querySelector(`[data-likec4-search] .${focusable}`)?.focus();
+}
+function queryAllFocusable(from, where, selector = `.${focusable}`) {
+	if (!from) {
+		console.error("queryAllFocusable: from is null or undefined");
+		return [];
+	}
+	const root = from.getRootNode();
+	if (!isFunction(root.querySelectorAll)) {
+		console.error("queryAllFocusable: root.querySelectorAll is not a function");
+		return [];
+	}
+	return [...root.querySelectorAll(`[data-likec4-search-${where}] ${selector}`)];
+}
+/**
+* Title of the view prefixed with the folders it belongs to, e.g. `Folder 1 / Folder 2 / View`.
+* Views at the root are returned as is.
+*/
+function viewTitleWithFolder(view) {
+	if (view.folder.isRoot) return view.titleOrUntitled;
+	return [...view.folder.breadcrumbs.map((folder) => folder.title), view.titleOrUntitled].join(" / ");
+}
+/**
+* Fuzzy search over the views (see `createFuzzySearch`): matches the view id, its title with the folder path,
+* and its summary or description.
+*/
+function createViewSearch(views) {
+	return createFuzzySearch(views, [
+		{
+			name: "id",
+			getFn: (view) => view.id
+		},
+		{
+			name: "title",
+			getFn: (view) => viewTitleWithFolder(view)
+		},
+		{
+			name: "description",
+			getFn: (view) => preferSummary(view.$view)?.md ?? ""
+		}
+	]);
+}
+
+export { centerY, createViewSearch, focusToFirstFoundElement, moveFocusToSearchInput, queryAllFocusable, stopAndPrevent, viewTitleWithFolder };

package/dist/search/fuzzy.mjs

@@ -0,0 +1,27 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import Fuse from "fuse.js";
+
+// src/search/fuzzy.ts
+/**
+* Fuzzy search over `items`, with the same settings as the `search-element` tool of the MCP server:
+* a word still matches with a typo ("chekout" finds "checkout") and it may match any of the `keys`.
+*
+* The index is built once. The returned function takes a search string and gives back the items that
+* match every word of it, in their original order (the callers build a tree from the result).
+*/
+function createFuzzySearch(items, keys) {
+	const fuse = new Fuse(items, {
+		useExtendedSearch: true,
+		ignoreLocation: true,
+		threshold: .2,
+		keys
+	});
+	return (search) => {
+		const words = search.match(/[\p{L}\p{M}\p{N}_]+/gu);
+		if (!words) return [];
+		const found = new Set(fuse.search({ $and: words.map((word) => ({ $or: keys.map((key) => ({ [key.name]: word })) })) }).map((result) => result.item));
+		return items.filter((item) => found.has(item));
+	};
+}
+
+export { createFuzzySearch };

package/dist/search/hooks.mjs

@@ -0,0 +1,17 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { useSearchContext } from "./SearchContext.mjs";
+import { useCallback, useDeferredValue } from "react";
+
+// src/search/hooks.ts
+function useNormalizedSearch() {
+	const ctx = useSearchContext();
+	return useDeferredValue(ctx.normalizedSearch);
+}
+function useUpdateSearch() {
+	const { setSearchValue } = useSearchContext();
+	return useCallback((search) => {
+		setSearchValue(search);
+	}, [setSearchValue]);
+}
+
+export { useNormalizedSearch, useUpdateSearch };

package/dist/search/metadata-search.mjs

@@ -0,0 +1,32 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+
+// src/search/metadata-search.ts
+const METADATA_SEARCH_PREFIX = "meta:";
+/**
+* Builds a search query that finds elements with the given metadata key,
+* and optionally the given value: `meta:key` or `meta:key=value`.
+*/
+function metadataSearchQuery(key, value) {
+	return value === void 0 ? `${METADATA_SEARCH_PREFIX}${key}` : `${METADATA_SEARCH_PREFIX}${key}=${value}`;
+}
+function metadataValues(value) {
+	if (Array.isArray(value)) return value.map(String);
+	if (typeof value === "string") return value.includes("\n") ? value.split("\n").map((s) => s.trim()).filter(Boolean) : [value];
+	return [];
+}
+/**
+* Checks if metadata matches a normalized (lowercased) `meta:` search.
+* - `meta:key` matches elements having a key that includes `key`
+* - `meta:key=value` matches elements having exactly `key`, with any value that includes `value`
+*/
+function matchesMetadataSearch(metadata, normalizedSearch) {
+	const query = normalizedSearch.slice(5);
+	if (query === "") return Object.keys(metadata).length > 0;
+	const eq = query.indexOf("=");
+	if (eq < 0) return Object.keys(metadata).some((key) => key.toLowerCase().includes(query));
+	const searchKey = query.slice(0, eq).trim();
+	const searchValue = query.slice(eq + 1).trim();
+	return Object.entries(metadata).some(([key, value]) => key.toLowerCase() === searchKey && (searchValue === "" || metadataValues(value).some((v) => v.toLowerCase().includes(searchValue))));
+}
+
+export { METADATA_SEARCH_PREFIX, matchesMetadataSearch, metadataSearchQuery };

package/dist/search/searchActor.d.mts

@@ -0,0 +1,35 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { Fqn, ViewId } from "@likec4/core/types";
+import { ActorRef, SnapshotFrom, StateMachine } from "xstate";
+export type SearchActorEvent = {
+  type: 'open';
+  search?: string | undefined;
+} | {
+  type: 'close';
+} | {
+  type: 'change.search';
+  search: string;
+} | {
+  type: 'pickview.open';
+  elementFqn: Fqn;
+} | {
+  type: 'navigate.to';
+  viewId: ViewId;
+  focusOnElement?: Fqn | undefined;
+} | {
+  type: 'animation.presence.end';
+} | {
+  type: 'pickview.close';
+};
+export interface SearchContext {
+  openedWithSearch: string | null;
+  searchValue: string;
+  pickViewFor: Fqn | null;
+  navigateTo: {
+    viewId: ViewId;
+    focusOnElement?: Fqn | undefined;
+  } | null;
+}
+export interface SearchActorLogic extends StateMachine<SearchContext, SearchActorEvent, {}, any, any, any, any, 'inactive' | 'opened' | 'pickView' | 'waitAnimationEnd', never, never, any, any, any, any> {}
+export type SearchActorSnapshot = SnapshotFrom<SearchActorLogic>;
+export interface SearchActorRef extends ActorRef<SearchActorSnapshot, SearchActorEvent> {}

package/dist/search/searchActor.mjs

@@ -0,0 +1,103 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { typedSystem } from "../likec4diagram/state/utils.mjs";
+import { assertEvent, assign, enqueueActions, setup } from "xstate";
+
+// src/search/searchActor.ts
+const _searchActorLogic = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	delays: { "MAX_WAIT_ANIMATION_END": 1e3 },
+	actions: {
+		"reset navigateTo": assign(() => ({ navigateTo: null })),
+		"assign navigateTo": assign(({ event }) => {
+			assertEvent(event, ["navigate.to"]);
+			return { navigateTo: {
+				viewId: event.viewId,
+				focusOnElement: event.focusOnElement
+			} };
+		}),
+		"change searchValue": assign({ searchValue: ({ event, context }) => {
+			assertEvent(event, ["change.search", "open"]);
+			return event.search ?? context.searchValue;
+		} }),
+		"reset pickViewFor": assign(() => ({ pickViewFor: null }))
+	}
+}).createMachine({
+	id: "search",
+	context: {
+		openedWithSearch: null,
+		searchValue: "",
+		pickViewFor: null,
+		navigateTo: null
+	},
+	initial: "inactive",
+	states: {
+		inactive: {
+			entry: ["reset navigateTo", "reset pickViewFor"],
+			on: { "open": {
+				target: "opened",
+				actions: [assign({
+					openedWithSearch: ({ event }) => event.search ?? null,
+					searchValue: ({ event, context }) => event.search ?? context.searchValue
+				})]
+			} }
+		},
+		opened: { on: {
+			"open": { actions: "change searchValue" },
+			"change.search": { actions: "change searchValue" },
+			"pickview.open": {
+				target: "pickView",
+				actions: assign({ pickViewFor: ({ event }) => event.elementFqn })
+			},
+			"navigate.to": {
+				target: "waitAnimationEnd",
+				actions: "assign navigateTo"
+			},
+			"close": { target: "inactive" }
+		} },
+		pickView: { on: {
+			"pickview.close": {
+				target: "opened",
+				actions: "reset pickViewFor"
+			},
+			"navigate.to": {
+				target: "waitAnimationEnd",
+				actions: "assign navigateTo"
+			},
+			"close": { target: "inactive" }
+		} },
+		/**
+		* Wait for animation end before triggering navigation
+		* Otherwise, there could be weird artifacts when navigating to large diagrams.
+		*/
+		waitAnimationEnd: {
+			on: { "animation.presence.end": {
+				target: "inactive",
+				actions: enqueueActions(({ context, system, enqueue }) => {
+					const navigateTo = context.navigateTo;
+					if (!navigateTo) return;
+					const diagramActor = typedSystem(system).diagramActorRef;
+					if (navigateTo.focusOnElement) {
+						if (diagramActor.getSnapshot().context.view.id === navigateTo.viewId) {
+							enqueue.sendTo(diagramActor, {
+								type: "focus.node",
+								nodeId: navigateTo.focusOnElement
+							});
+							return;
+						}
+					}
+					enqueue.sendTo(diagramActor, {
+						type: "navigate.to",
+						...navigateTo
+					});
+				})
+			} },
+			after: { MAX_WAIT_ANIMATION_END: { target: "inactive" } }
+		}
+	}
+});
+const searchActorLogic = _searchActorLogic;
+
+export { searchActorLogic };

package/dist/shadowroot/ShadowRoot.mjs

@@ -0,0 +1,206 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { FramerMotionConfig } from "../context/FramerMotionConfig.mjs";
+import { useCallbackRef as useCallbackRef$1 } from "../hooks/useCallbackRef.mjs";
+import { useId as useId$2 } from "../hooks/useId.mjs";
+import { LikeC4MantineProvider } from "../LikeC4MantineProvider.mjs";
+import styles_font_default from "../styles-font2.mjs";
+import styles_default from "../styles2.mjs";
+import { memo, useEffectEvent, useInsertionEffect, useLayoutEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { first, isDefined, isFunction, isString, once } from "remeda";
+import { useColorScheme, useMutationObserverTarget } from "@mantine/hooks";
+import { createPortal } from "react-dom";
+
+// src/shadowroot/ShadowRoot.tsx
+function useShadowRootStyle(instanceId, keepAspectRatio = false) {
+	if (keepAspectRatio === false) return `
+:where([data-likec4-instance="${instanceId}"]) {
+  display: block;
+  box-sizing: border-box;
+  border: 0 solid transparent;
+  background: transparent;
+  padding: 0;
+  margin: 0;
+  overflow: hidden;
+  width: 100%;
+  height: 100%;
+  min-width: 80px;
+  min-height: 80px;
+}`;
+	const width = Math.ceil(keepAspectRatio.width);
+	const height = Math.ceil(keepAspectRatio.height);
+	const isLandscape = width > height;
+	return `
+:where([data-likec4-instance="${instanceId}"]) {
+  display: block;
+  box-sizing: border-box;
+  border: 0 solid transparent;
+  background: transparent;
+  padding: 0;
+  overflow: hidden;
+  aspect-ratio: ${width} / ${height};
+  ${isLandscape ? "" : `
+max-width: min(100%, var(--likec4-view-max-width, ${width}px));
+margin-left: auto;
+margin-right: auto;`}
+  width: ${isLandscape ? "100%" : "auto"};
+  height: ${isLandscape ? "auto" : "100%"};
+  ${isLandscape ? `min-width: 80px;` : `min-height: 80px;`}
+  max-height: min(100%, var(--likec4-view-max-height, ${height}px));
+}`;
+}
+function useInjectLikeC4Font(injectFontCss, styleNonce) {
+	useInsertionEffect(() => {
+		if (injectFontCss && !document.querySelector(`style[data-likec4-font]`)) {
+			const style = document.createElement("style");
+			style.setAttribute("type", "text/css");
+			style.setAttribute("data-likec4-font", "");
+			let nonce;
+			if (isString(styleNonce)) nonce = styleNonce;
+			if (isFunction(styleNonce)) nonce = styleNonce();
+			if (nonce) style.setAttribute("nonce", nonce);
+			style.appendChild(document.createTextNode(styles_font_default));
+			document.head.appendChild(style);
+		}
+	}, []);
+}
+function ShadowRoot({ children, theme, injectFontCss = true, styleNonce, colorScheme: explicitColorScheme, keepAspectRatio = false, ...props }) {
+	const colorScheme = useColorScheme$1(explicitColorScheme);
+	const id = useId$2();
+	const cssstyle = useShadowRootStyle(id, keepAspectRatio);
+	const mantineRootRef = useRef(null);
+	useInjectLikeC4Font(injectFontCss, styleNonce);
+	const getRootElement = useCallbackRef$1(() => mantineRootRef.current ?? void 0);
+	const getStyleNonce = useCallbackRef$1(() => {
+		if (isDefined(styleNonce)) {
+			if (typeof styleNonce === "string") return styleNonce ?? "";
+			else if (typeof styleNonce === "function") return styleNonce() ?? "";
+		}
+		return "";
+	});
+	const nonce = getStyleNonce();
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(MemoizedStyle, {
+		nonce,
+		cssstyle
+	}), /* @__PURE__ */ jsx(ShadowRootHost, {
+		...props,
+		"data-likec4-instance": id,
+		children: /* @__PURE__ */ jsx("div", {
+			ref: mantineRootRef,
+			"data-mantine-color-scheme": colorScheme,
+			className: "likec4-shadow-root",
+			children: /* @__PURE__ */ jsx(LikeC4MantineProvider, {
+				defaultColorScheme: colorScheme,
+				getRootElement,
+				cssVariablesSelector: ".likec4-shadow-root",
+				withCssVariables: true,
+				getStyleNonce,
+				theme,
+				...explicitColorScheme && { forceColorScheme: explicitColorScheme },
+				children: /* @__PURE__ */ jsx(FramerMotionConfig, { children })
+			})
+		})
+	})] });
+}
+/**
+* @internal Memoized styles gives a performance boost during development
+*/
+const MemoizedStyle = memo(({ nonce, cssstyle }) => /* @__PURE__ */ jsx("style", {
+	type: "text/css",
+	...nonce && { nonce },
+	dangerouslySetInnerHTML: { __html: cssstyle }
+}), (a, b) => a.cssstyle === b.cssstyle);
+MemoizedStyle.displayName = "MemoizedStyle";
+const ShadowRootHostPortal = ({ children, root }) => {
+	return createPortal(children, root, "likec4-shadow-root");
+};
+const ShadowRootHost = ({ children, ...props }) => {
+	const hostRef = useRef(null);
+	const [root, setRoot] = useState(null);
+	const styles = shadowScopedCSS();
+	const updateShadowRoot = useEffectEvent((styles) => {
+		setRoot((current) => {
+			const host = hostRef.current;
+			if (!host) return null;
+			if (host.shadowRoot) {
+				try {
+					if (host.shadowRoot.adoptedStyleSheets?.length !== 1) {
+						console.error("Shadow root has unexpected number of style sheets (expected 1, got %d)", host.shadowRoot.adoptedStyleSheets?.length ?? 0);
+						return host.shadowRoot;
+					}
+					host.shadowRoot.adoptedStyleSheets[0].replaceSync(styles);
+				} catch (error) {
+					if (import.meta.env.DEV) console.error(error);
+				}
+				return host.shadowRoot;
+			}
+			try {
+				const shadowRoot = host.attachShadow({
+					mode: "open",
+					delegatesFocus: false
+				});
+				shadowRoot.adoptedStyleSheets = createShadowRootStylesheets(styles);
+				return shadowRoot;
+			} catch (error) {
+				if (import.meta.env.DEV) console.error(error);
+				return current;
+			}
+		});
+	});
+	useLayoutEffect(() => {
+		updateShadowRoot(styles);
+	}, [styles]);
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		ref: hostRef,
+		children: root && /* @__PURE__ */ jsx(ShadowRootHostPortal, {
+			root,
+			children
+		})
+	});
+};
+function scopeStylesToShadowRoot(styles) {
+	return styles.replaceAll(/:where\(\s*:root\s*,\s*:host\s*\)/g, `:where(.likec4-shadow-root)`).replaceAll(":root", `.likec4-shadow-root`).replaceAll(/(^|[{},;]|\*\/)(\s*)body(?=\s*[{,])/g, "$1$2.likec4-shadow-root");
+}
+/**
+* Creates a CSS string with styles scoped to the shadow root
+* @returns CSS string for the shadow root
+*/
+const shadowScopedCSS = once(() => {
+	const scoped = scopeStylesToShadowRoot(styles_default);
+	if (import.meta.env.DEV) {
+		console.log("Shadow root scoped CSS:");
+		console.log(scoped);
+	}
+	return scoped;
+});
+/**
+* Creates a CSSStyleSheet with styles scoped to the shadow root
+*/
+function createShadowRootStylesheets(csstext) {
+	const css = new CSSStyleSheet();
+	css.replaceSync(csstext);
+	return [css];
+}
+const getComputedColorScheme = () => {
+	try {
+		const htmlScheme = window.getComputedStyle(document.documentElement).colorScheme ?? "";
+		const colorScheme = first(htmlScheme.split(" "));
+		if (colorScheme === "light" || colorScheme === "dark") return colorScheme;
+	} catch {}
+	return null;
+};
+const getDocumentElement = () => document.documentElement;
+function useColorScheme$1(explicit) {
+	const preferred = useColorScheme();
+	const [computed, setComputed] = useState(getComputedColorScheme);
+	useMutationObserverTarget(useCallbackRef$1(() => setComputed(getComputedColorScheme)), {
+		attributes: true,
+		childList: false,
+		subtree: false
+	}, getDocumentElement);
+	return explicit ?? computed ?? preferred;
+}
+__name(useColorScheme$1, "useColorScheme");
+
+export { ShadowRoot };

package/dist/styles-font.css

@@ -0,0 +1 @@
+@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/latin-wght-normal.woff2)format("woff2-variations");unicode-range:U+??,U+131,U+152-153,U+2BB-2BC,U+2C6,U+2DA,U+2DC,U+304,U+308,U+329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/cyrillic-wght-normal.woff2)format("woff2-variations");unicode-range:U+301,U+400-45F,U+490-491,U+4B0-4B1,U+2116}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/cyrillic-ext-wght-normal.woff2)format("woff2-variations");unicode-range:U+460-52F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/greek-wght-normal.woff2)format("woff2-variations");unicode-range:U+370-377,U+37A-37F,U+384-38A,U+38C,U+38E-3A1,U+3A3-3FF}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/latin-ext-wght-normal.woff2)format("woff2-variations");unicode-range:U+100-2BA,U+2BD-2C5,U+2C7-2CC,U+2CE-2D7,U+2DD-2FF,U+304,U+308,U+329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/vietnamese-wght-normal.woff2)format("woff2-variations");unicode-range:U+102-103,U+110-111,U+128-129,U+168-169,U+1A0-1A1,U+1AF-1B0,U+300-301,U+303-304,U+308-309,U+323,U+329,U+1EA0-1EF9,U+20AB}

package/dist/styles-font2.mjs

@@ -0,0 +1,4 @@
+// src/styles-font.css?inline
+var styles_font_default = "@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/latin-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+??,U+131,U+152-153,U+2BB-2BC,U+2C6,U+2DA,U+2DC,U+304,U+308,U+329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/cyrillic-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+301,U+400-45F,U+490-491,U+4B0-4B1,U+2116}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/cyrillic-ext-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+460-52F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/greek-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+370-377,U+37A-37F,U+384-38A,U+38C,U+38E-3A1,U+3A3-3FF}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/latin-ext-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+100-2BA,U+2BD-2C5,U+2C7-2CC,U+2CE-2D7,U+2DD-2FF,U+304,U+308,U+329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:IBM Plex Sans Variable;font-style:normal;font-display:swap;font-weight:100 700;src:url(https://cdn.jsdelivr.net/fontsource/fonts/ibm-plex-sans:vf@latest/vietnamese-wght-normal.woff2)format(\"woff2-variations\");unicode-range:U+102-103,U+110-111,U+128-129,U+168-169,U+1A0-1A1,U+1AF-1B0,U+300-301,U+303-304,U+308-309,U+323,U+329,U+1EA0-1EF9,U+20AB}\n";
+
+export { styles_font_default as default };