Set up comprehensive frontend testing infrastructure

- Install Jest for unit testing with React Testing Library
- Install Playwright for end-to-end testing
- Configure Jest with proper TypeScript support and module mapping
- Create test setup files and utilities for both unit and e2e tests

Components:
* Jest configuration with coverage thresholds
* Playwright configuration with browser automation
* Unit tests for LoginForm, AuthContext, and useSocketIO hook
* E2E tests for authentication, dashboard, and agents workflows
* GitHub Actions workflow for automated testing
* Mock data and API utilities for consistent testing
* Test documentation with best practices

Testing features:
- Unit tests with 70% coverage threshold
- E2E tests with API mocking and user journey testing
- CI/CD integration for automated test runs
- Cross-browser testing support with Playwright
- Authentication system testing end-to-end

🚀 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/node_modules/tldts/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2017 Thomas Parisot, 2018 Rémi Berson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

frontend/node_modules/tldts/README.md

@@ -0,0 +1,327 @@
+# tldts - Blazing Fast URL Parsing
+
+`tldts` is a JavaScript library to extract hostnames, domains, public suffixes, top-level domains and subdomains from URLs.
+
+**Features**:
+
+1. Tuned for **performance** (order of 0.1 to 1 μs per input)
+2. Handles both URLs and hostnames
+3. Full Unicode/IDNA support
+4. Support parsing email addresses
+5. Detect IPv4 and IPv6 addresses
+6. Continuously updated version of the public suffix list
+7. **TypeScript**, ships with `umd`, `esm`, `cjs` bundles and _type definitions_
+8. Small bundles and small memory footprint
+9. Battle tested: full test coverage and production use
+
+# Install
+
+```bash
+npm install --save tldts
+```
+
+# Usage
+
+Using the command-line interface:
+
+```js
+$ npx tldts 'http://www.writethedocs.org/conf/eu/2017/'
+{
+  "domain": "writethedocs.org",
+  "domainWithoutSuffix": "writethedocs",
+  "hostname": "www.writethedocs.org",
+  "isIcann": true,
+  "isIp": false,
+  "isPrivate": false,
+  "publicSuffix": "org",
+  "subdomain": "www"
+}
+```
+
+Programmatically:
+
+```js
+const { parse } = require('tldts');
+
+// Retrieving hostname related informations of a given URL
+parse('http://www.writethedocs.org/conf/eu/2017/');
+// { domain: 'writethedocs.org',
+//   domainWithoutSuffix: 'writethedocs',
+//   hostname: 'www.writethedocs.org',
+//   isIcann: true,
+//   isIp: false,
+//   isPrivate: false,
+//   publicSuffix: 'org',
+//   subdomain: 'www' }
+```
+
+Modern _ES6 modules import_ is also supported:
+
+```js
+import { parse } from 'tldts';
+```
+
+Alternatively, you can try it _directly in your browser_ here: https://npm.runkit.com/tldts
+
+# API
+
+- `tldts.parse(url | hostname, options)`
+- `tldts.getHostname(url | hostname, options)`
+- `tldts.getDomain(url | hostname, options)`
+- `tldts.getPublicSuffix(url | hostname, options)`
+- `tldts.getSubdomain(url, | hostname, options)`
+- `tldts.getDomainWithoutSuffix(url | hostname, options)`
+
+The behavior of `tldts` can be customized using an `options` argument for all
+the functions exposed as part of the public API. This is useful to both change
+the behavior of the library as well as fine-tune the performance depending on
+your inputs.
+
+```js
+{
+  // Use suffixes from ICANN section (default: true)
+  allowIcannDomains: boolean;
+  // Use suffixes from Private section (default: false)
+  allowPrivateDomains: boolean;
+  // Extract and validate hostname (default: true)
+  // When set to `false`, inputs will be considered valid hostnames.
+  extractHostname: boolean;
+  // Validate hostnames after parsing (default: true)
+  // If a hostname is not valid, not further processing is performed. When set
+  // to `false`, inputs to the library will be considered valid and parsing will
+  // proceed regardless.
+  validateHostname: boolean;
+  // Perform IP address detection (default: true).
+  detectIp: boolean;
+  // Assume that both URLs and hostnames can be given as input (default: true)
+  // If set to `false` we assume only URLs will be given as input, which
+  // speed-ups processing.
+  mixedInputs: boolean;
+  // Specifies extra valid suffixes (default: null)
+  validHosts: string[] | null;
+}
+```
+
+The `parse` method returns handy **properties about a URL or a hostname**.
+
+```js
+const tldts = require('tldts');
+
+tldts.parse('https://spark-public.s3.amazonaws.com/dataanalysis/loansData.csv');
+// { domain: 'amazonaws.com',
+//   domainWithoutSuffix: 'amazonaws',
+//   hostname: 'spark-public.s3.amazonaws.com',
+//   isIcann: true,
+//   isIp: false,
+//   isPrivate: false,
+//   publicSuffix: 'com',
+//   subdomain: 'spark-public.s3' }
+
+tldts.parse(
+  'https://spark-public.s3.amazonaws.com/dataanalysis/loansData.csv',
+  { allowPrivateDomains: true },
+);
+// { domain: 'spark-public.s3.amazonaws.com',
+//   domainWithoutSuffix: 'spark-public',
+//   hostname: 'spark-public.s3.amazonaws.com',
+//   isIcann: false,
+//   isIp: false,
+//   isPrivate: true,
+//   publicSuffix: 's3.amazonaws.com',
+//   subdomain: '' }
+
+tldts.parse('gopher://domain.unknown/');
+// { domain: 'domain.unknown',
+//   domainWithoutSuffix: 'domain',
+//   hostname: 'domain.unknown',
+//   isIcann: false,
+//   isIp: false,
+//   isPrivate: true,
+//   publicSuffix: 'unknown',
+//   subdomain: '' }
+
+tldts.parse('https://192.168.0.0'); // IPv4
+// { domain: null,
+//   domainWithoutSuffix: null,
+//   hostname: '192.168.0.0',
+//   isIcann: null,
+//   isIp: true,
+//   isPrivate: null,
+//   publicSuffix: null,
+//   subdomain: null }
+
+tldts.parse('https://[::1]'); // IPv6
+// { domain: null,
+//   domainWithoutSuffix: null,
+//   hostname: '::1',
+//   isIcann: null,
+//   isIp: true,
+//   isPrivate: null,
+//   publicSuffix: null,
+//   subdomain: null }
+
+tldts.parse('tldts@emailprovider.co.uk'); // email
+// { domain: 'emailprovider.co.uk',
+//   domainWithoutSuffix: 'emailprovider',
+//   hostname: 'emailprovider.co.uk',
+//   isIcann: true,
+//   isIp: false,
+//   isPrivate: false,
+//   publicSuffix: 'co.uk',
+//   subdomain: '' }
+```
+
+| Property Name         | Type   | Description                                     |
+| :-------------------- | :----- | :---------------------------------------------- |
+| `hostname`            | `str`  | `hostname` of the input extracted automatically |
+| `domain`              | `str`  | Domain (tld + sld)                              |
+| `domainWithoutSuffix` | `str`  | Domain without public suffix                    |
+| `subdomain`           | `str`  | Sub domain (what comes after `domain`)          |
+| `publicSuffix`        | `str`  | Public Suffix (tld) of `hostname`               |
+| `isIcann`             | `bool` | Does TLD come from ICANN part of the list       |
+| `isPrivate`           | `bool` | Does TLD come from Private part of the list     |
+| `isIP`                | `bool` | Is `hostname` an IP address?                    |
+
+## Single purpose methods
+
+These methods are shorthands if you want to retrieve only a single value (and
+will perform better than `parse` because less work will be needed).
+
+### getHostname(url | hostname, options?)
+
+Returns the hostname from a given string.
+
+```javascript
+const { getHostname } = require('tldts');
+
+getHostname('google.com'); // returns `google.com`
+getHostname('fr.google.com'); // returns `fr.google.com`
+getHostname('fr.google.google'); // returns `fr.google.google`
+getHostname('foo.google.co.uk'); // returns `foo.google.co.uk`
+getHostname('t.co'); // returns `t.co`
+getHostname('fr.t.co'); // returns `fr.t.co`
+getHostname(
+  'https://user:password@example.co.uk:8080/some/path?and&query#hash',
+); // returns `example.co.uk`
+```
+
+### getDomain(url | hostname, options?)
+
+Returns the fully qualified domain from a given string.
+
+```javascript
+const { getDomain } = require('tldts');
+
+getDomain('google.com'); // returns `google.com`
+getDomain('fr.google.com'); // returns `google.com`
+getDomain('fr.google.google'); // returns `google.google`
+getDomain('foo.google.co.uk'); // returns `google.co.uk`
+getDomain('t.co'); // returns `t.co`
+getDomain('fr.t.co'); // returns `t.co`
+getDomain('https://user:password@example.co.uk:8080/some/path?and&query#hash'); // returns `example.co.uk`
+```
+
+### getDomainWithoutSuffix(url | hostname, options?)
+
+Returns the domain (as returned by `getDomain(...)`) without the public suffix part.
+
+```javascript
+const { getDomainWithoutSuffix } = require('tldts');
+
+getDomainWithoutSuffix('google.com'); // returns `google`
+getDomainWithoutSuffix('fr.google.com'); // returns `google`
+getDomainWithoutSuffix('fr.google.google'); // returns `google`
+getDomainWithoutSuffix('foo.google.co.uk'); // returns `google`
+getDomainWithoutSuffix('t.co'); // returns `t`
+getDomainWithoutSuffix('fr.t.co'); // returns `t`
+getDomainWithoutSuffix(
+  'https://user:password@example.co.uk:8080/some/path?and&query#hash',
+); // returns `example`
+```
+
+### getSubdomain(url | hostname, options?)
+
+Returns the complete subdomain for a given string.
+
+```javascript
+const { getSubdomain } = require('tldts');
+
+getSubdomain('google.com'); // returns ``
+getSubdomain('fr.google.com'); // returns `fr`
+getSubdomain('google.co.uk'); // returns ``
+getSubdomain('foo.google.co.uk'); // returns `foo`
+getSubdomain('moar.foo.google.co.uk'); // returns `moar.foo`
+getSubdomain('t.co'); // returns ``
+getSubdomain('fr.t.co'); // returns `fr`
+getSubdomain(
+  'https://user:password@secure.example.co.uk:443/some/path?and&query#hash',
+); // returns `secure`
+```
+
+### getPublicSuffix(url | hostname, options?)
+
+Returns the [public suffix][] for a given string.
+
+```javascript
+const { getPublicSuffix } = require('tldts');
+
+getPublicSuffix('google.com'); // returns `com`
+getPublicSuffix('fr.google.com'); // returns `com`
+getPublicSuffix('google.co.uk'); // returns `co.uk`
+getPublicSuffix('s3.amazonaws.com'); // returns `com`
+getPublicSuffix('s3.amazonaws.com', { allowPrivateDomains: true }); // returns `s3.amazonaws.com`
+getPublicSuffix('tld.is.unknown'); // returns `unknown`
+```
+
+# Troubleshooting
+
+## Retrieving subdomain of `localhost` and custom hostnames
+
+`tldts` methods `getDomain` and `getSubdomain` are designed to **work only with _known and valid_ TLDs**.
+This way, you can trust what a domain is.
+
+`localhost` is a valid hostname but not a TLD. You can pass additional options to each method exposed by `tldts`:
+
+```js
+const tldts = require('tldts');
+
+tldts.getDomain('localhost'); // returns null
+tldts.getSubdomain('vhost.localhost'); // returns null
+
+tldts.getDomain('localhost', { validHosts: ['localhost'] }); // returns 'localhost'
+tldts.getSubdomain('vhost.localhost', { validHosts: ['localhost'] }); // returns 'vhost'
+```
+
+## Updating the TLDs List
+
+`tldts` made the opinionated choice of shipping with a list of suffixes directly
+in its bundle. There is currently no mechanism to update the lists yourself, but
+we make sure that the version shipped is always up-to-date.
+
+If you keep `tldts` updated, the lists should be up-to-date as well!
+
+# Performance
+
+`tldts` is the _fastest JavaScript library_ available for parsing hostnames. It is able to parse _millions of inputs per second_ (typically 2-3M depending on your hardware and inputs). It also offers granular options to fine-tune the behavior and performance of the library depending on the kind of inputs you are dealing with (e.g.: if you know you only manipulate valid hostnames you can disable the hostname extraction step with `{ extractHostname: false }`).
+
+Please see [this detailed comparison](./comparison/comparison.md) with other available libraries.
+
+## Contributors
+
+`tldts` is based upon the excellent `tld.js` library and would not exist without
+the many contributors who worked on the project:
+<a href="graphs/contributors"><img src="https://opencollective.com/tldjs/contributors.svg?width=890" /></a>
+
+This project would not be possible without the amazing Mozilla's
+[public suffix list][]. Thank you for your hard work!
+
+# License
+
+[MIT License](LICENSE).
+
+[badge-ci]: https://secure.travis-ci.org/remusao/tldts.svg?branch=master
+[badge-downloads]: https://img.shields.io/npm/dm/tldts.svg
+[public suffix list]: https://publicsuffix.org/list/
+[list the recent changes]: https://github.com/publicsuffix/list/commits/master
+[changes Atom Feed]: https://github.com/publicsuffix/list/commits/master.atom
+[public suffix]: https://publicsuffix.org/learn/

