@yahoo/uds-v5-wip 1.60.0 → 1.62.0

package/dist/config/dist/factories.js

@@ -0,0 +1,393 @@
+import { attachSourcePath, captureCallerPath } from "./captureCallerPath.js";
+import { composite, styleProp, tag, token } from "./refs.js";
+import { darken, lighten } from "./colorExpressions.js";
+import "./defineProvider.js";
+//#region ../config/dist/factories.js
+function defineTokenGroup(t) {
+	const out = {
+		tokens: t,
+		metadata(meta) {
+			if (meta.label !== void 0) out.label = meta.label;
+			if (meta.description !== void 0) out.description = meta.description;
+			return out;
+		}
+	};
+	attachSourcePath(out, captureCallerPath());
+	Object.defineProperty(out, "metadata", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value: out.metadata
+	});
+	return out;
+}
+function defineModifier(t) {
+	return attachSourcePath(t, captureCallerPath());
+}
+function defineMode(t) {
+	return attachSourcePath(t, captureCallerPath());
+}
+function defineCompositeStyle(t) {
+	return attachSourcePath(t, captureCallerPath());
+}
+function defineMotion(t) {
+	return attachSourcePath(t, captureCallerPath());
+}
+function defineComponentGroup(t) {
+	return attachSourcePath(t, captureCallerPath());
+}
+/**
+* Author a style-prop spec. `P` is inferred from `cssProperty` so the
+* `values` array narrows against the chosen CSS property's accepted
+* keyword union (`'transparent'` is OK for `border-color`, errors for
+* `padding`). For custom properties (`--foo`), `values` accepts open
+* strings — `cssType` constrains the runtime value space instead.
+*
+* Returns the spec with a non-enumerable `.metadata({...})` chain;
+* the chain merges the supplied bag into `spec.metadata` so multiple
+* `.metadata({...})` calls accumulate.
+*/
+function defineStyleProp(spec) {
+	const attached = attachSourcePath(spec, captureCallerPath());
+	Object.defineProperty(attached, "metadata", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value(meta) {
+			attached.metadata = {
+				...attached.metadata ?? {},
+				...meta
+			};
+			return attached;
+		}
+	});
+	Object.defineProperty(attached, "withOpacity", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value(opacitySpec) {
+			attached.opacityPair = {
+				as: opacitySpec.as,
+				values: opacitySpec.values,
+				separator: opacitySpec.separator ?? "_",
+				ref: opacitySpec.as
+			};
+			return attached;
+		}
+	});
+	return attached;
+}
+function slot(pathOrOptions, options) {
+	let marker;
+	const openOptions = typeof pathOrOptions === "object" ? pathOrOptions : void 0;
+	const pathOrLayer = typeof pathOrOptions === "string" ? pathOrOptions : void 0;
+	const valueType = openOptions?.type ?? options?.type;
+	if (pathOrLayer === void 0) marker = { __kind: "slot" };
+	else if (options?.prop !== void 0) marker = {
+		__kind: "slot",
+		layer: pathOrLayer,
+		layerProp: options.prop
+	};
+	else {
+		const slash = pathOrLayer.indexOf("/");
+		marker = slash === -1 ? {
+			__kind: "slot",
+			layer: pathOrLayer,
+			layerProp: "children"
+		} : {
+			__kind: "slot",
+			layer: pathOrLayer.slice(0, slash),
+			layerProp: pathOrLayer.slice(slash + 1)
+		};
+	}
+	if (valueType !== void 0) Object.defineProperty(marker, "__valueType", {
+		enumerable: true,
+		configurable: true,
+		writable: true,
+		value: valueType
+	});
+	Object.defineProperty(marker, "required", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value() {
+			Object.defineProperty(marker, "__required", {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: true
+			});
+			return marker;
+		}
+	});
+	Object.defineProperty(marker, "accepts", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value(component) {
+			Object.defineProperty(marker, "__accepts", {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: Array.isArray(component) ? component : [component]
+			});
+			return marker;
+		}
+	});
+	Object.defineProperty(marker, "transform", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value(fn) {
+			Object.defineProperty(marker, "__transform", {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: fn
+			});
+			return marker;
+		}
+	});
+	return marker;
+}
+/**
+* Attach a chainable `.required()` method to a marker that flips
+* `__required: true` and returns the same marker reference (so further
+* chaining still works).
+*/
+function attachRequired(marker) {
+	Object.defineProperty(marker, "required", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value() {
+			Object.defineProperty(marker, "__required", {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: true
+			});
+			return marker;
+		}
+	});
+	return marker;
+}
+/**
+* Boolean-prop binding. Codegen emits the prop as `<name>?: boolean`
+* and routes presence/absence into a per-layer `data-${name}` attribute
+* the runtime selects on. Mirrors the old `@uds/config` `helpers.boolean()`.
+*
+* The optional `values` argument carries per-state per-layer styles
+* (`{ true: { root: {...} }, false: { root: {...} } }`) — codegen emits
+* one variant CSS class per layer per state, same as `variant({...})`.
+*
+* `.required()` flips the prop to mandatory at JSX call sites.
+*/
+function boolean(values) {
+	return attachRequired(values === void 0 ? { __kind: "boolean" } : {
+		__kind: "boolean",
+		values
+	});
+}
+/**
+* Cross-layer style override — `_hover: layer('close', { opacity: 1 })`
+* declares "when this layer is hovered, apply these styles to the
+* named layer". Codegen emits a descendant-combinator rule pointing
+* from the source layer's selector to the target layer's selector.
+* Mirrors the old `@uds/config` `helpers.layer()`.
+*/
+function layer(layerName, styles) {
+	return {
+		__kind: "layer",
+		layer: layerName,
+		styles
+	};
+}
+function variant(values, defaultValue) {
+	return attachRequired(defaultValue === void 0 ? {
+		__kind: "variant",
+		values
+	} : {
+		__kind: "variant",
+		values,
+		default: defaultValue
+	});
+}
+/**
+* Wide-string prop binding. Codegen emits the prop as `<name>?: string`
+* (or required when chained with `.required()`). No CSS effect — use
+* this for free-form text props (URLs, labels). When you want a
+* constrained list of accepted strings, reach for the array form of
+* `variant(...)` instead.
+*/
+function string() {
+	return attachRequired({ __kind: "string" });
+}
+/**
+* Wide-number prop binding. Codegen emits the prop as `<name>?: number`
+* (or required when chained with `.required()`). No CSS effect — use
+* this for free-form numeric props (tabIndex, count). When you want a
+* constrained list of accepted numbers, reach for the array form of
+* `variant(...)` instead.
+*/
+function number() {
+	return attachRequired({ __kind: "number" });
+}
+/**
+* Axis marker for `.preview({ matrix: { columns, rows } })`. The
+* `kind` field discriminates between prop axes (varies a JSX prop
+* across the grid) and modifier axes (toggles a `_${name}` modifier
+* across the grid). Studio reads these to build the canvas preview;
+* codegen round-trips them verbatim through `Component.preview`.
+*
+* `.nest(child)` builds a 2-D nesting — the outer axis steps once
+* per child-axis sweep. Mirrors the old `@uds/config` matrix shape.
+*/
+function makePreviewAxis(source, nested) {
+	return {
+		__kind: "previewAxis",
+		...source,
+		...nested !== void 0 ? { nested } : {},
+		nest(child) {
+			return makePreviewAxis(source, child);
+		}
+	};
+}
+const configHelpers = {
+	slot,
+	variant,
+	boolean,
+	string,
+	number,
+	layer,
+	composite,
+	styleProp,
+	token,
+	darken,
+	lighten
+};
+/**
+* Normalize the `props()` argument to a rule list: a flat bag becomes a
+* single unconditional rule; a rule array passes through.
+*/
+function normalizePropsRules(arg) {
+	return Array.isArray(arg) ? arg : [{ props: arg }];
+}
+const previewHelpers = {
+	prop: (name) => makePreviewAxis({
+		kind: "prop",
+		prop: name
+	}),
+	modifier: (name) => makePreviewAxis({
+		kind: "modifier",
+		modifier: name
+	}),
+	props: (arg) => makePreviewAxis({
+		kind: "props",
+		rules: normalizePropsRules(arg)
+	})
+};
+/**
+* Fields merged shallowly when `.config(cb)` runs — each subkey from a
+* later call overlays the same subkey on the seed (so `defaultProps:
+* { as: 'path' }` doesn't drop Box's inherited defaults). Other fields
+* (`compoundProps`, `motion` scalar) overwrite.
+*/
+const MERGEABLE_NESTED_FIELDS = new Set([
+	"props",
+	"base",
+	"defaultProps",
+	"motion"
+]);
+function mergeConfigIntoSeed(seed, addition) {
+	for (const [key, value] of Object.entries(addition)) {
+		if (MERGEABLE_NESTED_FIELDS.has(key) && typeof value === "object" && value !== null) {
+			const existing = seed[key];
+			const base = typeof existing === "object" && existing !== null ? existing : {};
+			if (key === "base") {
+				const merged = { ...base };
+				for (const [layerName, layerStyles] of Object.entries(value)) {
+					const prevLayer = merged[layerName];
+					merged[layerName] = typeof prevLayer === "object" && prevLayer !== null && typeof layerStyles === "object" && layerStyles !== null ? {
+						...prevLayer,
+						...layerStyles
+					} : layerStyles;
+				}
+				seed[key] = merged;
+				continue;
+			}
+			seed[key] = {
+				...base,
+				...value
+			};
+			continue;
+		}
+		seed[key] = value;
+	}
+}
+function isComponentBuilderValue(value) {
+	return typeof value === "object" && value !== null && typeof value.config === "function";
+}
+function attachChainMethods(seed) {
+	const def = (key, value) => {
+		Object.defineProperty(seed, key, {
+			enumerable: false,
+			configurable: true,
+			writable: true,
+			value
+		});
+	};
+	def("config", function configMethod(cb) {
+		mergeConfigIntoSeed(seed, cb(configHelpers));
+		return seed;
+	});
+	def("render", function renderMethod(fn) {
+		def("__renderFn", fn);
+		def("__hasRenderFn", true);
+		return seed;
+	});
+	def("preview", function previewMethod(spec) {
+		def("__preview", typeof spec === "function" ? spec(previewHelpers) : spec);
+		return seed;
+	});
+	def("subcomponents", function subcomponentsMethod(children) {
+		for (const [childName, child] of Object.entries(children)) if (typeof child !== "object" || child === null || typeof child.layers !== "object") throw new Error(`subcomponents: entry "${childName}" is not a component definition`);
+		def("__subcomponents", children);
+		return seed;
+	});
+	def("metadata", function metadataMethod(meta) {
+		seed.metadata = {
+			...seed.metadata ?? {},
+			...meta
+		};
+		return seed;
+	});
+	return seed;
+}
+function defineComponentImpl(arg) {
+	let seed;
+	let extendsFromRef;
+	if (typeof arg === "string") seed = { layers: { root: tag(arg) } };
+	else if (isComponentBuilderValue(arg)) {
+		const source = arg;
+		seed = { ...source };
+		extendsFromRef = source;
+	} else seed = arg;
+	attachSourcePath(seed, captureCallerPath());
+	attachChainMethods(seed);
+	if (extendsFromRef !== void 0) Object.defineProperty(seed, "__extendsFrom", {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value: extendsFromRef
+	});
+	return seed;
+}
+defineComponentImpl.layers = function layersEntry(layers) {
+	const seed = { layers };
+	attachSourcePath(seed, captureCallerPath());
+	return attachChainMethods(seed);
+};
+const defineComponent = defineComponentImpl;
+//#endregion
+export { boolean, defineComponent, defineComponentGroup, defineCompositeStyle, defineMode, defineModifier, defineMotion, defineStyleProp, defineTokenGroup, number, slot, string, variant };

