@bgub/fig 0.0.1 → 0.1.0-alpha.1

package/dist/element-BZ7r9ncY.d.ts

@@ -0,0 +1,342 @@
+//#region src/data.d.ts
+type DataResourceKeyInput = string | number | boolean | null | readonly DataResourceKeyInput[] | {
+  readonly [key: string]: DataResourceKeyInput;
+};
+type DataResourceKey = readonly [string, ...DataResourceKeyInput[]];
+interface DataResourceLoadContext {
+  signal: AbortSignal;
+}
+type DataResourceLoader<TArgs extends unknown[], TValue> = (...argsAndContext: [...TArgs, DataResourceLoadContext]) => TValue | PromiseLike<TValue>;
+interface DataResource<TArgs extends unknown[] = unknown[], TValue = unknown> {
+  readonly $$typeof: symbol;
+  readonly debugArgs?: (...args: TArgs) => DataResourceKeyInput;
+  readonly key: (...args: TArgs) => DataResourceKey;
+  readonly load?: DataResourceLoader<TArgs, TValue>;
+}
+type DataRefreshResult<T> = {
+  status: "fulfilled";
+  value: T;
+} | {
+  status: "rejected";
+  error: unknown;
+  staleValue?: T;
+} | {
+  status: "aborted";
+  reason: "superseded" | "store-disposed" | "evicted";
+  staleValue?: T;
+} | {
+  status: "unsupported";
+  reason: "no-client-loader";
+  staleValue?: T;
+};
+interface FigDataHydrationEntry {
+  key: DataResourceKey;
+  value: unknown;
+}
+type FigDataEntryStatus = "pending" | "fulfilled" | "rejected" | "refreshing";
+interface DataStoreEntrySnapshot {
+  canonicalKey: string;
+  error?: unknown;
+  hasValue: boolean;
+  key: DataResourceKey;
+  pending: boolean;
+  refreshError?: unknown;
+  stale: boolean;
+  status: FigDataEntryStatus;
+  subscriberCount: number;
+  value?: unknown;
+}
+interface FigDataStoreHandle {
+  ensureData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): Promise<TValue>;
+  hydrate(entries: readonly FigDataHydrationEntry[]): void;
+  invalidateData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): void;
+  invalidateDataError(error: unknown): boolean;
+  invalidateDataKey(key: DataResourceKey): void;
+  invalidateDataPrefix(prefix: DataResourceKey): void;
+  preloadData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): void;
+  refreshData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): Promise<DataRefreshResult<TValue>>;
+  run<T>(callback: () => T): T;
+}
+/**
+ * A root-neutral data store. A renderer adopts it exactly once, preserving
+ * entries loaded before rendering while attaching subscriber scheduling.
+ */
+interface FigDataStoreController extends FigDataStoreHandle {
+  dispose(): void;
+  snapshot(): FigDataHydrationEntry[];
+}
+interface FigDataStoreOptions {
+  initialData?: readonly FigDataHydrationEntry[];
+  partition?: DataResourceKeyInput;
+}
+interface FigDataStore extends FigDataStoreHandle {
+  commitDataDependencies(owner: object, previousOwner: object | null): void;
+  deleteDataOwner(owner: object): void;
+  releaseDataOwner(owner: object): void;
+  resetDataDependencies(owner: object): void;
+  dispose(): void;
+  inspectDataDependencyCanonicalKeys(owner: object): string[];
+  inspectDataEntries(): DataStoreEntrySnapshot[];
+  snapshot(): FigDataHydrationEntry[];
+  readData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, args: TArgs, owner: object): TValue;
+}
+interface FigDataStoreHost {
+  getLane(): unknown;
+  partition?: DataResourceKeyInput;
+  schedule(owner: object, lane: unknown): void;
+}
+type FigDataStoreFactory = (host: FigDataStoreHost) => FigDataStore;
+type LoadContextHydrate = (entries: readonly FigDataHydrationEntry[]) => void;
+type LoadContextAttributeError = (error: unknown) => void;
+interface LoadContextCapabilities {
+  attributeError: LoadContextAttributeError;
+  hydrate: LoadContextHydrate;
+  key?: DataResourceKey;
+}
+declare function defineLoadContextCapabilities(context: DataResourceLoadContext, capabilities: LoadContextCapabilities): void;
+declare function loadContextCapabilities(context: DataResourceLoadContext): LoadContextCapabilities | undefined;
+declare function resolveCurrentDataStore(message?: string): FigDataStore;
+declare function setCurrentDataStore(store: FigDataStore | null): FigDataStore | null;
+declare function markDataResourceError(error: unknown, key: DataResourceKey): void;
+declare function dataResourceKeysForError(error: unknown): DataResourceKey[] | undefined;
+//#endregion
+//#region src/resource.d.ts
+type AssetResourceBlocking = "reveal" | "none";
+type CrossOrigin = "anonymous" | "use-credentials" | "";
+type FetchPriority = "high" | "low" | "auto";
+type AssetResourceDestination = "head" | "stream";
+type FigAssetResource = StylesheetResource | PreloadResource | ModulePreloadResource | ScriptResource | FontResource | PreconnectResource | TitleResource | MetaResource;
+interface ResourceBase {
+  key?: string;
+}
+interface StylesheetResource extends ResourceBase {
+  blocking?: AssetResourceBlocking;
+  crossorigin?: CrossOrigin;
+  href: string;
+  kind: "stylesheet";
+  media?: string;
+  precedence?: string;
+}
+interface PreloadResource extends ResourceBase {
+  as: string;
+  crossorigin?: CrossOrigin;
+  fetchpriority?: FetchPriority;
+  href: string;
+  kind: "preload";
+  type?: string;
+}
+interface ModulePreloadResource extends ResourceBase {
+  crossorigin?: CrossOrigin;
+  fetchpriority?: FetchPriority;
+  href: string;
+  kind: "modulepreload";
+}
+interface ScriptResource extends ResourceBase {
+  async?: boolean;
+  crossorigin?: CrossOrigin;
+  defer?: boolean;
+  kind: "script";
+  module?: boolean;
+  src: string;
+}
+interface FontResource extends ResourceBase {
+  crossorigin?: CrossOrigin;
+  fetchpriority?: FetchPriority;
+  href: string;
+  kind: "font";
+  type: string;
+}
+interface PreconnectResource extends ResourceBase {
+  crossorigin?: CrossOrigin;
+  href: string;
+  kind: "preconnect";
+}
+interface TitleResource extends ResourceBase {
+  kind: "title";
+  value: string;
+}
+interface MetaResourceBase extends ResourceBase {
+  kind: "meta";
+}
+type DistributiveOmit<Value, Key extends PropertyKey> = Value extends unknown ? Omit<Value, Key> : never;
+type MetaResource = (MetaResourceBase & {
+  charset: string;
+  content?: never;
+  "http-equiv"?: never;
+  name?: never;
+  property?: never;
+}) | (MetaResourceBase & {
+  charset?: never;
+  content: string;
+  "http-equiv"?: never;
+  name: string;
+  property?: never;
+}) | (MetaResourceBase & {
+  charset?: never;
+  content: string;
+  "http-equiv"?: never;
+  name?: never;
+  property: string;
+}) | (MetaResourceBase & {
+  charset?: never;
+  content: string;
+  "http-equiv": string;
+  name?: never;
+  property?: never;
+});
+type MetaResourceOptions = DistributiveOmit<MetaResource, "kind">;
+type FigAssetResourceList = FigAssetResource | readonly FigAssetResource[];
+type ClientReferenceAssets = FigAssetResourceList | (() => FigAssetResourceList);
+interface AssetsProps {
+  assets: FigAssetResourceList;
+  children?: FigNode;
+}
+declare function assets(value: FigAssetResourceList, children?: FigNode): FigElement<AssetsProps>;
+declare function stylesheet(href: string, options?: Omit<StylesheetResource, "href" | "kind">): StylesheetResource;
+declare function preload(href: string, as: string, options?: Omit<PreloadResource, "as" | "href" | "kind">): PreloadResource;
+declare function modulepreload(href: string, options?: Omit<ModulePreloadResource, "href" | "kind">): ModulePreloadResource;
+declare function script(src: string, options?: Omit<ScriptResource, "kind" | "src">): ScriptResource;
+declare function font(href: string, type: string, options?: Omit<FontResource, "href" | "kind" | "type">): FontResource;
+declare function preconnect(href: string, options?: Omit<PreconnectResource, "href" | "kind">): PreconnectResource;
+declare function title(value: string): TitleResource;
+declare function meta(options: MetaResourceOptions): MetaResource;
+declare function isFigAssetResource(value: unknown): value is FigAssetResource;
+declare function clientReferenceAssets(reference: FigClientReference): readonly FigAssetResource[];
+declare function assetResourceKey(resource: FigAssetResource): string;
+declare function assetResourceDestination(resource: FigAssetResource): AssetResourceDestination;
+declare function assetResourceFromHostProps(type: string, props: Props): FigAssetResource | null;
+declare function preventAssetResourceHoist<P extends Props>(props: P): P;
+declare function assetResourceFromHostAttributes(type: string, getAttribute: (name: string) => unknown): FigAssetResource | null;
+type AssetResourceHostAttribute = readonly [name: string, value: string | true];
+declare function assetResourceHostAttributes(resource: FigAssetResource): AssetResourceHostAttribute[];
+//#endregion
+//#region src/element.d.ts
+type Key = string | number;
+type Props = Record<string, any>;
+type ComponentType<P = Props> = (props: P & {
+  children?: FigNode;
+}) => FigNode;
+type ComponentProps<T extends ComponentType<any>> = Parameters<T> extends [infer P, ...unknown[]] ? P extends Props ? P : Props : {};
+type ElementType<P = Props> = string | typeof Fragment | FigAssets | FigClientReference<P> | FigErrorBoundary | FigSuspense | FigActivity | FigViewTransition | ComponentType<P>;
+type AwaitedFigNode = FigElement<any> | FigPortal<any> | string | number | boolean | null | undefined | FigNode[];
+type FigNode = AwaitedFigNode | PromiseLike<AwaitedFigNode>;
+interface FigElement<P = Props> {
+  readonly $$typeof: symbol;
+  readonly type: ElementType<any>;
+  readonly key: Key | null;
+  readonly props: P & {
+    children?: FigNode;
+  };
+}
+interface FigPortal<Target = unknown> {
+  readonly $$typeof: symbol;
+  readonly children: FigNode;
+  readonly key: Key | null;
+  readonly target: Target;
+}
+interface ClientReferenceOptions<P extends Props = Props> {
+  assets?: ClientReferenceAssets;
+  id: string;
+  ssr?: ComponentType<P>;
+}
+interface FigClientReference<P = Props> {
+  (props: P & {
+    children?: FigNode;
+  }): FigNode;
+  readonly $$typeof: symbol;
+  readonly assets?: ClientReferenceAssets;
+  readonly id: string;
+  readonly ssr?: ComponentType<P>;
+}
+type LazyLoader<T extends ComponentType<any> = ComponentType<any>> = () => PromiseLike<T>;
+interface SuspenseProps {
+  fallback?: FigNode;
+  children?: FigNode;
+}
+interface FigSuspense {
+  (props: SuspenseProps): FigNode;
+  readonly $$typeof: symbol;
+}
+type ActivityMode = "visible" | "hidden";
+interface ActivityProps {
+  mode: ActivityMode;
+  children?: FigNode;
+}
+interface FigActivity {
+  (props: ActivityProps): FigNode;
+  readonly $$typeof: symbol;
+}
+type ViewTransitionClass = "auto" | "none" | (string & {});
+type ViewTransitionPhase = "enter" | "exit" | "share" | "update";
+interface ViewTransitionSurface {
+  readonly name: string;
+}
+interface ViewTransitionEvent {
+  readonly phase: ViewTransitionPhase;
+  readonly surfaces: readonly ViewTransitionSurface[];
+  readonly types: readonly string[];
+}
+type ViewTransitionCallback = (event: ViewTransitionEvent, signal: AbortSignal) => undefined;
+interface ViewTransitionProps {
+  name?: string;
+  children?: FigNode;
+  default?: ViewTransitionClass;
+  enter?: ViewTransitionClass;
+  exit?: ViewTransitionClass;
+  share?: ViewTransitionClass;
+  update?: ViewTransitionClass;
+  onTransition?: ViewTransitionCallback;
+}
+interface FigViewTransition {
+  (props: ViewTransitionProps): FigNode;
+  readonly $$typeof: symbol;
+}
+interface ErrorBoundaryProps {
+  fallback?: FigNode | ((error: unknown, info: ErrorInfo) => FigNode);
+  onError?: (error: unknown, info: ErrorInfo) => void;
+  children?: FigNode;
+}
+interface ErrorInfo {
+  componentStack: string;
+  dataResourceKeys?: DataResourceKey[];
+}
+interface FigErrorBoundary {
+  (props: ErrorBoundaryProps): FigNode;
+  readonly $$typeof: symbol;
+}
+interface FigAssets {
+  (props: Props & {
+    children?: FigNode;
+  }): FigNode;
+  readonly $$typeof: symbol;
+}
+declare const Fragment: unique symbol;
+declare const FigElementSymbol: unique symbol;
+declare const FigClientReferenceSymbol: unique symbol;
+declare const FigActivitySymbol: unique symbol;
+declare const FigErrorBoundarySymbol: unique symbol;
+declare const FigPortalSymbol: unique symbol;
+declare const FigAssetsSymbol: unique symbol;
+declare const FigSuspenseSymbol: unique symbol;
+declare const FigViewTransitionSymbol: unique symbol;
+declare const Assets: FigAssets;
+declare const ErrorBoundary: FigErrorBoundary;
+declare const Suspense: FigSuspense;
+declare const Activity: FigActivity;
+declare const ViewTransition: FigViewTransition;
+declare function createElement<P extends Props>(type: ElementType<P>, config?: (P & {
+  key?: Key | null;
+}) | null, ...children: FigNode[]): FigElement<P>;
+declare function isValidElement(value: unknown): value is FigElement;
+declare function createPortalNode<Target>(children: FigNode, target: Target, key?: Key | null): FigPortal<Target>;
+declare function isPortal(value: unknown): value is FigPortal;
+declare function clientReference<P extends Props = Props>(options: ClientReferenceOptions<P>): FigClientReference<P>;
+declare function lazy<T extends ComponentType<any>>(load: LazyLoader<T>): ComponentType<ComponentProps<T>>;
+declare function isClientReference(value: unknown): value is FigClientReference;
+declare function isSuspense(value: unknown): value is FigSuspense;
+declare function isActivity(value: unknown): value is FigActivity;
+declare function isErrorBoundary(value: unknown): value is FigErrorBoundary;
+declare function isViewTransition(value: unknown): value is FigViewTransition;
+declare function isAssets(value: unknown): value is FigAssets;
+//#endregion
+export { isViewTransition as $, LoadContextHydrate as $t, Fragment as A, preconnect as At, ViewTransitionPhase as B, DataResourceLoadContext as Bt, FigNode as C, assetResourceKey as Ct, FigSuspenseSymbol as D, isFigAssetResource as Dt, FigSuspense as E, font as Et, SuspenseProps as F, title as Ft, createPortalNode as G, FigDataStore as Gt, ViewTransitionSurface as H, DataStoreEntrySnapshot as Ht, ViewTransition as I, DataRefreshResult as It, isClientReference as J, FigDataStoreHandle as Jt, isActivity as K, FigDataStoreController as Kt, ViewTransitionCallback as L, DataResource as Lt, LazyLoader as M, preventAssetResourceHoist as Mt, Props as N, script as Nt, FigViewTransition as O, meta as Ot, Suspense as P, stylesheet as Pt, isValidElement as Q, LoadContextCapabilities as Qt, ViewTransitionClass as R, DataResourceKey as Rt, FigErrorBoundarySymbol as S, assetResourceHostAttributes as St, FigPortalSymbol as T, clientReferenceAssets as Tt, clientReference as U, FigDataEntryStatus as Ut, ViewTransitionProps as V, DataResourceLoader as Vt, createElement as W, FigDataHydrationEntry as Wt, isPortal as X, FigDataStoreOptions as Xt, isErrorBoundary as Y, FigDataStoreHost as Yt, isSuspense as Z, LoadContextAttributeError as Zt, FigClientReference as _, StylesheetResource as _t, AwaitedFigNode as a, setCurrentDataStore as an, ClientReferenceAssets as at, FigElementSymbol as b, assetResourceFromHostAttributes as bt, ComponentType as c, FigAssetResource as ct, ErrorBoundaryProps as d, MetaResource as dt, dataResourceKeysForError as en, lazy as et, ErrorInfo as f, MetaResourceOptions as ft, FigAssetsSymbol as g, ScriptResource as gt, FigAssets as h, PreloadResource as ht, Assets as i, resolveCurrentDataStore as in, AssetsProps as it, Key as j, preload as jt, FigViewTransitionSymbol as k, modulepreload as kt, ElementType as l, FigAssetResourceList as lt, FigActivitySymbol as m, PreconnectResource as mt, ActivityMode as n, loadContextCapabilities as nn, AssetResourceDestination as nt, ClientReferenceOptions as o, CrossOrigin as ot, FigActivity as p, ModulePreloadResource as pt, isAssets as q, FigDataStoreFactory as qt, ActivityProps as r, markDataResourceError as rn, AssetResourceHostAttribute as rt, ComponentProps as s, FetchPriority as st, Activity as t, defineLoadContextCapabilities as tn, AssetResourceBlocking as tt, ErrorBoundary as u, FontResource as ut, FigClientReferenceSymbol as v, TitleResource as vt, FigPortal as w, assets as wt, FigErrorBoundary as x, assetResourceFromHostProps as xt, FigElement as y, assetResourceDestination as yt, ViewTransitionEvent as z, DataResourceKeyInput as zt };