frontend/node_modules/tldts/bin/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { parse } = require('..');
+const readline = require('readline');
+
+if (process.argv.length > 2) {
+  // URL(s) was specified in the command arguments
+  console.log(
+    JSON.stringify(parse(process.argv[process.argv.length - 1]), null, 2),
+  );
+} else {
+  // No arguments were specified, read URLs from each line of STDIN
+  const rlInterface = readline.createInterface({
+    input: process.stdin,
+  });
+  rlInterface.on('line', function (line) {
+    console.log(JSON.stringify(parse(line), null, 2));
+  });
+}

frontend/node_modules/tldts/dist/cjs/src/suffix-trie.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = suffixLookup;
+const tldts_core_1 = require("tldts-core");
+const trie_1 = require("./data/trie");
+/**
+ * Lookup parts of domain in Trie
+ */
+function lookupInTrie(parts, trie, index, allowedMask) {
+    let result = null;
+    let node = trie;
+    while (node !== undefined) {
+        // We have a match!
+        if ((node[0] & allowedMask) !== 0) {
+            result = {
+                index: index + 1,
+                isIcann: node[0] === 1 /* RULE_TYPE.ICANN */,
+                isPrivate: node[0] === 2 /* RULE_TYPE.PRIVATE */,
+            };
+        }
+        // No more `parts` to look for
+        if (index === -1) {
+            break;
+        }
+        const succ = node[1];
+        node = Object.prototype.hasOwnProperty.call(succ, parts[index])
+            ? succ[parts[index]]
+            : succ['*'];
+        index -= 1;
+    }
+    return result;
+}
+/**
+ * Check if `hostname` has a valid public suffix in `trie`.
+ */
+function suffixLookup(hostname, options, out) {
+    var _a;
+    if ((0, tldts_core_1.fastPathLookup)(hostname, options, out)) {
+        return;
+    }
+    const hostnameParts = hostname.split('.');
+    const allowedMask = (options.allowPrivateDomains ? 2 /* RULE_TYPE.PRIVATE */ : 0) |
+        (options.allowIcannDomains ? 1 /* RULE_TYPE.ICANN */ : 0);
+    // Look for exceptions
+    const exceptionMatch = lookupInTrie(hostnameParts, trie_1.exceptions, hostnameParts.length - 1, allowedMask);
+    if (exceptionMatch !== null) {
+        out.isIcann = exceptionMatch.isIcann;
+        out.isPrivate = exceptionMatch.isPrivate;
+        out.publicSuffix = hostnameParts.slice(exceptionMatch.index + 1).join('.');
+        return;
+    }
+    // Look for a match in rules
+    const rulesMatch = lookupInTrie(hostnameParts, trie_1.rules, hostnameParts.length - 1, allowedMask);
+    if (rulesMatch !== null) {
+        out.isIcann = rulesMatch.isIcann;
+        out.isPrivate = rulesMatch.isPrivate;
+        out.publicSuffix = hostnameParts.slice(rulesMatch.index).join('.');
+        return;
+    }
+    // No match found...
+    // Prevailing rule is '*' so we consider the top-level domain to be the
+    // public suffix of `hostname` (e.g.: 'example.org' => 'org').
+    out.isIcann = false;
+    out.isPrivate = false;
+    out.publicSuffix = (_a = hostnameParts[hostnameParts.length - 1]) !== null && _a !== void 0 ? _a : null;
+}
+//# sourceMappingURL=suffix-trie.js.map

