@maptiler/geocoding-control 2.0.0 → 2.0.1

package/svelte/maptilersdk.js

@@ -1,7 +1,7 @@
 import * as maptilersdk from "@maptiler/sdk";
-import { crateBaseClass, } from "./MapLibreBasedGeocodingControl";
+import { crateClasses, } from "./MapLibreBasedGeocodingControl";
 export { createMapLibreGlMapController } from "./maplibregl-controller";
-const Base = crateBaseClass(maptilersdk.Evented, maptilersdk, (map, div) => {
+const { MapLibreBasedGeocodingControl, events } = crateClasses(maptilersdk.Evented, maptilersdk, (map, div) => {
     const sdkConfig = {};
     if (!("getSdkConfig" in map && typeof map.getSdkConfig === "function")) {
         throw new Error("MapTiler SDK not detected");
@@ -15,8 +15,16 @@ const Base = crateBaseClass(maptilersdk.Evented, maptilersdk, (map, div) => {
     div.className += " maptiler-ctrl";
     return sdkConfig;
 });
-export class GeocodingControl extends Base {
+export class GeocodingControl extends MapLibreBasedGeocodingControl {
     onAdd(map) {
         return super.onAddInt(map);
     }
 }
+export const SelectEvent = events.SelectEvent;
+export const FeaturesListedEvent = events.FeaturesListedEvent;
+export const FeaturesMarkedEvent = events.FeaturesMarkedEvent;
+export const OptionsVisibilityChangeEvent = events.OptionsVisibilityChangeEvent;
+export const PickEvent = events.PickEvent;
+export const QueryChangeEvent = events.QueryChangeEvent;
+export const ResponseEvent = events.ResponseEvent;
+export const ReverseToggleEvent = events.ReverseToggleEvent;

package/svelte/openlayers-controller.d.ts

@@ -9,7 +9,7 @@ export declare function createOpenLayersMapController(map: Map, flyToOptions?: A
     fitBounds(bbox: BBox, padding: number, maxZoom: number): void;
     indicateReverse(reverse: boolean): void;
     setReverseMarker(coordinates?: Position): void;
-    setMarkers(markedFeatures: FeatureType[] | undefined, picked: FeatureType | undefined): void;
+    setFeatures(markedFeatures: FeatureType[] | undefined, picked: FeatureType | undefined, showPolygonMarker: boolean): void;
     setSelectedMarker(index: number): void;
     getCenterAndZoom(): [number, x: number, y: number] | undefined;
 };

package/svelte/openlayers-controller.js

@@ -167,7 +167,7 @@ export function createOpenLayersMapController(map, flyToOptions = {}, flyToBound
                 source.addFeature(reverseMarker);
             }
         },
-        setMarkers(markedFeatures, picked) {
+        setFeatures(markedFeatures, picked, showPolygonMarker) {
             function setData(data) {
                 if (!data) {
                     return;
@@ -235,6 +235,9 @@ export function createOpenLayersMapController(map, flyToOptions = {}, flyToBound
                     source.addFeature(new OlFeature(fromWgs84(new OlMultiLineString(picked.geometry.coordinates))));
                     return; // no pin for (multi)linestrings
                 }
+                if (!showPolygonMarker && picked.geometry.type !== "Point") {
+                    return;
+                }
                 source.addFeature(new OlFeature(fromWgs84(new OlPoint(picked.center))));
             }
             for (const feature of markedFeatures ?? []) {

package/svelte/openlayers.d.ts

@@ -1,7 +1,10 @@
 import type { Map } from "ol";
+import type { ObjectEvent } from "ol/Object";
+import type { CombinedOnSignature, EventTypes } from "ol/Observable";
 import type { AnimationOptions, FitOptions } from "ol/View";
 import { Control } from "ol/control";
 import type { Options } from "ol/control/Control";
+import type { EventsKey } from "ol/events";
 import BaseEvent from "ol/events/Event";
 import type { StyleLike } from "ol/style/Style";
 import type { FlatStyleLike } from "ol/style/flat";
@@ -11,8 +14,26 @@ type OpenLayersControlOptions = ControlOptions & Options & {
     flyTo?: boolean | (AnimationOptions & FitOptions);
     fullGeometryStyle?: StyleLike | FlatStyleLike;
 };
+type CustomEventMap = {
+    select: SelectEvent;
+    featureslisted: FeaturesListedEvent;
+    featuresmarked: FeaturesMarkedEvent;
+    optionsvisibilitychange: OptionsVisibilityChangeEvent;
+    pick: PickEvent;
+    querychange: QueryChangeEvent;
+    response: ResponseEvent;
+    reversetoggle: ReverseToggleEvent;
+};
+type CustomObjectOnSignature<ReturnType> = {
+    <K extends keyof CustomEventMap>(type: K, listener: (evt: CustomEventMap[K]) => void): ReturnType;
+} & {
+    (type: "propertychange", listener: (evt: ObjectEvent) => void): ReturnType;
+} & CombinedOnSignature<EventTypes | "propertychange" | keyof CustomEventMap, ReturnType>;
 export declare class GeocodingControl extends Control {
     #private;
+    on: CustomObjectOnSignature<EventsKey>;
+    once: CustomObjectOnSignature<EventsKey>;
+    un: CustomObjectOnSignature<EventsKey>;
     constructor(options: OpenLayersControlOptions);
     setMap(map: Map | null): void;
     setOptions(options: OpenLayersControlOptions): void;

package/svelte/openlayers.js

@@ -21,45 +21,30 @@ export class GeocodingControl extends Control {
                 ...restOptions,
             },
         });
-        for (const eventName of [
-            "select",
-            "pick",
-            "featuresListed",
-            "featuresMarked",
-            "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
-        ]) {
-            this.#gc.$on(eventName, (event) => {
-                switch (eventName) {
-                    case "select":
-                        this.dispatchEvent(new SelectEvent(event.detail));
-                        break;
-                    case "featuresListed":
-                        this.dispatchEvent(new FeaturesListedEvent(event.detail));
-                        break;
-                    case "featuresMarked":
-                        this.dispatchEvent(new FeaturesMarkedEvent(event.detail));
-                        break;
-                    case "optionsVisibilityChange":
-                        this.dispatchEvent(new OptionsVisibilityChangeEvent(event.detail));
-                        break;
-                    case "pick":
-                        this.dispatchEvent(new PickEvent(event.detail));
-                        break;
-                    case "queryChange":
-                        this.dispatchEvent(new QueryChangeEvent(event.detail));
-                        break;
-                    case "response":
-                        this.dispatchEvent(new ResponseEvent(event.detail.url, event.detail.featureCollection));
-                        break;
-                    case "reverseToggle":
-                        this.dispatchEvent(new ReverseToggleEvent(event.detail));
-                        break;
-                }
-            });
-        }
+        this.#gc.$on("select", (event) => {
+            this.dispatchEvent(new SelectEvent(event.detail.feature));
+        });
+        this.#gc.$on("pick", (event) => {
+            this.dispatchEvent(new PickEvent(event.detail.feature));
+        });
+        this.#gc.$on("featureslisted", (event) => {
+            this.dispatchEvent(new FeaturesListedEvent(event.detail.features));
+        });
+        this.#gc.$on("featuresmarked", (event) => {
+            this.dispatchEvent(new FeaturesMarkedEvent(event.detail.features));
+        });
+        this.#gc.$on("response", (event) => {
+            this.dispatchEvent(new ResponseEvent(event.detail.url, event.detail.featureCollection));
+        });
+        this.#gc.$on("optionsvisibilitychange", (event) => {
+            this.dispatchEvent(new OptionsVisibilityChangeEvent(event.detail.optionsVisible));
+        });
+        this.#gc.$on("reversetoggle", (event) => {
+            this.dispatchEvent(new ReverseToggleEvent(event.detail.reverse));
+        });
+        this.#gc.$on("querychange", (event) => {
+            this.dispatchEvent(new QueryChangeEvent(event.detail.query));
+        });
         this.#options = options;
     }
     setMap(map) {
@@ -77,7 +62,7 @@ export class GeocodingControl extends Control {
         }
     }
     setOptions(options) {
-        this.#options = options;
+        Object.assign(this.#options, options);
         const { flyTo, fullGeometryStyle, ...restOptions } = this.#options;
         this.#gc?.$set({
             ...restOptions,
@@ -110,21 +95,21 @@ export class SelectEvent extends BaseEvent {
 export class FeaturesListedEvent extends BaseEvent {
     features;
     constructor(features) {
-        super("featuresListed");
+        super("featureslisted");
         this.features = features;
     }
 }
 export class FeaturesMarkedEvent extends BaseEvent {
     features;
     constructor(features) {
-        super("featuresMarked");
+        super("featuresmarked");
         this.features = features;
     }
 }
 export class OptionsVisibilityChangeEvent extends BaseEvent {
     optionsVisible;
     constructor(optionsVisible) {
-        super("optionsVisibilityChange");
+        super("optionsvisibilitychange");
         this.optionsVisible = optionsVisible;
     }
 }
@@ -138,7 +123,7 @@ export class PickEvent extends BaseEvent {
 export class QueryChangeEvent extends BaseEvent {
     query;
     constructor(query) {
-        super("queryChange");
+        super("querychange");
         this.query = query;
     }
 }
@@ -154,7 +139,7 @@ export class ResponseEvent extends BaseEvent {
 export class ReverseToggleEvent extends BaseEvent {
     reverse;
     constructor(reverse) {
-        super("reverseToggle");
+        super("reversetoggle");
         this.reverse = reverse;
     }
 }

package/svelte/react.d.ts

@@ -1,5 +1,5 @@
-import type { ControlOptions, DispatcherType, MapController } from "./types";
-type EventNames = keyof DispatcherType;
+import type { ControlOptions, DispatcherTypeCC, MapController } from "./types";
+type EventNames = keyof DispatcherTypeCC;
 type EventHandlerFnName<T extends EventNames> = `on${Capitalize<T>}`;
 type CallbackProperties<T> = {
     [K in keyof T as EventHandlerFnName<Extract<K, EventNames>>]?: (event: T[K]) => void;
@@ -7,7 +7,7 @@ type CallbackProperties<T> = {
 type MapControllerProp = {
     mapController?: MapController;
 };
-export type Props = ControlOptions & CallbackProperties<DispatcherType> & MapControllerProp;
+export type Props = ControlOptions & CallbackProperties<DispatcherTypeCC> & MapControllerProp;
 export type Methods = {
     blur(): void;
     focus(): void;
@@ -15,5 +15,5 @@ export type Methods = {
     clearMap(): void;
     clearList(): void;
 };
-declare const ReactGeocodingControl: import("react").ForwardRefExoticComponent<ControlOptions & CallbackProperties<DispatcherType> & MapControllerProp & import("react").RefAttributes<Methods>>;
+declare const ReactGeocodingControl: import("react").ForwardRefExoticComponent<ControlOptions & CallbackProperties<DispatcherTypeCC> & MapControllerProp & import("react").RefAttributes<Methods>>;
 export { ReactGeocodingControl as GeocodingControl };

package/svelte/react.js

@@ -11,6 +11,7 @@ const eventNames = [
     "select",
 ];
 const propertyNames = [
+    "adjustUrlQuery",
     "apiKey",
     "bbox",
     "clearButtonTitle",
@@ -19,25 +20,24 @@ const propertyNames = [
     "country",
     "debounceSearch",
     "enableReverse",
-    "reverseActive",
     "errorMessage",
+    "excludeTypes",
     "filter",
     "fuzzyMatch",
     "language",
     "limit",
+    "mapController",
     "minLength",
     "noResultsMessage",
+    "pickedResultStyle",
     "placeholder",
     "proximity",
+    "reverseActive",
     "reverseButtonTitle",
-    "showFullGeometry",
     "showPlaceType",
     "showResultsWhileTyping",
-    "adjustUrlQuery",
     "types",
-    "excludeTypes",
     "zoom",
-    "mapController",
 ];
 function getEventFnName(name) {
     return ("on" +

package/svelte/types.d.ts

@@ -33,7 +33,7 @@ export type MapController = {
     flyTo(center: Position, zoom?: number): void;
     fitBounds(bbox: BBox, padding: number, maxZoom?: number): void;
     indicateReverse(reverse: boolean): void;
-    setMarkers(features: Feature[] | undefined, picked: Feature | undefined): void;
+    setFeatures(features: Feature[] | undefined, picked: Feature | undefined, showPolygonMarker: boolean): void;
     setReverseMarker(coordinates?: Position): void;
     setSelectedMarker(index: number): void;
     getCenterAndZoom(): [zoom: number, lon: number, lat: number] | undefined;
@@ -68,43 +68,51 @@ export type ControlOptions = {
     /**
      * Sets the amount of time, in milliseconds, to wait before querying the server when a user types into the Geocoder input box.
      * This parameter may be useful for reducing the total number of API calls made for a single query.
+     *
      * Default value is `200`.
      */
     debounceSearch?: number;
     /**
      * Search results closer to the proximity point will be given higher priority. First matching rule from the array will be used.
      * Set to `null` to disable the proximity.
+     *
      * Default value is `[{ type: "server-geolocation" }]`.
      */
     proximity?: ProximityRule[] | null;
     /**
      * Override the default placeholder attribute value.
+     *
      * Default value is `"Search"`.
      */
     placeholder?: string;
     /**
      * Override the default error message.
+     *
      * Default value is `"Something went wrong…"`.
      */
     errorMessage?: string;
     /**
      * Override the default message if no results are found.
+     *
      * Default value is `"Oops! Looks like you're trying to predict something that's not quite right. We can't seem to find what you're looking for. Maybe try double-checking your spelling or try a different search term. Keep on typing - we'll do our best to get you where you need to go!"`.
      */
     noResultsMessage?: string;
     /**
      * Minimum number of characters to enter before results are shown.
+     *
      * Default value is `2`.
      */
     minLength?: number;
     /**
      * A bounding box argument: this is a bounding box given as an array in the format [minX, minY, maxX, maxY].
      * Search results will be limited to the bounding box.
+     *
      * Default value is `undefined`.
      */
     bbox?: BBox;
     /**
      * Maximum number of results to show.
+     *
      * Default value is `5`.
      */
     limit?: number;
@@ -113,128 +121,144 @@ export type ControlOptions = {
      * Options are IETF language tags comprised of a mandatory ISO 639-1 language code and optionally one or more IETF subtags for country or script.
      * More than one value can also be specified, separated by commas.
      * Set to `null` or empty string for disabling language-specific searching.
-     * Defaults to the browser's language settings.
-     * Default value is `undefined`.
+     *
+     * Default value is `undefined` which means to use the browser's language settings.
      */
     language?: string | string[] | null;
     /**
      * If `false`, indicates that search will only occur on enter key press.
      * If `true`, indicates that the Geocoder will search on the input box being updated above the minLength option.
+     *
      * Default value is `false`.
      */
     showResultsWhileTyping?: boolean;
     /**
      * Set to `false` to disable fuzzy search.
-     * Default value is `true`
+     *
+     * Default value is `true`.
      */
     fuzzyMatch?: boolean;
     /**
      * On geocoded result what zoom level should the map animate to when a bbox in the response isn't present or is a point.
      * If a bbox is present and not a point then the map will fit to the bbox.
      *
-     * Value can be a number (deprecated) or key-value pairs, where key is a <type> or <type>.<categoy> and value is the zoom level.
+     * Value is key-value pairs, where key is a <type> or <type>.<categoy> and the value is the zoom level.
      *
      * Default value is `GeocodingControl.ZOOM_DEFAULTS`.
      */
-    zoom?: number | Record<string, number>;
-    /**
-     * On geocoded result what max zoom level should the map animate to when a bbox in the response isn't present or is a point.
-     * Used for small features.
-     *
-     * If a bbox is present and not a point then the map will fit to the bbox.
-     *
-     * @deprecated use `zoom` option
-     */
-    maxZoom?: number;
+    zoom?: Record<string, number>;
     /**
      * If `true`, the geocoder control will collapse until hovered or in focus.
+     *
      * Default value is `false`.
      */
     collapsed?: boolean;
     /**
      * If true, the geocoder control will clear its value when the input blurs.
+     *
      * Default value is `false`.
      */
     clearOnBlur?: boolean;
     /**
      * A function which accepts a Feature in the Carmen GeoJSON format to filter out results from the Geocoding API response before they are included in the suggestions list.
      * Return true to keep the item, false otherwise.
+     *
+     * Default value is a function returning always `true`.
      */
     filter?: (feature: Feature) => boolean;
     /**
      * Class of the root element.
+     *
      * Default value is `undefined`.
      */
     class?: string;
     /**
-     * Set to `true` to enable reverse geocoding button with title. Set to `"always"` to reverse geocoding be always active.
-     * Default value is `false`
+     * Set to `button` to enable reverse geocoding button with title. Set to `"always"` to reverse geocoding be always active.
+     *
+     * Default value is `"never"`.
      */
-    enableReverse?: boolean | "always";
+    enableReverse?: EnableReverse;
     /**
-     * Toggle reverse mode.
+     * Reverse mode active.
+     *
      * Default value is `false`.
      */
     reverseActive?: boolean;
     /**
-     * Reverse toggle button title.
+     * Title of the reverse toggle button.
+     *
      * Default value is `"toggle reverse geocoding"`.
      */
     reverseButtonTitle?: string;
     /**
-     * Clear button title.
+     * Title of the clear button.
+     *
      * Default value is `"clear"`.
      */
     clearButtonTitle?: string;
     /**
-     * Set to `false` to hide place/POI type. If set to `"always"` then type is shown for all items.
-     * If set to `"ifNeeded"` then type is shown only for places/POIs not determined from the icon.
-     * Default value is `"ifNeeded"`.
+     * Set to `"never"` to hide place/POI type. If set to `"always"` then type is shown for all items.
+     * If set to `"if-needed"` then type is shown only for places/POIs not determined from the icon.
+     *
+     * Default value is `"if-needed"`.
      */
-    showPlaceType?: false | "always" | "ifNeeded";
+    showPlaceType?: ShowPlaceType;
     /**
-     * Set to `true` to show full feature geometry of the chosen result. Otherwise only marker will be shown.
+     * Style of the picked result on the map:
+     *
+     * - `"marker-only"` - show only marker at the center of the feature
+     * - `"full-geometry"` - show full feature geometry of the chosen result
+     * - `"full-geometry-including-polygon-center-marker"` - show full feature geometry of the chosen result together with a marker in the center of polygon feature
+     *
      * Default value is `true`.
      */
-    showFullGeometry?: boolean;
+    pickedResultStyle?: PickedResultStyle;
     /**
      * Limit search to specified country(ies).
+     *
      * Default value is `undefined` - use all countries.
      */
     country?: string | string[];
     /**
      * Filter of feature types to return.
+     *
      * Default value is `undefined` - all available feature types are returned.
      */
     types?: string[];
     /**
      * Use `limit` value for reverse geocoding even if `types` is not an array with a single element.
      * Will work only if enabled on the server.
+     *
      * Default value is `false`.
      */
     exhaustiveReverseGeocoding?: boolean;
     /**
      * If set to `true` then use all types except for those listed in `types`.
+     *
      * Default value is `false`.
      */
     excludeTypes?: boolean;
     /**
      * Geocoding API URL.
+     *
      * Default value is MapTiler Geocoding API URL.
      */
     apiUrl?: string;
     /**
      * Extra fetch parameters.
+     *
      * Default value is `undefined`.
      */
     fetchParameters?: RequestInit;
     /**
      * Base URL for POI icons.
+     *
      * Default value is `"icons/"` for Svelte apps, otherwise `"https://cdn.maptiler.com/maptiler-geocoding-control/v${version}/icons/"`.
      */
     iconsBaseUrl?: string;
     /**
      * Function to adjust URL search parameters.
+     *
      * Default value is empty function.
      */
     adjustUrlQuery?: (sp: URLSearchParams) => void;
@@ -257,16 +281,41 @@ export type ControlOptions = {
      */
     markerOnSelected?: boolean;
 };
-export type DispatcherType = {
-    featuresListed: Feature[] | undefined;
-    featuresMarked: Feature[] | undefined;
-    optionsVisibilityChange: boolean;
-    pick: Feature | undefined;
-    queryChange: string;
+export type PickedResultStyle = "marker-only" | "full-geometry" | "full-geometry-including-polygon-center-marker";
+export type EnableReverse = "never" | "always" | "button";
+export type ShowPlaceType = "never" | "always" | "if-needed";
+export type DispatcherTypeCC = {
+    featuresListed: {
+        features: Feature[] | undefined;
+    };
+    featuresMarked: {
+        features: Feature[] | undefined;
+    };
+    optionsVisibilityChange: {
+        optionsVisible: boolean;
+    };
+    pick: {
+        feature: Feature | undefined;
+    };
+    queryChange: {
+        query: string;
+    };
     response: {
         url: string;
         featureCollection: FeatureCollection;
     };
-    reverseToggle: boolean;
-    select: Feature | undefined;
+    reverseToggle: {
+        reverse: boolean;
+    };
+    select: {
+        feature: Feature | undefined;
+    };
+};
+export type DispatcherType = {
+    [T in keyof DispatcherTypeCC as Lowercase<T>]: DispatcherTypeCC[T];
 };
+export type RedefineType<OriginalType, UpdatedType extends {
+    [K in keyof OriginalType]: OriginalType[K];
+} & {
+    [K in Exclude<keyof UpdatedType, keyof OriginalType>]: never;
+}> = UpdatedType;

package/svelte/vanilla.d.ts

@@ -1,7 +1,17 @@
-import type { ControlOptions, MapController } from "./types";
+import type { ControlOptions, DispatcherType, MapController } from "./types";
 type Options = ControlOptions & {
     mapController?: MapController;
 };
+interface GeocodingControlEvent<T> extends CustomEvent<T> {
+    readonly target: GeocodingControl;
+    readonly currentTarget: GeocodingControl;
+}
+type CustomEventListenerOrEventListenerObject<K extends keyof CustomEventMap> = ((evt: CustomEventMap[K]) => void) | {
+    handleEvent(object: CustomEventMap[K]): void;
+};
+type CustomEventMap = {
+    [T in keyof DispatcherType]: GeocodingControlEvent<DispatcherType[T]>;
+};
 export declare class GeocodingControl extends EventTarget {
     #private;
     constructor({ target, ...options }: Options & {
@@ -13,5 +23,8 @@ export declare class GeocodingControl extends EventTarget {
     clearList(): void;
     focus(): void;
     blur(): void;
+    addEventListener<K extends keyof CustomEventMap>(type: K, callback: CustomEventListenerOrEventListenerObject<K> | null, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof CustomEventMap>(type: K, callback: CustomEventListenerOrEventListenerObject<K> | null, options?: EventListenerOptions | boolean): void;
+    dispatchEvent<K extends keyof CustomEventMap>(event: CustomEventMap[K]): boolean;
 }
 export {};

package/svelte/vanilla.js

@@ -1,4 +1,4 @@
-import GC from "./GeocodingControl.svelte";
+import GeocodingControlComponent from "./GeocodingControl.svelte";
 const finalizationRegistry = new FinalizationRegistry((gc) => {
     gc.$destroy();
 });
@@ -6,22 +6,31 @@ export class GeocodingControl extends EventTarget {
     #gc;
     constructor({ target, ...options }) {
         super();
-        this.#gc = new GC({
+        this.#gc = new GeocodingControlComponent({
             target,
             props: options,
         });
         for (const eventName of [
             "select",
             "pick",
-            "featuresListed",
-            "featuresMarked",
+            "featureslisted",
+            "featuresmarked",
             "response",
-            "optionsVisibilityChange",
-            "reverseToggle",
-            "queryChange",
+            "optionsvisibilitychange",
+            "reversetoggle",
+            "querychange",
         ]) {
-            this.#gc.$on(eventName, (event) => this.dispatchEvent(event));
+            this.#gc.$on(eventName, (event) => {
+                // Use the new `emit` method for type-safe dispatching
+                this.#emit(eventName, event.detail);
+            });
         }
+        this.#gc.$on("select", (event) => {
+            const geocodingEvent = new CustomEvent(event.type, {
+                detail: event.detail,
+            });
+            this.dispatchEvent(geocodingEvent);
+        });
         finalizationRegistry.register(this, this.#gc);
     }
     setOptions(options) {
@@ -42,4 +51,18 @@ export class GeocodingControl extends EventTarget {
     blur() {
         this.#gc?.blur();
     }
+    addEventListener(type, callback, options) {
+        super.addEventListener(type, callback, options);
+    }
+    removeEventListener(type, callback, options) {
+        super.removeEventListener(type, callback, options);
+    }
+    dispatchEvent(event) {
+        return super.dispatchEvent(event);
+    }
+    #emit(type, detail) {
+        return super.dispatchEvent(new CustomEvent(type, {
+            detail,
+        }));
+    }
 }