Architecting a Geospatial Visualization System for Global Nuclear Events: JavaScript Frontends and PHP APIs

Full report

On this page

Introduction to Geospatial Architecture for Nuclear Data

The visualization of historical and contemporary nuclear events on a global map requires a sophisticated, full-stack geospatial architecture. Ranging from the 1945 Trinity test to the comprehensive test ban era ending in 1998, over two thousand nuclear detonations have been recorded worldwide1. Beyond detonations, global datasets encompass the lifecycle of nuclear power plants, as well as environmental radiocaesium and radiostrontium contamination resulting from accidents such as the 1986 Chernobyl disaster and the 2011 Fukushima Daiichi accident3. Creating an interactive, web-based Geographic Information System (GIS) to visualize this dense, complex array of spatial and temporal data demands a highly optimized technology stack. A robust architecture typically employs a relational spatial database, a middleware application programming interface (API) written in PHP, and a dynamic JavaScript frontend utilizing libraries like Leaflet or MapLibre GL JS8. The integration of these tiers allows for the real-time querying, transport, and rendering of thousands of geometric features. This report provides an exhaustive analysis of the methodologies, architectural patterns, mathematical optimizations, and cybersecurity best practices required to build an enterprise-grade nuclear event mapping system.

Taxonomy and Ontology of Geospatial Nuclear Datasets

The foundation of any web GIS application is the underlying data structure. The nuclear event domain is uniquely heterogeneous, characterized by point geometries, complex polygon data, and continuous raster layers2. Understanding the varied sources and structures of this data is critical for designing the backend schema and the API transport logic. Historical nuclear detonation datasets, such as those curated by the Stockholm International Peace Research Institute (SIPRI) and the CORGIS Dataset Project, provide structured, multifaceted records of global atomic tests2. These records include geodetic coordinates, detonation dates, and highly specific metadata regarding the method of deployment and purpose. Deployments are categorized across a wide spectrum, including atmospheric drops, underground tests, balloon suspensions, airdrops, rocket deployments, constructed towers, water surface barges, and deep underwater detonations10. The purpose of these tests ranges from active combat and military exercises to peaceful nuclear explosions and safety experiments10. In addition to historical detonation logs, contemporary architectural designs must account for environmental and structural datasets. Global power plant databases track commercial reactor statuses (active, closed, or under construction), reactor models, construction start dates, and commercial operation lifespans3. The integration of seismic data, such as that provided by the IRIS-DMC, further enriches the geospatial context. Seismic datasets classify global events into precise taxonomies, distinguishing between chemical explosions, generic collapses, damaging earthquakes, and verified nuclear explosions12. This specific seismic dataset encompasses magnitude values (ranging from 2.17 to 6.5 for body waves), exact geographic coordinates, and depth parameters reaching up to 29.7 kilometers, providing a geophysical perspective on subterranean nuclear activity12. Furthermore, post-accident environmental data necessitates the handling of dense spatial clusters and continuous fallout rasters. For example, datasets detailing the Ukrainian Chernobyl Exclusion Zone curated by the Ukrainian Institute of Agricultural Radiology (UIAR) contain decades of comprehensive soil sampling5. These samples measure radiocaesium, radiostrontium, plutonium isotopes, and "hot particles" collected across a sixty-kilometer radial area around the facility, resulting in highly concentrated arrays of geographic points with associated radiation dose rates6. Similarly, open-source datasets regarding the 2011 Fukushima Daiichi Nuclear Power Plant accident contain fallout rasters generated by Inverse Distance Weighted (IDW) interpolation of airborne surveys, translating discrete radiation point grids into continuous spatial matrices mapping the radioactive decay of isotopes7. Finally, highly specialized nuclear physics data, such as the Evaluated Gamma-ray Activation File (EGAF) library, provides thermal-neutron capture gamma-ray data15. This database tracks gamma-ray energies and cross-sections for 245 isotopes, comprising 8,172 primary and 29,605 secondary gamma rays15. While primarily used in fundamental physics and forensics, modern geospatial applications can interlink this isotopic signature data—accessible via tools like the pyEGAF Python package—with geographic testing locations to model the theoretical isotopic fallout of historical events15.

