Maptor — Technical Documentation

1. Specific Function core

Maptor is a lightweight XML sitemap generator designed for SEO professionals and website owners. Its primary purpose is to produce a standards‑compliant sitemap.xml file in two simple steps:

Enter your domain — The user provides a base domain (e.g., veckpriv.com). The tool automatically prefixes it with https:// to form absolute URLs.
Add URL paths — One or more relative paths (e.g., /about, /contact, /maptor/) are added via a dynamic list. Each path is combined with the domain to create a complete <loc> entry.
Download XML — With a single click, the tool generates a valid XML document that follows the sitemap.org standard, including <lastmod> (today's date), <changefreq> (set to daily), and <priority> (set to 0.8 for all entries).

The tool is ideal for quickly generating a sitemap for small to medium‑sized websites without the need for server‑side processing or third‑party services. All processing is done locally, ensuring complete privacy.

🛠️ All operations are performed entirely inside your browser using JavaScript's DOM API and the Blob interface for file generation. No data is ever transmitted.

2. Local JavaScript Mechanism under the hood

Every operation in Maptor executes 100% inside the browser's memory. No user input — not even the domain or URL paths — ever leaves the client.

Domain input — The user types a domain name into a text field. The value is read via getElementById() and stored in a local variable. No form submission or network request is triggered.
Dynamic URL list — The tool maintains an array of path strings in JavaScript. Users can add or remove entries using DOM manipulation (appendChild(), remove()). Each path is validated locally (non‑empty, leading slash enforced).
XML generation — When the user clicks the download button, the script constructs a full XML document as a string, using template literals to insert the domain and each path. The XML includes:
- <?xml version="1.0" encoding="UTF-8"?>
- <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
- One <url> block per path with <loc>, <lastmod>, <changefreq>, and <priority>.
File download — The XML string is wrapped in a Blob with MIME type application/xml. A temporary <a> element is created, its href set to an object URL, and a programmatic click triggers the download. All of this uses the FileSaver-like native API — no external libraries.
Zero network I/O — The entire process uses only local variables, DOM manipulation, and browser APIs. There are no fetch(), XMLHttpRequest, or WebSocket calls of any kind.

                
                    // Core generation logic — triggered on download click

                    function generateSitemap() {

                      const domain = document.getElementById('domainInput').value.trim();

                      const paths = getPathsFromDOM();  // array of strings

                      const today = new Date().toISOString().split('T')[0];

                      let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';

                      xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';

                      paths.forEach(p => {

                        xml += `  <url>\n    <loc>https://${domain}${p}</loc>\n`;

                        xml += `    <lastmod>${today}</lastmod>\n`;

                        xml += `    <changefreq>daily</changefreq>\n`;

                        xml += `    <priority>0.8</priority>\n  </url>\n`;

                      });

                      xml += '</urlset>';

                      // create Blob and trigger download — all local

                      const blob = new Blob([xml], { type: 'application/xml' });

                      const url = URL.createObjectURL(blob);

                      const a = document.createElement('a');

                      a.href = url; a.download = 'sitemap.xml'; a.click();

                      URL.revokeObjectURL(url);

                    }

✅ This design guarantees that all processing happens in memory — nothing is serialised, stored, or transmitted outside the browser tab.

3. Dependencies / Libraries vanilla & zero

Maptor has zero external dependencies. It is built entirely with vanilla JavaScript (ES6), standard HTML5, and plain CSS.

JavaScript — Uses only native browser APIs: document DOM manipulation, Blob, URL.createObjectURL(), addEventListener(), and toISOString(). No third‑party libraries, no npm packages, no CDN imports.
CSS — All styles are hand‑written in a single stylesheet. No frameworks (Bootstrap, Tailwind, etc.), no preprocessors, no icon libraries.
Fonts — The page uses system‑native font stacks ('Inter', -apple-system, BlinkMacSystemFont, ...) to avoid any external font requests. No Google Fonts or webfont services.
No analytics, no telemetry — There is no embedded tracking script, no pixel, no beacon, no crash‑reporting service.

📜 Zero dependencies means zero supply‑chain risk. Every line of code is auditable, self‑contained, and immune to third‑party compromise.

4. Storage Limitations ephemeral

Maptor does not persist any data — neither on the server (there is none) nor on the client beyond the current browser session.

No localStorage — The tool never writes to localStorage, sessionStorage, or IndexedDB. Your domain and URL paths exist only in volatile memory (JavaScript variables and DOM state).
No cookies — No cookies are created, read, or modified. The page does not set or access any document.cookie.
No cloud storage — Since no data is ever transmitted, there is no cloud storage, no database, no backup, no sync.
Lost on tab close — When you close the browser tab, all JavaScript state is destroyed. The next time you open the page, the domain field and URL list are empty (default state).
Cache behaviour — The browser may cache the HTML, CSS, and JavaScript files for performance, but this is standard HTTP caching controlled by your browser — it does not store any user‑generated data.

🔒 Ephemeral by design — your interaction with Maptor leaves no trace. This is not a limitation; it is a deliberate privacy guarantee.

5. Input Security zero‑exfiltration

Maptor handles no sensitive user data — it only processes a domain name and a list of URL paths. Nevertheless, the security model is absolute: nothing ever touches the network.

No form submissions — The domain input and URL list are standard <input> and <button> elements with click and change listeners. They do not wrap a <form> and never issue a POST or GET request.
No input validation sent remotely — All input validation (checking that the domain is non‑empty, that paths start with a slash, etc.) happens locally in JavaScript. No validation payload is ever transmitted.
No data serialisation — The tool does not serialise user input into JSON, XML, or any other format for transmission. The domain and paths are used exclusively in local calculations (building the XML string).
No external API keys — Since there are no external APIs, there are no API keys, no secrets, no authentication tokens embedded in the code or sent over the wire.
Network tab proof — Open your browser's Developer Tools (F12), go to the Network tab, and reload the page. You will see zero requests to external servers beyond the initial HTML and asset load (except for the initial HTML load and requests to official sandboxed subdomains.). No beacons, no analytics, no tracking pixels, no telemetry.

                
                    // The only "inputs" are the domain and path list — processed locally

                    const domain = document.getElementById('domainInput').value;

                    const paths = Array.from(document.querySelectorAll('.url-path-input'))

                      .map(inp => inp.value.trim())

                      .filter(p => p.length > 0);

                    // No fetch(), no XMLHttpRequest, no WebSocket

                    // No cookies, no localStorage, no IndexedDB

🛡️ Absolute input security is guaranteed by the architecture: the browser never initiates any outbound request containing user‑derived data. Your interaction with Maptor is completely offline after the initial page load.

📜 Ready to generate your sitemap?

Launch Maptor, enter your domain and paths, and download a valid sitemap.xml — instantly, privately.

▶ Open Maptor

🎯 zero‑tracking 💻 browser‑native 🔒 no server 📄 XML output