package/dist/config/dist/foreign-component-name.js

@@ -0,0 +1,42 @@
+//#region ../config/dist/foreign-component-name.js
+/**
+* Reserved registry namespace for third-party leaf components — the prefix in a
+* `foreign:<displayName>` key. Not a peer design-system namespace (those are
+* meaningful disambiguation); it marks "not a UDS component," so display
+* surfaces strip it to the bare name.
+*/
+const FOREIGN_NAMESPACE = "foreign";
+const FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+const MEMO_TYPE = Symbol.for("react.memo");
+function nameOf(value) {
+	if (typeof value !== "object" && typeof value !== "function") return null;
+	const named = value;
+	if (typeof named.displayName === "string" && named.displayName.length > 0) return named.displayName;
+	if (typeof named.name === "string" && named.name.length > 0) return named.name;
+	return null;
+}
+/**
+* Display name for a `forwardRef`/`memo` component object — preferring its own
+* `displayName`, then the wrapped function's name. Returns `null` for anything
+* that isn't one of those wrappers, and for an anonymous wrapper with no
+* resolvable name (so the JSX runtime can keep it as a pending ref instead).
+*/
+function foreignComponentName(type) {
+	if (type === null || typeof type !== "object") return null;
+	const wrapper = type;
+	if (wrapper.$$typeof === FORWARD_REF_TYPE) return nameOf(type) ?? nameOf(wrapper.render);
+	if (wrapper.$$typeof === MEMO_TYPE) return nameOf(type) ?? nameOf(wrapper.type);
+	return null;
+}
+/**
+* Registry key for a foreign component: `foreign:<displayName>`. The
+* `foreign:` namespace keeps a third-party component (e.g. an icon named
+* `Button`) from clobbering a registered UDS component of the same name.
+* Returns `null` when the component has no resolvable foreign name.
+*/
+function foreignRegistryKey(type) {
+	const name = foreignComponentName(type);
+	return name === null ? null : `${FOREIGN_NAMESPACE}:${name}`;
+}
+//#endregion
+export { FOREIGN_NAMESPACE, foreignRegistryKey };

