@at-flux/astro-feature-flags 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1107 @@
+import { t as DEV_TOOLBAR_FLAG_ICON_SVG } from "./dev-toolbar-flag-icon-BHCQJ53N.mjs";
+import { longestMatchingRoutePrefix, mergeFlagsWithProcessEnvOverrides, resolveFeatureFlagsByEnvironment, resolveFeatureRuntime, routePathsToPrune, routePatternToPrefix, shouldIncludeRoute, toEnumKey, toToken } from "./runtime.mjs";
+import { readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "node-html-parser";
+//#region src/badge-layout.ts
+function clampPercent(n, fallback) {
+	if (typeof n !== "number" || Number.isNaN(n)) return fallback;
+	return Math.min(100, Math.max(0, n));
+}
+function normalizeElementBadgeLayout(input) {
+	const v = clampPercent(input?.elementBadgeVerticalShiftPercent ?? 80, 80);
+	const anchor = input?.elementBadgeVerticalAnchor === "bottom" ? "bottom" : "top";
+	const hp = input?.elementBadgeHorizontalPercent;
+	if (hp !== void 0 && hp !== null && typeof hp === "number") return {
+		mode: "percent",
+		horizontalPercent: clampPercent(hp, 50),
+		verticalShiftPercent: v,
+		verticalAnchor: anchor
+	};
+	return {
+		mode: "align",
+		horizontalAlign: input?.elementBadgeHorizontalAlign === "start" || input?.elementBadgeHorizontalAlign === "center" ? input.elementBadgeHorizontalAlign : "end",
+		verticalShiftPercent: v,
+		verticalAnchor: anchor
+	};
+}
+const INSET = "0.35rem";
+/**
+* `left` / `right` / `top` | `bottom` / `transform` for the element `::before` badge (no trailing newline).
+*/
+function elementBadgePositionBlock(layout) {
+	const { verticalShiftPercent: v, verticalAnchor } = layout;
+	const y = verticalAnchor === "top" ? `translateY(calc(-1 * ${v}%))` : `translateY(${v}%)`;
+	if (layout.mode === "percent") {
+		const h = layout.horizontalPercent;
+		if (verticalAnchor === "top") return `  left: ${h}%;
+  right: auto;
+  top: 0;
+  bottom: auto;
+  transform: translateX(-50%) ${y};`;
+		return `  left: ${h}%;
+  right: auto;
+  bottom: 0;
+  top: auto;
+  transform: translateX(-50%) ${y};`;
+	}
+	const { horizontalAlign } = layout;
+	if (horizontalAlign === "center") {
+		if (verticalAnchor === "top") return `  left: 50%;
+  right: auto;
+  top: 0;
+  bottom: auto;
+  transform: translateX(-50%) ${y};`;
+		return `  left: 50%;
+  right: auto;
+  bottom: 0;
+  top: auto;
+  transform: translateX(-50%) ${y};`;
+	}
+	if (horizontalAlign === "start") {
+		if (verticalAnchor === "top") return `  left: ${INSET};
+  right: auto;
+  top: 0;
+  bottom: auto;
+  transform: ${y};`;
+		return `  left: ${INSET};
+  right: auto;
+  bottom: 0;
+  top: auto;
+  transform: ${y};`;
+	}
+	if (verticalAnchor === "top") return `  left: auto;
+  right: ${INSET};
+  top: 0;
+  bottom: auto;
+  transform: ${y};`;
+	return `  left: auto;
+  right: ${INSET};
+  bottom: 0;
+  top: auto;
+  transform: ${y};`;
+}
+//#endregion
+//#region src/inline-script.ts
+function compactInlineScript(source) {
+	return source.split("\n").map((line) => line.trim()).filter((line, idx, arr) => line.length > 0 || idx > 0 && idx < arr.length - 1).join("\n").trim();
+}
+function inlineInvoke(fn, payload) {
+	return compactInlineScript(`(${fn.toString()})(${JSON.stringify(payload)});`);
+}
+//#endregion
+//#region src/dev-inline-runtimes.ts
+function affHeadInlineRuntime(payload) {
+	const toPrefix = (pattern) => {
+		let p = String(pattern || "").trim();
+		if (p.endsWith("/**")) p = p.slice(0, -3);
+		else if (p.endsWith("/*")) p = p.slice(0, -2);
+		else if (p.length > 1 && p.endsWith("*")) p = p.slice(0, -1);
+		return p.endsWith("/") ? p : `${p}/`;
+	};
+	try {
+		const { featureFlagStyles, routeFlags: RF, flagNameToToken: M } = payload;
+		const s = document.createElement("style");
+		s.setAttribute("data-astro-feature-flags", "");
+		s.textContent = featureFlagStyles;
+		(document.head || document.documentElement).appendChild(s);
+		const affPath = () => {
+			let p = typeof location !== "undefined" && location.pathname ? location.pathname : "/";
+			if (!p.endsWith("/")) p += "/";
+			return p;
+		};
+		const affFlagNames = (pathname) => {
+			let p = pathname || "/";
+			if (!p.endsWith("/")) p += "/";
+			const out = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const rp in RF) {
+				if (!Object.prototype.hasOwnProperty.call(RF, rp)) continue;
+				const route = toPrefix(rp);
+				if (!(p === route || p.indexOf(route) === 0)) continue;
+				const fns = RF[rp] || [];
+				for (let i = 0; i < fns.length; i++) {
+					const fn = fns[i];
+					if (fn && !seen.has(fn)) {
+						seen.add(fn);
+						out.push(fn);
+					}
+				}
+			}
+			return out;
+		};
+		const affTokens = (pathname) => affFlagNames(pathname).map((name) => M[name]).filter(Boolean);
+		const affSyncDisabledOverlay = () => {
+			const root = document.documentElement;
+			if (!document.body) return;
+			const names = affFlagNames(affPath());
+			const disabled = [];
+			for (let i = 0; i < names.length; i++) {
+				const tk = M[names[i]];
+				if (!tk) continue;
+				if (root.getAttribute(`data-ff-enabled-${tk}`) === "off") disabled.push(tk);
+			}
+			const id = "aff-route-disabled-overlay";
+			let el = document.getElementById(id);
+			if (!disabled.length) {
+				if (el) el.remove();
+				root.removeAttribute("data-aff-route-disabled");
+				return;
+			}
+			root.setAttribute("data-aff-route-disabled", "");
+			if (!el) {
+				el = document.createElement("div");
+				el.id = id;
+				el.className = "aff-route-disabled-overlay";
+				const p = document.createElement("p");
+				el.appendChild(p);
+				document.body.appendChild(el);
+			}
+			const pEl = el.querySelector("p") || el;
+			const flagsText = disabled.join(", ");
+			pEl.textContent = `${disabled.length === 1 ? `Page disabled: ${flagsText} flag is disabled.` : `Page disabled: ${flagsText} flags are disabled.`}\nIn production builds, pages with disabled flags like this will not be emitted`;
+		};
+		const affApply = () => {
+			document.documentElement.setAttribute("data-ff-route", affTokens(affPath()).join(" "));
+			affSyncDisabledOverlay();
+		};
+		affApply();
+		if (typeof MutationObserver === "function") new MutationObserver((muts) => {
+			for (let i = 0; i < muts.length; i++) {
+				const a = muts[i] && muts[i].attributeName;
+				if (a === "data-ff-route" || a && a.indexOf("data-ff-enabled-") === 0) {
+					affSyncDisabledOverlay();
+					break;
+				}
+			}
+		}).observe(document.documentElement, { attributes: true });
+		document.addEventListener("astro:page-load", affApply);
+		document.addEventListener("astro:after-swap", affApply);
+	} catch {}
+}
+function affDevBootstrapRuntime(payload) {
+	const toPrefix = (pattern) => {
+		let p = String(pattern || "").trim();
+		if (p.endsWith("/**")) p = p.slice(0, -3);
+		else if (p.endsWith("/*")) p = p.slice(0, -2);
+		else if (p.length > 1 && p.endsWith("*")) p = p.slice(0, -1);
+		return p.endsWith("/") ? p : `${p}/`;
+	};
+	const T = payload.flagTokens;
+	const C = payload.colors;
+	const OD = payload.outlineDefaults;
+	const BD = payload.badgeDefaults;
+	const RF = payload.routeFlags;
+	const F2T = payload.flagNameToToken;
+	const N = payload.namespace;
+	const K = `${N}.dev.v1`;
+	const root = document.documentElement;
+	const isEnabled = (tk) => root.getAttribute(`data-ff-enabled-${tk}`) !== "off";
+	const currentTokenColor = (tk, cols) => {
+		return root.style.getPropertyValue(`--${N}-c-${tk}`).trim() || cols[tk] || C[tk] || "#94a3b8";
+	};
+	const unique = (a) => [...new Set(a.filter(Boolean))];
+	const comboTokens = (el) => {
+		let out = [];
+		const raw = (el.getAttribute(`data-${N}`) || "").trim();
+		if (raw) out = out.concat(raw.split(/\s+/).filter(Boolean));
+		for (let i = 0; i < T.length; i++) {
+			const tk = T[i];
+			if (el.hasAttribute(`data-${N}-${tk}`)) out.push(tk);
+		}
+		return unique(out);
+	};
+	const stripBooleanFlagAttrs = (el) => {
+		for (let i = 0; i < T.length; i++) el.removeAttribute(`data-${N}-${T[i]}`);
+	};
+	const clearComboVisualState = (el) => {
+		el.removeAttribute("data-ff-label");
+		el.style.removeProperty("--ff-combo-gradient");
+		el.style.removeProperty("--ff-combo-gradient-soft");
+		el.style.removeProperty("--ff-combo-outline");
+		el.style.removeProperty("--ff-combo-text");
+		el.style.removeProperty("--ff-combo-badge-border");
+		el.style.removeProperty("--ff-combo-badge-gradient");
+	};
+	const applyCombo = (el, cols) => {
+		const allTokens = comboTokens(el);
+		const hasCombo = allTokens.length >= 2;
+		const hasDisabledInCombo = hasCombo && allTokens.some((tk) => !isEnabled(tk));
+		const visual = allTokens.filter((tk) => isEnabled(tk));
+		if (hasDisabledInCombo) {
+			stripBooleanFlagAttrs(el);
+			el.setAttribute(`data-${N}`, allTokens.join(" "));
+			clearComboVisualState(el);
+			return;
+		}
+		if (visual.length < 2) {
+			clearComboVisualState(el);
+			if (hasCombo) {
+				stripBooleanFlagAttrs(el);
+				if (visual.length === 1) el.setAttribute(`data-${N}`, visual[0]);
+				else el.removeAttribute(`data-${N}`);
+			}
+			return;
+		}
+		stripBooleanFlagAttrs(el);
+		el.setAttribute(`data-${N}`, visual.join(" "));
+		el.setAttribute("data-ff-label", visual.join(" | "));
+		const strong = visual.map((tk) => currentTokenColor(tk, cols));
+		const soft = strong.map((c) => `color-mix(in oklab, white 86%, ${c} 14%)`);
+		el.style.setProperty("--ff-combo-gradient", `linear-gradient(90deg, ${strong.join(", ")})`);
+		el.style.setProperty("--ff-combo-gradient-soft", `linear-gradient(90deg, ${soft.join(", ")})`);
+		el.style.setProperty("--ff-combo-outline", strong[0] || "#64748b");
+		el.style.setProperty("--ff-combo-text", strong[0] || "#111827");
+		el.style.setProperty("--ff-combo-badge-border", `color-mix(in oklab, ${strong[0] || "#64748b"} 35%, transparent)`);
+		el.style.setProperty("--ff-combo-badge-gradient", `linear-gradient(90deg, ${soft.join(", ")})`);
+	};
+	const routeTokensForPath = (path) => {
+		const out = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const rp in RF) {
+			if (!Object.prototype.hasOwnProperty.call(RF, rp)) continue;
+			const cnd = toPrefix(rp);
+			if (!(path === cnd || path.indexOf(cnd) === 0)) continue;
+			const fns = RF[rp] || [];
+			for (let i = 0; i < fns.length; i++) {
+				const tk = F2T[fns[i]];
+				if (tk && !seen.has(tk)) {
+					seen.add(tk);
+					out.push(tk);
+				}
+			}
+		}
+		return out;
+	};
+	const routeLabelFor = (path, toks) => {
+		if (!toks.length) return "";
+		const byFlag = {};
+		for (const rp in RF) {
+			if (!Object.prototype.hasOwnProperty.call(RF, rp)) continue;
+			const cnd = toPrefix(rp);
+			if (!(path === cnd || path.indexOf(cnd) === 0)) continue;
+			const fns = RF[rp] || [];
+			for (let i = 0; i < fns.length; i++) {
+				const tk = F2T[fns[i]];
+				if (!tk) continue;
+				if (!byFlag[tk]) byFlag[tk] = [];
+				byFlag[tk].push(rp);
+			}
+		}
+		return `Page: ${toks.map((tk) => `${tk} - ${(byFlag[tk] || []).join(", ") || "matched"}`).join(" | ")}`;
+	};
+	const affSyncRouteChrome = (path) => {
+		if (!document.body) return;
+		const routeAll = routeTokensForPath(path);
+		if (!routeAll.length) {
+			document.getElementById("aff-route-frame")?.remove();
+			document.getElementById("aff-route-badge")?.remove();
+			root.removeAttribute("data-ff-route");
+			root.removeAttribute("data-ff-route-label");
+			return;
+		}
+		root.setAttribute("data-ff-route", routeAll.join(" "));
+		root.setAttribute("data-ff-route-label", routeLabelFor(path, routeAll));
+		if (!document.getElementById("aff-route-frame")) {
+			const frame = document.createElement("div");
+			frame.id = "aff-route-frame";
+			frame.className = "aff-route-frame";
+			frame.setAttribute("aria-hidden", "true");
+			document.body.appendChild(frame);
+		}
+		let badge = document.getElementById("aff-route-badge");
+		if (!badge) {
+			badge = document.createElement("div");
+			badge.id = "aff-route-badge";
+			badge.className = "aff-route-badge";
+			badge.setAttribute("role", "status");
+			document.body.appendChild(badge);
+		}
+		badge.textContent = root.getAttribute("data-ff-route-label") || "";
+		badge.setAttribute("aria-label", badge.textContent || "");
+	};
+	try {
+		window.__AFF__ = {
+			tokens: T,
+			colors: C,
+			namespace: N
+		};
+		const raw = localStorage.getItem(K) || localStorage.getItem("aff.dev.v1");
+		const st = raw ? JSON.parse(raw) : {};
+		const o = st.outline || st.chrome || {};
+		const e = st.enabled || st.render || {};
+		const b = st.badge || {};
+		const cols = st.colors || {};
+		for (let i = 0; i < T.length; i++) {
+			const t = T[i];
+			const od = OD[t] !== false;
+			const bd = BD[t] !== false;
+			if (o[t] === false || !od && o[t] !== true) root.setAttribute(`data-ff-outline-${t}`, "off");
+			else root.removeAttribute(`data-ff-outline-${t}`);
+			if (e[t] === false) root.setAttribute(`data-ff-enabled-${t}`, "off");
+			else root.removeAttribute(`data-ff-enabled-${t}`);
+			if (b[t] === false || !bd && b[t] !== true) root.setAttribute(`data-ff-badge-${t}`, "off");
+			else root.removeAttribute(`data-ff-badge-${t}`);
+			const col = cols[t] || C[t];
+			const vn = `--${N}-c-${t}`;
+			if (col) root.style.setProperty(vn, col);
+			else root.style.removeProperty(vn);
+		}
+		const applyAll = () => {
+			const map = /* @__PURE__ */ new Set();
+			document.querySelectorAll(`[data-${N}]`).forEach((el) => map.add(el));
+			for (let i = 0; i < T.length; i++) document.querySelectorAll(`[data-${N}-${T[i]}]`).forEach((el) => map.add(el));
+			map.forEach((el) => applyCombo(el, cols));
+		};
+		const affAfterNav = () => {
+			if (!document.body) return;
+			let p = window.location?.pathname || "/";
+			if (!p.endsWith("/")) p += "/";
+			const toks = routeTokensForPath(p).filter((tk) => isEnabled(tk));
+			if (toks.length) {
+				const strong = toks.map((tk) => currentTokenColor(tk, cols));
+				const soft = strong.map((c) => `color-mix(in oklab, white 86%, ${c} 14%)`);
+				root.style.setProperty(`--${N}-route-gradient`, `linear-gradient(90deg, ${soft.join(", ")})`);
+				root.style.setProperty("--ff-route-outline-gradient", `linear-gradient(90deg, ${strong.join(", ")})`);
+				root.style.setProperty("--ff-route-badge-gradient", `linear-gradient(90deg, ${soft.join(", ")})`);
+				root.style.setProperty("--ff-route-badge-border", `color-mix(in oklab, ${strong[0] || "#64748b"} 35%, transparent)`);
+				root.style.setProperty("--ff-route-outline", strong[0] || "#64748b");
+				root.style.setProperty("--ff-route-text", strong[0] || "#111827");
+			} else {
+				root.style.removeProperty(`--${N}-route-gradient`);
+				root.style.removeProperty("--ff-route-outline-gradient");
+				root.style.removeProperty("--ff-route-badge-gradient");
+				root.style.removeProperty("--ff-route-badge-border");
+				root.style.removeProperty("--ff-route-outline");
+				root.style.removeProperty("--ff-route-text");
+			}
+			applyAll();
+			affSyncRouteChrome(p);
+		};
+		affAfterNav();
+		if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", affAfterNav, { once: true });
+		document.addEventListener("astro:page-load", affAfterNav);
+		document.addEventListener("astro:after-swap", affAfterNav);
+		if (typeof MutationObserver === "function") new MutationObserver((muts) => {
+			for (let i = 0; i < muts.length; i++) {
+				const a = muts[i]?.attributeName;
+				if (!a) continue;
+				if (a === "style" || a.indexOf("data-ff-enabled-") === 0 || a.indexOf("data-ff-outline-") === 0 || a.indexOf("data-ff-badge-") === 0) {
+					affAfterNav();
+					break;
+				}
+			}
+		}).observe(root, { attributes: true });
+	} catch {}
+}
+//#endregion
+//#region src/dev-outline-css.ts
+const defaultDevOutlineCssOptions = {
+	outlineWidth: "2px",
+	outlineColor: "rgb(220 38 38)",
+	outlineOffset: "-2px",
+	borderRadius: "0.5rem",
+	badgeLabelWip: "wip",
+	badgeLabelByToken: {},
+	hiddenStrategy: "visibility",
+	badgeMinInlineSize: "8rem"
+};
+function normalizeCssOptions(css, runtime) {
+	const byToken = {
+		...runtime.flagColorsByToken,
+		...css?.outlineColorByToken ?? {}
+	};
+	const badgeLabelWip = css?.badgeLabelWip ?? css?.badgeLabelDev ?? defaultDevOutlineCssOptions.badgeLabelWip;
+	return {
+		...defaultDevOutlineCssOptions,
+		...css ?? {},
+		outlineColorByToken: byToken,
+		badgeLabelWip,
+		badgeLabelByToken: {
+			...defaultDevOutlineCssOptions.badgeLabelByToken,
+			...css?.badgeLabelByToken ?? {}
+		}
+	};
+}
+function colorForToken(token, opts) {
+	return opts.outlineColorByToken[token] ?? opts.outlineColor;
+}
+/** CSS variable per token, set on &lt;html&gt; from ff.json + dev-toolbar overrides. */
+function featureColorVar(token, namespace) {
+	return `--${toToken(namespace) || "ff"}-c-${token}`;
+}
+/**
+* Dev-only styles: `data-ff="token"` (or space-separated tokens) gates outlines/badges.
+* `html[data-ff-route="<token>"]` (dev) adds a fixed top-right route badge (label only).
+* Toolbar toggles: `data-ff-enabled-*`, `data-ff-outline-*`, `data-ff-badge-*`, `--<namespace>-c-*`.
+*/
+function createFeatureFlagStyles(runtime, css) {
+	const nsAttr = `data-${toToken(runtime.namespace) || "ff"}`;
+	const selectorsForFlag = (flag) => {
+		const token = toToken(flag);
+		const valueSelectors = [`[${nsAttr}~="${token}"]`];
+		if (flag !== token) valueSelectors.push(`[${nsAttr}~="${flag}"]`);
+		const baseSelectors = [...valueSelectors, `[${nsAttr}-${token}]`];
+		return {
+			token,
+			baseSelectors,
+			selOutline: baseSelectors.map((s) => `${s}:not([${nsAttr}*=" "])`).join(", "),
+			selIs: `:is(${baseSelectors.join(", ")})`
+		};
+	};
+	const opts = normalizeCssOptions(css, runtime);
+	const badgePos = elementBadgePositionBlock(normalizeElementBadgeLayout(css));
+	const chunks = [];
+	for (const flag of Object.keys(runtime.flags)) {
+		const { token, selOutline, selIs } = selectorsForFlag(flag);
+		/** Combo hosts use `[${nsAttr}*=" "]` + `data-ff-label`; skip per-token ::before so combo rules win. */
+		const selIsSingleBadge = `${selIs}:not([${nsAttr}*=" "])`;
+		const col = colorForToken(token, opts);
+		const v = featureColorVar(token, runtime.namespace);
+		const label = opts.badgeLabelByToken[token] ?? (token === "wip" ? opts.badgeLabelWip : token);
+		const labelEscaped = String(label).replace(/'/g, "\\'");
+		chunks.push(`
+html {
+  --aff-outline-c-${token}: transparent;
+}
+html:not([data-ff-outline-${token}="off"]) {
+  --aff-outline-c-${token}: var(${v}, ${col});
+}
+${selOutline} {
+  position: relative;
+  outline: ${opts.outlineWidth} solid var(--aff-outline-c-${token});
+  outline-offset: ${opts.outlineOffset};
+  border-radius: ${opts.borderRadius};
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}::before {
+  box-sizing: border-box;
+  position: absolute;
+  inset: auto;
+  margin: 0;
+  width: max-content;
+  max-width: min(18rem, calc(100% - 0.75rem));
+  pointer-events: auto;
+  z-index: 20;
+${badgePos}
+  display: block;
+  content: '${labelEscaped}';
+  border: 1px solid color-mix(in oklab, var(${v}, ${col}) 60%, transparent);
+  border-radius: 9999px;
+  padding: 0.125rem 0.45rem;
+  font-size: 0.625rem;
+  line-height: 1.2;
+  letter-spacing: 0.02em;
+  font-weight: 600;
+  color: var(${v}, ${col});
+  background: color-mix(in oklab, white 85%, var(${v}, ${col}) 15%);
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  overflow: hidden;
+  transition: opacity 0.14s ease, background 0.14s ease, border-color 0.14s ease;
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}:hover::before {
+  opacity: 0.16;
+  background: color-mix(in oklab, white 94%, var(${v}, ${col}) 6%);
+  border-color: color-mix(in oklab, var(${v}, ${col}) 35%, transparent);
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-align="start"]::before {
+  left: 0.35rem;
+  right: auto;
+  transform: translateY(calc(-1 * 80%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-align="center"]::before {
+  left: 50%;
+  right: auto;
+  transform: translate(-50%, calc(-1 * 80%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-align="end"]::before {
+  left: auto;
+  right: 0.35rem;
+  transform: translateY(calc(-1 * 80%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-horizontal]::before {
+  left: calc(attr(data-ff-horizontal number, 50) * 1%);
+  right: auto;
+  transform: translate(-50%, calc(-1 * 80%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-horizontal][data-ff-anchor="bottom"]::before {
+  transform: translate(-50%, 80%);
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-anchor="bottom"]::before {
+  top: auto;
+  bottom: 0;
+  transform: translateY(80%);
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-anchor="bottom"][data-ff-align="center"]::before {
+  transform: translate(-50%, 80%);
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-vertical]::before {
+  transform: translateY(calc(attr(data-ff-vertical number, 80) * -1%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-horizontal][data-ff-vertical]::before {
+  transform: translate(-50%, calc(attr(data-ff-vertical number, 80) * -1%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-anchor="bottom"][data-ff-vertical]::before {
+  transform: translateY(calc(attr(data-ff-vertical number, 80) * 1%));
+}
+html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}[data-ff-anchor="bottom"][data-ff-horizontal][data-ff-vertical]::before {
+  transform: translate(-50%, calc(attr(data-ff-vertical number, 80) * 1%));
+}
+html[data-ff-enabled-${token}="off"] ${selIs} {
+  display: none !important;
+}
+`);
+	}
+	chunks.push(`
+[${nsAttr}*=" "] {
+  position: relative;
+  outline: none !important;
+  outline-offset: 0 !important;
+  border-radius: ${opts.borderRadius};
+}
+html [${nsAttr}*=" "]::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  pointer-events: none;
+  z-index: 10;
+  box-sizing: border-box;
+  padding: ${opts.outlineWidth};
+  background: var(--ff-combo-gradient, linear-gradient(90deg, #fecaca, #bfdbfe, #bbf7d0));
+  -webkit-mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+  mask-composite: exclude;
+}
+html [${nsAttr}*=" "]::before {
+  box-sizing: border-box;
+  position: absolute;
+  inset: auto;
+  margin: 0;
+  width: max-content;
+  max-width: min(18rem, calc(100% - 0.75rem));
+  pointer-events: auto;
+  z-index: 20;
+${badgePos}
+  display: block;
+  content: attr(${nsAttr});
+  background: var(--ff-combo-badge-gradient, var(--ff-combo-gradient-soft, linear-gradient(90deg, #fff1f2, #eff6ff, #f0fdf4))) !important;
+  color: var(--ff-combo-text, #111827) !important;
+  border: 1px solid var(--ff-combo-badge-border, color-mix(in oklab, #94a3b8 50%, transparent)) !important;
+  border-radius: 9999px;
+  padding: 0.125rem 0.45rem;
+  font-size: 0.625rem;
+  line-height: 1.2;
+  letter-spacing: 0.02em;
+  font-weight: 600;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  overflow: hidden;
+  transition: opacity 0.14s ease, background 0.14s ease, border-color 0.14s ease;
+}
+html [${nsAttr}*=" "][data-ff-label]::before {
+  content: attr(data-ff-label) !important;
+}
+html [${nsAttr}*=" "]:hover::before {
+  opacity: 0.2;
+  background: linear-gradient(90deg, #fff8f9, #f8fbff, #f8fff9);
+  border-color: color-mix(in oklab, #94a3b8 35%, transparent);
+}
+`);
+	for (const flag of Object.keys(runtime.flags)) {
+		const { token, selIs } = selectorsForFlag(flag);
+		chunks.push(`
+html[data-ff-badge-${token}="off"] ${selIs}[${nsAttr}*=" "]::before,
+html[data-ff-badge-${token}="off"] ${selIs}[${nsAttr}*=" "][data-ff-label]::before {
+  display: none !important;
+  content: none !important;
+}
+html[data-ff-badge-${token}="off"] ${selIs}[${nsAttr}*=" "]:hover::before,
+html[data-ff-badge-${token}="off"] ${selIs}[${nsAttr}*=" "][data-ff-label]:hover::before {
+  display: none !important;
+  opacity: 1 !important;
+  background: none !important;
+  border-color: transparent !important;
+}
+html[data-ff-outline-${token}="off"] ${selIs}[${nsAttr}*=" "] {
+  outline: none !important;
+  outline-offset: 0 !important;
+}
+html[data-ff-outline-${token}="off"] ${selIs}[${nsAttr}*=" "]::after {
+  display: none !important;
+}
+`);
+	}
+	chunks.push(`
+.aff-route-frame {
+  position: fixed;
+  inset: 0.6rem;
+  pointer-events: none;
+  z-index: 10040;
+  box-sizing: border-box;
+  border-radius: 0.5rem;
+  overflow: hidden;
+}
+.aff-route-frame::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  padding: 2px;
+  background: var(--ff-route-outline-gradient, linear-gradient(90deg, #ef4444, #3b82f6, #22c55e));
+  -webkit-mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+  mask-composite: exclude;
+}
+.aff-route-badge {
+  position: fixed;
+  top: 0.75rem;
+  right: 0.75rem;
+  z-index: 10060;
+  pointer-events: auto;
+  box-sizing: border-box;
+  display: inline-flex;
+  align-items: center;
+  max-width: min(34rem, calc(100vw - 1.5rem));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  border: 1px solid var(--ff-route-badge-border, color-mix(in oklab, #94a3b8 55%, transparent));
+  border-radius: 9999px;
+  padding: 0.15rem 0.5rem;
+  font-size: 0.625rem;
+  line-height: 1.2;
+  letter-spacing: 0.02em;
+  font-weight: 600;
+  color: var(--ff-route-text, #111827);
+  background: var(--ff-route-badge-gradient, linear-gradient(90deg, #fff1f2));
+  opacity: 1;
+  transition: opacity 0.14s ease, border-color 0.14s ease, background 0.14s ease;
+}
+.aff-route-badge:hover {
+  opacity: 0.2;
+  border-color: color-mix(in oklab, #94a3b8 35%, transparent);
+}
+.aff-route-disabled-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 10050;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: clamp(1rem, 4vw, 2.5rem);
+  text-align: center;
+  font: 600 0.95rem/1.45 system-ui, -apple-system, Segoe UI, sans-serif;
+  color: #f8fafc;
+  background: rgba(15, 23, 42, 0.52);
+  backdrop-filter: blur(2px);
+  pointer-events: auto;
+}
+.aff-route-disabled-overlay > p {
+  margin: 0;
+  max-width: min(44rem, calc(100vw - 2rem));
+  white-space: pre-line;
+}
+`);
+	for (const flag of Object.keys(runtime.flags)) {
+		const token = toToken(flag);
+		chunks.push(`
+[data-ff-route~="${token}"][data-ff-outline-${token}="off"] #aff-route-frame {
+  display: none !important;
+}
+[data-ff-route~="${token}"][data-ff-badge-${token}="off"] #aff-route-badge {
+  display: none !important;
+}
+[data-ff-route~="${token}"][data-ff-enabled-${token}="off"] #aff-route-frame {
+  display: none !important;
+}
+[data-ff-route~="${token}"][data-ff-enabled-${token}="off"] #aff-route-badge {
+  display: none !important;
+}
+`);
+	}
+	return "\n" + chunks.join("\n") + "\n";
+}
+/**
+* CSS-only hiding for disabled flags. The Astro integration no longer injects this into
+* production builds — static HTML is culled instead. Kept for custom tooling or tests.
+*/
+function createProductionGateStyles(runtime) {
+	const nsAttr = `data-${toToken(runtime.namespace) || "ff"}`;
+	const chunks = [];
+	for (const [flag, enabled] of Object.entries(runtime.flags)) {
+		if (enabled) continue;
+		const token = toToken(flag);
+		const valueSelectors = [`[${nsAttr}~="${token}"]`];
+		if (flag !== token) valueSelectors.push(`[${nsAttr}~="${flag}"]`);
+		chunks.push(`${[...valueSelectors, `[${nsAttr}-${token}]`].join(", ")} { display: none !important; }`);
+	}
+	return chunks.length ? `\n${chunks.join("\n")}\n` : "";
+}
+function buildAffDevBootstrapScript(flagTokens, colors, outlineDefaults, badgeDefaults, routeFlags, flagNameToToken, namespace) {
+	return inlineInvoke(affDevBootstrapRuntime, {
+		flagTokens,
+		colors,
+		outlineDefaults,
+		badgeDefaults,
+		routeFlags,
+		flagNameToToken,
+		namespace: toToken(namespace) || "ff"
+	});
+}
+//#endregion
+//#region src/production-html-cull.ts
+function walkHtmlFiles(dir) {
+	const out = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const ent of entries) {
+		const p = join(dir, ent.name);
+		if (ent.isDirectory()) out.push(...walkHtmlFiles(p));
+		else if (ent.isFile() && ent.name.endsWith(".html")) out.push(p);
+	}
+	return out;
+}
+function namespaceAttrName(namespace) {
+	return `data-${toToken(namespace) || "ff"}`;
+}
+function elementFlagSlugs(el, nsAttr, knownTokens) {
+	const slugSet = /* @__PURE__ */ new Set();
+	const combined = el.getAttribute(nsAttr)?.trim();
+	if (combined) for (const part of combined.split(/\s+/).filter(Boolean)) slugSet.add(part);
+	for (const tk of knownTokens) if (el.hasAttribute(`${nsAttr}-${tk}`)) slugSet.add(tk);
+	return [...slugSet];
+}
+function slugToFlagNames(slug, flagNames) {
+	const out = [];
+	for (const name of flagNames) if (slug === name || slug === toToken(name)) out.push(name);
+	return out;
+}
+function shouldCullElement(el, runtime, nsAttr, knownTokens, flagNames) {
+	const slugs = elementFlagSlugs(el, nsAttr, knownTokens);
+	if (slugs.length === 0) return false;
+	for (const slug of slugs) if (slugToFlagNames(slug, flagNames).length === 0) return false;
+	for (const slug of slugs) {
+		const names = slugToFlagNames(slug, flagNames);
+		for (const name of names) if (!runtime.flags[name]) return true;
+	}
+	return false;
+}
+function elementDepth(el) {
+	let d = 0;
+	let n = el.parentNode;
+	while (n) {
+		d++;
+		n = n.parentNode;
+	}
+	return d;
+}
+/**
+* Production static HTML: remove nodes gated by disabled flags (same rules as dev
+* `data-*` / `data-*-<token>`), strip dev-only route attributes on `<html>`, and drop
+* empty `<style>` tags left after `featureFlagStyles` is empty.
+*/
+function cullProductionHtml(html, runtime) {
+	const root = parse(html);
+	const nsAttr = namespaceAttrName(runtime.namespace);
+	const flagNames = Object.keys(runtime.flags);
+	const knownTokens = flagNames.map((n) => toToken(n));
+	const candidates = root.querySelectorAll("*");
+	const toRemove = [];
+	for (const el of candidates) if (shouldCullElement(el, runtime, nsAttr, knownTokens, flagNames)) toRemove.push(el);
+	toRemove.sort((a, b) => elementDepth(b) - elementDepth(a));
+	for (const el of toRemove) el.remove();
+	const htmlEl = root.querySelector("html");
+	if (htmlEl) {
+		htmlEl.removeAttribute("data-ff-route");
+		htmlEl.removeAttribute("data-ff-route-label");
+	}
+	const styles = root.querySelectorAll("style");
+	for (const st of styles) if (!(st.textContent ?? "").trim()) st.remove();
+	return root.outerHTML;
+}
+/**
+* Walk `outDir` (e.g. Astro `dist/`) and apply {@link cullProductionHtml} to every `.html` file.
+*/
+function applyProductionHtmlCullToDist(outDir, runtime) {
+	for (const file of walkHtmlFiles(outDir)) {
+		const before = readFileSync(file, "utf8");
+		const after = cullProductionHtml(before, runtime);
+		if (after !== before) writeFileSync(file, after, "utf8");
+	}
+}
+//#endregion
+//#region src/dev-head-inject.ts
+/**
+* Single `injectScript('head-inline', …)` payload for `astro dev`: dev-only outline CSS,
+* `data-ff-route` on `<html>` (pathname + {@link ResolvedFeatureRuntime.routeFlags}), then
+* the feature-flag dev bootstrap (toolbar state, combo badges, route chrome).
+*/
+function buildAffDevHeadInline(args) {
+	const { runtime, featureFlagStyles, affDevBootstrap } = args;
+	const flagNameToToken = Object.fromEntries(Object.keys(runtime.flags).map((name) => [name, toToken(name)]));
+	return `${inlineInvoke(affHeadInlineRuntime, {
+		featureFlagStyles,
+		routeFlags: runtime.routeFlags,
+		flagNameToToken
+	})}\n${affDevBootstrap}`;
+}
+//#endregion
+//#region src/route-prefix-js.ts
+/**
+* Shared JS helper source used by generated browser scripts.
+* Keep this in sync with runtime.routePatternToPrefix semantics.
+*/
+function routePrefixJsHelper(functionName) {
+	return `function ${functionName}(pattern){var p=String(pattern||'').trim();if(p.endsWith('/**'))p=p.slice(0,-3);else if(p.endsWith('/*'))p=p.slice(0,-2);else if(p.length>1&&p.endsWith('*'))p=p.slice(0,-1);return p.endsWith('/')?p:p+'/';}`;
+}
+//#endregion
+//#region src/index.ts
+/** Prefer `prod` if present; else first non-`dev` key (sorted); else `"prod"`. */
+function primaryNonDevEnvironmentKey(flagsByEnvironment) {
+	const keys = Object.keys(flagsByEnvironment);
+	if (keys.includes("prod")) return "prod";
+	return keys.filter((k) => k !== "dev").sort()[0] ?? "prod";
+}
+function withDefaultEnvironments(options = {}) {
+	const mode = options.mode ?? process.env.NODE_ENV ?? "development";
+	const raw = options.environments && typeof options.environments === "object" && !Array.isArray(options.environments) ? { ...options.environments } : {};
+	delete raw.dev;
+	const environments = {
+		dev: { when: mode !== "production" },
+		...raw
+	};
+	if (Object.keys(environments).length < 2) environments.prod = environments.prod ?? {
+		when: mode === "production",
+		flags: {}
+	};
+	return {
+		...options,
+		environments
+	};
+}
+function createVirtualModuleSource(runtime, css, flagsByEnvironment = {}, devBootstrap) {
+	const flagNames = Object.keys(runtime.flags);
+	const flagTokens = flagNames.map((name) => toToken(name));
+	const enumEntries = flagNames.map((name) => `  ${toEnumKey(name)}: ${JSON.stringify(name)}`).join(",\n");
+	const tokenEntries = flagNames.map((name) => `  ${toEnumKey(name)}: ${JSON.stringify(toToken(name))}`).join(",\n");
+	const styles = createFeatureFlagStyles(runtime, css);
+	const colorsJson = JSON.stringify(runtime.flagColorsByToken, null, 2);
+	const flagNameToToken = JSON.stringify(Object.fromEntries(flagNames.map((name) => [name, toToken(name)])), null, 2);
+	const defaultNonDevEnvironment = primaryNonDevEnvironmentKey(flagsByEnvironment);
+	const bootstrap = devBootstrap ?? buildAffDevBootstrapScript(flagTokens, { ...runtime.flagColorsByToken }, { ...runtime.flagOutlineDefaultsByToken }, { ...runtime.flagBadgeDefaultsByToken }, { ...runtime.routeFlags }, Object.fromEntries(flagNames.map((name) => [name, toToken(name)])), runtime.namespace);
+	return `${routePrefixJsHelper("affRoutePatternToPrefix")}
+
+export const FeatureFlag = Object.freeze({
+${enumEntries}
+});
+
+export const FeatureToken = Object.freeze({
+${tokenEntries}
+});
+
+export const featureFlagTokens = Object.freeze(${JSON.stringify(flagTokens)});
+export const featureFlagColors = Object.freeze(${colorsJson});
+export const featureFlags = Object.freeze(${JSON.stringify(runtime.flags, null, 2)});
+export const featureFlagsByEnvironment = Object.freeze(${JSON.stringify(flagsByEnvironment, null, 2)});
+export const defaultNonDevEnvironment = ${JSON.stringify(defaultNonDevEnvironment)};
+export const featureRouteFlags = Object.freeze(${JSON.stringify(runtime.routeFlags, null, 2)});
+export const featureNamespace = ${JSON.stringify(runtime.namespace)};
+/** True when Astro is running the dev server or dev build (import.meta.env.DEV). Not the same as the reserved \`dev\` environment layer — see \`activeEnvironmentKey\`. */
+export const isAstroDev = import.meta.env.DEV;
+export const activeEnvironmentKey = ${JSON.stringify(runtime.activeEnvironment)};
+
+export const affDevBootstrap = import.meta.env.DEV ? ${JSON.stringify(bootstrap)} : '';
+
+export function isFeatureEnabled(flag) {
+  return Boolean(featureFlags[flag]);
+}
+
+export function shouldRenderFeature(flag) {
+  return isFeatureEnabled(flag);
+}
+
+export function isFeatureRoute(pathname) {
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  return Object.keys(featureRouteFlags).some((route) => {
+    const candidate = affRoutePatternToPrefix(route);
+    return normalized === candidate || normalized.startsWith(candidate);
+  });
+}
+
+export function shouldIncludePath(pathname) {
+  if (import.meta.env.DEV) return true;
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  for (const [route, flags] of Object.entries(featureRouteFlags)) {
+    const candidate = affRoutePatternToPrefix(route);
+    if (normalized === candidate || normalized.startsWith(candidate)) {
+      return flags.every((flag) => isFeatureEnabled(flag));
+    }
+  }
+  return true;
+}
+
+export function flagsForEnvironment(envName) {
+  var F = featureFlagsByEnvironment[envName];
+  return F != null ? F : null;
+}
+
+export function isFeatureEnabledForEnvironment(flag, envName) {
+  var F = featureFlagsByEnvironment[envName];
+  return !!(F && F[flag]);
+}
+
+export function shouldIncludePathForEnvironment(pathname, envName) {
+  var F = featureFlagsByEnvironment[envName];
+  if (!F) return true;
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  for (const [route, flagList] of Object.entries(featureRouteFlags)) {
+    const candidate = affRoutePatternToPrefix(route);
+    if (normalized === candidate || normalized.startsWith(candidate)) {
+      return flagList.every((flag) => Boolean(F[flag]));
+    }
+  }
+  return true;
+}
+
+const flagNameToToken = Object.freeze(${flagNameToToken});
+
+export function matchedFeatureRoutePrefix(pathname) {
+  if (!pathname) return null;
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  let best = null;
+  let bestLen = -1;
+  for (const routePrefix of Object.keys(featureRouteFlags)) {
+    const route = affRoutePatternToPrefix(routePrefix);
+    if (normalized === route || normalized.startsWith(route)) {
+      if (route.length > bestLen) {
+        bestLen = route.length;
+        best = routePrefix;
+      }
+    }
+  }
+  return best;
+}
+
+export function routeFeatureTokenForPath(pathname) {
+  const prefix = matchedFeatureRoutePrefix(pathname);
+  if (!prefix) return undefined;
+  const flagNames = featureRouteFlags[prefix] || [];
+  const first = flagNames[0];
+  return first != null ? flagNameToToken[first] : undefined;
+}
+
+export function routeFeatureTokensForPath(pathname) {
+  if (!pathname) return [];
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  const out = [];
+  const seen = new Set();
+  for (const [routePrefix, flagNames] of Object.entries(featureRouteFlags)) {
+    const route = affRoutePatternToPrefix(routePrefix);
+    if (!(normalized === route || normalized.startsWith(route))) continue;
+    for (const name of flagNames || []) {
+      const token = flagNameToToken[name];
+      if (!token || seen.has(token)) continue;
+      seen.add(token);
+      out.push(token);
+    }
+  }
+  return out;
+}
+
+export function routeFeatureMatchesForPath(pathname) {
+  if (!pathname) return [];
+  const normalized = pathname.endsWith('/') ? pathname : pathname + '/';
+  var byFlag = {};
+  for (const [routePattern, flagNames] of Object.entries(featureRouteFlags)) {
+    const candidate = affRoutePatternToPrefix(routePattern);
+    if (!(normalized === candidate || normalized.startsWith(candidate))) continue;
+    for (const flagName of flagNames || []) {
+      const token = flagNameToToken[flagName];
+      if (!token) continue;
+      if (!byFlag[flagName]) byFlag[flagName] = { flag: flagName, token, routes: [] };
+      byFlag[flagName].routes.push(routePattern);
+    }
+  }
+  return Object.values(byFlag);
+}
+
+export const featureFlagStyles = import.meta.env.DEV ? ${JSON.stringify(styles)} : "";
+`;
+}
+function getResolvedFeatures(options = {}) {
+	return resolveFeatureRuntime(withDefaultEnvironments(options));
+}
+function featureRouteIncluded(pathname, runtime) {
+	return shouldIncludeRoute({
+		pathname,
+		routeFlags: runtime.routeFlags,
+		flags: runtime.flags,
+		isDev: runtime.isDev
+	});
+}
+function astroFeatureFlags(options = {}) {
+	const { css, staticMinify = true, ...flagOpts } = options;
+	const opts = withDefaultEnvironments(flagOpts);
+	const mode = opts.mode ?? process.env.NODE_ENV ?? "development";
+	const runtime = resolveFeatureRuntime({
+		...opts,
+		mode
+	});
+	return {
+		name: "astro-feature-flags",
+		hooks: {
+			"astro:config:setup": ({ updateConfig, addDevToolbarApp, command, injectScript }) => {
+				const flagNames = Object.keys(runtime.flags);
+				const flagTokens = flagNames.map((name) => toToken(name));
+				const flagsByEnvironment = resolveFeatureFlagsByEnvironment(opts);
+				const flagNameToToken = Object.fromEntries(flagNames.map((name) => [name, toToken(name)]));
+				const bootstrap = buildAffDevBootstrapScript(flagTokens, { ...runtime.flagColorsByToken }, { ...runtime.flagOutlineDefaultsByToken }, { ...runtime.flagBadgeDefaultsByToken }, { ...runtime.routeFlags }, flagNameToToken, runtime.namespace);
+				if (command === "dev" && runtime.isDev && typeof addDevToolbarApp === "function") addDevToolbarApp({
+					id: "astro-feature-flags",
+					name: "Feature flags",
+					icon: DEV_TOOLBAR_FLAG_ICON_SVG,
+					entrypoint: fileURLToPath(new URL("./dev-toolbar-app.mjs", import.meta.url))
+				});
+				if (command === "dev" && runtime.isDev && typeof injectScript === "function") injectScript("head-inline", buildAffDevHeadInline({
+					runtime,
+					featureFlagStyles: createFeatureFlagStyles(runtime, css),
+					affDevBootstrap: bootstrap
+				}));
+				updateConfig({ vite: { plugins: [{
+					name: "astro-feature-flags:virtual-module",
+					resolveId(id) {
+						if (id === "virtual:astro-feature-flags") return "\0virtual:astro-feature-flags";
+						return null;
+					},
+					load(id) {
+						if (id === "\0virtual:astro-feature-flags") return createVirtualModuleSource(runtime, css, flagsByEnvironment, bootstrap);
+						return null;
+					}
+				}] } });
+			},
+			"astro:build:done": ({ dir }) => {
+				if (runtime.isDev || !staticMinify) return;
+				const outDir = fileURLToPath(dir);
+				const prunePaths = routePathsToPrune({
+					routeFlags: runtime.routeFlags,
+					flags: runtime.flags
+				});
+				for (const routePath of prunePaths) rmSync(join(outDir, routePath), {
+					recursive: true,
+					force: true
+				});
+				applyProductionHtmlCullToDist(outDir, runtime);
+			}
+		}
+	};
+}
+//#endregion
+export { applyProductionHtmlCullToDist, createFeatureFlagStyles, createProductionGateStyles, createVirtualModuleSource, cullProductionHtml, astroFeatureFlags as default, elementBadgePositionBlock, featureRouteIncluded, getResolvedFeatures, longestMatchingRoutePrefix, mergeFlagsWithProcessEnvOverrides, normalizeElementBadgeLayout, primaryNonDevEnvironmentKey, resolveFeatureFlagsByEnvironment, routePatternToPrefix };
+
+//# sourceMappingURL=index.mjs.map