GeoJSON Serialization and Standardization

To systematically transport this highly varied data between the server and the client browser, the GeoJSON format is the industry standard16. GeoJSON is a lightweight geospatial data interchange format based on JavaScript Object Notation (JSON), explicitly utilizing the World Geodetic System 1984 (WGS 84\) coordinate reference system and units of decimal degrees17. A GeoJSON document is built around several core objects. A geographic feature is defined as a Feature, which contains a Geometry object dictating its spatial boundaries, and a properties object containing the metadata16. Multiple features are aggregated into a FeatureCollection16. Web mapping libraries support all standard geometry types, including Point, LineString, Polygon, and their multi-part equivalents16. By standardizing the diverse datasets (from SIPRI detonation logs to UIAR soil samples) into a uniform GeoJSON schema, the frontend visualization logic is decoupled from the backend storage mechanics. A typical schema mapping for nuclear explosions is represented in the structured comparison below:

By encoding the nuclear data into this standardized schema, mapping engines dynamically read the properties object and render varying symbologies, such as modulating the radius of a vector circle based on the yield\_upper value or altering the fill color based on the purpose attribute10.

Database Architecture: Relational Modeling and Spatial Indexing

To serve thousands of nuclear events to a web client without inducing critical latency, the backend must rely on a dedicated spatial database engine. MySQL provides native support for geospatial data types and spatial reference systems, which is vastly superior to storing geographic coordinates as standard floating-point strings19. Rather than storing latitude and longitude in isolated numerical columns, modern architectural best practices dictate the use of MySQL's POINT and POLYGON data types19. A POINT natively encodes a location in a two-dimensional coordinate space19. Storing data natively as geometries allows the database engine to utilize specialized spatial indexing techniques that dramatically reduce query execution times22. A standard SQL table for nuclear events must be structured with a POINT column accompanied by an explicit Spatial Reference System Identifier (SRID). Utilizing SRID 4326 is critical, as it aligns exactly with the WGS 84 standard required by the GeoJSON specification17. Querying thousands of points across a global map is computationally ruinous if the database must perform a full table scan for every user pan or zoom event. To mitigate this, spatial columns must be indexed using an R-Tree22. Unlike standard B-Trees, which sort scalar data sequentially, R-Trees group spatial coordinates into increasingly larger bounding rectangles. When a user queries a specific geographic region, the database immediately discards all bounding rectangles that fall outside the designated query area, reducing query execution time from linear to logarithmic complexity22.

Algorithmic Spatial Querying and Bounding Box Mathematics

To optimize the API payload and conserve network bandwidth, the backend should only return nuclear events that fall within the user's current geographic viewport24. When the user pans or zooms the map, the JavaScript frontend calculates the new viewport's bounding box and transmits these coordinate boundaries to the PHP API24. A viewport bounding box is defined by two pairs of coordinates: the southwest corner (minimum longitude, minimum latitude) and the northeast corner (maximum longitude, maximum latitude)24. The SQL query then implements a spatial filter using bounding parameters to extract only the relevant records. Alternatively, geospatial applications frequently require radial queries, such as evaluating nuclear hazards or environmental monitoring zones within a specific distance from a central point (for instance, the sixty-kilometer radius surrounding the Chernobyl Nuclear Power Plant)6. Calculating the precise spherical distance between thousands of rows and a central point using functions like ST\_Distance\_Sphere forces the database to evaluate every row, bypassing the spatial index19. To maintain high performance, developers must calculate an artificial bounding box around the central point before applying the exact distance calculation. The bounding coordinates around a central latitude ([Figure omitted from source export]) and longitude ([Figure omitted from source export]) for a given distance ([Figure omitted from source export]) and an Earth radius ([Figure omitted from source export] km) are mathematically derived as follows: [Figure omitted from source export] [Figure omitted from source export] [Figure omitted from source export] [Figure omitted from source export] By calculating these maximum and minimum extents in the PHP application layer, the resulting parameters are passed into the SQL query using standard BETWEEN operators. This allows the database to instantly utilize the spatial R-Tree index to filter out the vast majority of irrelevant global points, applying the computationally intensive ST\_Distance\_Sphere formula only to the small subset of points that fall within the bounding square19. This two-tiered approach to spatial querying ensures instantaneous response times even with datasets containing tens of thousands of records19.