package/dist/element-DmbzNH0T.js

@@ -0,0 +1,299 @@
+//#region src/data.ts
+const LoadContextCapabilitiesSymbol = Symbol.for("fig.data-load-context");
+function defineLoadContextCapabilities(context, capabilities) {
+	Object.defineProperty(context, LoadContextCapabilitiesSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: capabilities
+	});
+}
+function loadContextCapabilities(context) {
+	return context[LoadContextCapabilitiesSymbol];
+}
+const objectDataErrors = /* @__PURE__ */ new WeakMap();
+let currentDataStore = null;
+function resolveCurrentDataStore(message = "Data resource APIs require a Fig data store.") {
+	if (currentDataStore === null) throw new Error(message);
+	return currentDataStore;
+}
+function setCurrentDataStore(store) {
+	const previousStore = currentDataStore;
+	currentDataStore = store;
+	return previousStore;
+}
+function markDataResourceError(error, key) {
+	if (!isAttributableError(error)) return;
+	let keys = objectDataErrors.get(error);
+	if (keys === void 0) {
+		keys = [];
+		objectDataErrors.set(error, keys);
+	}
+	if (keys.some((existing) => sameDataResourceKey(existing, key))) return;
+	keys.push(key);
+}
+function dataResourceKeysForError(error) {
+	if (!isAttributableError(error)) return void 0;
+	const keys = objectDataErrors.get(error);
+	return keys === void 0 || keys.length === 0 ? void 0 : [...keys];
+}
+function sameDataResourceKey(a, b) {
+	return a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+}
+function isAttributableError(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+//#endregion
+//#region src/hooks.ts
+let currentDispatcher = null;
+function useState(initialState) {
+	return resolveDispatcher().useState(initialState);
+}
+/**
+* Tracks state returned by a client-side action. The action receives the
+* previous committed state first, then the runner's arguments, then an
+* `AbortSignal` Fig appends (declare the trailing signal parameter — it also
+* drives `Args` inference). Async actions run in a transition priority scope
+* and keep `isPending` true until they settle.
+*
+* Runs are last-run-wins: starting a new run aborts the previous one's
+* signal and retires it — a retired run's settlement (value or rejection)
+* never touches state or pending. The signal also aborts on unmount and
+* when an enclosing Activity hides.
+*/
+function useActionState(action, initialState) {
+	return resolveDispatcher().useActionState(action, initialState);
+}
+function useId() {
+	return resolveDispatcher().useId();
+}
+function useDeferredValue(value, initialValue) {
+	return resolveDispatcher().useDeferredValue(value, initialValue, arguments.length > 1);
+}
+function useMemo(calculate, deps) {
+	return resolveDispatcher().useMemo(calculate, deps);
+}
+function useTransition() {
+	return resolveDispatcher().useTransition();
+}
+function useCallback(callback, deps) {
+	return resolveDispatcher().useMemo(() => callback, deps);
+}
+function useReactive(effect, deps) {
+	resolveDispatcher().useReactive(effect, deps);
+}
+function useBeforePaint(effect, deps) {
+	resolveDispatcher().useBeforePaint(effect, deps);
+}
+function useBeforeLayout(effect, deps) {
+	resolveDispatcher().useBeforeLayout(effect, deps);
+}
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+	return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useStableEvent(handler) {
+	return resolveDispatcher().useStableEvent(handler);
+}
+function readContext(context) {
+	return resolveDispatcher("readContext can only be called while rendering a component.").readContext(context);
+}
+function readPromise(promise) {
+	return resolveDispatcher("readPromise can only be called while rendering a component.").readPromise(promise);
+}
+function readData(resource, ...args) {
+	return resolveDispatcher("readData can only be called while rendering a component.").readData(resource, args);
+}
+function preloadData(resource, ...args) {
+	if (currentDispatcher !== null) {
+		currentDispatcher.preloadData(resource, args);
+		return;
+	}
+	resolveDataStore().preloadData(resource, ...args);
+}
+function setCurrentDispatcher(dispatcher) {
+	const previousDispatcher = currentDispatcher;
+	currentDispatcher = dispatcher;
+	return previousDispatcher;
+}
+function resolveDispatcher(message = "Hooks can only be called while rendering a component.") {
+	if (currentDispatcher === null) throw new Error(message);
+	return currentDispatcher;
+}
+function resolveDataStore() {
+	return resolveCurrentDataStore("No ambient Fig data store. Data APIs work synchronously during render, event handlers, actions, and effects — not after an await. Capture readDataStore() (or root.data) synchronously and call the handle instead.");
+}
+//#endregion
+//#region src/mixin.ts
+const FigMixinSymbol = Symbol.for("fig.mixin");
+const FigMixinSlotSymbol = Symbol.for("fig.mixin-slot");
+const FigClientOnlyHostBehaviorSymbol = Symbol.for("fig.client-only-host-behavior");
+/** Creates a render-time host behavior for the `mix` prop. */
+function createMixin(type) {
+	const descriptorType = type;
+	return (...args) => ({
+		$$typeof: FigMixinSymbol,
+		args,
+		type: descriptorType
+	});
+}
+const maximumResolvedMixins = 1024;
+function resolveHostMix(type, input) {
+	const props = input;
+	const mix = props.mix;
+	delete props.mix;
+	let resolvedMixins = 0;
+	function resolve(value, slot) {
+		if (emptyMixinValue(value)) return;
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) resolve(value[index], `${slot}.${index}`);
+			return;
+		}
+		if (!isMixinDescriptor(value)) throw new Error(`The mix prop on <${type}> must contain descriptors created by createMixin().`);
+		resolvedMixins += 1;
+		if (resolvedMixins > maximumResolvedMixins) throw new Error(`The mix prop on <${type}> resolved more than ${maximumResolvedMixins} mixins.`);
+		const context = {
+			[FigMixinSlotSymbol]: slot,
+			props,
+			type
+		};
+		const result = value.type(context, ...value.args);
+		if (emptyMixinValue(result)) return;
+		if (isMixinDescriptor(result) || Array.isArray(result)) {
+			resolve(result, `${slot}.result`);
+			return;
+		}
+		if (typeof result !== "object") throw new Error(`A mixin on <${type}> must return host props, more mixins, or nothing.`);
+		const returnedProps = result;
+		if ("children" in returnedProps || "key" in returnedProps || "unsafeHTML" in returnedProps) throw new Error(`A mixin on <${type}> cannot return children, key, or unsafeHTML.`);
+		const { mix: nestedMix, ...patch } = returnedProps;
+		Object.assign(props, patch);
+		resolve(nestedMix, `${slot}.mix`);
+	}
+	resolve(mix, "0");
+	props.mix = mix;
+	return props;
+}
+function mixinSlot(context) {
+	return context[FigMixinSlotSymbol];
+}
+function markClientOnlyHostBehavior(context, behavior) {
+	if (context.props[FigClientOnlyHostBehaviorSymbol] !== void 0) return;
+	Object.defineProperty(context.props, FigClientOnlyHostBehaviorSymbol, {
+		configurable: true,
+		value: behavior
+	});
+}
+function clientOnlyHostBehavior(props) {
+	const behavior = props[FigClientOnlyHostBehaviorSymbol];
+	return typeof behavior === "string" ? behavior : void 0;
+}
+function emptyMixinValue(value) {
+	return value === false || value === 0 || value === 0n || value === "" || value === null || value === void 0;
+}
+function isMixinDescriptor(value) {
+	return typeof value === "object" && value !== null && "$$typeof" in value && value.$$typeof === FigMixinSymbol;
+}
+//#endregion
+//#region src/element.ts
+const Fragment = Symbol.for("fig.fragment");
+const FigElementSymbol = Symbol.for("fig.element");
+const FigClientReferenceSymbol = Symbol.for("fig.client-reference");
+const FigActivitySymbol = Symbol.for("fig.activity");
+const FigErrorBoundarySymbol = Symbol.for("fig.error-boundary");
+const FigPortalSymbol = Symbol.for("fig.portal");
+const FigAssetsSymbol = Symbol.for("fig.assets");
+const FigSuspenseSymbol = Symbol.for("fig.suspense");
+const FigViewTransitionSymbol = Symbol.for("fig.view-transition");
+const Assets = Object.assign((props) => props.children, { $$typeof: FigAssetsSymbol });
+const ErrorBoundary = Object.assign((props) => props.children, { $$typeof: FigErrorBoundarySymbol });
+const Suspense = Object.assign((props) => props.children, { $$typeof: FigSuspenseSymbol });
+const Activity = Object.assign((props) => props.children, { $$typeof: FigActivitySymbol });
+const ViewTransition = Object.assign((props) => props.children, { $$typeof: FigViewTransitionSymbol });
+function createElement(type, config, ...children) {
+	const props = { ...config };
+	const key = props.key ?? null;
+	delete props.key;
+	if (children.length === 1) props.children = children[0];
+	else if (children.length > 1) props.children = children;
+	return {
+		$$typeof: FigElementSymbol,
+		type,
+		key,
+		props: "mix" in props && typeof type === "string" ? resolveHostMix(type, props) : props
+	};
+}
+function isValidElement(value) {
+	return hasObjectBrand(value, FigElementSymbol);
+}
+function createPortalNode(children, target, key = null) {
+	return {
+		$$typeof: FigPortalSymbol,
+		children,
+		key,
+		target
+	};
+}
+function isPortal(value) {
+	return hasObjectBrand(value, FigPortalSymbol);
+}
+function clientReference(options) {
+	return Object.assign(() => {
+		throw new Error(`Client reference "${options.id}" cannot be rendered on the server directly.`);
+	}, {
+		$$typeof: FigClientReferenceSymbol,
+		assets: options.assets,
+		id: options.id,
+		ssr: options.ssr
+	});
+}
+function lazy(load) {
+	let promise = null;
+	let rejected = false;
+	const Lazy = (props) => {
+		if (promise === null) {
+			rejected = false;
+			const next = Promise.resolve(load()).then((value) => value, (error) => {
+				if (promise === next) rejected = true;
+				throw error;
+			});
+			promise = next;
+		}
+		try {
+			return createElement(readPromise(promise), props);
+		} catch (error) {
+			if (rejected) {
+				promise = null;
+				rejected = false;
+			}
+			throw error;
+		}
+	};
+	return Lazy;
+}
+function isClientReference(value) {
+	return hasFunctionBrand(value, FigClientReferenceSymbol);
+}
+function isSuspense(value) {
+	return hasFunctionBrand(value, FigSuspenseSymbol);
+}
+function isActivity(value) {
+	return hasFunctionBrand(value, FigActivitySymbol);
+}
+function isErrorBoundary(value) {
+	return hasFunctionBrand(value, FigErrorBoundarySymbol);
+}
+function isViewTransition(value) {
+	return hasFunctionBrand(value, FigViewTransitionSymbol);
+}
+function isAssets(value) {
+	return hasFunctionBrand(value, FigAssetsSymbol);
+}
+function hasObjectBrand(value, brand) {
+	return typeof value === "object" && value !== null && "$$typeof" in value && value.$$typeof === brand;
+}
+function hasFunctionBrand(value, brand) {
+	return typeof value === "function" && "$$typeof" in value && value.$$typeof === brand;
+}
+//#endregion
+export { loadContextCapabilities as $, markClientOnlyHostBehavior as A, useBeforePaint as B, isSuspense as C, FigMixinSymbol as D, lazy as E, readData as F, useReactive as G, useDeferredValue as H, readPromise as I, useSyncExternalStore as J, useStableEvent as K, setCurrentDispatcher as L, resolveHostMix as M, preloadData as N, clientOnlyHostBehavior as O, readContext as P, isAttributableError as Q, useActionState as R, isPortal as S, isViewTransition as T, useId as U, useCallback as V, useMemo as W, dataResourceKeysForError as X, useTransition as Y, defineLoadContextCapabilities as Z, createPortalNode as _, FigAssetsSymbol as a, isClientReference as b, FigErrorBoundarySymbol as c, FigViewTransitionSymbol as d, markDataResourceError as et, Fragment as f, createElement as g, clientReference as h, FigActivitySymbol as i, mixinSlot as j, createMixin as k, FigPortalSymbol as l, ViewTransition as m, Assets as n, setCurrentDataStore as nt, FigClientReferenceSymbol as o, Suspense as p, useState as q, ErrorBoundary as r, FigElementSymbol as s, Activity as t, resolveCurrentDataStore as tt, FigSuspenseSymbol as u, isActivity as v, isValidElement as w, isErrorBoundary as x, isAssets as y, useBeforeLayout as z };
+
+//# sourceMappingURL=element-DmbzNH0T.js.map