@ai-react-markdown/core 1.0.1 → 1.0.2

package/dist/index.d.cts

@@ -12,6 +12,13 @@ import { Components } from 'react-markdown';
  * @module defs
  */
 
+/**
+ * Custom component overrides for the markdown renderer.
+ * Alias for `react-markdown`'s `Components` type, re-exported under the
+ * library's `AIMarkdown` naming convention so consumers don't need a
+ * direct `react-markdown` dependency for type imports.
+ */
+type AIMarkdownCustomComponents = Components;
 /**
  * Extra markdown syntax extensions beyond standard GFM.
  * Enable or disable these via {@link AIMarkdownRenderConfig.extraSyntaxSupported}.
@@ -47,8 +54,13 @@ interface AIMarkdownRenderConfig {
     displayOptimizeAbilities: AIMarkdownRenderDisplayOptimizeAbility[];
 }
 /**
- * Arbitrary metadata that consumers can pass through the render context.
- * Custom renderers can access this via {@link AIMarkdownRenderState.metadata}.
+ * Sensible default configuration with all extensions and optimizations enabled.
+ * Frozen to prevent accidental mutation.
+ */
+declare const defaultAIMarkdownRenderConfig: AIMarkdownRenderConfig;
+/**
+ * Arbitrary metadata that consumers can pass through a dedicated React context.
+ * Custom renderers can access this via the {@link useAIMarkdownMetadata} hook.
  */
 interface AIMarkdownMetadata extends Record<string, any> {
 }
