@animus-ui/system 0.1.15 → 0.1.17

package/dist/createClassResolver-CcCgar2Z.js

@@ -0,0 +1,360 @@
+import { isUnitlessProperty } from "@animus-ui/properties";
+//#region src/runtime/is-dev.ts
+/**
+* The define token is tested as the initializer's own conditional, never from
+* inside the fallback: only there can a minifier drop the dev-gated code.
+*/
+const IS_DEV = typeof __ANIMUS_DEV__ === "boolean" ? __ANIMUS_DEV__ : (() => {
+	try {
+		if (typeof process !== "undefined" && typeof process.env === "undefined") return true;
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+})();
+//#endregion
+//#region src/runtime/witness.ts
+const WITNESS_CAP = 5e3;
+function recordWitness(component, prop, value, outcome) {
+	if (!IS_DEV) return;
+	const g = globalThis;
+	const buf = g.__ANIMUS_WITNESS__ ??= [];
+	buf.push({
+		component,
+		prop,
+		value: String(value),
+		outcome
+	});
+	if (buf.length > 5e3) buf.splice(0, buf.length - WITNESS_CAP);
+}
+//#endregion
+//#region src/runtime/resolveClasses.ts
+/**
+* A mixed property set resolves to unitless: a bare number on a length
+* property is dropped by the parser, `px` on a unitless one shifts layout.
+*/
+function applyUnitFallback(value, cssProperties) {
+	if (typeof value === "number") {
+		if (cssProperties.some(isUnitlessProperty)) return String(value);
+		return `${value}px`;
+	}
+	return String(value);
+}
+/**
+* The key format is fixed by the Rust css generator; a divergence here misses
+* every static class lookup.
+*/
+function serializeValueKey(value) {
+	if (typeof value === "number" || typeof value === "string") return String(value);
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.keys(value).sort().map((k) => `${k}:${value[k]}`).join("|");
+	return String(value);
+}
+/**
+* A callback, inline or configured, can tell `100` from `"100"`, so its static classes are keyed by
+* type: a string is its JSON literal, a number its decimal text, a
+* responsive value `{…}` its `"breakpoint":key` entries in key order. Must
+* stay in step with the Rust css generator.
+*/
+function typedValueKey(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const entries = value;
+		return `{${Object.keys(entries).sort().map((k) => `${JSON.stringify(k)}:${typedValueKey(entries[k])}`).join(",")}}`;
+	}
+	return String(value);
+}
+function isValidTransformResult(result) {
+	return typeof result === "string" || typeof result === "number" && Number.isFinite(result);
+}
+/**
+* The domain is results that failed `isValidTransformResult`; a valid string
+* or finite number passed here is mislabeled.
+*/
+function describeResultShape(result) {
+	if (result === null) return "null";
+	if (Array.isArray(result)) return "array";
+	if (typeof result === "number") return "non-finite-number";
+	return typeof result;
+}
+function negateCssValue(css) {
+	if (css.includes("(")) return `calc(${css} * -1)`;
+	if (css === "0" || css === "-0") return "0";
+	if (css.startsWith("-")) return css.slice(1);
+	return `-${css.startsWith("+") ? css.slice(1) : css}`;
+}
+/** A CSS `<number>`, exponent included. */
+const CSS_NUMBER = String.raw`[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?`;
+const CONTAINER_UNIT = new RegExp(`^${CSS_NUMBER}(?:cqw|cqi|cqh|cqb|cqmin|cqmax)$`);
+const SIZE_LENGTH = new RegExp(`^${CSS_NUMBER}(?:px|rem|vh|vw|vmax|vmin|%)$`);
+const SIZE_PROPERTY = /^(?:left|right|top|bottom|inset|width|height)$|(?:Width|Height|-width|-height)$/;
+/**
+* Values a strict prop's public type admits beside its tokens: zero, the
+* keywords extraction lists for its property, container units, token
+* references, and the lengths size properties take. Must stay in step with
+* the extractor's rule.
+*/
+function isAdmittedWithoutToken(value, dc) {
+	if (typeof value === "number") return value === 0;
+	if (typeof value !== "string") return true;
+	return value === "0" || dc.keywords?.includes(value) === true || value.includes("{") || CONTAINER_UNIT.test(value) || dc.property !== void 0 && SIZE_PROPERTY.test(dc.property) && (SIZE_LENGTH.test(value) || value.startsWith("calc("));
+}
+function resolveEntry(value, dc) {
+	const key = String(value);
+	let scaleResolved = dc.scaleValues?.[key];
+	let negate = false;
+	if (scaleResolved == null && dc.negative && typeof value === "number" && value < 0) {
+		scaleResolved = dc.scaleValues?.[String(-value)];
+		negate = scaleResolved != null;
+	}
+	if (scaleResolved == null && dc.strict && dc.scaleValues && !isAdmittedWithoutToken(value, dc)) return { entry: value };
+	const input = scaleResolved ?? value;
+	let transformed = input;
+	if (dc.transform) {
+		try {
+			transformed = dc.transform(input);
+		} catch (cause) {
+			return { cause };
+		}
+		if (!isValidTransformResult(transformed)) return { shape: describeResultShape(transformed) };
+	}
+	let css;
+	if (typeof transformed === "number") {
+		const cssProperties = dc.properties && dc.properties.length > 0 ? dc.properties : dc.property ? [dc.property] : [];
+		css = applyUnitFallback(transformed, cssProperties);
+	} else css = String(transformed);
+	return negate ? negateCssValue(css) : css;
+}
+const warnedDrops = /* @__PURE__ */ new Set();
+function warnDroppedValue(baseClassName, propName, serializedValue, customOwned) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}`;
+		if (warnedDrops.has(dedupeKey)) return;
+		warnedDrops.add(dedupeKey);
+		console.warn(customOwned ? `[animus:drop] ${baseClassName}: value ${serializedValue} on custom prop '${propName}' is none of its extracted values and the prop has no runtime slot — it will not render. A literal missing from the prop's strict scale is reported by the build as animus.props.strict-token-miss; a value passed through an untraced alias is not.` : `[animus:drop] ${baseClassName}: value ${serializedValue} on prop '${propName}' matched no static class and no dynamic slot — it will not render. If this prop should accept runtime values, ensure its dynamic config is emitted.`);
+	}
+}
+/**
+* A value taken from a variant default emits `--{prop}-default`, not the
+* value, so the compose override rule misses and the parent's value wins.
+*/
+function applyVariantClasses(classes, baseClassName, props, config) {
+	if (!config.variants) return;
+	for (const [prop, vc] of Object.entries(config.variants)) {
+		const value = props[prop] ?? vc.default;
+		if (value != null) {
+			const isDefault = !(prop in props) && vc.default != null;
+			classes.push(`${baseClassName}--${prop}-${isDefault ? "default" : value}`);
+			recordWitness(baseClassName, prop, value, "static");
+		}
+	}
+}
+function applyCompoundClasses(classes, props, config) {
+	if (!config.compounds) return;
+	for (const compound of config.compounds) {
+		let match = true;
+		for (const [prop, expected] of Object.entries(compound.conditions)) {
+			const current = props[prop] ?? config.variants?.[prop]?.default;
+			if (Array.isArray(expected) ? !expected.includes(current) : current !== expected) {
+				match = false;
+				break;
+			}
+		}
+		if (match) classes.push(compound.className);
+	}
+}
+function applyStateClasses(classes, baseClassName, props, config, activeStates) {
+	if (!config.states) return;
+	for (const state of config.states) if (props[state]) {
+		classes.push(`${baseClassName}--${state}`);
+		activeStates.push(state);
+		recordWitness(baseClassName, state, "true", "static");
+	}
+}
+const warnedInvalidResults = /* @__PURE__ */ new Set();
+function warnInvalidTransformResult(baseClassName, propName, shape) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}`;
+		if (warnedInvalidResults.has(dedupeKey)) return;
+		warnedInvalidResults.add(dedupeKey);
+		console.warn(`[animus:drop] ${baseClassName}: transform for prop '${propName}' returned ${shape} — expected string or finite number; value dropped`);
+	}
+}
+const warnedThrows = /* @__PURE__ */ new Set();
+const warnedStrictMisses = /* @__PURE__ */ new Set();
+/** Keyed by value, like a throw: each rejected input is reported once. */
+function warnStrictScaleMiss(baseClassName, propName, serializedValue, miss) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}|${serializedValue}`;
+		if (warnedStrictMisses.has(dedupeKey)) return;
+		warnedStrictMisses.add(dedupeKey);
+		const entry = miss.breakpoint === void 0 ? "" : ` (${String(miss.entry)} at ${miss.breakpoint})`;
+		console.warn(`[animus:drop] ${baseClassName}: value ${serializedValue} on prop '${propName}' is not a token of its strict scale${entry}; prop styling dropped`);
+	}
+}
+function describeThrown(cause) {
+	try {
+		return String(cause);
+	} catch {
+		return "unprintable thrown value";
+	}
+}
+/**
+* Read as a string so the console never inspects the thrown value itself; a
+* hostile object could rethrow from an inspecting formatter.
+*/
+function thrownStack(cause) {
+	try {
+		if (!(cause instanceof Error)) return void 0;
+		const stack = cause.stack;
+		return typeof stack === "string" ? stack : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Keyed by value as well as prop: each distinct rejected input is reported
+* once, so the warning never names a stale value.
+*/
+function warnTransformThrow(baseClassName, propName, transformName, serializedValue, cause) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}|${serializedValue}`;
+		if (warnedThrows.has(dedupeKey)) return;
+		warnedThrows.add(dedupeKey);
+		const transform = transformName ? `transform '${transformName}'` : "inline transform";
+		const stack = thrownStack(cause);
+		console.warn(`[animus:drop] ${baseClassName}: ${transform} for prop '${propName}' threw for value ${serializedValue} (${describeThrown(cause)}); prop styling dropped`, ...stack ? [stack] : []);
+	}
+}
+/**
+* Resolution is staged so a drop is atomic: one entry that misses a strict
+* scale, or one transform that throws or returns an invalid result, leaves
+* `classes` and `dynStyle` untouched.
+*/
+function applyDynamicProp(classes, dynStyle, propValue, dc) {
+	const staged = [];
+	if (typeof propValue === "object" && propValue !== null && !Array.isArray(propValue)) for (const [bp, bpVal] of Object.entries(propValue)) {
+		if (bpVal == null) continue;
+		const resolved = resolveEntry(bpVal, dc);
+		if (typeof resolved !== "string") return "entry" in resolved ? {
+			...resolved,
+			breakpoint: bp
+		} : resolved;
+		staged.push(bp === "_" ? [
+			dc.slotClass,
+			dc.varName,
+			resolved
+		] : [
+			`${dc.slotClass}-${bp}`,
+			`${dc.varName}-${bp}`,
+			resolved
+		]);
+	}
+	else {
+		const resolved = resolveEntry(propValue, dc);
+		if (typeof resolved !== "string") return resolved;
+		staged.push([
+			dc.slotClass,
+			dc.varName,
+			resolved
+		]);
+	}
+	for (const [slotClass, varName, resolved] of staged) {
+		classes.push(slotClass);
+		dynStyle[varName] = resolved;
+	}
+	return null;
+}
+/**
+* A declaration prop writes every member of the selected record. The base
+* consuming class applies whenever the prop applies, so a value without a
+* base key reads the base member variables an ancestor wrote, or else leaves
+* lower layers in force. A key outside the scale drops the whole value.
+*/
+function applyDeclarationProp(classes, dynStyle, propValue, dc) {
+	const records = dc.declarationScaleValues;
+	const memberVars = Object.entries(dc.memberVars);
+	const responsive = typeof propValue === "object" && propValue !== null && !Array.isArray(propValue);
+	const entries = responsive ? Object.entries(propValue).filter(([, value]) => value != null) : [["_", propValue]];
+	const staged = [];
+	for (const [breakpoint, value] of entries) {
+		const key = String(value);
+		if (!Object.prototype.hasOwnProperty.call(records, key)) return responsive ? {
+			entry: value,
+			breakpoint
+		} : { entry: value };
+		staged.push([breakpoint, records[key]]);
+	}
+	if (staged.length === 0) return null;
+	classes.push(dc.slotClass);
+	for (const [breakpoint, record] of staged) {
+		const suffix = breakpoint === "_" ? "" : `-${breakpoint}`;
+		if (suffix) classes.push(`${dc.slotClass}${suffix}`);
+		for (const [member, varName] of memberVars) dynStyle[`${varName}${suffix}`] = record[member];
+	}
+	return null;
+}
+function resolveClasses(baseClassName, props, config, systemPropMap, dynamicPropConfig) {
+	const classes = [baseClassName];
+	let dynStyle;
+	applyVariantClasses(classes, baseClassName, props, config);
+	applyCompoundClasses(classes, props, config);
+	const activeStates = [];
+	applyStateClasses(classes, baseClassName, props, config, activeStates);
+	const systemPropNames = config.systemPropNames || [];
+	if (systemPropNames.length > 0) {
+		const { customPropMap, customDynamicConfig } = config;
+		for (const propName of systemPropNames) {
+			if (!(propName in props)) continue;
+			const propValue = props[propName];
+			if (propValue == null) continue;
+			const key = serializeValueKey(propValue);
+			const customOwned = customPropMap?.[propName] !== void 0 || customDynamicConfig?.[propName] !== void 0;
+			const [classMap, typedProps] = customOwned ? [customPropMap, config.typedCustomProps] : [systemPropMap, config.typedSystemProps];
+			const cls = classMap?.[propName]?.[typedProps?.includes(propName) ? typedValueKey(propValue) : key];
+			if (cls) {
+				classes.push(cls);
+				recordWitness(baseClassName, propName, key, "static");
+			} else {
+				const dc = customOwned ? customDynamicConfig?.[propName] : dynamicPropConfig?.[propName];
+				if (dc) {
+					const staged = dynStyle ?? {};
+					const failure = dc.kind === "declarations" ? applyDeclarationProp(classes, staged, propValue, dc) : applyDynamicProp(classes, staged, propValue, dc);
+					if (failure === null) {
+						dynStyle = staged;
+						recordWitness(baseClassName, propName, key, "dynamic");
+					} else {
+						if ("shape" in failure) warnInvalidTransformResult(baseClassName, propName, failure.shape);
+						else if ("entry" in failure) warnStrictScaleMiss(baseClassName, propName, key, failure);
+						else warnTransformThrow(baseClassName, propName, dc.transformName, key, failure.cause);
+						recordWitness(baseClassName, propName, key, "drop");
+					}
+				} else {
+					warnDroppedValue(baseClassName, propName, key, customOwned);
+					recordWitness(baseClassName, propName, key, "drop");
+				}
+			}
+		}
+	}
+	return {
+		classes,
+		dynamicStyle: dynStyle,
+		activeStates
+	};
+}
+//#endregion
+//#region src/runtime/createClassResolver.ts
+function serializeDynamicStyle(style) {
+	return Object.entries(style).map(([property, value]) => `${property}: ${value}`).join("; ");
+}
+function createClassResolver(className, config, systemPropMap, dynamicPropConfig) {
+	const resolveAttributes = (props) => {
+		const { classes, dynamicStyle } = resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig);
+		const attributes = { class: classes.join(" ") };
+		if (dynamicStyle && Object.keys(dynamicStyle).length > 0) attributes.style = serializeDynamicStyle(dynamicStyle);
+		return attributes;
+	};
+	const resolver = (props) => resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig).classes.join(" ");
+	return Object.assign(resolver, { attrs: resolveAttributes });
+}
+//#endregion
+export { resolveClasses as n, createClassResolver as t };

package/dist/{createComposedFamily-C4NovMcd.js → createComposedFamily-C9ShrVy6.js}

@@ -1,4 +1,4 @@
-import { n as resolveClasses } from "./createClassResolver-EpwTL9Sa.js";
+import { n as resolveClasses } from "./createClassResolver-CcCgar2Z.js";
 import { t as assertRootSlot } from "./assert-root-slot-C3Lp9MNJ.js";
 import { Children, cloneElement, createElement, forwardRef, isValidElement } from "react";
 //#region src/runtime/index.ts
@@ -24,13 +24,23 @@ function forwardProps(props, filterProps, domProps) {
 	}
 }
 /**
+* React 19 carries a ref as a plain prop and warns on `element.ref`; React 18
+* keeps it on the element and guards `props.ref` with a warning getter.
+* Reading the descriptor never invokes either getter.
+*/
+function childRefOf(child) {
+	const propRef = Object.getOwnPropertyDescriptor(child.props, "ref");
+	if (propRef && !propRef.get) return propRef.value;
+	return child.ref;
+}
+/**
 * The child wins every conflict: parent props spread under the child's own, so
 * a handler declared on the child replaces the parent's instead of chaining.
 */
 function renderAsChild(className, filterProps, props, ref, classes, dynamicStyle) {
 	const child = Children.only(props.children);
 	if (!isValidElement(child)) throw new Error(`${className}: asChild requires a single React element as children`);
-	const childRef = child.ref;
+	const childRef = childRefOf(child);
 	const mergedClassName = [classes.join(" "), child.props.className].filter(Boolean).join(" ");
 	const mergedStyle = dynamicStyle || props.style || child.props.style ? {
 		...props.style,
@@ -84,8 +94,11 @@ function createComponent(element, className, config, systemPropMap, dynamicPropC
 	if (config.variants) {
 		for (const [prop, vc] of Object.entries(config.variants)) if (vc.default != null) variantDefaults[prop] = vc.default;
 	}
+	const customTransforms = {};
+	for (const [prop, dc] of Object.entries(config.customDynamicConfig ?? {})) if (dc.transform) customTransforms[prop] = dc.transform;
 	return Object.assign(Component, {
 		variantDefaults: Object.freeze(variantDefaults),
+		customTransforms: Object.freeze(customTransforms),
 		extend: () => {
 			throw new Error(`Cannot extend extracted component "${className}" at runtime. Extensions must be authored in source code using the builder API (e.g. import the original component and call .extend() there) so the extraction pipeline can resolve them at build time.`);
 		}

package/dist/declarations.d.ts

@@ -0,0 +1,38 @@
+import type { DeclarationProp, SystemProp } from './types/config';
+/** One key's declarations: canonical member name → CSS value. */
+export interface DeclarationRecord {
+    [member: string]: string | number;
+}
+/** Scale key → that key's complete record. */
+export interface DeclarationScaleValues {
+    [key: string]: DeclarationRecord;
+}
+/**
+ * What an author can hand a declaration scale before it is validated: plain
+ * JavaScript data whose shape the types may not have enforced.
+ */
+export type AuthoredDeclarationValue = string | number | boolean | null | undefined | AuthoredDeclarationRecord | readonly AuthoredDeclarationValue[];
+export interface AuthoredDeclarationRecord {
+    readonly [key: string]: AuthoredDeclarationValue;
+}
+export declare function isDeclarationProp(entry: SystemProp | undefined): entry is DeclarationProp;
+/**
+ * The camelCase spelling of a CSS property, so `font-size` and `fontSize`
+ * name one member; vendor prefixes follow React's spelling (`WebkitX`,
+ * `msX`). Custom properties are not members.
+ */
+export declare function canonicalMemberName(name: string): string | undefined;
+/**
+ * A declaration prop with its members canonicalized. Matching its members
+ * against the effective scale happens where the system and theme meet.
+ */
+export declare function validateDeclarationProp(propName: string, entry: DeclarationProp): DeclarationProp;
+/**
+ * Each record must be flat, with string or finite-number values, and every
+ * record of one scale must set the same members. Returns the records with
+ * canonical member names.
+ */
+export declare function validateDeclarationRecords(label: string, scale: string, values: AuthoredDeclarationValue): DeclarationScaleValues;
+/** Every record names the members of the first; the diagnostic names the gap. */
+export declare function assertUniformMembers(label: string, scale: string, values: DeclarationScaleValues): void;
+//# sourceMappingURL=declarations.d.ts.map

package/dist/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../src/declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAElE,iEAAiE;AACjE,MAAM,WAAW,iBAAiB;IAChC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CACnC;AAED,8CAA8C;AAC9C,MAAM,WAAW,sBAAsB;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,yBAAyB,GACzB,SAAS,wBAAwB,EAAE,CAAC;AAExC,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,wBAAwB,CAAC;CAClD;AAqCD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,KAAK,IAAI,eAAe,CAE1B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkBpE;AAyBD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,GACrB,eAAe,CA2BjB;AA2CD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,wBAAwB,GAC/B,sBAAsB,CAexB;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,sBAAsB,GAC7B,IAAI,CAwBN"}

package/dist/groups/index.js

@@ -1,4 +1,4 @@
-import { a as borderShorthand, i as gridItemRatio, n as size, o as createScale, r as gridItem } from "../size-C4gOY6lI.js";
+import { a as borderShorthand, i as gridItemRatio, n as size, o as createScale, r as gridItem } from "../size-ZhCTPtA-.js";
 //#region src/groups/index.ts
 const color = {
 	color: {

package/dist/index.d.ts

@@ -18,7 +18,7 @@ export { areTransformsEqual, createTransform, type NamedTransform, type Transfor
 export { gridItem, gridItemRatio } from './transforms/grid';
 export { percentageOrAbsolute, size } from './transforms/size';
 export type { AnimusComponent, AnimusWrappedComponent, AnyBrandedComponent, ComposedFamily, SharedConfig, VariantPropsOf, } from './types/component';
-export type { AbstractParser, BuiltInConditionAlias, BuiltInSelectorAlias, CompoundEntry, CSSPropMap, CSSProps, CustomPropConfig, Parser, ParserProps, Prop, PropertyValues, Scale, ScaleValue, SelectorAliasProps, SystemProps, ThemedCSSPropMap, ThemedCSSProps, ThemedScale, ThemedScaleValue, VariantConfig, } from './types/config';
+export type { AbstractParser, BuiltInConditionAlias, BuiltInSelectorAlias, CompoundEntry, CSSPropMap, CSSProps, CustomPropConfig, DeclarationKey, DeclarationProp, Parser, ParserProps, Prop, PropertyValues, Scale, ScaleValue, SelectorAliasProps, SystemProp, SystemProps, ThemedCSSPropMap, ThemedCSSProps, ThemedScale, ThemedScaleValue, VariantConfig, } from './types/config';
 export type { AbstractProps, MediaQueryMap, ResponsiveProp, ThemeProps, } from './types/props';
 export type { ArrayScale, MapScale } from './types/scales';
 export type { CSSObject } from './types/shared';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}