@babylonjs/core 7.19.1 → 7.20.0

package/Loading/sceneLoader.js

@@ -9,6 +9,7 @@ import { IsBase64DataUrl } from "../Misc/fileTools.js";
 import { RuntimeError, ErrorCodes } from "../Misc/error.js";
 import { RandomGUID } from "../Misc/guid.js";
 import { Engine } from "../Engines/engine.js";
+import { AbstractEngine } from "../Engines/abstractEngine.js";
 /**
  * Mode that determines how to handle old animation groups before loading new ones.
  */
@@ -31,6 +32,9 @@ export var SceneLoaderAnimationGroupLoadingMode;
      */
     SceneLoaderAnimationGroupLoadingMode[SceneLoaderAnimationGroupLoadingMode["NoSync"] = 3] = "NoSync";
 })(SceneLoaderAnimationGroupLoadingMode || (SceneLoaderAnimationGroupLoadingMode = {}));
+function isFile(value) {
+    return !!value.name;
+}
 /**
  * Class used to load scene from various file formats using registered plugins
  * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/loadingFileTypes
@@ -127,7 +131,7 @@ export class SceneLoader {
         }
         return errorMessage;
     }
-    static _LoadData(fileInfo, scene, onSuccess, onProgress, onError, onDispose, pluginExtension, name) {
+    static _LoadData(fileInfo, scene, onSuccess, onProgress, onError, onDispose, pluginExtension, name, pluginOptions) {
         const directLoad = SceneLoader._GetDirectLoad(fileInfo.url);
         if (fileInfo.rawData && !pluginExtension) {
             // eslint-disable-next-line no-throw-literal
@@ -138,14 +142,20 @@ export class SceneLoader {
             : directLoad
                 ? SceneLoader._GetPluginForDirectLoad(fileInfo.url)
                 : SceneLoader._GetPluginForFilename(fileInfo.url);
+        if (pluginOptions?.[registeredPlugin.plugin.name]?.enabled === false) {
+            throw new Error(`The '${registeredPlugin.plugin.name}' plugin is disabled via the loader options passed to the loading operation.`);
+        }
         if (fileInfo.rawData && !registeredPlugin.isBinary) {
             // eslint-disable-next-line no-throw-literal
             throw "Loading from ArrayBufferView can not be used with plugins that don't support binary loading.";
         }
-        const plugin = registeredPlugin.plugin.createPlugin?.() ?? registeredPlugin.plugin;
+        // For plugin factories, the plugin is instantiated on each SceneLoader operation. This makes options handling
+        // much simpler as we can just pass the options to the factory, rather than passing options through to every possible
+        // plugin call. Given this, options are only supported for plugins that provide a factory function.
+        const plugin = registeredPlugin.plugin.createPlugin?.(pluginOptions ?? {}) ?? registeredPlugin.plugin;
         if (!plugin) {
             // eslint-disable-next-line no-throw-literal
-            throw "The loader plugin corresponding to the file type you are trying to load has not been found. If using es6, please import the plugin you wish to use before.";
+            throw `The loader plugin corresponding to the '${pluginExtension}' file type has not been found. If using es6, please import the plugin you wish to use before.`;
         }
         SceneLoader.OnPluginActivatedObservable.notifyObservers(plugin);
         // Check if we have a direct load url. If the plugin is registered to handle
@@ -226,33 +236,32 @@ export class SceneLoader {
         }
         return plugin;
     }
-    static _GetFileInfo(rootUrl, sceneFilename) {
+    static _GetFileInfo(rootUrl, sceneSource) {
         let url;
         let name;
         let file = null;
         let rawData = null;
-        if (!sceneFilename) {
+        if (!sceneSource) {
             url = rootUrl;
             name = Tools.GetFilename(rootUrl);
             rootUrl = Tools.GetFolderPath(rootUrl);
         }
-        else if (sceneFilename.name) {
-            const sceneFile = sceneFilename;
-            url = `file:${sceneFile.name}`;
-            name = sceneFile.name;
-            file = sceneFile;
+        else if (isFile(sceneSource)) {
+            url = `file:${sceneSource.name}`;
+            name = sceneSource.name;
+            file = sceneSource;
         }
-        else if (ArrayBuffer.isView(sceneFilename)) {
+        else if (ArrayBuffer.isView(sceneSource)) {
             url = "";
             name = RandomGUID();
-            rawData = sceneFilename;
+            rawData = sceneSource;
         }
-        else if (typeof sceneFilename === "string" && sceneFilename.startsWith("data:")) {
-            url = sceneFilename;
+        else if (sceneSource.startsWith("data:")) {
+            url = sceneSource;
             name = "";
         }
-        else {
-            const filename = sceneFilename;
+        else if (rootUrl) {
+            const filename = sceneSource;
             if (filename.substr(0, 1) === "/") {
                 Tools.Error("Wrong sceneFilename parameter");
                 return null;
@@ -260,6 +269,11 @@ export class SceneLoader {
             url = rootUrl + filename;
             name = filename;
         }
+        else {
+            url = sceneSource;
+            name = Tools.GetFilename(sceneSource);
+            rootUrl = Tools.GetFolderPath(sceneSource);
+        }
         return {
             url: url,
             rootUrl: rootUrl,
@@ -320,7 +334,10 @@ export class SceneLoader {
      * @param name defines the name of the file, if the data is binary
      * @returns The loaded plugin
      */