frontend/node_modules/tldts/dist/cjs/src/suffix-trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suffix-trie.js","sourceRoot":"","sources":["../../../src/suffix-trie.ts"],"names":[],"mappings":"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"}

frontend/node_modules/tldts/dist/es6/index.js

@@ -0,0 +1,33 @@
+import { getEmptyResult, parseImpl, resetResult, } from 'tldts-core';
+import suffixLookup from './src/suffix-trie';
+// For all methods but 'parse', it does not make sense to allocate an object
+// every single time to only return the value of a specific attribute. To avoid
+// this un-necessary allocation, we use a global object which is re-used.
+const RESULT = getEmptyResult();
+export function parse(url, options = {}) {
+    return parseImpl(url, 5 /* FLAG.ALL */, suffixLookup, options, getEmptyResult());
+}
+export function getHostname(url, options = {}) {
+    /*@__INLINE__*/ resetResult(RESULT);
+    return parseImpl(url, 0 /* FLAG.HOSTNAME */, suffixLookup, options, RESULT).hostname;
+}
+export function getPublicSuffix(url, options = {}) {
+    /*@__INLINE__*/ resetResult(RESULT);
+    return parseImpl(url, 2 /* FLAG.PUBLIC_SUFFIX */, suffixLookup, options, RESULT)
+        .publicSuffix;
+}
+export function getDomain(url, options = {}) {
+    /*@__INLINE__*/ resetResult(RESULT);
+    return parseImpl(url, 3 /* FLAG.DOMAIN */, suffixLookup, options, RESULT).domain;
+}
+export function getSubdomain(url, options = {}) {
+    /*@__INLINE__*/ resetResult(RESULT);
+    return parseImpl(url, 4 /* FLAG.SUB_DOMAIN */, suffixLookup, options, RESULT)
+        .subdomain;
+}
+export function getDomainWithoutSuffix(url, options = {}) {
+    /*@__INLINE__*/ resetResult(RESULT);
+    return parseImpl(url, 5 /* FLAG.ALL */, suffixLookup, options, RESULT)
+        .domainWithoutSuffix;
+}
+//# sourceMappingURL=index.js.map

