kennel 0.1.8 → 0.2.0

package/node_modules/@libsql/client/lib-esm/ws.js

@@ -0,0 +1,359 @@
+import * as hrana from "@libsql/hrana-client";
+import { LibsqlError } from "@libsql/core/api";
+import { expandConfig } from "@libsql/core/config";
+import { HranaTransaction, executeHranaBatch, stmtToHrana, resultSetFromHrana, mapHranaError, } from "./hrana.js";
+import { SqlCache } from "./sql_cache.js";
+import { encodeBaseUrl } from "@libsql/core/uri";
+import { supportedUrlLink } from "@libsql/core/util";
+import promiseLimit from "promise-limit";
+export * from "@libsql/core/api";
+export function createClient(config) {
+    return _createClient(expandConfig(config, false));
+}
+/** @private */
+export function _createClient(config) {
+    if (config.scheme !== "wss" && config.scheme !== "ws") {
+        throw new LibsqlError('The WebSocket client supports only "libsql:", "wss:" and "ws:" URLs, ' +
+            `got ${JSON.stringify(config.scheme + ":")}. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
+    }
+    if (config.encryptionKey !== undefined) {
+        throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
+    }
+    if (config.scheme === "ws" && config.tls) {
+        throw new LibsqlError(`A "ws:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
+    }
+    else if (config.scheme === "wss" && !config.tls) {
+        throw new LibsqlError(`A "wss:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
+    }
+    const url = encodeBaseUrl(config.scheme, config.authority, config.path);
+    let client;
+    try {
+        client = hrana.openWs(url, config.authToken);
+    }
+    catch (e) {
+        if (e instanceof hrana.WebSocketUnsupportedError) {
+            const suggestedScheme = config.scheme === "wss" ? "https" : "http";
+            const suggestedUrl = encodeBaseUrl(suggestedScheme, config.authority, config.path);
+            throw new LibsqlError("This environment does not support WebSockets, please switch to the HTTP client by using " +
+                `a "${suggestedScheme}:" URL (${JSON.stringify(suggestedUrl)}). ` +
+                `For more information, please read ${supportedUrlLink}`, "WEBSOCKETS_NOT_SUPPORTED");
+        }
+        throw mapHranaError(e);
+    }
+    return new WsClient(client, url, config.authToken, config.intMode, config.concurrency);
+}
+const maxConnAgeMillis = 60 * 1000;
+const sqlCacheCapacity = 100;
+export class WsClient {
+    #url;
+    #authToken;
+    #intMode;
+    // State of the current connection. The `hrana.WsClient` inside may be closed at any moment due to an
+    // asynchronous error.
+    #connState;
+    // If defined, this is a connection that will be used in the future, once it is ready.
+    #futureConnState;
+    closed;
+    protocol;
+    #isSchemaDatabase;
+    #promiseLimitFunction;
+    /** @private */
+    constructor(client, url, authToken, intMode, concurrency) {
+        this.#url = url;
+        this.#authToken = authToken;
+        this.#intMode = intMode;
+        this.#connState = this.#openConn(client);
+        this.#futureConnState = undefined;
+        this.closed = false;
+        this.protocol = "ws";
+        this.#promiseLimitFunction = promiseLimit(concurrency);
+    }
+    async limit(fn) {
+        return this.#promiseLimitFunction(fn);
+    }
+    async execute(stmtOrSql, args) {
+        let stmt;
+        if (typeof stmtOrSql === "string") {
+            stmt = {
+                sql: stmtOrSql,
+                args: args || [],
+            };
+        }
+        else {
+            stmt = stmtOrSql;
+        }
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const hranaStmt = stmtToHrana(stmt);
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                streamState.conn.sqlCache.apply([hranaStmt]);
+                const hranaRowsPromise = streamState.stream.query(hranaStmt);
+                streamState.stream.closeGracefully();
+                const hranaRowsResult = await hranaRowsPromise;
+                return resultSetFromHrana(hranaRowsResult);
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async batch(stmts, mode = "deferred") {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const normalizedStmts = stmts.map((stmt) => {
+                    if (Array.isArray(stmt)) {
+                        return {
+                            sql: stmt[0],
+                            args: stmt[1] || [],
+                        };
+                    }
+                    return stmt;
+                });
+                const hranaStmts = normalizedStmts.map(stmtToHrana);
+                const version = await streamState.conn.client.getVersion();
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                streamState.conn.sqlCache.apply(hranaStmts);
+                const batch = streamState.stream.batch(version >= 3);
+                const resultsPromise = executeHranaBatch(mode, version, batch, hranaStmts);
+                const results = await resultsPromise;
+                return results;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async migrate(stmts) {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const hranaStmts = stmts.map(stmtToHrana);
+                const version = await streamState.conn.client.getVersion();
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                const batch = streamState.stream.batch(version >= 3);
+                const resultsPromise = executeHranaBatch("deferred", version, batch, hranaStmts, true);
+                const results = await resultsPromise;
+                return results;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async transaction(mode = "write") {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const version = await streamState.conn.client.getVersion();
+                // the BEGIN statement will be batched with the first statement on the transaction to save a
+                // network roundtrip
+                return new WsTransaction(this, streamState, mode, version);
+            }
+            catch (e) {
+                this._closeStream(streamState);
+                throw mapHranaError(e);
+            }
+        });
+    }
+    async executeMultiple(sql) {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                const promise = streamState.stream.sequence(sql);
+                streamState.stream.closeGracefully();
+                await promise;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    sync() {
+        throw new LibsqlError("sync not supported in ws mode", "SYNC_NOT_SUPPORTED");
+    }
+    async #openStream() {
+        if (this.closed) {
+            throw new LibsqlError("The client is closed", "CLIENT_CLOSED");
+        }
+        const now = new Date();
+        const ageMillis = now.valueOf() - this.#connState.openTime.valueOf();
+        if (ageMillis > maxConnAgeMillis &&
+            this.#futureConnState === undefined) {
+            // The existing connection is too old, let's open a new one.
+            const futureConnState = this.#openConn();
+            this.#futureConnState = futureConnState;
+            // However, if we used `futureConnState` immediately, we would introduce additional latency,
+            // because we would have to wait for the WebSocket handshake to complete, even though we may a
+            // have perfectly good existing connection in `this.#connState`!
+            //
+            // So we wait until the `hrana.Client.getVersion()` operation completes (which happens when the
+            // WebSocket hanshake completes), and only then we replace `this.#connState` with
+            // `futureConnState`, which is stored in `this.#futureConnState` in the meantime.
+            futureConnState.client.getVersion().then((_version) => {
+                if (this.#connState !== futureConnState) {
+                    // We need to close `this.#connState` before we replace it. However, it is possible
+                    // that `this.#connState` has already been replaced: see the code below.
+                    if (this.#connState.streamStates.size === 0) {
+                        this.#connState.client.close();
+                    }
+                    else {
+                        // If there are existing streams on the connection, we must not close it, because
+                        // these streams would be broken. The last stream to be closed will also close the
+                        // connection in `_closeStream()`.
+                    }
+                }
+                this.#connState = futureConnState;
+                this.#futureConnState = undefined;
+            }, (_e) => {
+                // If the new connection could not be established, let's just ignore the error and keep
+                // using the existing connection.
+                this.#futureConnState = undefined;
+            });
+        }
+        if (this.#connState.client.closed) {
+            // An error happened on this connection and it has been closed. Let's try to seamlessly reconnect.
+            try {
+                if (this.#futureConnState !== undefined) {
+                    // We are already in the process of opening a new connection, so let's just use it
+                    // immediately.
+                    this.#connState = this.#futureConnState;
+                }
+                else {
+                    this.#connState = this.#openConn();
+                }
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+        }
+        const connState = this.#connState;
+        try {
+            // Now we wait for the WebSocket handshake to complete (if it hasn't completed yet). Note that
+            // this does not increase latency, because any messages that we would send on the WebSocket before
+            // the handshake would be queued until the handshake is completed anyway.
+            if (connState.useSqlCache === undefined) {
+                connState.useSqlCache =
+                    (await connState.client.getVersion()) >= 2;
+                if (connState.useSqlCache) {
+                    connState.sqlCache.capacity = sqlCacheCapacity;
+                }
+            }
+            const stream = connState.client.openStream();
+            stream.intMode = this.#intMode;
+            const streamState = { conn: connState, stream };
+            connState.streamStates.add(streamState);
+            return streamState;
+        }
+        catch (e) {
+            throw mapHranaError(e);
+        }
+    }
+    #openConn(client) {
+        try {
+            client ??= hrana.openWs(this.#url, this.#authToken);
+            return {
+                client,
+                useSqlCache: undefined,
+                sqlCache: new SqlCache(client, 0),
+                openTime: new Date(),
+                streamStates: new Set(),
+            };
+        }
+        catch (e) {
+            throw mapHranaError(e);
+        }
+    }
+    async reconnect() {
+        try {
+            for (const st of Array.from(this.#connState.streamStates)) {
+                try {
+                    st.stream.close();
+                }
+                catch { }
+            }
+            this.#connState.client.close();
+        }
+        catch { }
+        if (this.#futureConnState) {
+            try {
+                this.#futureConnState.client.close();
+            }
+            catch { }
+            this.#futureConnState = undefined;
+        }
+        const next = this.#openConn();
+        const version = await next.client.getVersion();
+        next.useSqlCache = version >= 2;
+        if (next.useSqlCache) {
+            next.sqlCache.capacity = sqlCacheCapacity;
+        }
+        this.#connState = next;
+        this.closed = false;
+    }
+    _closeStream(streamState) {
+        streamState.stream.close();
+        const connState = streamState.conn;
+        connState.streamStates.delete(streamState);
+        if (connState.streamStates.size === 0 &&
+            connState !== this.#connState) {
+            // We are not using this connection anymore and this is the last stream that was using it, so we
+            // must close it now.
+            connState.client.close();
+        }
+    }
+    close() {
+        this.#connState.client.close();
+        this.closed = true;
+        if (this.#futureConnState) {
+            try {
+                this.#futureConnState.client.close();
+            }
+            catch { }
+            this.#futureConnState = undefined;
+        }
+        this.closed = true;
+    }
+}
+export class WsTransaction extends HranaTransaction {
+    #client;
+    #streamState;
+    /** @private */
+    constructor(client, state, mode, version) {
+        super(mode, version);
+        this.#client = client;
+        this.#streamState = state;
+    }
+    /** @private */
+    _getStream() {
+        return this.#streamState.stream;
+    }
+    /** @private */
+    _getSqlCache() {
+        return this.#streamState.conn.sqlCache;
+    }
+    close() {
+        this.#client._closeStream(this.#streamState);
+    }
+    get closed() {
+        return this.#streamState.stream.closed;
+    }
+}

package/node_modules/@libsql/client/package.json

@@ -0,0 +1,123 @@
+{
+    "name": "@libsql/client",
+    "version": "0.17.4",
+    "keywords": [
+        "libsql",
+        "database",
+        "sqlite",
+        "serverless",
+        "vercel",
+        "netlify",
+        "lambda"
+    ],
+    "description": "libSQL driver for TypeScript and JavaScript",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tursodatabase/libsql-client-ts",
+        "directory": "packages/libsql-client"
+    },
+    "authors": [
+        "Jan Špaček <honza@chiselstrike.com>",
+        "Pekka Enberg <penberg@chiselstrike.com>",
+        "Jan Plhak <jp@chiselstrike.com>"
+    ],
+    "license": "MIT",
+    "type": "module",
+    "main": "lib-cjs/node.js",
+    "types": "lib-esm/node.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib-esm/node.d.ts",
+            "import": {
+                "workerd": "./lib-esm/web.js",
+                "deno": "./lib-esm/node.js",
+                "edge-light": "./lib-esm/web.js",
+                "netlify": "./lib-esm/web.js",
+                "node": "./lib-esm/node.js",
+                "browser": "./lib-esm/web.js",
+                "default": "./lib-esm/node.js"
+            },
+            "require": "./lib-cjs/node.js"
+        },
+        "./node": {
+            "types": "./lib-esm/node.d.ts",
+            "import": "./lib-esm/node.js",
+            "require": "./lib-cjs/node.js"
+        },
+        "./http": {
+            "types": "./lib-esm/http.d.ts",
+            "import": "./lib-esm/http.js",
+            "require": "./lib-cjs/http.js"
+        },
+        "./ws": {
+            "types": "./lib-esm/ws.d.ts",
+            "import": "./lib-esm/ws.js",
+            "require": "./lib-cjs/ws.js"
+        },
+        "./sqlite3": {
+            "types": "./lib-esm/sqlite3.d.ts",
+            "import": "./lib-esm/sqlite3.js",
+            "require": "./lib-cjs/sqlite3.js"
+        },
+        "./web": {
+            "types": "./lib-esm/web.d.ts",
+            "import": "./lib-esm/web.js",
+            "require": "./lib-cjs/web.js"
+        }
+    },
+    "typesVersions": {
+        "*": {
+            ".": [
+                "./lib-esm/node.d.ts"
+            ],
+            "http": [
+                "./lib-esm/http.d.ts"
+            ],
+            "hrana": [
+                "./lib-esm/hrana.d.ts"
+            ],
+            "sqlite3": [
+                "./lib-esm/sqlite3.d.ts"
+            ],
+            "web": [
+                "./lib-esm/web.d.ts"
+            ]
+        }
+    },
+    "files": [
+        "lib-cjs/**",
+        "lib-esm/**",
+        "README.md"
+    ],
+    "scripts": {
+        "prepublishOnly": "npm run build",
+        "prebuild": "rm -rf ./lib-cjs ./lib-esm",
+        "build": "npm run build:cjs && npm run build:esm",
+        "build:cjs": "tsc -p tsconfig.build-cjs.json",
+        "build:esm": "tsc -p tsconfig.build-esm.json",
+        "format:check": "prettier --check .",
+        "postbuild": "cp package-cjs.json ./lib-cjs/package.json",
+        "test": "jest --runInBand",
+        "typecheck": "tsc --noEmit",
+        "typedoc": "rm -rf ./docs && typedoc",
+        "lint-staged": "lint-staged"
+    },
+    "dependencies": {
+        "@libsql/core": "^0.17.4",
+        "@libsql/hrana-client": "^0.10.0",
+        "js-base64": "^3.7.5",
+        "libsql": "^0.5.28",
+        "promise-limit": "^2.7.0"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.2.5",
+        "@types/node": "^18.15.5",
+        "jest": "^29.3.1",
+        "lint-staged": "^15.2.2",
+        "msw": "^2.3.0",
+        "prettier": "3.2.5",
+        "ts-jest": "^29.0.5",
+        "typedoc": "^0.23.28",
+        "typescript": "^4.9.4"
+    }
+}