-    static ImportMesh(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "") {
+    static ImportMesh(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
+        return SceneLoader._ImportMesh(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+    }
+    static _ImportMesh(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
         if (!scene) {
             Logger.Error("No scene available to import mesh to");
             return null;
@@ -394,22 +411,36 @@ export class SceneLoader {
                     errorHandler(error.message, error);
                 });
             }
-        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name);
+        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
     }
-    /**
-     * Import meshes into a scene
-     * @param meshNames an array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
-     * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
-     * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene or a File object (default: empty string)
-     * @param scene the instance of BABYLON.Scene to append to
-     * @param onProgress a callback with a progress event for each file being loaded
-     * @param pluginExtension the extension used to determine the plugin
-     * @param name defines the name of the file
-     * @returns The loaded list of imported meshes, particle systems, skeletons, and animation groups
-     */
-    static ImportMeshAsync(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress = null, pluginExtension = null, name = "") {
+    static ImportMeshAsync(...args) {
+        let meshNames;
+        let rootUrl;
+        let sceneFilename;
+        let scene;
+        let onProgress;
+        let pluginExtension;
+        let name;
+        let pluginOptions;
+        // This is a user-defined type guard: https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
+        // This is the most type safe way to distinguish between the two possible argument arrays.
+        const isOptionsArgs = (maybeOptionsArgs) => {
+            // If the second argument is an object, then it must be the options overload.
+            return typeof maybeOptionsArgs[1] === "object";
+        };
+        if (isOptionsArgs(args)) {
+            // Source is mapped to sceneFileName
+            sceneFilename = args[0];
+            scene = args[1];
+            // Options determine the rest of the arguments
+            ({ meshNames, rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = args[2] ?? {});
+        }
+        else {
+            // For the legacy signature, we just directly map each argument
+            [meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name] = args;
+        }
         return new Promise((resolve, reject) => {
-            SceneLoader.ImportMesh(meshNames, rootUrl, sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
+            SceneLoader._ImportMesh(meshNames, rootUrl, sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
                 resolve({
                     meshes: meshes,
                     particleSystems: particleSystems,
@@ -422,7 +453,7 @@ export class SceneLoader {
                 });
             }, onProgress, (scene, message, exception) => {
                 reject(exception || new Error(message));
-            }, pluginExtension, name);
+            }, pluginExtension, name, pluginOptions);
         });
     }
     /**
@@ -437,30 +468,47 @@ export class SceneLoader {
      * @param name defines the filename, if the data is binary
      * @returns The loaded plugin
      */
-    static Load(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "") {
+    static Load(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name) {
+        return SceneLoader._Load(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name);
+    }
+    static _Load(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
         if (!engine) {
             Tools.Error("No engine available");
             return null;
         }
-        return SceneLoader.Append(rootUrl, sceneFilename, new Scene(engine), onSuccess, onProgress, onError, pluginExtension, name);
+        return SceneLoader._Append(rootUrl, sceneFilename, new Scene(engine), onSuccess, onProgress, onError, pluginExtension, name, pluginOptions);
     }
-    /**
-     * Load a scene
-     * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
-     * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene or a File object (default: empty string)
-     * @param engine is the instance of BABYLON.Engine to use to create the scene
-     * @param onProgress a callback with a progress event for each file being loaded
-     * @param pluginExtension the extension used to determine the plugin
-     * @param name defines the filename, if the data is binary
-     * @returns The loaded scene
-     */
-    static LoadAsync(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onProgress = null, pluginExtension = null, name = "") {
+    static LoadAsync(...args) {
+        let rootUrl;
+        let sceneFilename;
+        let engine;
+        let onProgress;
+        let pluginExtension;
+        let name;
+        let pluginOptions;
+        // This is a user-defined type guard: https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
+        // This is the most type safe way to distinguish between the two possible argument arrays.
+        const isOptionsArgs = (maybeOptionsArgs) => {
+            // If the second argument is an engine, then it must be the options overload.
+            return maybeOptionsArgs[1] instanceof AbstractEngine;
+        };
+        if (isOptionsArgs(args)) {
+            // Source is mapped to sceneFileName
+            sceneFilename = args[0];
+            engine = args[1];
+            // Options determine the rest of the arguments
+            ({ rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = args[2] ?? {});
+        }
+        else {
+            // For the legacy signature, we just directly map each argument
+            [rootUrl, sceneFilename, engine, onProgress, pluginExtension, name] = args;
+        }
         return new Promise((resolve, reject) => {
-            SceneLoader.Load(rootUrl, sceneFilename, engine, (scene) => {
+            SceneLoader._Load(rootUrl, sceneFilename, engine, (scene) => {
                 resolve(scene);
             }, onProgress, (scene, message, exception) => {
                 reject(exception || new Error(message));
-            }, pluginExtension, name);
+            }, pluginExtension, name, pluginOptions);
         });
     }
     /**
@@ -475,7 +523,10 @@ export class SceneLoader {
      * @param name defines the name of the file, if the data is binary
      * @returns The loaded plugin
      */
-    static Append(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "") {
+    static Append(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
+        return SceneLoader._Append(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+    }
+    static _Append(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
         if (!scene) {
             Logger.Error("No scene available to append to");
             return null;
@@ -550,25 +601,39 @@ export class SceneLoader {
                     errorHandler(error.message, error);
                 });
             }
-        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name);
+        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
     }
-    /**
-     * Append a scene
-     * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
-     * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene or a File object (default: empty string)
-     * @param scene is the instance of BABYLON.Scene to append to
-     * @param onProgress a callback with a progress event for each file being loaded
-     * @param pluginExtension the extension used to determine the plugin
-     * @param name defines the name of the file, if the data is binary
-     * @returns The given scene
-     */
-    static AppendAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress = null, pluginExtension = null, name = "") {
+    static AppendAsync(...args) {
+        let rootUrl;
+        let sceneFilename;
+        let scene;
+        let onProgress;
+        let pluginExtension;
+        let name;
+        let pluginOptions;
+        // This is a user-defined type guard: https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
+        // This is the most type safe way to distinguish between the two possible argument arrays.
+        const isOptionsArgs = (maybeOptionsArgs) => {
+            // If the second argument is a Scene, then it must be the options overload.
+            return maybeOptionsArgs[1] instanceof Scene;
+        };
+        if (isOptionsArgs(args)) {
+            // Source is mapped to sceneFileName
+            sceneFilename = args[0];
+            scene = args[1];
+            // Options determine the rest of the arguments
+            ({ rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = args[2] ?? {});
+        }
+        else {
+            // For the legacy signature, we just directly map each argument
+            [rootUrl, sceneFilename, scene, onProgress, pluginExtension, name] = args;
+        }
         return new Promise((resolve, reject) => {
-            SceneLoader.Append(rootUrl, sceneFilename, scene, (scene) => {
+            SceneLoader._Append(rootUrl, sceneFilename, scene, (scene) => {
                 resolve(scene);
             }, onProgress, (scene, message, exception) => {
                 reject(exception || new Error(message));
-            }, pluginExtension, name);
+            }, pluginExtension, name, pluginOptions);
         });
     }
     /**
@@ -583,7 +648,10 @@ export class SceneLoader {
      * @param name defines the filename, if the data is binary
      * @returns The loaded plugin
      */
-    static LoadAssetContainer(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "") {
+    static LoadAssetContainer(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
+        return SceneLoader._LoadAssetContainer(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+    }
+    static _LoadAssetContainer(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
         if (!scene) {
             Logger.Error("No scene available to load asset container to");
             return null;
@@ -656,24 +724,41 @@ export class SceneLoader {
             else {
                 errorHandler("LoadAssetContainer is not supported by this plugin. Plugin did not provide a loadAssetContainer or loadAssetContainerAsync method.");
             }
-        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name);
+        }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
     }
-    /**
-     * Load a scene into an asset container
-     * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
-     * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene (default: empty string)
-     * @param scene is the instance of Scene to append to
-     * @param onProgress a callback with a progress event for each file being loaded
-     * @param pluginExtension the extension used to determine the plugin
-     * @returns The loaded asset container
-     */
-    static LoadAssetContainerAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress = null, pluginExtension = null) {
+    // This is the single implementation that handles both the legacy many-parameters overload and the
+    // new source + config overload. Using a parameters array union is the most type safe way to handle this.
+    static LoadAssetContainerAsync(...args) {
+        let rootUrl;
+        let sceneFilename;
+        let scene;
+        let onProgress;
+        let pluginExtension;
+        let name;
+        let pluginOptions;
+        // This is a user-defined type guard: https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
+        // This is the most type safe way to distinguish between the two possible argument arrays.
+        const isOptionsArgs = (maybeOptionsArgs) => {
+            // If the second argument is a Scene, then it must be the options overload.
+            return maybeOptionsArgs[1] instanceof Scene;
+        };
+        if (isOptionsArgs(args)) {
+            // Source is mapped to sceneFileName
+            sceneFilename = args[0];
+            scene = args[1];
+            // Options determine the rest of the arguments
+            ({ rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = args[2] ?? {});
+        }
+        else {
+            // For the legacy signature, we just directly map each argument
+            [rootUrl, sceneFilename, scene, onProgress, pluginExtension, name] = args;
+        }
         return new Promise((resolve, reject) => {
-            SceneLoader.LoadAssetContainer(rootUrl, sceneFilename, scene, (assetContainer) => {
+            SceneLoader._LoadAssetContainer(rootUrl, sceneFilename, scene, (assetContainer) => {
                 resolve(assetContainer);
             }, onProgress, (scene, message, exception) => {
                 reject(exception || new Error(message));
-            }, pluginExtension);
+            }, pluginExtension, name, pluginOptions);
         });
     }
     /**
@@ -688,8 +773,12 @@ export class SceneLoader {
      * @param onProgress a callback with a progress event for each file being loaded
      * @param onError a callback with the scene, a message, and possibly an exception when import fails
      * @param pluginExtension the extension used to determine the plugin
+     * @param name defines the filename, if the data is binary
      */
-    static ImportAnimations(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onSuccess = null, onProgress = null, onError = null, pluginExtension = null) {
+    static ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name) {
+        SceneLoader._ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name);
+    }
+    static _ImportAnimations(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
         if (!scene) {
             Logger.Error("No scene available to load animations to");
             return;
@@ -745,33 +834,42 @@ export class SceneLoader {
                 onSuccess(scene);
             }
         };
-        this.LoadAssetContainer(rootUrl, sceneFilename, scene, onAssetContainerLoaded, onProgress, onError, pluginExtension);
+        this._LoadAssetContainer(rootUrl, sceneFilename, scene, onAssetContainerLoaded, onProgress, onError, pluginExtension, name, pluginOptions);
     }
-    /**
-     * Import animations from a file into a scene
-     * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
-     * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene or a File object (default: empty string)
-     * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
-     * @param overwriteAnimations when true, animations are cleaned before importing new ones. Animations are appended otherwise
-     * @param animationGroupLoadingMode defines how to handle old animations groups before importing new ones
-     * @param targetConverter defines a function used to convert animation targets from loaded scene to current scene (default: search node by name)
-     * @param onSuccess a callback with the scene when import succeeds
-     * @param onProgress a callback with a progress event for each file being loaded
-     * @param onError a callback with the scene, a message, and possibly an exception when import fails
-     * @param pluginExtension the extension used to determine the plugin
-     * @returns the updated scene with imported animations
-     */
-    static ImportAnimationsAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onSuccess = null, onProgress = null, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onError = null, pluginExtension = null) {
+    static ImportAnimationsAsync(...args) {
+        let rootUrl;
+        let sceneFilename;
+        let scene;
+        let overwriteAnimations;
+        let animationGroupLoadingMode;
+        let targetConverter;
+        let onProgress;
+        let pluginExtension;
+        let name;
+        let pluginOptions;
+        // This is a user-defined type guard: https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
+        // This is the most type safe way to distinguish between the two possible argument arrays.
+        const isOptionsArgs = (maybeOptionsArgs) => {
+            // If the second argument is a Scene, then it must be the options overload.
+            return maybeOptionsArgs[1] instanceof Scene;
+        };
+        if (isOptionsArgs(args)) {
+            // Source is mapped to sceneFileName
+            sceneFilename = args[0];
+            scene = args[1];
+            // Options determine the rest of the arguments
+            ({ rootUrl = "", overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions } = args[2] ?? {});
+        }
+        else {
+            // For the legacy signature, we just directly map each argument
+            [rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, , onProgress, , pluginExtension, name] = args;
+        }
         return new Promise((resolve, reject) => {
-            SceneLoader.ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, (_scene) => {
+            SceneLoader._ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, (_scene) => {
                 resolve(_scene);
             }, onProgress, (_scene, message, exception) => {
                 reject(exception || new Error(message));
-            }, pluginExtension);
+            }, pluginExtension, name, pluginOptions);
         });
     }
 }