@@ -74,48 +86,373 @@ interface AIMarkdownTypographyProps extends PropsWithChildren {
 /** React component type for the typography wrapper. */
 type AIMarkdownTypographyComponent = ComponentType<AIMarkdownTypographyProps>;
 /** Props accepted by an optional extra style wrapper component. */
-interface AIMarkdownExtraStyleProps extends PropsWithChildren {
+interface AIMarkdownExtraStylesProps extends PropsWithChildren {
 }
 /** React component type for an optional extra style wrapper. */
-type AIMarkdownExtraStyleComponent = ComponentType<AIMarkdownExtraStyleProps>;
+type AIMarkdownExtraStylesComponent = ComponentType<AIMarkdownExtraStylesProps>;
 /**
  * Immutable render state exposed to all descendant components via React context.
  * Access this with the {@link useAIMarkdownRenderState} hook.
  *
+ * Metadata is provided via a separate context — use {@link useAIMarkdownMetadata} instead.
+ *
  * @typeParam TConfig - Render configuration type (defaults to {@link AIMarkdownRenderConfig}).
- * @typeParam TMetadata - Metadata type (defaults to {@link AIMarkdownMetadata}).
  */
-interface AIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> {
+interface AIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig> {
     /** Whether the content is currently being streamed (e.g. from an LLM). */
     streaming: boolean;
     /** Resolved CSS font-size value. */
     fontSize: string;
+    /** Active typography variant. */
+    variant: AIMarkdownVariant;
+    /** Active color scheme. */
+    colorScheme: AIMarkdownColorScheme;
     /** Active render configuration. */
     config: TConfig;
-    /** Optional consumer-provided metadata. */
-    metadata?: TMetadata;
 }
 
+// Sourced from type-fest v5.4.4
+// https://github.com/sindresorhus/type-fest
+// SPDX-License-Identifier: (MIT OR CC0-1.0)
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
 /**
- * Shared TypeScript utility types.
- *
- * @module ts-util
- */
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+// Sourced from type-fest v5.4.4
+// https://github.com/sindresorhus/type-fest
+// SPDX-License-Identifier: (MIT OR CC0-1.0)
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+
+
 /**
- * Recursively makes all properties of `T` optional.
- * Unlike the built-in `Partial<T>`, this traverses nested objects.
- *
- * @typeParam T - The type to make deeply partial.
- *
- * @example
- * ```ts
- * type Config = { a: { b: number } };
- * type PartialConfig = DeepPartial<Config>;
- * // { a?: { b?: number } }
- * ```
- */
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<
+  Options extends object,
+  Defaults extends Simplify<
+    Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>
+  >,
+  SpecifiedOptions extends Options,
+> = If<
+  IsAny<SpecifiedOptions>,
+  Defaults,
+  If<
+    IsNever<SpecifiedOptions>,
+    Defaults,
+    Simplify<
+      Merge<
+        Defaults,
+        {
+          [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options>
+            ? undefined extends SpecifiedOptions[Key]
+              ? never
+              : Key
+            : Key]: SpecifiedOptions[Key];
+        }
+      > &
+        Required<Options>
+    >
+  >
+>; // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+}
+  ? B extends A
+    ? A extends B
+      ? false
+      : true
+    : true
+  : false;
+
+/**
+@see {@link PartialDeep}
+*/
+type PartialDeepOptions = {
+  /**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+  readonly recurseIntoArrays?: boolean;
+
+  /**
+	Allows `undefined` values in non-tuple arrays.
+
+	- When set to `true`, elements of non-tuple arrays can be `undefined`.
+	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
+
+	@default false
+
+	@example
+	You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
+
+	```
+	import type {PartialDeep} from 'type-fest';
+
+	type Settings = {
+		languages: string[];
+	};
+
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
+
+	partialSettings.languages = [undefined]; // OK
+	```
+	*/
+  readonly allowUndefinedInNonTupleArrays?: boolean;
+};
+
+type DefaultPartialDeepOptions = {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+let settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400,
+	},
+	autocomplete: false,
+	autosave: true,
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Shape = {
+	dimensions: [number, number];
+};
+
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
+};
+
+partialShape.dimensions = [15]; // OK
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<
+  T,
+  ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>
+>;
+
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends
+  | BuiltIns
+  | (new (...arguments_: any[]) => unknown)
+  ? T
+  : T extends Map<infer KeyType, infer ValueType>
+    ? PartialMapDeep<KeyType, ValueType, Options>
+    : T extends Set<infer ItemType>
+      ? PartialSetDeep<ItemType, Options>
+      : T extends ReadonlyMap<infer KeyType, infer ValueType>
+        ? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+        : T extends ReadonlySet<infer ItemType>
+          ? PartialReadonlySetDeep<ItemType, Options>
+          : T extends (...arguments_: any[]) => unknown
+            ? IsNever<keyof T> extends true
+              ? T // For functions with no properties
+              : HasMultipleCallSignatures<T> extends true
+                ? T
+                : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options>
+            : T extends object
+              ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+                ? Options['recurseIntoArrays'] extends true
+                  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+                    ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+                      ? ReadonlyArray<
+                          _PartialDeep<
+                            Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined,
+                            Options
+                          >
+                        >
+                      : Array<
+                          _PartialDeep<
+                            Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined,
+                            Options
+                          >
+                        >
+                    : PartialObjectDeep<T, Options> // Tuples behave properly
+                  : T // If they don't opt into array testing, just use the original type
+                : PartialObjectDeep<T, Options>
+              : unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<
+  _PartialDeep<KeyType, Options>,
+  _PartialDeep<ValueType, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<
+  _PartialDeep<KeyType, Options>,
+  _PartialDeep<ValueType, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<
+  _PartialDeep<T, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
+  [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
 };
 
 /**
@@ -125,8 +462,7 @@ type DeepPartial<T> = {
  * Throws if called outside the provider boundary.
  *
  * @typeParam TConfig - Expected configuration shape (defaults to {@link AIMarkdownRenderConfig}).
- * @typeParam TMetadata - Expected metadata shape (defaults to {@link AIMarkdownMetadata}).
- * @returns The current render state.
+ * @returns The current render state (does not include metadata — use {@link useAIMarkdownMetadata} for that).
  *
  * @example
  * ```tsx
@@ -136,13 +472,35 @@ type DeepPartial<T> = {
  * }
  * ```
  */
-declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata>(): AIMarkdownRenderState<TConfig, TMetadata>;
+declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig>(): AIMarkdownRenderState<TConfig>;
+/**
+ * Access the current metadata from within the `<AIMarkdown>` tree.
+ *
+ * Metadata lives in a separate React context so that changes to metadata
+ * do not cause re-renders in components that only consume render state
+ * (e.g. {@link MarkdownContent}).
+ *
+ * @typeParam TMetadata - Expected metadata shape (defaults to {@link AIMarkdownMetadata}).
+ * @returns The current metadata, or `undefined` if none was provided.
+ */
+declare function useAIMarkdownMetadata<TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata>(): TMetadata | undefined;
 /** Props for {@link AIMarkdownRenderStateProvider}. */
-interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> extends PropsWithChildren {
+interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig> extends PropsWithChildren {
     streaming: boolean;
     fontSize: string;
-    /** Partial config that will be deep-merged with {@link defaultAIMarkdownRenderConfig}. */
-    config?: DeepPartial<TConfig>;
+    variant: AIMarkdownVariant;
+    colorScheme: AIMarkdownColorScheme;
+    /**
+     * Base default config to merge against. When omitted, falls back to
+     * {@link defaultAIMarkdownRenderConfig}. Sub-packages (e.g. mantine) can
+     * pass their own extended defaults here.
+     */
+    defaultConfig?: TConfig;
+    /** Partial config that will be deep-merged with the default config. */
+    config?: PartialDeep<TConfig>;
+}
+/** Props for {@link AIMarkdownMetadataProvider}. */
+interface AIMarkdownMetadataProviderProps<TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> extends PropsWithChildren {
     metadata?: TMetadata;
 }
 
@@ -168,13 +526,38 @@ interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderCon
  */
 type AIMDContentPreprocessor = (content: string) => string;
 
+/**
+ * Hook for referential stability of deep-equal values.
+ *
+ * @module hooks/useStableValue
+ */
+/**
+ * Returns a referentially stable version of `value`.
+ *
+ * On each render the new value is deep-compared (via `lodash/isEqual`) against
+ * the previous one. If they are structurally equal the *previous* reference is
+ * returned, preventing unnecessary re-renders in downstream `useMemo` / `useEffect`
+ * consumers that depend on reference equality.
+ *
+ * @typeParam T - The value type.
+ * @param value - The potentially new value to stabilize.
+ * @returns The previous reference when deep-equal, otherwise the new value.
+ *
+ * @example
+ * ```tsx
+ * const stableConfig = useStableValue(config);
+ * // stableConfig keeps the same reference as long as config is deep-equal.
+ * ```
+ */
+declare function useStableValue<T>(value: T): T;
+
 /**
  * Props for the `<AIMarkdown>` component.
  *
  * @typeParam TConfig - Custom render configuration type (extends {@link AIMarkdownRenderConfig}).
  * @typeParam TRenderData - Custom metadata type (extends {@link AIMarkdownMetadata}).
  */
-interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata> extends Omit<AIMarkdownRenderStateProviderProps<TConfig, TRenderData>, 'fontSize'> {
+interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata> extends Omit<AIMarkdownRenderStateProviderProps<TConfig>, 'fontSize' | 'variant' | 'colorScheme'>, AIMarkdownMetadataProviderProps<TRenderData> {
     /**
      * Base font size for the rendered output.
      * Accepts a CSS length string (e.g. `'14px'`, `'0.875rem'`) or a number
@@ -193,18 +576,18 @@ interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRen
      * Use this to replace the default renderers for specific HTML elements
      * (e.g. code blocks, links, images).
      */
-    customComponents?: Components;
+    customComponents?: AIMarkdownCustomComponents;
     /**
      * Typography wrapper component. Receives `fontSize`, `variant`, and `colorScheme`.
      * Defaults to the built-in {@link DefaultTypography}.
      */
-    typography?: AIMarkdownTypographyComponent;
+    Typography?: AIMarkdownTypographyComponent;
     /**
      * Optional extra style wrapper component rendered between the typography
      * wrapper and the markdown content. Useful for injecting additional
      * CSS scope or theme providers.
      */
-    extraStyle?: AIMarkdownExtraStyleComponent;
+    ExtraStyles?: AIMarkdownExtraStylesComponent;
     /** Typography variant name. Defaults to `'default'`. */
     variant?: AIMarkdownVariant;
     /** Color scheme name. Defaults to `'light'`. */
@@ -214,7 +597,7 @@ interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRen
  * Root component that preprocesses markdown content and renders it through
  * a configurable remark/rehype pipeline wrapped in typography and style layers.
  */
-declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, config, metadata, typography: Typography, extraStyle: ExtraStyle, variant, colorScheme, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
+declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, defaultConfig, config, metadata, Typography, ExtraStyles, variant, colorScheme, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
 declare const _default: typeof AIMarkdownComponent;
 
-export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownExtraStyleComponent, type AIMarkdownExtraStyleProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, _default as default, useAIMarkdownRenderState };
+export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownCustomComponents, type AIMarkdownExtraStylesComponent, type AIMarkdownExtraStylesProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, type PartialDeep, _default as default, defaultAIMarkdownRenderConfig, useAIMarkdownMetadata, useAIMarkdownRenderState, useStableValue };