Middleware Implementation: PHP API Design and Geo-Processing

The PHP API acts as the architectural bridge between the relational database and the dynamic frontend. Its primary responsibilities encompass handling HTTP requests, sanitizing inputs, executing secure queries, restructuring the relational data into a nested GeoJSON format, and serving it over the network with appropriate caching headers8. Historically, combining PHP and MySQL involved procedural functions highly susceptible to SQL injection vulnerabilities. Modern engineering mandates the use of PHP Data Objects (PDO) to interface with the database8. PDO enables the use of prepared statements, which strictly isolate the SQL logic from the user-provided data. If the PHP API accepts bounding box parameters (e.g., ?bbox=sw\_lng,sw\_lat,ne\_lng,ne\_lat), these parameters must never be concatenated directly into the SQL string24. Instead, they are bound to parameter placeholders, ensuring that malicious spatial inputs cannot alter the underlying query structure or execute unauthorized commands. Furthermore, character encoding is a frequent and silent failure point when transitioning data from MySQL to JSON. Datasets containing nuclear test sites in foreign jurisdictions frequently include diacritics, Cyrillic characters for Soviet tests, or complex string formats8. If the PDO connection does not explicitly define UTF-8 encoding, PHP's json\_encode function will fail or return truncated, malformed strings8. The PDO connection string must include the UTF-8 character set directive, and the PDO::MYSQL\_ATTR\_INIT\_COMMAND should be explicitly configured to execute SET NAMES utf8 upon initialization, guaranteeing an unbroken chain of UTF-8 encoding from the database disk to the browser DOM8. When utilizing PHP to manually serialize the data into GeoJSON, the developer iterates through the database result set utilizing PDO::FETCH\_ASSOC, progressively building a multidimensional associative array24. The parent array is initialized with a type of FeatureCollection24. Within the loop, the spatial coordinates are isolated from the descriptive metadata to form a child Feature array, mapping the coordinates to a nested Point object and the metadata to the properties array24. Once the loop concludes, the entire structure is serialized. When invoking json\_encode, utilizing the JSON\_NUMERIC\_CHECK flag is a vital best practice; it forces the PHP engine to encode numerical strings as native JSON numbers, ensuring that mapping libraries correctly interpret the latitude and longitude as computational floats rather than static strings8.

Advanced Middleware Techniques: Native GeoJSON and In-Memory Caching

While manual PHP array construction is effective for simple point data, managing complex geometries—such as the multipolygon boundaries of the Chernobyl Exclusion Zone or interpolated raster footprints—requires advanced techniques. MySQL versions 5.7 and later provide the ST\_AsGeoJSON() function, which accepts a geometry object and returns a GeoJSON geometry string natively, allowing the database to offload the coordinate string formatting20. Developers can pass bitmask options to append bounding boxes or Coordinate Reference System (CRS) Uniform Resource Names (URNs) directly to the output20. Because ST\_AsGeoJSON only generates the Geometry portion of the GeoJSON specification, the PHP layer must still construct the surrounding Feature and properties wrappers20. For legacy databases or highly complex spatial manipulations, developers frequently leverage the geoPHP library26. geoPHP acts as an open-source native PHP library that parses Well-Known Text (WKT) or Well-Known Binary (WKB) data directly from the database query and transforms it into fully compliant GeoJSON, circumventing the need for complex string replacements or manual array manipulation21. Crucially, geoPHP operates as a wrapper for the GEOS C++ extension; when the GEOS extension is installed on the server environment, applications receive a transparent and massive performance increase, enabling the API to execute complex OpenGIS operations like unions and intersections in memory before delivering the payload to the client26. To further reduce database load, especially during high-traffic scenarios analyzing major global events, API responses should be aggressively cached. Modern middleware architectures frequently integrate the RedisJson module via clients like phpredis-json27. By serializing the GeoJSON payload and storing it in a Redis in-memory datastore against a key representing the bounding box or the specific temporal query, subsequent identical API requests bypass the MySQL database entirely, retrieving the complete JSON structure from RAM in mere milliseconds27.