package/dist/config/dist/index.d.ts

@@ -1,13 +1,31 @@
-import { ComponentRef, CompositeRef, RegisteredComponents, RegisteredComposites, RegisteredStyleProps, StylePropRef } from "./component-refs.js";
-import { BoolMarker, ComponentConfigValue, ComposedLayer, CompositeBinding, CompoundVariant, EnumMarker, HtmlTag, LayerInput, PrimitiveLayer, PrimitivePropBinding, PropBinding, RootTag, SingleLayerCompositeBinding, StylePropBinding, StylePropShorthand, VerbosePropBinding } from "./component-config.js";
-import { Props } from "./Props.js";
-import { BoundComponent } from "./defineComponent.js";
-import { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, HexColor, HslColor, RgbColor } from "./types/css-values.js";
-import { AnyStyleProp, ArbitraryEntry, ArbitrarySpec, StylePropMetadata } from "./defineStyleProp.js";
-import { TokenType, VarGroupDef, VarTokenDef, VarsConfig } from "./types.js";
-import { AtomicToken, BuildOptions, CheckForReservedModifiersInput, ComponentConfig, DefineComponentInput, DefineComponentMotionInput, ExampleDef, ExampleEntryDef, ExampleLayoutStyles, GetModifierFromInput, GlobalStylesDef, InterpolateMarker, ModeGroup, ModeOption, ModeOptionInput, ModeSetInput, ModesInput, ModifierDef, MotionPresetsDef, SingleComponentDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig } from "./createConfig.js";
-import { ResolvedStyleProp, ResolvedToken } from "./resolveStyleProp.js";
-import { defaultColors } from "./consts/defaultColors.js";
-import { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig } from "./serialize.js";
-import { ComponentsConfig as ComponentsConfig$1 } from "@uds/types";
-export { type ComponentsConfig$1 as ComponentsConfig };
+import { ASSET_CLASS_CAPABILITIES, AssetKind, isPlaceable } from "./asset-kind.js";
+import { AnyRef, AssetGroupName, AssetGroupRef, ComponentName, ComponentRef, CompositeName, CompositeRef, CompositeRefBuilder, ModeName, ModeRef, RegisteredAssetGroups, RegisteredComponents, RegisteredCompositeStyles, RegisteredModes, RegisteredModifiers, RegisteredMotionDefs, RegisteredStyleProps, RegisteredTokenGroups, StylePropName, StylePropRef, TagName, TagRef, TokenGroupName, TokenGroupRef, TokenName, TokenQualifiedName, TokenRef, assetGroup, component, composite, isAssetGroupRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, tag, token, tokenGroup } from "./refs.js";
+import { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, CssVarRef, HexColor, HslColor, RgbColor } from "./types/css-values.js";
+import { ColorExpression, ColorSpace, ColorValue, GradientStop, GradientValue, LengthOrPercent, LineDirection, LinearGradientExpr, MixExpr, RadialGradientExpr, RadialSize, TokenRefToCss, alpha, isColorExpression, isLinearGradientExpr, isMixExpr, isRadialGradientExpr, linearGradient, mix, radialGradient, resolveColorExpression } from "./colorExpressions.js";
+import { CSS_GLOBAL_KEYWORDS, CSS_PROPERTY_KEYWORDS, CssPropertyWithKeywords } from "./types/css-property-keywords.js";
+import { ColorCssProperty, CssGlobalKeyword, CssPropertyName, CssPropertyValues } from "./types/css-properties.js";
+import { AssetGroupBuilder, AssetGroupConfig, AssetGroupDefinition, FontAssetGroupConfig, FontAssetGroupDefinition, IconAssetGroupConfig, IconAssetGroupDefinition, IconAssetMember, IconAssetMetadata, defineAssetGroup, defineAssetIcon } from "./defineAssetGroup.js";
+import { AnyStylePropDefinition, ArbitrarySpec, BaseStyles, BuildOptions, ComponentDefinition, ComponentGroupDefinition, ComponentMetadata, CompositeStyleDefinition, CompositeStyleObject, CompoundPropsEntry, CssMotionDefinition, FontAssetMember, GlobalStylesDef, JsMotionDefinition, LayerInput, LiteralFor, ModeDefinition, ModeOptionDefinition, ModifierDefinition, MotionDefinitionInput, MotionKeyframes, MotionStateKeyframe, MotionTransition, OpacityPairSpec, PreviewDefinition, PropBinding, SerializedAssetGroup, SerializedComponentGroup, SerializedConfig, SerializedFontAssetGroup, SerializedIconAssetGroup, SerializedTokenGroup, SlotMotion, StylePropDefinition, StylePropMetadata, StylePropProperty, TokenDefinition, TokenGroupDefinition, TokenModifierKey, TokenModifierValue, TokenType, TokenValue, ValuesEntry } from "./types.js";
+import { AssetGroup } from "./AssetGroup.js";
+import { Css, CssClassName, CssDeclaration, CssSelector, CssVar, cssClassName, cssDeclaration, cssSelector, cssVar } from "./brands.js";
+import { BooleanMarker, LayerMarker, NumberMarker, PREVIEW_SEED_KEY, PreviewAxisMarker, PreviewPropsRule, RequiredBrand, SlotMarker, SlotRef, SlotValueType, StringMarker, VariantMarker, VariantMarkerArray, VariantMarkerObject, isBoolMarker, isLayerMarker, isNumberMarker, isPreviewAxisMarker, isSlotMarker, isStringMarker, isVariantArrayMarker, isVariantMarker, matchesPreviewWhen, resolvePreviewRules } from "./markers.js";
+import { Component, ComponentKind, CompositeInfo, FunctionInfo, Layer, PrimitivePropKind, PropBase, PropInfo, PropKind, ResolvedCompoundOverrides, SlotInfo, SlotValueKind, StylePropInfo, StylePropKeyword, StylePropTokenUsage, VariantInfo } from "./Component.js";
+import { ComponentGroup } from "./ComponentGroup.js";
+import { CompositeStyle } from "./CompositeStyle.js";
+import { makeTokenRefToCss } from "./entity-utils.js";
+import { DataAttrs } from "./Props.js";
+import { BoundComponent, ComponentBuilder, ComponentBuilderMethods, ComponentRenderFn, ConfigCallbackHelpers, DefineComponentFn, DefinedComponent, DefinedProvider, DefinedStyleProp, DefinedTokenGroup, PreviewCallbackHelpers, TokenGroupMetadata, TypedSlotRef, boolean, defineComponent, defineComponentGroup, defineCompositeStyle, defineMode, defineModifier, defineMotion, defineStyleProp, defineTokenGroup, number, slot, string, variant } from "./factories.js";
+import { defineProvider } from "./defineProvider.js";
+import { Mode, ModeOption } from "./Mode.js";
+import { Modifier } from "./Modifier.js";
+import { CssMotionDef, JsMotionDef, MotionDef } from "./MotionDef.js";
+import { Provider } from "./Provider.js";
+import { ResolvedTokenLiteral, Token } from "./Token.js";
+import { StyleProp } from "./StyleProp.js";
+import { TokenGroup } from "./TokenGroup.js";
+import { Config, DependenciesQuery, DependencyKind, DependencyRef, DependentsQuery, parseRegistryKey } from "./Config.js";
+import { SOURCE_PATH_KEY, attachSourcePath, captureCallerPath, readSourcePath } from "./captureCallerPath.js";
+import { ELEMENT_MARKER_KIND, ElementMarker, OpaqueLeafPredicate, hasElementMarkerDeep, isElementLikeValue, isElementMarker, reviveElementMarkersDeep } from "./element-marker.js";
+import { interpolate } from "./interpolate.js";
+import { ModeBackedModifierDefinition, ModeBackedModifierInput, ModeBackedModifierLookup, OverrideModeRef, OverrideRow, buildModeBackedModifierLookup, buildNestedModifierUpdate, createModeBackedModifierLookup, mergeModifierUpdates, modifierIdToPath, modifierPathToId, modifierTreeToOverrideRows, overrideRowsToModifierTree, resolveOverrideRowValue } from "./token-override-rows.js";
+import { rem } from "./units.js";

