umberto 10.5.1 → 10.6.1

package/CHANGELOG.md

@@ -1,41 +1,48 @@
 Changelog
 =========
 
-## [10.5.1](https://github.com/cksource/umberto/compare/v10.5.0...v10.5.1) (May 14, 2026)
+## [10.6.1](https://github.com/cksource/umberto/compare/v10.6.0...v10.6.1) (June 18, 2026)
 
-### Bug fixes
+### Other changes
 
-* Changed the call for feedback title from `<h3>` to `<div>` to prevent it from appearing in the table of contents.
+* Updated homepage link.
+* Restored the web-based Google Tag Manager snippets in both Gloria and legacy Umberto themes.
 
 
-## [10.5.0](https://github.com/cksource/umberto/compare/v10.4.1...v10.5.0) (April 14, 2026)
+## [10.6.0](https://github.com/cksource/umberto/compare/v10.5.1...v10.6.0) (June 8, 2026)
 
 ### Features
 
-* Added the Call for feedback component for documentation pages.
+* Improved rendering of complex TypeScript types in API docs.
 
+  Intersection (`A & B`), tuple (`[ key: T, value: U ]`), and conditional (`T extends U ? X : Y`) types now render with their full structure preserved and each reference linkable, instead of collapsing to a generic `object` or `tuple` placeholder. Optional tuple elements display the trailing `?` from the source. The `infer X` keyword inside conditionals renders as such and no longer triggers "unsupported type" warnings during the docs build.
 
-## [10.4.1](https://github.com/cksource/umberto/compare/v10.4.0...v10.4.1) (April 13, 2026)
+  Properties tables on intersection type aliases now list the fields from the inline-literal half — including nested cases like `abc: A & { b: T }`, which now exposes `abc.b` as a sub-row, and cases where the inline literal is wrapped in `Partial<...>`, `Readonly<...>`, or `Required<...>`, where the wrapper's modifier is applied to each field. Per-field inline TSDoc comments (`/** ... */`) above each field render their descriptions in the Properties table, where they were previously dropped.
 
-### Bug fixes
+### Other changes
 
-* Fixed URL in the dropdown for LTS item to have absolute URL to pass documentation validation.
+* Updated the GTM integration to use the new server-side setup in both Gloria and legacy Umberto themes.
 
 
-## [10.4.0](https://github.com/cksource/umberto/compare/v10.3.0...v10.4.0) (April 9, 2026)
+## [10.5.1](https://github.com/cksource/umberto/compare/v10.5.0...v10.5.1) (May 14, 2026)
 
-### Features
+### Bug fixes
 
-* Added the LTS edition to the docs product picker.
+* Changed the call for feedback title from `<h3>` to `<div>` to prevent it from appearing in the table of contents.
 
 
-## [10.3.0](https://github.com/cksource/umberto/compare/v10.2.0...v10.3.0) (April 3, 2026)
+## [10.5.0](https://github.com/cksource/umberto/compare/v10.4.1...v10.5.0) (April 14, 2026)
 
 ### Features
 
-* Added support for displaying and filtering experimental API items in TypeDoc-based API docs.
+* Added the Call for feedback component for documentation pages.
+
 
-  Experimental annotations now appear in page headers and member listings, and can be toggled with the API filters.
+## [10.4.1](https://github.com/cksource/umberto/compare/v10.4.0...v10.4.1) (April 13, 2026)
+
+### Bug fixes
+
+* Fixed URL in the dropdown for LTS item to have absolute URL to pass documentation validation.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umberto",
-  "version": "10.5.1",
+  "version": "10.6.1",
   "description": "CKSource Documentation builder",
   "main": "src/index.js",
   "type": "module",