Frontend Rendering Pipelines: Document Object Model vs. WebGL

With the API configured to deliver structured GeoJSON, the frontend architecture assumes responsibility for the consumption, rendering, and interaction logic. The choice of the underlying mapping library fundamentally dictates the application's performance characteristics, visual capabilities, and ability to handle large data volumes1. The JavaScript ecosystem offers multiple mapping libraries, with Leaflet and MapLibre GL JS representing the two predominant, yet distinct, architectural paradigms9.

Leaflet remains highly popular due to its simplicity, well-documented API, and straightforward handling of GeoJSON payloads. By default, when an application feeds a GeoJSON point layer into Leaflet via L.geoJSON(), the engine generates standard DOM-based image markers for every coordinate16. However, rendering over two thousand distinct nuclear detonation markers as standard DOM nodes triggers massive reflows and repaints in the browser's rendering engine, degrading scrolling performance and causing severe UI latency. MapLibre GL JS resolves this by abandoning the DOM entirely for rendering geographic features, instead utilizing WebGL to draw vectors directly onto an HTML5 Canvas, leveraging the client's Graphics Processing Unit (GPU) to maintain smooth framerates even with tens of thousands of simultaneous points9.

Visual Optimization: Vectorization, Clustering, and Temporal Animation

If an architecture dictates the use of Leaflet, developers must actively optimize the rendering pipeline to prevent DOM overload. This is achieved by intercepting the default marker creation process using the pointToLayer option within the L.geoJSON configuration object3. The pointToLayer function is passed the raw GeoJSON feature data and the geographic coordinates, allowing the developer to bypass image instantiation and instead return an L.circleMarker3. Unlike standard UI markers, CircleMarker objects are rendered using vector graphics (SVG or Canvas), vastly reducing the computational footprint in the browser16. Furthermore, pointToLayer enables dynamic, attribute-based symbolization. A developer can programmatically read a power plant's status property ("active", "closed", "under construction") or an explosion's Yield\_Upper\_Kilotons property to dictate the vector circle's radius, fill color, and stroke opacity in real-time3. Utilizing external color scale libraries like Chroma.js facilitates the dynamic coloring of points based on continuous variables, such as population density, radiation hazard values, or detonation magnitude18. Even with highly optimized vector rendering, displaying thousands of nuclear events at a global zoom level results in overlapping markers, rendering the map visually incomprehensible and analytically useless. Marker clustering is an indispensable spatial technique that groups proximate points into a single composite icon, typically displaying an aggregate count of the underlying features1. While the Leaflet.markercluster plugin is the historical standard, modern geospatial frameworks increasingly rely on the supercluster library1. Supercluster performs rapid, hierarchical clustering of GeoJSON points utilizing a highly optimized JavaScript spatial index18. When the user manipulates the map or zooms into a specific cluster, the cluster dynamically "spiderfies" or resolves into its constituent points, allowing for granular exploration of historically dense testing areas, such as the Nevada Test Site in the United States or the Semipalatinsk Test Site in the former Soviet Union10. A critical requirement for analyzing nuclear events is understanding their spatial distribution over time. The era of atmospheric testing evolved rapidly into underground testing before global treaties largely halted detonations after 19981. Animating this temporal progression requires specialized logic overriding the standard map state. Plugins like Leaflet.timeline parse timestamp data within the GeoJSON properties and overlay a playback interface with an interactive slider onto the map viewport1. As the playback progresses, the plugin dynamically filters the visible GeoJSON layer, adding elements to the map to represent events that occurred prior to the current slider timestamp1. A common architectural pitfall in temporal mapping involves date formatting inconsistencies. Datasets frequently encode dates in varying, non-standardized formats—ranging from ISO 8601 strings (YYYY-MM-DD) to Unix epoch integers, or entirely separated year/month/day columns1. The JavaScript logic must utilize robust date parsing libraries, such as moment.js, to strictly normalize the start and end temporal variables before passing them to the timeline plugin, ensuring the mapping engine correctly correlates the GeoJSON properties with the timeline's mathematical progression1. Advanced implementations of nuclear mapping extend beyond historical static data into real-time hazard simulation. For example, the Argentine Nuclear Regulatory Authority's Emergency Control Center (CCE) integrates geographic information systems with forecasting models (such as the Dose Assessment in Accidents System \- SEDA)33. These systems layer real-time social, economic, and physical data alongside dynamic models of radiation dispersal33. Similarly, open-source QGIS plugins have been developed utilizing the MQTT protocol to stream simulated or actual radiation sensor data in real-time, visualizing expanding radiation radii dynamically atop OpenStreetMap layers, providing invaluable tools for emergency response and predictive analysis31.

