@elementor/editor-components 4.1.0-741 → 4.1.0-742

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elementor/editor-components",
   "description": "Elementor editor components",
-  "version": "4.1.0-741",
+  "version": "4.1.0-742",
   "private": false,
   "author": "Elementor Team",
   "homepage": "https://elementor.com/",
@@ -40,31 +40,31 @@
     "dev": "tsup --config=../../tsup.dev.ts"
   },
   "dependencies": {
-    "@elementor/editor": "4.1.0-741",
-    "@elementor/editor-canvas": "4.1.0-741",
-    "@elementor/editor-controls": "4.1.0-741",
-    "@elementor/editor-documents": "4.1.0-741",
-    "@elementor/editor-editing-panel": "4.1.0-741",
-    "@elementor/editor-elements": "4.1.0-741",
-    "@elementor/editor-elements-panel": "4.1.0-741",
-    "@elementor/editor-mcp": "4.1.0-741",
-    "@elementor/editor-templates": "4.1.0-741",
-    "@elementor/editor-panels": "4.1.0-741",
-    "@elementor/editor-props": "4.1.0-741",
-    "@elementor/editor-styles-repository": "4.1.0-741",
-    "@elementor/editor-ui": "4.1.0-741",
-    "@elementor/editor-v1-adapters": "4.1.0-741",
-    "@elementor/http-client": "4.1.0-741",
+    "@elementor/editor": "4.1.0-742",
+    "@elementor/editor-canvas": "4.1.0-742",
+    "@elementor/editor-controls": "4.1.0-742",
+    "@elementor/editor-documents": "4.1.0-742",
+    "@elementor/editor-editing-panel": "4.1.0-742",
+    "@elementor/editor-elements": "4.1.0-742",
+    "@elementor/editor-elements-panel": "4.1.0-742",
+    "@elementor/editor-mcp": "4.1.0-742",
+    "@elementor/editor-templates": "4.1.0-742",
+    "@elementor/editor-panels": "4.1.0-742",
+    "@elementor/editor-props": "4.1.0-742",
+    "@elementor/editor-styles-repository": "4.1.0-742",
+    "@elementor/editor-ui": "4.1.0-742",
+    "@elementor/editor-v1-adapters": "4.1.0-742",
+    "@elementor/http-client": "4.1.0-742",
     "@elementor/icons": "^1.68.0",
-    "@elementor/events": "4.1.0-741",
-    "@elementor/query": "4.1.0-741",
-    "@elementor/schema": "4.1.0-741",
-    "@elementor/store": "4.1.0-741",
+    "@elementor/events": "4.1.0-742",
+    "@elementor/query": "4.1.0-742",
+    "@elementor/schema": "4.1.0-742",
+    "@elementor/store": "4.1.0-742",
     "@elementor/ui": "1.36.17",
-    "@elementor/utils": "4.1.0-741",
+    "@elementor/utils": "4.1.0-742",
     "@wordpress/i18n": "^5.13.0",
-    "@elementor/editor-notifications": "4.1.0-741",
-    "@elementor/editor-current-user": "4.1.0-741"
+    "@elementor/editor-notifications": "4.1.0-742",
+    "@elementor/editor-current-user": "4.1.0-742"
   },
   "peerDependencies": {
     "react": "^18.3.1",

package/src/components/instance-editing-panel/override-prop-control.tsx

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { useMemo } from 'react';
 import {
 	ControlReplacementsProvider,
 	getControlReplacements,
@@ -29,6 +30,7 @@ import {
 import {
 	type ComponentInstanceOverride,
 	componentInstanceOverridesPropTypeUtil,
+	type ComponentInstanceOverridesPropValue,
 } from '../../prop-types/component-instance-overrides-prop-type';
 import { componentInstancePropTypeUtil } from '../../prop-types/component-instance-prop-type';
 import {
@@ -44,14 +46,18 @@ import { OverridablePropProvider } from '../../provider/overridable-prop-context
 import { updateOverridableProp } from '../../store/actions/update-overridable-prop';
 import { useCurrentComponentId } from '../../store/store';
 import { type OriginPropFields, type OverridableProp, type OverridableProps } from '../../types';
-import { getContainerByOriginId } from '../../utils/get-container-by-origin-id';
 import { getPropTypeForComponentOverride } from '../../utils/get-prop-type-for-component-override';
 import { getMatchingOverride } from '../../utils/overridable-props-utils';
 import { resolveOverridePropValue } from '../../utils/resolve-override-prop-value';
+import { resolveOverridesChain } from '../../utils/resolve-overrides-chain';
 import { ControlLabel } from '../control-label';
 import { OverrideControlInnerElementNotFoundError } from '../errors';
-import { useResolvedOriginValue } from './use-resolved-origin-value';
 import { correctExposedEmptyOverride } from './utils/correct-exposed-empty-override';
+import {
+	applyOverridesToSettings,
+	type OverridesMapping,
+	unwrapOverridableSettings,
+} from './utils/resolve-element-settings';
 
 type Props = {
 	overrideKey: string;
@@ -92,8 +98,6 @@ function OverrideControl( { overridableProp }: InternalProps ) {
 
 	const matchingOverride = getMatchingOverride( overrides, overridableProp.overrideKey );
 
-	const recursiveOriginValue = useResolvedOriginValue( matchingOverride, overridableProp );
-
 	if ( ! componentId ) {
 		throw new Error( 'Component ID is required' );
 	}
@@ -102,14 +106,59 @@ function OverrideControl( { overridableProp }: InternalProps ) {
 		throw new Error( 'Component has no overridable props' );
 	}
 
+	const {
+		elementId: originElementId,
+		widgetType,
+		elType,
+		propKey,
+	} = overridableProp.originPropFields ?? overridableProp;
+	const type = elType === 'widget' ? widgetType : elType;
+	const elementType = getElementType( type );
+
+	const { elementId, overridesMapping } = useMemo( () => {
+		const overridesChainResult = resolveOverridesChain( {
+			outerOverridableProp: overridableProp,
+			outerInstanceId: componentInstanceElement.element.id,
+		} );
+
+		if ( overridesChainResult.isChainBroken ) {
+			throw new OverrideControlInnerElementNotFoundError( {
+				context: { componentId, elementId: originElementId },
+			} );
+		}
+
+		return {
+			elementId: overridesChainResult.innerElement.id,
+			overridesMapping: overridesChainResult.overridesMapping,
+		};
+	}, [ overridableProp, componentInstanceElement.element.id, componentId, originElementId ] );
+
+	// Not reactive to inner element store changes — intentional.
+	// Inner element settings can only change in component edit mode, which unmounts this component.
+	const settingsWithInnerOverrides = useMemo( () => {
+		const settings = getElementSettings< AnyTransformable >(
+			elementId,
+			Object.keys( elementType?.propsSchema ?? {} )
+		);
+
+		return applyOverridesToSettings( settings, overridesMapping );
+	}, [ elementId, elementType?.propsSchema, overridesMapping ] );
+
+	const resolvedElementSettings = useMemo( () => {
+		const withAllOverrides = applyOverridesToSettings(
+			settingsWithInnerOverrides,
+			formatOverridesToApply( overrides )
+		);
+		return unwrapOverridableSettings( withAllOverrides );
+	}, [ settingsWithInnerOverrides, overrides ] );
+
 	const propType = getPropTypeForComponentOverride( overridableProp );
 
-	if ( ! propType ) {
+	if ( ! propType || ! elementType ) {
 		return null;
 	}
 
-	const resolvedOverrideValue = matchingOverride ? resolveOverridePropValue( matchingOverride ) : null;
-	const propValue = resolvedOverrideValue ?? recursiveOriginValue ?? overridableProp.originValue;
+	const propValue = resolvedElementSettings[ propKey ];
 
 	const value = {
 		[ overridableProp.overrideKey ]: propValue,
@@ -161,8 +210,13 @@ function OverrideControl( { overridableProp }: InternalProps ) {
 				return;
 			}
 
-			const { elType, widgetType, propKey, elementId } = overridableProp;
-			updateOverridableProp( wrappingComponentId, overridableValue, { elType, widgetType, propKey, elementId } );
+			const originPropFields = {
+				elType: overridableProp.elType,
+				widgetType: overridableProp.widgetType,
+				propKey: overridableProp.propKey,
+				elementId: overridableProp.elementId,
+			};
+			updateOverridableProp( wrappingComponentId, overridableValue, originPropFields );
 		}
 	};
 
@@ -172,29 +226,6 @@ function OverrideControl( { overridableProp }: InternalProps ) {
 		overridableProp.label
 	);
 
-	const {
-		elementId: originElementId,
-		widgetType,
-		elType,
-		propKey,
-	} = overridableProp.originPropFields ?? overridableProp;
-
-	const element = getContainerByOriginId( originElementId, componentInstanceElement.element.id );
-
-	if ( ! element ) {
-		throw new OverrideControlInnerElementNotFoundError( { context: { componentId, elementId: originElementId } } );
-	}
-	const elementId = element.id;
-
-	const type = elType === 'widget' ? widgetType : elType;
-	const elementType = getElementType( type );
-
-	if ( ! elementType ) {
-		return null;
-	}
-
-	const settings = getElementSettings< AnyTransformable >( elementId, Object.keys( elementType.propsSchema ) );
-
 	const propTypeSchema = createTopLevelObjectType( {
 		schema: {
 			[ overridableProp.overrideKey ]: propType,
@@ -206,7 +237,11 @@ function OverrideControl( { overridableProp }: InternalProps ) {
 			value={ componentOverridablePropTypeUtil.extract( matchingOverride ) ?? undefined }
 			componentInstanceElement={ componentInstanceElement }
 		>
-			<ElementProvider element={ { id: elementId, type } } elementType={ elementType } settings={ settings }>
+			<ElementProvider
+				element={ { id: elementId, type } }
+				elementType={ elementType }
+				settings={ resolvedElementSettings }
+			>
 				<SettingsField bind={ propKey } propDisplayName={ overridableProp.label }>
 					<PropProvider
 						propType={ propTypeSchema }
@@ -344,3 +379,31 @@ function isValidOverride( overridableProps: OverridableProps, override: Componen
 
 	return !! overridableProps.props[ overridableKey ];
 }
+
+function formatOverridesToApply( overrides: ComponentInstanceOverridesPropValue ): OverridesMapping {
+	if ( ! overrides ) {
+		return {};
+	}
+
+	const result: OverridesMapping = {};
+
+	for ( const item of overrides ) {
+		const overridable = componentOverridablePropTypeUtil.extract( item );
+		let override: PropValue = item;
+
+		if ( overridable ) {
+			override = overridable.origin_value;
+		}
+
+		const extractedOverride = componentInstanceOverridePropTypeUtil.extract( override );
+		if ( ! extractedOverride ) {
+			continue;
+		}
+
+		result[ extractedOverride.override_key ] = {
+			value: extractedOverride.override_value as AnyTransformable | null,
+		};
+	}
+
+	return result;
+}

package/src/components/instance-editing-panel/utils/resolve-element-settings.ts

@@ -0,0 +1,65 @@
+import { type AnyTransformable } from '@elementor/editor-props';
+
+import { componentOverridablePropTypeUtil } from '../../../prop-types/component-overridable-prop-type';
+
+type ElementSettings = Record< string, AnyTransformable | null >;
+
+export type OverridesMapping = {
+	[ key: string ]: {
+		value: AnyTransformable | null;
+		outermostKey?: string;
+	};
+};
+
+export function applyOverridesToSettings(
+	elementSettings: ElementSettings,
+	overrides: OverridesMapping
+): ElementSettings {
+	const result: ElementSettings = {};
+
+	for ( const [ propKey, propValue ] of Object.entries( elementSettings ) ) {
+		const overridable = componentOverridablePropTypeUtil.extract( propValue );
+
+		if ( ! overridable ) {
+			result[ propKey ] = propValue;
+			continue;
+		}
+
+		const override = overrides[ overridable.override_key ];
+
+		if ( ! override ) {
+			result[ propKey ] = propValue;
+			continue;
+		}
+
+		if ( override.outermostKey && override.outermostKey !== overridable.override_key ) {
+			const originValue = overridable.origin_value as AnyTransformable | null;
+
+			result[ propKey ] = componentOverridablePropTypeUtil.create( {
+				override_key: override.outermostKey,
+				origin_value: override.value ?? originValue,
+			} );
+		} else {
+			result[ propKey ] = override.value ?? propValue;
+		}
+	}
+
+	return result;
+}
+
+export function unwrapOverridableSettings( elementSettings: ElementSettings ): ElementSettings {
+	const result: ElementSettings = {};
+
+	for ( const [ propKey, propValue ] of Object.entries( elementSettings ) ) {
+		const overridable = componentOverridablePropTypeUtil.extract( propValue );
+
+		if ( ! overridable ) {
+			result[ propKey ] = propValue;
+			continue;
+		}
+
+		result[ propKey ] = overridable.origin_value as AnyTransformable | null;
+	}
+
+	return result;
+}

package/src/utils/filter-valid-overridable-props.ts

@@ -1,11 +1,5 @@
-import { type ComponentInstanceOverride } from '../prop-types/component-instance-overrides-prop-type';
-import { componentInstanceOverridesPropTypeUtil } from '../prop-types/component-instance-overrides-prop-type';
-import { componentInstancePropTypeUtil } from '../prop-types/component-instance-prop-type';
-import { componentOverridablePropTypeUtil } from '../prop-types/component-overridable-prop-type';
 import { type OverridableProp, type OverridableProps } from '../types';
-import { getContainerByOriginId } from './get-container-by-origin-id';
-import { getOverridableProp } from './get-overridable-prop';
-import { extractInnerOverrideInfo } from './overridable-props-utils';
+import { resolveOverridesChain } from './resolve-overrides-chain';
 
 export function filterValidOverridableProps(
 	overridableProps: OverridableProps,
@@ -36,59 +30,10 @@ export function filterValidOverridableProps(
 }
 
 export function isExposedPropValid( prop: OverridableProp, instanceElementId?: string ): boolean {
-	if ( ! prop.originPropFields ) {
-		// if no originPropFields - the prop is on the widget level itself, therefore no need to lookup for a corresponding component's overridables
-		return true;
-	}
-
-	const innerComponentInstanceElement = getContainerByOriginId( prop.elementId, instanceElementId );
-
-	if ( ! innerComponentInstanceElement ) {
-		return false;
-	}
-
-	const setting = innerComponentInstanceElement.settings?.get( 'component_instance' ) ?? null;
-	const componentInstance = componentInstancePropTypeUtil.extract( setting );
-
-	if ( ! componentInstance?.component_id?.value ) {
-		return false;
-	}
-
-	const overrides = componentInstanceOverridesPropTypeUtil.extract( componentInstance.overrides ) ?? undefined;
-	const matchingOverride = findOverrideByOuterKey( overrides, prop.overrideKey );
-	const innerOverrideInfo = extractInnerOverrideInfo( matchingOverride );
-
-	if ( ! innerOverrideInfo ) {
-		return false;
-	}
-
-	const { componentId, innerOverrideKey } = innerOverrideInfo;
-	const innerOverridableProp = getOverridableProp( { componentId, overrideKey: innerOverrideKey } );
-
-	if ( ! innerOverridableProp ) {
-		return false;
-	}
-
-	return isExposedPropValid( innerOverridableProp, innerComponentInstanceElement.id );
-}
-
-function findOverrideByOuterKey(
-	overrides: ComponentInstanceOverride[] | undefined,
-	outerKey: string
-): ComponentInstanceOverride | null {
-	if ( ! overrides ) {
-		return null;
-	}
-
-	return (
-		overrides.find( ( override ) => {
-			const overridableValue = componentOverridablePropTypeUtil.extract( override );
-
-			if ( overridableValue ) {
-				return overridableValue.override_key === outerKey;
-			}
+	const { isChainBroken } = resolveOverridesChain( {
+		outerOverridableProp: prop,
+		outerInstanceId: instanceElementId,
+	} );
 
-			return override.value.override_key === outerKey;
-		} ) ?? null
-	);
+	return ! isChainBroken;
 }

package/src/utils/overridable-props-utils.ts

@@ -5,12 +5,6 @@ import {
 } from '../prop-types/component-instance-overrides-prop-type';
 import { componentOverridablePropTypeUtil } from '../prop-types/component-overridable-prop-type';
 
-export type InnerOverrideInfo = {
-	componentId: number;
-	innerOverrideKey: string;
-	overrideValue: unknown;
-};
-
 export function getMatchingOverride(
 	overrides: ComponentInstanceOverridesPropValue,
 	overrideKey: string
@@ -28,31 +22,3 @@ export function getMatchingOverride(
 		} ) ?? null
 	);
 }
-
-export function extractInnerOverrideInfo( override: ComponentInstanceOverride | null ): InnerOverrideInfo | null {
-	if ( ! override ) {
-		return null;
-	}
-
-	const overridableValue = componentOverridablePropTypeUtil.extract( override );
-	const innerOverride = overridableValue
-		? componentInstanceOverridePropTypeUtil.extract( overridableValue.origin_value )
-		: componentInstanceOverridePropTypeUtil.extract( override );
-
-	if ( ! innerOverride ) {
-		return null;
-	}
-
-	const {
-		schema_source: schemaSource,
-		override_key: innerOverrideKey,
-		override_value: overrideValue,
-	} = innerOverride;
-	const componentId = schemaSource?.id;
-
-	if ( ! componentId || ! innerOverrideKey ) {
-		return null;
-	}
-
-	return { componentId, innerOverrideKey, overrideValue };
-}

package/src/utils/resolve-overrides-chain.ts

@@ -0,0 +1,197 @@
+import { type V1Element } from '@elementor/editor-elements';
+import { type AnyTransformable } from '@elementor/editor-props';
+
+import { type OverridesMapping } from '../components/instance-editing-panel/utils/resolve-element-settings';
+import {
+	type ComponentInstanceOverrideProp,
+	componentInstanceOverridePropTypeUtil,
+} from '../prop-types/component-instance-override-prop-type';
+import {
+	type ComponentInstanceOverride,
+	componentInstanceOverridesPropTypeUtil,
+} from '../prop-types/component-instance-overrides-prop-type';
+import { componentInstancePropTypeUtil } from '../prop-types/component-instance-prop-type';
+import { componentOverridablePropTypeUtil } from '../prop-types/component-overridable-prop-type';
+import { type OverridableProp } from '../types';
+import { getContainerByOriginId } from './get-container-by-origin-id';
+import { getOverridableProp } from './get-overridable-prop';
+
+type OverridesChainResult =
+	| {
+			isChainBroken: false;
+			innerElement: V1Element;
+			overridesMapping: OverridesMapping;
+	  }
+	| {
+			isChainBroken: true;
+	  };
+
+// Recursively walks down a chain of nested component instances to find the innermost element
+// and collect the overrides mapping for it.
+// Returns the resolved inner element with its overrides mapping,
+// or { isChainBroken: true } if any level in the chain is no longer overridable.
+export function resolveOverridesChain( {
+	outerOverridableProp,
+	outerInstanceId,
+	overridesMapping = {},
+}: {
+	outerOverridableProp: OverridableProp;
+	outerInstanceId?: string;
+	overridesMapping?: OverridesMapping;
+} ): OverridesChainResult {
+	// Stop condition: no originPropFields means we've reached the most inner component instance
+	if ( ! outerOverridableProp.originPropFields ) {
+		const innerElement = getContainerByOriginId( outerOverridableProp.elementId, outerInstanceId );
+
+		if ( ! innerElement ) {
+			throw new Error(
+				`Inner element not found inside instance. elementId: ${ outerOverridableProp.elementId }, instanceId: ${ outerInstanceId }`
+			);
+		}
+
+		return { isChainBroken: false, innerElement, overridesMapping };
+	}
+
+	// Step 1: Find the intermediate component instance and read its settings.
+	const currentInstance = getContainerByOriginId( outerOverridableProp.elementId, outerInstanceId );
+	if ( ! currentInstance ) {
+		// One of the instances in the chain was deleted.
+		return { isChainBroken: true };
+	}
+	const { componentId, overrides } = extractComponentInstanceSettings( currentInstance );
+
+	if ( ! componentId ) {
+		throw new Error(
+			`Component ID not found for current instance. currentInstanceId: ${ currentInstance.id }. outerInstanceId: ${ outerInstanceId }`
+		);
+	}
+
+	// Collect overrides from this level, translating keys for exposed-further props.
+	const mergedOverrides = buildOverridesMap( overridesMapping, overrides ?? [] );
+
+	// Find the overridable-override that matches the outer overridable prop's key,
+	// to get the next level's overridable prop.
+	const override = findOverrideByOuterKey( overrides, outerOverridableProp.overrideKey );
+	const overrideKey = componentInstanceOverridePropTypeUtil.extract( override )?.override_key;
+
+	if ( ! override || ! overrideKey ) {
+		// No matching override found for the current level - it means it's no longer overridable.
+		return { isChainBroken: true };
+	}
+
+	const overridableProp = getOverridableProp( { componentId, overrideKey } );
+
+	if ( ! overridableProp ) {
+		throw new Error( `Overridable prop not found. componentId: ${ componentId }, overrideKey: ${ overrideKey }` );
+	}
+
+	// Step 4: Recurse into the next nesting level.
+	return resolveOverridesChain( {
+		outerOverridableProp: overridableProp,
+		outerInstanceId: currentInstance.id,
+		overridesMapping: mergedOverrides,
+	} );
+}
+
+/**
+ * Builds overrides map from instances chain:
+ * At each level, we collect overrides from the current instance and merge them with the overrides from the outer levels.
+ *
+ * For exposed-further overrides (overridable wrapping an override), we have outer key (overridable's) and inner key (override's).
+ * If a higher level already set a value for the outer key, that value is carried forward to the inner key
+ * — same logic as the componentOverridableTransformer in the render pipeline.
+ *
+ * For simple overrides, that are not exposed further, we just use the override's key and value.
+ *
+ * @param existing       - Previously accumulated overrides from outer levels.
+ * @param levelOverrides - The overrides array from the current level instance.
+ */
+export function buildOverridesMap(
+	existing: OverridesMapping,
+	levelOverrides: ComponentInstanceOverride[]
+): OverridesMapping {
+	const result: OverridesMapping = { ...existing };
+
+	for ( const item of levelOverrides ) {
+		const overridableValue = componentOverridablePropTypeUtil.extract( item );
+
+		if ( overridableValue ) {
+			// Exposed-further: overridable wraps an inner override with a different key.
+			const override = componentInstanceOverridePropTypeUtil.extract( overridableValue.origin_value );
+
+			if ( ! override ) {
+				continue;
+			}
+
+			const outerKey = overridableValue.override_key;
+			const innerKey = override.override_key;
+			const innerValue = override.override_value as AnyTransformable | null;
+
+			// If an upper level already set a value for the outer key, carry it forward to the inner key.
+			const higherLevelOverride = existing[ outerKey ];
+
+			if ( higherLevelOverride ) {
+				const outerValue = higherLevelOverride.value;
+				result[ innerKey ] = {
+					value: outerValue ?? innerValue,
+					outermostKey: higherLevelOverride.outermostKey ?? outerKey,
+				};
+				continue;
+			}
+
+			result[ innerKey ] = {
+				value: innerValue,
+				outermostKey: outerKey,
+			};
+		} else {
+			// Simple override: not exposed further, we just store the override's key and value.
+			const override = componentInstanceOverridePropTypeUtil.extract( item );
+
+			if ( ! override ) {
+				continue;
+			}
+
+			const key = override.override_key;
+			const value = override.override_value as AnyTransformable | null;
+
+			result[ key ] = { value };
+		}
+	}
+
+	return result;
+}
+
+function extractComponentInstanceSettings( element: V1Element ) {
+	const instanceSetting = element.settings?.get( 'component_instance' );
+	const instanceValue = componentInstancePropTypeUtil.extract( instanceSetting );
+	const componentId = instanceValue?.component_id?.value;
+	const overrides = componentInstanceOverridesPropTypeUtil.extract( instanceValue?.overrides );
+
+	return { componentId, overrides };
+}
+
+// Finds the inner override prop whose wrapping overridable matches the given outer key.
+function findOverrideByOuterKey(
+	overrides: ComponentInstanceOverride[] | null | undefined,
+	outerKey: string
+): ComponentInstanceOverrideProp | null {
+	if ( ! overrides ) {
+		return null;
+	}
+
+	const overridableOverride: ComponentInstanceOverride | undefined = overrides.find( ( item ) => {
+		const overridableValue = componentOverridablePropTypeUtil.extract( item );
+		if ( ! overridableValue ) {
+			return false;
+		}
+		return overridableValue.override_key === outerKey;
+	} );
+
+	const override = componentOverridablePropTypeUtil.extract( overridableOverride )?.origin_value;
+
+	if ( ! override || ! componentInstanceOverridePropTypeUtil.isValid( override ) ) {
+		return null;
+	}
+
+	return override;
+}