@@ -16,7 +16,7 @@
   ],
   "dependencies": {
     "@babel/core": "^7.18.10",
-    "@babel/preset-env": "^7.18.10",
+    "@babel/preset-env": "^7.29.5",
     "@minify-html/node": "^0.17.1",
     "@vscode/markdown-it-katex": "^1.1.2",
     "babel-loader": "^10.0.0",

package/src/data-converter/converters/typedoc/typedocconverter.js

@@ -265,7 +265,11 @@ export class TypedocConverter {
 					response.defaultvalue = item.defaultValue;
 				}
 
-				const nestedProperties = this._convertProperties( item );
+				// Parameter tables expand inline object literals one level only and skip intersection
+				// fan-out: TypeDoc materializes mapped types like `{ [K in keyof this]?: unknown }` into
+				// a reflection containing every property of the host class, which would otherwise produce
+				// dozens of fake `param.*` sub-rows.
+				const nestedProperties = this._convertProperties( item, { maxDepth: 0, deepIntersections: false } );
 
 				if ( !nestedProperties ) {
 					return response;
@@ -285,9 +289,20 @@ export class TypedocConverter {
 	/**
 	 * @protected
 	 * @param {CallSignatureReflection} signature
+	 * @param {Object} [options]
+	 * @param {Number} [options.maxDepth=Infinity] How many additional levels of nested inline object
+	 *   literals to expand under each child. `0` means "do not recurse; emit only the immediate
+	 *   children of `signature.type`". Default `Infinity` is unbounded (terminates naturally at
+	 *   intrinsics) — used for type-alias property tables so nested intersections/inline literals
+	 *   are flattened to dotted names.
+	 * @param {Boolean} [options.deepIntersections=true] Whether to fan out intersection members the
+	 *   way unions are fanned out. Type-alias property tables want this; function-parameter tables
+	 *   set it to `false` because TypeDoc materializes mapped types like `{ [K in keyof this]?: unknown }`
+	 *   into reflections containing every property of the host class — fanning into them would
+	 *   produce dozens of misleading sub-rows on parameters such as `values: object & ...`.
 	 * @returns {Array|null}
 	 */
-	_convertProperties( signature ) {
+	_convertProperties( signature, { maxDepth = Infinity, deepIntersections = true } = {} ) {
 		let types;
 
 		// Support for a literal object (`const foo: { /* object literal */ } = ...`).
@@ -302,7 +317,10 @@ export class TypedocConverter {
 					}
 				}
 			];
+		} else if ( deepIntersections ) {
+			types = flattenCompositeTypes( signature.type );
 		} else {
+			// Fan out unions only; intersections stay opaque so each member is treated as a whole.
 			types = signature.type.type === 'union' ? signature.type.types : [ signature.type ];
 		}
 
@@ -315,7 +333,7 @@ export class TypedocConverter {
 				];
 			} );
 