Cybersecurity Posture: Neutralizing Cross-Site Scripting (XSS)

A sophisticated geospatial application must not only perform efficiently but also guarantee stringent security. The most severe threat vector in web-based mapping applications is Cross-Site Scripting (XSS), particularly related to the rendering of map Popups and Tooltips34. When a user clicks or hovers over a nuclear event marker, the map typically generates a popup displaying localized metadata (e.g., detonation name, date, kiloton yield, and associated historical notes)10. If this metadata is retrieved from an untrusted source, or if the application allows user-generated annotations, it represents a critical and highly exploitable injection sink34. The underlying mechanics of Leaflet's API have been heavily scrutinized following the publication of CVE-2025-69993, which highlighted that Leaflet versions up to 1.9.4 treat the bindPopup() method as a direct XSS sink34. The bindPopup() method is explicitly engineered to accept and render arbitrary HTML strings by default34. It does not inherently sanitize user-supplied input, as the architectural philosophy of Leaflet dictates that sanitization is entirely the responsibility of the host application34. If an attacker compromises the underlying database or manipulates a URL parameter to inject a malicious payload—for instance, replacing a nuclear test name with \<img src=x onerror="alert('XSS')"\>—and the JavaScript application blindly passes this string to marker.bindPopup(feature.properties.name), the Leaflet engine will render the raw HTML directly into the Document Object Model34. The browser will attempt to load the nonexistent image source 'x', fail, and immediately execute the malicious JavaScript contained in the onerror event handler34. Other documented payloads utilize SVG load events (e.g., \<svg onload="alert('XSS')"\>) or exfiltrate document cookies to remote attacker-controlled domains34. This vulnerability facilitates Stored XSS if the malicious metadata is saved in the database, or Reflected XSS if dynamically generated from manipulated URL parameters34. Successful exploitation grants an attacker the ability to steal session cookies, capture keystrokes, inject phishing forms, or perform unauthorized API requests on behalf of the victim34. This architectural pattern—a documented API rendering HTML without native sanitization—is standard across the JavaScript ecosystem. MapLibre GL JS documents that its setHTML() method does not perform filtering, and frameworks like React and Vue mandate explicit developer warnings through mechanisms like dangerouslySetInnerHTML and v-html36.

Defense-in-Depth: Sanitization and Native Object Injection