frontend/node_modules/tldts/dist/es6/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EAGd,SAAS,EACT,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,YAAY,MAAM,mBAAmB,CAAC;AAE7C,4EAA4E;AAC5E,+EAA+E;AAC/E,yEAAyE;AACzE,MAAM,MAAM,GAAY,cAAc,EAAE,CAAC;AAEzC,MAAM,UAAU,KAAK,CAAC,GAAW,EAAE,UAA6B,EAAE;IAChE,OAAO,SAAS,CAAC,GAAG,oBAAY,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,GAAW,EACX,UAA6B,EAAE;IAE/B,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,GAAG,yBAAiB,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC;AAC/E,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,GAAW,EACX,UAA6B,EAAE;IAE/B,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,GAAG,8BAAsB,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC;SACrE,YAAY,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,SAAS,CACvB,GAAW,EACX,UAA6B,EAAE;IAE/B,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,GAAG,uBAAe,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC;AAC3E,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,GAAW,EACX,UAA6B,EAAE;IAE/B,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,GAAG,2BAAmB,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC;SAClE,SAAS,CAAC;AACf,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,GAAW,EACX,UAA6B,EAAE;IAE/B,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC,GAAG,oBAAY,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC;SAC3D,mBAAmB,CAAC;AACzB,CAAC"}

