@panoramax/web-viewer 4.0.2 → 4.0.3-develop-d59993ce

package/src/utils/PresetsManager.js

@@ -0,0 +1,137 @@
+import { PanoramaxPresetsURL } from "./services";
+
+// Iconify aliases for whole collections
+const ICON_COLLECTIONS_SUB = {
+	"fas": "fa6-solid"
+};
+
+// Iconify aliases for specific icons
+const ICON_SUBS = {
+	"fa6-solid:directions": "fa6-solid:diamond-turn-right"
+};
+
+/**
+ * Presets Manager handle retrieval of presets against dedicated endpoint.
+ * It allows an easily search between all presets, and handles translations.
+ *
+ * @class Panoramax.utils.PresetsManager
+ * @typicalname presetsManager
+ * @param {string} [lang] The user prefered language. Defaults to web browser preferences.
+ * @param {boolean} [skipLoad=false] Set to true to disable automatic load of API data
+ */
+export default class PresetManager {
+	constructor(lang = null, skipLoad = false) {
+		this._ready = false;
+		this._presets = null;
+		this._translations = {};
+		if(!skipLoad) { this._load(lang); }
+	}
+
+	/**
+	 * Downloads various JSON file against presets API.
+	 * @private
+	 */
+	async _load(lang) {
+		lang = lang || window.navigator.languages[0]?.substring(0, 2);
+		
+		try {
+			const [translationsENRes, translationsLangRes, presetsRes] = await Promise.all([
+				fetch(`${PanoramaxPresetsURL()}/translations/en.min.json`),
+				lang ? fetch(`${PanoramaxPresetsURL()}/translations/${lang}.min.json`) : Promise.resolve({ok: true}),
+				fetch(`${PanoramaxPresetsURL()}/presets.min.json`),
+			]);
+
+			if (
+				!translationsENRes || !translationsLangRes || !presetsRes
+				|| !translationsENRes.ok || !translationsLangRes.ok || !presetsRes.ok
+			) {
+				this._ready = -1;
+				throw new Error("Presets service is not available");
+			}
+
+			this._presets = await presetsRes.json();
+			this._translations.en = (await translationsENRes.json())?.en?.presets;
+			if(lang) {
+				this._translations[lang] = (await translationsLangRes.json())?.[lang]?.presets;
+			}
+
+			// Post-process presets
+			Object.entries(this._presets).forEach(([pid,p]) => {
+				// Add labels
+				if(this._translations[lang]?.presets?.[pid]?.name) {
+					p.name = this._translations[lang].presets[pid].name;
+				}
+				else if(this._translations.en?.presets?.[pid]?.name) {
+					p.name = this._translations.en.presets[pid].name;
+				}
+
+				// Create iconify-compatible icon
+				if(p.icon) {
+					const iconColl = p.icon.split("-")[0];
+					const iconCollSub = ICON_COLLECTIONS_SUB[iconColl];
+					p.iconify = iconCollSub ? p.icon.replace(iconColl+"-", iconCollSub+":") : p.icon.split("-")[0]+":"+p.icon.split("-").slice(1).join("-");
+					if(ICON_SUBS[p.iconify]) { p.iconify = ICON_SUBS[p.iconify]; }
+				}
+			});
+
+			this._ready = true;
+		} catch (error) {
+			console.error("Presets service throws an error:", error);
+			this._ready = -1;
+		}
+	}
+
+	/**
+	 * Resolves when the all necessary data was downloaded.
+	 * @memberOf Panoramax.utils.PresetsManager#
+	 * @returns {Promise}
+	 */
+	async onceReady() {
+		if(!this._ready) {
+			await new Promise(resolve => setTimeout(resolve, 250));
+			return this.onceReady();
+		}
+		else if(this._ready === -1) { return Promise.reject(); }
+		else { return Promise.resolve(); }
+	}
+
+	/**
+	 * Find the best matching preset for a given STAC feature.
+	 * @memberOf Panoramax.utils.PresetsManager#
+	 * @returns {Promise}
+	 * @fulfil {object|null} The preset JSON that best matches, or null if no matches
+	 */
+	async getPreset(f) {
+		return this.onceReady().then(() => {
+			const candidatePresets = Object.values(this._presets).filter(p => {
+				if(Object.keys(p.tags).length === 0) { return false; }
+
+				// Check if every tag on preset exists in feature
+				for(let pk in p.tags) {
+					const pv = p.tags[pk];
+					if(!f.semantics.find(s => s.key === pk && (pv === "*" || pv === s.value))) {
+						return false;
+					}
+				}
+				return true;
+			});
+
+			// Find best matching preset
+			candidatePresets.sort((a,b) => {
+				const nbTagsA = Object.keys(a.tags).length;
+				const nbTagsB = Object.keys(b.tags).length;
+
+				if(nbTagsA > nbTagsB) { return -1; }
+				else if(nbTagsA === nbTagsB) {
+					const nbTagsStarA = Object.values(a.tags).filter(v => v === "*").length;
+					const nbTagsStarB = Object.values(b.tags).filter(v => v === "*").length;
+					if(nbTagsStarA < nbTagsStarB) { return -1; }
+					else if(nbTagsStarA > nbTagsStarB) { return 1; }
+					else { return 0; }
+				}
+				else { return 1; }
+			});
+			return candidatePresets.shift();
+		});
+	}
+}