To secure the frontend against XSS, developers must implement defense-in-depth strategies. The most widespread methodology is the implementation of DOMPurify, a highly efficient, DOM-only HTML sanitization library developed by the Cure53 security consultancy37. Unlike legacy regex-based string replacements—which are notoriously prone to bypasses by creative attackers—DOMPurify operates by parsing the untrusted input into an inert, clean DOM tree in memory39. It meticulously evaluates tags and attributes against an explicit allowlist, completely stripping out dangerous event handlers (e.g., onclick, onload, onerror), unauthorized execution contexts (such as \<script\> tags), and malicious URI schemes (javascript:)39. The sanitized, safe HTML output can then be safely passed to bindPopup34. However, reliance on third-party sanitizers demands strict dependency management, as even robust libraries like DOMPurify are susceptible to undiscovered edge cases. For instance, CVE-2026-0540 detailed a critical vulnerability in specific DOMPurify versions (3.1.3 through 3.3.1, and 2.5.3 through 2.5.8)37. In this vulnerability, the SAFE\_FOR\_XML regex pattern failed to account for certain "rawtext" elements, specifically \<noscript\>, \<xmp\>, \<noembed\>, \<noframes\>, and \<iframe\>37. Attackers successfully bypassed the attribute sanitization routines by injecting closing rawtext tags to break out of the sanitized contexts and execute JavaScript37. Consequently, developers must continually audit NPM dependencies, avoid placing sanitized outputs blindly into dangerous rawtext contexts, and deploy supplementary monitoring37.

Given the persistent risks of library vulnerabilities, a universally foolproof method for eliminating XSS in map popups—which requires absolutely no external dependencies—is the utilization of native browser DOM APIs to safely encode text34. Instead of passing an HTML string to Leaflet's bindPopup(), the application architecture should dictate the programmatic creation of HTML elements using document.createElement()34. By assigning the untrusted metadata variable specifically to the textContent property of the newly created element (rather than the dangerous innerHTML property), the browser fundamentally and irreversibly treats the data as a literal text string rather than executable HTML34. Once the DOM element is securely constructed and populated with safe text, the object itself is passed directly into the bindPopup method34. This programmatic pattern completely neutralizes any embedded HTML tags or JavaScript vectors, as the browser's rendering engine strictly isolates the content payload from the execution context34. A comprehensive enterprise security posture must ultimately be reinforced by a strict Content Security Policy (CSP) delivered via server HTTP headers37. By explicitly blocking inline scripts and prohibiting unsafe-eval execution, a properly configured CSP provides a definitive, browser-level backstop against DOM-based XSS execution, ensuring that even if a sanitization bypass occurs, the malicious payload is blocked from execution by the client's browser37.

Conclusion

Visualizing over a half-century of global nuclear detonations, operating power facilities, and complex radiation exclusion zones represents a highly demanding technical undertaking. It necessitates a harmonious, optimized interaction across the entirety of the technology stack, from relational database spatial indexing to browser-based rendering pipelines and zero-trust security enforcement. To achieve an enterprise-grade architecture, applications must store spatial data natively using POINT and POLYGON geometries within a spatial relational database, strictly utilizing SRID 4326 to align with GeoJSON specifications. Indexing these columns via R-Trees and implementing trigonometric bounding-box parameters are absolute necessities to prevent algorithmic latency during heavy global query loads. The PHP middleware layer must exclusively rely on PDO prepared statements, enforcing UTF-8 character encoding at the connection level, and utilizing JSON numeric checks to ensure accurate, parseable payloads. For complex geometries, integrating tools like geoPHP alongside GEOS allows for highly efficient in-memory spatial transformations, while Redis caches prevent redundant database polling. On the client side, managing thousands of simultaneous features requires abandoning traditional DOM markers in favor of Canvas or WebGL-based vector rendering, supplemented heavily by hierarchical clustering algorithms like Supercluster to maintain visual clarity and high framerates. Temporal analysis is enriched through timeline manipulation, provided strict date normalization is enforced. Finally, due to the inherent design of mapping libraries, developers must treat all dataset metadata as potentially hostile XSS vectors, unconditionally implementing native DOM text encoding or rigorous HTML sanitization routines before rendering interactive popups, securing the application against catastrophic client-side exploitation.

