diff --git a/src/api/features/features.api.js b/src/api/features/features.api.js
index e9d929842..380bdff97 100644
--- a/src/api/features/features.api.js
+++ b/src/api/features/features.api.js
@@ -15,8 +15,7 @@ import {
 import { getApi3BaseUrl } from '@/config/baseUrl.config'
 import { DEFAULT_FEATURE_COUNT_SINGLE_POINT } from '@/config/map.config'
 import allCoordinateSystems, { LV95 } from '@/utils/coordinates/coordinateSystems'
-import { projExtent } from '@/utils/coordinates/coordinateUtils'
-import { createPixelExtentAround } from '@/utils/extentUtils'
+import { createPixelExtentAround, projExtent } from '@/utils/extentUtils'
 import { getGeoJsonFeatureCoordinates, reprojectGeoJsonData } from '@/utils/geoJsonUtils'
 import log from '@/utils/logging'
 
diff --git a/src/api/file-proxy.api.js b/src/api/file-proxy.api.js
index 3251674e3..d1ef9f0bb 100644
--- a/src/api/file-proxy.api.js
+++ b/src/api/file-proxy.api.js
@@ -1,3 +1,4 @@
+import axios from 'axios'
 import { isString } from 'lodash'
 
 import { getServiceProxyBaseUrl } from '@/config/baseUrl.config'
@@ -68,3 +69,14 @@ export function unProxifyUrl(proxifiedUrl) {
 
     return proxifiedUrl
 }
+
+/**
+ * @param {String} fileUrl
+ * @returns {Promise<ArrayBuffer>}
+ */
+export async function getContentThroughServiceProxy(fileUrl) {
+    const proxifyGetResponse = await axios.get(proxifyUrl(fileUrl), {
+        responseType: 'arraybuffer',
+    })
+    return proxifyGetResponse.data
+}
diff --git a/src/api/files.api.js b/src/api/files.api.js
index c6d01c5aa..68a37281e 100644
--- a/src/api/files.api.js
+++ b/src/api/files.api.js
@@ -340,6 +340,7 @@ export function loadKmlData(kmlLayer) {
  * proxy.
  *
  * @param {string} url URL to fetch
+ * @param {Object} [options]
  * @param {Number} [options.timeout] How long should the call wait before timing out
  * @param {string} [options.responseType] Type of data that the server will respond with. Options
  *   are 'arraybuffer', 'document', 'json', 'text', 'stream'. Default is `json`
@@ -349,10 +350,10 @@ export async function getFileFromUrl(url, options = {}) {
     const { timeout = null, responseType = null } = options
     if (/^https?:\/\/localhost/.test(url) || isInternalUrl(url)) {
         // don't go through proxy if it is on localhost or the internal server
-        return axios.get(url, { timeout, responseType })
+        return await axios.get(url, { timeout, responseType })
     } else if (url.startsWith('http://')) {
         // HTTP request goes through the proxy
-        return axios.get(proxifyUrl(url), { timeout, responseType })
+        return await axios.get(proxifyUrl(url), { timeout, responseType })
     }
 
     // For other urls we need to check if they support CORS
@@ -374,8 +375,8 @@ export async function getFileFromUrl(url, options = {}) {
 
     if (supportCORS) {
         // Server support CORS
-        return axios.get(url, { timeout, responseType })
+        return await axios.get(url, { timeout, responseType })
     }
     // server don't support CORS use proxy
-    return axios.get(proxifyUrl(url), { timeout, responseType })
+    return await axios.get(proxifyUrl(url), { timeout, responseType })
 }
diff --git a/src/api/layers/GPXLayer.class.js b/src/api/layers/GPXLayer.class.js
index f3217f01a..fc62bf4c8 100644
--- a/src/api/layers/GPXLayer.class.js
+++ b/src/api/layers/GPXLayer.class.js
@@ -15,6 +15,7 @@ export default class GPXLayer extends AbstractLayer {
      * @param {GPXMetadata | null} [gpxLayerData.gpxMetadata=null] Metadata of the GPX file. This
      *   object contains all the metadata found in the file itself within the <metadata> tag.
      *   Default is `null`
+     * @param {[Number, Number, Number, Number] | null} gpxLayerData.extent
      * @throws InvalidLayerDataError if no `gpxLayerData` is given or if it is invalid
      */
     constructor(gpxLayerData) {
@@ -27,6 +28,7 @@ export default class GPXLayer extends AbstractLayer {
             opacity = 1.0,
             gpxData = null,
             gpxMetadata = null,
+            extent = null,
         } = gpxLayerData
         if (gpxFileUrl === null) {
             throw new InvalidLayerDataError('Missing GPX file URL', gpxLayerData)
@@ -51,5 +53,6 @@ export default class GPXLayer extends AbstractLayer {
         this.gpxFileUrl = gpxFileUrl
         this.gpxData = gpxData
         this.gpxMetadata = gpxMetadata
+        this.extent = extent
     }
 }
diff --git a/src/api/layers/KMLLayer.class.js b/src/api/layers/KMLLayer.class.js
index 17281ef97..be2cadbf9 100644
--- a/src/api/layers/KMLLayer.class.js
+++ b/src/api/layers/KMLLayer.class.js
@@ -32,6 +32,7 @@ export default class KMLLayer extends AbstractLayer {
      * @param {Map<string, ArrayBuffer>} [kmlLayerData.linkFiles=Map()] Map of KML link files. Those
      *   files are usually sent with the kml inside a KMZ archive and can be referenced inside the
      *   KML (e.g. icon, image, ...). Default is `Map()`
+     * @param {[Number, Number, Number, Number] | null} kmlLayerData.extent
      * @throws InvalidLayerDataError if no `gpxLayerData` is given or if it is invalid
      */
     constructor(kmlLayerData) {
@@ -46,6 +47,7 @@ export default class KMLLayer extends AbstractLayer {
             kmlData = null,
             kmlMetadata = null,
             linkFiles = new Map(),
+            extent = null,
         } = kmlLayerData
         if (kmlFileUrl === null) {
             throw new InvalidLayerDataError('Missing KML file URL', kmlLayerData)
@@ -77,13 +79,14 @@ export default class KMLLayer extends AbstractLayer {
 
         this.kmlMetadata = kmlMetadata
         if (kmlData) {
-            this.name = parseKmlName(kmlData)
+            this.name = parseKmlName(kmlData) ?? kmlFileUrl
             this.isLoading = false
         } else {
             this.isLoading = true
         }
         this.kmlData = kmlData
         this.linkFiles = linkFiles
+        this.extent = extent
     }
 
     /**
diff --git a/src/modules/i18n/locales/de.json b/src/modules/i18n/locales/de.json
index fd180d1b8..ae2b2986a 100644
--- a/src/modules/i18n/locales/de.json
+++ b/src/modules/i18n/locales/de.json
@@ -644,6 +644,7 @@
     "transparency": "Transparenz",
     "try_test_viewer": "Probieren Sie test.map.geo.admin.ch aus",
     "twitter_tooltip": "Twittern Sie diese Karte",
+    "unknown_projection_error": "Die Datei verwendet eine ununterstützte Projektion {epsg}",
     "unsupported_content_type": "Nicht unterstützter Antwortinhaltstyp",
     "upload_failed": "Fehler beim Hochladen!",
     "upload_succeeded": "Upload OK!",
diff --git a/src/modules/i18n/locales/en.json b/src/modules/i18n/locales/en.json
index ddafa29b6..594556212 100644
--- a/src/modules/i18n/locales/en.json
+++ b/src/modules/i18n/locales/en.json
@@ -644,6 +644,7 @@
     "transparency": "Transparency",
     "try_test_viewer": "Try out test.map.geo.admin.ch",
     "twitter_tooltip": "Tweet this map",
+    "unknown_projection_error": "File is using an unsupported projection {epsg}",
     "unsupported_content_type": "Unsupported response content type",
     "upload_failed": "Upload error!",
     "upload_succeeded": "Upload OK!",
diff --git a/src/modules/i18n/locales/fr.json b/src/modules/i18n/locales/fr.json
index bebca11b5..d751324e6 100644
--- a/src/modules/i18n/locales/fr.json
+++ b/src/modules/i18n/locales/fr.json
@@ -644,6 +644,7 @@
     "transparency": "Transparence",
     "try_test_viewer": "Essayez test.map.geo.admin.ch",
     "twitter_tooltip": "Tweeter cette carte",
+    "unknown_projection_error": "Le fichier utilise une projection non prise en charge {epsg}",
     "unsupported_content_type": "Type de contenu de réponse non pris en charge",
     "upload_failed": "Erreur d'enregistrement!",
     "upload_succeeded": "Chargement OK!",
diff --git a/src/modules/i18n/locales/it.json b/src/modules/i18n/locales/it.json
index edc93aa61..5c4327bb9 100644
--- a/src/modules/i18n/locales/it.json
+++ b/src/modules/i18n/locales/it.json
@@ -644,6 +644,7 @@
     "transparency": "Trasparenza",
     "try_test_viewer": "Prova test.map.geo.admin.ch",
     "twitter_tooltip": "Tweet della carta",
+    "unknown_projection_error": "Il file utilizza una proiezione non supportata {epsg}",
     "unsupported_content_type": "Tipo di contenuto della risposta non supportato",
     "upload_failed": "Caricamento fallito!",
     "upload_succeeded": "Caricamento OK!",
diff --git a/src/modules/i18n/locales/rm.json b/src/modules/i18n/locales/rm.json
index 740146891..019a1e735 100644
--- a/src/modules/i18n/locales/rm.json
+++ b/src/modules/i18n/locales/rm.json
@@ -642,6 +642,7 @@
     "transparency": "Transparenza",
     "try_test_viewer": "Empruvai test.map.geo.admin.ch",
     "twitter_tooltip": "Tschivlottais questa charta",
+    "unknown_projection_error": "Die Datei verwendet eine ununterstützte Projektion {epsg}",
     "unsupported_content_type": "Tip da containt da resposta betg sustegnì",
     "upload_failed": "Errur da chargiar",
     "upload_succeeded": "Chargiar reussì",
diff --git a/src/modules/map/components/footer/MapFooterAttributionList.vue b/src/modules/map/components/footer/MapFooterAttributionList.vue
index 99f0a6075..ddb9ca822 100644
--- a/src/modules/map/components/footer/MapFooterAttributionList.vue
+++ b/src/modules/map/components/footer/MapFooterAttributionList.vue
@@ -6,7 +6,7 @@
                 v-if="source.hasDataDisclaimer"
                 :source-name="source.name"
                 :complete-disclaimer-on-click="!source.url"
-                :is-external-data-local="source.isExternalDataLocal"
+                :is-local-file="source.isLocalFile"
             >
                 <MapFooterAttributionItem
                     :source-id="source.id"
@@ -67,7 +67,7 @@ export default {
                                 name: attribution.name,
                                 url: attribution.url,
                                 hasDataDisclaimer: this.hasDataDisclaimer(layer.id),
-                                isExternalDataLocal: this.isLocalFile(layer),
+                                isLocalFile: this.isLocalFile(layer),
                             }
                         })
                     })
diff --git a/src/modules/map/components/openlayers/OpenLayersWMSLayer.vue b/src/modules/map/components/openlayers/OpenLayersWMSLayer.vue
index 9a73d7f79..5df03dc5f 100644
--- a/src/modules/map/components/openlayers/OpenLayersWMSLayer.vue
+++ b/src/modules/map/components/openlayers/OpenLayersWMSLayer.vue
@@ -15,8 +15,8 @@ import { getBaseUrlOverride } from '@/config/baseUrl.config'
 import { WMS_TILE_SIZE } from '@/config/map.config'
 import useAddLayerToMap from '@/modules/map/components/openlayers/utils/useAddLayerToMap.composable'
 import { LV95 } from '@/utils/coordinates/coordinateSystems'
-import { flattenExtent } from '@/utils/coordinates/coordinateUtils'
 import CustomCoordinateSystem from '@/utils/coordinates/CustomCoordinateSystem.class'
+import { flattenExtent } from '@/utils/extentUtils'
 import { getTimestampFromConfig } from '@/utils/layerUtils'
 
 const props = defineProps({
diff --git a/src/modules/map/components/openlayers/utils/useMapInteractions.composable.js b/src/modules/map/components/openlayers/utils/useMapInteractions.composable.js
index b4de6fb6a..a78662472 100644
--- a/src/modules/map/components/openlayers/utils/useMapInteractions.composable.js
+++ b/src/modules/map/components/openlayers/utils/useMapInteractions.composable.js
@@ -9,12 +9,9 @@ import LayerTypes from '@/api/layers/LayerTypes.enum'
 import { DRAWING_HIT_TOLERANCE } from '@/config/map.config'
 import { IS_TESTING_WITH_CYPRESS } from '@/config/staging.config'
 import { useDragBoxSelect } from '@/modules/map/components/openlayers/utils/useDragBoxSelect.composable'
-import { handleFileContent } from '@/modules/menu/components/advancedTools/ImportFile/utils'
+import useImportFile from '@/modules/menu/components/advancedTools/ImportFile/useImportFile.composable'
 import { ClickInfo, ClickType } from '@/store/modules/map.store'
-import { normalizeExtent, OutOfBoundsError } from '@/utils/coordinates/coordinateUtils'
-import ErrorMessage from '@/utils/ErrorMessage.class'
-import { EmptyGPXError } from '@/utils/gpxUtils'
-import { EmptyKMLError } from '@/utils/kmlUtils'
+import { normalizeExtent } from '@/utils/extentUtils'
 import log from '@/utils/logging'
 
 const dispatcher = {
@@ -27,6 +24,8 @@ const longPressEvents = [
 ]
 
 export default function useMapInteractions(map) {
+    const { handleFileSource } = useImportFile()
+
     const store = useStore()
 
     const isCurrentlyDrawing = computed(() => store.state.drawing.drawingOverlay.show)
@@ -254,47 +253,6 @@ export default function useMapInteractions(map) {
         mapElement.removeEventListener('dragleave', onDragLeave)
     }
 
-    /**
-     * @param {File} file
-     * @returns {Promise<ArrayBuffer>}
-     */
-    function readFileContent(file) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader()
-            reader.onload = (event) => resolve(event.target.result)
-            reader.onerror = (error) => reject(error)
-            // The file might be a KMZ file, which is a zip archive. Reading zip archive as text
-            // is asking for trouble therefore we use ArrayBuffer
-            reader.readAsArrayBuffer(file)
-        })
-    }
-
-    /**
-     * @param {File} file
-     * @returns {Promise<void>}
-     */
-    async function handleFile(file) {
-        try {
-            const fileContent = await readFileContent(file)
-            await handleFileContent(store, fileContent, file.name, file)
-        } catch (error) {
-            let errorKey
-            log.error(`Error loading file`, file.name, error)
-            if (error instanceof OutOfBoundsError) {
-                errorKey = 'imported_file_out_of_bounds'
-            } else if (error instanceof EmptyKMLError || error instanceof EmptyGPXError) {
-                errorKey = 'kml_gpx_file_empty'
-            } else {
-                errorKey = 'invalid_import_file_error'
-                log.error(`Failed to load file`, error)
-            }
-            store.dispatch('addErrors', {
-                errors: [new ErrorMessage(errorKey, null)],
-                ...dispatcher,
-            })
-        }
-    }
-
     function onDragOver(event) {
         event.preventDefault()
         store.dispatch('setShowDragAndDropOverlay', { showDragAndDropOverlay: true, ...dispatcher })
@@ -308,19 +266,15 @@ export default function useMapInteractions(map) {
         })
 
         if (event.dataTransfer.items) {
-            // Use DataTransferItemList interface to access the file(s)
-            for (let i = 0; i < event.dataTransfer.items.length; i++) {
+            for (/** @type {DataTransferItem} */ const item of event.dataTransfer.items) {
                 // If dropped items aren't files, reject them
-                if (event.dataTransfer.items[i].kind === 'file') {
-                    const file = event.dataTransfer.items[i].getAsFile()
-                    handleFile(file)
+                if (item.kind === 'file') {
+                    handleFileSource(item.getAsFile())
                 }
             }
         } else {
-            // Use DataTransfer interface to access the file(s)
-            for (let i = 0; i < event.dataTransfer.files.length; i++) {
-                const file = event.dataTransfer.files[i]
-                handleFile(file)
+            for (/** @type {File} */ const file of event.dataTransfer.files) {
+                handleFileSource(file)
             }
         }
     }
diff --git a/src/modules/menu/components/activeLayers/MenuActiveLayersListItem.vue b/src/modules/menu/components/activeLayers/MenuActiveLayersListItem.vue
index f844b682d..4e9cbb601 100644
--- a/src/modules/menu/components/activeLayers/MenuActiveLayersListItem.vue
+++ b/src/modules/menu/components/activeLayers/MenuActiveLayersListItem.vue
@@ -15,6 +15,7 @@ import MenuActiveLayersListItemTimeSelector from '@/modules/menu/components/acti
 import ErrorButton from '@/utils/components/ErrorButton.vue'
 import TextTruncate from '@/utils/components/TextTruncate.vue'
 import ThirdPartyDisclaimer from '@/utils/components/ThirdPartyDisclaimer.vue'
+import ZoomToExtentButton from '@/utils/components/ZoomToExtentButton.vue'
 import { useTippyTooltip } from '@/utils/composables/useTippyTooltip'
 import debounce from '@/utils/debounce'
 import log from '@/utils/logging'
@@ -165,6 +166,7 @@ function duplicateLayer() {
                 @click="onToggleLayerVisibility"
                 >{{ layer.name }}</TextTruncate
             >
+            <ZoomToExtentButton v-if="layer.extent" :extent="layer.extent" />
             <button
                 v-if="showSpinner"
                 class="loading-button btn border-0 d-flex align-items-center"
diff --git a/src/modules/menu/components/advancedTools/ImportFile/ImportFileLocalTab.vue b/src/modules/menu/components/advancedTools/ImportFile/ImportFileLocalTab.vue
index 4d9e4586a..9ca9c3e00 100644
--- a/src/modules/menu/components/advancedTools/ImportFile/ImportFileLocalTab.vue
+++ b/src/modules/menu/components/advancedTools/ImportFile/ImportFileLocalTab.vue
@@ -1,18 +1,17 @@
 <script setup>
 import { computed, ref, toRefs } from 'vue'
-import { useStore } from 'vuex'
 
 import ImportFileButtons from '@/modules/menu/components/advancedTools/ImportFile/ImportFileButtons.vue'
-import { handleFileContent } from '@/modules/menu/components/advancedTools/ImportFile/utils'
+import EmptyFileContentError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error'
+import OutOfBoundsError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error'
+import UnknownProjectionError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/UnknownProjectionError.error'
+import useImportFile from '@/modules/menu/components/advancedTools/ImportFile/useImportFile.composable'
 import FileInput from '@/utils/components/FileInput.vue'
-import { OutOfBoundsError } from '@/utils/coordinates/coordinateUtils'
-import { EmptyGPXError } from '@/utils/gpxUtils'
-import { EmptyKMLError } from '@/utils/kmlUtils'
 import log from '@/utils/logging'
 
 const acceptedFileTypes = ['.kml', '.kmz', '.gpx', '.tif', '.tiff']
 
-const store = useStore()
+const { handleFileSource } = useImportFile()
 
 const props = defineProps({
     active: {
@@ -26,6 +25,7 @@ const { active } = toRefs(props)
 const loadingFile = ref(false)
 const selectedFile = ref(null)
 const errorFileLoadingMessage = ref(null)
+const errorFileLoadingExtraParams = ref(null)
 const isFormValid = ref(false)
 const activateValidation = ref(false)
 const importSuccessMessage = ref('')
@@ -36,21 +36,21 @@ const buttonState = computed(() => (loadingFile.value ? 'loading' : 'default'))
 async function loadFile() {
     importSuccessMessage.value = ''
     errorFileLoadingMessage.value = ''
+    errorFileLoadingExtraParams.value = null
     activateValidation.value = true
     loadingFile.value = true
 
     if (isFormValid.value && selectedFile.value) {
         try {
-            // The file might be a KMZ which is a zip archive. Handling zip archive as text is
-            // asking for trouble, therefore we need first to get it as binary
-            const content = await selectedFile.value.arrayBuffer()
-            await handleFileContent(store, content, selectedFile.value.name)
-            importSuccessMessage.value = 'file_imported_success'
+            await handleFileSource(selectedFile.value, false)
         } catch (error) {
             if (error instanceof OutOfBoundsError) {
                 errorFileLoadingMessage.value = 'imported_file_out_of_bounds'
-            } else if (error instanceof EmptyKMLError || error instanceof EmptyGPXError) {
+            } else if (error instanceof EmptyFileContentError) {
                 errorFileLoadingMessage.value = 'kml_gpx_file_empty'
+            } else if (error instanceof UnknownProjectionError) {
+                errorFileLoadingMessage.value = 'unknown_projection_error'
+                errorFileLoadingExtraParams.value = { epsg: error.epsg }
             } else {
                 errorFileLoadingMessage.value = 'invalid_import_file_error'
                 log.error(`Failed to load file`, error)
@@ -86,6 +86,7 @@ function validateForm(valid) {
             :activate-validation="activateValidation"
             :invalid-marker="!!errorFileLoadingMessage"
             :invalid-message="errorFileLoadingMessage"
+            :invalid-message-extra-params="errorFileLoadingExtraParams"
             :valid-message="importSuccessMessage"
             @validate="validateForm"
         />
diff --git a/src/modules/menu/components/advancedTools/ImportFile/ImportFileOnlineTab.vue b/src/modules/menu/components/advancedTools/ImportFile/ImportFileOnlineTab.vue
index 5fcc82b13..7bb529e53 100644
--- a/src/modules/menu/components/advancedTools/ImportFile/ImportFileOnlineTab.vue
+++ b/src/modules/menu/components/advancedTools/ImportFile/ImportFileOnlineTab.vue
@@ -1,22 +1,14 @@
 <script setup>
-import { AxiosError } from 'axios'
 import { computed, onMounted, ref, toRefs, watch } from 'vue'
-import { useStore } from 'vuex'
 
-import { getFileFromUrl } from '@/api/files.api'
 import ImportFileButtons from '@/modules/menu/components/advancedTools/ImportFile/ImportFileButtons.vue'
-import { handleFileContent } from '@/modules/menu/components/advancedTools/ImportFile/utils'
+import EmptyFileContentError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error'
+import OutOfBoundsError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error'
+import useImportFile from '@/modules/menu/components/advancedTools/ImportFile/useImportFile.composable'
 import TextInput from '@/utils/components/TextInput.vue'
-import { OutOfBoundsError } from '@/utils/coordinates/coordinateUtils'
-import { EmptyGPXError } from '@/utils/gpxUtils'
-import { EmptyKMLError } from '@/utils/kmlUtils'
 import log from '@/utils/logging'
 import { isValidUrl } from '@/utils/utils'
 
-const REQUEST_TIMEOUT = 5 * 60 * 1000 // milliseconds
-
-const store = useStore()
-
 const props = defineProps({
     active: {
         type: Boolean,
@@ -25,6 +17,8 @@ const props = defineProps({
 })
 const { active } = toRefs(props)
 
+const { handleFileSource } = useImportFile()
+
 // Reactive data
 const loading = ref(false)
 const fileUrlInput = ref(null)
@@ -81,24 +75,12 @@ async function loadFile() {
     loading.value = true
 
     try {
-        const response = await getFileFromUrl(fileUrl.value, {
-            timeout: REQUEST_TIMEOUT,
-            responseType: 'arraybuffer',
-        })
-        if (response.status !== 200) {
-            throw new Error(`Failed to fetch ${fileUrl.value}; status_code=${response.status}`)
-        }
-        await handleFileContent(store, response.data, fileUrl.value)
-        importSuccessMessage.value = 'file_imported_success'
-        setTimeout(() => (buttonState.value = 'default'), 3000)
+        await handleFileSource(fileUrl.value, false)
     } catch (error) {
         buttonState.value = 'default'
-        if (error instanceof AxiosError || /fetch/.test(error.message)) {
-            log.error(`Failed to load file from url ${fileUrl.value}`, error)
-            errorFileLoadingMessage.value = 'loading_error_network_failure'
-        } else if (error instanceof OutOfBoundsError) {
+        if (error instanceof OutOfBoundsError) {
             errorFileLoadingMessage.value = 'imported_file_out_of_bounds'
-        } else if (error instanceof EmptyKMLError || error instanceof EmptyGPXError) {
+        } else if (error instanceof EmptyFileContentError) {
             errorFileLoadingMessage.value = 'kml_gpx_file_empty'
         } else {
             log.error(`Failed to parse file from url ${fileUrl.value}`, error)
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class.js b/src/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class.js
new file mode 100644
index 000000000..c0f22ece7
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class.js
@@ -0,0 +1,240 @@
+import axios from 'axios'
+
+import { getContentThroughServiceProxy } from '@/api/file-proxy.api'
+import log from '@/utils/logging'
+
+/**
+ * @function
+ * @typedef ValidateProxifyContent
+ *
+ *   Function receiving the content from service-proxy, and assessing if it is a match for this parser
+ * @param {ArrayBuffer} content
+ * @returns {Boolean} Content is a match for this parser, or not
+ */
+
+/**
+ * @typedef ServiceProxyConfiguration
+ * @property {ValidateProxifyContent} validateContent
+ */
+
+/**
+ * Base class to build a file parser upon. Each file parser detects if it can handle the file
+ * through a list of file extensions or little endian signature.
+ *
+ * @abstract
+ */
+export default class FileParser {
+    /**
+     * @param {String} config.displayedName Name used to describe this file type to the end user
+     * @param {Number[]} config.fileTypeLittleEndianSignature Little endian signature (aka magic
+     *   numbers), if any, for this file type. Will be used to check the first 4 bytes of the file.
+     * @param {String[]} config.fileExtensions Which file extensions this file type is carried with
+     *   (case-insensitive)
+     * @param {String[]} config.fileContentTypes Which MIME types are typically associated with this
+     *   file type. Will be used with one HTTP HEAD request on the file URL (if online file) to
+     *   assert if this parser is the valid candidate for the file.
+     * @param {ServiceProxyConfiguration} [config.serviceProxyConfiguration=null] If set,
+     *   service-proxy will be used to get the file content if first request on the URL failed.
+     *   Content of the proxifyed request will be checked against the ValidateProxifyContent before
+     *   going through the parsing. Default is `null`
+     */
+    constructor(config = {}) {
+        const {
+            fileTypeLittleEndianSignature = [],
+            fileExtensions = [],
+            fileContentTypes = [],
+            serviceProxyConfiguration = null,
+        } = config
+        this.fileTypeLittleEndianSignature = fileTypeLittleEndianSignature
+        this.fileExtensions = fileExtensions
+        this.fileContentTypes = fileContentTypes
+        this.serviceProxyConfiguration = serviceProxyConfiguration
+    }
+
+    /**
+     * @param {File | String} fileSource
+     * @returns {boolean}
+     */
+    isLocalFile(fileSource) {
+        return fileSource instanceof File
+    }
+
+    /**
+     * Will detect, through the file's content (its little endian signature) or the file name (file
+     * extension) if this parser could be a valid match for this file.
+     *
+     * @param {File} fileSource
+     * @returns {Promise<Boolean>}
+     */
+    async isLocalFileParsingPossible(fileSource) {
+        const fileArrayBuffer = await fileSource.arrayBuffer()
+        // if a little endian signature was found, and we know one to match against, we prioritize this way of
+        // detecting if this file is a valid candidate
+        if (fileArrayBuffer.byteLength >= 4 && this.fileTypeLittleEndianSignature.length === 4) {
+            const littleEndianSignature = new Uint8Array(fileArrayBuffer.slice(0, 4))
+            return this.fileTypeLittleEndianSignature.every(
+                (byte, index) => byte === littleEndianSignature[index]
+            )
+        }
+        // if no known little endian signature for this file type we fall back to check the file extension
+        return (
+            this.fileExtensions.length > 0 &&
+            this.fileExtensions.some(
+                (extension) => fileSource.name.toLowerCase().indexOf(extension.toLowerCase()) !== -1
+            )
+        )
+    }
+
+    /**
+     * @abstract
+     * @param {File} file
+     * @param {CoordinateSystem} currentProjection Can be used to check bounds of parsed file
+     *   against the current projection (and raise OutOfBoundError in case no mutual data is
+     *   available)
+     * @returns {Promise<AbstractLayer>}
+     */
+    async parseLocalFile(file, currentProjection) {
+        throw new Error(`Parser not yet implemented ${file} ${currentProjection}`)
+    }
+
+    /**
+     * @param {String} fileUrl
+     * @returns {Promise<ArrayBuffer>}
+     */
+    async getContentThroughServiceProxy(fileUrl) {
+        if (!this.serviceProxyConfiguration) {
+            throw new Error('No service-proxy configuration for this parser')
+        }
+        // service proxy will stream the response, so we will only receive Content-Type application/binary
+        // we need to check the content of what is returned
+        return await getContentThroughServiceProxy(fileUrl)
+    }
+
+    /**
+     * @param {ArrayBuffer} fileArrayBuffer
+     * @returns {Boolean}
+     */
+    validateContentThroughServiceProxy(fileArrayBuffer) {
+        if (!this.serviceProxyConfiguration) {
+            return false
+        }
+        // service proxy will stream the response, so we will only receive Content-Type application/binary
+        // we need to check the content of what is returned
+        return this.serviceProxyConfiguration.validateContent(fileArrayBuffer)
+    }
+
+    /**
+     * Will detect through a HEAD request if Content-type (or file extension) are a match and this
+     * parser could try parsing this URL.
+     *
+     * @param {String} fileUrl
+     * @param {Object} options
+     * @param {Boolean} [options.allowServiceProxy] Flag telling if the resource could be accessed
+     *   with the use of service-proxy if another means do not work (MIME type parsing or little
+     *   endian signature detection)
+     * @param {String} [options.mimeType] MIME type (from a Content-Type HTTP header) gathered from
+     *   a previous HEAD request (so no need to re-run a HEAD request to get this info)
+     * @param {ArrayBuffer} [options.loadedContent] File content already loaded (most likely by
+     *   service-proxy). When given, no other request will be made on the file source, but this
+     *   content will be used instead.
+     * @returns {Promise<Boolean>}
+     */
+    async isOnlineFileParsingPossible(fileUrl, options = {}) {
+        const { allowServiceProxy = false, mimeType = null, loadedContent = null } = options
+
+        if (mimeType) {
+            return this.fileContentTypes.includes(mimeType)
+        }
+
+        if (loadedContent) {
+            return this.validateContentThroughServiceProxy(loadedContent)
+        }
+
+        log.debug(
+            `[FileParser][${this.constructor.name}] no pre-loaded content to verify, launching HEAD request on file URL`,
+            fileUrl,
+            this.constructor.name
+        )
+        // HEAD request wasn't run yet (we are not coming from the main parseLayerFromFile function)
+        // so we have to run all the requests ourselves
+        try {
+            const headResponse = await axios.head(fileUrl)
+            return this.fileContentTypes.includes(headResponse.headers.get('content-type'))
+        } catch (error) {
+            if (allowServiceProxy) {
+                log.debug(
+                    `[FileParser][${this.constructor.name}] could not access resource through HEAD request, trying through service-proxy`,
+                    fileUrl
+                )
+                return this.validateContentThroughServiceProxy(
+                    await getContentThroughServiceProxy(fileUrl)
+                )
+            } else {
+                log.debug(
+                    `[FileParser][${this.constructor.name}] HEAD request failed, but service-proxy is not allowed for file, could not parse`,
+                    fileUrl,
+                    this.constructor.name
+                )
+            }
+        }
+        return false
+    }
+
+    /**
+     * @abstract
+     * @param {String} fileUrl
+     * @param {CoordinateSystem} currentProjection Can be used to check bounds of parsed file
+     *   against the current projection (and raise OutOfBoundError in case no mutual data is
+     *   available)
+     * @param {Object} options
+     * @param {Number} [options.timeout] The timeout length (in milliseconds) to use when requesting
+     *   online file
+     * @returns {Promise<AbstractLayer>}
+     */
+    async parseUrl(fileUrl, currentProjection, options = {}) {
+        throw new Error(`Parser not yet implemented ${fileUrl} ${currentProjection} ${options}`)
+    }
+
+    /**
+     * @param {Object} config
+     * @param {String | File} config.fileSource
+     * @param {CoordinateSystem} config.currentProjection Can be used to check bounds of parsed file
+     *   against the current projection (and raise OutOfBoundError in case no mutual data is
+     *   available)
+     * @param {Object} [options]
+     * @param {Number} [options.timeout] The timeout length (in milliseconds) to use when requesting
+     *   online file
+     * @param {Boolean} [options.allowServiceProxy=false] Flag telling if the resource could be
+     *   accessed with the use of service-proxy if another means do not work (MIME type parsing or
+     *   little endian signature detection). Default is `false`
+     * @param {String} [options.mimeType] MIME type (from a Content-Type HTTP header) gathered from
+     *   a previous HEAD request (so no need to re-run a HEAD request to get this info)
+     * @param {ArrayBuffer} [options.loadedContent] File content already loaded (most likely by
+     *   service-proxy). When given, no other request will be made on the file source, but this
+     *   content will be used instead.
+     * @returns {Promise<AbstractLayer>} A promise to layer config derived from the file's
+     *   metadata/content, ready to be added to the map. Or a rejected promise if the file wasn't
+     *   compatible.
+     * @throws OutOfBoundsError if the imported file is out of bound of the current projection
+     * @throws EmptyFileContentError if missing data (or no data) while reading the file
+     */
+    async parse(config = {}, options = {}) {
+        const { fileSource, currentProjection } = config
+        if (!fileSource || !currentProjection) {
+            log.error(
+                `[FileParser][${this.constructor.name}] Could not attempt parsing of the file, wrong configuration received`,
+                config
+            )
+            throw new Error('Invalid parsing configuration')
+        }
+        if (this.isLocalFile(fileSource)) {
+            if (await this.isLocalFileParsingPossible(fileSource)) {
+                return this.parseLocalFile(fileSource, currentProjection)
+            }
+        } else if (await this.isOnlineFileParsingPossible(fileSource, options)) {
+            return this.parseUrl(fileSource, currentProjection, options)
+        }
+        // rejecting parsing
+        throw false
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/GPXParser.class.js b/src/modules/menu/components/advancedTools/ImportFile/parser/GPXParser.class.js
new file mode 100644
index 000000000..8ec509f78
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/GPXParser.class.js
@@ -0,0 +1,70 @@
+import GPX from 'ol/format/GPX'
+
+import { getFileFromUrl } from '@/api/files.api'
+import GPXLayer from '@/api/layers/GPXLayer.class'
+import EmptyFileContentError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error'
+import OutOfBoundsError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error'
+import FileParser from '@/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class'
+import { WGS84 } from '@/utils/coordinates/coordinateSystems'
+import { getExtentIntersectionWithCurrentProjection } from '@/utils/extentUtils'
+import { getGpxExtent } from '@/utils/gpxUtils'
+
+/**
+ * Checks if file is GPX
+ *
+ * @param {ArrayBuffer} fileContent
+ * @returns {boolean}
+ */
+export function isGpx(fileContent) {
+    const fileContentAsText = new TextDecoder('utf-8').decode(fileContent)
+    return /<gpx/.test(fileContentAsText) && /<\/gpx\s*>/.test(fileContentAsText)
+}
+
+const gpxMetadataParser = new GPX()
+
+export default class GPXParser extends FileParser {
+    constructor() {
+        super({
+            fileExtensions: ['.gpx'],
+            serviceProxyConfiguration: {
+                validateContent: isGpx,
+            },
+        })
+    }
+
+    parseGpxLayer(fileContent, fileSource, currentProjection) {
+        const extent = getGpxExtent(fileContent)
+        if (!extent) {
+            throw new EmptyFileContentError()
+        }
+        const extentInCurrentProjection = getExtentIntersectionWithCurrentProjection(
+            extent,
+            WGS84,
+            currentProjection
+        )
+        if (!extentInCurrentProjection) {
+            throw new OutOfBoundsError(`GPX is out of bounds of current projection: ${extent}`)
+        }
+        return new GPXLayer({
+            gpxFileUrl: fileSource,
+            visible: true,
+            opacity: 1.0,
+            gpxData: fileContent,
+            gpxMetadata: gpxMetadataParser.readMetadata(fileContent),
+            extent: extentInCurrentProjection,
+        })
+    }
+
+    async parseLocalFile(file, currentProjection) {
+        return this.parseGpxLayer(
+            new TextDecoder('utf-8').decode(await file.arrayBuffer()),
+            file.name,
+            currentProjection
+        )
+    }
+
+    async parseUrl(fileUrl, currentProjection, options) {
+        const fileContent = await getFileFromUrl(fileUrl, options)
+        return this.parseGpxLayer(fileContent.data, fileUrl, currentProjection)
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class.js b/src/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class.js
new file mode 100644
index 000000000..9bf3df8d3
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class.js
@@ -0,0 +1,85 @@
+import { getFileFromUrl } from '@/api/files.api'
+import KMLLayer from '@/api/layers/KMLLayer.class'
+import EmptyFileContentError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error'
+import OutOfBoundsError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error'
+import FileParser from '@/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class'
+import { WGS84 } from '@/utils/coordinates/coordinateSystems'
+import { getExtentIntersectionWithCurrentProjection } from '@/utils/extentUtils'
+import { getKmlExtent } from '@/utils/kmlUtils'
+
+/**
+ * Checks if file is KMLs
+ *
+ * @param {ArrayBuffer | String} fileContent
+ * @returns {boolean}
+ */
+export function isKml(fileContent) {
+    let stringValue = fileContent
+    if (fileContent instanceof ArrayBuffer) {
+        stringValue = new TextDecoder('utf-8').decode(fileContent)
+    }
+    return /^\s*(<\?xml\b[^>]*\?>)?\s*(<!--(.*?)-->\s*)*<(kml:)?kml\b[^>]*>[\s\S.]*<\/(kml:)?kml\s*>/g.test(
+        stringValue
+    )
+}
+
+export class KMLParser extends FileParser {
+    constructor() {
+        super({
+            fileExtensions: ['.kml'],
+            serviceProxyConfiguration: {
+                validateContent: isKml,
+            },
+        })
+    }
+
+    /**
+     * @param {String} fileContent
+     * @param fileSource
+     * @param currentProjection
+     * @param {Map<string, ArrayBuffer>} [linkFiles] Used in the context of a KMZ to carry the
+     *   embedded files with the layer
+     * @returns {KMLLayer}
+     */
+    parseKmlLayer(fileContent, fileSource, currentProjection, linkFiles = null) {
+        if (isKml(fileContent)) {
+            const extent = getKmlExtent(fileContent)
+            if (!extent) {
+                throw new EmptyFileContentError()
+            }
+            const extentInCurrentProjection = getExtentIntersectionWithCurrentProjection(
+                extent,
+                WGS84,
+                currentProjection
+            )
+            if (!extentInCurrentProjection) {
+                throw new OutOfBoundsError(`KML is out of bounds of current projection: ${extent}`)
+            }
+            return new KMLLayer({
+                kmlFileUrl: fileSource,
+                visible: true,
+                opacity: 1.0,
+                adminId: null,
+                kmlData: fileContent,
+                extent: extentInCurrentProjection,
+                extentProjection: currentProjection,
+                linkFiles,
+            })
+        }
+
+        throw new Error('No KML data found in this file')
+    }
+
+    async parseLocalFile(file, currentProjection) {
+        return this.parseKmlLayer(
+            new TextDecoder('utf-8').decode(await file.arrayBuffer()),
+            file.name,
+            currentProjection
+        )
+    }
+
+    async parseUrl(fileUrl, currentProjection, options) {
+        const fileContent = await getFileFromUrl(fileUrl, options)
+        return this.parseKmlLayer(fileContent.data, fileUrl, currentProjection)
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/KMZParser.class.js b/src/modules/menu/components/advancedTools/ImportFile/parser/KMZParser.class.js
new file mode 100644
index 000000000..3778a41fe
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/KMZParser.class.js
@@ -0,0 +1,61 @@
+import { getFileFromUrl } from '@/api/files.api'
+import FileParser from '@/modules/menu/components/advancedTools/ImportFile/parser/FileParser.class'
+import { KMLParser } from '@/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class'
+import { unzipKmz } from '@/utils/kmlUtils'
+
+/**
+ * Check if the input is a zipfile content or not
+ *
+ * @param {ArrayBuffer} content
+ * @returns {boolean} Return true if the content is a zipfile content
+ */
+export function isZipContent(content) {
+    // Check the first 4 bytes for the ZIP file signature
+    const zipSignature = [0x50, 0x4b, 0x03, 0x04]
+    const view = new Uint8Array(content.slice(0, 4))
+    for (let i = 0; i < zipSignature.length; i++) {
+        if (view[i] !== zipSignature[i]) {
+            return false
+        }
+    }
+    return true
+}
+
+const kmlParser = new KMLParser()
+
+export default class KMZParser extends FileParser {
+    constructor() {
+        super({
+            fileExtensions: ['.kmz'],
+            // ZIP file signature
+            fileTypeLittleEndianSignature: [0x50, 0x4b, 0x03, 0x04],
+            serviceProxyConfiguration: {
+                validateContent: isZipContent,
+            },
+        })
+    }
+
+    /**
+     * @param {String | ArrayBuffer} data
+     * @param {String} fileSource
+     * @param {CoordinateSystem} currentProjection
+     * @returns {Promise<KMLLayer>}
+     */
+    async parseKmzLayer(data, fileSource, currentProjection) {
+        const kmz = await unzipKmz(data, fileSource)
+        return kmlParser.parseKmlLayer(kmz.kml, kmz.name, currentProjection, kmz.files)
+    }
+
+    async parseLocalFile(file, currentProjection) {
+        return await this.parseKmzLayer(await file.arrayBuffer(), file.name, currentProjection)
+    }
+
+    async parseUrl(fileUrl, currentProjection, options) {
+        const fileContent = await getFileFromUrl(fileUrl, {
+            ...options,
+            // Reading zip archive as text is asking for trouble therefore we use ArrayBuffer
+            responseType: 'arraybuffer',
+        })
+        return await this.parseKmzLayer(fileContent.data, fileUrl, currentProjection)
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/__tests__/utils.spec.js b/src/modules/menu/components/advancedTools/ImportFile/parser/__tests__/KMLParser.class.spec.js
similarity index 80%
rename from src/modules/menu/components/advancedTools/ImportFile/__tests__/utils.spec.js
rename to src/modules/menu/components/advancedTools/ImportFile/parser/__tests__/KMLParser.class.spec.js
index 20e50c2d0..a72db61d2 100644
--- a/src/modules/menu/components/advancedTools/ImportFile/__tests__/utils.spec.js
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/__tests__/KMLParser.class.spec.js
@@ -1,22 +1,25 @@
 import { expect } from 'chai'
 import { describe, it } from 'vitest'
 
-import { isKml } from '@/modules/menu/components/advancedTools/ImportFile/utils'
+import { isKml } from '@/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class'
 
-describe('Test ImportFile utils', () => {
+describe('Test KMLParser utils', () => {
     it('Detect KML file syntax', () => {
         expect(isKml('<kml>test</kml>')).to.be.true
         expect(isKml('<kml:kml>test</kml:kml>')).to.be.true
         expect(isKml(' <?xml version="1.0" encoding="UTF-8"?><kml:kml>test</kml:kml>')).to.be.true
         expect(
-            isKml(`<?xml version="1.0" encoding="UTF-8"?>
+            isKml(
+                `<?xml version="1.0" encoding="UTF-8"?>
         <kml:kml>
             test
         </kml:kml>
-        `)
+        `
+            )
         ).to.be.true
         expect(
-            isKml(`
+            isKml(
+                `
 <kml>
     <Placemark>
         <name>test</name>
@@ -25,7 +28,8 @@ describe('Test ImportFile utils', () => {
             <coordinates>7.438632503,46.951082887,598.947</coordinates>
         </Point>
     </Placemark>
-</kml>`)
+</kml>`
+            )
         ).to.be.true
     })
     it("Don't detect invalid KML file syntax", () => {
@@ -33,7 +37,8 @@ describe('Test ImportFile utils', () => {
         expect(isKml('<akml>test</akml>')).to.be.false
         expect(isKml('<?xml version="1.0" encoding="UTF-8"?><div>test</div>')).to.be.false
         expect(
-            isKml(`<div><![CDATA[
+            isKml(
+                `<div><![CDATA[
 <kml>
     <Placemark>
         <name>test</name>
@@ -43,7 +48,8 @@ describe('Test ImportFile utils', () => {
         </Point>
     </Placemark>
 </kml>
-]]></div>`)
+]]></div>`
+            )
         ).to.be.false
     })
 })
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error.js b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error.js
new file mode 100644
index 000000000..89e7e97b9
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error.js
@@ -0,0 +1 @@
+export default class EmptyFileContentError extends Error {}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error.js b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error.js
new file mode 100644
index 000000000..95cd787b4
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error.js
@@ -0,0 +1,7 @@
+/** Coordinates or extent out of bounds error */
+export default class OutOfBoundsError extends Error {
+    constructor(message) {
+        super(message)
+        this.name = 'OutOfBoundsError'
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/errors/UnknownProjectionError.error.js b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/UnknownProjectionError.error.js
new file mode 100644
index 000000000..279e0d129
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/errors/UnknownProjectionError.error.js
@@ -0,0 +1,6 @@
+export default class UnknownProjectionError extends Error {
+    constructor(message, epsg) {
+        super(message)
+        this.epsg = epsg
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/parser/index.js b/src/modules/menu/components/advancedTools/ImportFile/parser/index.js
new file mode 100644
index 000000000..4488ef415
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/parser/index.js
@@ -0,0 +1,108 @@
+import axios from 'axios'
+
+import { getContentThroughServiceProxy } from '@/api/file-proxy.api.js'
+import AbstractLayer from '@/api/layers/AbstractLayer.class'
+import GPXParser from '@/modules/menu/components/advancedTools/ImportFile/parser/GPXParser.class'
+import { KMLParser } from '@/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class'
+import KMZParser from '@/modules/menu/components/advancedTools/ImportFile/parser/KMZParser.class'
+import log from '@/utils/logging.js'
+
+const allParsers = [new KMZParser(), new KMLParser(), new GPXParser()]
+
+/**
+ * @param {Object} config
+ * @param {File | String} config.fileSource
+ * @param {CoordinateSystem} config.currentProjection
+ * @param {Object} [options]
+ * @param {Boolean} [options.allowServiceProxy=false] Default is `false`
+ * @param {String} [options.mimeType]
+ * @param {ArrayBuffer} [options.loadedContent]
+ * @returns {Promise<AbstractLayer>}
+ */
+async function parseAll(config, options) {
+    const allSettled = await Promise.allSettled(
+        allParsers.map((parser) => parser.parse(config, options))
+    )
+    const firstFulfilled = allSettled.find(
+        (response) => response.status === 'fulfilled' && response.value instanceof AbstractLayer
+    )
+    if (firstFulfilled) {
+        return firstFulfilled.value
+    }
+    const anyErrorRaised = allSettled.find(
+        (response) => response.status === 'rejected' && response.reason
+    )
+    if (anyErrorRaised) {
+        throw anyErrorRaised.reason
+    }
+    throw new Error('Could not parse file')
+}
+
+/**
+ * @param {File | String} fileSource
+ * @param {CoordinateSystem} currentProjection Can be used to check bounds of parsed file against
+ *   the current projection (and raise OutOfBoundError in case no mutual data is available)
+ * @param {Object} [options]
+ * @param {Number} [options.timeout] The timeout length (in milliseconds) to use when requesting
+ *   online file
+ * @returns {Promise<AbstractLayer>}
+ */
+export async function parseLayerFromFile(fileSource, currentProjection, options = {}) {
+    const isLocalFile = fileSource instanceof File
+    let mimeType = null
+    if (!isLocalFile) {
+        // running a HEAD request on the resource to only gather this info once for all file parsers
+        try {
+            const headResponse = await axios.head(fileSource)
+            mimeType = headResponse.headers.get('content-type')
+            log.debug('[FileParsing] got MIME type', mimeType, 'for file', fileSource)
+        } catch (err) {
+            log.debug(
+                '[File parsing] could not have a HEAD response on',
+                fileSource,
+                'this file might require service-proxy'
+            )
+        }
+    }
+    // if we could read the MIME type of the file, we parse the file disabling any service-proxy request
+    if (mimeType) {
+        try {
+            return await parseAll(
+                {
+                    fileSource,
+                    currentProjection,
+                },
+                {
+                    ...options,
+                    mimeType,
+                    allowServiceProxy: false,
+                }
+            )
+        } catch (error) {
+            log.debug(
+                'Could not parse file through mime type detection, attempting a content parsing through service-proxy',
+                error
+            )
+        }
+    }
+    // if MIME type detection was unsuccessful, we attempt another pass of parsing, this using service-proxy to ge the file's content
+    if (!isLocalFile) {
+        log.debug('[FileParser] MIME type detection failed, going through service-proxy')
+        return await parseAll(
+            {
+                fileSource,
+                currentProjection,
+            },
+            {
+                ...options,
+                // only firing service-proxy request once here, the same response will be used by all parsers
+                loadedContent: await getContentThroughServiceProxy(fileSource),
+                allowServiceProxy: false,
+            }
+        )
+    }
+    return await parseAll({
+        fileSource,
+        currentProjection,
+    })
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/useImportFile.composable.js b/src/modules/menu/components/advancedTools/ImportFile/useImportFile.composable.js
new file mode 100644
index 000000000..45ce3289e
--- /dev/null
+++ b/src/modules/menu/components/advancedTools/ImportFile/useImportFile.composable.js
@@ -0,0 +1,76 @@
+import { computed } from 'vue'
+import { useStore } from 'vuex'
+
+import { parseLayerFromFile } from '@/modules/menu/components/advancedTools/ImportFile/parser'
+import EmptyFileContentError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/EmptyFileContentError.error'
+import OutOfBoundsError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/OutOfBoundsError.error'
+import UnknownProjectionError from '@/modules/menu/components/advancedTools/ImportFile/parser/errors/UnknownProjectionError.error'
+import ErrorMessage from '@/utils/ErrorMessage.class'
+import log from '@/utils/logging'
+
+const dispatcher = {
+    dispatcher: 'useImportFile.composable',
+}
+
+/** Standardized way of dealing with the import of external files (local or through URL) in our app. */
+export default function useImportFile() {
+    const store = useStore()
+    const projection = computed(() => store.state.position.projection)
+
+    /**
+     * @param {File | String} source
+     * @param {Boolean} [sendErrorToStore=true] If true, will dispatch any error to the store, if
+     *   false will throw any error at you. Default is `true`
+     * @returns {Promise<void>}
+     */
+    async function handleFileSource(source, sendErrorToStore = true) {
+        if (!source) {
+            return
+        }
+        await store.dispatch('setLoadingBarRequester', {
+            requester: source.name ?? source,
+            ...dispatcher,
+        })
+        try {
+            const layer = await parseLayerFromFile(source, projection.value)
+            await store.dispatch('addLayer', {
+                layer,
+                zoomToLayerExtent: true,
+                ...dispatcher,
+            })
+        } catch (error) {
+            if (!sendErrorToStore) {
+                throw error
+            }
+            let errorKey
+            let errorParams
+            log.error(`Error loading file`, source.name ?? source, error)
+            if (error instanceof OutOfBoundsError) {
+                errorKey = 'imported_file_out_of_bounds'
+            } else if (error instanceof EmptyFileContentError) {
+                errorKey = 'kml_gpx_file_empty'
+            } else if (error instanceof UnknownProjectionError) {
+                errorKey = 'unknown_projection_error'
+                errorParams = {
+                    epsg: error.epsg,
+                }
+            } else {
+                errorKey = 'invalid_import_file_error'
+                log.error(`Failed to load file`, error)
+            }
+            await store.dispatch('addErrors', {
+                errors: [new ErrorMessage(errorKey, errorParams)],
+                ...dispatcher,
+            })
+        } finally {
+            await store.dispatch('clearLoadingBarRequester', {
+                requester: source.name ?? source,
+                ...dispatcher,
+            })
+        }
+    }
+
+    return {
+        handleFileSource,
+    }
+}
diff --git a/src/modules/menu/components/advancedTools/ImportFile/utils.js b/src/modules/menu/components/advancedTools/ImportFile/utils.js
deleted file mode 100644
index 5af61e6f0..000000000
--- a/src/modules/menu/components/advancedTools/ImportFile/utils.js
+++ /dev/null
@@ -1,143 +0,0 @@
-import { fromArrayBuffer } from 'geotiff'
-import GPX from 'ol/format/GPX'
-
-import GeoTIFFLayer from '@/api/layers/GeoTIFFLayer.class'
-import GPXLayer from '@/api/layers/GPXLayer.class'
-import KMLLayer from '@/api/layers/KMLLayer.class'
-import { normalizeExtent, OutOfBoundsError } from '@/utils/coordinates/coordinateUtils'
-import { getExtentForProjection } from '@/utils/extentUtils'
-import { EmptyGPXError, getGpxExtent } from '@/utils/gpxUtils'
-import { EmptyKMLError, getKmlExtent, unzipKmz } from '@/utils/kmlUtils'
-import log from '@/utils/logging'
-import { isTiffContent, isZipContent } from '@/utils/utils'
-
-const dispatcher = { dispatcher: 'ImportFile/utils' }
-
-/**
- * Checks if file is KML
- *
- * @param {string} fileContent
- * @returns {boolean}
- */
-export function isKml(fileContent) {
-    return /^\s*(<\?xml\b[^>]*\?>)?\s*(<!--(.*?)-->\s*)*<(kml:)?kml\b[^>]*>[\s\S.]*<\/(kml:)?kml\s*>/g.test(
-        fileContent
-    )
-}
-
-/**
- * Checks if file is GPX
- *
- * @param {string} fileContent
- * @returns {boolean}
- */
-export function isGpx(fileContent) {
-    return /<gpx/.test(fileContent) && /<\/gpx\s*>/.test(fileContent)
-}
-
-/**
- * Handle file content
- *
- * @param {OBject} store Vuex store
- * @param {ArrayBuffer} content Content of the file
- * @param {string} source Source of the file (either URL or file path)
- * @param {File | null} [originalFile]
- * @returns {ExternalLayer} External layer object
- */
-export async function handleFileContent(store, content, source, originalFile = null) {
-    let layer = null
-    let parsedContent
-    let linkFiles
-    if (isZipContent(content)) {
-        log.debug(`File content is a zipfile, assume it is a KMZ archive`)
-        const kmz = await unzipKmz(content, source)
-        parsedContent = kmz.kml
-        linkFiles = kmz.files
-    } else if (isTiffContent(content)) {
-        log.debug(`File content might be a GeoTIFF, attempting a parse as such`)
-        try {
-            parsedContent = await fromArrayBuffer(content)
-            layer = new GeoTIFFLayer({
-                fileSource: source,
-                visible: true,
-                opacity: 1.0,
-                // For local files : OpenLayers needs a Blob, and not an already parsed GeoTIFF instance
-                data: originalFile,
-            })
-        } catch (err) {
-            log.error('parsing as GeoTIFF failed', err)
-            throw new Error(`Could not parse GeoTIFF from ${source}`)
-        }
-        // looking into the GeoTIFF file to get the extent
-        const geoTIFFImage = await parsedContent.getImage()
-        const geoTIFFExtent = geoTIFFImage.getBoundingBox()
-        if (geoTIFFExtent) {
-            const projectedExtent = getExtentForProjection(
-                store.state.position.projection,
-                normalizeExtent(geoTIFFExtent)
-            )
-            if (!projectedExtent) {
-                throw new OutOfBoundsError(`GeoTIFF out of projection bounds: ${geoTIFFExtent}`)
-            }
-            store.dispatch('zoomToExtent', {
-                extent: normalizeExtent(geoTIFFExtent),
-                ...dispatcher,
-            })
-        }
-        store.dispatch('addLayer', { layer, ...dispatcher })
-        // we are done here, so to not run the parsed content part below, we stop the function here
-        return layer
-    } else {
-        // If it is not a zip file then we assume is a text file and decode it for further handling
-        parsedContent = new TextDecoder('utf-8').decode(content)
-    }
-    if (isKml(parsedContent)) {
-        layer = new KMLLayer({
-            kmlFileUrl: source,
-            visible: true,
-            opacity: 1.0,
-            adminId: null,
-            kmlData: parsedContent,
-            linkFiles,
-        })
-        const extent = getKmlExtent(parsedContent)
-        if (!extent) {
-            throw new EmptyKMLError()
-        }
-        const projectedExtent = getExtentForProjection(store.state.position.projection, extent)
-
-        if (!projectedExtent) {
-            throw new OutOfBoundsError(`KML out of projection bounds: ${extent}`)
-        }
-        store.dispatch('zoomToExtent', { extent: projectedExtent, ...dispatcher })
-        if (store.getters.getActiveLayersById(layer.id).length > 0) {
-            store.dispatch('updateLayers', { layers: [layer], ...dispatcher })
-        } else {
-            store.dispatch('addLayer', { layer, ...dispatcher })
-        }
-    } else if (isGpx(parsedContent)) {
-        const gpxParser = new GPX()
-        const metadata = gpxParser.readMetadata(parsedContent)
-        layer = new GPXLayer({
-            gpxFileUrl: source,
-            visible: true,
-            opacity: 1.0,
-            gpxData: parsedContent,
-            gpxMetadata: metadata,
-        })
-        const extent = getGpxExtent(parsedContent)
-        if (!extent) {
-            throw new EmptyGPXError()
-        }
-        const projectedExtent = getExtentForProjection(store.state.position.projection, extent)
-        if (!projectedExtent) {
-            throw new OutOfBoundsError(`GPX out of projection bounds: ${extent}`)
-        }
-        store.dispatch('zoomToExtent', { extent: projectedExtent, ...dispatcher })
-        store.dispatch('addLayer', { layer, ...dispatcher })
-    } else {
-        throw new Error(`Unsupported file ${source} textContent`)
-    }
-
-    return layer
-}
diff --git a/src/router/storeSync/LayerParamConfig.class.js b/src/router/storeSync/LayerParamConfig.class.js
index e7c120956..47d1d6a8c 100644
--- a/src/router/storeSync/LayerParamConfig.class.js
+++ b/src/router/storeSync/LayerParamConfig.class.js
@@ -15,8 +15,8 @@ import {
     parseLayersParam,
     transformLayerIntoUrlString,
 } from '@/router/storeSync/layersParamParser'
-import { flattenExtent } from '@/utils/coordinates/coordinateUtils.js'
 import ErrorMessage from '@/utils/ErrorMessage.class'
+import { flattenExtent } from '@/utils/extentUtils'
 import { getExtentOfGeometries } from '@/utils/geoJsonUtils'
 import log from '@/utils/logging'
 import WarningMessage from '@/utils/WarningMessage.class'
diff --git a/src/store/index.js b/src/store/index.js
index 985ac807b..620faaee8 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -23,9 +23,9 @@ import loadExternalLayerAttributes from '@/store/plugins/external-layers.plugin'
 import geolocationManagementPlugin from '@/store/plugins/geolocation-management.plugin'
 import loadGeojsonStyleAndData from '@/store/plugins/load-geojson-style-and-data.plugin'
 import loadGpxDataAndMetadata from '@/store/plugins/load-gpx-data.plugin'
-import loadKmlDataAndMetadata from '@/store/plugins/load-kml-data.plugin'
+import loadKmlDataAndMetadata from '@/store/plugins/load-kml-kmz-data.plugin'
 import loadLayersConfigOnLangChange from '@/store/plugins/load-layersconfig-on-lang-change'
-import redoSearchWhenNeeded from '@/store/plugins/redo-search-when-needed.plugin.js'
+import redoSearchWhenNeeded from '@/store/plugins/redo-search-when-needed.plugin'
 import reprojectSelectedFeaturesOnProjectionChangePlugin from '@/store/plugins/reproject-selected-features-on-projection-change.plugin'
 import screenSizeManagementPlugin from '@/store/plugins/screen-size-management.plugin'
 import syncCameraLonLatZoom from '@/store/plugins/sync-camera-lonlatzoom'
diff --git a/src/store/modules/__tests__/layers.store.spec.js b/src/store/modules/__tests__/layers.store.spec.js
index d72700da1..00c3f6ffa 100644
--- a/src/store/modules/__tests__/layers.store.spec.js
+++ b/src/store/modules/__tests__/layers.store.spec.js
@@ -153,7 +153,7 @@ describe('Update layer', () => {
             ...dispatcher,
         })
     })
-    it('Update a single layer by index with a full layer object', () => {
+    it('Update a single layer by ID with a full layer object', () => {
         const clone = secondLayer.clone()
         clone.name = 'Update second layer name'
         clone.visible = false
@@ -161,29 +161,29 @@ describe('Update layer', () => {
         expect(store.state.layers.activeLayers[1].name).to.be.equal('Second layer')
         expect(store.state.layers.activeLayers[1].visible).to.be.true
         expect(store.state.layers.activeLayers[1].timeConfig.currentYear).to.be.equal(2024)
-        store.dispatch('updateLayer', { index: 1, layer: clone, ...dispatcher })
+        store.dispatch('updateLayer', { layerId: secondLayer.id, values: clone, ...dispatcher })
         expect(store.state.layers.activeLayers[1].name).to.be.equal('Update second layer name')
         expect(store.state.layers.activeLayers[1].visible).to.be.false
         expect(store.state.layers.activeLayers[1].timeConfig.currentYear).to.be.equal(1900)
     })
-    it('Update a single layer with invalid index', () => {
+    it('Update a single layer with invalid layer ID', () => {
         expect(() =>
             store.dispatch('updateLayer', {
-                index: 5,
-                layer: { name: 'Update second layer name', visible: false, opacity: 0.8 },
+                layerId: 'some.non.existant.layer',
+                values: { name: 'Update second layer name', visible: false, opacity: 0.8 },
                 ...dispatcher,
             })
         ).to.throw()
         expect(() =>
             store.dispatch('updateLayer', {
-                layer: { name: 'Update second layer name', visible: false, opacity: 0.8 },
+                values: { name: 'Update second layer name', visible: false, opacity: 0.8 },
                 ...dispatcher,
             })
         ).to.throw()
         expect(() =>
             store.dispatch('updateLayer', {
-                index: -1,
-                layer: { name: 'Update second layer name', visible: false, opacity: 0.8 },
+                layerId: -1,
+                values: { name: 'Update second layer name', visible: false, opacity: 0.8 },
                 ...dispatcher,
             })
         ).to.throw()
diff --git a/src/store/modules/features.store.js b/src/store/modules/features.store.js
index 71ac32103..480aa43eb 100644
--- a/src/store/modules/features.store.js
+++ b/src/store/modules/features.store.js
@@ -12,7 +12,7 @@ import {
     DEFAULT_FEATURE_COUNT_SINGLE_POINT,
     GPX_GEOMETRY_SIMPLIFICATION_TOLERANCE,
 } from '@/config/map.config'
-import { flattenExtent } from '@/utils/coordinates/coordinateUtils'
+import { flattenExtent } from '@/utils/extentUtils'
 import { allStylingColors, allStylingSizes } from '@/utils/featureStyleUtils'
 import { transformIntoTurfEquivalent } from '@/utils/geoJsonUtils'
 import log from '@/utils/logging'
diff --git a/src/store/modules/layers.store.js b/src/store/modules/layers.store.js
index cfcdcf417..00cd3b635 100644
--- a/src/store/modules/layers.store.js
+++ b/src/store/modules/layers.store.js
@@ -1,6 +1,7 @@
 import AbstractLayer from '@/api/layers/AbstractLayer.class'
 import LayerTypes from '@/api/layers/LayerTypes.enum'
-import { getExtentForProjection } from '@/utils/extentUtils.js'
+import { WGS84 } from '@/utils/coordinates/coordinateSystems.js'
+import { getExtentIntersectionWithCurrentProjection } from '@/utils/extentUtils.js'
 import { getGpxExtent } from '@/utils/gpxUtils.js'
 import { getKmlExtent, parseKmlName } from '@/utils/kmlUtils'
 import log from '@/utils/logging'
@@ -315,11 +316,12 @@ const actions = {
      * @param {AbstractLayer} layer
      * @param {String} layerId
      * @param {ActiveLayerConfig} layerConfig
+     * @param {Boolean} zoomToLayerExtent
      * @param {string} dispatcher Action dispatcher name
      */
     addLayer(
-        { commit, getters },
-        { layer = null, layerId = null, layerConfig = null, dispatcher }
+        { commit, dispatch, getters },
+        { layer = null, layerId = null, layerConfig = null, zoomToLayerExtent = false, dispatcher }
     ) {
         // creating a clone of the config, so that we do not modify the initial config of the app
         // (it is possible to add one layer many times, so we want to always have the correct
@@ -335,6 +337,12 @@ const actions = {
         }
         if (clone) {
             commit('addLayer', { layer: clone, dispatcher })
+            if (zoomToLayerExtent && layer.extent) {
+                dispatch('zoomToExtent', {
+                    extent: layer.extent,
+                    dispatcher,
+                })
+            }
         } else {
             log.error('no layer found for payload:', layer, layerId, layerConfig, dispatcher)
         }
@@ -389,31 +397,13 @@ const actions = {
     /**
      * Full or partial update of a layer at index in the active layer list
      *
-     * @param {number} index Index of the layer to update
-     * @param {AbstractLayer | { any: any }} layer Full layer object (AbstractLayer) to update or an
-     *   object with the properties to update (partial update)
+     * @param {String} layerId ID of the layer we want to update
+     * @param {AbstractLayer | { any: any }} values Full layer object (AbstractLayer) to update or
+     *   an object with the properties to update (partial update)
      * @param {string} dispatcher Action dispatcher name
      */
-    updateLayer({ commit, getters }, { index, layer, dispatcher }) {
-        if (layer instanceof AbstractLayer) {
-            commit('updateLayer', { index, layer, dispatcher })
-        } else {
-            // Partial update of a layer
-            const layer2Update = getters.getActiveLayerByIndex(index)
-            if (!layer2Update) {
-                throw new Error(`Failed to updateLayer: invalid layer index ${index}`)
-            }
-            if (layer.id && layer.id !== layer2Update.id) {
-                throw new Error(
-                    `Failed to updateLayer "${layer2Update.id}" at index ${index}: not allowed to update layer ID to "${layer.id}"`
-                )
-            }
-
-            const updatedLayer = layer2Update.clone()
-            Object.entries(layer).forEach((entry) => (updatedLayer[entry[0]] = entry[1]))
-
-            commit('updateLayer', { index, layer: updatedLayer, dispatcher })
-        }
+    updateLayer({ commit }, { layerId, values, dispatcher }) {
+        commit('updateLayer', { layerId, values, dispatcher })
     },
 
     /**
@@ -719,7 +709,13 @@ const actions = {
 
                 if (!extent) {
                     clone.addErrorKey('kml_gpx_file_empty')
-                } else if (!getExtentForProjection(rootState.position.projection, extent)) {
+                } else if (
+                    !getExtentIntersectionWithCurrentProjection(
+                        extent,
+                        WGS84,
+                        rootState.position.projection
+                    )
+                ) {
                     clone.addErrorKey('imported_file_out_of_bounds')
                 }
             }
@@ -795,17 +791,12 @@ const mutations = {
     setLayers(state, { layers }) {
         state.activeLayers = layers
     },
-    updateLayer(state, { index, layer }) {
-        const layer2Update = getActiveLayerByIndex(state, index)
-        if (!layer2Update) {
-            throw new Error(`Failed to update layer at index ${index}: invalid index`)
-        }
-        if (layer.id && layer.id !== layer2Update.id) {
-            throw new Error(
-                `Failed to update layer at index ${index}: layer id "${layer2Update.id}" at index ${index} don't match given id "${layer.id}"`
-            )
+    updateLayer(state, { layerId, values }) {
+        const layer2Update = state.activeLayers.find((layer) => layer.id === layerId)
+        if (!(layer2Update instanceof AbstractLayer)) {
+            throw new Error(`Failed to updateLayer: no layer found with ID ${layerId}`)
         }
-        Object.assign(layer2Update, layer)
+        Object.assign(layer2Update, values)
     },
     updateLayers(state, { layers }) {
         layers.forEach((layer) => {
diff --git a/src/store/modules/position.store.js b/src/store/modules/position.store.js
index 90ba0235e..21a3e65cd 100644
--- a/src/store/modules/position.store.js
+++ b/src/store/modules/position.store.js
@@ -6,8 +6,9 @@ import CoordinateSystem from '@/utils/coordinates/CoordinateSystem.class'
 import allCoordinateSystems, { LV95, WGS84 } from '@/utils/coordinates/coordinateSystems'
 import CustomCoordinateSystem from '@/utils/coordinates/CustomCoordinateSystem.class'
 import StandardCoordinateSystem from '@/utils/coordinates/StandardCoordinateSystem.class'
+import { normalizeExtent } from '@/utils/extentUtils'
 import log from '@/utils/logging'
-import { wrapDegrees } from '@/utils/numberUtils.js'
+import { wrapDegrees } from '@/utils/numberUtils'
 
 /** @enum */
 export const CrossHairs = {
@@ -260,11 +261,12 @@ const actions = {
         }
     },
     zoomToExtent: ({ commit, state, rootState }, { extent, maxZoom, dispatcher }) => {
-        if (extent && Array.isArray(extent) && extent.length === 2) {
+        const normalizedExtent = extent ? normalizeExtent(extent) : null
+        if (normalizedExtent && Array.isArray(normalizedExtent) && normalizedExtent.length === 2) {
             // Convert extent points to WGS84 as adding the coordinates in metric gives incorrect results.
             const points = [
-                proj4(state.projection.epsg, WGS84.epsg, extent[0]),
-                proj4(state.projection.epsg, WGS84.epsg, extent[1]),
+                proj4(state.projection.epsg, WGS84.epsg, normalizedExtent[0]),
+                proj4(state.projection.epsg, WGS84.epsg, normalizedExtent[1]),
             ]
             // Calculate center of extent and convert position back to the wanted projection
             // Based on: https://github.com/Turfjs/turf/blob/v6.5.0/packages/turf-center/index.ts
@@ -281,8 +283,8 @@ const actions = {
                 })
             }
             const extentSize = {
-                width: extent[1][0] - extent[0][0],
-                height: extent[1][1] - extent[0][1],
+                width: normalizedExtent[1][0] - normalizedExtent[0][0],
+                height: normalizedExtent[1][1] - normalizedExtent[0][1],
             }
             let targetResolution
             // if the extent's height is greater than width, we base our resolution calculation on that
diff --git a/src/store/modules/search.store.js b/src/store/modules/search.store.js
index 749b9b02c..56052d311 100644
--- a/src/store/modules/search.store.js
+++ b/src/store/modules/search.store.js
@@ -6,8 +6,8 @@ import coordinateFromString from '@/utils/coordinates/coordinateExtractors'
 import { STANDARD_ZOOM_LEVEL_1_25000_MAP } from '@/utils/coordinates/CoordinateSystem.class'
 import { LV03 } from '@/utils/coordinates/coordinateSystems'
 import { reprojectAndRound } from '@/utils/coordinates/coordinateUtils'
-import { flattenExtent } from '@/utils/coordinates/coordinateUtils'
 import CustomCoordinateSystem from '@/utils/coordinates/CustomCoordinateSystem.class'
+import { flattenExtent } from '@/utils/extentUtils'
 import log from '@/utils/logging'
 
 const state = {
diff --git a/src/store/plugins/load-geojson-style-and-data.plugin.js b/src/store/plugins/load-geojson-style-and-data.plugin.js
index 433da35fe..6cb180f5a 100644
--- a/src/store/plugins/load-geojson-style-and-data.plugin.js
+++ b/src/store/plugins/load-geojson-style-and-data.plugin.js
@@ -40,12 +40,11 @@ async function autoReloadData(store, geoJsonLayer) {
             const requester = 'auto-load-geojson-style'
             store.dispatch('setLoadingBarRequester', { requester, ...dispatcher })
             const { data } = await load(geoJsonLayer.geoJsonUrl).response
-            const layerCopy = geoJsonLayer.clone()
-            layerCopy.geoJsonData = data
-            // we update through the action updateLayers, so that if multiple copies of the same GeoJSON layer are present,
-            // they will all be updated with the fresh data
-            store.dispatch('updateLayers', {
-                layers: [layerCopy],
+            store.dispatch('updateLayer', {
+                layerId: geoJsonLayer.id,
+                layers: {
+                    geoJsonData: data,
+                },
                 ...dispatcher,
             })
             store.dispatch('clearLoadingBarRequester', { requester, ...dispatcher })
diff --git a/src/store/plugins/load-gpx-data.plugin.js b/src/store/plugins/load-gpx-data.plugin.js
index f84319102..4363e0511 100644
--- a/src/store/plugins/load-gpx-data.plugin.js
+++ b/src/store/plugins/load-gpx-data.plugin.js
@@ -3,14 +3,14 @@
  * it here
  */
 
-import GPX from 'ol/format/GPX'
-
-import { getFileFromUrl } from '@/api/files.api'
 import GPXLayer from '@/api/layers/GPXLayer.class'
+import GPXParser from '@/modules/menu/components/advancedTools/ImportFile/parser/GPXParser.class'
 import log from '@/utils/logging'
 
 const dispatcher = { dispatcher: 'load-gpx-data.plugin' }
 
+const gpxParser = new GPXParser()
+
 /**
  * @param {Vuex.Store} store
  * @param {GPXLayer} gpxLayer
@@ -19,15 +19,18 @@ const dispatcher = { dispatcher: 'load-gpx-data.plugin' }
 async function loadGpx(store, gpxLayer) {
     log.debug(`Loading data for added GPX layer`, gpxLayer)
     try {
-        const response = await getFileFromUrl(gpxLayer.gpxFileUrl)
-        const gpxContent = response.data
-        const gpxParser = new GPX()
-        const metadata = gpxParser.readMetadata(gpxContent)
-        store.dispatch('setKmlGpxLayerData', {
-            layerId: gpxLayer.id,
-            metadata,
-            data: gpxContent,
-            ...dispatcher,
+        const updatedLayer = await gpxParser.parse(
+            {
+                fileSource: gpxLayer.gpxFileUrl,
+                currentProjection: store.state.position.projection,
+            },
+            {
+                allowServiceProxy: true,
+            }
+        )
+        store.dispatch('updateLayer', {
+            layerId: updatedLayer.id,
+            values: updatedLayer,
         })
     } catch (error) {
         log.error(`Error while fetching GPX data for layer ${gpxLayer?.id}`)
@@ -48,7 +51,7 @@ async function loadGpx(store, gpxLayer) {
 export default function loadGpxDataAndMetadata(store) {
     store.subscribe((mutation) => {
         const addLayerSubscriber = (layer) => {
-            if (layer instanceof GPXLayer && !layer?.gpxData) {
+            if (layer instanceof GPXLayer && !layer.gpxData) {
                 loadGpx(store, layer)
             }
         }
diff --git a/src/store/plugins/load-kml-data.plugin.js b/src/store/plugins/load-kml-kmz-data.plugin.js
similarity index 58%
rename from src/store/plugins/load-kml-data.plugin.js
rename to src/store/plugins/load-kml-kmz-data.plugin.js
index 056b52624..541fbaa8b 100644
--- a/src/store/plugins/load-kml-data.plugin.js
+++ b/src/store/plugins/load-kml-kmz-data.plugin.js
@@ -3,13 +3,16 @@
  * it here
  */
 
-import { loadKmlData, loadKmlMetadata } from '@/api/files.api'
+import { loadKmlMetadata } from '@/api/files.api'
 import KMLLayer from '@/api/layers/KMLLayer.class'
-import { unzipKmz } from '@/utils/kmlUtils'
+import { KMLParser } from '@/modules/menu/components/advancedTools/ImportFile/parser/KMLParser.class'
+import KMZParser from '@/modules/menu/components/advancedTools/ImportFile/parser/KMZParser.class'
 import log from '@/utils/logging'
-import { isZipContent } from '@/utils/utils'
 
-const dispatcher = { dispatcher: 'load-kml-data.plugin' }
+const dispatcher = { dispatcher: 'load-kml-kmz-data.plugin' }
+
+const kmzParser = new KMZParser()
+const kmlParser = new KMLParser()
 
 /**
  * @param {Vuex.Store} store
@@ -20,9 +23,11 @@ async function loadMetadata(store, kmlLayer) {
     log.debug(`Loading metadata for added KML layer`, kmlLayer)
     try {
         const metadata = await loadKmlMetadata(kmlLayer)
-        store.dispatch('setKmlGpxLayerData', {
-            layerId: kmlLayer?.id,
-            metadata,
+        store.dispatch('updateLayer', {
+            layerId: kmlLayer.id,
+            values: {
+                kmlMetadata: metadata,
+            },
             ...dispatcher,
         })
     } catch (error) {
@@ -38,21 +43,39 @@ async function loadMetadata(store, kmlLayer) {
 async function loadData(store, kmlLayer) {
     log.debug(`Loading data for added KML layer`, kmlLayer)
     try {
-        let kmlData
-        let kmlLinkFiles = new Map()
-        const data = await loadKmlData(kmlLayer)
-        if (isZipContent(data)) {
-            log.debug(`KML ${kmlLayer.id} is a KMZ file, unzipping it first`)
-            const kmz = await unzipKmz(data, kmlLayer.id)
-            kmlData = kmz.kml
-            kmlLinkFiles = kmz.files
-        } else {
-            kmlData = new TextDecoder('utf-8').decode(data)
-        }
-        store.dispatch('setKmlGpxLayerData', {
-            layerId: kmlLayer?.id,
-            data: kmlData,
-            linkFiles: kmlLinkFiles,
+        const kmz = await kmzParser.parse(
+            {
+                fileSource: kmlLayer.kmlFileUrl,
+                currentProjection: store.state.position.projection,
+            },
+            {
+                allowServiceProxy: true,
+            }
+        )
+        store.dispatch('updateLayer', {
+            layerId: kmlLayer.id,
+            values: kmz,
+            ...dispatcher,
+        })
+        // avoiding going below in the KML parsing
+        return
+    } catch (error) {
+        // not a KMZ layer, we proceed below to check if it is a KML
+    }
+
+    try {
+        const kml = await kmlParser.parse(
+            {
+                fileSource: kmlLayer.kmlFileUrl,
+                currentProjection: store.state.position.projection,
+            },
+            {
+                allowServiceProxy: true,
+            }
+        )
+        store.dispatch('updateLayer', {
+            layerId: kmlLayer.id,
+            values: kml,
             ...dispatcher,
         })
     } catch (error) {
diff --git a/src/store/plugins/reproject-selected-features-on-projection-change.plugin.js b/src/store/plugins/reproject-selected-features-on-projection-change.plugin.js
index 99b1b6615..116c31ecd 100644
--- a/src/store/plugins/reproject-selected-features-on-projection-change.plugin.js
+++ b/src/store/plugins/reproject-selected-features-on-projection-change.plugin.js
@@ -2,7 +2,7 @@ import proj4 from 'proj4'
 
 import EditableFeature from '@/api/features/EditableFeature.class'
 import LayerFeature from '@/api/features/LayerFeature.class'
-import { projExtent } from '@/utils/coordinates/coordinateUtils'
+import { projExtent } from '@/utils/extentUtils'
 import log from '@/utils/logging'
 
 const dispatcher = { dispatcher: 'reproject-selected-features-on-projection-change.plugin' }
diff --git a/src/utils/__tests__/extentUtils.spec.js b/src/utils/__tests__/extentUtils.spec.js
index 0f92446c5..d712c0ef2 100644
--- a/src/utils/__tests__/extentUtils.spec.js
+++ b/src/utils/__tests__/extentUtils.spec.js
@@ -3,38 +3,45 @@ import { describe, it } from 'vitest'
 
 import { LV95, WGS84 } from '@/utils/coordinates/coordinateSystems'
 import { reprojectAndRound } from '@/utils/coordinates/coordinateUtils'
-import { getExtentForProjection } from '@/utils/extentUtils'
+import { getExtentIntersectionWithCurrentProjection } from '@/utils/extentUtils'
 
 describe('Test extent utils', () => {
     describe('reproject and cut extent within projection bounds', () => {
         it('handles well wrong inputs and returns null', () => {
-            expect(getExtentForProjection()).to.be.null
-            expect(getExtentForProjection(null, null)).to.be.null
-            expect(getExtentForProjection(0, 0)).to.be.null
-            expect(getExtentForProjection({}, [])).to.be.null
-            expect(getExtentForProjection(LV95, [1, 2, 3])).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection()).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection(null, null, null)).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection(0, 0, 0)).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection({}, [], [])).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection([1, 2, 3], LV95, LV95)).to.be.null
         })
         it('reproject extent of a single coordinate inside the bounds of the projection', () => {
             const singleCoordinate = [8.2, 47.5]
             const singleCoordinateInLV95 = reprojectAndRound(WGS84, LV95, singleCoordinate)
             const extent = [singleCoordinate, singleCoordinate].flat()
-            expect(getExtentForProjection(LV95, extent)).to.deep.equal([
-                singleCoordinateInLV95,
-                singleCoordinateInLV95,
+            expect(getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)).to.deep.equal([
+                ...singleCoordinateInLV95,
+                ...singleCoordinateInLV95,
             ])
         })
         it('returns null if a single coordinate outside of bounds is given', () => {
             const singleCoordinateOutOfLV95Bounds = [8.2, 40]
             const extent = [singleCoordinateOutOfLV95Bounds, singleCoordinateOutOfLV95Bounds].flat()
-            expect(getExtentForProjection(LV95, extent)).to.be.null
+            expect(getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)).to.be.null
         })
         it('returns null if the extent given is completely outside of the projection bounds', () => {
-            const extent = [-5.0, -20.0, -25.0, -45.0]
-            expect(getExtentForProjection(LV95, extent)).to.be.null
+            const extent = [-25.0, -20.0, -5.0, -45.0]
+            expect(getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)).to.be.null
         })
         it('reproject and cut an extent that is greater than LV95 extent on all sides', () => {
-            const projectedExtent = getExtentForProjection(LV95, [-2.4, 35, 21.3, 51.7])
-            expect(projectedExtent).to.deep.equal([LV95.bounds.bottomLeft, LV95.bounds.topRight])
+            const projectedExtent = getExtentIntersectionWithCurrentProjection(
+                [-2.4, 35, 21.3, 51.7],
+                WGS84,
+                LV95
+            )
+            expect(projectedExtent).to.deep.equal([
+                ...LV95.bounds.bottomLeft,
+                ...LV95.bounds.topRight,
+            ])
         })
         it('only gives back the portion of an extent that is within LV95 bounds', () => {
             const singleCoordinateInsideLV95 = [7.54, 48.12]
@@ -44,10 +51,9 @@ describe('Test extent utils', () => {
                 singleCoordinateInsideLV95
             )
             const overlappingExtent = [0, 0, ...singleCoordinateInsideLV95]
-            expect(getExtentForProjection(LV95, overlappingExtent)).to.deep.equal([
-                LV95.bounds.bottomLeft,
-                singleCoordinateInLV95,
-            ])
+            expect(
+                getExtentIntersectionWithCurrentProjection(overlappingExtent, WGS84, LV95)
+            ).to.deep.equal([...LV95.bounds.bottomLeft, ...singleCoordinateInLV95])
         })
     })
 })
diff --git a/src/utils/components/FileInput.vue b/src/utils/components/FileInput.vue
index 2b5a84069..f067c7a20 100644
--- a/src/utils/components/FileInput.vue
+++ b/src/utils/components/FileInput.vue
@@ -149,6 +149,17 @@ const props = defineProps({
         type: String,
         default: '',
     },
+    /**
+     * Invalid message might sometimes require extra parameters to correctly set all placeholder in
+     * the translated message. This object is used to convey this dynamic placeholder replacement to
+     * the i18n call.
+     *
+     * @type {Object}
+     */
+    invalidMessageExtraParams: {
+        type: Object,
+        default: () => {},
+    },
     /**
      * Mark the field has validated.
      *
@@ -272,6 +283,7 @@ function onFileSelected(evt) {
                     i18n.t(invalidMessage, {
                         maxFileSize: maxFileSizeHuman,
                         allowedFormats: acceptedFileTypes.join(', '),
+                        ...invalidMessageExtraParams,
                     })
                 }}
             </div>
diff --git a/src/utils/components/ThirdPartyDisclaimer.vue b/src/utils/components/ThirdPartyDisclaimer.vue
index cb9f1aae5..1ea62575e 100644
--- a/src/utils/components/ThirdPartyDisclaimer.vue
+++ b/src/utils/components/ThirdPartyDisclaimer.vue
@@ -54,7 +54,7 @@ export default {
             currentLang: (state) => state.i18n.lang,
         }),
         tooltipContent() {
-            return this.isExternalDataLocal
+            return this.isLocalFile
                 ? this.$t('warn_share_local_file')
                 : this.$t('external_data_tooltip')
         },
@@ -67,7 +67,7 @@ export default {
     mounted() {
         if (this.showTippy) {
             this.tippyInstance = tippy(this.$refs.tippyAnchor, {
-                theme: this.isExternalDataLocal ? 'secondary' : 'primary',
+                theme: this.isLocalFile ? 'secondary' : 'primary',
                 content: this.tooltipContent,
                 arrow: true,
                 placement: 'top',
@@ -76,7 +76,7 @@ export default {
                 onCreate: (instance) => {
                     instance.popper.setAttribute(
                         'data-cy',
-                        this.isExternalDataLocal
+                        this.isLocalFile
                             ? `tippy-warn-share-local-file`
                             : `tippy-third-part-disclaimer`
                     )
diff --git a/src/utils/components/ZoomToExtentButton.vue b/src/utils/components/ZoomToExtentButton.vue
index cbc3593bd..c12cc0dea 100644
--- a/src/utils/components/ZoomToExtentButton.vue
+++ b/src/utils/components/ZoomToExtentButton.vue
@@ -17,7 +17,7 @@ import { ref, toRefs } from 'vue'
 import { useStore } from 'vuex'
 
 import { useTippyTooltip } from '@/utils/composables/useTippyTooltip'
-import { normalizeExtent } from '@/utils/coordinates/coordinateUtils'
+import { normalizeExtent } from '@/utils/extentUtils'
 
 const dispatcher = { dispatcher: 'ZoomToExtentButton.vue' }
 
diff --git a/src/utils/coordinates/coordinateUtils.js b/src/utils/coordinates/coordinateUtils.js
index 6b9330a41..8dce90cf8 100644
--- a/src/utils/coordinates/coordinateUtils.js
+++ b/src/utils/coordinates/coordinateUtils.js
@@ -23,69 +23,6 @@ export function toRoundedString(coordinate, digits, withThousandsSeparator = tru
         .replace(/\B(?=(\d{3})+(?!\d))/g, "'")
 }
 
-/**
- * Projection of an extent, described as [topLeftX, topLeftY, bottomRightX, bottomRightY]
- *
- * @param {CoordinateSystem} fromProj Current projection used to describe the extent
- * @param {CoordinateSystem} toProj Target projection we want the extent be expressed in
- * @param {Number[]} extent An extent, described as `[topLeftX, topLeftY, bottomRightX,
- *   bottomRightY]`
- * @returns {null | Number[]} The reprojected extent, or null if the given extent is not an array of
- *   four numbers
- */
-export function projExtent(fromProj, toProj, extent) {
-    if (extent.length === 4) {
-        const topLeft = proj4(fromProj.epsg, toProj.epsg, [extent[0], extent[1]])
-        const bottomRight = proj4(fromProj.epsg, toProj.epsg, [extent[2], extent[3]])
-        return [...topLeft, ...bottomRight].map(toProj.roundCoordinateValue)
-    }
-    return null
-}
-
-/**
- * Return an extent normalized to [[x, y], [x, y]] from a flat extent
- *
- * @param {Array} extent Extent to normalize
- * @returns {Array} Extent in the form [[x, y], [x, y]]
- */
-export function normalizeExtent(extent) {
-    let extentNormalized = extent
-    if (extent?.length === 4) {
-        // convert to the flat extent to [[x, y], [x, y]]
-        extentNormalized = [
-            [extent[0], extent[1]],
-            [extent[2], extent[3]],
-        ]
-    } else if (extent?.length !== 2) {
-        throw new Error(`Invalid extent: ${extent}`)
-    }
-    return extentNormalized
-}
-
-/**
- * Flatten extent
- *
- * @param {Array} extent Extent to flatten
- * @returns {Array} Flatten extent in from [minx, miny, maxx, maxy]
- */
-export function flattenExtent(extent) {
-    let flattenExtent = extent
-    if (extent?.length === 2) {
-        flattenExtent = [...extent[0], ...extent[1]]
-    } else if (extent?.length !== 4) {
-        throw new Error(`Invalid extent: ${extent}`)
-    }
-    return flattenExtent
-}
-
-/** Coordinates or extent out of bounds error */
-export class OutOfBoundsError extends Error {
-    constructor(message) {
-        super(message)
-        this.name = 'OutOfBoundsError'
-    }
-}
-
 /**
  * Convert recursively input coordinates into LV95
  *
diff --git a/src/utils/extentUtils.js b/src/utils/extentUtils.js
index 2078f5d44..9048287da 100644
--- a/src/utils/extentUtils.js
+++ b/src/utils/extentUtils.js
@@ -1,46 +1,113 @@
 import bbox from '@turf/bbox'
 import buffer from '@turf/buffer'
 import { point } from '@turf/helpers'
-import { getIntersection as getExtentIntersection, isEmpty as isExtentEmpty } from 'ol/extent'
+import { getIntersection as getExtentIntersection } from 'ol/extent'
 import proj4 from 'proj4'
 
-import CoordinateSystem from '@/utils/coordinates/CoordinateSystem.class.js'
+import CoordinateSystem from '@/utils/coordinates/CoordinateSystem.class'
 import { WGS84 } from '@/utils/coordinates/coordinateSystems'
-import { normalizeExtent, projExtent } from '@/utils/coordinates/coordinateUtils'
-import log from '@/utils/logging'
 import { round } from '@/utils/numberUtils'
 
 /**
- * Get a flattened extent for the projection bounds.
+ * Projection of an extent, described as [minx, miny, maxx, maxy].
  *
- * @param {CoordinateSystem} projection Projection in which to get the extent
- * @param {[number, number, number, number]} extent Extent in WGS84 such as `[minx, miny, maxx,
- *   maxy]`
- * @returns {null | [[number, number], [number, number]]} Return null if the extent is out of
- *   projection bounds or the intersection between the extent and projection bounds. The return
- *   extent is re-projected to the projection. The output format will be `[[minx, miny], [maxx,
- *   maxy]]`.
+ * @param {CoordinateSystem} fromProj Current projection used to describe the extent
+ * @param {CoordinateSystem} toProj Target projection we want the extent be expressed in
+ * @param {Number[]} extent An extent, described as `[minx, miny, maxx, maxy].`
+ * @returns {null | Number[]} The reprojected extent, or null if the given extent is not an array of
+ *   four numbers
  */
-export function getExtentForProjection(projection, extent) {
-    if (!(projection instanceof CoordinateSystem) || extent?.length !== 4) {
+export function projExtent(fromProj, toProj, extent) {
+    if (extent.length === 4) {
+        const bottomLeft = proj4(fromProj.epsg, toProj.epsg, [extent[0], extent[1]])
+        const topRight = proj4(fromProj.epsg, toProj.epsg, [extent[2], extent[3]])
+        return [...bottomLeft, ...topRight].map(toProj.roundCoordinateValue)
+    }
+    return null
+}
+
+/**
+ * Return an extent normalized to [[x, y], [x, y]] from a flat extent
+ *
+ * @param {Array} extent Extent to normalize
+ * @returns {Array} Extent in the form [[x, y], [x, y]]
+ */
+export function normalizeExtent(extent) {
+    let extentNormalized = extent
+    if (extent?.length === 4) {
+        // convert to the flat extent to [[x, y], [x, y]]
+        extentNormalized = [
+            [extent[0], extent[1]],
+            [extent[2], extent[3]],
+        ]
+    } else if (extent?.length !== 2) {
+        throw new Error(`Invalid extent: ${extent}`)
+    }
+    return extentNormalized
+}
+
+/**
+ * Flatten extent
+ *
+ * @param {Array} extent Extent to flatten
+ * @returns {Array} Flatten extent in from [minx, miny, maxx, maxy]
+ */
+export function flattenExtent(extent) {
+    let flattenExtent = extent
+    if (extent?.length === 2) {
+        flattenExtent = [...extent[0], ...extent[1]]
+    } else if (extent?.length !== 4) {
+        throw new Error(`Invalid extent: ${extent}`)
+    }
+    return flattenExtent
+}
+
+/**
+ * Get the intersection of the extent with the current projection, as a flatten extent expressed in
+ * the current projection
+ *
+ * @param {[Number, Number, Number, Number] | [[Number, Number], [Number, Number]]} extent Such as
+ *   [minx, miny, maxx, maxy]. or [bottomLeft, topRight]
+ * @param {CoordinateSystem} extentProjection
+ * @param {CoordinateSystem} currentProjection
+ * @returns {[Number, Number, Number, Number] | null}
+ */
+export function getExtentIntersectionWithCurrentProjection(
+    extent,
+    extentProjection,
+    currentProjection
+) {
+    if (
+        (extent?.length !== 4 && extent?.length !== 2) ||
+        !(extentProjection instanceof CoordinateSystem) ||
+        !(currentProjection instanceof CoordinateSystem)
+    ) {
         return null
     }
-    const projectionBounds = projection.getBoundsAs(WGS84).flatten
-    let intersectExtent = getExtentIntersection(projectionBounds, extent)
-    log.debug(
-        `Get extent for projection ${projection.epsg}`,
-        `extent=${extent}`,
-        `projectionBounds=${projectionBounds}`,
-        `intersectExtent=${intersectExtent}`
+    let extentInCurrentProjection = flattenExtent(extent)
+    if (extentProjection.epsg !== currentProjection.epsg) {
+        extentInCurrentProjection = projExtent(
+            extentProjection,
+            currentProjection,
+            extentInCurrentProjection
+        )
+    }
+    extentInCurrentProjection = getExtentIntersection(
+        extentInCurrentProjection,
+        currentProjection.bounds.flatten
     )
-    if (!isExtentEmpty(intersectExtent)) {
-        return normalizeExtent(projExtent(WGS84, projection, intersectExtent))
+    if (
+        !extentInCurrentProjection ||
+        // OL now populates the extent with Infinity when nothing is in common, instead returning a null value
+        extentInCurrentProjection.every((value) => Math.abs(value) === Infinity)
+    ) {
+        return null
     }
-    return null
+    return flattenExtent(extentInCurrentProjection)
 }
 
 /**
- * @param {Number} config.size Number of pixels the extent should be (if 100 is given, a box of
+ * @param {Number} config.size Number of pixels the extent should be (if s100 is given, a box of
  *   100x100 pixels with the coordinate at its center will be returned)
  * @param {[Number, Number]} config.coordinate Where the center of the "size" pixel(s) extent should
  *   be.
diff --git a/src/utils/geoJsonUtils.js b/src/utils/geoJsonUtils.js
index 9e3c5a1f2..ec01eacf7 100644
--- a/src/utils/geoJsonUtils.js
+++ b/src/utils/geoJsonUtils.js
@@ -14,7 +14,7 @@ import { reproject } from 'reproject'
 
 import CoordinateSystem from '@/utils/coordinates/CoordinateSystem.class'
 import allCoordinateSystems, { WGS84 } from '@/utils/coordinates/coordinateSystems'
-import { normalizeExtent } from '@/utils/coordinates/coordinateUtils'
+import { normalizeExtent } from '@/utils/extentUtils'
 import log from '@/utils/logging'
 
 /**
diff --git a/src/utils/gpxUtils.js b/src/utils/gpxUtils.js
index 373fe61b5..209568ab6 100644
--- a/src/utils/gpxUtils.js
+++ b/src/utils/gpxUtils.js
@@ -49,5 +49,3 @@ export function parseGpx(gpxData, projection) {
     })
     return features
 }
-
-export class EmptyGPXError extends Error {}
diff --git a/src/utils/kmlUtils.js b/src/utils/kmlUtils.js
index 34d48df32..2d871769f 100644
--- a/src/utils/kmlUtils.js
+++ b/src/utils/kmlUtils.js
@@ -553,7 +553,6 @@ export function parseKml(kmlLayer, projection, iconSets, iconUrlProxy = iconUrlP
     return features
 }
 
-export class EmptyKMLError extends Error {}
 export class KMZError extends Error {}
 
 /**
@@ -581,7 +580,7 @@ export class KMZObject {
  *
  * See https://developers.google.com/kml/documentation/kmzarchives
  *
- * @param {string} kmzContent KMZ archive content as string
+ * @param {String | ArrayBuffer} kmzContent KMZ archive content
  * @param {string} kmzFileName KMZ archive name
  * @returns {KMZObject} Returns a KMZ unzip object
  */
diff --git a/src/utils/utils.js b/src/utils/utils.js
index 62231c9c2..18060f46c 100644
--- a/src/utils/utils.js
+++ b/src/utils/utils.js
@@ -260,35 +260,3 @@ export function humanFileSize(size) {
 export function isInternalUrl(url) {
     return internalDomainRegex.test(url)
 }
-
-/**
- * Check if the input is a zipfile content or not
- *
- * @param {ArrayBuffer} content
- * @returns {boolean} Return true if the content is a zipfile content
- */
-export function isZipContent(content) {
-    // Check the first 4 bytes for the ZIP file signature
-    const zipSignature = [0x50, 0x4b, 0x03, 0x04]
-    const view = new Uint8Array(content.slice(0, 4))
-    for (let i = 0; i < zipSignature.length; i++) {
-        if (view[i] !== zipSignature[i]) {
-            return false
-        }
-    }
-    return true
-}
-
-/**
- * Check if the input is a TIFF content or not
- *
- * @param {ArrayBuffer} content
- * @returns {boolean} Return true if the content is a TIFF content
- */
-export function isTiffContent(content) {
-    // Check the first 4 bytes for the TIFF file signature
-    // signatures can be found here https://en.wikipedia.org/wiki/TIFF
-    const tiffLittleEndianSignature = [0x49, 0x49, 0x2a, 0x00]
-    const contentSignature = new Uint8Array(content.slice(0, 4))
-    return tiffLittleEndianSignature.every((byte, index) => byte === contentSignature[index])
-}