package/dist/config/dist/index.js

@@ -1,11 +1,27 @@
-import "./component-resolution.js";
-import "./consts/defaultColors.js";
-import "./propertyAcceptedTypes.js";
+import "./brands.js";
+import "./entity-utils.js";
+import "./AssetGroup.js";
+import "./asset-kind.js";
+import "./captureCallerPath.js";
 import "./refs.js";
-import "./resolveTokenTypes.js";
-import "./resolveStyleProp.js";
-import "./createConfig.js";
-import "./defineComponent.js";
-import "./defineStyleProp.js";
-import "./propertyGroups.js";
-import "./serialize.js";
+import "./colorExpressions.js";
+import "./defineAssetGroup.js";
+import "./element-marker.js";
+import "./markers.js";
+import "./Component.js";
+import "./ComponentGroup.js";
+import "./CompositeStyle.js";
+import "./Mode.js";
+import "./Modifier.js";
+import "./MotionDef.js";
+import "./Provider.js";
+import "./StyleProp.js";
+import "./Token.js";
+import "./TokenGroup.js";
+import "./Config.js";
+import "./defineProvider.js";
+import "./factories.js";
+import "./interpolate.js";
+import "./token-override-rows.js";
+import "./types/css-property-keywords.js";
+import "./units.js";

package/dist/config/dist/interpolate.d.ts

@@ -0,0 +1,21 @@
+//#region ../config/dist/interpolate.d.ts
+//#region src/interpolate.d.ts
+/**
+ * Motion interpolation marker — used inside `JsMotionDefinition`
+ * keyframes to declare an index-based interpolation (e.g. stagger).
+ *
+ * Codegen's `motion-transform.ts` detects `{ __type: 'interpolate' }`
+ * shapes on keyframe values and lifts them into the renderer's
+ * `useTransform`-style interpolation.
+ */
+interface InterpolateMarker {
+  readonly __type: 'interpolate';
+  readonly output: readonly number[];
+  readonly extrapolate: 'clamp' | 'extend' | 'identity';
+}
+declare function interpolate(config: {
+  output: readonly number[];
+  extrapolate?: 'clamp' | 'extend' | 'identity';
+}): InterpolateMarker; //#endregion
+//#endregion
+export { interpolate };

package/dist/{foundational-presets/dist/motion.js → config/dist/interpolate.js}

@@ -1,4 +1,4 @@
-//#region ../foundational-presets/dist/motion.js
+//#region ../config/dist/interpolate.js
 function interpolate(config) {
 	return {
 		__type: "interpolate",