frontend/node_modules/tldts/dist/es6/src/suffix-trie.js

@@ -0,0 +1,64 @@
+import { fastPathLookup, } from 'tldts-core';
+import { exceptions, rules } from './data/trie';
+/**
+ * Lookup parts of domain in Trie
+ */
+function lookupInTrie(parts, trie, index, allowedMask) {
+    let result = null;
+    let node = trie;
+    while (node !== undefined) {
+        // We have a match!
+        if ((node[0] & allowedMask) !== 0) {
+            result = {
+                index: index + 1,
+                isIcann: node[0] === 1 /* RULE_TYPE.ICANN */,
+                isPrivate: node[0] === 2 /* RULE_TYPE.PRIVATE */,
+            };
+        }
+        // No more `parts` to look for
+        if (index === -1) {
+            break;
+        }
+        const succ = node[1];
+        node = Object.prototype.hasOwnProperty.call(succ, parts[index])
+            ? succ[parts[index]]
+            : succ['*'];
+        index -= 1;
+    }
+    return result;
+}
+/**
+ * Check if `hostname` has a valid public suffix in `trie`.
+ */
+export default function suffixLookup(hostname, options, out) {
+    var _a;
+    if (fastPathLookup(hostname, options, out)) {
+        return;
+    }
+    const hostnameParts = hostname.split('.');
+    const allowedMask = (options.allowPrivateDomains ? 2 /* RULE_TYPE.PRIVATE */ : 0) |
+        (options.allowIcannDomains ? 1 /* RULE_TYPE.ICANN */ : 0);
+    // Look for exceptions
+    const exceptionMatch = lookupInTrie(hostnameParts, exceptions, hostnameParts.length - 1, allowedMask);
+    if (exceptionMatch !== null) {
+        out.isIcann = exceptionMatch.isIcann;
+        out.isPrivate = exceptionMatch.isPrivate;
+        out.publicSuffix = hostnameParts.slice(exceptionMatch.index + 1).join('.');
+        return;
+    }
+    // Look for a match in rules
+    const rulesMatch = lookupInTrie(hostnameParts, rules, hostnameParts.length - 1, allowedMask);
+    if (rulesMatch !== null) {
+        out.isIcann = rulesMatch.isIcann;
+        out.isPrivate = rulesMatch.isPrivate;
+        out.publicSuffix = hostnameParts.slice(rulesMatch.index).join('.');
+        return;
+    }
+    // No match found...
+    // Prevailing rule is '*' so we consider the top-level domain to be the
+    // public suffix of `hostname` (e.g.: 'example.org' => 'org').
+    out.isIcann = false;
+    out.isPrivate = false;
+    out.publicSuffix = (_a = hostnameParts[hostnameParts.length - 1]) !== null && _a !== void 0 ? _a : null;
+}
+//# sourceMappingURL=suffix-trie.js.map