package/src/utils/URLHandler.js

@@ -150,7 +150,7 @@ export default class URLHandler extends EventTarget {
 		// If hash is compressed
 		if(keyvals.s) {
 			const shortVals = Object.fromEntries(
-				keyvals.s
+				decodeURIComponent(keyvals.s)
 					.split(";")
 					.map(kv => [kv[0], kv.substring(1)])
 			);

package/src/utils/geocoder.js

@@ -3,6 +3,20 @@ import maplibregl from "!maplibre-gl";
 
 import { NominatimBaseUrl, AdresseDataGouvBaseURL } from "./services";
 
+const PLACETYPE_ZOOM =  {
+	"house": 20,
+	"housenumber": 20,
+	"street": 18,
+	"locality": 15,
+	"district": 13,
+	"municipality": 12,
+	"city": 12,
+	"county": 8,
+	"region": 7,
+	"state": 7,
+	"country": 5
+};
+
 /**
  * Transforms a set of parameters into an URL-ready string
  * It also removes null/undefined values
@@ -20,69 +34,6 @@ function geocoderParamsToURLString(params) {
 	return new URLSearchParams(p).toString();
 }
 
-/**
- * Transforms Nominatim search result into a nice-to-display address.
- * @param {object} addr The Nominatim API "address" property
- * @returns {string} The clean-up string for display
- * @private
- */
-function nominatimAddressToPlaceName(addr) {
-	// API format @ https://nominatim.org/release-docs/develop/api/Output/#addressdetails
-	if(!addr || typeof addr != "object") { return ""; }
-
-	let res = "";
-
-	// House n°-like
-	if(addr.house_number) { res = addr.house_number; }
-	else if(addr.house_name) { res = addr.house_name; }
-	else {
-		const potentialNames = [
-			"emergency", "historic", "military", "natural", "landuse", "place", "railway", "man_made",
-			"aerialway", "boundary", "amenity", "aeroway", "club", "craft", "leisure", "office",
-			"mountain_pass", "shop", "tourism", "bridge", "tunnel", "waterway", "park"
-		];
-		for(let pn of potentialNames) {
-			if(addr[pn]) {
-				res = addr[pn];
-				break;
-			}
-		}
-	}
-
-	// Street-like
-	let street;
-	if(addr.road && addr.road.length > 6) { street = addr.road; }
-	else {
-		const potentialNames = [
-			// Hamlet-like
-			"hamlet", "croft", "isolated_dwelling",
-			// Zone Indus-like
-			"farm", "farmyard", "industrial", "commercial", "retail", "city_block", "residential",
-			// Quarter-like
-			"neighbourhood", "allotments", "quarter",
-			// Fallback to road if nothing else found
-			"road"
-		];
-		for(let pn of potentialNames) {
-			if(addr[pn]) {
-				street = addr[pn];
-				break;
-			}
-		}
-	}
-
-	if(street && res.length > 0) { res += (addr.house_number ? " " : ", ")+street; }
-	else if(street) { res = street; }
-
-	// City
-	if(addr.village || addr.town || addr.city || addr.municipality) {
-		if(res.length > 0) { res += ", "; }
-		res += addr.village || addr.town || addr.city || addr.municipality;
-	}
-
-	return res;
-}
-
 /**
  * Nominatim (OSM) geocoder, ready to use for our Map
  * @private
@@ -96,18 +47,19 @@ export function forwardGeocodingNominatim(config) {
 		viewbox: config.bbox,
 	};
 
-	return fetch(`${NominatimBaseUrl()}/search?${geocoderParamsToURLString(params)}&format=geojson&polygon_geojson=1&addressdetails=1`)
+	return fetch(`${NominatimBaseUrl()}/search?${geocoderParamsToURLString(params)}&format=geocodejson&addressdetails=1`)
 		.then(res => res.json())
 		.then(res => {
 			const finalRes = { features: [] };
 			const listedNames = [];
-			res.features.forEach(f => {
-				const plname = nominatimAddressToPlaceName(f.properties.address) || f.properties.display_name;
+			(res.features || []).forEach(f => {
+				const plname = geocodeJsonToPlaceName(f.properties?.geocoding) || f.properties?.geocoding?.label;
 				if(!listedNames.includes(plname)) {
 					finalRes.features.push({
 						place_type: ["place"],
 						place_name: plname,
-						bounds: new maplibregl.LngLatBounds(f.bbox),
+						center: new maplibregl.LngLat(...f.geometry.coordinates),
+						zoom: PLACETYPE_ZOOM[f.properties?.geocoding?.type],
 					});
 					listedNames.push(plname);
 				}
@@ -117,18 +69,113 @@ export function forwardGeocodingNominatim(config) {
 }
 
 export function reverseGeocodingNominatim(lat, lon) {
-	return fetch(`${NominatimBaseUrl()}/reverse?lat=${lat}&lon=${lon}&zoom=18&format=jsonv2`)
+	return fetch(`${NominatimBaseUrl()}/reverse?lat=${lat}&lon=${lon}&zoom=18&format=geocodejson`)
 		.then(res => res.json())
-		.then(res => nominatimAddressToPlaceName(res?.address));
+		.then(res => geocodeJsonToPlaceName(res?.features?.shift()?.properties?.geocoding));
 }
 
 /**
  * Base adresse nationale (FR) geocoder, ready to use for our Map
- * @param {object} config Configuration sent by MapLibre GL Geocoder, following the geocoderApi format ( https://github.com/maplibre/maplibre-gl-geocoder/blob/main/API.md#setgeocoderapi )
- * @returns {object} GeoJSON Feature collection in Carmen GeoJSON format
+ * @param {object} config Configuration sent by MapLibre GL Geocoder, following the geocoderApi format ( https://maplibre.org/maplibre-gl-geocoder/types/MaplibreGeocoderApiConfig.html )
+ * @returns {object} GeoJSON Feature collection in Carmen GeoJSON format ( https://maplibre.org/maplibre-gl-geocoder/types/CarmenGeojsonFeature.html )
  * @private
  */
 export function forwardGeocodingBAN(config) {
+	return forwardGeocodingStandard(config, AdresseDataGouvBaseURL());
+}
+
+/**
+ * Transforms GeocodeJSON search result into a nice-to-display address.
+ * @param {object} props The GecodeJSON API feature properties
+ * @returns {string} The clean-up string for display
+ * @private
+ */
+function geocodeJsonToPlaceName(props) {
+	// API format @ https://github.com/geocoders/geocodejson-spec/blob/master/draft/README.md
+	if(!props || typeof props != "object") { return ""; }
+
+	// P1 = main name, P2=locality-like, P3=country+high-level admin
+	let p1 = props.name;
+	let p2 = [], p3 = [];
+
+	switch(props.type) {
+	case "hamlet":
+	case "croft":
+	case "isolated_dwelling":
+	case "neighbourhood":
+	case "allotments":
+	case "quarter":
+	case "farm":
+	case "farmyard":
+	case "industrial":
+	case "commercial":
+	case "retail":
+	case "city_block":
+	case "residential":
+	case "locality":
+	case "district":
+		p3.push(props.city);
+		p3.push(props.county);
+		p3.push(props.state);
+		p3.push(props.country);
+		break;
+	case "city":
+		p3.push(props.county);
+		p3.push(props.state);
+		p3.push(props.country);
+		break;
+	case "region":
+		p3.push(props.county);
+		p3.push(props.state);
+		p3.push(props.country);
+		break;
+	case "country":
+		break;
+	case "house":
+	case "housenumber":
+		p2.push(props.housenumber);
+		p2.push(props.street);
+		p2.push(props.locality);
+		p2.push(props.district);
+		p3.push(props.city);
+		p3.push(props.county);
+		p3.push(props.state);
+		p3.push(props.country);
+		break;
+	case "street":
+	case "road":
+	default:
+		p2.push(props.street);
+		p2.push(props.locality);
+		p2.push(props.district);
+		p3.push(props.city);
+		p3.push(props.county);
+		p3.push(props.state);
+		p3.push(props.country);
+		break;
+	}
+
+	p2 = p2.filter(v => v);
+	p2 = p2.filter((v,i) => v != p1 && (i === 0 || p2[i-1] !== v));
+	p2 = p2.length > 0 ? (props.housenumber ? p2.slice(0,2).join(" ") : p2.shift()) : null;
+	if(p2 === p1) { p2 = null; }
+
+	p3 = p3.filter(v => v);
+	p3 = p3.filter((v,i) => v != p1 && (!p2 || !p2.includes(v)) && (i === 0 || p3[i-1] !== v));
+
+	let res = [p1, p2, p3.shift()].filter(v => v);
+
+	return res.join(", ");
+}
+
+/**
+ * Standard forward geocoder
+ * @param {object} config Configuration sent by MapLibre GL Geocoder, following the geocoderApi format ( https://maplibre.org/maplibre-gl-geocoder/types/MaplibreGeocoderApiConfig.html )
+ * @param {string} endpoint The URL endpoint (everything before the /?q=...)
+ * @returns {object} GeoJSON Feature collection in Carmen GeoJSON format ( https://maplibre.org/maplibre-gl-geocoder/types/CarmenGeojsonFeature.html )
+ * @private
+ */
+export function forwardGeocodingStandard(config, endpoint) {
 	// Transform parameters into BAN format
 	const params = { q: config.query, limit: config.limit };
 	if(typeof config.proximity === "string") {
@@ -137,18 +184,23 @@ export function forwardGeocodingBAN(config) {
 		params.lon = lon;
 	}
 
-	const toPlaceName = p => [p.name, p.district, p.city].filter(v => v).join(", ");
-	const placeTypeToZoom =  { "housenumber": 20, "street": 18, "locality": 15, "municipality": 12 };
-	
-	return fetch(`${AdresseDataGouvBaseURL()}/search/?${geocoderParamsToURLString(params)}`)
+	return fetch(`${endpoint}/?${geocoderParamsToURLString(params)}`)
 		.then(res => res.json())
 		.then(res => {
-			res.features = res.features.map(f => ({
-				place_type: ["place"],
-				place_name: toPlaceName(f.properties),
-				center: new maplibregl.LngLat(...f.geometry.coordinates),
-				zoom: placeTypeToZoom[f.properties.type],
-			}));
-			return res;
+			const finalRes = { features: [] };
+			const listedNames = [];
+			(res.features || []).forEach(f => {
+				const plname = geocodeJsonToPlaceName(f.properties);
+				if(!listedNames.includes(plname) && f.properties.type != "other") {
+					finalRes.features.push({
+						place_type: ["place"],
+						place_name: plname,
+						center: new maplibregl.LngLat(...f.geometry.coordinates),
+						zoom: PLACETYPE_ZOOM[f.properties.type],
+					});
+					listedNames.push(plname);
+				}
+			});
+			return finalRes;
 		});
-}
+}

package/src/utils/index.js

@@ -2,11 +2,13 @@ import * as geocoder from "./geocoder";
 import * as i18n from "./i18n";
 import * as map from "./map";
 import * as picture from "./picture";
+import * as semantics from "./semantics";
 import * as services from "./services";
 import * as utils from "./utils";
 import * as widgets from "./widgets";
 
-export { geocoder, i18n, map, picture, services, utils, widgets };
+export { geocoder, i18n, map, picture, semantics, services, utils, widgets };
 export {default as API} from "./API";
 export {default as PhotoAdapter} from "./PhotoAdapter";
+export {default as PresetsManager} from "./PresetsManager";
 export {default as URLHandler} from "./URLHandler";

package/src/utils/picture.js

@@ -377,6 +377,11 @@ export function apiFeatureToPSVNode(f, t, fastInternet=false, customLinkFilter=n
 		};
 	}
 
+	// Cleanup empty semantics feature (metacatalog bug)
+	if(f.properties?.semantics) {
+		f.properties.semantics = f.properties.semantics.filter(o => Object.keys(o).length > 0);
+	}
+
 	const node = {
 		id: f.id,
 		caption: getNodeCaption(f, t),
@@ -444,4 +449,27 @@ export function filterRelatedPicsLinks(metadata, customFilter = null) {
 		arrowStyle: arrowStyle(l),
 		linkOffset: { yaw: rectifiedYaw }
 	}));