-		return properties.map( child => {
+		return properties.flatMap( child => {
 			// Nested properties cannot be duplicated so we can take the first signature when processing functions.
 			const childSignature = child.kind === ReflectionKind.Method ? child.signatures[ 0 ] : child;
 			const response = this._convertTypeToJsDoc( childSignature );
@@ -326,14 +344,17 @@ export class TypedocConverter {
 			response.extraId = `member-${ childSignature.name }`;
 			response.name = TypedocConverter.getComputedName( childSignature );
 
-			if ( signature.comment && signature.comment.blockTags ) {
-				const atProperty = signature.comment.blockTags.find( blockTag => {
-					return blockTag.tag === '@property' && blockTag.name === childSignature.name;
-				} );
+			// Prefer a matching `@property` block tag on the parent type alias; otherwise fall back to
+			// the child reflection's own comment summary (inline `/** ... */` on each field).
+			//
+			// `blockTags` is an empty array (not absent) when TypeDoc parses a comment with only a summary,
+			// so a plain truthy check would always pass and the fallback would be unreachable.
+			const atProperty = signature.comment?.blockTags?.find( blockTag => {
+				return blockTag.tag === '@property' && blockTag.name === childSignature.name;
+			} );
 
-				if ( atProperty ) {
-					response.description = TypedocConverter.convertComment( atProperty.content );
-				}
+			if ( atProperty ) {
+				response.description = TypedocConverter.convertComment( atProperty.content );
 			} else if ( childSignature.comment && childSignature.comment.summary ) {
 				response.description = TypedocConverter.convertComment( childSignature.comment.summary );
 			}
@@ -342,11 +363,34 @@ export class TypedocConverter {
 				response.optional = true;
 			}
 
+			if ( childSignature.flags.isReadonly ) {
+				response.readonly = true;
+			}
+
 			if ( childSignature.defaultValue ) {
 				response.defaultvalue = childSignature.defaultValue;
 			}
 
-			return response;
+			// If the property's type is itself an inline object literal (directly, or as part of an
+			// intersection/union), expose its fields as nested rows — mirrors how `_convertParameters`
+			// flattens nested object literals in function parameters. The intersection-walking flag is
+			// propagated so callers that disable it (parameters) stay consistent through recursion.
+			const nestedProperties = maxDepth > 0 ?
+				this._convertProperties( childSignature, { maxDepth: maxDepth - 1, deepIntersections } ) :
+				null;
+
+			if ( !nestedProperties || !nestedProperties.length ) {
+				return response;
+			}
+
+			return [
+				response,
+				...nestedProperties.map( nestedProperty => {
+					nestedProperty.name = `${ childSignature.name }.${ nestedProperty.name }`;
+
+					return nestedProperty;
+				} )
+			];
 		} );
 	}
 
@@ -553,7 +597,12 @@ class TypeConverter {
 				};
 			}
 
-			if ( parameter.default ) {
+			// The `type += ` = default `` concatenation below assumes `type` is a string.
+			// When the constraint is a structured value (intersection, conditional, tuple, generic,
+			// function, predicate, operator, raw) or an array (`Array<X>` sugar), `+=` coerces it
+			// via `toString()` — producing `[object Object] = ...` or stripping the `Array<>` wrapper.
+			// Skip the default in those cases; the constraint is still rendered.
+			if ( parameter.default && typeof type === 'string' ) {
 				type += ` = ${ this.convertIntrinsicType( parameter.default ) }`;
 			}
 
@@ -729,20 +778,50 @@ class TypeConverter {
 			return 'object';
 		}
 
-		// A structure represented by an array.
+		// A structure represented by an array. The position and label of each element matter.
+		// E.g.: `[ number, string ]`, `[ key: number, value: string ]`, or `[ first: string, second?: number ]`.
+		// Optional elements appear in two forms in TypeDoc:
+		//   * `[ key?: T ]` — `namedTupleMember` with `isOptional`.
+		//   * `( T )?`     — an `optional` wrapper around the element type.
 		if ( typeReflection.type === 'tuple' ) {
-			// It is an array with mixed types.
-			// The position of these types matter.
-			return 'tuple';
+			return {
+				type: 'tuple',
+				elements: ( typeReflection.elements || [] ).map( element => {
+					if ( element.type === 'namedTupleMember' ) {
+						const result = { name: element.name, value: this.convert( element.element ) };
+
+						if ( element.isOptional ) {
+							result.optional = true;
+						}
+
+						return result;
+					}
+
+					if ( element.type === 'optional' ) {
+						return { value: this.convert( element.elementType ), optional: true };
+					}
+
+					return { value: this.convert( element ) };
+				} )
+			};
 		}
 
+		// A namedTupleMember reached outside a tuple context (defensive — TS does not allow this at top level).
 		if ( typeReflection.type === 'namedTupleMember' ) {
 			return this.convert( typeReflection.element );
 		}
 
 		// A structure that mixes two and more different types.
+		// Each member is converted independently so its name/reference is preserved in the rendered signature.
+		// Inline object literal members additionally contribute their fields to the doclet's property table
+		// (see `flattenCompositeTypes()` consumed by `_convertProperties()`).
 		if ( typeReflection.type === 'intersection' ) {
-			return 'object';
+			return {
+				type: 'intersection',
+				values: typeReflection.types
+					.map( singleType => this.convert( singleType ) )
+					.filter( Boolean )
+			};
 		}
 
 		if ( typeReflection.type === 'query' ) {
@@ -776,11 +855,16 @@ class TypeConverter {
 			return type.join( ' ' );
 		}
 
-		// A conditional type.
-		// Perhaps it could be rendered as an union.
+		// A conditional type: `CheckType extends ExtendsType ? TrueType : FalseType`.
 		// See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html.
 		if ( typeReflection.type === 'conditional' ) {
-			return 'object';
+			return {
+				type: 'conditional',
+				checkType: this.convert( typeReflection.checkType ),
+				extendsType: this.convert( typeReflection.extendsType ),
+				trueType: this.convert( typeReflection.trueType ),
+				falseType: this.convert( typeReflection.falseType )
+			};
 		}
 
 		// See: https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html.
@@ -815,15 +899,24 @@ class TypeConverter {
 			}
 
 			if ( !Array.isArray( typesOrType ) ) {
-				// `typesOrType` can be an object representing a generic value.
-				// TODO: Missing CC here.
+				// Predicates fundamentally resolve to `boolean` for narrowing — when the target type cannot
+				// be expressed compactly inline (an intersection, a conditional, a tuple, or an inline
+				// object literal), show just `boolean`. References, generics, etc. keep their normal rendering.
+				const compoundTypes = [ 'intersection', 'conditional', 'tuple' ];
+
+				if ( typeof typesOrType === 'object' && compoundTypes.includes( typesOrType.type ) ) {
+					return 'boolean';
+				}
+
+				// For all remaining objects, fall back to `.name` (e.g., `{ type: 'generic', name: 'Array' }`).
+				// Guard the case where `.name` is absent so an unanticipated shape does not throw.
 				const value = typeof typesOrType === 'object' ? typesOrType.name : typesOrType;
 
-				if ( value.toLowerCase() === 'object' ) {
+				if ( value && value.toLowerCase() === 'object' ) {
 					return 'boolean';
 				}
 
-				// Convert a single item into an array to avoid having mixed structures in a view.
+				// Convert a single item into an array to keep a uniform shape for the renderer.
 				typesOrType = [ typesOrType ];
 			}
 
@@ -844,6 +937,12 @@ class TypeConverter {
 			};
 		}
 
+		// An `infer X` type-variable binding inside a conditional's `extendsType`.
+		// See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#inferring-within-conditional-types.
+		if ( typeReflection.type === 'inferred' ) {
+			return `infer ${ typeReflection.name }`;
+		}
+
 		// At this stage, the type cannot be converted. Perhaps, we missed something while developing
 		// the conversion. Let's ask users to create a new issue containing the non-supported structure.
 		//
@@ -884,3 +983,60 @@ function mapIndexSignatureObject( subItem, index ) {
 		name: `${ subItem.name }[${ index }]`
 	};
 }
+
+/**
+ * Modifier flags applied by the built-in utility type wrappers we descend into.
+ * Used by `flattenCompositeTypes()` so that an inline literal hidden inside e.g.
+ * `Partial<{...}>` still surfaces in the property table with the right per-field flags.
+ */
+const FLAG_PROPAGATING_WRAPPERS = new Map( [
+	[ 'Partial', { isOptional: true } ],
+	[ 'Required', { isOptional: false } ],
+	[ 'Readonly', { isReadonly: true } ]
+] );
+
+/**
+ * Flattens a typedoc type into a list of candidate types whose `declaration.children`
+ * contribute to the parent's property table. Unions and intersections are recursively
+ * flattened so members that are inline object literals are reached. References to the
+ * `Partial`, `Required`, and `Readonly` utility wrappers are descended into so an
+ * intersection like `Base & Partial<{ a: T }>` still exposes `a` (with the matching
+ * per-field modifier). Other reference and non-declaration members are left in place
+ * and skipped by the caller's `type.declaration` filter.
+ *
+ * @param {AvailableTypes} type
+ * @returns {Array.<AvailableTypes>}
+ */
+function flattenCompositeTypes( type ) {
+	if ( type.type === 'union' || type.type === 'intersection' ) {
+		return type.types.flatMap( flattenCompositeTypes );
+	}
+
+	if (
+		type.type === 'reference' &&
+		FLAG_PROPAGATING_WRAPPERS.has( type.name ) &&
+		type.typeArguments &&
+		type.typeArguments.length === 1
+	) {
+		const flagOverrides = FLAG_PROPAGATING_WRAPPERS.get( type.name );
+
+		return flattenCompositeTypes( type.typeArguments[ 0 ] ).map( inner => {
+			if ( !inner.declaration ) {
+				return inner;
+			}
+
+			return {
+				...inner,
+				declaration: {
+					...inner.declaration,
+					children: ( inner.declaration.children || [] ).map( child => ( {
+						...child,
+						flags: { ...child.flags, ...flagOverrides }
+					} ) )
+				}
+			};
+		} );
+	}
+
+	return [ type ];
+}

package/themes/umberto/layout/gloria/_api-docs/_mixin/_type.pug

@@ -26,7 +26,7 @@ mixin renderStringValue( inlineObjectOrType )
 //- TODO: Description.
 //-
 //- @param {Object} complexType
-//- @param {'function'|'predicate'|'operator'|'generic'} complexType.type
+//- @param {'function'|'predicate'|'operator'|'generic'|'intersection'|'tuple'|'conditional'} complexType.type
 //- @param {Array.<*>} [complexType.params]
 //- @param {String} [complexType.name]
 //- @param {Array.<*>} [complexType.instances]
@@ -69,6 +69,26 @@ mixin renderComplexStructure( complexType )
 	if ( complexType.type === 'generic' && complexType.name && ( complexType.typeParameters || complexType.typeParameter ) )
 		+renderGenericType( complexType )
 
+	//- Intersection: `Foo & Bar & Baz`.
+	if ( complexType.type === 'intersection' && complexType.values )
+		+renderIntersection( complexType.values )
+
+	//- Tuple: `[ Type1, Type2 ]` or `[ name1: Type1, name2: Type2 ]`.
+	if ( complexType.type === 'tuple' && complexType.elements )
+		+renderTuple( complexType.elements )
+
+	//- Conditional: `CheckType extends ExtendsType ? TrueType : FalseType`.
+	if ( complexType.type === 'conditional' )
+		+renderType( complexType.checkType )
+		| !{ ' ' }
+		i !{ 'extends' }
+		| !{ ' ' }
+		+renderType( complexType.extendsType )
+		| !{ ' ? ' }
+		+renderType( complexType.trueType )
+		| !{ ' : ' }
+		+renderType( complexType.falseType )
+
 
 //- Renders a structure for an union, an array or a single type specified as a string.
 //-
@@ -110,6 +130,52 @@ mixin renderUnion( iterable )
 		if index < iterable.length - 1
 			| !{ ' | ' }
 
+//- Renders an intersection structure, e.g., `Foo & Bar & Baz`.
+//-
+//- All types are linkable if they point to an existing JSDoc doclet.
+//-
+//- @param {Array.<String>} type
+mixin renderIntersection( iterable )
+	each item, index in iterable
+		+renderType( item )
+		if index < iterable.length - 1
+			| !{ ' & ' }
+
+//- Renders a tuple structure, e.g., `[ string, number ]`, `[ key: string, value: number ]`,
+//- or `[ first: string, second?: number ]` (optional last element).
+//-
+//- For anonymous optional elements whose value renders with an infix operator
+//- (`|`, `&`, ` ? `, ` => `), the value is wrapped in parentheses so the trailing `?`
+//- unambiguously applies to the whole expression — matching TypeScript's `( T | U )?` source syntax.
+//- Single tokens (`number?`, `Array<T>?`) and named members (`key?: T | U`) stay unwrapped.
+//-
+//- @param {Array.<{ name?: String, value: *, optional?: Boolean }>} elements
+mixin renderTuple( elements )
+	| !{ '&lsqb; ' }
+	each element, index in elements
+		if ( element.name )
+			if ( element.optional )
+				| #{ element.name }?:&nbsp;
+			else
+				| #{ element.name }:&nbsp;
+			+renderType( element.value )
+		else
+			//- The trailing `?` binds tighter than `|`/`&`, so wrap compound values
+			//- to keep the source semantics. Plain strings and arrays (`Array<T>`,
+			//- which self-brackets) are unambiguous and need no parens.
+			- const v = element.value
+			- const wrap = element.optional && ( v instanceof Set || ( v && typeof v === 'object' && !Array.isArray( v ) && [ 'intersection', 'conditional', 'function' ].includes( v.type ) ) )
+			if ( wrap )
+				| !{ '&lpar; ' }
+			+renderType( element.value )
+			if ( wrap )
+				| !{ ' &rpar;' }
+			if ( element.optional )
+				| ?
+		if index < elements.length - 1
+			| !{ ', ' }
+	| !{ ' &rsqb;' }
+
 //- Draws an inline callback structure.
 //-
 //- E.g.: `( ArgumentFoo | ArgumentBar, AnotherArgument ) => ReturnType`

package/themes/umberto/layout/gloria/_modules/header/index.pug

@@ -12,8 +12,8 @@ mixin header({ withChooseProject = true, className = '' } = {})
 		.c-header__mobile.l-hide-desktop
 			.c-header__mobile-brand
 				a.b-link.u-display-inline-flex(
-					title='Navigate to the CKEditor Ecosystem Documentation homepage',
-					href=relative_url(page.path, 'index.html')
+					title='Navigate to the CKEditor homepage',
+					href='https://ckeditor.com'
 				)
 					+inline-svg({ file: 'ckeditor-logo', ariaHidden: true, className: 'c-header__brand-logo' })
 
@@ -39,8 +39,8 @@ mixin header({ withChooseProject = true, className = '' } = {})
 			.c-header__brand-row
 				.c-header__brand-row-selector.u-flex-horizontal.u-align-items-center
 					a.b-link.u-display-inline-flex(
-						title='Navigate to the CKEditor Ecosystem Documentation homepage',
-						href=relative_url(page.path, 'index.html')
+						title='Navigate to the CKEditor homepage',
+						href='https://ckeditor.com'
 					)
 						+inline-svg({ file: 'ckeditor-logo', ariaHidden: true, className: 'c-header__brand-logo' })
 

package/themes/umberto/layout/gloria/_trackers/google-tag-manager-noscript.pug

@@ -0,0 +1,4 @@
+mixin google-tag-manager-noscript()
+	if googletagmanager && googletagmanager.gtm
+		noscript
+			iframe( src='https://www.googletagmanager.com/ns.html?id=' + googletagmanager.gtm height='0' width='0' style='display:none;visibility:hidden' )

package/themes/umberto/layout/gloria/_trackers/index.pug

@@ -1,2 +1,3 @@
+include google-tag-manager-noscript
 include google-tag-manager
 include google-analytics

package/themes/umberto/layout/gloria/api.pug

@@ -7,6 +7,7 @@ html(lang='en')
 	head
 		include _head/index
 	body.l-layout.js-layout
+		+google-tag-manager-noscript
 		+header-nightly-info
 		+header-lts-info
 		+header-promobar

package/themes/umberto/layout/gloria/base.pug

@@ -6,6 +6,7 @@ html(lang='en')
 	head
 		include _head/index
 	body.l-layout.js-layout
+		+google-tag-manager-noscript
 		+header-nightly-info
 		+header-lts-info
 		+header-promobar

package/themes/umberto/layout/gloria/index.pug

@@ -7,6 +7,7 @@ html(lang='en')
 		include _head/index
 
 	body.l-layout.l-layout--muted.js-layout
+		+google-tag-manager-noscript
 		+header-nightly-info
 		+header-lts-info
 		+header-promobar

package/themes/umberto/layout/umberto/_partial/google-tag-manager.pug

@@ -1,18 +1,14 @@
 if googletagmanager
-
-    // Google Tag Manager
-    script.
-        if (!{ JSON.stringify(googletagmanager.domains) }.indexOf(location.hostname) !== -1) {
-            (function (w, d, s, l, i) {
-                w[l] = w[l] || [];
-                w[l].push({'gtm.start': new Date().getTime(), event: 'gtm.js'});
-                var f = d.getElementsByTagName(s)[0],
-                    j = d.createElement(s),
-                    dl = l != 'dataLayer' ? '&l=' + l : '';
-                j.async = true;
-                j.src = 'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
-                f.parentNode.insertBefore(j, f);
-            })( window, document, 'script', 'dataLayer', '!{ googletagmanager.gtm }' );
-        }
-
-    // End Google Tag Manager
+	script.
+		if (!{ JSON.stringify(googletagmanager.domains) }.indexOf(location.hostname) !== -1) {
+			(function (w, d, s, l, i) {
+				w[l] = w[l] || [];
+				w[l].push({'gtm.start': new Date().getTime(), event: 'gtm.js'});
+				var f = d.getElementsByTagName(s)[0],
+					j = d.createElement(s),
+					dl = l != 'dataLayer' ? '&l=' + l : '';
+				j.async = true;
+				j.src = 'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
+				f.parentNode.insertBefore(j, f);
+			})( window, document, 'script', 'dataLayer', '!{ googletagmanager.gtm }' );
+		}