@opengeoweb/data-explorer 13.2.1 → 14.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/index.esm.js +1578 -504
  2. package/package.json +9 -9
  3. package/src/lib/components/DataExplorerFilters/DataExplorerFilterOption.d.ts +1 -0
  4. package/src/lib/components/DataExplorerInfo/InfoDialogWMSMap.d.ts +14 -0
  5. package/src/lib/components/DataExplorerInfo/InfoDialogWMSMapConnect.d.ts +15 -0
  6. package/src/lib/components/DataExplorerInfo/InfoDialogWMSMapConnect.spec.d.ts +1 -0
  7. package/src/lib/components/DataExplorerInfo/InfoDialogWMSMapConnect.stories.d.ts +7 -0
  8. package/src/lib/store/reducer.d.ts +2 -1
  9. package/src/lib/store/selectors.d.ts +21 -0
  10. package/src/lib/store/types.d.ts +17 -0
package/index.esm.js CHANGED
@@ -4,7 +4,7 @@ import React__default, { useMemo, useRef, useEffect, useCallback, useState } fro
4
4
  import { mapListener, serviceListener, layersListener, syncGroupsListener, genericListener, uiReducer, syncGroupsReducer, layerReducer, serviceReducer, mapReducer, uiSelectors, uiTypes, uiActions, layerActions, layerTypes, layerSelectors, useSetupDialog } from '@opengeoweb/store';
5
5
  import { useDispatch, useSelector } from 'react-redux';
6
6
  import { Box, ListItem, ListItemButton, ListItemIcon, Checkbox, ListItemText, Typography, List, useTheme, Grid, Tooltip, Autocomplete, TextField, LinearProgress, Link, IconButton, Accordion, AccordionSummary, AccordionDetails } from '@mui/material';
7
- import { SearchField, CustomTooltip, CustomAccordion, CustomToggleButton, CustomIconButton, SearchHighlight, PROJECTION, useDebounce, renderCounter, useWheelStopPropagation, ToolContainerDraggable, AlertBanner } from '@opengeoweb/shared';
7
+ import { SearchField, CustomTooltip, CustomAccordion, CustomToggleButton, CustomIconButton, SearchHighlight, PROJECTION, useDebounce, renderCounter, useWheelStopPropagation, ToolContainerDraggable, AlertBanner, ErrorBoundary } from '@opengeoweb/shared';
8
8
  import { createSelector, createSlice, createListenerMiddleware, combineReducers } from '@reduxjs/toolkit';
9
9
  import { snackbarListener, snackbarReducer } from '@opengeoweb/snackbar';
10
10
  import { t } from 'i18next';
@@ -16,11 +16,12 @@ import { Info, Close, ExitDomain, Link as Link$1, Copy, ChevronDown } from '@ope
16
16
  import * as turf from '@turf/turf';
17
17
  import { View } from 'ol';
18
18
  import { unByKey } from 'ol/Observable';
19
- import { transformExtent, transform } from 'ol/proj';
19
+ import { transformExtent, transform, fromLonLat } from 'ol/proj';
20
20
  import { debounce } from 'lodash';
21
21
  import GeoJSON from 'ol/format/GeoJSON';
22
- import { OpenLayersMapView, MapControls, OpenLayersZoomControl, OpenLayersFeatureLayer, genericOpenLayersFeatureStyle, OpenLayersLayer } from '@opengeoweb/webmap-react';
22
+ import { OpenLayersMapView, MapControls, OpenLayersZoomControl, OpenLayersFeatureLayer, genericOpenLayersFeatureStyle, OpenLayersLayer, DefaultBaseLayers, WMSLayer, useQueryGetWMSGetCapabilities } from '@opengeoweb/webmap-react';
23
23
  import { useLocationList, useLocationDetail } from '@opengeoweb/core';
24
+ import { boundingExtent } from 'ol/extent';
24
25
 
25
26
  var en = {
26
27
  "dataexplorer-search-datasets": "Search datasets",
@@ -60,7 +61,199 @@ var en = {
60
61
  "contacts-organisation": "Organisation",
61
62
  "contacts-hours-of-service": "Hours of service",
62
63
  "contacts-contact-instructions": "Contact instructions",
63
- "contacts-telephone": "Telephone"
64
+ "contacts-telephone": "Telephone",
65
+ AFG: "Afghanistan",
66
+ AIA: "Anguilla",
67
+ ALB: "Albania",
68
+ DZA: "Algeria",
69
+ AND: "Andorra",
70
+ AGO: "Angola",
71
+ ATG: "Antigua and Barbuda",
72
+ ARG: "Argentina",
73
+ ARM: "Armenia",
74
+ AUS: "Australia",
75
+ AUT: "Austria",
76
+ AZE: "Azerbaijan",
77
+ BHS: "Bahamas",
78
+ BHR: "Bahrain",
79
+ BGD: "Bangladesh",
80
+ BRB: "Barbados",
81
+ BLR: "Belarus",
82
+ BEL: "Belgium",
83
+ BLZ: "Belize",
84
+ BEN: "Benin",
85
+ BTN: "Bhutan",
86
+ BOL: "Bolivia, Plurinational State of",
87
+ BIH: "Bosnia and Herzegovina",
88
+ BWA: "Botswana",
89
+ BRA: "Brazil",
90
+ BRN: "Brunei Darussalam",
91
+ BGR: "Bulgaria",
92
+ BFA: "Burkina Faso",
93
+ BDI: "Burundi",
94
+ CAN: "Canada",
95
+ COD: "Congo, The Democratic Republic of the",
96
+ COG: "Congo",
97
+ TCD: "Chad",
98
+ CHL: "Chile",
99
+ CMR: "Cameroon",
100
+ CRI: "Costa Rica",
101
+ HRV: "Croatia",
102
+ CUB: "Cuba",
103
+ CYM: "Cayman Islands",
104
+ CYP: "Cyprus",
105
+ CZE: "Czechia",
106
+ DNK: "Denmark",
107
+ DJI: "Djibouti",
108
+ DMA: "Dominica",
109
+ DOM: "Dominican Republic",
110
+ ECU: "Ecuador",
111
+ EGY: "Egypt",
112
+ SLV: "El Salvador",
113
+ GNQ: "Equatorial Guinea",
114
+ ERI: "Eritrea",
115
+ EST: "Estonia",
116
+ SWZ: "Eswatini",
117
+ ETH: "Ethiopia",
118
+ FJI: "Fiji",
119
+ FIN: "Finland",
120
+ FRA: "France",
121
+ GAB: "Gabon",
122
+ GMB: "Gambia",
123
+ GEO: "Georgia",
124
+ DEU: "Germany",
125
+ GHA: "Ghana",
126
+ GRC: "Greece",
127
+ GRD: "Grenada",
128
+ GTM: "Guatemala",
129
+ GIN: "Guinea",
130
+ GNB: "Guinea-Bissau",
131
+ GUY: "Guyana",
132
+ HKG: "Hong Kong",
133
+ HTI: "Haiti",
134
+ HND: "Honduras",
135
+ HUN: "Hungary",
136
+ ISL: "Iceland",
137
+ IND: "India",
138
+ IDN: "Indonesia",
139
+ IRN: "Iran, Islamic Republic of",
140
+ IRQ: "Iraq",
141
+ IRL: "Ireland",
142
+ ISR: "Israel",
143
+ ITA: "Italy",
144
+ JAM: "Jamaica",
145
+ JPN: "Japan",
146
+ JOR: "Jordan",
147
+ KAZ: "Kazakhstan",
148
+ KEN: "Kenya",
149
+ KIR: "Kiribati",
150
+ KWT: "Kuwait",
151
+ KGZ: "Kyrgyzstan",
152
+ LAO: "Lao People's Democratic Republic",
153
+ LVA: "Latvia",
154
+ LBN: "Lebanon",
155
+ LSO: "Lesotho",
156
+ LBR: "Liberia",
157
+ LBY: "Libya",
158
+ LIE: "Liechtenstein",
159
+ LTU: "Lithuania",
160
+ LUX: "Luxembourg",
161
+ MDG: "Madagascar",
162
+ MWI: "Malawi",
163
+ MYS: "Malaysia",
164
+ MDV: "Maldives",
165
+ MLI: "Mali",
166
+ MLT: "Malta",
167
+ MHL: "Marshall Islands",
168
+ MRT: "Mauritania",
169
+ MUS: "Mauritius",
170
+ MEX: "Mexico",
171
+ FSM: "Micronesia, Federated States of",
172
+ MSR: "Montserrat",
173
+ MDA: "Moldova, Republic of",
174
+ MCO: "Monaco",
175
+ MNG: "Mongolia",
176
+ MNE: "Montenegro",
177
+ MAR: "Morocco",
178
+ MOZ: "Mozambique",
179
+ MMR: "Myanmar",
180
+ NAM: "Namibia",
181
+ NRU: "Nauru",
182
+ NPL: "Nepal",
183
+ NLD: "Netherlands",
184
+ NZL: "New Zealand",
185
+ NIC: "Nicaragua",
186
+ NER: "Niger",
187
+ NGA: "Nigeria",
188
+ MKD: "North Macedonia",
189
+ NOR: "Norway",
190
+ OMN: "Oman",
191
+ PAK: "Pakistan",
192
+ PLW: "Palau",
193
+ PAN: "Panama",
194
+ PNG: "Papua New Guinea",
195
+ PRY: "Paraguay",
196
+ PER: "Peru",
197
+ PHL: "Philippines",
198
+ POL: "Poland",
199
+ PRT: "Portugal",
200
+ QAT: "Qatar",
201
+ ROU: "Romania",
202
+ RUS: "Russian Federation",
203
+ RWA: "Rwanda",
204
+ KNA: "Saint Kitts and Nevis",
205
+ LCA: "Saint Lucia",
206
+ VCT: "Saint Vincent and the Grenadines",
207
+ WSM: "Samoa",
208
+ SMR: "San Marino",
209
+ STP: "Sao Tome and Principe",
210
+ SAU: "Saudi Arabia",
211
+ SEN: "Senegal",
212
+ SRB: "Serbia",
213
+ SYC: "Seychelles",
214
+ SLE: "Sierra Leone",
215
+ SGP: "Singapore",
216
+ SXM: "Sint Maarten",
217
+ SVK: "Slovakia",
218
+ SVN: "Slovenia",
219
+ SLB: "Solomon Islands",
220
+ SOM: "Somalia",
221
+ ZAF: "South Africa",
222
+ KOR: "Korea, Republic of",
223
+ SSD: "South Sudan",
224
+ ESP: "Spain",
225
+ LKA: "Sri Lanka",
226
+ SDN: "Sudan",
227
+ SUR: "Suriname",
228
+ SWE: "Sweden",
229
+ CHE: "Switzerland",
230
+ SYR: "Syrian Arab Republic",
231
+ TWN: "Taiwan, Province of China",
232
+ TJK: "Tajikistan",
233
+ TZA: "Tanzania, United Republic of",
234
+ THA: "Thailand",
235
+ TLS: "Timor-Leste",
236
+ TGO: "Togo",
237
+ TON: "Tonga",
238
+ TTO: "Trinidad and Tobago",
239
+ TUN: "Tunisia",
240
+ TUR: "Türkiye",
241
+ TKM: "Turkmenistan",
242
+ TCA: "Turks and Caicos Islands",
243
+ UGA: "Uganda",
244
+ UKR: "Ukraine",
245
+ ARE: "United Arab Emirates",
246
+ GBR: "United Kingdom",
247
+ USA: "United States",
248
+ URY: "Uruguay",
249
+ UZB: "Uzbekistan",
250
+ VUT: "Vanuatu",
251
+ VEN: "Venezuela, Bolivarian Republic of",
252
+ VNM: "Viet Nam",
253
+ VGB: "British Virgin Islands",
254
+ YEM: "Yemen",
255
+ ZMB: "Zambia",
256
+ ZWE: "Zimbabwe"
64
257
  };
65
258
  var fi = {
66
259
  "dataexplorer-search-datasets": "ei käännetty",
@@ -100,7 +293,199 @@ var fi = {
100
293
  "contacts-organisation": "ei käännetty",
101
294
  "contacts-hours-of-service": "ei käännetty",
102
295
  "contacts-contact-instructions": "ei käännetty",
103
- "contacts-telephone": "ei käännetty"
296
+ "contacts-telephone": "ei käännetty",
297
+ AFG: "Afganistan",
298
+ AIA: "Anguilla",
299
+ ALB: "Albania",
300
+ DZA: "Algeria",
301
+ AND: "Andorra",
302
+ AGO: "Angola",
303
+ ATG: "Antigua ja Barbuda",
304
+ ARG: "Argentiina",
305
+ ARM: "Armenia",
306
+ AUS: "Australia",
307
+ AUT: "Itävalta",
308
+ AZE: "Azerbaidžan",
309
+ BHS: "Bahama",
310
+ BHR: "Bahrain",
311
+ BGD: "Bangladesh",
312
+ BRB: "Barbados",
313
+ BLR: "Valko-Venäjä",
314
+ BEL: "Belgia",
315
+ BLZ: "Belize",
316
+ BEN: "Benin",
317
+ BTN: "Bhutan",
318
+ BOL: "Bolivia",
319
+ BIH: "Bosnia ja Hertsegovina",
320
+ BWA: "Botswana",
321
+ BRA: "Brasilia",
322
+ BRN: "Brunei",
323
+ BGR: "Bulgaria",
324
+ BFA: "Burkina Faso",
325
+ BDI: "Burundi",
326
+ COD: "Kongon demokraattinen tasavalta",
327
+ COG: "Kongon tasavalta",
328
+ TCD: "Tšad",
329
+ CHL: "Chile",
330
+ CMR: "Kamerun",
331
+ CAN: "Kanada",
332
+ CRI: "Costa Rica",
333
+ HRV: "Kroatia",
334
+ CUB: "Kuuba",
335
+ CYM: "Caymansaaret",
336
+ CYP: "Kypros",
337
+ CZE: "Tšekki",
338
+ DNK: "Tanska",
339
+ DJI: "Djibouti",
340
+ DMA: "Dominica",
341
+ DOM: "Dominikaaninen tasavalta",
342
+ ECU: "Ecuador",
343
+ EGY: "Egypti",
344
+ SLV: "El Salvador",
345
+ GNQ: "Päiväntasaajan Guinea",
346
+ ERI: "Eritrea",
347
+ EST: "Viro",
348
+ SWZ: "Eswatini",
349
+ ETH: "Etiopia",
350
+ FJI: "Fidži",
351
+ FIN: "Suomi",
352
+ FRA: "Ranska",
353
+ GAB: "Gabon",
354
+ GMB: "Gambia",
355
+ GEO: "Georgia",
356
+ DEU: "Saksa",
357
+ GHA: "Ghana",
358
+ GRC: "Kreikka",
359
+ GRD: "Grenada",
360
+ GTM: "Guatemala",
361
+ GIN: "Guinea",
362
+ GNB: "Guinea-Bissau",
363
+ GUY: "Guyana",
364
+ HKG: "Hongkong",
365
+ HTI: "Haiti",
366
+ HND: "Honduras",
367
+ HUN: "Unkari",
368
+ ISL: "Islanti",
369
+ IND: "Intia",
370
+ IDN: "Indonesia",
371
+ IRN: "Iran",
372
+ IRQ: "Irak",
373
+ IRL: "Irlanti",
374
+ ISR: "Israel",
375
+ ITA: "Italia",
376
+ JAM: "Jamaika",
377
+ JPN: "Japani",
378
+ JOR: "Jordania",
379
+ KAZ: "Kazakstan",
380
+ KEN: "Kenia",
381
+ KIR: "Kiribati",
382
+ KWT: "Kuwait",
383
+ KGZ: "Kirgisia",
384
+ LAO: "Laos",
385
+ LVA: "Latvia",
386
+ LBN: "Libanon",
387
+ LSO: "Lesotho",
388
+ LBR: "Liberia",
389
+ LBY: "Libya",
390
+ LIE: "Liechtenstein",
391
+ LTU: "Liettua",
392
+ LUX: "Luxemburg",
393
+ MDG: "Madagaskar",
394
+ MWI: "Malawi",
395
+ MYS: "Malesia",
396
+ MDV: "Malediivit",
397
+ MLI: "Mali",
398
+ MLT: "Malta",
399
+ MHL: "Marshallinsaaret",
400
+ MRT: "Mauritania",
401
+ MUS: "Mauritius",
402
+ MEX: "Meksiko",
403
+ FSM: "Mikronesia",
404
+ MSR: "Montserrat",
405
+ MDA: "Moldova",
406
+ MCO: "Monaco",
407
+ MNG: "Mongolia",
408
+ MNE: "Montenegro",
409
+ MAR: "Marokko",
410
+ MOZ: "Mosambik",
411
+ MMR: "Myanmar",
412
+ NAM: "Namibia",
413
+ NRU: "Nauru",
414
+ NPL: "Nepal",
415
+ NLD: "Alankomaat",
416
+ NZL: "Uusi-Seelanti",
417
+ NIC: "Nicaragua",
418
+ NER: "Niger",
419
+ NGA: "Nigeria",
420
+ MKD: "Pohjois-Makedonia",
421
+ NOR: "Norja",
422
+ OMN: "Oman",
423
+ PAK: "Pakistan",
424
+ PLW: "Palau",
425
+ PAN: "Panama",
426
+ PNG: "Papua-Uusi-Guinea",
427
+ PRY: "Paraguay",
428
+ PER: "Peru",
429
+ PHL: "Filippiinit",
430
+ POL: "Puola",
431
+ PRT: "Portugali",
432
+ QAT: "Qatar",
433
+ ROU: "Romania",
434
+ RUS: "Venäjä",
435
+ RWA: "Ruanda",
436
+ KNA: "Saint Kitts ja Nevis",
437
+ LCA: "Saint Lucia",
438
+ VCT: "Saint Vincent ja Grenadiinit",
439
+ WSM: "Samoa",
440
+ SMR: "San Marino",
441
+ STP: "São Tomé ja Príncipe",
442
+ SAU: "Saudi-Arabia",
443
+ SEN: "Senegal",
444
+ SRB: "Serbia",
445
+ SYC: "Seychellit",
446
+ SLE: "Sierra Leone",
447
+ SGP: "Singapore",
448
+ SXM: "Sint Maarten",
449
+ SVK: "Slovakia",
450
+ SVN: "Slovenia",
451
+ SLB: "Salomonsaaret",
452
+ SOM: "Somalia",
453
+ ZAF: "Etelä-Afrikka",
454
+ KOR: "Etelä-Korea",
455
+ SSD: "Etelä-Sudan",
456
+ ESP: "Espanja",
457
+ LKA: "Sri Lanka",
458
+ SDN: "Sudan",
459
+ SUR: "Suriname",
460
+ SWE: "Ruotsi",
461
+ CHE: "Sveitsi",
462
+ SYR: "Syyria",
463
+ TWN: "Taiwan",
464
+ TJK: "Tadžikistan",
465
+ TZA: "Tansania",
466
+ THA: "Thaimaa",
467
+ TLS: "Itä-Timor",
468
+ TGO: "Togo",
469
+ TON: "Tonga",
470
+ TTO: "Trinidad ja Tobago",
471
+ TUN: "Tunisia",
472
+ TUR: "Turkki",
473
+ TKM: "Turkmenistan",
474
+ TCA: "Turks- ja Caicossaaret",
475
+ UGA: "Uganda",
476
+ UKR: "Ukraina",
477
+ ARE: "Arabiemiirikunnat",
478
+ GBR: "Yhdistynyt kuningaskunta",
479
+ USA: "Yhdysvallat",
480
+ URY: "Uruguay",
481
+ UZB: "Uzbekistan",
482
+ VUT: "Vanuatu",
483
+ VEN: "Venezuela",
484
+ VNM: "Vietnam",
485
+ VGB: "Brittiläiset Neitsytsaaret",
486
+ YEM: "Jemen",
487
+ ZMB: "Sambia",
488
+ ZWE: "Zimbabwe"
104
489
  };
105
490
  var no = {
106
491
  "dataexplorer-search-datasets": "ikke oversatt",
@@ -140,7 +525,199 @@ var no = {
140
525
  "contacts-organisation": "ikke oversatt",
141
526
  "contacts-hours-of-service": "ikke oversatt",
142
527
  "contacts-contact-instructions": "ikke oversatt",
143
- "contacts-telephone": "ikke oversatt"
528
+ "contacts-telephone": "ikke oversatt",
529
+ AFG: "Afghanistan",
530
+ AIA: "Anguilla",
531
+ ALB: "Albania",
532
+ DZA: "Algerie",
533
+ AND: "Andorra",
534
+ AGO: "Angola",
535
+ ATG: "Antigua og Barbuda",
536
+ ARG: "Argentina",
537
+ ARM: "Armenia",
538
+ AUS: "Australia",
539
+ AUT: "Østerrike",
540
+ AZE: "Aserbajdsjan",
541
+ BHS: "Bahamas",
542
+ BHR: "Bahrain",
543
+ BGD: "Bangladesh",
544
+ BRB: "Barbados",
545
+ BLR: "Hviterussland",
546
+ BEL: "Belgia",
547
+ BLZ: "Belize",
548
+ BEN: "Benin",
549
+ BTN: "Bhutan",
550
+ BOL: "Bolivia",
551
+ BIH: "Bosnia-Hercegovina",
552
+ BWA: "Botswana",
553
+ BRA: "Brasil",
554
+ BRN: "Brunei",
555
+ BGR: "Bulgaria",
556
+ BFA: "Burkina Faso",
557
+ BDI: "Burundi",
558
+ COD: "Den demokratiske republikken Kongo",
559
+ COG: "Republikken Kongo",
560
+ TCD: "Tsjad",
561
+ CHL: "Chile",
562
+ CMR: "Kamerun",
563
+ CAN: "Canada",
564
+ CRI: "Costa Rica",
565
+ HRV: "Kroatia",
566
+ CUB: "Cuba",
567
+ CYM: "Caymanøyene",
568
+ CYP: "Kypros",
569
+ CZE: "Tsjekkia",
570
+ DNK: "Danmark",
571
+ DJI: "Djibouti",
572
+ DMA: "Dominica",
573
+ DOM: "Den dominikanske republikk",
574
+ ECU: "Ecuador",
575
+ EGY: "Egypt",
576
+ SLV: "El Salvador",
577
+ GNQ: "Ekvatorial-Guinea",
578
+ ERI: "Eritrea",
579
+ EST: "Estland",
580
+ SWZ: "Eswatini",
581
+ ETH: "Etiopia",
582
+ FJI: "Fiji",
583
+ FIN: "Finland",
584
+ FRA: "Frankrike",
585
+ GAB: "Gabon",
586
+ GMB: "Gambia",
587
+ GEO: "Georgia",
588
+ DEU: "Tyskland",
589
+ GHA: "Ghana",
590
+ GRC: "Hellas",
591
+ GRD: "Grenada",
592
+ GTM: "Guatemala",
593
+ GIN: "Guinea",
594
+ GNB: "Guinea-Bissau",
595
+ GUY: "Guyana",
596
+ HKG: "Hongkong",
597
+ HTI: "Haiti",
598
+ HND: "Honduras",
599
+ HUN: "Ungarn",
600
+ ISL: "Island",
601
+ IND: "India",
602
+ IDN: "Indonesia",
603
+ IRN: "Iran",
604
+ IRQ: "Irak",
605
+ IRL: "Irland",
606
+ ISR: "Israel",
607
+ ITA: "Italia",
608
+ JAM: "Jamaica",
609
+ JPN: "Japan",
610
+ JOR: "Jordan",
611
+ KAZ: "Kasakhstan",
612
+ KEN: "Kenya",
613
+ KIR: "Kiribati",
614
+ KWT: "Kuwait",
615
+ KGZ: "Kirgisistan",
616
+ LAO: "Laos",
617
+ LVA: "Latvia",
618
+ LBN: "Libanon",
619
+ LSO: "Lesotho",
620
+ LBR: "Liberia",
621
+ LBY: "Libya",
622
+ LIE: "Liechtenstein",
623
+ LTU: "Litauen",
624
+ LUX: "Luxembourg",
625
+ MDG: "Madagaskar",
626
+ MWI: "Malawi",
627
+ MYS: "Malaysia",
628
+ MDV: "Maldivene",
629
+ MLI: "Mali",
630
+ MLT: "Malta",
631
+ MHL: "Marshalløyene",
632
+ MRT: "Mauritania",
633
+ MUS: "Mauritius",
634
+ MEX: "Mexico",
635
+ FSM: "Mikronesia",
636
+ MSR: "Montserrat",
637
+ MDA: "Moldova",
638
+ MCO: "Monaco",
639
+ MNG: "Mongolia",
640
+ MNE: "Montenegro",
641
+ MAR: "Marokko",
642
+ MOZ: "Mosambik",
643
+ MMR: "Myanmar",
644
+ NAM: "Namibia",
645
+ NRU: "Nauru",
646
+ NPL: "Nepal",
647
+ NLD: "Nederland",
648
+ NZL: "New Zealand",
649
+ NIC: "Nicaragua",
650
+ NER: "Niger",
651
+ NGA: "Nigeria",
652
+ MKD: "Nord-Makedonia",
653
+ NOR: "Norge",
654
+ OMN: "Oman",
655
+ PAK: "Pakistan",
656
+ PLW: "Palau",
657
+ PAN: "Panama",
658
+ PNG: "Papua Ny-Guinea",
659
+ PRY: "Paraguay",
660
+ PER: "Peru",
661
+ PHL: "Filippinene",
662
+ POL: "Polen",
663
+ PRT: "Portugal",
664
+ QAT: "Qatar",
665
+ ROU: "Romania",
666
+ RUS: "Russland",
667
+ RWA: "Rwanda",
668
+ KNA: "Saint Kitts og Nevis",
669
+ LCA: "Saint Lucia",
670
+ VCT: "Saint Vincent og Grenadinene",
671
+ WSM: "Samoa",
672
+ SMR: "San Marino",
673
+ STP: "São Tomé og Príncipe",
674
+ SAU: "Saudi-Arabia",
675
+ SEN: "Senegal",
676
+ SRB: "Serbia",
677
+ SYC: "Seychellene",
678
+ SLE: "Sierra Leone",
679
+ SGP: "Singapore",
680
+ SXM: "Sint Maarten",
681
+ SVK: "Slovakia",
682
+ SVN: "Slovenia",
683
+ SLB: "Salomonøyene",
684
+ SOM: "Somalia",
685
+ ZAF: "Sør-Afrika",
686
+ KOR: "Sør-Korea",
687
+ SSD: "Sør-Sudan",
688
+ ESP: "Spania",
689
+ LKA: "Sri Lanka",
690
+ SDN: "Sudan",
691
+ SUR: "Surinam",
692
+ SWE: "Sverige",
693
+ CHE: "Sveits",
694
+ SYR: "Syria",
695
+ TWN: "Taiwan",
696
+ TJK: "Tadsjikistan",
697
+ TZA: "Tanzania",
698
+ THA: "Thailand",
699
+ TLS: "Øst-Timor",
700
+ TGO: "Togo",
701
+ TON: "Tonga",
702
+ TTO: "Trinidad og Tobago",
703
+ TUN: "Tunisia",
704
+ TUR: "Tyrkia",
705
+ TKM: "Turkmenistan",
706
+ TCA: "Turks- og Caicosøyene",
707
+ UGA: "Uganda",
708
+ UKR: "Ukraina",
709
+ ARE: "De forente arabiske emirater",
710
+ GBR: "Storbritannia",
711
+ USA: "USA",
712
+ URY: "Uruguay",
713
+ UZB: "Usbekistan",
714
+ VUT: "Vanuatu",
715
+ VEN: "Venezuela",
716
+ VNM: "Vietnam",
717
+ VGB: "De britiske jomfruøyene",
718
+ YEM: "Jemen",
719
+ ZMB: "Zambia",
720
+ ZWE: "Zimbabwe"
144
721
  };
145
722
  var nl = {
146
723
  "dataexplorer-search-datasets": "niet vertaald",
@@ -180,7 +757,199 @@ var nl = {
180
757
  "contacts-organisation": "niet vertaald",
181
758
  "contacts-hours-of-service": "niet vertaald",
182
759
  "contacts-contact-instructions": "niet vertaald",
183
- "contacts-telephone": "niet vertaald"
760
+ "contacts-telephone": "niet vertaald",
761
+ AFG: "Afghanistan",
762
+ AIA: "Anguilla",
763
+ ALB: "Albanië",
764
+ DZA: "Algerije",
765
+ AND: "Andorra",
766
+ AGO: "Angola",
767
+ ATG: "Antigua en Barbuda",
768
+ ARG: "Argentinië",
769
+ ARM: "Armenië",
770
+ AUS: "Australië",
771
+ AUT: "Oostenrijk",
772
+ AZE: "Azerbeidzjan",
773
+ BHS: "Bahama's",
774
+ BHR: "Bahrein",
775
+ BGD: "Bangladesh",
776
+ BRB: "Barbados",
777
+ BLR: "Wit-Rusland",
778
+ BEL: "België",
779
+ BLZ: "Belize",
780
+ BEN: "Benin",
781
+ BTN: "Bhutan",
782
+ BOL: "Bolivia",
783
+ BIH: "Bosnië en Herzegovina",
784
+ BWA: "Botswana",
785
+ BRA: "Brazilië",
786
+ BRN: "Brunei",
787
+ BGR: "Bulgarije",
788
+ BFA: "Burkina Faso",
789
+ BDI: "Burundi",
790
+ CAN: "Canada",
791
+ COD: "Congo, Democratische Republiek",
792
+ COG: "Congo",
793
+ TCD: "Tsjaad",
794
+ CHL: "Chili",
795
+ CMR: "Kameroen",
796
+ CRI: "Costa Rica",
797
+ HRV: "Kroatië",
798
+ CUB: "Cuba",
799
+ CYM: "Caymaneilanden",
800
+ CYP: "Cyprus",
801
+ CZE: "Tsjechië",
802
+ DNK: "Denemarken",
803
+ DJI: "Djibouti",
804
+ DMA: "Dominica",
805
+ DOM: "Dominicaanse Republiek",
806
+ ECU: "Ecuador",
807
+ EGY: "Egypte",
808
+ SLV: "El Salvador",
809
+ GNQ: "Equatoriaal-Guinea",
810
+ ERI: "Eritrea",
811
+ EST: "Estland",
812
+ SWZ: "Eswatini",
813
+ ETH: "Ethiopië",
814
+ FJI: "Fiji",
815
+ FIN: "Finland",
816
+ FRA: "Frankrijk",
817
+ GAB: "Gabon",
818
+ GMB: "Gambia",
819
+ GEO: "Georgië",
820
+ DEU: "Duitsland",
821
+ GHA: "Ghana",
822
+ GRC: "Griekenland",
823
+ GRD: "Grenada",
824
+ GTM: "Guatemala",
825
+ GIN: "Guinee",
826
+ GNB: "Guinee-Bissau",
827
+ GUY: "Guyana",
828
+ HKG: "Hongkong",
829
+ HTI: "Haïti",
830
+ HND: "Honduras",
831
+ HUN: "Hongarije",
832
+ ISL: "IJsland",
833
+ IND: "India",
834
+ IDN: "Indonesië",
835
+ IRN: "Iran",
836
+ IRQ: "Irak",
837
+ IRL: "Ierland",
838
+ ISR: "Israël",
839
+ ITA: "Italië",
840
+ JAM: "Jamaica",
841
+ JPN: "Japan",
842
+ JOR: "Jordanië",
843
+ KAZ: "Kazachstan",
844
+ KEN: "Kenia",
845
+ KIR: "Kiribati",
846
+ KWT: "Koeweit",
847
+ KGZ: "Kirgizië",
848
+ LAO: "Laos",
849
+ LVA: "Letland",
850
+ LBN: "Libanon",
851
+ LSO: "Lesotho",
852
+ LBR: "Liberia",
853
+ LBY: "Libië",
854
+ LIE: "Liechtenstein",
855
+ LTU: "Litouwen",
856
+ LUX: "Luxemburg",
857
+ MDG: "Madagaskar",
858
+ MWI: "Malawi",
859
+ MYS: "Maleisië",
860
+ MDV: "Maldiven",
861
+ MLI: "Mali",
862
+ MLT: "Malta",
863
+ MHL: "Marshalleilanden",
864
+ MRT: "Mauritanië",
865
+ MUS: "Mauritius",
866
+ MEX: "Mexico",
867
+ FSM: "Micronesië",
868
+ MSR: "Montserrat",
869
+ MDA: "Moldavië",
870
+ MCO: "Monaco",
871
+ MNG: "Mongolië",
872
+ MNE: "Montenegro",
873
+ MAR: "Marokko",
874
+ MOZ: "Mozambique",
875
+ MMR: "Myanmar",
876
+ NAM: "Namibië",
877
+ NRU: "Nauru",
878
+ NPL: "Nepal",
879
+ NLD: "Nederland",
880
+ NZL: "Nieuw-Zeeland",
881
+ NIC: "Nicaragua",
882
+ NER: "Niger",
883
+ NGA: "Nigeria",
884
+ MKD: "Noord-Macedonië",
885
+ NOR: "Noorwegen",
886
+ OMN: "Oman",
887
+ PAK: "Pakistan",
888
+ PLW: "Palau",
889
+ PAN: "Panama",
890
+ PNG: "Papoea-Nieuw-Guinea",
891
+ PRY: "Paraguay",
892
+ PER: "Peru",
893
+ PHL: "Filipijnen",
894
+ POL: "Polen",
895
+ PRT: "Portugal",
896
+ QAT: "Qatar",
897
+ ROU: "Roemenië",
898
+ RUS: "Rusland",
899
+ RWA: "Rwanda",
900
+ KNA: "Saint Kitts en Nevis",
901
+ LCA: "Saint Lucia",
902
+ VCT: "Saint Vincent en de Grenadines",
903
+ WSM: "Samoa",
904
+ SMR: "San Marino",
905
+ STP: "Sao Tomé en Principe",
906
+ SAU: "Saoedi-Arabië",
907
+ SEN: "Senegal",
908
+ SRB: "Servië",
909
+ SYC: "Seychellen",
910
+ SLE: "Sierra Leone",
911
+ SGP: "Singapore",
912
+ SXM: "Sint Maarten",
913
+ SVK: "Slowakije",
914
+ SVN: "Slovenië",
915
+ SLB: "Salomonseilanden",
916
+ SOM: "Somalië",
917
+ ZAF: "Zuid-Afrika",
918
+ KOR: "Zuid-Korea",
919
+ SSD: "Zuid-Soedan",
920
+ ESP: "Spanje",
921
+ LKA: "Sri Lanka",
922
+ SDN: "Soedan",
923
+ SUR: "Suriname",
924
+ SWE: "Zweden",
925
+ CHE: "Zwitserland",
926
+ SYR: "Syrië",
927
+ TWN: "Taiwan",
928
+ TJK: "Tadzjikistan",
929
+ TZA: "Tanzania",
930
+ THA: "Thailand",
931
+ TLS: "Oost-Timor",
932
+ TGO: "Togo",
933
+ TON: "Tonga",
934
+ TTO: "Trinidad en Tobago",
935
+ TUN: "Tunesië",
936
+ TUR: "Turkije",
937
+ TKM: "Turkmenistan",
938
+ TCA: "Turks- en Caicoseilanden",
939
+ UGA: "Oeganda",
940
+ UKR: "Oekraïne",
941
+ ARE: "Verenigde Arabische Emiraten",
942
+ GBR: "Verenigd Koninkrijk",
943
+ USA: "Verenigde Staten",
944
+ URY: "Uruguay",
945
+ UZB: "Oezbekistan",
946
+ VUT: "Vanuatu",
947
+ VEN: "Venezuela",
948
+ VNM: "Vietnam",
949
+ VGB: "Britse Maagdeneilanden",
950
+ YEM: "Jemen",
951
+ ZMB: "Zambia",
952
+ ZWE: "Zimbabwe"
184
953
  };
185
954
  var dataexplorerTranslations = {
186
955
  en: en,
@@ -215,6 +984,7 @@ const getQueryableConfigurations = createSelector(getDataExplorerState, store =>
215
984
  const getConcepts = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.filters.concepts) || []);
216
985
  const getSelectedDatasetId = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.selectedDatasetId) || '');
217
986
  const getDiscoveryCatalogueURL = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.discoveryCatalogueURL) || '');