+}
+
+/**
+ * Read structured hashtags from picture metadata
+ * @private
+ */
+export function getHashTags(metadata) {
+	if(!metadata?.properties?.semantics) { return []; }
+	
+	// Find hashtag entry in semantics
+	const hashtagsTags = metadata.properties.semantics.filter(kv => kv.key === "hashtags");
+	const readHashTags = [];
+	hashtagsTags.forEach(htt => htt.value.split(";").forEach(v => readHashTags.push(v.trim())));
+
+	return readHashTags;
+}
+
+/**
+ * Check if a given picture has associated annotations.
+ * @private
+ */
+export function hasAnnotations(metadata) {
+	return metadata?.properties?.annotations?.length > 0;
 }

package/src/utils/semantics.js

@@ -0,0 +1,162 @@
+import { html } from "lit";
+import { fa } from "./widgets";
+import { faInfoCircle } from "@fortawesome/free-solid-svg-icons";
+import logoOsm from "../img/osm.svg";
+import logoWd from "../img/wd.svg";
+import { OSMWikiURL, WikidataURL } from "./services";
+
+
+// General helpers
+function valToValLink(val, url, title) {
+	return html`
+		${val}
+		<pnx-link-button
+			kind="superinline"
+			size="sm"
+			href=${url}
+			target="_blank"
+			style="vertical-align: middle"
+			title=${title}
+		>${fa(faInfoCircle)}</pnx-link-button>`;
+}
+
+// OSM helpers
+const OSM_MAIN_KEYS = [
+	"highway", "building", "amenity", "landuse", "natural", "waterway", "leisure",
+	"shop", "railway", "tourism", "barrier", "boundary", "place", "power"
+];
+
+// Supported prefixes for nice semantic display
+const KNOWN_PREFIXES = {
+	"": { title: "Panoramax" },
+
+	osm: {
+		title: "OpenStreetMap",
+		logo: logoOsm,
+		key_transform: (tag, _t) => valToValLink(
+			tag.key,
+			`${OSMWikiURL()}/Key:${tag.key}`,
+			_t.pnx.semantics_key_doc
+		),
+		value_transform: (tag, _t) => {
+			if(OSM_MAIN_KEYS.includes(tag.key)) {
+				return valToValLink(
+					tag.value,
+					`${OSMWikiURL()}/Tag:${tag.key}=${tag.value}`,
+					_t.pnx.semantics_value_doc
+				);
+			}
+			else { return tag.value; }
+		}
+	},
+
+	wd: {
+		title: "Wikidata",
+		logo: logoWd,
+		key_transform: (tag, _t) => {
+			const url = `${WikidataURL()}/Property:${tag.key}`;
+			return _t.pnx.semantics_wikidata_properties[tag.key]
+				? valToValLink(
+					`${_t.pnx.semantics_wikidata_properties[tag.key]} (${tag.key})`,
+					url,
+					_t.pnx.semantics_key_doc
+				)
+				: valToValLink(tag.key, url, _t.pnx.semantics_key_doc);
+		},
+		value_transform: (tag, _t) => valToValLink(
+			tag.value,
+			`${WikidataURL()}/${tag.value}`, _t.pnx.semantics_value_doc
+		)
+	},
+
+	exif: { title: "EXIF" },
+};
+
+
+/**
+ * Transform a prefix|key=value into parsed object.
+ * Does not handle qualifiers tags.
+ * @private
+ */
+export function decodeBasicTag(tag) {
+	const firstEqual = (tag || "").indexOf("=");
+	if(firstEqual < 0) { return null; }
+	return {
+		key: decodeKey(tag.substring(0, firstEqual)),
+		value: tag.substring(firstEqual+1),
+	};
+}
+
+
+/** @private */
+export function decodeKey(key = "") {
+	const regex = /^(?:([a-z_]+)\|)?([^[]+)(?:\[(.*)\])?$/;
+	const match = key.match(regex);
+
+	if (!match) {
+		return { prefix: "", subkey: key, qualifies: null };
+	}
+
+	const [, prefix, subkey, qualifies ] = match;
+	return {
+		prefix: prefix || "",
+		subkey,
+		qualifies: decodeBasicTag(qualifies),
+	};
+}
+
+
+/**
+ * Transforms raw API semantics properties into ready-to-display container.
+ * @param {object[]} tags The API semantics tags
+ * @returns {object[]} A list of groups (by prefix), with {title, tags} information.
+ */
+export function groupByPrefix(tags) {
+	// Create raw groups by prefix
+	const byPrefix = {};
+	const qualifiers = [];
+
+	// First pass: analyze tags, separate by prefix
+	tags.forEach(tag => {
+		const decodedKey = decodeKey(tag.key);
+
+		// Put apart qualifiers, to later insert on tags themselves
+		if(decodedKey.qualifies) {
+			qualifiers.push(Object.assign({}, tag, decodedKey));
+		}
+		// Process classic tag
+		else {
+			if (!byPrefix[decodedKey.prefix]) { byPrefix[decodedKey.prefix] = []; }
+
+			byPrefix[decodedKey.prefix].push(decodedKey.prefix.length > 0 ? {
+				key: decodedKey.subkey,
+				value: tag.value
+			} : tag);
+		}
+	});
+
+	// Second pass: add qualifiers on concerned tags
+	qualifiers.forEach(({key, prefix, subkey, qualifies, value}) => {
+		const concernedTag = byPrefix[qualifies.key.prefix]?.find(t => (
+			t.key === qualifies.key.subkey
+			&& (!qualifies.value || qualifies.value === t.value)
+		));
+
+		if(concernedTag) {
+			if(!concernedTag.qualifiers) { concernedTag.qualifiers = []; }
+			concernedTag.qualifiers.push({key, prefix, subkey, value});
+		}
+	});
+
+	// Append known prefixes information
+	let groups = Object.entries(byPrefix).map(([prefix, prefixTags]) => {
+		if(KNOWN_PREFIXES[prefix]) {
+			return Object.assign({ prefix, tags: prefixTags }, KNOWN_PREFIXES[prefix]);
+		}
+		else {
+			return { prefix, title: prefix, tags: prefixTags };
+		}
+	});
+
+	return groups;
+}

package/src/utils/services.js

@@ -4,6 +4,36 @@
  */
 
 
+/**
+ * Panoramax Presets URL
+ * @returns {string} The presets URL
+ */
+export function PanoramaxPresetsURL() {
+	return "https://presets.panoramax.fr";
+}
+
+/**
+ * Temaki icons URL
+ * @param {string} [iconName] The icon name to insert in URL
+ * @returns {string} The SVG icon URL
+ */
+export function TemakiIconURL(iconName) {
+	return `https://raw.githubusercontent.com/rapideditor/temaki/refs/heads/main/icons/${iconName}.svg`;
+}
+
+/**
+ * Wikidata URL
+ * @returns {string} The Wikidata URL
+ */
+export function WikidataURL() {
+	return "https://www.wikidata.org/wiki";
+}
+
+
+/* -----------------------------------------------------
+ * OpenStreetMap docs & tools
+ */
+
 /**
  * OpenStreetMap iD editor URL
  * @returns {string} The editor URL
@@ -12,6 +42,14 @@ export function IdEditorURL() {
 	return "https://www.openstreetmap.org/edit?editor=id";
 }
 
+/**
+ * OpenStreetMap wiki URL
+ * @returns {string} The wiki URL
+ */
+export function OSMWikiURL() {
+	return "https://wiki.openstreetmap.org/wiki";
+}
+
 
 /* -----------------------------------------------------
  * Internet speed tests
@@ -45,7 +83,7 @@ export function InternetFastTestFile() {
  * @returns {string} The Base Adresse Nationale URL (must support /search calls).
  */
 export function AdresseDataGouvBaseURL() {
-	return "https://data.geopf.fr/geocodage";
+	return "https://data.geopf.fr/geocodage/search";
 }
 
 /**