package/node_modules/@raggle-ai/local/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raggle AI
+
+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.

package/node_modules/@raggle-ai/local/README.md

@@ -0,0 +1,52 @@
+# @raggle-ai/local
+
+Local project discovery and expansion logic for Raggle Scout.
+
+## Install
+
+```sh
+npm install @raggle-ai/local
+```
+
+## Entry points
+
+- `@raggle-ai/local` — compatibility surface for existing consumers
+- `@raggle-ai/local/search` — search indexes, query helpers, and live/user search lifecycle; preferred for new search integrations
+- `@raggle-ai/local/sessions`
+- `@raggle-ai/local/acp`
+- `@raggle-ai/local/service-client` — generated typed Fetch client
+- `@raggle-ai/local/service` — start and close the local HTTP service
+- `@raggle-ai/local/folder-metadata` — synchronous local folder/icon resolution. `resolveFolderMetadata(folder, { repositoryRoot?, fallbackIcon? })` returns the resolved folder, repository root, and optional icon with `local`, `repository`, or `cache` provenance. Nearest local icons win, then ancestors up to the repository root, then the opaque catalog fallback. Without a repository, only the requested folder is searched. No network or image encoding occurs during resolution. Asset encoding remains internal to feed/metadata adapters.
+- `@raggle-ai/local/mcp` — process startup entry; importing it starts the stdio MCP server
+
+The library includes its native Node add-on and resolves it relative to the installed package. Internal `src` and `dist` paths are not public exports.
+
+## Automatic project emoji
+
+Project loaders, cache readers, and search results include `emoji?: string` by default when no image `icon` is available. The value is a Unicode emoji, not an image path. `hasIcon` continues to describe images only.
+
+`resolveProjectEmoji({ worktree, name?, icon?, tags?, keywords?, repositoryRoot?, parentProjectName? })` provides the same selection for other consumers. It checks the name and folder, then tags and keywords, then parent folders within the repository. Whole words and longer phrases are matched against a generated catalog of English Emojibase labels, country names, Emojibase/GitHub shortcodes, CLDR tags, and Emojilib keywords. Country names and exact labels take priority over broad keywords. Short country codes only match a complete name or tag, so `contact-us` does not select 🇺🇸. Tied matches remain unresolved instead of using dataset order. A small product preference map selects common meanings such as `music` → `🎵`, `greek` → `🇬🇷`, and `british` → `🇬🇧`.
+
+The catalog is loaded once per process without network access. `Greece` selects `🇬🇷`, `UK` selects `🇬🇧`, and unknown topics select `📁`. Full flag, variation-selector, and joined emoji sequences are preserved. Image icons take priority. Selection does not depend on the search query.
+
+Builds generate `src/generated/project-emoji.json` and `THIRD_PARTY_NOTICES.md` from pinned, development-only datasets. The published package contains the catalog and required license notices; it does not require Emojibase or Emojilib at runtime. To refresh the data, update the exact development dependency versions, run `npm run generate:emoji --workspace @raggle-ai/local`, review the generated changes, and run `npm run test:project-emoji` from the repository root. Do not edit the generated catalog manually.
+
+## Project display names and folder metadata
+
+Configure the shared formatter once per adapter:
+
+```ts
+import { createProjectPresenter } from "@raggle-ai/local";
+
+const presentProject = createProjectPresenter({ addEmojis: true });
+const display = presentProject(project);
+// display.name: "🎵 music" when no image exists
+// display.path: the unchanged folder or Markdown file path
+// display.metadata.icon?.path: the resolved local, inherited, or catalog image
+```
+
+The formatter reads current metadata from the local folder to open, or the containing folder for a Markdown result. Images take priority over generated emoji. Input names, paths, and search data do not change. With `addEmojis` omitted or false, `display.name` stays plain and `display.emoji` is available for a separate icon component. The project feed enables inline emoji. Raycast and the TUI use the separate emoji field so emoji and image icons occupy the same display column. Pass `addEmojis: false` to `listLocalProjectFeed` or `buildProjectFeedPresentation` when feed names will be indexed, as in the HTTP service.
+
+The CLI is installed separately with `npm install -g @raggle-ai/cli`. This package no longer owns `rgl` or `raggle-local`.
+
+Build from the repository root with `npm run build:all` before running `npm --workspace @raggle-ai/local test`. See the [repository documentation](https://github.com/raggle-ai/scout#readme) for development and release details.

package/node_modules/@raggle-ai/local/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,95 @@
+# Third-party emoji data notices
+
+Generated by `scripts/generate-project-emoji.mjs`. Do not edit manually.
+
+## emojibase-data 17.0.0
+
+MIT License
+
+Copyright (c) 2017-2019 Miles Johnson
+
+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.
+
+## emojilib 4.0.3
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Mu-An Chiou
+
+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.
+
+## Unicode and CLDR data
+
+Source: https://www.unicode.org/license.txt
+
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2026 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE 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 OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.