frontend/node_modules/tldts/dist/es6/src/suffix-trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suffix-trie.js","sourceRoot":"","sources":["../../../src/suffix-trie.ts"],"names":[],"mappings":"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"}

frontend/node_modules/tldts/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import { IOptions, IResult } from 'tldts-core';
+export declare function parse(url: string, options?: Partial<IOptions>): IResult;
+export declare function getHostname(url: string, options?: Partial<IOptions>): string | null;
+export declare function getPublicSuffix(url: string, options?: Partial<IOptions>): string | null;
+export declare function getDomain(url: string, options?: Partial<IOptions>): string | null;
+export declare function getSubdomain(url: string, options?: Partial<IOptions>): string | null;
+export declare function getDomainWithoutSuffix(url: string, options?: Partial<IOptions>): string | null;

frontend/node_modules/tldts/dist/types/src/data/trie.d.ts

@@ -0,0 +1,5 @@
+export type ITrie = [0 | 1 | 2, {
+    [label: string]: ITrie;
+}];
+export declare const exceptions: ITrie;
+export declare const rules: ITrie;

frontend/node_modules/tldts/dist/types/src/suffix-trie.d.ts

@@ -0,0 +1,5 @@
+import { IPublicSuffix, ISuffixLookupOptions } from 'tldts-core';
+/**
+ * Check if `hostname` has a valid public suffix in `trie`.
+ */
+export default function suffixLookup(hostname: string, options: ISuffixLookupOptions, out: IPublicSuffix): void;

frontend/node_modules/tldts/index.ts

