@yahoo/uds-create-config 5.53.1 → 5.55.0

package/dist/entities/system/drawn-motion.js

@@ -1,6 +1,6 @@
 import { isRef, pathOf, ref, routedSource, sourceOf } from "../../framework/utils/refs.js";
 import { moduleViewOf } from "../../framework/module-views.js";
-import { linkedLocalRow } from "../../framework/projections.js";
+import { linkedDraw } from "../../framework/projections.js";
 //#region src/entities/system/drawn-motion.ts
 /**
 * The name the preset a `motion` value names plays under in `config`: a path of `config`'s own, or a
@@ -32,36 +32,43 @@ function drawnMotionBody(config, name) {
 	return (sourceOf(name) === void 0 ? at.resolve("motion", name) : at.resolveRef(ref("motion", name)))?.toJSON();
 }
 function linkedName({ config, slug, path }) {
-	return linkedLocalRow({
+	const drawn = linkedDraw({
 		config,
 		slug,
 		kind: "motion",
 		path
-	}) ?? `${path}@${slug}`;
+	});
+	return "row" in drawn ? drawn.row : `${drawn.path}@${drawn.slug}`;
 }
 const linkedPresets = /* @__PURE__ */ new WeakMap();
 /**
 * Every linked preset `config` plays under its pin's name: each preset a reached source holds that
-* this config's refs reach, unless the link draws it with a row of this config's own.
+* this config's refs reach, unless the link draws it with a row of this config's own, and the preset
+* of a nearer link's that a routed pin draws with in its place ({@link linkedDraw}).
 */
 function linkedMotionPresets(config) {
 	const hit = linkedPresets.get(config);
 	if (hit) return hit;
 	const out = [];
-	for (const slug of config.reachedSlugs()) {
-		const source = config.sourceFor(slug);
-		if (!source) continue;
-		for (const target of config.sourceClosure(slug, "motion")) {
-			const path = pathOf(target);
-			if (linkedLocalRow({
+	const seen = /* @__PURE__ */ new Set();
+	for (const reached of config.reachedSlugs()) {
+		if (!config.sourceFor(reached)) continue;
+		for (const target of config.sourceClosure(reached, "motion")) {
+			const drawn = linkedDraw({
 				config,
-				slug,
+				slug: reached,
 				kind: "motion",
-				path
-			}) !== void 0) continue;
-			const body = source.resolve("motion", path)?.toJSON();
-			if (body) out.push({
-				name: `${path}@${slug}`,
+				path: pathOf(target)
+			});
+			if ("row" in drawn) continue;
+			const { slug, path } = drawn;
+			const name = `${path}@${slug}`;
+			const source = config.sourceFor(slug);
+			const body = source?.resolve("motion", path)?.toJSON();
+			if (!source || !body || seen.has(name)) continue;
+			seen.add(name);
+			out.push({
+				name,
 				slug,
 				path,
 				body,

package/dist/entities/system/link-plan.js

@@ -1,5 +1,5 @@
-import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { collectRefs, isMintedRow, ref, sourceOf, splitRef } from "../../framework/utils/refs.js";
+import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { blockedBy } from "../../framework/plan.js";
 import { excludedCondition } from "../../framework/source-integrity.js";
 import { PIN_KIND, covers, declarationOf, entriesFor, excludePaths, excludes, includePaths, narrowDeclaration } from "./link-declaration.js";

package/dist/entities/system/motion-convert.js

@@ -1,5 +1,5 @@
-import { isRef } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
+import { isRef } from "../../framework/utils/refs.js";
 import { MOTION_EASING_NAMES, bezierPoints, motionOfCssKeyword } from "./easings.js";
 import { cssEasing } from "./css-timing.js";
 import { JS_ONLY_FIELDS } from "./Motion.js";

package/dist/entities/system/motion-variants.js

@@ -1,6 +1,6 @@
-import { reject } from "../../framework/rejection.js";
-import { isRef, kindOf, pathOf } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
+import { isRef, kindOf, pathOf } from "../../framework/utils/refs.js";
+import { reject } from "../../framework/rejection.js";
 import { createSliceMemo } from "../../framework/memo.js";
 import { drawnMotionBody, drawnMotionName } from "./drawn-motion.js";
 import { webMotionBody } from "./motion-types.js";

package/dist/framework/Config.d.ts

@@ -73,7 +73,7 @@ interface RecordedSource {
  * The dense-counter `2` a short-lived scheme stamped before the chain existed reads as the mint
  * that replaced it (see `detectedWireVersion`).
  */
-declare const SERIALIZED_CONFIG_VERSION = 20261022184639;
+declare const SERIALIZED_CONFIG_VERSION = 20261023152030;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;

package/dist/framework/Config.js

@@ -1,8 +1,8 @@
+import { applyPathDelta, isPlainObject, namedFields, pathSegments, sectionDelta, touchedFields } from "./utils/field-path.js";
+import { MINTED, collectRefs, entityPathProblem, entityRefOf, isExtendedRef, isMintedRow, isRef, kindOf, memberOf, memberRef, pathOf, qualifyRefs, ref, rewriteRefNamespace, rewriteRefSource, rewriteRefs, routedSource, singletonRef, sourceHops, sourceOf, splitRef } from "./utils/refs.js";
 import "./config-operation-kind.js";
 import { ConfigFormatError, ConfigRejection, isConfigRejection, issuePath, refusalIssues, reject, rejectData, rejectInvalid, rejectReferrers } from "./rejection.js";
-import { MINTED, collectRefs, entityPathProblem, entityRefOf, isExtendedRef, isMintedRow, isRef, kindOf, memberOf, memberRef, pathOf, qualifyRefs, ref, rewriteRefNamespace, rewriteRefSource, rewriteRefs, routedSource, singletonRef, sourceHops, sourceOf, splitRef } from "./utils/refs.js";
 import { describePatch } from "./plan.js";
-import { applyPathDelta, isPlainObject, namedFields, pathSegments, sectionDelta, touchedFields } from "./utils/field-path.js";
 import { METADATA_KEYS, declaredField } from "./utils/field-schema.js";
 import { dataSchema, resolveInputSchema } from "./schemas.js";
 import { isComposedValue } from "../entities/system/composed-values.js";
@@ -438,13 +438,18 @@ function storeCollection(def, patch, next) {
 }
 /** Drop every member of a declared `orphans` collection that still points at `target` — what a
 *  delete leaves behind when a sibling member exists only to describe the one removed. */
-function dropOrphans(sub, def, target, namespace) {
+function dropOrphans(sub, def, target, namespace, keyed) {
 	if (!sub?.orphans?.length) return def;
 	let out = def;
 	for (const field of sub.orphans) {
 		const collection = out[field];
 		if (!isPlainObject(collection)) continue;
+		const keyedFields = Object.entries(keyed?.subEntities[field]?.namesMembersOf ?? {}).filter(([, names]) => names === keyed?.collection).map(([record]) => record);
 		const kept = Object.fromEntries(Object.entries(collection).filter(([, member]) => {
+			if (keyed && isPlainObject(member) && keyedFields.some((record) => {
+				const names = member[record];
+				return isPlainObject(names) && Object.hasOwn(names, keyed.key);
+			})) return false;
 			const refs = collectRefs(member);
 			if (refs.includes(target)) return false;
 			if (!namespace) return true;
@@ -2401,6 +2406,10 @@ var Config = class Config {
 			def = dropOrphans(sub, def, `${leafOf(patch.field).replace(/s$/, "")}:${refPathOf(patch, patch.key)}`, sub?.namespaces ? {
 				kind: sub.namespaces,
 				path: patch.key
+			} : void 0, patch.owner === void 0 ? {
+				collection: patch.field,
+				key: patch.key,
+				subEntities: entry.subEntities
 			} : void 0);
 		}
 		const next = snapshot.withChanges([itemChange(entry, patch.kind, patch.path, def)]);
@@ -6044,7 +6053,7 @@ var Config = class Config {
 	*  links from the provided sources. A declared `linkedKind` with no provided source throws. */
 	hydrateFrom(stored, options) {
 		const claimed = schemaVersionOf(stored);
-		if (claimed > 20261022184639) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20261023152030) throw new SchemaVersionTooNew(claimed);
 		const wire = upgradeSerializedConfig(stored);
 		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating.`);
 		const leftover = wire.options;

package/dist/framework/class-names.d.ts

@@ -217,30 +217,35 @@ declare function componentPropComposites(config: Config, path: string, state?: R
  */
 declare function inlineRuleComposites(config: Config, element: unknown, authored: Record<string, unknown>): Record<string, unknown>;
 /**
- * The composites a rule's bag names that are drawn with another config's row, taken out of the bag.
+ * The composites a rule's bag names that are drawn with another config's entity, taken out of the bag.
  *
  * A linked component's rule is read against its source, and a `hybrid` link draws a composite it
- * names with the consuming config's row of that name. `drawnWith` answers which row that is, as a
- * member path in `local`, and the member's styles are that row's, so they have to be rendered against
- * `local` while the rest of the rule is rendered against the source. The marker is the source's, which
- * the component's own `_on<Group><Member>` rules query. `bag` is what's left for
+ * names with the consuming config's row of that name, or a routed pin with a nearer link's. `drawnWith`
+ * answers which entity that is, as a config and a member path in it, and the member's styles are
+ * that entity's, so they have to be rendered against that config while the rest of the rule is
+ * rendered against the source. Each config's members come back as one bag. The marker is the
+ * source's, which the component's own `_on<Group><Member>` rules query. `bag` is what's left for
  * {@link inlineRuleComposites}.
  */
 declare function splitRuleComposites({
   config,
   element,
   bag: authored,
-  local,
   drawnWith
 }: {
   readonly config: Config;
   readonly element: unknown;
   readonly bag: Record<string, unknown>;
-  readonly local: Config;
-  readonly drawnWith: (member: string) => string | undefined;
+  readonly drawnWith: (member: string) => {
+    readonly config: Config;
+    readonly path: string;
+  } | undefined;
 }): {
   readonly bag: Record<string, unknown>;
-  readonly drawn: Record<string, unknown> | undefined;
+  readonly drawn: readonly {
+    readonly config: Config;
+    readonly bag: Record<string, unknown>;
+  }[];
 };
 /**
  * A composite member's styles as a bag, with the composite's marker

package/dist/framework/class-names.js

@@ -1,4 +1,5 @@
 import { isRef, kindOf, memberOf, pathOf, refLeaf, refOfKey, sourceHops, sourceOf } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { forwardsOf, rootLayerOf } from "../entities/system/element.js";
 import { createSliceMemo } from "./memo.js";
 import { moduleViewOf } from "./module-views.js";
@@ -568,40 +569,43 @@ function inlineRuleComposites(config, element, authored) {
 	return mergeStyleBags(inlined, rest);
 }
 /**
-* The composites a rule's bag names that are drawn with another config's row, taken out of the bag.
+* The composites a rule's bag names that are drawn with another config's entity, taken out of the bag.
 *
 * A linked component's rule is read against its source, and a `hybrid` link draws a composite it
-* names with the consuming config's row of that name. `drawnWith` answers which row that is, as a
-* member path in `local`, and the member's styles are that row's, so they have to be rendered against
-* `local` while the rest of the rule is rendered against the source. The marker is the source's, which
-* the component's own `_on<Group><Member>` rules query. `bag` is what's left for
+* names with the consuming config's row of that name, or a routed pin with a nearer link's. `drawnWith`
+* answers which entity that is, as a config and a member path in it, and the member's styles are
+* that entity's, so they have to be rendered against that config while the rest of the rule is
+* rendered against the source. Each config's members come back as one bag. The marker is the
+* source's, which the component's own `_on<Group><Member>` rules query. `bag` is what's left for
 * {@link inlineRuleComposites}.
 */
-function splitRuleComposites({ config, element, bag: authored, local, drawnWith }) {
+function splitRuleComposites({ config, element, bag: authored, drawnWith }) {
 	const bag = resolveAppliedComposites(config, authored);
-	let drawn;
+	const drawn = /* @__PURE__ */ new Map();
 	const taken = /* @__PURE__ */ new Set();
 	for (const [key, member] of ruleCompositeMembers({
 		config,
 		element,
 		bag
 	})) {
-		const path = drawnWith(member);
-		if (path === void 0 || !local.resolve("composite", path)) continue;
-		drawn = mergeStyleBags(drawn ?? {}, compositeMemberBag({
-			config: local,
-			path,
+		const at = drawnWith(member);
+		if (!at?.config.resolve("composite", at.path)) continue;
+		drawn.set(at.config, mergeStyleBags(drawn.get(at.config) ?? {}, compositeMemberBag({
+			...at,
 			markedIn: config
-		}));
+		})));
 		taken.add(key);
 	}
-	if (!drawn) return {
+	if (taken.size === 0) return {
 		bag,
-		drawn
+		drawn: []
 	};
 	return {
 		bag: Object.fromEntries(Object.entries(bag).filter(([key]) => !taken.has(key))),
-		drawn
+		drawn: [...drawn].map(([from, styles]) => ({
+			config: from,
+			bag: styles
+		}))
 	};
 }
 /** The composite member each key of a rule's bag names, by key: a key `element` declares as a
@@ -655,9 +659,13 @@ function compositeMemberBag({ config, path, markedIn = config }) {
 function layerRoutedProps(config, path, state = {}) {
 	const component = config.resolve("component", path);
 	if (!component) return {};
-	const { layers = {}, styles = {}, defaultProps = {} } = component.toJSON();
+	const body = component.toJSON();
+	const { layers = {}, styles = {} } = body;
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const out = {};
@@ -704,9 +712,13 @@ function layerRoutedProps(config, path, state = {}) {
 * that layer through motion's factory and hands it the preset's props.
 */
 function layerJsMotionPresets(config, path, state = {}) {
-	const { styles = {}, defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
+	const { styles = {} } = body ?? {};
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const rules = Object.entries(styles);
@@ -743,9 +755,12 @@ function layerJsMotionPresets(config, path, state = {}) {
 * here, and one expanded from the config alone needs this.
 */
 function styleRuleMotionClasses(config, path, state = {}) {
-	const { defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const out = {};

package/dist/framework/default-conditions.d.ts

@@ -0,0 +1,26 @@
+//#region src/framework/default-conditions.d.ts
+/** One `defaultPropsWhen` entry as stored: the condition, and the defaults that hold under it. */
+interface StoredDefaultCondition {
+  readonly when: Record<string, unknown>;
+  readonly props: Record<string, unknown>;
+}
+/** Every `defaultPropsWhen` entry a body stores, keyed and ordered as stored. Empty for none. */
+declare function storedDefaultConditions(body: unknown): Readonly<Record<string, StoredDefaultCondition>>;
+/**
+ * The defaults that apply to a component given the props it was handed: `defaultProps`, with every
+ * `defaultPropsWhen` entry whose condition holds laid over it in stored order, so a later entry wins
+ * on the prop it sets.
+ *
+ * A condition reads a prop's given value, else its unconditional default. A prop that is itself
+ * conditionally defaulted can't be a condition (the schema refuses it), so one pass decides.
+ * Values compare by leaf, so a stored value ref and the bare name a call site writes match.
+ */
+declare function defaultsFor({
+  body,
+  given
+}: {
+  body: unknown;
+  given: Readonly<Record<string, unknown>>;
+}): Record<string, unknown>;
+//#endregion
+export { StoredDefaultCondition, defaultsFor, storedDefaultConditions };

package/dist/framework/default-conditions.js

@@ -0,0 +1,35 @@
+import { isPlainObject } from "./utils/field-path.js";
+import { refLeaf } from "./utils/refs.js";
+//#region src/framework/default-conditions.ts
+/**
+* A component's stored `defaultPropsWhen` collection, read off a body with nothing else in scope:
+* the defaults that hold only under a condition on the component's other props, beside the
+* unconditional `defaultProps` they override.
+*/
+/** Every `defaultPropsWhen` entry a body stores, keyed and ordered as stored. Empty for none. */
+function storedDefaultConditions(body) {
+	const stored = body?.defaultPropsWhen;
+	return isPlainObject(stored) ? stored : {};
+}
+/**
+* The defaults that apply to a component given the props it was handed: `defaultProps`, with every
+* `defaultPropsWhen` entry whose condition holds laid over it in stored order, so a later entry wins
+* on the prop it sets.
+*
+* A condition reads a prop's given value, else its unconditional default. A prop that is itself
+* conditionally defaulted can't be a condition (the schema refuses it), so one pass decides.
+* Values compare by leaf, so a stored value ref and the bare name a call site writes match.
+*/
+function defaultsFor({ body, given }) {
+	const defaults = body?.defaultProps ?? {};
+	const conditions = Object.values(storedDefaultConditions(body));
+	if (conditions.length === 0) return defaults;
+	const out = { ...defaults };
+	for (const { when, props } of conditions) if (Object.entries(when).every(([prop, value]) => {
+		const current = given[prop] !== void 0 ? given[prop] : defaults[prop];
+		return String(refLeaf(current)) === String(refLeaf(value));
+	})) Object.assign(out, props);
+	return out;
+}
+//#endregion
+export { defaultsFor, storedDefaultConditions };

package/dist/framework/defineEntity.js

@@ -1,5 +1,5 @@
-import { CONFIG_OPERATION_KIND } from "./config-operation-kind.js";
 import { isRef, kindOf, pathOf, ref, refSchema, refTo, sourceOf } from "./utils/refs.js";
+import { CONFIG_OPERATION_KIND } from "./config-operation-kind.js";
 import { resolveFields } from "./schemas.js";
 import { buildKind } from "./registry.js";
 import { brandGroup } from "./utils/group.js";

package/dist/framework/inline-sources.js

@@ -1,5 +1,5 @@
-import { rejectData } from "./rejection.js";
 import { MINTED, collectRefs, entityRefOf, isRef, kindOf, pathOf, ref, rewriteRefs, sourceOf } from "./utils/refs.js";
+import { rejectData } from "./rejection.js";
 import { kindBorrowable } from "./registry.js";
 //#region src/framework/inline-sources.ts
 /**

package/dist/framework/layer-styles.js

@@ -1,4 +1,5 @@
 import { isRef, refLeaf } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { authoredBag } from "./projections.js";
 import { resolveAppliedComposites } from "../entities/system/applied-composites.js";
 //#region src/framework/layer-styles.ts
@@ -83,9 +84,13 @@ function ruleSpecificity(when) {
 * "styled with nothing".
 */
 function layerStyles(config, path, props = {}, options = {}) {
-	const { styles = {}, defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
+	const { styles = {} } = body ?? {};
 	const state = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: props
+		}),
 		...props
 	};
 	const forced = (options.forced ?? []).map((name) => name.replace(/^_/, ""));

package/dist/framework/module-views.d.ts

@@ -1,15 +1,14 @@
-import type { Config } from './Config';
+import { Config } from "./Config.js";
+
+//#region src/framework/module-views.d.ts
 /** The config a linked component's module view is built for, and the pin its owner is reached
  *  through. */
-export interface ModuleViewLink {
-    readonly consumer: Config;
-    readonly slug: string;
+interface ModuleViewLink {
+  readonly consumer: Config;
+  readonly slug: string;
 }
-/** Records that `view` is an owner's config as `link.consumer` converts its files. */
-export declare function registerModuleView({ view, link, }: {
-    readonly view: Config;
-    readonly link: ModuleViewLink;
-}): void;
 /** The consumer and pin `config` was built for, when it is a module view. A name it reads is its
  *  owner's, and what that names is drawn as the consumer draws it. */
-export declare function moduleViewOf(config: Config): ModuleViewLink | undefined;
+declare function moduleViewOf(config: Config): ModuleViewLink | undefined;
+//#endregion
+export { ModuleViewLink, moduleViewOf };

package/dist/framework/plan.js

@@ -1,5 +1,5 @@
-import { isConfigRejection } from "./rejection.js";
 import { splitRef } from "./utils/refs.js";
+import { isConfigRejection } from "./rejection.js";
 //#region src/framework/plan.ts
 /**
 * One line for a patch, read off the patch itself: its kind, what it did, and where. The payload

package/dist/framework/projections.d.ts

@@ -34,12 +34,15 @@ type VarNaming = string | ((tokenPath: string) => string);
  * is declared under the pin's namespace ({@link sourceVarPrefix}), since this config has no name of
  * its own for it. A relative own name (`cssVariable: 'spacing'`) is placed under a prefix, and the
  * pin's is the one that keeps it apart from ours.
+ *
+ * Which of these a token is comes from {@link linkedDraw}: a token drawn with a row of this config's
+ * is named by that row, and one a routed pin draws with an entity of a nearer link's is named as that
+ * link names it.
  */
 declare function linkedVarNaming(config: Config, slug: string): (tokenPath: string) => string;
 /**
- * The path of this config's row that what `slug` brings at `kind:path` is drawn with: the row
- * pointing at it ({@link heldLinked}), or this config's row at the path when the pin draws with it
- * ({@link Config.drawsWithLocalRow}). `undefined` when the source's own entity is drawn.
+ * The path of this config's row that what `slug` brings at `kind:path` is drawn with
+ * ({@link linkedDraw}). `undefined` when a source's entity is drawn.
  */
 declare function linkedLocalRow({
   config,
@@ -52,6 +55,35 @@ declare function linkedLocalRow({
   readonly kind: string;
   readonly path: string;
 }): string | undefined;
+/** What a linked value is drawn with: a row of this config's own, or a source's entity, named by the
+ *  pin it's reached through. */
+type LinkedDraw = {
+  readonly row: string;
+} | {
+  readonly slug: string;
+  readonly path: string;
+};
+/**
+ * What `slug` brings at `kind:path` is drawn with, from this config.
+ *
+ * Through a pin of this config's own, it's this config's row pointing at it ({@link heldLinked}), or
+ * its row at the path when the pin draws with one ({@link Config.drawsWithLocalRow}), and otherwise
+ * the source's entity. A routed slug (`bridge~yos`) is resolved one link at a time: `bridge` is asked
+ * what it draws `yos`'s entity with, and a row of `bridge`'s own is then what this config draws
+ * through `bridge`. So an app linking the Bridge draws a component the Bridge takes through a `hybrid`
+ * link with the Bridge's values, as the Bridge does.
+ */
+declare function linkedDraw({
+  config,
+  slug,
+  kind,
+  path
+}: {
+  readonly config: Config;
+  readonly slug: string;
+  readonly kind: string;
+  readonly path: string;
+}): LinkedDraw;
 /**
  * Their path → the path of this config's row pointing at it, for every row of `kind` that is a
  * pointer into `slug`: the rows a `link` mints and any written by hand. A pointer with a local delta
@@ -839,4 +871,4 @@ declare function propValueFromAxis(config: Config, path: string, prop: string, v
 /** The `value` a string, number or boolean prop declares as its default, per prop. */
 declare function declaredPropDefaults(props: Record<string, unknown> | undefined): Record<string, unknown>;
 //#endregion
-export { IconTool, IndexedPreviewCondition, PreviewMatrix, PropDeclaration, StyleDeclarationGroup, StylePropEntry, StylePropertyItem, VarNaming, authoredBag, authoredValue, bodyNumberLeaves, bodyNumberUnit, className, cssPropValue, cssVar, cssVarRef, declarationKeyName, declaredPropDefaults, declaredPropRouting, declaresCssVariable, glyphComponentOf, glyphLibrariesOf, glyphPropsOf, heldLinked, holdingPreviewConditions, iconToolAxisOptions, iconToolFor, iconToolOf, iconToolsOf, isCustomPropertyKey, keyedPreviewConditions, linkedLocalRow, linkedVarNaming, literalValueOf, memberFromLeaf, memberLeaves, nameStyleNumbers, negatedCssValue, opacityPercentage, pinStyleNumbers, previewConditionalProps, previewConditions, previewDefaults, previewMatrix, propOwner, propValueDomain, propValueFromAxis, refListOf, renderInterpolated, renderStyleValue, resolveComponentProps, resolveFieldValue, resolveTokenValue, resolveTokenValueUnder, rewriteStyleNumbers, routedBag, sourceVarPrefix, styleAliasesOf, styleDeclarationGroups, styleDeclarations, styleNumberAsPainted, styleNumberReadingChanges, stylePropEntries, stylePropLeafForToken, stylePropNegates, stylePropNumberCss, stylePropNumberLeaf, stylePropNumberLeaves, stylePropNumberName, stylePropNumberNamedLeaves, stylePropNumberUnit, stylePropNumberUnitRefusal, stylePropTokenGroup, stylePropTokenPath, stylePropTokenValues, stylePropValueFromLeaf, stylePropValueLeaves, stylePropValues, stylePropertiesWriting, stylePropertyAccepts, stylePropertyFor, stylePropertyPathFor, tokenReference, validateComponentProps };
+export { IconTool, IndexedPreviewCondition, LinkedDraw, PreviewMatrix, PropDeclaration, StyleDeclarationGroup, StylePropEntry, StylePropertyItem, VarNaming, authoredBag, authoredValue, bodyNumberLeaves, bodyNumberUnit, className, cssPropValue, cssVar, cssVarRef, declarationKeyName, declaredPropDefaults, declaredPropRouting, declaresCssVariable, glyphComponentOf, glyphLibrariesOf, glyphPropsOf, heldLinked, holdingPreviewConditions, iconToolAxisOptions, iconToolFor, iconToolOf, iconToolsOf, isCustomPropertyKey, keyedPreviewConditions, linkedDraw, linkedLocalRow, linkedVarNaming, literalValueOf, memberFromLeaf, memberLeaves, nameStyleNumbers, negatedCssValue, opacityPercentage, pinStyleNumbers, previewConditionalProps, previewConditions, previewDefaults, previewMatrix, propOwner, propValueDomain, propValueFromAxis, refListOf, renderInterpolated, renderStyleValue, resolveComponentProps, resolveFieldValue, resolveTokenValue, resolveTokenValueUnder, rewriteStyleNumbers, routedBag, sourceVarPrefix, styleAliasesOf, styleDeclarationGroups, styleDeclarations, styleNumberAsPainted, styleNumberReadingChanges, stylePropEntries, stylePropLeafForToken, stylePropNegates, stylePropNumberCss, stylePropNumberLeaf, stylePropNumberLeaves, stylePropNumberName, stylePropNumberNamedLeaves, stylePropNumberUnit, stylePropNumberUnitRefusal, stylePropTokenGroup, stylePropTokenPath, stylePropTokenValues, stylePropValueFromLeaf, stylePropValueLeaves, stylePropValues, stylePropertiesWriting, stylePropertyAccepts, stylePropertyFor, stylePropertyPathFor, tokenReference, validateComponentProps };