Works cited

1. Leaflet timeline plugin issue \- javascript \- GIS Stack Exchange, https://gis.stackexchange.com/questions/262518/leaflet-timeline-plugin-issue

2. data-is-plural/nuclear-explosions \- GitHub, https://github.com/data-is-plural/nuclear-explosions

3. Exercise 4: Interactive Web Mapping, http://osgl.ethz.ch/training/webmaps/exercises/04\_exercise\_Interactivity.pdf

4. Geo Nuclear Data \- Kaggle, https://www.kaggle.com/datasets/mexwell/geo-nuclear-data

5. Spatial datasets of radionuclide contamination in the Ukrainian Chernobyl Exclusion Zone, https://essd.copernicus.org/articles/10/339/2018/

6. Spatial radionuclide deposition data from the 60 km radial area around the Chernobyl nuclear power plant, 1987 \- EIDC Catalogue, https://catalogue.ceh.ac.uk/id/a408ac9d-763e-4f4c-ba72-73bc2d1f596d

7. Spatial datasets associated with decontamination and remediation operations following the Fukushima nuclear accident, Japan (2011–2023) \- Zenodo, https://zenodo.org/records/7827616

8. PHP & MySQL and Leaflet API \- Stack Overflow, https://stackoverflow.com/questions/34843393/php-mysql-and-leaflet-api

9. Optimising MapLibre Performance: Tips for Large GeoJSON Datasets, https://maplibre.org/maplibre-gl-js/docs/guides/large-data/

10. Nuclear Explosions Data \- Kaggle, https://www.kaggle.com/datasets/utkarshx27/nuclear-explosions-data

11. Nuclear Explosions Python Library \- CORGIS Datasets Project, https://corgis-edu.github.io/corgis/python/nuclear\_explosions/

12. Alemayehubk/Seismic-Events-Data: Seismic Events Data including chemical explosions, collapses, nuclear explosions, damaging earthquakes, felt earthquakes, generic earthquakes and generic explosions \- GitHub, https://github.com/Alemayehubk/Seismic-Events-Data

13. Spatial datasets of radionuclide contamination in the Ukrainian Chernobyl Exclusion Zone, https://data.europa.eu/data/datasets/spatial-datasets-of-radionuclide-contamination-in-the-ukrainian-chernobyl-exclusion-zone?locale=en

14. Spatial datasets of radionuclide contamination in the Ukrainian Chernobyl Exclusion Zone, https://www.data.gov.uk/dataset/0262d64f-d152-471f-a341-f881fa378a0c/spatial-datasets-of-radionuclide-contamination-in-the-ukrainian-chernobyl-exclusion-zone

15. GitHub \- AaronMHurst/python\_egaf: Python package for access, manipulation, and analysis of thermal neutron-capture gamma-ray data from the Evaluated Gamma-ray Activation File (EGAF) library., https://github.com/AaronMHurst/python\_egaf

16. Using GeoJSON with Leaflet \- Leaflet \- a JavaScript library for interactive maps, https://leafletjs.com/examples/geojson/

17. Loading a layer from a GeoJSON file into Leaflet Antarctic map (part 1a) \- Thomas Williams, https://thomasswilliams.github.io/development/2022/05/12/leaflet-antarctica-demo-1a.html

18. GeoJSON Tutorial \- Dash Leaflet, https://www.dash-leaflet.com/docs/geojson\_tutorial

19. Bounding Boxes for GEOSPATIAL queries in MySQL | PHP \- Medium, https://ijachipius8.medium.com/bounding-boxes-for-geospatial-queries-in-mysql-php-9d25bfab8836