987
+ createSelector(getDataExplorerState, store => (store == null ? void 0 : store.filters.wmsbox) || []);
218
988
  const getBbox = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.filters.bbox) || []);
219
989
  const getAreaFilterTileURL = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.areaFilterTileURL) || '');
220
990
  const getAreaFilterTileLicense = createSelector(getDataExplorerState, store => (store == null ? void 0 : store.areaFilterTileLicense) || '');
@@ -267,7 +1037,7 @@ var globalThis_1 =
267
1037
 
268
1038
  var objectGetOwnPropertyDescriptor = {};
269
1039
 
270
- var fails$p = function (exec) {
1040
+ var fails$q = function (exec) {
271
1041
  try {
272
1042
  return !!exec();
273
1043
  } catch (error) {
@@ -275,17 +1045,17 @@ var fails$p = function (exec) {
275
1045
  }
276
1046
  };
277
1047
 
278
- var fails$o = fails$p;
1048
+ var fails$p = fails$q;
279
1049
 
280
1050
  // Detect IE8's incomplete defineProperty implementation
281
- var descriptors = !fails$o(function () {
1051
+ var descriptors = !fails$p(function () {
282
1052
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
283
1053
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
284
1054
  });
285
1055
 
286
- var fails$n = fails$p;
1056
+ var fails$o = fails$q;
287
1057
 
288
- var functionBindNative = !fails$n(function () {
1058
+ var functionBindNative = !fails$o(function () {
289
1059
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
290
1060
  var test = (function () { /* empty */ }).bind();
291
1061
  // eslint-disable-next-line no-prototype-builtins -- safe
@@ -294,10 +1064,10 @@ var functionBindNative = !fails$n(function () {
294
1064
 
295
1065
  var NATIVE_BIND$3 = functionBindNative;
296
1066
 
297
- var call$m = Function.prototype.call;
1067
+ var call$n = Function.prototype.call;
298
1068
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
299
- var functionCall = NATIVE_BIND$3 ? call$m.bind(call$m) : function () {
300
- return call$m.apply(call$m, arguments);
1069
+ var functionCall = NATIVE_BIND$3 ? call$n.bind(call$n) : function () {
1070
+ return call$n.apply(call$n, arguments);
301
1071
  };
302
1072
 
303
1073
  var objectPropertyIsEnumerable = {};
@@ -328,34 +1098,34 @@ var createPropertyDescriptor$5 = function (bitmap, value) {
328
1098
  var NATIVE_BIND$2 = functionBindNative;
329
1099
 
330
1100
  var FunctionPrototype$2 = Function.prototype;
331
- var call$l = FunctionPrototype$2.call;
1101
+ var call$m = FunctionPrototype$2.call;
332
1102
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
333
- var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$l, call$l);
1103
+ var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$m, call$m);
334
1104
 
335
1105
  var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
336
1106
  return function () {
337
- return call$l.apply(fn, arguments);
1107
+ return call$m.apply(fn, arguments);
338
1108
  };
339
1109
  };
340
1110
 
341
- var uncurryThis$u = functionUncurryThis;
1111
+ var uncurryThis$v = functionUncurryThis;
342
1112
 
343
- var toString$d = uncurryThis$u({}.toString);
344
- var stringSlice$9 = uncurryThis$u(''.slice);
1113
+ var toString$e = uncurryThis$v({}.toString);
1114
+ var stringSlice$a = uncurryThis$v(''.slice);
345
1115
 
346
1116
  var classofRaw$2 = function (it) {
347
- return stringSlice$9(toString$d(it), 8, -1);
1117
+ return stringSlice$a(toString$e(it), 8, -1);
348
1118
  };
349
1119
 
350
- var uncurryThis$t = functionUncurryThis;
351
- var fails$m = fails$p;
1120
+ var uncurryThis$u = functionUncurryThis;
1121
+ var fails$n = fails$q;
352
1122
  var classof$9 = classofRaw$2;
353
1123
 
354
1124
  var $Object$4 = Object;
355
- var split$3 = uncurryThis$t(''.split);
1125
+ var split$3 = uncurryThis$u(''.split);
356
1126
 
357
1127
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
358
- var indexedObject = fails$m(function () {
1128
+ var indexedObject = fails$n(function () {
359
1129
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
360
1130
  // eslint-disable-next-line no-prototype-builtins -- safe
361
1131
  return !$Object$4('z').propertyIsEnumerable(0);
@@ -375,17 +1145,17 @@ var $TypeError$h = TypeError;
375
1145
 
376
1146
  // `RequireObjectCoercible` abstract operation
377
1147
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
378
- var requireObjectCoercible$8 = function (it) {
1148
+ var requireObjectCoercible$9 = function (it) {
379
1149
  if (isNullOrUndefined$3(it)) throw new $TypeError$h("Can't call method on " + it);
380
1150
  return it;
381
1151
  };
382
1152
 
383
1153
  // toObject with fallback for non-array-like ES3 strings
384
1154
  var IndexedObject$1 = indexedObject;
385
- var requireObjectCoercible$7 = requireObjectCoercible$8;
1155
+ var requireObjectCoercible$8 = requireObjectCoercible$9;
386
1156
 
387
1157
  var toIndexedObject$5 = function (it) {
388
- return IndexedObject$1(requireObjectCoercible$7(it));
1158
+ return IndexedObject$1(requireObjectCoercible$8(it));
389
1159
  };
390
1160
 
391
1161
  // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
@@ -402,7 +1172,7 @@ var isCallable$n = typeof documentAll == 'undefined' && documentAll !== undefine
402
1172
 
403
1173
  var isCallable$m = isCallable$n;
404
1174
 
405
- var isObject$f = function (it) {
1175
+ var isObject$g = function (it) {
406
1176
  return typeof it == 'object' ? it !== null : isCallable$m(it);
407
1177
  };
408
1178
 
@@ -417,9 +1187,9 @@ var getBuiltIn$8 = function (namespace, method) {
417
1187
  return arguments.length < 2 ? aFunction(globalThis$r[namespace]) : globalThis$r[namespace] && globalThis$r[namespace][method];
418
1188
  };
419
1189
 
420
- var uncurryThis$s = functionUncurryThis;
1190
+ var uncurryThis$t = functionUncurryThis;
421
1191
 
422
- var objectIsPrototypeOf = uncurryThis$s({}.isPrototypeOf);
1192
+ var objectIsPrototypeOf = uncurryThis$t({}.isPrototypeOf);
423
1193
 
424
1194
  var globalThis$q = globalThis_1;
425
1195
 
@@ -458,13 +1228,13 @@ var environmentV8Version = version;
458
1228
 
459
1229
  /* eslint-disable es/no-symbol -- required for testing */
460
1230
  var V8_VERSION$1 = environmentV8Version;
461
- var fails$l = fails$p;
1231
+ var fails$m = fails$q;
462
1232
  var globalThis$o = globalThis_1;
463
1233
 
464
1234
  var $String$5 = globalThis$o.String;
465
1235
 
466
1236
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
467
- var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$l(function () {
1237
+ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$m(function () {
468
1238
  var symbol = Symbol('symbol detection');
469
1239
  // Chrome 38 Symbol has incorrect toString conversion
470
1240
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
@@ -522,14 +1292,14 @@ var isNullOrUndefined$2 = isNullOrUndefined$4;
522
1292
 
523
1293
  // `GetMethod` abstract operation
524
1294
  // https://tc39.es/ecma262/#sec-getmethod
525
- var getMethod$5 = function (V, P) {
1295
+ var getMethod$6 = function (V, P) {
526
1296
  var func = V[P];
527
1297
  return isNullOrUndefined$2(func) ? undefined : aCallable$9(func);
528
1298
  };
529
1299
 
530
- var call$k = functionCall;
1300
+ var call$l = functionCall;
531
1301
  var isCallable$i = isCallable$n;
532
- var isObject$e = isObject$f;
1302
+ var isObject$f = isObject$g;
533
1303
 
534
1304
  var $TypeError$f = TypeError;
535
1305
 
@@ -537,9 +1307,9 @@ var $TypeError$f = TypeError;
537
1307
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
538
1308
  var ordinaryToPrimitive$1 = function (input, pref) {
539
1309
  var fn, val;
540
- if (pref === 'string' && isCallable$i(fn = input.toString) && !isObject$e(val = call$k(fn, input))) return val;
541
- if (isCallable$i(fn = input.valueOf) && !isObject$e(val = call$k(fn, input))) return val;
542
- if (pref !== 'string' && isCallable$i(fn = input.toString) && !isObject$e(val = call$k(fn, input))) return val;
1310
+ if (pref === 'string' && isCallable$i(fn = input.toString) && !isObject$f(val = call$l(fn, input))) return val;
1311
+ if (isCallable$i(fn = input.valueOf) && !isObject$f(val = call$l(fn, input))) return val;
1312
+ if (pref !== 'string' && isCallable$i(fn = input.toString) && !isObject$f(val = call$l(fn, input))) return val;
543
1313
  throw new $TypeError$f("Can't convert object to primitive value");
544
1314
  };
545
1315
 
@@ -582,20 +1352,20 @@ var shared$4 = function (key, value) {
582
1352
  return store$2[key] || (store$2[key] = value || {});
583
1353
  };
584
1354
 
585
- var requireObjectCoercible$6 = requireObjectCoercible$8;
1355
+ var requireObjectCoercible$7 = requireObjectCoercible$9;
586
1356
 
587
1357
  var $Object$2 = Object;
588
1358
 
589
1359
  // `ToObject` abstract operation
590
1360
  // https://tc39.es/ecma262/#sec-toobject
591
1361
  var toObject$9 = function (argument) {
592
- return $Object$2(requireObjectCoercible$6(argument));
1362
+ return $Object$2(requireObjectCoercible$7(argument));
593
1363
  };
594
1364
 
595
- var uncurryThis$r = functionUncurryThis;
1365
+ var uncurryThis$s = functionUncurryThis;
596
1366
  var toObject$8 = toObject$9;
597
1367
 
598
- var hasOwnProperty = uncurryThis$r({}.hasOwnProperty);
1368
+ var hasOwnProperty = uncurryThis$s({}.hasOwnProperty);
599
1369
 
600
1370
  // `HasOwnProperty` abstract operation
601
1371
  // https://tc39.es/ecma262/#sec-hasownproperty
@@ -604,14 +1374,14 @@ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
604
1374
  return hasOwnProperty(toObject$8(it), key);
605
1375
  };
606
1376
 
607
- var uncurryThis$q = functionUncurryThis;
1377
+ var uncurryThis$r = functionUncurryThis;
608
1378
 
609
1379
  var id = 0;
610
1380
  var postfix = Math.random();
611
- var toString$c = uncurryThis$q(1.1.toString);
1381
+ var toString$d = uncurryThis$r(1.1.toString);
612
1382
 
613
1383
  var uid$2 = function (key) {
614
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$c(++id + postfix, 36);
1384
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$d(++id + postfix, 36);
615
1385
  };
616
1386
 
617
1387
  var globalThis$l = globalThis_1;
@@ -633,10 +1403,10 @@ var wellKnownSymbol$l = function (name) {
633
1403
  } return WellKnownSymbolsStore[name];
634
1404
  };
635
1405
 
636
- var call$j = functionCall;
637
- var isObject$d = isObject$f;
1406
+ var call$k = functionCall;
1407
+ var isObject$e = isObject$g;
638
1408
  var isSymbol$1 = isSymbol$2;
639
- var getMethod$4 = getMethod$5;
1409
+ var getMethod$5 = getMethod$6;
640
1410
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
641
1411
  var wellKnownSymbol$k = wellKnownSymbol$l;
642
1412
 
@@ -646,13 +1416,13 @@ var TO_PRIMITIVE = wellKnownSymbol$k('toPrimitive');
646
1416
  // `ToPrimitive` abstract operation
647
1417
  // https://tc39.es/ecma262/#sec-toprimitive
648
1418
  var toPrimitive$1 = function (input, pref) {
649
- if (!isObject$d(input) || isSymbol$1(input)) return input;
650
- var exoticToPrim = getMethod$4(input, TO_PRIMITIVE);
1419
+ if (!isObject$e(input) || isSymbol$1(input)) return input;
1420
+ var exoticToPrim = getMethod$5(input, TO_PRIMITIVE);
651
1421
  var result;
652
1422
  if (exoticToPrim) {
653
1423
  if (pref === undefined) pref = 'default';
654
- result = call$j(exoticToPrim, input, pref);
655
- if (!isObject$d(result) || isSymbol$1(result)) return result;
1424
+ result = call$k(exoticToPrim, input, pref);
1425
+ if (!isObject$e(result) || isSymbol$1(result)) return result;
656
1426
  throw new $TypeError$e("Can't convert object to primitive value");
657
1427
  }
658
1428
  if (pref === undefined) pref = 'number';
@@ -670,22 +1440,22 @@ var toPropertyKey$2 = function (argument) {
670
1440
  };
671
1441
 
672
1442
  var globalThis$k = globalThis_1;
673
- var isObject$c = isObject$f;
1443
+ var isObject$d = isObject$g;
674
1444
 
675
1445
  var document$3 = globalThis$k.document;
676
1446
  // typeof document.createElement is 'object' in old IE
677
- var EXISTS$1 = isObject$c(document$3) && isObject$c(document$3.createElement);
1447
+ var EXISTS$1 = isObject$d(document$3) && isObject$d(document$3.createElement);
678
1448
 
679
1449
  var documentCreateElement$2 = function (it) {
680
1450
  return EXISTS$1 ? document$3.createElement(it) : {};
681
1451
  };
682
1452
 
683
1453
  var DESCRIPTORS$i = descriptors;
684
- var fails$k = fails$p;
1454
+ var fails$l = fails$q;
685
1455
  var createElement$1 = documentCreateElement$2;
686
1456
 
687
1457
  // Thanks to IE8 for its funny defineProperty
688
- var ie8DomDefine = !DESCRIPTORS$i && !fails$k(function () {
1458
+ var ie8DomDefine = !DESCRIPTORS$i && !fails$l(function () {
689
1459
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
690
1460
  return Object.defineProperty(createElement$1('div'), 'a', {
691
1461
  get: function () { return 7; }
@@ -693,7 +1463,7 @@ var ie8DomDefine = !DESCRIPTORS$i && !fails$k(function () {
693
1463
  });
694
1464
 
695
1465
  var DESCRIPTORS$h = descriptors;
696
- var call$i = functionCall;
1466
+ var call$j = functionCall;
697
1467
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
698
1468
  var createPropertyDescriptor$4 = createPropertyDescriptor$5;
699
1469
  var toIndexedObject$4 = toIndexedObject$5;
@@ -712,17 +1482,17 @@ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$h ? $getOwnPropertyDescriptor$1 :
712
1482
  if (IE8_DOM_DEFINE$1) try {
713
1483
  return $getOwnPropertyDescriptor$1(O, P);
714
1484
  } catch (error) { /* empty */ }
715
- if (hasOwn$c(O, P)) return createPropertyDescriptor$4(!call$i(propertyIsEnumerableModule$1.f, O, P), O[P]);
1485
+ if (hasOwn$c(O, P)) return createPropertyDescriptor$4(!call$j(propertyIsEnumerableModule$1.f, O, P), O[P]);
716
1486
  };
717
1487
 
718
1488
  var objectDefineProperty = {};
719
1489
 
720
1490
  var DESCRIPTORS$g = descriptors;
721
- var fails$j = fails$p;
1491
+ var fails$k = fails$q;
722
1492
 
723
1493
  // V8 ~ Chrome 36-
724
1494
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
725
- var v8PrototypeDefineBug = DESCRIPTORS$g && fails$j(function () {
1495
+ var v8PrototypeDefineBug = DESCRIPTORS$g && fails$k(function () {
726
1496
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
727
1497
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
728
1498
  value: 42,
@@ -730,21 +1500,21 @@ var v8PrototypeDefineBug = DESCRIPTORS$g && fails$j(function () {
730
1500
  }).prototype !== 42;
731
1501
  });
732
1502
 
733
- var isObject$b = isObject$f;
1503
+ var isObject$c = isObject$g;
734
1504
 
735
1505
  var $String$3 = String;
736
1506
  var $TypeError$d = TypeError;
737
1507
 
738
1508
  // `Assert: Type(argument) is Object`
739
- var anObject$g = function (argument) {
740
- if (isObject$b(argument)) return argument;
1509
+ var anObject$h = function (argument) {
1510
+ if (isObject$c(argument)) return argument;
741
1511
  throw new $TypeError$d($String$3(argument) + ' is not an object');
742
1512
  };
743
1513
 
744
1514
  var DESCRIPTORS$f = descriptors;
745
1515
  var IE8_DOM_DEFINE = ie8DomDefine;
746
1516
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
747
- var anObject$f = anObject$g;
1517
+ var anObject$g = anObject$h;
748
1518
  var toPropertyKey = toPropertyKey$2;
749
1519
 
750
1520
  var $TypeError$c = TypeError;
@@ -759,9 +1529,9 @@ var WRITABLE = 'writable';
759
1529
  // `Object.defineProperty` method
760
1530
  // https://tc39.es/ecma262/#sec-object.defineproperty
761
1531
  objectDefineProperty.f = DESCRIPTORS$f ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
762
- anObject$f(O);
1532
+ anObject$g(O);
763
1533
  P = toPropertyKey(P);
764
- anObject$f(Attributes);
1534
+ anObject$g(Attributes);
765
1535
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
766
1536
  var current = $getOwnPropertyDescriptor(O, P);
767
1537
  if (current && current[WRITABLE]) {
@@ -774,9 +1544,9 @@ objectDefineProperty.f = DESCRIPTORS$f ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
774
1544
  }
775
1545
  } return $defineProperty(O, P, Attributes);
776
1546
  } : $defineProperty : function defineProperty(O, P, Attributes) {
777
- anObject$f(O);
1547
+ anObject$g(O);
778
1548
  P = toPropertyKey(P);
779
- anObject$f(Attributes);
1549
+ anObject$g(Attributes);
780
1550
  if (IE8_DOM_DEFINE) try {
781
1551
  return $defineProperty(O, P, Attributes);
782
1552
  } catch (error) { /* empty */ }
@@ -815,11 +1585,11 @@ var functionName = {
815
1585
  CONFIGURABLE: CONFIGURABLE
816
1586
  };
817
1587
 
818
- var uncurryThis$p = functionUncurryThis;
1588
+ var uncurryThis$q = functionUncurryThis;
819
1589
  var isCallable$h = isCallable$n;
820
1590
  var store$1 = sharedStoreExports;
821
1591
 
822
- var functionToString = uncurryThis$p(Function.toString);
1592
+ var functionToString = uncurryThis$q(Function.toString);
823
1593
 
824
1594
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
825
1595
  if (!isCallable$h(store$1.inspectSource)) {
@@ -850,7 +1620,7 @@ var hiddenKeys$4 = {};
850
1620
 
851
1621
  var NATIVE_WEAK_MAP = weakMapBasicDetection;
852
1622
  var globalThis$i = globalThis_1;
853
- var isObject$a = isObject$f;
1623
+ var isObject$b = isObject$g;
854
1624
  var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
855
1625
  var hasOwn$a = hasOwnProperty_1;
856
1626
  var shared$1 = sharedStoreExports;
@@ -869,7 +1639,7 @@ var enforce = function (it) {
869
1639
  var getterFor = function (TYPE) {
870
1640
  return function (it) {
871
1641
  var state;
872
- if (!isObject$a(it) || (state = get(it)).type !== TYPE) {
1642
+ if (!isObject$b(it) || (state = get(it)).type !== TYPE) {
873
1643
  throw new TypeError$4('Incompatible receiver, ' + TYPE + ' required');
874
1644
  } return state;
875
1645
  };
@@ -919,8 +1689,8 @@ var internalState = {
919
1689
  getterFor: getterFor
920
1690
  };
921
1691
 
922
- var uncurryThis$o = functionUncurryThis;
923
- var fails$i = fails$p;
1692
+ var uncurryThis$p = functionUncurryThis;
1693
+ var fails$j = fails$q;
924
1694
  var isCallable$f = isCallable$n;
925
1695
  var hasOwn$9 = hasOwnProperty_1;
926
1696
  var DESCRIPTORS$c = descriptors;
@@ -933,18 +1703,18 @@ var getInternalState$3 = InternalStateModule$5.get;
933
1703
  var $String$2 = String;
934
1704
  // eslint-disable-next-line es/no-object-defineproperty -- safe
935
1705
  var defineProperty$5 = Object.defineProperty;
936
- var stringSlice$8 = uncurryThis$o(''.slice);
937
- var replace$6 = uncurryThis$o(''.replace);
938
- var join$4 = uncurryThis$o([].join);
1706
+ var stringSlice$9 = uncurryThis$p(''.slice);
1707
+ var replace$6 = uncurryThis$p(''.replace);
1708
+ var join$4 = uncurryThis$p([].join);
939
1709
 
940
- var CONFIGURABLE_LENGTH = DESCRIPTORS$c && !fails$i(function () {
1710
+ var CONFIGURABLE_LENGTH = DESCRIPTORS$c && !fails$j(function () {
941
1711
  return defineProperty$5(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
942
1712
  });
943
1713
 
944
1714
  var TEMPLATE = String(String).split('String');
945
1715
 
946
1716
  var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
947
- if (stringSlice$8($String$2(name), 0, 7) === 'Symbol(') {
1717
+ if (stringSlice$9($String$2(name), 0, 7) === 'Symbol(') {
948
1718
  name = '[' + replace$6($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
949
1719
  }
950
1720
  if (options && options.getter) name = 'get ' + name;
@@ -1030,33 +1800,33 @@ var toIntegerOrInfinity$5 = function (argument) {
1030
1800
  var toIntegerOrInfinity$4 = toIntegerOrInfinity$5;
1031
1801
 
1032
1802
  var max$1 = Math.max;
1033
- var min$3 = Math.min;
1803
+ var min$4 = Math.min;
1034
1804
 
1035
1805
  // Helper for a popular repeating case of the spec:
1036
1806
  // Let integer be ? ToInteger(index).
1037
1807
  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1038
1808
  var toAbsoluteIndex$2 = function (index, length) {
1039
1809
  var integer = toIntegerOrInfinity$4(index);
1040
- return integer < 0 ? max$1(integer + length, 0) : min$3(integer, length);
1810
+ return integer < 0 ? max$1(integer + length, 0) : min$4(integer, length);
1041
1811
  };
1042
1812
 
1043
1813
  var toIntegerOrInfinity$3 = toIntegerOrInfinity$5;
1044
1814
 
1045
- var min$2 = Math.min;
1815
+ var min$3 = Math.min;
1046
1816
 
1047
1817
  // `ToLength` abstract operation
1048
1818
  // https://tc39.es/ecma262/#sec-tolength
1049
- var toLength$4 = function (argument) {
1819
+ var toLength$5 = function (argument) {
1050
1820
  var len = toIntegerOrInfinity$3(argument);
1051
- return len > 0 ? min$2(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1821
+ return len > 0 ? min$3(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1052
1822
  };
1053
1823
 
1054
- var toLength$3 = toLength$4;
1824
+ var toLength$4 = toLength$5;
1055
1825
 
1056
1826
  // `LengthOfArrayLike` abstract operation
1057
1827
  // https://tc39.es/ecma262/#sec-lengthofarraylike
1058
1828
  var lengthOfArrayLike$8 = function (obj) {
1059
- return toLength$3(obj.length);
1829
+ return toLength$4(obj.length);
1060
1830
  };
1061
1831
 
1062
1832
  var toIndexedObject$3 = toIndexedObject$5;
@@ -1093,23 +1863,23 @@ var arrayIncludes = {
1093
1863
  indexOf: createMethod$1(false)
1094
1864
  };
1095
1865
 
1096
- var uncurryThis$n = functionUncurryThis;
1866
+ var uncurryThis$o = functionUncurryThis;
1097
1867
  var hasOwn$8 = hasOwnProperty_1;
1098
1868
  var toIndexedObject$2 = toIndexedObject$5;
1099
1869
  var indexOf$1 = arrayIncludes.indexOf;
1100
1870
  var hiddenKeys$2 = hiddenKeys$4;
1101
1871
 
1102
- var push$6 = uncurryThis$n([].push);
1872
+ var push$7 = uncurryThis$o([].push);
1103
1873
 
1104
1874
  var objectKeysInternal = function (object, names) {
1105
1875
  var O = toIndexedObject$2(object);
1106
1876
  var i = 0;
1107
1877
  var result = [];
1108
1878
  var key;
1109
- for (key in O) !hasOwn$8(hiddenKeys$2, key) && hasOwn$8(O, key) && push$6(result, key);
1879
+ for (key in O) !hasOwn$8(hiddenKeys$2, key) && hasOwn$8(O, key) && push$7(result, key);
1110
1880
  // Don't enum bug & hidden keys
1111
1881
  while (names.length > i) if (hasOwn$8(O, key = names[i++])) {
1112
- ~indexOf$1(result, key) || push$6(result, key);
1882
+ ~indexOf$1(result, key) || push$7(result, key);
1113
1883
  }
1114
1884
  return result;
1115
1885
  };
@@ -1143,16 +1913,16 @@ var objectGetOwnPropertySymbols = {};
1143
1913
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
1144
1914
 
1145
1915
  var getBuiltIn$6 = getBuiltIn$8;
1146
- var uncurryThis$m = functionUncurryThis;
1916
+ var uncurryThis$n = functionUncurryThis;
1147
1917
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
1148
1918
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
1149
- var anObject$e = anObject$g;
1919
+ var anObject$f = anObject$h;
1150
1920
 
1151
- var concat$2 = uncurryThis$m([].concat);
1921
+ var concat$2 = uncurryThis$n([].concat);
1152
1922
 
1153
1923
  // all object keys, includes non-enumerable and symbols
1154
1924
  var ownKeys$1 = getBuiltIn$6('Reflect', 'ownKeys') || function ownKeys(it) {
1155
- var keys = getOwnPropertyNamesModule.f(anObject$e(it));
1925
+ var keys = getOwnPropertyNamesModule.f(anObject$f(it));
1156
1926
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
1157
1927
  return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
1158
1928
  };
@@ -1174,7 +1944,7 @@ var copyConstructorProperties$2 = function (target, source, exceptions) {
1174
1944
  }
1175
1945
  };
1176
1946
 
1177
- var fails$h = fails$p;
1947
+ var fails$i = fails$q;
1178
1948
  var isCallable$d = isCallable$n;
1179
1949
 
1180
1950
  var replacement = /#|\.prototype\./;
@@ -1183,7 +1953,7 @@ var isForced$2 = function (feature, detection) {
1183
1953
  var value = data[normalize(feature)];
1184
1954
  return value === POLYFILL ? true
1185
1955
  : value === NATIVE ? false
1186
- : isCallable$d(detection) ? fails$h(detection)
1956
+ : isCallable$d(detection) ? fails$i(detection)
1187
1957
  : !!detection;
1188
1958
  };
1189
1959
 
@@ -1267,7 +2037,7 @@ var objectKeys$2 = Object.keys || function keys(O) {
1267
2037
  var DESCRIPTORS$b = descriptors;
1268
2038
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
1269
2039
  var definePropertyModule$1 = objectDefineProperty;
1270
- var anObject$d = anObject$g;
2040
+ var anObject$e = anObject$h;
1271
2041
  var toIndexedObject$1 = toIndexedObject$5;
1272
2042
  var objectKeys$1 = objectKeys$2;
1273
2043
 
@@ -1275,7 +2045,7 @@ var objectKeys$1 = objectKeys$2;
1275
2045
  // https://tc39.es/ecma262/#sec-object.defineproperties
1276
2046
  // eslint-disable-next-line es/no-object-defineproperties -- safe
1277
2047
  objectDefineProperties.f = DESCRIPTORS$b && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1278
- anObject$d(O);
2048
+ anObject$e(O);
1279
2049
  var props = toIndexedObject$1(Properties);
1280
2050
  var keys = objectKeys$1(Properties);
1281
2051
  var length = keys.length;
@@ -1290,7 +2060,7 @@ var getBuiltIn$5 = getBuiltIn$8;
1290
2060
  var html$2 = getBuiltIn$5('document', 'documentElement');
1291
2061
 
1292
2062
  /* global ActiveXObject -- old IE, WSH */
1293
- var anObject$c = anObject$g;
2063
+ var anObject$d = anObject$h;
1294
2064
  var definePropertiesModule = objectDefineProperties;
1295
2065
  var enumBugKeys = enumBugKeys$3;
1296
2066
  var hiddenKeys = hiddenKeys$4;
@@ -1365,7 +2135,7 @@ hiddenKeys[IE_PROTO$1] = true;
1365
2135
  var objectCreate = Object.create || function create(O, Properties) {
1366
2136
  var result;
1367
2137
  if (O !== null) {
1368
- EmptyConstructor[PROTOTYPE] = anObject$c(O);
2138
+ EmptyConstructor[PROTOTYPE] = anObject$d(O);
1369
2139
  result = new EmptyConstructor();
1370
2140
  EmptyConstructor[PROTOTYPE] = null;
1371
2141
  // add "__proto__" for Object.getPrototypeOf polyfill
@@ -1397,11 +2167,11 @@ var addToUnscopables$4 = function (key) {
1397
2167
 
1398
2168
  var $$k = _export;
1399
2169
  var $includes = arrayIncludes.includes;
1400
- var fails$g = fails$p;
2170
+ var fails$h = fails$q;
1401
2171
  var addToUnscopables$3 = addToUnscopables$4;
1402
2172
 
1403
2173
  // FF99+ bug
1404
- var BROKEN_ON_SPARSE = fails$g(function () {
2174
+ var BROKEN_ON_SPARSE = fails$h(function () {
1405
2175
  // eslint-disable-next-line es/no-array-prototype-includes -- detection
1406
2176
  return !Array(1).includes();
1407
2177
  });
@@ -1466,9 +2236,9 @@ var toObject$7 = toObject$9;
1466
2236
  var lengthOfArrayLike$6 = lengthOfArrayLike$8;
1467
2237
  var setArrayLength = arraySetLength;
1468
2238
  var doesNotExceedSafeInteger$1 = doesNotExceedSafeInteger$2;
1469
- var fails$f = fails$p;
2239
+ var fails$g = fails$q;
1470
2240
 
1471
- var INCORRECT_TO_LENGTH = fails$f(function () {
2241
+ var INCORRECT_TO_LENGTH = fails$g(function () {
1472
2242
  return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
1473
2243
  });
1474
2244
 
@@ -1503,7 +2273,7 @@ $$j({ target: 'Array', proto: true, arity: 1, forced: FORCED$1 }, {
1503
2273
  }
1504
2274
  });
1505
2275
 
1506
- var isObject$9 = isObject$f;
2276
+ var isObject$a = isObject$g;
1507
2277
  var classof$7 = classofRaw$2;
1508
2278
  var wellKnownSymbol$i = wellKnownSymbol$l;
1509
2279
 
@@ -1513,7 +2283,7 @@ var MATCH$1 = wellKnownSymbol$i('match');
1513
2283
  // https://tc39.es/ecma262/#sec-isregexp
1514
2284
  var isRegexp = function (it) {
1515
2285
  var isRegExp;
1516
- return isObject$9(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$7(it) === 'RegExp');
2286
+ return isObject$a(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$7(it) === 'RegExp');
1517
2287
  };
1518
2288
 
1519
2289
  var isRegExp = isRegexp;
@@ -1569,7 +2339,7 @@ var classof$5 = classof$6;
1569
2339
 
1570
2340
  var $String$1 = String;
1571
2341
 
1572
- var toString$b = function (argument) {
2342
+ var toString$c = function (argument) {
1573
2343
  if (classof$5(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
1574
2344
  return $String$1(argument);
1575
2345
  };
@@ -1591,21 +2361,21 @@ var correctIsRegexpLogic = function (METHOD_NAME) {
1591
2361
  };
1592
2362
 
1593
2363
  var $$i = _export;
1594
- var uncurryThis$l = functionUncurryThis;
2364
+ var uncurryThis$m = functionUncurryThis;
1595
2365
  var notARegExp$1 = notARegexp;
1596
- var requireObjectCoercible$5 = requireObjectCoercible$8;
1597
- var toString$a = toString$b;
2366
+ var requireObjectCoercible$6 = requireObjectCoercible$9;
2367
+ var toString$b = toString$c;
1598
2368
  var correctIsRegExpLogic$1 = correctIsRegexpLogic;
1599
2369
 
1600
- var stringIndexOf$2 = uncurryThis$l(''.indexOf);
2370
+ var stringIndexOf$2 = uncurryThis$m(''.indexOf);
1601
2371
 
1602
2372
  // `String.prototype.includes` method
1603
2373
  // https://tc39.es/ecma262/#sec-string.prototype.includes
1604
2374
  $$i({ target: 'String', proto: true, forced: !correctIsRegExpLogic$1('includes') }, {
1605
2375
  includes: function includes(searchString /* , position = 0 */) {
1606
2376
  return !!~stringIndexOf$2(
1607
- toString$a(requireObjectCoercible$5(this)),
1608
- toString$a(notARegExp$1(searchString)),
2377
+ toString$b(requireObjectCoercible$6(this)),
2378
+ toString$b(notARegExp$1(searchString)),
1609
2379
  arguments.length > 1 ? arguments[1] : undefined
1610
2380
  );
1611
2381
  }
@@ -1708,6 +2478,12 @@ const slice = createSlice({
1708
2478
  })));
1709
2479
  draft.filters.queryableConfigurations = queryables;
1710
2480
  },
2481
+ setWMSbox: (draft, action) => {
2482
+ const {
2483
+ wmsBox
2484
+ } = action.payload;
2485
+ draft.filters.wmsbox = wmsBox;
2486
+ },
1711
2487
  setBbox: (draft, action) => {
1712
2488
  const {
1713
2489
  bbox
@@ -1770,9 +2546,9 @@ const dataExplorerMiddlewares = [mapListener.middleware, serviceListener.middlew
1770
2546
  combineReducers(dataExplorerReducersMap);
1771
2547
 
1772
2548
  var DESCRIPTORS$9 = descriptors;
1773
- var uncurryThis$k = functionUncurryThis;
1774
- var call$h = functionCall;
1775
- var fails$e = fails$p;
2549
+ var uncurryThis$l = functionUncurryThis;
2550
+ var call$i = functionCall;
2551
+ var fails$f = fails$q;
1776
2552
  var objectKeys = objectKeys$2;
1777
2553
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1778
2554
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
@@ -1783,11 +2559,11 @@ var IndexedObject = indexedObject;
1783
2559
  var $assign = Object.assign;
1784
2560
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1785
2561
  var defineProperty$3 = Object.defineProperty;
1786
- var concat$1 = uncurryThis$k([].concat);
2562
+ var concat$1 = uncurryThis$l([].concat);
1787
2563
 
1788
2564
  // `Object.assign` method
1789
2565
  // https://tc39.es/ecma262/#sec-object.assign
1790
- var objectAssign = !$assign || fails$e(function () {
2566
+ var objectAssign = !$assign || fails$f(function () {
1791
2567
  // should have correct order of operations (Edge bug)
1792
2568
  if (DESCRIPTORS$9 && $assign({ b: 1 }, $assign(defineProperty$3({}, 'a', {
1793
2569
  enumerable: true,
@@ -1822,7 +2598,7 @@ var objectAssign = !$assign || fails$e(function () {
1822
2598
  var key;
1823
2599
  while (length > j) {
1824
2600
  key = keys[j++];
1825
- if (!DESCRIPTORS$9 || call$h(propertyIsEnumerable, S, key)) T[key] = S[key];
2601
+ if (!DESCRIPTORS$9 || call$i(propertyIsEnumerable, S, key)) T[key] = S[key];
1826
2602
  }
1827
2603
  } return T;
1828
2604
  } : $assign;
@@ -1866,20 +2642,20 @@ const DataExplorerSearchConnect = () => {
1866
2642
  };
1867
2643
 
1868
2644
  var classofRaw = classofRaw$2;
1869
- var uncurryThis$j = functionUncurryThis;
2645
+ var uncurryThis$k = functionUncurryThis;
1870
2646
 
1871
2647
  var functionUncurryThisClause = function (fn) {
1872
2648
  // Nashorn bug:
1873
2649
  // https://github.com/zloirock/core-js/issues/1128
1874
2650
  // https://github.com/zloirock/core-js/issues/1130
1875
- if (classofRaw(fn) === 'Function') return uncurryThis$j(fn);
2651
+ if (classofRaw(fn) === 'Function') return uncurryThis$k(fn);
1876
2652
  };
1877
2653
 
1878
- var uncurryThis$i = functionUncurryThisClause;
2654
+ var uncurryThis$j = functionUncurryThisClause;
1879
2655
  var aCallable$8 = aCallable$a;
1880
2656
  var NATIVE_BIND$1 = functionBindNative;
1881
2657
 
1882
- var bind$8 = uncurryThis$i(uncurryThis$i.bind);
2658
+ var bind$8 = uncurryThis$j(uncurryThis$j.bind);
1883
2659
 
1884
2660
  // optional / simple context binding
1885
2661
  var functionBindContext = function (fn, that) {
@@ -1923,8 +2699,8 @@ var flattenIntoArray$2 = function (target, original, source, sourceLen, start, d
1923
2699
 
1924
2700
  var flattenIntoArray_1 = flattenIntoArray$2;
1925
2701
 
1926
- var uncurryThis$h = functionUncurryThis;
1927
- var fails$d = fails$p;
2702
+ var uncurryThis$i = functionUncurryThis;
2703
+ var fails$e = fails$q;
1928
2704
  var isCallable$b = isCallable$n;
1929
2705
  var classof$4 = classof$6;
1930
2706
  var getBuiltIn$4 = getBuiltIn$8;
@@ -1933,7 +2709,7 @@ var inspectSource$1 = inspectSource$3;
1933
2709
  var noop = function () { /* empty */ };
1934
2710
  var construct = getBuiltIn$4('Reflect', 'construct');
1935
2711
  var constructorRegExp = /^\s*(?:class|function)\b/;
1936
- var exec$4 = uncurryThis$h(constructorRegExp.exec);
2712
+ var exec$4 = uncurryThis$i(constructorRegExp.exec);
1937
2713
  var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
1938
2714
 
1939
2715
  var isConstructorModern = function isConstructor(argument) {
@@ -1967,7 +2743,7 @@ isConstructorLegacy.sham = true;
1967
2743
 
1968
2744
  // `IsConstructor` abstract operation
1969
2745
  // https://tc39.es/ecma262/#sec-isconstructor
1970
- var isConstructor$3 = !construct || fails$d(function () {
2746
+ var isConstructor$3 = !construct || fails$e(function () {
1971
2747
  var called;
1972
2748
  return isConstructorModern(isConstructorModern.call)
1973
2749
  || !isConstructorModern(Object)
@@ -1977,7 +2753,7 @@ var isConstructor$3 = !construct || fails$d(function () {
1977
2753
 
1978
2754
  var isArray = isArray$3;
1979
2755
  var isConstructor$2 = isConstructor$3;
1980
- var isObject$8 = isObject$f;
2756
+ var isObject$9 = isObject$g;
1981
2757
  var wellKnownSymbol$e = wellKnownSymbol$l;
1982
2758
 
1983
2759
  var SPECIES$4 = wellKnownSymbol$e('species');
@@ -1991,7 +2767,7 @@ var arraySpeciesConstructor$1 = function (originalArray) {
1991
2767
  C = originalArray.constructor;
1992
2768
  // cross-realm fallback
1993
2769
  if (isConstructor$2(C) && (C === $Array$1 || isArray(C.prototype))) C = undefined;
1994
- else if (isObject$8(C)) {
2770
+ else if (isObject$9(C)) {
1995
2771
  C = C[SPECIES$4];
1996
2772
  if (C === null) C = undefined;
1997
2773
  }
@@ -2028,9 +2804,9 @@ $$g({ target: 'Array', proto: true }, {
2028
2804
 
2029
2805
  var iterators = {};
2030
2806
 
2031
- var fails$c = fails$p;
2807
+ var fails$d = fails$q;
2032
2808
 
2033
- var correctPrototypeGetter = !fails$c(function () {
2809
+ var correctPrototypeGetter = !fails$d(function () {
2034
2810
  function F() { /* empty */ }
2035
2811
  F.prototype.constructor = null;
2036
2812
  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
@@ -2059,9 +2835,9 @@ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : f
2059
2835
  } return object instanceof $Object ? ObjectPrototype : null;
2060
2836
  };
2061
2837
 
2062
- var fails$b = fails$p;
2838
+ var fails$c = fails$q;
2063
2839
  var isCallable$9 = isCallable$n;
2064
- var isObject$7 = isObject$f;
2840
+ var isObject$8 = isObject$g;
2065
2841
  var getPrototypeOf$1 = objectGetPrototypeOf;
2066
2842
  var defineBuiltIn$a = defineBuiltIn$c;
2067
2843
  var wellKnownSymbol$d = wellKnownSymbol$l;
@@ -2084,7 +2860,7 @@ if ([].keys) {
2084
2860
  }
2085
2861
  }
2086
2862
 
2087
- var NEW_ITERATOR_PROTOTYPE = !isObject$7(IteratorPrototype$2) || fails$b(function () {
2863
+ var NEW_ITERATOR_PROTOTYPE = !isObject$8(IteratorPrototype$2) || fails$c(function () {
2088
2864
  var test = {};
2089
2865
  // FF44- legacy iterators case
2090
2866
  return IteratorPrototype$2[ITERATOR$7].call(test) !== test;
@@ -2134,20 +2910,20 @@ var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUME
2134
2910
  return IteratorConstructor;
2135
2911
  };
2136
2912
 
2137
- var uncurryThis$g = functionUncurryThis;
2913
+ var uncurryThis$h = functionUncurryThis;
2138
2914
  var aCallable$7 = aCallable$a;
2139
2915
 
2140
2916
  var functionUncurryThisAccessor = function (object, key, method) {
2141
2917
  try {
2142
2918
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2143
- return uncurryThis$g(aCallable$7(Object.getOwnPropertyDescriptor(object, key)[method]));
2919
+ return uncurryThis$h(aCallable$7(Object.getOwnPropertyDescriptor(object, key)[method]));
2144
2920
  } catch (error) { /* empty */ }
2145
2921
  };
2146
2922
 
2147
- var isObject$6 = isObject$f;
2923
+ var isObject$7 = isObject$g;
2148
2924
 
2149
2925
  var isPossiblePrototype$1 = function (argument) {
2150
- return isObject$6(argument) || argument === null;
2926
+ return isObject$7(argument) || argument === null;
2151
2927
  };
2152
2928
 
2153
2929
  var isPossiblePrototype = isPossiblePrototype$1;
@@ -2162,8 +2938,8 @@ var aPossiblePrototype$1 = function (argument) {
2162
2938
 
2163
2939
  /* eslint-disable no-proto -- safe */
2164
2940
  var uncurryThisAccessor = functionUncurryThisAccessor;
2165
- var isObject$5 = isObject$f;
2166
- var requireObjectCoercible$4 = requireObjectCoercible$8;
2941
+ var isObject$6 = isObject$g;
2942
+ var requireObjectCoercible$5 = requireObjectCoercible$9;
2167
2943
  var aPossiblePrototype = aPossiblePrototype$1;
2168
2944
 
2169
2945
  // `Object.setPrototypeOf` method
@@ -2180,9 +2956,9 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
2180
2956
  CORRECT_SETTER = test instanceof Array;
2181
2957
  } catch (error) { /* empty */ }
2182
2958
  return function setPrototypeOf(O, proto) {
2183
- requireObjectCoercible$4(O);
2959
+ requireObjectCoercible$5(O);
2184
2960
  aPossiblePrototype(proto);
2185
- if (!isObject$5(O)) return O;
2961
+ if (!isObject$6(O)) return O;
2186
2962
  if (CORRECT_SETTER) setter(O, proto);
2187
2963
  else O.__proto__ = proto;
2188
2964
  return O;
@@ -2190,7 +2966,7 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
2190
2966
  }() : undefined);
2191
2967
 
2192
2968
  var $$f = _export;
2193
- var call$g = functionCall;
2969
+ var call$h = functionCall;
2194
2970
  var FunctionName = functionName;
2195
2971
  var isCallable$8 = isCallable$n;
2196
2972
  var createIteratorConstructor$1 = iteratorCreateConstructor;
@@ -2262,7 +3038,7 @@ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAUL
2262
3038
  createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
2263
3039
  } else {
2264
3040
  INCORRECT_VALUES_NAME = true;
2265
- defaultIterator = function values() { return call$g(nativeIterator, this); };
3041
+ defaultIterator = function values() { return call$h(nativeIterator, this); };
2266
3042
  }
2267
3043
  }
2268
3044
 
@@ -2364,9 +3140,9 @@ var deletePropertyOrThrow$1 = function (O, P) {
2364
3140
  if (!delete O[P]) throw new $TypeError$7('Cannot delete property ' + tryToString$3(P) + ' of ' + tryToString$3(O));
2365
3141
  };
2366
3142
 
2367
- var uncurryThis$f = functionUncurryThis;
3143
+ var uncurryThis$g = functionUncurryThis;
2368
3144
 
2369
- var arraySlice$3 = uncurryThis$f([].slice);
3145
+ var arraySlice$3 = uncurryThis$g([].slice);
2370
3146
 
2371
3147
  var arraySlice$2 = arraySlice$3;
2372
3148
 
@@ -2410,11 +3186,11 @@ var sort = function (array, comparefn) {
2410
3186
 
2411
3187
  var arraySort$1 = sort;
2412
3188
 
2413
- var fails$a = fails$p;
3189
+ var fails$b = fails$q;
2414
3190
 
2415
3191
  var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
2416
3192
  var method = [][METHOD_NAME];
2417
- return !!method && fails$a(function () {
3193
+ return !!method && fails$b(function () {
2418
3194
  // eslint-disable-next-line no-useless-call -- required for testing
2419
3195
  method.call(null, argument || function () { return 1; }, 1);
2420
3196
  });
@@ -2437,13 +3213,13 @@ var webkit = userAgent$4.match(/AppleWebKit\/(\d+)\./);
2437
3213
  var environmentWebkitVersion = !!webkit && +webkit[1];
2438
3214
 
2439
3215
  var $$e = _export;
2440
- var uncurryThis$e = functionUncurryThis;
3216
+ var uncurryThis$f = functionUncurryThis;
2441
3217
  var aCallable$6 = aCallable$a;
2442
3218
  var toObject$3 = toObject$9;
2443
3219
  var lengthOfArrayLike$3 = lengthOfArrayLike$8;
2444
3220
  var deletePropertyOrThrow = deletePropertyOrThrow$1;
2445
- var toString$9 = toString$b;
2446
- var fails$9 = fails$p;
3221
+ var toString$a = toString$c;
3222
+ var fails$a = fails$q;
2447
3223
  var internalSort = arraySort$1;
2448
3224
  var arrayMethodIsStrict = arrayMethodIsStrict$1;
2449
3225
  var FF = environmentFfVersion;
@@ -2452,21 +3228,21 @@ var V8 = environmentV8Version;
2452
3228
  var WEBKIT = environmentWebkitVersion;
2453
3229
 
2454
3230
  var test = [];
2455
- var nativeSort = uncurryThis$e(test.sort);
2456
- var push$5 = uncurryThis$e(test.push);
3231
+ var nativeSort = uncurryThis$f(test.sort);
3232
+ var push$6 = uncurryThis$f(test.push);
2457
3233
 
2458
3234
  // IE8-
2459
- var FAILS_ON_UNDEFINED = fails$9(function () {
3235
+ var FAILS_ON_UNDEFINED = fails$a(function () {
2460
3236
  test.sort(undefined);
2461
3237
  });
2462
3238
  // V8 bug
2463
- var FAILS_ON_NULL = fails$9(function () {
3239
+ var FAILS_ON_NULL = fails$a(function () {
2464
3240
  test.sort(null);
2465
3241
  });
2466
3242
  // Old WebKit
2467
3243
  var STRICT_METHOD = arrayMethodIsStrict('sort');
2468
3244
 
2469
- var STABLE_SORT = !fails$9(function () {
3245
+ var STABLE_SORT = !fails$a(function () {
2470
3246
  // feature detection can be too slow, so check engines versions
2471
3247
  if (V8) return V8 < 70;
2472
3248
  if (FF && FF > 3) return;
@@ -2508,7 +3284,7 @@ var getSortCompare = function (comparefn) {
2508
3284
  if (y === undefined) return -1;
2509
3285
  if (x === undefined) return 1;
2510
3286
  if (comparefn !== undefined) return +comparefn(x, y) || 0;
2511
- return toString$9(x) > toString$9(y) ? 1 : -1;
3287
+ return toString$a(x) > toString$a(y) ? 1 : -1;
2512
3288
  };
2513
3289
  };
2514
3290
 
@@ -2527,7 +3303,7 @@ $$e({ target: 'Array', proto: true, forced: FORCED }, {
2527
3303
  var itemsLength, index;
2528
3304
 
2529
3305
  for (index = 0; index < arrayLength; index++) {
2530
- if (index in array) push$5(items, array[index]);
3306
+ if (index in array) push$6(items, array[index]);
2531
3307
  }
2532
3308
 
2533
3309
  internalSort(items, getSortCompare(comparefn));
@@ -2632,11 +3408,15 @@ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
2632
3408
 
2633
3409
  const DataExplorerFilterOption = ({
2634
3410
  optionId,
3411
+ filterId,
2635
3412
  checked,
2636
3413
  onClick,
2637
3414
  value,
2638
3415
  count
2639
3416
  }) => {
3417
+ const {
3418
+ t
3419
+ } = useDataExplorerTranslation();
2640
3420
  return jsx(ListItem, {
2641
3421
  disablePadding: true,
2642
3422
  sx: {
@@ -2661,15 +3441,31 @@ const DataExplorerFilterOption = ({
2661
3441
  checked: checked,
2662
3442
  tabIndex: -1,
2663
3443
  disableRipple: true,
2664
- inputProps: {
2665
- 'aria-labelledby': optionId,
2666
- 'aria-label': optionId
3444
+ slotProps: {
3445
+ input: {
3446
+ 'aria-labelledby': optionId,
3447
+ 'aria-label': optionId
3448
+ }
2667
3449
  },
2668
3450
  name: optionId
2669
3451
  })
2670
3452
  }), jsx(ListItemText, {
2671
3453
  id: optionId,
2672
- primary: jsx(CustomTooltip, {
3454
+ primary: filterId === 'contacts.addresses.country' ? jsx(CustomTooltip, {
3455
+ title: t(value),
3456
+ children: jsx(Typography, {
3457
+ sx: {
3458
+ float: 'left',
3459
+ fontSize: '12px',
3460
+ maxWidth: 'calc(100% - 44px)',
3461
+ whiteSpace: 'nowrap',
3462
+ overflow: 'hidden',
3463
+ textOverflow: 'ellipsis'
3464
+ },
3465
+ "data-testid": `dataExplorerFilterOptionValue-${value}`,
3466
+ children: t(value)
3467
+ })
3468
+ }) : jsx(CustomTooltip, {
2673
3469
  title: value,
2674
3470
  children: jsx(Typography, {
2675
3471
  sx: {
@@ -2726,6 +3522,7 @@ const DataExplorerFilters = ({
2726
3522
  padding: '0px'
2727
3523
  },
2728
3524
  children: filter.values.map(value => jsx(DataExplorerFilterOption, {
3525
+ filterId: filter.id,
2729
3526
  optionId: `${filter.id}-${value.value}`,
2730
3527
  checked: filter.selected.includes(value.value),
2731
3528
  onClick: checked => toggleFilter(checked, filter.id, value.value),
@@ -2813,7 +3610,7 @@ var aConstructor$1 = function (argument) {
2813
3610
  throw new $TypeError$5(tryToString$2(argument) + ' is not a constructor');
2814
3611
  };
2815
3612
 
2816
- var anObject$b = anObject$g;
3613
+ var anObject$c = anObject$h;
2817
3614
  var aConstructor = aConstructor$1;
2818
3615
  var isNullOrUndefined$1 = isNullOrUndefined$4;
2819
3616
  var wellKnownSymbol$8 = wellKnownSymbol$l;
@@ -2822,21 +3619,21 @@ var SPECIES$2 = wellKnownSymbol$8('species');
2822
3619
 
2823
3620
  // `SpeciesConstructor` abstract operation
2824
3621
  // https://tc39.es/ecma262/#sec-speciesconstructor
2825
- var speciesConstructor$1 = function (O, defaultConstructor) {
2826
- var C = anObject$b(O).constructor;
3622
+ var speciesConstructor$2 = function (O, defaultConstructor) {
3623
+ var C = anObject$c(O).constructor;
2827
3624
  var S;
2828
- return C === undefined || isNullOrUndefined$1(S = anObject$b(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
3625
+ return C === undefined || isNullOrUndefined$1(S = anObject$c(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
2829
3626
  };
2830
3627
 
2831
3628
  var NATIVE_BIND = functionBindNative;
2832
3629
 
2833
3630
  var FunctionPrototype = Function.prototype;
2834
3631
  var apply$2 = FunctionPrototype.apply;
2835
- var call$f = FunctionPrototype.call;
3632
+ var call$g = FunctionPrototype.call;
2836
3633
 
2837
3634
  // eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
2838
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$f.bind(apply$2) : function () {
2839
- return call$f.apply(apply$2, arguments);
3635
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$g.bind(apply$2) : function () {
3636
+ return call$g.apply(apply$2, arguments);
2840
3637
  });
2841
3638
 
2842
3639
  var $TypeError$4 = TypeError;
@@ -2856,7 +3653,7 @@ var apply$1 = functionApply;
2856
3653
  var bind$6 = functionBindContext;
2857
3654
  var isCallable$7 = isCallable$n;
2858
3655
  var hasOwn$4 = hasOwnProperty_1;
2859
- var fails$8 = fails$p;
3656
+ var fails$9 = fails$q;
2860
3657
  var html = html$2;
2861
3658
  var arraySlice$1 = arraySlice$3;
2862
3659
  var createElement = documentCreateElement$2;
@@ -2876,7 +3673,7 @@ var queue$2 = {};
2876
3673
  var ONREADYSTATECHANGE = 'onreadystatechange';
2877
3674
  var $location, defer, channel, port;
2878
3675
 
2879
- fails$8(function () {
3676
+ fails$9(function () {
2880
3677
  // Deno throws a ReferenceError on `location` access without `--location` flag
2881
3678
  $location = globalThis$d.location;
2882
3679
  });
@@ -2943,7 +3740,7 @@ if (!set || !clear) {
2943
3740
  isCallable$7(globalThis$d.postMessage) &&
2944
3741
  !globalThis$d.importScripts &&
2945
3742
  $location && $location.protocol !== 'file:' &&
2946
- !fails$8(globalPostMessageDefer)
3743
+ !fails$9(globalPostMessageDefer)
2947
3744
  ) {
2948
3745
  defer = globalPostMessageDefer;
2949
3746
  globalThis$d.addEventListener('message', eventListener, false);
@@ -3181,16 +3978,16 @@ var $$d = _export;
3181
3978
  var IS_NODE = environmentIsNode;
3182
3979
  var globalThis$8 = globalThis_1;
3183
3980
  var path = path$1;
3184
- var call$e = functionCall;
3981
+ var call$f = functionCall;
3185
3982
  var defineBuiltIn$8 = defineBuiltIn$c;
3186
3983
  var setPrototypeOf = objectSetPrototypeOf;
3187
3984
  var setToStringTag$2 = setToStringTag$6;
3188
3985
  var setSpecies = setSpecies$1;
3189
3986
  var aCallable$4 = aCallable$a;
3190
3987
  var isCallable$5 = isCallable$n;
3191
- var isObject$4 = isObject$f;
3988
+ var isObject$5 = isObject$g;
3192
3989
  var anInstance$2 = anInstance$3;
3193
- var speciesConstructor = speciesConstructor$1;
3990
+ var speciesConstructor$1 = speciesConstructor$2;
3194
3991
  var task = task$1.set;
3195
3992
  var microtask = microtask_1;
3196
3993
  var hostReportErrors = hostReportErrors$1;
@@ -3230,7 +4027,7 @@ var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
3230
4027
  // helpers
3231
4028
  var isThenable = function (it) {
3232
4029
  var then;
3233
- return isObject$4(it) && isCallable$5(then = it.then) ? then : false;
4030
+ return isObject$5(it) && isCallable$5(then = it.then) ? then : false;
3234
4031
  };
3235
4032
 
3236
4033
  var callReaction = function (reaction, state) {
@@ -3259,7 +4056,7 @@ var callReaction = function (reaction, state) {
3259
4056
  if (result === reaction.promise) {
3260
4057
  reject(new TypeError$3('Promise-chain cycle'));
3261
4058
  } else if (then = isThenable(result)) {
3262
- call$e(then, result, resolve, reject);
4059
+ call$f(then, result, resolve, reject);
3263
4060
  } else resolve(result);
3264
4061
  } else reject(value);
3265
4062
  } catch (error) {
@@ -3296,7 +4093,7 @@ var dispatchEvent = function (name, promise, reason) {
3296
4093
  };
3297
4094
 
3298
4095
  var onUnhandled = function (state) {
3299
- call$e(task, globalThis$8, function () {
4096
+ call$f(task, globalThis$8, function () {
3300
4097
  var promise = state.facade;
3301
4098
  var value = state.value;
3302
4099
  var IS_UNHANDLED = isUnhandled(state);
@@ -3319,7 +4116,7 @@ var isUnhandled = function (state) {
3319
4116
  };
3320
4117
 
3321
4118
  var onHandleUnhandled = function (state) {
3322
- call$e(task, globalThis$8, function () {
4119
+ call$f(task, globalThis$8, function () {
3323
4120
  var promise = state.facade;
3324
4121
  if (IS_NODE) {
3325
4122
  process.emit('rejectionHandled', promise);
@@ -3353,7 +4150,7 @@ var internalResolve = function (state, value, unwrap) {
3353
4150
  microtask(function () {
3354
4151
  var wrapper = { done: false };
3355
4152
  try {
3356
- call$e(then, value,
4153
+ call$f(then, value,
3357
4154
  bind$4(internalResolve, wrapper, state),
3358
4155
  bind$4(internalReject, wrapper, state)
3359
4156
  );
@@ -3377,7 +4174,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
3377
4174
  PromiseConstructor = function Promise(executor) {
3378
4175
  anInstance$2(this, PromisePrototype);
3379
4176
  aCallable$4(executor);
3380
- call$e(Internal, this);
4177
+ call$f(Internal, this);
3381
4178
  var state = getInternalPromiseState(this);
3382
4179
  try {
3383
4180
  executor(bind$4(internalResolve, state), bind$4(internalReject, state));
@@ -3406,7 +4203,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
3406
4203
  // https://tc39.es/ecma262/#sec-promise.prototype.then
3407
4204
  Internal.prototype = defineBuiltIn$8(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
3408
4205
  var state = getInternalPromiseState(this);
3409
- var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
4206
+ var reaction = newPromiseCapability$1(speciesConstructor$1(this, PromiseConstructor));
3410
4207
  state.parent = true;
3411
4208
  reaction.ok = isCallable$5(onFulfilled) ? onFulfilled : true;
3412
4209
  reaction.fail = isCallable$5(onRejected) && onRejected;
@@ -3440,7 +4237,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
3440
4237
  defineBuiltIn$8(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
3441
4238
  var that = this;
3442
4239
  return new PromiseConstructor(function (resolve, reject) {
3443
- call$e(nativeThen, that, resolve, reject);
4240
+ call$f(nativeThen, that, resolve, reject);
3444
4241
  }).then(onFulfilled, onRejected);
3445
4242
  // https://github.com/zloirock/core-js/issues/640
3446
4243
  }, { unsafe: true });
@@ -3481,7 +4278,7 @@ var isArrayIteratorMethod$2 = function (it) {
3481
4278
  };
3482
4279
 
3483
4280
  var classof$2 = classof$6;
3484
- var getMethod$3 = getMethod$5;
4281
+ var getMethod$4 = getMethod$6;
3485
4282
  var isNullOrUndefined = isNullOrUndefined$4;
3486
4283
  var Iterators = iterators;
3487
4284
  var wellKnownSymbol$5 = wellKnownSymbol$l;
@@ -3489,14 +4286,14 @@ var wellKnownSymbol$5 = wellKnownSymbol$l;
3489
4286
  var ITERATOR$3 = wellKnownSymbol$5('iterator');
3490
4287
 
3491
4288
  var getIteratorMethod$4 = function (it) {
3492
- if (!isNullOrUndefined(it)) return getMethod$3(it, ITERATOR$3)
3493
- || getMethod$3(it, '@@iterator')
4289
+ if (!isNullOrUndefined(it)) return getMethod$4(it, ITERATOR$3)
4290
+ || getMethod$4(it, '@@iterator')
3494
4291
  || Iterators[classof$2(it)];
3495
4292
  };
3496
4293
 
3497
- var call$d = functionCall;
4294
+ var call$e = functionCall;
3498
4295
  var aCallable$3 = aCallable$a;
3499
- var anObject$a = anObject$g;
4296
+ var anObject$b = anObject$h;
3500
4297
  var tryToString$1 = tryToString$5;
3501
4298
  var getIteratorMethod$3 = getIteratorMethod$4;
3502
4299
 
@@ -3504,37 +4301,37 @@ var $TypeError$2 = TypeError;
3504
4301
 
3505
4302
  var getIterator$3 = function (argument, usingIterator) {
3506
4303
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$3(argument) : usingIterator;
3507
- if (aCallable$3(iteratorMethod)) return anObject$a(call$d(iteratorMethod, argument));
4304
+ if (aCallable$3(iteratorMethod)) return anObject$b(call$e(iteratorMethod, argument));
3508
4305
  throw new $TypeError$2(tryToString$1(argument) + ' is not iterable');
3509
4306
  };
3510
4307
 
3511
- var call$c = functionCall;
3512
- var anObject$9 = anObject$g;
3513
- var getMethod$2 = getMethod$5;
4308
+ var call$d = functionCall;
4309
+ var anObject$a = anObject$h;
4310
+ var getMethod$3 = getMethod$6;
3514
4311
 
3515
4312
  var iteratorClose$2 = function (iterator, kind, value) {
3516
4313
  var innerResult, innerError;
3517
- anObject$9(iterator);
4314
+ anObject$a(iterator);
3518
4315
  try {
3519
- innerResult = getMethod$2(iterator, 'return');
4316
+ innerResult = getMethod$3(iterator, 'return');
3520
4317
  if (!innerResult) {
3521
4318
  if (kind === 'throw') throw value;
3522
4319
  return value;
3523
4320
  }
3524
- innerResult = call$c(innerResult, iterator);
4321
+ innerResult = call$d(innerResult, iterator);
3525
4322
  } catch (error) {
3526
4323
  innerError = true;
3527
4324
  innerResult = error;
3528
4325
  }
3529
4326
  if (kind === 'throw') throw value;
3530
4327
  if (innerError) throw innerResult;
3531
- anObject$9(innerResult);
4328
+ anObject$a(innerResult);
3532
4329
  return value;
3533
4330
  };
3534
4331
 
3535
4332
  var bind$3 = functionBindContext;
3536
- var call$b = functionCall;
3537
- var anObject$8 = anObject$g;
4333
+ var call$c = functionCall;
4334
+ var anObject$9 = anObject$h;
3538
4335
  var tryToString = tryToString$5;
3539
4336
  var isArrayIteratorMethod$1 = isArrayIteratorMethod$2;
3540
4337
  var lengthOfArrayLike$2 = lengthOfArrayLike$8;
@@ -3568,7 +4365,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
3568
4365
 
3569
4366
  var callFn = function (value) {
3570
4367
  if (AS_ENTRIES) {
3571
- anObject$8(value);
4368
+ anObject$9(value);
3572
4369
  return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
3573
4370
  } return INTERRUPTED ? fn(value, stop) : fn(value);
3574
4371
  };
@@ -3591,7 +4388,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
3591
4388
  }
3592
4389
 
3593
4390
  next = IS_RECORD ? iterable.next : iterator.next;
3594
- while (!(step = call$b(next, iterator)).done) {
4391
+ while (!(step = call$c(next, iterator)).done) {
3595
4392
  try {
3596
4393
  result = callFn(step.value);
3597
4394
  } catch (error) {
@@ -3651,7 +4448,7 @@ var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCor
3651
4448
  });
3652
4449
 
3653
4450
  var $$c = _export;
3654
- var call$a = functionCall;
4451
+ var call$b = functionCall;
3655
4452
  var aCallable$2 = aCallable$a;
3656
4453
  var newPromiseCapabilityModule$2 = newPromiseCapability$2;
3657
4454
  var perform$1 = perform$3;
@@ -3675,7 +4472,7 @@ $$c({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
3675
4472
  var index = counter++;
3676
4473
  var alreadyCalled = false;
3677
4474
  remaining++;
3678
- call$a($promiseResolve, C, promise).then(function (value) {
4475
+ call$b($promiseResolve, C, promise).then(function (value) {
3679
4476
  if (alreadyCalled) return;
3680
4477
  alreadyCalled = true;
3681
4478
  values[index] = value;
@@ -3715,7 +4512,7 @@ if (isCallable$4(NativePromiseConstructor)) {
3715
4512
  }
3716
4513
 
3717
4514
  var $$a = _export;
3718
- var call$9 = functionCall;
4515
+ var call$a = functionCall;
3719
4516
  var aCallable$1 = aCallable$a;
3720
4517
  var newPromiseCapabilityModule$1 = newPromiseCapability$2;
3721
4518
  var perform = perform$3;
@@ -3732,7 +4529,7 @@ $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
3732
4529
  var result = perform(function () {
3733
4530
  var $promiseResolve = aCallable$1(C.resolve);
3734
4531
  iterate(iterable, function (promise) {
3735
- call$9($promiseResolve, C, promise).then(capability.resolve, reject);
4532
+ call$a($promiseResolve, C, promise).then(capability.resolve, reject);
3736
4533
  });
3737
4534
  });
3738
4535
  if (result.error) reject(result.value);
@@ -3755,13 +4552,13 @@ $$9({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
3755
4552
  }
3756
4553
  });
3757
4554
 
3758
- var anObject$7 = anObject$g;
3759
- var isObject$3 = isObject$f;
4555
+ var anObject$8 = anObject$h;
4556
+ var isObject$4 = isObject$g;
3760
4557
  var newPromiseCapability = newPromiseCapability$2;
3761
4558
 
3762
4559
  var promiseResolve$1 = function (C, x) {
3763
- anObject$7(C);
3764
- if (isObject$3(x) && x.constructor === C) return x;
4560
+ anObject$8(C);
4561
+ if (isObject$4(x) && x.constructor === C) return x;
3765
4562
  var promiseCapability = newPromiseCapability.f(C);
3766
4563
  var resolve = promiseCapability.resolve;
3767
4564
  resolve(x);
@@ -3795,7 +4592,7 @@ const fetchGeoJSON = async collectionUrl => {
3795
4592
  if (!collectionUrl) {
3796
4593
  return null;
3797
4594
  }
3798
- return fetch(`${collectionUrl}`).then(handleResponse);
4595
+ return fetch(collectionUrl).then(handleResponse);
3799
4596
  };
3800
4597
  const fetchItem = async (baseUrl, datasetId) => {
3801
4598
  if (!baseUrl || !datasetId) {
@@ -3874,6 +4671,9 @@ const DataExplorerFiltersConnect = () => {
3874
4671
  const {
3875
4672
  data: filteringDatasets
3876
4673
  } = useFetchItems(baseUrl, searchText, [], concepts);
4674
+ const {
4675
+ t
4676
+ } = useDataExplorerTranslation();
3877
4677
  const setFilterValue = (id, value, checked) => {
3878
4678
  dispatch(dataExplorerActions.setQueryableValue({
3879
4679
  id,
@@ -3891,7 +4691,7 @@ const DataExplorerFiltersConnect = () => {
3891
4691
  // Update the list of possible values for each filter
3892
4692
  queryableConfigurations.forEach(config => {
3893
4693
  const currentFilter = filtersRef.current.find(filter => filter.id === config.id);
3894
- const queryable = getQueryableWithValues(config, filteringDatasets, currentFilter);
4694
+ const queryable = getQueryableWithValues(config, filteringDatasets, t, currentFilter);
3895
4695
  queryables.push(queryable);
3896
4696
  });
3897
4697
  }
@@ -3900,30 +4700,14 @@ const DataExplorerFiltersConnect = () => {
3900
4700
  }));
3901
4701
  };
3902
4702
  updateDisplayedFilters();
3903
- }, [filteringDatasets, dispatch, queryableConfigurations]);
4703
+ }, [filteringDatasets, dispatch, queryableConfigurations, t]);
3904
4704
  return jsx(DataExplorerFilters, {
3905
4705
  filters: filters,
3906
4706
  onSetFilterValue: setFilterValue
3907
4707
  });
3908
4708
  };
3909
- const getNestedProperty = (obj, path) => {
3910
- const keys = path.split('.');
3911
- let result = obj;
3912
- for (const key of keys) {
3913
- if (Array.isArray(result)) {
3914
- result = result.map(item => getNestedProperty(item, keys.slice(keys.indexOf(key)).join('.'))).flat(Infinity);
3915
- return result;
3916
- }
3917
- if (result && typeof result === 'object' && key in result) {
3918
- result = result[key];
3919
- } else {
3920
- return undefined;
3921
- }
3922
- }
3923
- return result;
3924
- };
3925
4709
  // Go through datasets to get the possible values for the queryable filter
3926
- const getQueryableWithValues = (config, filteringDatasets, currentFilter) => {
4710
+ const getQueryableWithValues = (config, filteringDatasets, t, currentFilter) => {
3927
4711
  const queryable = {
3928
4712
  id: config.id,
3929
4713
  label: config.label,
@@ -3957,7 +4741,7 @@ const getQueryableWithValues = (config, filteringDatasets, currentFilter) => {
3957
4741
  }
3958
4742
  queryable.values.sort((valueA, valueB) => {
3959
4743
  if (typeof valueA.value === 'string' && typeof valueB.value === 'string') {
3960
- return valueA.value.localeCompare(valueB.value);
4744
+ return t(valueA.value).localeCompare(t(valueB.value));
3961
4745
  }
3962
4746
  return -1;
3963
4747
  });
@@ -3970,14 +4754,30 @@ const getQueryableWithValues = (config, filteringDatasets, currentFilter) => {
3970
4754
  }
3971
4755
  return queryable;
3972
4756
  };
4757
+ const getNestedProperty = (obj, path) => {
4758
+ const keys = path.split('.');
4759
+ let result = obj;
4760
+ for (const key of keys) {
4761
+ if (Array.isArray(result)) {
4762
+ result = result.map(item => getNestedProperty(item, keys.slice(keys.indexOf(key)).join('.'))).flat(Infinity);
4763
+ return result;
4764
+ }
4765
+ if (result && typeof result === 'object' && key in result) {
4766
+ result = result[key];
4767
+ } else {
4768
+ return undefined;
4769
+ }
4770
+ }
4771
+ return result;
4772
+ };
3973
4773
 
3974
4774
  var globalThis$7 = globalThis_1;
3975
- var fails$7 = fails$p;
4775
+ var fails$8 = fails$q;
3976
4776
 
3977
4777
  // babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
3978
4778
  var RegExp$1 = globalThis$7.RegExp;
3979
4779
 
3980
- var FLAGS_GETTER_IS_CORRECT = !fails$7(function () {
4780
+ var FLAGS_GETTER_IS_CORRECT = !fails$8(function () {
3981
4781
  var INDICES_SUPPORT = true;
3982
4782
  try {
3983
4783
  RegExp$1('.', 'd');
@@ -4018,12 +4818,12 @@ var FLAGS_GETTER_IS_CORRECT = !fails$7(function () {
4018
4818
 
4019
4819
  var regexpFlagsDetection = { correct: FLAGS_GETTER_IS_CORRECT };
4020
4820
 
4021
- var anObject$6 = anObject$g;
4821
+ var anObject$7 = anObject$h;
4022
4822
 
4023
4823
  // `RegExp.prototype.flags` getter implementation
4024
4824
  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
4025
4825
  var regexpFlags$1 = function () {
4026
- var that = anObject$6(this);
4826
+ var that = anObject$7(this);
4027
4827
  var result = '';
4028
4828
  if (that.hasIndices) result += 'd';
4029
4829
  if (that.global) result += 'g';
@@ -4036,7 +4836,7 @@ var regexpFlags$1 = function () {
4036
4836
  return result;
4037
4837
  };
4038
4838
 
4039
- var call$8 = functionCall;
4839
+ var call$9 = functionCall;
4040
4840
  var hasOwn$3 = hasOwnProperty_1;
4041
4841
  var isPrototypeOf$1 = objectIsPrototypeOf;
4042
4842
  var regExpFlagsDetection = regexpFlagsDetection;
@@ -4048,22 +4848,22 @@ var regexpGetFlags = regExpFlagsDetection.correct ? function (it) {
4048
4848
  return it.flags;
4049
4849
  } : function (it) {
4050
4850
  return (!regExpFlagsDetection.correct && isPrototypeOf$1(RegExpPrototype$2, it) && !hasOwn$3(it, 'flags'))
4051
- ? call$8(regExpFlagsGetterImplementation, it)
4851
+ ? call$9(regExpFlagsGetterImplementation, it)
4052
4852
  : it.flags;
4053
4853
  };
4054
4854
 
4055
4855
  var PROPER_FUNCTION_NAME = functionName.PROPER;
4056
4856
  var defineBuiltIn$6 = defineBuiltIn$c;
4057
- var anObject$5 = anObject$g;
4058
- var $toString$2 = toString$b;
4059
- var fails$6 = fails$p;
4857
+ var anObject$6 = anObject$h;
4858
+ var $toString$2 = toString$c;
4859
+ var fails$7 = fails$q;
4060
4860
  var getRegExpFlags$2 = regexpGetFlags;
4061
4861
 
4062
4862
  var TO_STRING = 'toString';
4063
4863
  var RegExpPrototype$1 = RegExp.prototype;
4064
4864
  var nativeToString = RegExpPrototype$1[TO_STRING];
4065
4865
 
4066
- var NOT_GENERIC = fails$6(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
4866
+ var NOT_GENERIC = fails$7(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
4067
4867
  // FF44- RegExp#toString has a wrong name
4068
4868
  var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
4069
4869
 
@@ -4071,7 +4871,7 @@ var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
4071
4871
  // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
4072
4872
  if (NOT_GENERIC || INCORRECT_NAME) {
4073
4873
  defineBuiltIn$6(RegExpPrototype$1, TO_STRING, function toString() {
4074
- var R = anObject$5(this);
4874
+ var R = anObject$6(this);
4075
4875
  var pattern = $toString$2(R.source);
4076
4876
  var flags = $toString$2(getRegExpFlags$2(R));
4077
4877
  return '/' + pattern + '/' + flags;
@@ -4220,16 +5020,16 @@ const ConceptListConnect = () => {
4220
5020
  };
4221
5021
 
4222
5022
  var $$7 = _export;
4223
- var uncurryThis$d = functionUncurryThisClause;
5023
+ var uncurryThis$e = functionUncurryThisClause;
4224
5024
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
4225
- var toLength$2 = toLength$4;
4226
- var toString$8 = toString$b;
5025
+ var toLength$3 = toLength$5;
5026
+ var toString$9 = toString$c;
4227
5027
  var notARegExp = notARegexp;
4228
- var requireObjectCoercible$3 = requireObjectCoercible$8;
5028
+ var requireObjectCoercible$4 = requireObjectCoercible$9;
4229
5029
  var correctIsRegExpLogic = correctIsRegexpLogic;
4230
5030
 
4231
- var stringSlice$7 = uncurryThis$d(''.slice);
4232
- var min$1 = Math.min;
5031
+ var stringSlice$8 = uncurryThis$e(''.slice);
5032
+ var min$2 = Math.min;
4233
5033
 
4234
5034
  var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
4235
5035
  // https://github.com/zloirock/core-js/pull/702
@@ -4242,26 +5042,26 @@ var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
4242
5042
  // https://tc39.es/ecma262/#sec-string.prototype.startswith
4243
5043
  $$7({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
4244
5044
  startsWith: function startsWith(searchString /* , position = 0 */) {
4245
- var that = toString$8(requireObjectCoercible$3(this));
5045
+ var that = toString$9(requireObjectCoercible$4(this));
4246
5046
  notARegExp(searchString);
4247
- var index = toLength$2(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length));
4248
- var search = toString$8(searchString);
4249
- return stringSlice$7(that, index, index + search.length) === search;
5047
+ var index = toLength$3(min$2(arguments.length > 1 ? arguments[1] : undefined, that.length));
5048
+ var search = toString$9(searchString);
5049
+ return stringSlice$8(that, index, index + search.length) === search;
4250
5050
  }
4251
5051
  });
4252
5052
 
4253
- var uncurryThis$c = functionUncurryThis;
5053
+ var uncurryThis$d = functionUncurryThis;
4254
5054
  var toIntegerOrInfinity$1 = toIntegerOrInfinity$5;
4255
- var toString$7 = toString$b;
4256
- var requireObjectCoercible$2 = requireObjectCoercible$8;
5055
+ var toString$8 = toString$c;
5056
+ var requireObjectCoercible$3 = requireObjectCoercible$9;
4257
5057
 
4258
- var charAt$6 = uncurryThis$c(''.charAt);
4259
- var charCodeAt$1 = uncurryThis$c(''.charCodeAt);
4260
- var stringSlice$6 = uncurryThis$c(''.slice);
5058
+ var charAt$6 = uncurryThis$d(''.charAt);
5059
+ var charCodeAt$1 = uncurryThis$d(''.charCodeAt);
5060
+ var stringSlice$7 = uncurryThis$d(''.slice);
4261
5061
 
4262
5062
  var createMethod = function (CONVERT_TO_STRING) {
4263
5063
  return function ($this, pos) {
4264
- var S = toString$7(requireObjectCoercible$2($this));
5064
+ var S = toString$8(requireObjectCoercible$3($this));
4265
5065
  var position = toIntegerOrInfinity$1(pos);
4266
5066
  var size = S.length;
4267
5067
  var first, second;
@@ -4273,7 +5073,7 @@ var createMethod = function (CONVERT_TO_STRING) {
4273
5073
  ? charAt$6(S, position)
4274
5074
  : first
4275
5075
  : CONVERT_TO_STRING
4276
- ? stringSlice$6(S, position, position + 2)
5076
+ ? stringSlice$7(S, position, position + 2)
4277
5077
  : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
4278
5078
  };
4279
5079
  };
@@ -4288,7 +5088,7 @@ var stringMultibyte = {
4288
5088
  };
4289
5089
 
4290
5090
  var charAt$5 = stringMultibyte.charAt;
4291
- var toString$6 = toString$b;
5091
+ var toString$7 = toString$c;
4292
5092
  var InternalStateModule$2 = internalState;
4293
5093
  var defineIterator = iteratorDefine;
4294
5094
  var createIterResultObject$1 = createIterResultObject$3;
@@ -4302,7 +5102,7 @@ var getInternalState$1 = InternalStateModule$2.getterFor(STRING_ITERATOR);
4302
5102
  defineIterator(String, 'String', function (iterated) {
4303
5103
  setInternalState$2(this, {
4304
5104
  type: STRING_ITERATOR,
4305
- string: toString$6(iterated),
5105
+ string: toString$7(iterated),
4306
5106
  index: 0
4307
5107
  });
4308
5108
  // `%StringIteratorPrototype%.next` method
@@ -4318,14 +5118,14 @@ defineIterator(String, 'String', function (iterated) {
4318
5118
  return createIterResultObject$1(point, false);
4319
5119
  });
4320
5120
 
4321
- var fails$5 = fails$p;
5121
+ var fails$6 = fails$q;
4322
5122
  var wellKnownSymbol$3 = wellKnownSymbol$l;
4323
5123
  var DESCRIPTORS$5 = descriptors;
4324
5124
  var IS_PURE = isPure;
4325
5125
 
4326
5126
  var ITERATOR$1 = wellKnownSymbol$3('iterator');
4327
5127
 
4328
- var urlConstructorDetection = !fails$5(function () {
5128
+ var urlConstructorDetection = !fails$6(function () {
4329
5129
  // eslint-disable-next-line unicorn/relative-url-style -- required for testing
4330
5130
  var url = new URL('b?a=1&b=2&c=3', 'https://a');
4331
5131
  var params = url.searchParams;
@@ -4360,13 +5160,13 @@ var urlConstructorDetection = !fails$5(function () {
4360
5160
  || new URL('https://x', undefined).host !== 'x';
4361
5161
  });
4362
5162
 
4363
- var anObject$4 = anObject$g;
5163
+ var anObject$5 = anObject$h;
4364
5164
  var iteratorClose = iteratorClose$2;
4365
5165
 
4366
5166
  // call something on iterator step with safe closing on error
4367
5167
  var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
4368
5168
  try {
4369
- return ENTRIES ? fn(anObject$4(value)[0], value[1]) : fn(value);
5169
+ return ENTRIES ? fn(anObject$5(value)[0], value[1]) : fn(value);
4370
5170
  } catch (error) {
4371
5171
  iteratorClose(iterator, 'throw', error);
4372
5172
  }
@@ -4382,7 +5182,7 @@ var createProperty$1 = function (object, key, value) {
4382
5182
  };
4383
5183
 
4384
5184
  var bind$2 = functionBindContext;
4385
- var call$7 = functionCall;
5185
+ var call$8 = functionCall;
4386
5186
  var toObject$2 = toObject$9;
4387
5187
  var callWithSafeIterationClosing = callWithSafeIterationClosing$1;
4388
5188
  var isArrayIteratorMethod = isArrayIteratorMethod$2;
@@ -4411,7 +5211,7 @@ var arrayFrom$1 = function from(arrayLike /* , mapfn = undefined, thisArg = unde
4411
5211
  result = IS_CONSTRUCTOR ? new this() : [];
4412
5212
  iterator = getIterator$1(O, iteratorMethod);
4413
5213
  next = iterator.next;
4414
- for (;!(step = call$7(next, iterator)).done; index++) {
5214
+ for (;!(step = call$8(next, iterator)).done; index++) {
4415
5215
  value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
4416
5216
  createProperty(result, index, value);
4417
5217
  }
@@ -4428,7 +5228,7 @@ var arrayFrom$1 = function from(arrayLike /* , mapfn = undefined, thisArg = unde
4428
5228
  };
4429
5229
 
4430
5230
  // based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
4431
- var uncurryThis$b = functionUncurryThis;
5231
+ var uncurryThis$c = functionUncurryThis;
4432
5232
 
4433
5233
  var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
4434
5234
  var base = 36;
@@ -4445,15 +5245,15 @@ var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
4445
5245
  var baseMinusTMin = base - tMin;
4446
5246
 
4447
5247
  var $RangeError$1 = RangeError;
4448
- var exec$3 = uncurryThis$b(regexSeparators.exec);
5248
+ var exec$3 = uncurryThis$c(regexSeparators.exec);
4449
5249
  var floor$2 = Math.floor;
4450
5250
  var fromCharCode$2 = String.fromCharCode;
4451
- var charCodeAt = uncurryThis$b(''.charCodeAt);
4452
- var join$3 = uncurryThis$b([].join);
4453
- var push$4 = uncurryThis$b([].push);
4454
- var replace$5 = uncurryThis$b(''.replace);
4455
- var split$2 = uncurryThis$b(''.split);
4456
- var toLowerCase$1 = uncurryThis$b(''.toLowerCase);
5251
+ var charCodeAt = uncurryThis$c(''.charCodeAt);
5252
+ var join$3 = uncurryThis$c([].join);
5253
+ var push$5 = uncurryThis$c([].push);
5254
+ var replace$5 = uncurryThis$c(''.replace);
5255
+ var split$2 = uncurryThis$c(''.split);
5256
+ var toLowerCase$1 = uncurryThis$c(''.toLowerCase);
4457
5257
 
4458
5258
  /**
4459
5259
  * Creates an array containing the numeric code points of each Unicode
@@ -4472,15 +5272,15 @@ var ucs2decode = function (string) {
4472
5272
  // It's a high surrogate, and there is a next character.
4473
5273
  var extra = charCodeAt(string, counter++);
4474
5274
  if ((extra & 0xFC00) === 0xDC00) { // Low surrogate.
4475
- push$4(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
5275
+ push$5(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
4476
5276
  } else {
4477
5277
  // It's an unmatched surrogate; only append this code unit, in case the
4478
5278
  // next code unit is the high surrogate of a surrogate pair.
4479
- push$4(output, value);
5279
+ push$5(output, value);
4480
5280
  counter--;
4481
5281
  }
4482
5282
  } else {
4483
- push$4(output, value);
5283
+ push$5(output, value);
4484
5284
  }
4485
5285
  }
4486
5286
  return output;
@@ -4533,7 +5333,7 @@ var encode = function (input) {
4533
5333
  for (i = 0; i < input.length; i++) {
4534
5334
  currentValue = input[i];
4535
5335
  if (currentValue < 0x80) {
4536
- push$4(output, fromCharCode$2(currentValue));
5336
+ push$5(output, fromCharCode$2(currentValue));
4537
5337
  }
4538
5338
  }
4539
5339
 
@@ -4542,7 +5342,7 @@ var encode = function (input) {
4542
5342
 
4543
5343
  // Finish the basic string with a delimiter unless it's empty.
4544
5344
  if (basicLength) {
4545
- push$4(output, delimiter);
5345
+ push$5(output, delimiter);
4546
5346
  }
4547
5347
 
4548
5348
  // Main encoding loop:
@@ -4579,12 +5379,12 @@ var encode = function (input) {
4579
5379
  if (q < t) break;
4580
5380
  var qMinusT = q - t;
4581
5381
  var baseMinusT = base - t;
4582
- push$4(output, fromCharCode$2(digitToBasic(t + qMinusT % baseMinusT)));
5382
+ push$5(output, fromCharCode$2(digitToBasic(t + qMinusT % baseMinusT)));
4583
5383
  q = floor$2(qMinusT / baseMinusT);
4584
5384
  k += base;
4585
5385
  }
4586
5386
 
4587
- push$4(output, fromCharCode$2(digitToBasic(q)));
5387
+ push$5(output, fromCharCode$2(digitToBasic(q)));
4588
5388
  bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
4589
5389
  delta = 0;
4590
5390
  handledCPCount++;
@@ -4603,20 +5403,20 @@ var stringPunycodeToAscii = function (input) {
4603
5403
  var i, label;
4604
5404
  for (i = 0; i < labels.length; i++) {
4605
5405
  label = labels[i];
4606
- push$4(encoded, exec$3(regexNonASCII, label) ? 'xn--' + encode(label) : label);
5406
+ push$5(encoded, exec$3(regexNonASCII, label) ? 'xn--' + encode(label) : label);
4607
5407
  }
4608
5408
  return join$3(encoded, '.');
4609
5409
  };
4610
5410
 
4611
5411
  var $$6 = _export;
4612
- var uncurryThis$a = functionUncurryThis;
5412
+ var uncurryThis$b = functionUncurryThis;
4613
5413
  var toAbsoluteIndex = toAbsoluteIndex$2;
4614
5414
 
4615
5415
  var $RangeError = RangeError;
4616
5416
  var fromCharCode$1 = String.fromCharCode;
4617
5417
  // eslint-disable-next-line es/no-string-fromcodepoint -- required for testing
4618
5418
  var $fromCodePoint = String.fromCodePoint;
4619
- var join$2 = uncurryThis$a([].join);
5419
+ var join$2 = uncurryThis$b([].join);
4620
5420
 
4621
5421
  // length should be 1, old FF problem
4622
5422
  var INCORRECT_LENGTH = !!$fromCodePoint && $fromCodePoint.length !== 1;
@@ -4654,8 +5454,8 @@ var $$5 = _export;
4654
5454
  var globalThis$6 = globalThis_1;
4655
5455
  var safeGetBuiltIn = safeGetBuiltIn$2;
4656
5456
  var getBuiltIn = getBuiltIn$8;
4657
- var call$6 = functionCall;
4658
- var uncurryThis$9 = functionUncurryThis;
5457
+ var call$7 = functionCall;
5458
+ var uncurryThis$a = functionUncurryThis;
4659
5459
  var DESCRIPTORS$3 = descriptors;
4660
5460
  var USE_NATIVE_URL$1 = urlConstructorDetection;
4661
5461
  var defineBuiltIn$4 = defineBuiltIn$c;
@@ -4669,9 +5469,9 @@ var isCallable$3 = isCallable$n;
4669
5469
  var hasOwn$2 = hasOwnProperty_1;
4670
5470
  var bind$1 = functionBindContext;
4671
5471
  var classof$1 = classof$6;
4672
- var anObject$3 = anObject$g;
4673
- var isObject$2 = isObject$f;
4674
- var $toString$1 = toString$b;
5472
+ var anObject$4 = anObject$h;
5473
+ var isObject$3 = isObject$g;
5474
+ var $toString$1 = toString$c;
4675
5475
  var create$1 = objectCreate;
4676
5476
  var createPropertyDescriptor = createPropertyDescriptor$5;
4677
5477
  var getIterator = getIterator$3;
@@ -4698,22 +5498,22 @@ var encodeURIComponent$1 = globalThis$6.encodeURIComponent;
4698
5498
  var fromCharCode = String.fromCharCode;
4699
5499
  var fromCodePoint = getBuiltIn('String', 'fromCodePoint');
4700
5500
  var $parseInt = parseInt;
4701
- var charAt$4 = uncurryThis$9(''.charAt);
4702
- var join$1 = uncurryThis$9([].join);
4703
- var push$3 = uncurryThis$9([].push);
4704
- var replace$4 = uncurryThis$9(''.replace);
4705
- var shift$1 = uncurryThis$9([].shift);
4706
- var splice = uncurryThis$9([].splice);
4707
- var split$1 = uncurryThis$9(''.split);
4708
- var stringSlice$5 = uncurryThis$9(''.slice);
4709
- var exec$2 = uncurryThis$9(/./.exec);
5501
+ var charAt$4 = uncurryThis$a(''.charAt);
5502
+ var join$1 = uncurryThis$a([].join);
5503
+ var push$4 = uncurryThis$a([].push);
5504
+ var replace$4 = uncurryThis$a(''.replace);
5505
+ var shift$1 = uncurryThis$a([].shift);
5506
+ var splice = uncurryThis$a([].splice);
5507
+ var split$1 = uncurryThis$a(''.split);
5508
+ var stringSlice$6 = uncurryThis$a(''.slice);
5509
+ var exec$2 = uncurryThis$a(/./.exec);
4710
5510
 
4711
5511
  var plus = /\+/g;
4712
5512
  var FALLBACK_REPLACER = '\uFFFD';
4713
5513
  var VALID_HEX = /^[0-9a-f]+$/i;
4714
5514
 
4715
5515
  var parseHexOctet = function (string, start) {
4716
- var substr = stringSlice$5(string, start, start + 2);
5516
+ var substr = stringSlice$6(string, start, start + 2);
4717
5517
  if (!exec$2(VALID_HEX, substr)) return NaN;
4718
5518
 
4719
5519
  return $parseInt(substr, 16);
@@ -4801,7 +5601,7 @@ var decode = function (input) {
4801
5601
  }
4802
5602
  if (nextByte > 191 || nextByte < 128) break;
4803
5603
 
4804
- push$3(octets, nextByte);
5604
+ push$4(octets, nextByte);
4805
5605
  i += 2;
4806
5606
  sequenceIndex++;
4807
5607
  }
@@ -4873,8 +5673,8 @@ var URLSearchParamsState = function (init) {
4873
5673
  this.url = null;
4874
5674
 
4875
5675
  if (init !== undefined) {
4876
- if (isObject$2(init)) this.parseObject(init);
4877
- else this.parseQuery(typeof init == 'string' ? charAt$4(init, 0) === '?' ? stringSlice$5(init, 1) : init : $toString$1(init));
5676
+ if (isObject$3(init)) this.parseObject(init);
5677
+ else this.parseQuery(typeof init == 'string' ? charAt$4(init, 0) === '?' ? stringSlice$6(init, 1) : init : $toString$1(init));
4878
5678
  }
4879
5679
  };
4880
5680
 
@@ -4892,18 +5692,18 @@ URLSearchParamsState.prototype = {
4892
5692
  if (iteratorMethod) {
4893
5693
  iterator = getIterator(object, iteratorMethod);
4894
5694
  next = iterator.next;
4895
- while (!(step = call$6(next, iterator)).done) {
4896
- entryIterator = getIterator(anObject$3(step.value));
5695
+ while (!(step = call$7(next, iterator)).done) {
5696
+ entryIterator = getIterator(anObject$4(step.value));
4897
5697
  entryNext = entryIterator.next;
4898
5698
  if (
4899
- (first = call$6(entryNext, entryIterator)).done ||
4900
- (second = call$6(entryNext, entryIterator)).done ||
4901
- !call$6(entryNext, entryIterator).done
5699
+ (first = call$7(entryNext, entryIterator)).done ||
5700
+ (second = call$7(entryNext, entryIterator)).done ||
5701
+ !call$7(entryNext, entryIterator).done
4902
5702
  ) throw new TypeError$2('Expected sequence with length 2');
4903
- push$3(entries, { key: $toString$1(first.value), value: $toString$1(second.value) });
5703
+ push$4(entries, { key: $toString$1(first.value), value: $toString$1(second.value) });
4904
5704
  }
4905
5705
  } else for (var key in object) if (hasOwn$2(object, key)) {
4906
- push$3(entries, { key: key, value: $toString$1(object[key]) });
5706
+ push$4(entries, { key: key, value: $toString$1(object[key]) });
4907
5707
  }
4908
5708
  },
4909
5709
  parseQuery: function (query) {
@@ -4916,7 +5716,7 @@ URLSearchParamsState.prototype = {
4916
5716
  attribute = attributes[index++];
4917
5717
  if (attribute.length) {
4918
5718
  entry = split$1(attribute, '=');
4919
- push$3(entries, {
5719
+ push$4(entries, {
4920
5720
  key: decode(shift$1(entry)),
4921
5721
  value: decode(join$1(entry, '='))
4922
5722
  });
@@ -4931,7 +5731,7 @@ URLSearchParamsState.prototype = {
4931
5731
  var entry;
4932
5732
  while (index < entries.length) {
4933
5733
  entry = entries[index++];
4934
- push$3(result, serialize(entry.key) + '=' + serialize(entry.value));
5734
+ push$4(result, serialize(entry.key) + '=' + serialize(entry.value));
4935
5735
  } return join$1(result, '&');
4936
5736
  },
4937
5737
  update: function () {
@@ -4960,7 +5760,7 @@ defineBuiltIns(URLSearchParamsPrototype$3, {
4960
5760
  append: function append(name, value) {
4961
5761
  var state = getInternalParamsState(this);
4962
5762
  validateArgumentsLength$3(arguments.length, 2);
4963
- push$3(state.entries, { key: $toString$1(name), value: $toString$1(value) });
5763
+ push$4(state.entries, { key: $toString$1(name), value: $toString$1(value) });
4964
5764
  if (!DESCRIPTORS$3) this.length++;
4965
5765
  state.updateURL();
4966
5766
  },
@@ -5005,7 +5805,7 @@ defineBuiltIns(URLSearchParamsPrototype$3, {
5005
5805
  var result = [];
5006
5806
  var index = 0;
5007
5807
  for (; index < entries.length; index++) {
5008
- if (entries[index].key === key) push$3(result, entries[index].value);
5808
+ if (entries[index].key === key) push$4(result, entries[index].value);
5009
5809
  }
5010
5810
  return result;
5011
5811
  },
@@ -5045,7 +5845,7 @@ defineBuiltIns(URLSearchParamsPrototype$3, {
5045
5845
  }
5046
5846
  }
5047
5847
  }
5048
- if (!found) push$3(entries, { key: key, value: val });
5848
+ if (!found) push$4(entries, { key: key, value: val });
5049
5849
  if (!DESCRIPTORS$3) this.size = entries.length;
5050
5850
  state.updateURL();
5051
5851
  },
@@ -5110,11 +5910,11 @@ $$5({ global: true, constructor: true, forced: !USE_NATIVE_URL$1 }, {
5110
5910
 
5111
5911
  // Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
5112
5912
  if (!USE_NATIVE_URL$1 && isCallable$3(Headers)) {
5113
- var headersHas = uncurryThis$9(HeadersPrototype.has);
5114
- var headersSet = uncurryThis$9(HeadersPrototype.set);
5913
+ var headersHas = uncurryThis$a(HeadersPrototype.has);
5914
+ var headersSet = uncurryThis$a(HeadersPrototype.set);
5115
5915
 
5116
5916
  var wrapRequestOptions = function (init) {
5117
- if (isObject$2(init)) {
5917
+ if (isObject$3(init)) {
5118
5918
  var body = init.body;
5119
5919
  var headers;
5120
5920
  if (classof$1(body) === URL_SEARCH_PARAMS) {
@@ -5165,7 +5965,7 @@ var DESCRIPTORS$2 = descriptors;
5165
5965
  var USE_NATIVE_URL = urlConstructorDetection;
5166
5966
  var globalThis$5 = globalThis_1;
5167
5967
  var bind = functionBindContext;
5168
- var uncurryThis$8 = functionUncurryThis;
5968
+ var uncurryThis$9 = functionUncurryThis;
5169
5969
  var defineBuiltIn$3 = defineBuiltIn$c;
5170
5970
  var defineBuiltInAccessor$2 = defineBuiltInAccessor$5;
5171
5971
  var anInstance = anInstance$3;
@@ -5175,7 +5975,7 @@ var arrayFrom = arrayFrom$1;
5175
5975
  var arraySlice = arraySlice$3;
5176
5976
  var codeAt = stringMultibyte.codeAt;
5177
5977
  var toASCII = stringPunycodeToAscii;
5178
- var $toString = toString$b;
5978
+ var $toString = toString$c;
5179
5979
  var setToStringTag = setToStringTag$6;
5180
5980
  var validateArgumentsLength$2 = validateArgumentsLength$5;
5181
5981
  var URLSearchParamsModule = web_urlSearchParams_constructor;
@@ -5191,18 +5991,18 @@ var TypeError$1 = globalThis$5.TypeError;
5191
5991
  var parseInt$1 = globalThis$5.parseInt;
5192
5992
  var floor$1 = Math.floor;
5193
5993
  var pow = Math.pow;
5194
- var charAt$3 = uncurryThis$8(''.charAt);
5195
- var exec$1 = uncurryThis$8(/./.exec);
5196
- var join = uncurryThis$8([].join);
5197
- var numberToString = uncurryThis$8(1.1.toString);
5198
- var pop = uncurryThis$8([].pop);
5199
- var push$2 = uncurryThis$8([].push);
5200
- var replace$3 = uncurryThis$8(''.replace);
5201
- var shift = uncurryThis$8([].shift);
5202
- var split = uncurryThis$8(''.split);
5203
- var stringSlice$4 = uncurryThis$8(''.slice);
5204
- var toLowerCase = uncurryThis$8(''.toLowerCase);
5205
- var unshift = uncurryThis$8([].unshift);
5994
+ var charAt$3 = uncurryThis$9(''.charAt);
5995
+ var exec$1 = uncurryThis$9(/./.exec);
5996
+ var join = uncurryThis$9([].join);
5997
+ var numberToString = uncurryThis$9(1.1.toString);
5998
+ var pop = uncurryThis$9([].pop);
5999
+ var push$3 = uncurryThis$9([].push);
6000
+ var replace$3 = uncurryThis$9(''.replace);
6001
+ var shift = uncurryThis$9([].shift);
6002
+ var split = uncurryThis$9(''.split);
6003
+ var stringSlice$5 = uncurryThis$9(''.slice);
6004
+ var toLowerCase = uncurryThis$9(''.toLowerCase);
6005
+ var unshift = uncurryThis$9([].unshift);
5206
6006
 
5207
6007
  var INVALID_AUTHORITY = 'Invalid authority';
5208
6008
  var INVALID_SCHEME = 'Invalid scheme';
@@ -5243,7 +6043,7 @@ var parseIPv4 = function (input) {
5243
6043
  radix = 10;
5244
6044
  if (part.length > 1 && charAt$3(part, 0) === '0') {
5245
6045
  radix = exec$1(HEX_START, part) ? 16 : 8;
5246
- part = stringSlice$4(part, radix === 8 ? 1 : 2);
6046
+ part = stringSlice$5(part, radix === 8 ? 1 : 2);
5247
6047
  }
5248
6048
  if (part === '') {
5249
6049
  number = 0;
@@ -5251,7 +6051,7 @@ var parseIPv4 = function (input) {
5251
6051
  if (!exec$1(radix === 10 ? DEC : radix === 8 ? OCT : HEX, part)) return input;
5252
6052
  number = parseInt$1(part, radix);
5253
6053
  }
5254
- push$2(numbers, number);
6054
+ push$3(numbers, number);
5255
6055
  }
5256
6056
  for (index = 0; index < partsLength; index++) {
5257
6057
  number = numbers[index];
@@ -5437,7 +6237,7 @@ var isWindowsDriveLetter = function (string, normalized) {
5437
6237
  // https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
5438
6238
  var startsWithWindowsDriveLetter = function (string) {
5439
6239
  var third;
5440
- return string.length > 1 && isWindowsDriveLetter(stringSlice$4(string, 0, 2)) && (
6240
+ return string.length > 1 && isWindowsDriveLetter(stringSlice$5(string, 0, 2)) && (
5441
6241
  string.length === 2 ||
5442
6242
  ((third = charAt$3(string, 2)) === '/' || third === '\\' || third === '?' || third === '#')
5443
6243
  );
@@ -5567,7 +6367,7 @@ URLState.prototype = {
5567
6367
  pointer++;
5568
6368
  } else {
5569
6369
  url.cannotBeABaseURL = true;
5570
- push$2(url.path, '');
6370
+ push$3(url.path, '');
5571
6371
  state = CANNOT_BE_A_BASE_URL_PATH;
5572
6372
  }
5573
6373
  } else if (!stateOverride) {
@@ -5795,7 +6595,7 @@ URLState.prototype = {
5795
6595
  break;
5796
6596
  }
5797
6597
  if (base && base.scheme === 'file' && !startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) {
5798
- if (isWindowsDriveLetter(base.path[0], true)) push$2(url.path, base.path[0]);
6598
+ if (isWindowsDriveLetter(base.path[0], true)) push$3(url.path, base.path[0]);
5799
6599
  else url.host = base.host;
5800
6600
  }
5801
6601
  state = PATH;
@@ -5844,18 +6644,18 @@ URLState.prototype = {
5844
6644
  if (isDoubleDot(buffer)) {
5845
6645
  url.shortenPath();
5846
6646
  if (chr !== '/' && !(chr === '\\' && url.isSpecial())) {
5847
- push$2(url.path, '');
6647
+ push$3(url.path, '');
5848
6648
  }
5849
6649
  } else if (isSingleDot(buffer)) {
5850
6650
  if (chr !== '/' && !(chr === '\\' && url.isSpecial())) {
5851
- push$2(url.path, '');
6651
+ push$3(url.path, '');
5852
6652
  }
5853
6653
  } else {
5854
6654
  if (url.scheme === 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
5855
6655
  if (url.host) url.host = '';
5856
6656
  buffer = charAt$3(buffer, 0) + ':'; // normalize windows drive letter
5857
6657
  }
5858
- push$2(url.path, buffer);
6658
+ push$3(url.path, buffer);
5859
6659
  }
5860
6660
  buffer = '';
5861
6661
  if (url.scheme === 'file' && (chr === EOF || chr === '?' || chr === '#')) {
@@ -5908,7 +6708,7 @@ URLState.prototype = {
5908
6708
  var result, codePoints, index;
5909
6709
  if (charAt$3(input, 0) === '[') {
5910
6710
  if (charAt$3(input, input.length - 1) !== ']') return INVALID_HOST;
5911
- result = parseIPv6(stringSlice$4(input, 1, -1));
6711
+ result = parseIPv6(stringSlice$5(input, 1, -1));
5912
6712
  if (!result) return INVALID_HOST;
5913
6713
  this.host = result;
5914
6714
  // opaque host
@@ -6074,7 +6874,7 @@ URLState.prototype = {
6074
6874
  if (search === '') {
6075
6875
  this.query = null;
6076
6876
  } else {
6077
- if (charAt$3(search, 0) === '?') search = stringSlice$4(search, 1);
6877
+ if (charAt$3(search, 0) === '?') search = stringSlice$5(search, 1);
6078
6878
  this.query = '';
6079
6879
  this.parse(search, QUERY);
6080
6880
  }
@@ -6095,7 +6895,7 @@ URLState.prototype = {
6095
6895
  this.fragment = null;
6096
6896
  return;
6097
6897
  }
6098
- if (charAt$3(hash, 0) === '#') hash = stringSlice$4(hash, 1);
6898
+ if (charAt$3(hash, 0) === '#') hash = stringSlice$5(hash, 1);
6099
6899
  this.fragment = '';
6100
6900
  this.parse(hash, FRAGMENT);
6101
6901
  },
@@ -6210,27 +7010,27 @@ $$4({ global: true, constructor: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTO
6210
7010
  });
6211
7011
 
6212
7012
  var $$3 = _export;
6213
- var call$5 = functionCall;
7013
+ var call$6 = functionCall;
6214
7014
 
6215
7015
  // `URL.prototype.toJSON` method
6216
7016
  // https://url.spec.whatwg.org/#dom-url-tojson
6217
7017
  $$3({ target: 'URL', proto: true, enumerable: true }, {
6218
7018
  toJSON: function toJSON() {
6219
- return call$5(URL.prototype.toString, this);
7019
+ return call$6(URL.prototype.toString, this);
6220
7020
  }
6221
7021
  });
6222
7022
 
6223
7023
  var defineBuiltIn$2 = defineBuiltIn$c;
6224
- var uncurryThis$7 = functionUncurryThis;
6225
- var toString$5 = toString$b;
7024
+ var uncurryThis$8 = functionUncurryThis;
7025
+ var toString$6 = toString$c;
6226
7026
  var validateArgumentsLength$1 = validateArgumentsLength$5;
6227
7027
 
6228
7028
  var $URLSearchParams$1 = URLSearchParams;
6229
7029
  var URLSearchParamsPrototype$2 = $URLSearchParams$1.prototype;
6230
- var append = uncurryThis$7(URLSearchParamsPrototype$2.append);
6231
- var $delete = uncurryThis$7(URLSearchParamsPrototype$2['delete']);
6232
- var forEach$1 = uncurryThis$7(URLSearchParamsPrototype$2.forEach);
6233
- var push$1 = uncurryThis$7([].push);
7030
+ var append = uncurryThis$8(URLSearchParamsPrototype$2.append);
7031
+ var $delete = uncurryThis$8(URLSearchParamsPrototype$2['delete']);
7032
+ var forEach$1 = uncurryThis$8(URLSearchParamsPrototype$2.forEach);
7033
+ var push$2 = uncurryThis$8([].push);
6234
7034
  var params$1 = new $URLSearchParams$1('a=1&a=2&b=3');
6235
7035
 
6236
7036
  params$1['delete']('a', 1);
@@ -6245,11 +7045,11 @@ if (params$1 + '' !== 'a=2') {
6245
7045
  if (length && $value === undefined) return $delete(this, name);
6246
7046
  var entries = [];
6247
7047
  forEach$1(this, function (v, k) { // also validates `this`
6248
- push$1(entries, { key: k, value: v });
7048
+ push$2(entries, { key: k, value: v });
6249
7049
  });
6250
7050
  validateArgumentsLength$1(length, 1);
6251
- var key = toString$5(name);
6252
- var value = toString$5($value);
7051
+ var key = toString$6(name);
7052
+ var value = toString$6($value);
6253
7053
  var index = 0;
6254
7054
  var dindex = 0;
6255
7055
  var found = false;
@@ -6270,14 +7070,14 @@ if (params$1 + '' !== 'a=2') {
6270
7070
  }
6271
7071
 
6272
7072
  var defineBuiltIn$1 = defineBuiltIn$c;
6273
- var uncurryThis$6 = functionUncurryThis;
6274
- var toString$4 = toString$b;
7073
+ var uncurryThis$7 = functionUncurryThis;
7074
+ var toString$5 = toString$c;
6275
7075
  var validateArgumentsLength = validateArgumentsLength$5;
6276
7076
 
6277
7077
  var $URLSearchParams = URLSearchParams;
6278
7078
  var URLSearchParamsPrototype$1 = $URLSearchParams.prototype;
6279
- var getAll = uncurryThis$6(URLSearchParamsPrototype$1.getAll);
6280
- var $has = uncurryThis$6(URLSearchParamsPrototype$1.has);
7079
+ var getAll = uncurryThis$7(URLSearchParamsPrototype$1.getAll);
7080
+ var $has = uncurryThis$7(URLSearchParamsPrototype$1.has);
6281
7081
  var params = new $URLSearchParams('a=1');
6282
7082
 
6283
7083
  // `undefined` case is a Chromium 117 bug
@@ -6289,7 +7089,7 @@ if (params.has('a', 2) || !params.has('a', undefined)) {
6289
7089
  if (length && $value === undefined) return $has(this, name);
6290
7090
  var values = getAll(this, name); // also validates `this`
6291
7091
  validateArgumentsLength(length, 1);
6292
- var value = toString$4($value);
7092
+ var value = toString$5($value);
6293
7093
  var index = 0;
6294
7094
  while (index < values.length) {
6295
7095
  if (values[index++] === value) return true;
@@ -6298,11 +7098,11 @@ if (params.has('a', 2) || !params.has('a', undefined)) {
6298
7098
  }
6299
7099
 
6300
7100
  var DESCRIPTORS$1 = descriptors;
6301
- var uncurryThis$5 = functionUncurryThis;
7101
+ var uncurryThis$6 = functionUncurryThis;
6302
7102
  var defineBuiltInAccessor$1 = defineBuiltInAccessor$5;
6303
7103
 
6304
7104
  var URLSearchParamsPrototype = URLSearchParams.prototype;
6305
- var forEach = uncurryThis$5(URLSearchParamsPrototype.forEach);
7105
+ var forEach = uncurryThis$6(URLSearchParamsPrototype.forEach);
6306
7106
 
6307
7107
  // `URLSearchParams.prototype.size` getter
6308
7108
  // https://github.com/whatwg/url/pull/734
@@ -6321,11 +7121,11 @@ if (DESCRIPTORS$1 && !('size' in URLSearchParamsPrototype)) {
6321
7121
  var $$2 = _export;
6322
7122
  var DESCRIPTORS = descriptors;
6323
7123
  var globalThis$4 = globalThis_1;
6324
- var uncurryThis$4 = functionUncurryThis;
7124
+ var uncurryThis$5 = functionUncurryThis;
6325
7125
  var hasOwn = hasOwnProperty_1;
6326
7126
  var isCallable$2 = isCallable$n;
6327
7127
  var isPrototypeOf = objectIsPrototypeOf;
6328
- var toString$3 = toString$b;
7128
+ var toString$4 = toString$c;
6329
7129
  var defineBuiltInAccessor = defineBuiltInAccessor$5;
6330
7130
  var copyConstructorProperties = copyConstructorProperties$2;
6331
7131
 
@@ -6339,7 +7139,7 @@ if (DESCRIPTORS && isCallable$2(NativeSymbol) && (!('description' in SymbolProto
6339
7139
  var EmptyStringDescriptionStore = {};
6340
7140
  // wrap Symbol constructor for correct work with undefined description
6341
7141
  var SymbolWrapper = function Symbol() {
6342
- var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$3(arguments[0]);
7142
+ var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$4(arguments[0]);
6343
7143
  var result = isPrototypeOf(SymbolPrototype, this)
6344
7144
  // eslint-disable-next-line sonarjs/inconsistent-function-call -- ok
6345
7145
  ? new NativeSymbol(description)
@@ -6354,11 +7154,11 @@ if (DESCRIPTORS && isCallable$2(NativeSymbol) && (!('description' in SymbolProto
6354
7154
  SymbolPrototype.constructor = SymbolWrapper;
6355
7155
 
6356
7156
  var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
6357
- var thisSymbolValue = uncurryThis$4(SymbolPrototype.valueOf);
6358
- var symbolDescriptiveString = uncurryThis$4(SymbolPrototype.toString);
7157
+ var thisSymbolValue = uncurryThis$5(SymbolPrototype.valueOf);
7158
+ var symbolDescriptiveString = uncurryThis$5(SymbolPrototype.toString);
6359
7159
  var regexp = /^Symbol\((.*)\)[^)]+$/;
6360
- var replace$2 = uncurryThis$4(''.replace);
6361
- var stringSlice$3 = uncurryThis$4(''.slice);
7160
+ var replace$2 = uncurryThis$5(''.replace);
7161
+ var stringSlice$4 = uncurryThis$5(''.slice);
6362
7162
 
6363
7163
  defineBuiltInAccessor(SymbolPrototype, 'description', {
6364
7164
  configurable: true,
@@ -6366,7 +7166,7 @@ if (DESCRIPTORS && isCallable$2(NativeSymbol) && (!('description' in SymbolProto
6366
7166
  var symbol = thisSymbolValue(this);
6367
7167
  if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
6368
7168
  var string = symbolDescriptiveString(symbol);
6369
- var desc = NATIVE_SYMBOL ? stringSlice$3(string, 7, -1) : replace$2(string, regexp, '$1');
7169
+ var desc = NATIVE_SYMBOL ? stringSlice$4(string, 7, -1) : replace$2(string, regexp, '$1');
6370
7170
  return desc === '' ? undefined : desc;
6371
7171
  }
6372
7172
  });
@@ -6662,29 +7462,27 @@ const DatasetRowConnect = ({
6662
7462
  service: serviceUrl,
6663
7463
  name: layerName,
6664
7464
  id: webmapUtils.generateLayerId(),
6665
- layerType: LayerType.featureLayer
7465
+ layerType: LayerType.featureLayer,
7466
+ isSelectable: true
6666
7467
  };
6667
7468
  dispatchAddLayer({
6668
7469
  layerId: layer.id,
6669
7470
  layer,
6670
7471
  origin: layerTypes.LayerActionOrigin.dataExplorer
6671
7472
  });
7473
+ setGeoJsonUrl(null);
6672
7474
  }
6673
7475
  };
6674
7476
  addGeoJsonLayer();
6675
7477
  }, [geoJsonData, dispatchAddLayer, serviceUrl, layerName, foundLayer, geoJsonUrl]);
6676
7478
  const deleteLayer = React__default.useCallback(() => {
6677
- // Remove the GeoJSON URL so that it does not get refetched
6678
- if (geoJsonUrl) {
6679
- setGeoJsonUrl(null);
6680
- }
6681
7479
  dispatch(layerActions.layerDelete({
6682
7480
  mapId: activeMapId,
6683
7481
  layerId: foundLayer == null ? void 0 : foundLayer.id,
6684
7482
  layerIndex: foundLayerIndex,
6685
7483
  origin: layerTypes.LayerActionOrigin.layerManager
6686
7484
  }));
6687
- }, [geoJsonUrl, dispatch, activeMapId, foundLayer == null ? void 0 : foundLayer.id, foundLayerIndex]);
7485
+ }, [dispatch, activeMapId, foundLayer == null ? void 0 : foundLayer.id, foundLayerIndex]);
6688
7486
  // Add layer to the map
6689
7487
  const addLayer = React__default.useCallback(() => {
6690
7488
  if (!serviceUrl || !layerName || !datasetFormat) {
@@ -6958,19 +7756,21 @@ const AreaFilterLocationSearch = ({
6958
7756
  setSelectedValue(null);
6959
7757
  }
6960
7758
  },
6961
- InputProps: Object.assign({}, params.InputProps, {
6962
- endAdornment: jsx(CustomIconButton, {
6963
- tooltipTitle: t('search-clear'),
6964
- onClick: () => {
6965
- setInputValue('');
6966
- setSelectedValue(null);
6967
- },
6968
- sx: {
6969
- marginRight: 1
6970
- },
6971
- children: jsx(Close, {})
7759
+ slotProps: {
7760
+ input: Object.assign({}, params.InputProps, {
7761
+ endAdornment: jsx(CustomIconButton, {
7762
+ tooltipTitle: t('search-clear'),
7763
+ onClick: () => {
7764
+ setInputValue('');
7765
+ setSelectedValue(null);
7766
+ },
7767
+ sx: {
7768
+ marginRight: 1
7769
+ },
7770
+ children: jsx(Close, {})
7771
+ })
6972
7772
  })
6973
- })
7773
+ }
6974
7774
  }))
6975
7775
  })
6976
7776
  });
@@ -6982,7 +7782,7 @@ const initialView = {
6982
7782
  center: [0, 0]
6983
7783
  };
6984
7784
  // Normalize longitude values so that they are between -180 and 180 degrees
6985
- const normalizeLongitude = lon => {
7785
+ const normalizeLongitude$1 = lon => {
6986
7786
  let normalized = lon;
6987
7787
  while (normalized < -180) {
6988
7788
  normalized += 360;
@@ -7011,8 +7811,8 @@ const AreaFilterConnect = () => {
7011
7811
  const extent = view.current.calculateExtent();
7012
7812
  const transformedExtent = transformExtent(extent, view.current.getProjection(), 'EPSG:4326');
7013
7813
  // The map can be panned left or right beyond the -180/180 longitude range, so values need to be normalized
7014
- transformedExtent[0] = normalizeLongitude(transformedExtent[0]);
7015
- transformedExtent[2] = normalizeLongitude(transformedExtent[2]);
7814
+ transformedExtent[0] = normalizeLongitude$1(transformedExtent[0]);
7815
+ transformedExtent[2] = normalizeLongitude$1(transformedExtent[2]);
7016
7816
  dispatch(dataExplorerActions.setBbox({
7017
7817
  bbox: transformedExtent
7018
7818
  }));
@@ -7279,6 +8079,7 @@ const InfoDialogBaseInfo = ({
7279
8079
  const formatLanguage = language => {
7280
8080
  switch (language) {
7281
8081
  case 'en':
8082
+ case 'eng':
7282
8083
  return 'English';
7283
8084
  case 'fi':
7284
8085
  return 'Finnish';
@@ -7360,8 +8161,10 @@ const InfoDialogBaseInfo = ({
7360
8161
  children: t('base-info-language')
7361
8162
  })
7362
8163
  }), jsx(Grid, {
7363
- children: jsx(Typography, {
8164
+ children: properties.language.code ? jsx(Typography, {
7364
8165
  children: formatLanguage(properties.language.code)
8166
+ }) : jsx(Typography, {
8167
+ children: formatLanguage(properties.language)
7365
8168
  })
7366
8169
  })]
7367
8170
  }), jsxs(Grid, {
@@ -7379,7 +8182,7 @@ const InfoDialogBaseInfo = ({
7379
8182
  children: properties['wmo:dataPolicy'].charAt(0).toUpperCase() + properties['wmo:dataPolicy'].slice(1)
7380
8183
  })
7381
8184
  })]
7382
- }), jsxs(Grid, {
8185
+ }), properties.formats && jsxs(Grid, {
7383
8186
  container: true,
7384
8187
  direction: "column",
7385
8188
  spacing: 0,
@@ -7390,7 +8193,7 @@ const InfoDialogBaseInfo = ({
7390
8193
  children: t('base-info-format')
7391
8194
  })
7392
8195
  }), jsx(Grid, {
7393
- children: properties.formats && properties.formats.map(format => jsx(Typography, {
8196
+ children: properties.formats.map(format => jsx(Typography, {
7394
8197
  children: format.name
7395
8198
  }, format.name))
7396
8199
  })]
@@ -7540,13 +8343,13 @@ const InfoDialogGeographicalCoverage = ({
7540
8343
  });
7541
8344
  };
7542
8345
 
7543
- var fails$4 = fails$p;
8346
+ var fails$5 = fails$q;
7544
8347
  var globalThis$3 = globalThis_1;
7545
8348
 
7546
8349
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
7547
8350
  var $RegExp$2 = globalThis$3.RegExp;
7548
8351
 
7549
- var UNSUPPORTED_Y$1 = fails$4(function () {
8352
+ var UNSUPPORTED_Y$2 = fails$5(function () {
7550
8353
  var re = $RegExp$2('a', 'y');
7551
8354
  re.lastIndex = 2;
7552
8355
  return re.exec('abcd') !== null;
@@ -7554,11 +8357,11 @@ var UNSUPPORTED_Y$1 = fails$4(function () {
7554
8357
 
7555
8358
  // UC Browser bug
7556
8359
  // https://github.com/zloirock/core-js/issues/1008
7557
- UNSUPPORTED_Y$1 || fails$4(function () {
8360
+ UNSUPPORTED_Y$2 || fails$5(function () {
7558
8361
  return !$RegExp$2('a', 'y').sticky;
7559
8362
  });
7560
8363
 
7561
- var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
8364
+ var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$5(function () {
7562
8365
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
7563
8366
  var re = $RegExp$2('^r', 'gy');
7564
8367
  re.lastIndex = 2;
@@ -7566,26 +8369,28 @@ var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
7566
8369
  });
7567
8370
 
7568
8371
  var regexpStickyHelpers = {
7569
- BROKEN_CARET: BROKEN_CARET};
8372
+ BROKEN_CARET: BROKEN_CARET,
8373
+ UNSUPPORTED_Y: UNSUPPORTED_Y$2
8374
+ };
7570
8375
 
7571
- var fails$3 = fails$p;
8376
+ var fails$4 = fails$q;
7572
8377
  var globalThis$2 = globalThis_1;
7573
8378
 
7574
8379
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
7575
8380
  var $RegExp$1 = globalThis$2.RegExp;
7576
8381
 
7577
- var regexpUnsupportedDotAll = fails$3(function () {
8382
+ var regexpUnsupportedDotAll = fails$4(function () {
7578
8383
  var re = $RegExp$1('.', 's');
7579
8384
  return !(re.dotAll && re.test('\n') && re.flags === 's');
7580
8385
  });
7581
8386
 
7582
- var fails$2 = fails$p;
8387
+ var fails$3 = fails$q;
7583
8388
  var globalThis$1 = globalThis_1;
7584
8389
 
7585
8390
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
7586
8391
  var $RegExp = globalThis$1.RegExp;
7587
8392
 
7588
- var regexpUnsupportedNcg = fails$2(function () {
8393
+ var regexpUnsupportedNcg = fails$3(function () {
7589
8394
  var re = $RegExp('(?<a>b)', 'g');
7590
8395
  return re.exec('b').groups.a !== 'b' ||
7591
8396
  'b'.replace(re, '$<a>c') !== 'bc';
@@ -7593,11 +8398,11 @@ var regexpUnsupportedNcg = fails$2(function () {
7593
8398
 
7594
8399
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
7595
8400
  /* eslint-disable regexp/no-useless-quantifier -- testing */
7596
- var call$4 = functionCall;
7597
- var uncurryThis$3 = functionUncurryThis;
7598
- var toString$2 = toString$b;
8401
+ var call$5 = functionCall;
8402
+ var uncurryThis$4 = functionUncurryThis;
8403
+ var toString$3 = toString$c;
7599
8404
  var regexpFlags = regexpFlags$1;
7600
- var stickyHelpers = regexpStickyHelpers;
8405
+ var stickyHelpers$1 = regexpStickyHelpers;
7601
8406
  var shared = shared$4;
7602
8407
  var create = objectCreate;
7603
8408
  var getInternalState = internalState.get;
@@ -7607,44 +8412,44 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
7607
8412
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
7608
8413
  var nativeExec = RegExp.prototype.exec;
7609
8414
  var patchedExec = nativeExec;
7610
- var charAt$2 = uncurryThis$3(''.charAt);
7611
- var indexOf = uncurryThis$3(''.indexOf);
7612
- var replace$1 = uncurryThis$3(''.replace);
7613
- var stringSlice$2 = uncurryThis$3(''.slice);
8415
+ var charAt$2 = uncurryThis$4(''.charAt);
8416
+ var indexOf = uncurryThis$4(''.indexOf);
8417
+ var replace$1 = uncurryThis$4(''.replace);
8418
+ var stringSlice$3 = uncurryThis$4(''.slice);
7614
8419
 
7615
8420
  var UPDATES_LAST_INDEX_WRONG = (function () {
7616
8421
  var re1 = /a/;
7617
8422
  var re2 = /b*/g;
7618
- call$4(nativeExec, re1, 'a');
7619
- call$4(nativeExec, re2, 'a');
8423
+ call$5(nativeExec, re1, 'a');
8424
+ call$5(nativeExec, re2, 'a');
7620
8425
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
7621
8426
  })();
7622
8427
 
7623
- var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
8428
+ var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
7624
8429
 
7625
8430
  // nonparticipating capturing group, copied from es5-shim's String#split patch.
7626
8431
  var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
7627
8432
 
7628
- var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
8433
+ var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
7629
8434
 
7630
8435
  if (PATCH) {
7631
8436
  patchedExec = function exec(string) {
7632
8437
  var re = this;
7633
8438
  var state = getInternalState(re);
7634
- var str = toString$2(string);
8439
+ var str = toString$3(string);
7635
8440
  var raw = state.raw;
7636
8441
  var result, reCopy, lastIndex, match, i, object, group;
7637
8442
 
7638
8443
  if (raw) {
7639
8444
  raw.lastIndex = re.lastIndex;
7640
- result = call$4(patchedExec, raw, str);
8445
+ result = call$5(patchedExec, raw, str);
7641
8446
  re.lastIndex = raw.lastIndex;
7642
8447
  return result;
7643
8448
  }
7644
8449
 
7645
8450
  var groups = state.groups;
7646
- var sticky = UNSUPPORTED_Y && re.sticky;
7647
- var flags = call$4(regexpFlags, re);
8451
+ var sticky = UNSUPPORTED_Y$1 && re.sticky;
8452
+ var flags = call$5(regexpFlags, re);
7648
8453
  var source = re.source;
7649
8454
  var charsAdded = 0;
7650
8455
  var strCopy = str;
@@ -7655,7 +8460,7 @@ if (PATCH) {
7655
8460
  flags += 'g';
7656
8461
  }
7657
8462
 
7658
- strCopy = stringSlice$2(str, re.lastIndex);
8463
+ strCopy = stringSlice$3(str, re.lastIndex);
7659
8464
  // Support anchored sticky behavior.
7660
8465
  if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$2(str, re.lastIndex - 1) !== '\n')) {
7661
8466
  source = '(?: ' + source + ')';
@@ -7672,12 +8477,12 @@ if (PATCH) {
7672
8477
  }
7673
8478
  if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
7674
8479
 
7675
- match = call$4(nativeExec, sticky ? reCopy : re, strCopy);
8480
+ match = call$5(nativeExec, sticky ? reCopy : re, strCopy);
7676
8481
 
7677
8482
  if (sticky) {
7678
8483
  if (match) {
7679
- match.input = stringSlice$2(match.input, charsAdded);
7680
- match[0] = stringSlice$2(match[0], charsAdded);
8484
+ match.input = stringSlice$3(match.input, charsAdded);
8485
+ match[0] = stringSlice$3(match[0], charsAdded);
7681
8486
  match.index = re.lastIndex;
7682
8487
  re.lastIndex += match[0].length;
7683
8488
  } else re.lastIndex = 0;
@@ -7687,7 +8492,7 @@ if (PATCH) {
7687
8492
  if (NPCG_INCLUDED && match && match.length > 1) {
7688
8493
  // Fix browsers whose `exec` methods don't consistently return `undefined`
7689
8494
  // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
7690
- call$4(nativeReplace, match[0], reCopy, function () {
8495
+ call$5(nativeReplace, match[0], reCopy, function () {
7691
8496
  for (i = 1; i < arguments.length - 2; i++) {
7692
8497
  if (arguments[i] === undefined) match[i] = undefined;
7693
8498
  }
@@ -7719,10 +8524,10 @@ $$1({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
7719
8524
 
7720
8525
  // TODO: Remove from `core-js@4` since it's moved to entry points
7721
8526
 
7722
- var call$3 = functionCall;
8527
+ var call$4 = functionCall;
7723
8528
  var defineBuiltIn = defineBuiltIn$c;
7724
8529
  var regexpExec$1 = regexpExec$2;
7725
- var fails$1 = fails$p;
8530
+ var fails$2 = fails$q;
7726
8531
  var wellKnownSymbol$1 = wellKnownSymbol$l;
7727
8532
  var createNonEnumerableProperty = createNonEnumerableProperty$5;
7728
8533
 
@@ -7732,14 +8537,14 @@ var RegExpPrototype = RegExp.prototype;
7732
8537
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
7733
8538
  var SYMBOL = wellKnownSymbol$1(KEY);
7734
8539
 
7735
- var DELEGATES_TO_SYMBOL = !fails$1(function () {
8540
+ var DELEGATES_TO_SYMBOL = !fails$2(function () {
7736
8541
  // String methods call symbol-named RegExp methods
7737
8542
  var O = {};
7738
8543
  O[SYMBOL] = function () { return 7; };
7739
8544
  return ''[KEY](O) !== 7;
7740
8545
  });
7741
8546
 
7742
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () {
8547
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$2(function () {
7743
8548
  // Symbol-named RegExp methods call .exec
7744
8549
  var execCalled = false;
7745
8550
  var re = /a/;
@@ -7779,9 +8584,9 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
7779
8584
  // The native String method already delegates to @@method (this
7780
8585
  // polyfilled function), leasing to infinite recursion.
7781
8586
  // We avoid it by directly calling the native @@method method.
7782
- return { done: true, value: call$3(nativeRegExpMethod, regexp, str, arg2) };
8587
+ return { done: true, value: call$4(nativeRegExpMethod, regexp, str, arg2) };
7783
8588
  }
7784
- return { done: true, value: call$3(nativeMethod, str, regexp, arg2) };
8589
+ return { done: true, value: call$4(nativeMethod, str, regexp, arg2) };
7785
8590
  }
7786
8591
  return { done: false };
7787
8592
  });
@@ -7797,12 +8602,12 @@ var charAt$1 = stringMultibyte.charAt;
7797
8602
 
7798
8603
  // `AdvanceStringIndex` abstract operation
7799
8604
  // https://tc39.es/ecma262/#sec-advancestringindex
7800
- var advanceStringIndex$2 = function (S, index, unicode) {
8605
+ var advanceStringIndex$3 = function (S, index, unicode) {
7801
8606
  return index + (unicode ? charAt$1(S, index).length : 1);
7802
8607
  };
7803
8608
 
7804
- var call$2 = functionCall;
7805
- var anObject$2 = anObject$g;
8609
+ var call$3 = functionCall;
8610
+ var anObject$3 = anObject$h;
7806
8611
  var isCallable$1 = isCallable$n;
7807
8612
  var classof = classofRaw$2;
7808
8613
  var regexpExec = regexpExec$2;
@@ -7814,61 +8619,61 @@ var $TypeError = TypeError;
7814
8619
  var regexpExecAbstract = function (R, S) {
7815
8620
  var exec = R.exec;
7816
8621
  if (isCallable$1(exec)) {
7817
- var result = call$2(exec, R, S);
7818
- if (result !== null) anObject$2(result);
8622
+ var result = call$3(exec, R, S);
8623
+ if (result !== null) anObject$3(result);
7819
8624
  return result;
7820
8625
  }
7821
- if (classof(R) === 'RegExp') return call$2(regexpExec, R, S);
8626
+ if (classof(R) === 'RegExp') return call$3(regexpExec, R, S);
7822
8627
  throw new $TypeError('RegExp#exec called on incompatible receiver');
7823
8628
  };
7824
8629
 
7825
- var call$1 = functionCall;
7826
- var uncurryThis$2 = functionUncurryThis;
7827
- var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
7828
- var anObject$1 = anObject$g;
7829
- var isObject$1 = isObject$f;
7830
- var toLength$1 = toLength$4;
7831
- var toString$1 = toString$b;
7832
- var requireObjectCoercible$1 = requireObjectCoercible$8;
7833
- var getMethod$1 = getMethod$5;
7834
- var advanceStringIndex$1 = advanceStringIndex$2;
8630
+ var call$2 = functionCall;
8631
+ var uncurryThis$3 = functionUncurryThis;
8632
+ var fixRegExpWellKnownSymbolLogic$2 = fixRegexpWellKnownSymbolLogic;
8633
+ var anObject$2 = anObject$h;
8634
+ var isObject$2 = isObject$g;
8635
+ var toLength$2 = toLength$5;
8636
+ var toString$2 = toString$c;
8637
+ var requireObjectCoercible$2 = requireObjectCoercible$9;
8638
+ var getMethod$2 = getMethod$6;
8639
+ var advanceStringIndex$2 = advanceStringIndex$3;
7835
8640
  var getRegExpFlags$1 = regexpGetFlags;
7836
- var regExpExec$1 = regexpExecAbstract;
8641
+ var regExpExec$2 = regexpExecAbstract;
7837
8642
 
7838
- var stringIndexOf$1 = uncurryThis$2(''.indexOf);
8643
+ var stringIndexOf$1 = uncurryThis$3(''.indexOf);
7839
8644
 
7840
8645
  // @@match logic
7841
- fixRegExpWellKnownSymbolLogic$1('match', function (MATCH, nativeMatch, maybeCallNative) {
8646
+ fixRegExpWellKnownSymbolLogic$2('match', function (MATCH, nativeMatch, maybeCallNative) {
7842
8647
  return [
7843
8648
  // `String.prototype.match` method
7844
8649
  // https://tc39.es/ecma262/#sec-string.prototype.match
7845
8650
  function match(regexp) {
7846
- var O = requireObjectCoercible$1(this);
7847
- var matcher = isObject$1(regexp) ? getMethod$1(regexp, MATCH) : undefined;
7848
- return matcher ? call$1(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString$1(O));
8651
+ var O = requireObjectCoercible$2(this);
8652
+ var matcher = isObject$2(regexp) ? getMethod$2(regexp, MATCH) : undefined;
8653
+ return matcher ? call$2(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString$2(O));
7849
8654
  },
7850
8655
  // `RegExp.prototype[@@match]` method
7851
8656
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@match
7852
8657
  function (string) {
7853
- var rx = anObject$1(this);
7854
- var S = toString$1(string);
8658
+ var rx = anObject$2(this);
8659
+ var S = toString$2(string);
7855
8660
  var res = maybeCallNative(nativeMatch, rx, S);
7856
8661
 
7857
8662
  if (res.done) return res.value;
7858
8663
 
7859
- var flags = toString$1(getRegExpFlags$1(rx));
8664
+ var flags = toString$2(getRegExpFlags$1(rx));
7860
8665
 
7861
- if (stringIndexOf$1(flags, 'g') === -1) return regExpExec$1(rx, S);
8666
+ if (stringIndexOf$1(flags, 'g') === -1) return regExpExec$2(rx, S);
7862
8667
 
7863
8668
  var fullUnicode = stringIndexOf$1(flags, 'u') !== -1;
7864
8669
  rx.lastIndex = 0;
7865
8670
  var A = [];
7866
8671
  var n = 0;
7867
8672
  var result;
7868
- while ((result = regExpExec$1(rx, S)) !== null) {
7869
- var matchStr = toString$1(result[0]);
8673
+ while ((result = regExpExec$2(rx, S)) !== null) {
8674
+ var matchStr = toString$2(result[0]);
7870
8675
  A[n] = matchStr;
7871
- if (matchStr === '') rx.lastIndex = advanceStringIndex$1(S, toLength$1(rx.lastIndex), fullUnicode);
8676
+ if (matchStr === '') rx.lastIndex = advanceStringIndex$2(S, toLength$2(rx.lastIndex), fullUnicode);
7872
8677
  n++;
7873
8678
  }
7874
8679
  return n === 0 ? null : A;
@@ -8079,13 +8884,13 @@ const InfoDialogLinks = ({
8079
8884
  }, href);
8080
8885
  };
8081
8886
 
8082
- var uncurryThis$1 = functionUncurryThis;
8887
+ var uncurryThis$2 = functionUncurryThis;
8083
8888
  var toObject = toObject$9;
8084
8889
 
8085
8890
  var floor = Math.floor;
8086
- var charAt = uncurryThis$1(''.charAt);
8087
- var replace = uncurryThis$1(''.replace);
8088
- var stringSlice$1 = uncurryThis$1(''.slice);
8891
+ var charAt = uncurryThis$2(''.charAt);
8892
+ var replace = uncurryThis$2(''.replace);
8893
+ var stringSlice$2 = uncurryThis$2(''.slice);
8089
8894
  // eslint-disable-next-line redos/no-vulnerable -- safe
8090
8895
  var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
8091
8896
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
@@ -8105,10 +8910,10 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
8105
8910
  switch (charAt(ch, 0)) {
8106
8911
  case '$': return '$';
8107
8912
  case '&': return matched;
8108
- case '`': return stringSlice$1(str, 0, position);
8109
- case "'": return stringSlice$1(str, tailPos);
8913
+ case '`': return stringSlice$2(str, 0, position);
8914
+ case "'": return stringSlice$2(str, tailPos);
8110
8915
  case '<':
8111
- capture = namedCaptures[stringSlice$1(ch, 1, -1)];
8916
+ capture = namedCaptures[stringSlice$2(ch, 1, -1)];
8112
8917
  break;
8113
8918
  default: // \d\d?
8114
8919
  var n = +ch;
@@ -8126,31 +8931,31 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
8126
8931
  };
8127
8932
 
8128
8933
  var apply = functionApply;
8129
- var call = functionCall;
8130
- var uncurryThis = functionUncurryThis;
8131
- var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
8132
- var fails = fails$p;
8133
- var anObject = anObject$g;
8934
+ var call$1 = functionCall;
8935
+ var uncurryThis$1 = functionUncurryThis;
8936
+ var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
8937
+ var fails$1 = fails$q;
8938
+ var anObject$1 = anObject$h;
8134
8939
  var isCallable = isCallable$n;
8135
- var isObject = isObject$f;
8940
+ var isObject$1 = isObject$g;
8136
8941
  var toIntegerOrInfinity = toIntegerOrInfinity$5;
8137
- var toLength = toLength$4;
8138
- var toString = toString$b;
8139
- var requireObjectCoercible = requireObjectCoercible$8;
8140
- var advanceStringIndex = advanceStringIndex$2;
8141
- var getMethod = getMethod$5;
8942
+ var toLength$1 = toLength$5;
8943
+ var toString$1 = toString$c;
8944
+ var requireObjectCoercible$1 = requireObjectCoercible$9;
8945
+ var advanceStringIndex$1 = advanceStringIndex$3;
8946
+ var getMethod$1 = getMethod$6;
8142
8947
  var getSubstitution = getSubstitution$1;
8143
8948
  var getRegExpFlags = regexpGetFlags;
8144
- var regExpExec = regexpExecAbstract;
8949
+ var regExpExec$1 = regexpExecAbstract;
8145
8950
  var wellKnownSymbol = wellKnownSymbol$l;
8146
8951
 
8147
8952
  var REPLACE = wellKnownSymbol('replace');
8148
8953
  var max = Math.max;
8149
- var min = Math.min;
8150
- var concat = uncurryThis([].concat);
8151
- var push = uncurryThis([].push);
8152
- var stringIndexOf = uncurryThis(''.indexOf);
8153
- var stringSlice = uncurryThis(''.slice);
8954
+ var min$1 = Math.min;
8955
+ var concat = uncurryThis$1([].concat);
8956
+ var push$1 = uncurryThis$1([].push);
8957
+ var stringIndexOf = uncurryThis$1(''.indexOf);
8958
+ var stringSlice$1 = uncurryThis$1(''.slice);
8154
8959
 
8155
8960
  var maybeToString = function (it) {
8156
8961
  return it === undefined ? it : String(it);
@@ -8171,7 +8976,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
8171
8976
  return false;
8172
8977
  })();
8173
8978
 
8174
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
8979
+ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$1(function () {
8175
8980
  var re = /./;
8176
8981
  re.exec = function () {
8177
8982
  var result = [];
@@ -8183,24 +8988,24 @@ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
8183
8988
  });
8184
8989
 
8185
8990
  // @@replace logic
8186
- fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
8991
+ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCallNative) {
8187
8992
  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
8188
8993
 
8189
8994
  return [
8190
8995
  // `String.prototype.replace` method
8191
8996
  // https://tc39.es/ecma262/#sec-string.prototype.replace
8192
8997
  function replace(searchValue, replaceValue) {
8193
- var O = requireObjectCoercible(this);
8194
- var replacer = isObject(searchValue) ? getMethod(searchValue, REPLACE) : undefined;
8998
+ var O = requireObjectCoercible$1(this);
8999
+ var replacer = isObject$1(searchValue) ? getMethod$1(searchValue, REPLACE) : undefined;
8195
9000
  return replacer
8196
- ? call(replacer, searchValue, O, replaceValue)
8197
- : call(nativeReplace, toString(O), searchValue, replaceValue);
9001
+ ? call$1(replacer, searchValue, O, replaceValue)
9002
+ : call$1(nativeReplace, toString$1(O), searchValue, replaceValue);
8198
9003
  },
8199
9004
  // `RegExp.prototype[@@replace]` method
8200
9005
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
8201
9006
  function (string, replaceValue) {
8202
- var rx = anObject(this);
8203
- var S = toString(string);
9007
+ var rx = anObject$1(this);
9008
+ var S = toString$1(string);
8204
9009
 
8205
9010
  if (
8206
9011
  typeof replaceValue == 'string' &&
@@ -8212,9 +9017,9 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
8212
9017
  }
8213
9018
 
8214
9019
  var functionalReplace = isCallable(replaceValue);
8215
- if (!functionalReplace) replaceValue = toString(replaceValue);
9020
+ if (!functionalReplace) replaceValue = toString$1(replaceValue);
8216
9021
 
8217
- var flags = toString(getRegExpFlags(rx));
9022
+ var flags = toString$1(getRegExpFlags(rx));
8218
9023
  var global = stringIndexOf(flags, 'g') !== -1;
8219
9024
  var fullUnicode;
8220
9025
  if (global) {
@@ -8225,14 +9030,14 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
8225
9030
  var results = [];
8226
9031
  var result;
8227
9032
  while (true) {
8228
- result = regExpExec(rx, S);
9033
+ result = regExpExec$1(rx, S);
8229
9034
  if (result === null) break;
8230
9035
 
8231
- push(results, result);
9036
+ push$1(results, result);
8232
9037
  if (!global) break;
8233
9038
 
8234
- var matchStr = toString(result[0]);
8235
- if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
9039
+ var matchStr = toString$1(result[0]);
9040
+ if (matchStr === '') rx.lastIndex = advanceStringIndex$1(S, toLength$1(rx.lastIndex), fullUnicode);
8236
9041
  }
8237
9042
 
8238
9043
  var accumulatedResult = '';
@@ -8240,8 +9045,8 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
8240
9045
  for (var i = 0; i < results.length; i++) {
8241
9046
  result = results[i];
8242
9047
 
8243
- var matched = toString(result[0]);
8244
- var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
9048
+ var matched = toString$1(result[0]);
9049
+ var position = max(min$1(toIntegerOrInfinity(result.index), S.length), 0);
8245
9050
  var captures = [];
8246
9051
  var replacement;
8247
9052
  // NOTE: This is equivalent to
@@ -8249,22 +9054,22 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
8249
9054
  // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
8250
9055
  // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
8251
9056
  // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
8252
- for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
9057
+ for (var j = 1; j < result.length; j++) push$1(captures, maybeToString(result[j]));
8253
9058
  var namedCaptures = result.groups;
8254
9059
  if (functionalReplace) {
8255
9060
  var replacerArgs = concat([matched], captures, position, S);
8256
- if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
8257
- replacement = toString(apply(replaceValue, undefined, replacerArgs));
9061
+ if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
9062
+ replacement = toString$1(apply(replaceValue, undefined, replacerArgs));
8258
9063
  } else {
8259
9064
  replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
8260
9065
  }
8261
9066
  if (position >= nextSourcePosition) {
8262
- accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
9067
+ accumulatedResult += stringSlice$1(S, nextSourcePosition, position) + replacement;
8263
9068
  nextSourcePosition = position + matched.length;
8264
9069
  }
8265
9070
  }
8266
9071
 
8267
- return accumulatedResult + stringSlice(S, nextSourcePosition);
9072
+ return accumulatedResult + stringSlice$1(S, nextSourcePosition);
8268
9073
  }
8269
9074
  ];
8270
9075
  }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
@@ -8502,6 +9307,269 @@ const DiscoveryCatalogueInfo = ({
8502
9307
  });
8503
9308
  };
8504
9309
 
9310
+ var call = functionCall;
9311
+ var uncurryThis = functionUncurryThis;
9312
+ var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
9313
+ var anObject = anObject$h;
9314
+ var isObject = isObject$g;
9315
+ var requireObjectCoercible = requireObjectCoercible$9;
9316
+ var speciesConstructor = speciesConstructor$2;
9317
+ var advanceStringIndex = advanceStringIndex$3;
9318
+ var toLength = toLength$5;
9319
+ var toString = toString$c;
9320
+ var getMethod = getMethod$6;
9321
+ var regExpExec = regexpExecAbstract;
9322
+ var stickyHelpers = regexpStickyHelpers;
9323
+ var fails = fails$q;
9324
+
9325
+ var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
9326
+ var MAX_UINT32 = 0xFFFFFFFF;
9327
+ var min = Math.min;
9328
+ var push = uncurryThis([].push);
9329
+ var stringSlice = uncurryThis(''.slice);
9330
+
9331
+ // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
9332
+ // Weex JS has frozen built-in prototypes, so use try / catch wrapper
9333
+ var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
9334
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
9335
+ var re = /(?:)/;
9336
+ var originalExec = re.exec;
9337
+ re.exec = function () { return originalExec.apply(this, arguments); };
9338
+ var result = 'ab'.split(re);
9339
+ return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
9340
+ });
9341
+
9342
+ var BUGGY = 'abbc'.split(/(b)*/)[1] === 'c' ||
9343
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
9344
+ 'test'.split(/(?:)/, -1).length !== 4 ||
9345
+ 'ab'.split(/(?:ab)*/).length !== 2 ||
9346
+ '.'.split(/(.?)(.?)/).length !== 4 ||
9347
+ // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
9348
+ '.'.split(/()()/).length > 1 ||
9349
+ ''.split(/.?/).length;
9350
+
9351
+ // @@split logic
9352
+ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
9353
+ var internalSplit = '0'.split(undefined, 0).length ? function (separator, limit) {
9354
+ return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);
9355
+ } : nativeSplit;
9356
+
9357
+ return [
9358
+ // `String.prototype.split` method
9359
+ // https://tc39.es/ecma262/#sec-string.prototype.split
9360
+ function split(separator, limit) {
9361
+ var O = requireObjectCoercible(this);
9362
+ var splitter = isObject(separator) ? getMethod(separator, SPLIT) : undefined;
9363
+ return splitter
9364
+ ? call(splitter, separator, O, limit)
9365
+ : call(internalSplit, toString(O), separator, limit);
9366
+ },
9367
+ // `RegExp.prototype[@@split]` method
9368
+ // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
9369
+ //
9370
+ // NOTE: This cannot be properly polyfilled in engines that don't support
9371
+ // the 'y' flag.
9372
+ function (string, limit) {
9373
+ var rx = anObject(this);
9374
+ var S = toString(string);
9375
+
9376
+ if (!BUGGY) {
9377
+ var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
9378
+ if (res.done) return res.value;
9379
+ }
9380
+
9381
+ var C = speciesConstructor(rx, RegExp);
9382
+ var unicodeMatching = rx.unicode;
9383
+ var flags = (rx.ignoreCase ? 'i' : '') +
9384
+ (rx.multiline ? 'm' : '') +
9385
+ (rx.unicode ? 'u' : '') +
9386
+ (UNSUPPORTED_Y ? 'g' : 'y');
9387
+ // ^(? + rx + ) is needed, in combination with some S slicing, to
9388
+ // simulate the 'y' flag.
9389
+ var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
9390
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
9391
+ if (lim === 0) return [];
9392
+ if (S.length === 0) return regExpExec(splitter, S) === null ? [S] : [];
9393
+ var p = 0;
9394
+ var q = 0;
9395
+ var A = [];
9396
+ while (q < S.length) {
9397
+ splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
9398
+ var z = regExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
9399
+ var e;
9400
+ if (
9401
+ z === null ||
9402
+ (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
9403
+ ) {
9404
+ q = advanceStringIndex(S, q, unicodeMatching);
9405
+ } else {
9406
+ push(A, stringSlice(S, p, q));
9407
+ if (A.length === lim) return A;
9408
+ for (var i = 1; i <= z.length - 1; i++) {
9409
+ push(A, z[i]);
9410
+ if (A.length === lim) return A;
9411
+ }
9412
+ q = p = e;
9413
+ }
9414
+ }
9415
+ push(A, stringSlice(S, p));
9416
+ return A;
9417
+ }
9418
+ ];
9419
+ }, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
9420
+
9421
+ const InfoDialogWMSMap = ({
9422
+ view,
9423
+ geometry,
9424
+ dataLink,
9425
+ getCapabilitiesJSON
9426
+ }) => {
9427
+ const mapContainerRef = React.useRef(null);
9428
+ const [mapSize, setMapSize] = React.useState([0, 0]);
9429
+ const [extent, setExtent] = React.useState(undefined);
9430
+ const props = {
9431
+ isFocused: false,
9432
+ view
9433
+ };
9434
+ React.useEffect(() => {
9435
+ if (mapContainerRef.current) {
9436
+ const rect = mapContainerRef.current.getBoundingClientRect();
9437
+ setMapSize([rect.width, rect.height]);
9438
+ }
9439
+ }, []);
9440
+ const findLayerName = link => {
9441
+ if (link.split(/(?<=layers=)/i)[1]) {
9442
+ return link.split(/(?<=layers=)/i)[1];
9443
+ }
9444
+ if (link.split(/(?<=layer=)/i)[1]) {
9445
+ return link.split(/(?<=layer=)/i)[1];
9446
+ }
9447
+ return '';
9448
+ };
9449
+ useEffect(() => {
9450
+ if (geometry.coordinates) {
9451
+ const coord1 = fromLonLat(geometry.coordinates[0][0], 'EPSG:3857');
9452
+ const coord2 = fromLonLat(geometry.coordinates[0][2], 'EPSG:3857');
9453
+ setExtent(boundingExtent([coord1, coord2]));
9454
+ }
9455
+ }, [geometry.coordinates]);
9456
+ useEffect(() => {
9457
+ if (mapSize && extent) {
9458
+ view.fit(extent, {
9459
+ size: mapSize
9460
+ });
9461
+ }
9462
+ }, [extent, geometry.coordinates, mapSize, view]);
9463
+ return getCapabilitiesJSON && getCapabilitiesJSON.WMS_Capabilities ? jsx("div", {
9464
+ ref: mapContainerRef,
9465
+ style: {
9466
+ width: '100%',
9467
+ paddingLeft: 12,
9468
+ paddingRight: 12,
9469
+ paddingBottom: 12
9470
+ },
9471
+ "data-testid": "info-dialog-wms-map",
9472
+ children: jsx("div", {
9473
+ style: {
9474
+ aspectRatio: '2 / 1',
9475
+ width: '100%'
9476
+ },
9477
+ children: jsxs(OpenLayersMapView, Object.assign({}, props, {
9478
+ children: [jsx(MapControls, {
9479
+ style: {
9480
+ top: 0
9481
+ },
9482
+ children: jsx(OpenLayersZoomControl, {
9483
+ homeExtent: extent
9484
+ })
9485
+ }), jsx(DefaultBaseLayers, {}), jsx(ErrorBoundary, {
9486
+ children: jsx(WMSLayer, {
9487
+ layerName: findLayerName(dataLink),
9488
+ layerOptions: {
9489
+ zIndex: 1,
9490
+ opacity: 0.5
9491
+ },
9492
+ url: dataLink,
9493
+ styleName: "default"
9494
+ })
9495
+ })]
9496
+ }))
9497
+ })
9498
+ }) : null;
9499
+ };
9500
+
9501
+ const view = new View({
9502
+ projection: 'EPSG:3857',
9503
+ zoom: 0,
9504
+ center: [0, 0]
9505
+ });
9506
+ // Normalize longitude values so that they are between -180 and 180 degrees
9507
+ const normalizeLongitude = lon => {
9508
+ let normalized = lon;
9509
+ while (normalized < -180) {
9510
+ normalized += 360;
9511
+ }
9512
+ while (normalized > 180) {
9513
+ normalized -= 360;
9514
+ }
9515
+ return normalized;
9516
+ };
9517
+ const InfoDialogWMSMapConnect = ({
9518
+ geometry,
9519
+ links
9520
+ }) => {
9521
+ const dispatch = useDispatch();
9522
+ const [dataLink, setDataLink] = React.useState('');
9523
+ const {
9524
+ data: getCapabilitiesJSON
9525
+ } = useQueryGetWMSGetCapabilities(dataLink);
9526
+ const debouncedSetBbox = useMemo(() => debounce(() => {
9527
+ const zoom = view.getZoom();
9528
+ // Some areas are cut out around the edges of the map even when zoomed out
9529
+ // So at low zoom levels, set the bbox to the whole world
9530
+ if (zoom !== undefined && zoom < 0.1) {
9531
+ dispatch(dataExplorerActions.setWMSbox({
9532
+ wmsBox: [-180, -90, 180, 90]
9533
+ }));
9534
+ } else {
9535
+ const extent = view.calculateExtent();
9536
+ const transformedExtent = transformExtent(extent, view.getProjection(), 'EPSG:4326');
9537
+ // The map can be panned left or right beyond the -180/180 longitude range, so values need to be normalized
9538
+ transformedExtent[0] = normalizeLongitude(transformedExtent[0]);
9539
+ transformedExtent[2] = normalizeLongitude(transformedExtent[2]);
9540
+ dispatch(dataExplorerActions.setWMSbox({
9541
+ wmsBox: transformedExtent
9542
+ }));
9543
+ }
9544
+ }, 1000), [dispatch]);
9545
+ useEffect(() => {
9546
+ const dataLink = links.find(link => link.rel === 'data');
9547
+ if (dataLink) {
9548
+ setDataLink(dataLink.href);
9549
+ }
9550
+ }, [links]);
9551
+ const setWMSbox = useCallback(() => {
9552
+ debouncedSetBbox();
9553
+ }, [debouncedSetBbox]);
9554
+ useEffect(() => {
9555
+ if (!view) {
9556
+ return () => {};
9557
+ }
9558
+ const eventKey = view.on('change', () => {
9559
+ setWMSbox();
9560
+ });
9561
+ return () => {
9562
+ unByKey(eventKey);
9563
+ };
9564
+ }, [setWMSbox]);
9565
+ return dataLink && getCapabilitiesJSON && jsx(InfoDialogWMSMap, {
9566
+ view: view,
9567
+ geometry: geometry,
9568
+ dataLink: dataLink,
9569
+ getCapabilitiesJSON: getCapabilitiesJSON
9570
+ });
9571
+ };
9572
+
8505
9573
  const DataExplorerInfo = ({
8506
9574
  onClose,
8507
9575
  isOpen,
@@ -8525,6 +9593,9 @@ const DataExplorerInfo = ({
8525
9593
  } = useDataExplorerTranslation();
8526
9594
  const stopWheelEventPropagationRef = useWheelStopPropagation();
8527
9595
  const placeHolderLoading = 'DISCOVERY CATALOGUE INFO LOADING...';
9596
+ const isWmsFormat = formats => {
9597
+ return formats.some(format => format.name.toLowerCase().includes('wms'));
9598
+ };
8528
9599
  return jsx(ToolContainerDraggable, {
8529
9600
  title: featureInfo == null ? void 0 : featureInfo.properties.title,
8530
9601
  startSize: {
@@ -8554,6 +9625,9 @@ const DataExplorerInfo = ({
8554
9625
  properties: featureInfo.properties,
8555
9626
  datasetLink: datasetLink,
8556
9627
  id: featureInfo.id
9628
+ }), featureInfo.properties.formats && isWmsFormat(featureInfo.properties.formats) && jsx(InfoDialogWMSMapConnect, {
9629
+ geometry: featureInfo.geometry,
9630
+ links: featureInfo.links
8557
9631
  }), jsxs(Accordion, {
8558
9632
  defaultExpanded: true,
8559
9633
  onClick: e => e.stopPropagation(),