@@ -0,0 +1,62 @@
+import {
+  FLAG,
+  getEmptyResult,
+  IOptions,
+  IResult,
+  parseImpl,
+  resetResult,
+} from 'tldts-core';
+
+import suffixLookup from './src/suffix-trie';
+
+// For all methods but 'parse', it does not make sense to allocate an object
+// every single time to only return the value of a specific attribute. To avoid
+// this un-necessary allocation, we use a global object which is re-used.
+const RESULT: IResult = getEmptyResult();
+
+export function parse(url: string, options: Partial<IOptions> = {}): IResult {
+  return parseImpl(url, FLAG.ALL, suffixLookup, options, getEmptyResult());
+}
+
+export function getHostname(
+  url: string,
+  options: Partial<IOptions> = {},
+): string | null {
+  /*@__INLINE__*/ resetResult(RESULT);
+  return parseImpl(url, FLAG.HOSTNAME, suffixLookup, options, RESULT).hostname;
+}
+
+export function getPublicSuffix(
+  url: string,
+  options: Partial<IOptions> = {},
+): string | null {
+  /*@__INLINE__*/ resetResult(RESULT);
+  return parseImpl(url, FLAG.PUBLIC_SUFFIX, suffixLookup, options, RESULT)
+    .publicSuffix;
+}
+
+export function getDomain(
+  url: string,
+  options: Partial<IOptions> = {},
+): string | null {
+  /*@__INLINE__*/ resetResult(RESULT);
+  return parseImpl(url, FLAG.DOMAIN, suffixLookup, options, RESULT).domain;
+}
+
+export function getSubdomain(
+  url: string,
+  options: Partial<IOptions> = {},
+): string | null {
+  /*@__INLINE__*/ resetResult(RESULT);
+  return parseImpl(url, FLAG.SUB_DOMAIN, suffixLookup, options, RESULT)
+    .subdomain;
+}
+
+export function getDomainWithoutSuffix(
+  url: string,
+  options: Partial<IOptions> = {},
+): string | null {
+  /*@__INLINE__*/ resetResult(RESULT);
+  return parseImpl(url, FLAG.ALL, suffixLookup, options, RESULT)
+    .domainWithoutSuffix;
+}

frontend/node_modules/tldts/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "tldts",
+  "version": "6.1.86",
+  "description": "Library to work against complex domain names, subdomains and URIs.",
+  "author": {
+    "name": "Rémi Berson"
+  },
+  "contributors": [
+    "Alexei <alexeiatyahoodotcom@gmail.com>",
+    "Alexey <kureev-mail@ya.ru>",
+    "Andrew <chefandrew@seomoz.org>",
+    "Johannes Ewald <johannes.ewald@peerigon.com>",
+    "Jérôme Desboeufs <jerome.desboeufs@gmail.com>",
+    "Kelly Campbell <kelly.a.campbell@gmail.com>",
+    "Kiko Beats <josefrancisco.verdu@gmail.com>",
+    "Kris Reeves <krisreeves@searchfanatics.com>",
+    "Krzysztof Jan Modras <chrmod@chrmod.net>",
+    "Olivier Melcher <olivier.melcher@gmail.com>",
+    "Rémi Berson <remi.berson@pm.me>",
+    "Saad Rashid <srashid@lendinghome.com>",
+    "Thomas Parisot <hi@oncletom.io>",
+    "Timo Tijhof <krinklemail@gmail.com>",
+    "Xavier Damman <xdamman@gmail.com>",
+    "Yehezkiel Syamsuhadi <yehezkielbs@gmail.com>"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/remusao/tldts#readme",
+  "bugs": {
+    "url": "https://github.com/remusao/tldts/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/remusao/tldts.git"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/es6/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "index.ts"
+  ],
+  "bin": {
+    "tldts": "bin/cli.js"
+  },
+  "scripts": {
+    "clean": "rimraf dist coverage",
+    "build": "tsc --build ./tsconfig.json",
+    "bundle": "tsc --build ./tsconfig.bundle.json && rollup --config ./rollup.config.mjs",
+    "prepack": "yarn run bundle",
+    "test": "nyc mocha --config ../../.mocharc.cjs"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-terser": "^0.4.0",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "@types/chai": "^4.2.18",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^22.0.0",
+    "chai": "^4.4.1",
+    "mocha": "^11.0.1",
+    "nyc": "^17.0.0",
+    "rimraf": "^5.0.1",
+    "rollup": "^4.1.0",
+    "rollup-plugin-sourcemaps": "^0.6.1",
+    "tldts-tests": "^6.1.86",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "tldts-core": "^6.1.86"
+  },
+  "keywords": [
+    "tld",
+    "sld",
+    "domain",
+    "subdomain",
+    "subdomain",
+    "hostname",
+    "browser",
+    "uri",
+    "url",
+    "domain name",
+    "public suffix",
+    "url parsing",
+    "typescript"
+  ],
+  "gitHead": "94251baa0e4ee46df6fd06fcd3749fcdf9b14ebc"
+}