20. 14.16.11 Spatial GeoJSON Functions \- MySQL :: Developer Zone, https://dev.mysql.com/doc/refman/en/spatial-geojson-functions.html

21. Querying SQL using Php and outputting geojson for a GeoPolygon \- Stack Overflow, https://stackoverflow.com/questions/45301235/querying-sql-using-php-and-outputting-geojson-for-a-geopolygon

22. Give Me Some Latitude... and Longitude \- Percona, https://www.percona.com/blog/give-me-some-latitude-and-longitude/

23. PHP PostGIS to GeoJSON \- with BBOX query \- GitHub Gist, https://gist.github.com/2146017

24. PHP-Database-GeoJSON/simple\_points/mysql\_points\_geojson.php at master \- GitHub, https://github.com/bmcbride/PHP-Database-GeoJSON/blob/master/simple\_points/mysql\_points\_geojson.php

25. Spatial data API with GraphQL, PHP and MySQL | by Alessandro Cristofori | The Startup, https://compatt.medium.com/spatial-data-api-with-graphql-php-and-mysql-a48e8b89d4e1

26. GeoPHP \- The world's most popular geospatial library for PHP, https://geophp.net/

27. averias/phpredis-json: A PHP client for RedisJSON module using phpredis extension \- GitHub, https://github.com/averias/phpredis-json

28. Map libraries popularity: Leaflet vs MapLibre GL vs OpenLayers \- Geoapify, https://www.geoapify.com/map-libraries-comparison-leaflet-vs-maplibre-gl-vs-openlayers-trends-and-statistics/

29. Leaflet migration guide \- MapLibre GL JS, https://maplibre.org/maplibre-gl-js/docs/guides/leaflet-migration-guide/

30. Investigating Historical Nuclear Explosions \- Kaggle, https://www.kaggle.com/code/utkarshx27/investigating-historical-nuclear-explosions

31. Nuclear Energy Plants' Radiations — QGIS Python Plugins Repository, https://plugins.qgis.org/plugins/Nuclear-Energy-Plant-Radiations-/

32. SweetEyesBirb/Nuclear-Test-Sites-Map \- GitHub, https://github.com/SweetEyesBirb/Nuclear-Test-Sites-Map

33. Geographic Information System (GIS) Applied to Nuclear Accident Response \- INIS-IAEA, https://inis.iaea.org/records/yey9m-y0693/files/50027358.pdf?download=1

34. leaflet-cve-2025-69993/ADVISORY.md at main \- GitHub, https://github.com/PierfrancescoConti/leaflet-cve-2025-69993/blob/main/ADVISORY.md

35. DOM based XSS Prevention Cheat Sheet, https://cheatsheetseries.owasp.org/cheatsheets/DOM\_based\_XSS\_Prevention\_Cheat\_Sheet.html

36. Statement on CVE-2025-69993 (XSS via \bindPopup\) · Issue \#10214 · Leaflet/Leaflet, https://github.com/Leaflet/Leaflet/issues/10214

37. CVE-2026-0540: Cure53 DOMPurify XSS Vulnerability \- SentinelOne, https://www.sentinelone.com/vulnerability-database/cve-2026-0540/

38. a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG. DOMPurify works with a secure default, but offers a lot of configurability and hooks. Demo: · GitHub, https://github.com/cure53/dompurify

39. How does DOMPurify ensure that sanitized HTML is safe for injection into the DOM?, https://dompurify.com/how-does-dompurify-ensure-that-sanitized-html-is-safe-for-injection-into-the-dom-2/

40. Insert HTML into user string and render it in React (and avoid XSS threat) \- Stack Overflow, https://stackoverflow.com/questions/58479405/insert-html-into-user-string-and-render-it-in-react-and-avoid-xss-threat

41. Documentation \- Leaflet \- a JavaScript library for interactive maps, https://leafletjs.com/reference.html