frontend/node_modules/tldts/src/suffix-trie.ts

@@ -0,0 +1,110 @@
+import {
+  fastPathLookup,
+  IPublicSuffix,
+  ISuffixLookupOptions,
+} from 'tldts-core';
+import { exceptions, ITrie, rules } from './data/trie';
+
+// Flags used to know if a rule is ICANN or Private
+const enum RULE_TYPE {
+  ICANN = 1,
+  PRIVATE = 2,
+}
+
+interface IMatch {
+  index: number;
+  isIcann: boolean;
+  isPrivate: boolean;
+}
+
+/**
+ * Lookup parts of domain in Trie
+ */
+function lookupInTrie(
+  parts: string[],
+  trie: ITrie,
+  index: number,
+  allowedMask: number,
+): IMatch | null {
+  let result: IMatch | null = null;
+  let node: ITrie | undefined = trie;
+  while (node !== undefined) {
+    // We have a match!
+    if ((node[0] & allowedMask) !== 0) {
+      result = {
+        index: index + 1,
+        isIcann: node[0] === RULE_TYPE.ICANN,
+        isPrivate: node[0] === RULE_TYPE.PRIVATE,
+      };
+    }
+
+    // No more `parts` to look for
+    if (index === -1) {
+      break;
+    }
+
+    const succ: { [label: string]: ITrie } = node[1];
+    node = Object.prototype.hasOwnProperty.call(succ, parts[index]!)
+      ? succ[parts[index]!]
+      : succ['*'];
+    index -= 1;
+  }
+
+  return result;
+}
+
+/**
+ * Check if `hostname` has a valid public suffix in `trie`.
+ */
+export default function suffixLookup(
+  hostname: string,
+  options: ISuffixLookupOptions,
+  out: IPublicSuffix,
+): void {
+  if (fastPathLookup(hostname, options, out)) {
+    return;
+  }
+
+  const hostnameParts = hostname.split('.');
+
+  const allowedMask =
+    (options.allowPrivateDomains ? RULE_TYPE.PRIVATE : 0) |
+    (options.allowIcannDomains ? RULE_TYPE.ICANN : 0);
+
+  // Look for exceptions
+  const exceptionMatch = lookupInTrie(
+    hostnameParts,
+    exceptions,
+    hostnameParts.length - 1,
+    allowedMask,
+  );
+
+  if (exceptionMatch !== null) {
+    out.isIcann = exceptionMatch.isIcann;
+    out.isPrivate = exceptionMatch.isPrivate;
+    out.publicSuffix = hostnameParts.slice(exceptionMatch.index + 1).join('.');
+    return;
+  }
+
+  // Look for a match in rules
+  const rulesMatch = lookupInTrie(
+    hostnameParts,
+    rules,
+    hostnameParts.length - 1,
+    allowedMask,
+  );
+
+  if (rulesMatch !== null) {
+    out.isIcann = rulesMatch.isIcann;
+    out.isPrivate = rulesMatch.isPrivate;
+    out.publicSuffix = hostnameParts.slice(rulesMatch.index).join('.');
+    return;
+  }
+
+  // No match found...
+  // Prevailing rule is '*' so we consider the top-level domain to be the
+  // public suffix of `hostname` (e.g.: 'example.org' => 'org').
+  out.isIcann = false;
+  out.isPrivate = false;
+  out.publicSuffix = hostnameParts[hostnameParts.length - 1] ?? null;
+}