Upload folder using huggingface_hub (part 50)

tools/ui/node_modules/svelte-ast-print/LICENSE.md

@@ -0,0 +1,19 @@
+# MIT License
+
+Copyright (c) 2024-present [these people](https://github.com/xeho91/svelte-ast-print/graphs/contributors)
+
+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.

tools/ui/node_modules/svelte-ast-print/README.md

@@ -0,0 +1,248 @@
+# `svelte-ast-print`
+
+![NPM Version](https://img.shields.io/npm/v/svelte-ast-print?style=for-the-badge&logo=npm)
+
+Print **Svelte [AST]** nodes as a string.\
+A.k.a. [`parse`] in reverse.
+
+This is what you need to create [codemods] - e.g. for migration between Svelte versions syntaxes.
+
+## Documentation
+
+<https://xeho91.github.io/svelte-ast-print>
+
+## Acknowledgements
+
+This package depends on:
+
+1. [`esrap`] for printing [ESTree] specification-compliant [AST] nodes
+1. [`zimmerframe`] for walking on the [AST] nodes
+
+## Limitations
+
+> [!WARNING]
+> **TypeScript isn't supported**, yet.\
+> See & subscribe to progress on [issue #86 - Add support for TypeScript](https://github.com/xeho91/svelte-ast-print/issues/86).
+
+---
+
+> [!IMPORTANT]
+> **It ignores any previous formatting**.\
+> The current focus is to be able to write codemods as soon as possible - because right now, there are no alternatives.
+>
+> If you need to format modified and stringified Svelte AST, use available formatters for Svelte:
+>
+> - [Biome](https://github.com/biomejs/biome) - _⚠️ has partial support_
+> - [Prettier](https://github.com/prettier/prettier) with [`prettier-plugin-svelte`](https://github.com/sveltejs/prettier-plugin-svelte)
+>
+> See [Formatting](#formatting) section for examples.
+
+---
+
+> [!NOTE]
+> **This package is in beta stage.**\
+> See [Roadmap](https://github.com/xeho91/svelte-ast-print/discussions/2)
+
+## Getting started
+
+1. Use the package manager of your choice to install this package:
+
+   <details>
+       <summary>npm</summary>
+
+   ```sh
+   npm install svelte-ast-print
+   ```
+
+   </details>
+
+   <details>
+       <summary>yarn</summary>
+
+   ```sh
+   yarn add svelte-ast-print
+   ```
+
+   </details>
+
+   <details>
+       <summary>pnpm</summary>
+
+   ```sh
+   pnpm add svelte-ast-print
+   ```
+
+   </details>
+
+   <details>
+       <summary>bun</summary>
+
+   ```sh
+   bun add svelte-ast-print
+   ```
+
+   </details>
+
+1. Incorporate it into your project, for example using Node.js and with the Svelte [`parse`] method:
+
+   ```ts
+   import fs from "node:fs";
+
+   import { print } from "svelte-ast-print";
+   import { parse } from "svelte/compiler";
+
+   const originalSvelteCode = fs.readFileSync("src/App.svelte", "utf-8");
+   let svelteAST = parse(originalSvelteCode, { modern: true });
+   //                                          👆 For now, only modern is supported.
+   //                                             By default is 'false'.
+   //                                             Is it planned to be 'true' from Svelte v6+
+
+   // ...
+   // Do some modifications on this AST...
+   // e.g. transform `<slot />` to `{@render children()}`
+   // ...
+
+   const output = print(svelteAST); // AST is now a stringified code output! 🎉
+
+   fs.writeFileSync("src/App.svelte", output, { encoding: " utf-8" });
+   ```
+
+> [!IMPORTANT]
+> When using [`parse`] from `svelte`, please remember about passing `modern: true` to options _(second argument)_.
+> This option is only available starting `svelte@5`\
+> Example:
+>
+> ```js
+> import { parse } from "svelte/compiler";
+>
+> parse(code, { modern: true });
+> //          👆 Don't forget about this
+> ```
+>
+> You can omit it from Svelte `v6` - [source](https://github.com/sveltejs/svelte/blob/5a05f6371a994286626a44168cb2c02f8a2ad567/packages/svelte/src/compiler/index.js#L99-L100).
+
+---
+
+## Formatting
+
+Until the package will support formatting feature option... below are the current and **simplified** workaround examples
+on how to get printed output formatted to your needs.
+
+### Prettier
+
+Two dependencies are required:
+
+1. [`prettier`](https://github.com/prettier/prettier)
+1. [`prettier-plugin-svelte`](https://github.com/sveltejs/prettier-plugin-svelte)
+
+Follow `prettier-plugin-svelte` [Setup guide](https://github.com/sveltejs/prettier-plugin-svelte?tab=readme-ov-file#setup)
+on how to configure Prettier for Svelte.
+
+#### Using Prettier API
+
+```js
+import { format } from "prettier";
+import { parse } from "svelte/compiler";
+import { print } from "svelte-ast-print";
+
+let code = "..." // 👈 Raw Svelte code
+let ast = parse(code, { modern: true });
+//                    👆 Don't forget about this, you can omit in Svelte v6
+
+// .. work with AST - transformations, etc. ...
+
+const output = print(ast);
+const formatted = await format(output {
+	// Two ways to provide options:
+
+	// 1. provide file path to prettier config
+	filepath: "path/to/your/prettier/config/file",
+
+	// or..
+
+	// 2. See `prettier-plugin-svelte` Setup guide for more info
+	parser: "svelte",
+	plugins: ["svelte-plugin-prettier"]
+});
+```
+
+#### Using Prettier CLI
+
+... and Node.js API.
+
+```js
+import fs from "node:fs";
+import childProcess from "node:child_process";
+
+import { parse } from "svelte/compiler";
+import { print } from "svelte-ast-print";
+
+const code = fs.readFileSync("./Button.svelte", "utf-8");
+let ast = parse(code, { modern: true });
+//                    👆 Don't forget about this, you can omit in Svelte v6
+
+// .. work with AST - transformations, etc. ...
+
+const output = print(ast);
+
+fs.writeFileSync("./Button.svelte", output, "utf-8");
+childProcess.spawnSync("prettier", ["./Button.svelte", "--write"], {
+	stdio: "inherit",
+	encoding: "utf-8",
+});
+```
+
+### Biome
+
+> [!WARNING]
+> This sub-section is incomplete. Feel free to contribute!
+
+---
+
+## Contributing
+
+Take a look at [contributing guide](./.github/CONTRIBUTING.md).
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification.
+**Contributions of any kind are welcome!**
+
+💌 to these people:
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/xeho91"><img src="https://avatars.githubusercontent.com/u/18627568?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mateusz Kadlubowski</b></sub></a><br /><a href="https://github.com/xeho91/svelte-ast-print/commits?author=xeho91" title="Code">💻</a> <a href="#maintenance-xeho91" title="Maintenance">🚧</a> <a href="https://github.com/xeho91/svelte-ast-print/commits?author=xeho91" title="Documentation">📖</a> <a href="#infra-xeho91" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/xeho91/svelte-ast-print/commits?author=xeho91" title="Tests">⚠️</a></td>
+    <td align="center"><a href="https://github.com/manuel3108"><img src="https://avatars.githubusercontent.com/u/30698007?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Manuel</b></sub></a><br /><a href="https://github.com/xeho91/svelte-ast-print/commits?author=manuel3108" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://reinhold.is/"><img src="https://avatars.githubusercontent.com/u/5678122?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jeppe Reinhold</b></sub></a><br /><a href="https://github.com/xeho91/svelte-ast-print/commits?author=JReinhold" title="Code">💻</a></td>
+  </tr>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+## Support
+
+If you don't have time, but you need this project to work, or resolve an existing issue, consider sponsorship.
+
+## Author
+
+Mateusz "[xeho91](https://github.com/xeho91)" Kadlubowski
+
+## License
+
+![Project License](https://img.shields.io/github/license/xeho91/svelte-ast-print?style=for-the-badge)
+
+This project is licensed under the [MIT License](./LICENSE.md).
+
+<!-- links -->
+
+[`esrap`]: https://github.com/rich-harris/esrap
+[`zimmerframe`]: https://github.com/rich-harris/zimmerframe
+[ESTree]: https://github.com/estree/estree
+[codemods]: https://codemod.com/blog/what-are-codemods#ill-find-replace-whats-the-issue-hint-a-lot
+[`parse`]: https://svelte.dev/docs/svelte-compiler#parse
+[AST]: https://en.wikipedia.org/wiki/Abstract_syntax_tree

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2023 [these people](https://github.com/Rich-Harris/esrap/graphs/contributors)
+
+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.

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/README.md

@@ -0,0 +1,57 @@
+# esrap
+
+Parse in reverse. AST goes in, code comes out.
+
+## Usage
+
+```js
+import { print } from 'esrap';
+
+const { code, map } = print({
+  type: 'Program',
+  body: [
+    {
+      type: 'ExpressionStatement',
+      expression: {
+        callee: {
+          type: 'Identifier',
+          name: 'alert'
+        },
+        arguments: [
+          {
+            type: 'Literal',
+            value: 'hello world!'
+          }
+        ]
+      }
+    }
+  ]
+});
+
+console.log(code); // alert('hello world!');
+```
+
+If the nodes of the input AST have `loc` properties (e.g. the AST was generated with [`acorn`](https://github.com/acornjs/acorn/tree/master/acorn/#interface) with the `locations` option set), sourcemap mappings will be created.
+
+## Options
+
+You can pass information that will be added to the resulting sourcemap (note that the AST is assumed to come from a single file):
+
+```js
+const { code, map } = print(ast, {
+  sourceMapSource: 'input.js',
+  sourceMapContent: fs.readFileSync('input.js', 'utf-8')
+});
+```
+
+## Why not just use Prettier?
+
+Because it's ginormous.
+
+## Developing
+
+This repo uses [Bun](https://bun.sh/). Once it's installed, do `bun install` to install dependencies, and `bun test` to run the tests.
+
+## License
+
+[MIT](LICENSE)

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "esrap",
+  "version": "1.2.2",
+  "description": "Parse in reverse",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rich-Harris/esrap"
+  },
+  "type": "module",
+  "files": [
+    "src",
+    "types"
+  ],
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "types": "./types/index.d.ts",
+  "devDependencies": {
+    "acorn": "^8.10.0",
+    "bun-types": "^1.0.9",
+    "dts-buddy": "^0.2.4",
+    "prettier": "^3.0.3",
+    "typescript": "^5.2.2",
+    "zimmerframe": "^1.0.0"
+  },
+  "scripts": {
+    "check": "tsc",
+    "prepublishOnly": "bun test && dts-buddy",
+    "sandbox": "bun run test/sandbox/index.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@jridgewell/sourcemap-codec": "^1.4.15",
+    "@types/estree": "^1.0.1"
+  }
+}

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/src/handlers.js

@@ -0,0 +1,1265 @@
+/** @type {import('./types').Newline} */
+const newline = { type: 'Newline' };
+
+/** @type {import('./types').Indent} */
+const indent = { type: 'Indent' };
+
+/** @type {import('./types').Dedent} */
+const dedent = { type: 'Dedent' };
+
+/**
+ * @param {import('./types').Command[]} children
+ * @returns {import('./types').Sequence}
+ */
+function create_sequence(...children) {
+	return { type: 'Sequence', children };
+}
+
+/**
+ * Rough estimate of the combined width of a group of commands
+ * @param {import('./types').Command[]} commands
+ * @param {number} from
+ * @param {number} to
+ */
+function measure(commands, from, to = commands.length) {
+	let total = 0;
+	for (let i = from; i < to; i += 1) {
+		const command = commands[i];
+		if (typeof command === 'string') {
+			total += command.length;
+		} else if (command.type === 'Chunk') {
+			total += command.content.length;
+		} else if (command.type === 'Sequence') {
+			// assume this is ', '
+			total += 2;
+		}
+	}
+
+	return total;
+}
+
+/**
+ * @param {import('estree').Node} node
+ * @param {import('./types').State} state
+ */
+export function handle(node, state) {
+	const handler = handlers[node.type];
+
+	if (!handler) {
+		throw new Error(`Not implemented ${node.type}`);
+	}
+
+	if (node.leadingComments) {
+		prepend_comments(node.leadingComments, state, false);
+	}
+
+	// @ts-expect-error
+	handler(node, state);
+
+	if (node.trailingComments) {
+		state.comments.push(node.trailingComments[0]); // there is only ever one
+	}
+}
+
+/**
+ * @param {string} content
+ * @param {import('estree').Node} node
+ * @returns {import('./types').Chunk}
+ */
+function c(content, node) {
+	return {
+		type: 'Chunk',
+		content,
+		loc: node?.loc ?? null
+	};
+}
+
+/**
+ * @param {import('estree').Comment[]} comments
+ * @param {import('./types').State} state
+ * @param {boolean} newlines
+ */
+function prepend_comments(comments, state, newlines) {
+	for (const comment of comments) {
+		state.commands.push({ type: 'Comment', comment });
+
+		if (newlines || comment.type === 'Line' || /\n/.test(comment.value)) {
+			state.commands.push(newline);
+		} else {
+			state.commands.push(' ');
+		}
+	}
+}
+
+const OPERATOR_PRECEDENCE = {
+	'||': 2,
+	'&&': 3,
+	'??': 4,
+	'|': 5,
+	'^': 6,
+	'&': 7,
+	'==': 8,
+	'!=': 8,
+	'===': 8,
+	'!==': 8,
+	'<': 9,
+	'>': 9,
+	'<=': 9,
+	'>=': 9,
+	in: 9,
+	instanceof: 9,
+	'<<': 10,
+	'>>': 10,
+	'>>>': 10,
+	'+': 11,
+	'-': 11,
+	'*': 12,
+	'%': 12,
+	'/': 12,
+	'**': 13
+};
+
+/** @type {Record<import('estree').Expression['type'] | 'Super' | 'RestElement', number>} */
+const EXPRESSIONS_PRECEDENCE = {
+	ArrayExpression: 20,
+	TaggedTemplateExpression: 20,
+	ThisExpression: 20,
+	Identifier: 20,
+	Literal: 18,
+	TemplateLiteral: 20,
+	Super: 20,
+	SequenceExpression: 20,
+	MemberExpression: 19,
+	MetaProperty: 19,
+	CallExpression: 19,
+	ChainExpression: 19,
+	ImportExpression: 19,
+	NewExpression: 19,
+	AwaitExpression: 17,
+	ClassExpression: 17,
+	FunctionExpression: 17,
+	ObjectExpression: 17,
+	UpdateExpression: 16,
+	UnaryExpression: 15,
+	BinaryExpression: 14,
+	LogicalExpression: 13,
+	ConditionalExpression: 4,
+	ArrowFunctionExpression: 3,
+	AssignmentExpression: 3,
+	YieldExpression: 2,
+	RestElement: 1
+};
+
+/**
+ *
+ * @param {import('estree').Expression} node
+ * @param {import('estree').BinaryExpression | import('estree').LogicalExpression} parent
+ * @param {boolean} is_right
+ * @returns
+ */
+function needs_parens(node, parent, is_right) {
+	// special case where logical expressions and coalesce expressions cannot be mixed,
+	// either of them need to be wrapped with parentheses
+	if (
+		node.type === 'LogicalExpression' &&
+		parent.type === 'LogicalExpression' &&
+		((parent.operator === '??' && node.operator !== '??') ||
+			(parent.operator !== '??' && node.operator === '??'))
+	) {
+		return true;
+	}
+
+	const precedence = EXPRESSIONS_PRECEDENCE[node.type];
+	const parent_precedence = EXPRESSIONS_PRECEDENCE[parent.type];
+
+	if (precedence !== parent_precedence) {
+		// Different node types
+		return (
+			(!is_right && precedence === 15 && parent_precedence === 14 && parent.operator === '**') ||
+			precedence < parent_precedence
+		);
+	}
+
+	if (precedence !== 13 && precedence !== 14) {
+		// Not a `LogicalExpression` or `BinaryExpression`
+		return false;
+	}
+
+	if (
+		/** @type {import('estree').BinaryExpression} */ (node).operator === '**' &&
+		parent.operator === '**'
+	) {
+		// Exponentiation operator has right-to-left associativity
+		return !is_right;
+	}
+
+	if (is_right) {
+		// Parenthesis are used if both operators have the same precedence
+		return (
+			OPERATOR_PRECEDENCE[/** @type {import('estree').BinaryExpression} */ (node).operator] <=
+			OPERATOR_PRECEDENCE[parent.operator]
+		);
+	}
+
+	return (
+		OPERATOR_PRECEDENCE[/** @type {import('estree').BinaryExpression} */ (node).operator] <
+		OPERATOR_PRECEDENCE[parent.operator]
+	);
+}
+
+/** @param {import('estree').Node} node */
+function has_call_expression(node) {
+	while (node) {
+		if (node.type === 'CallExpression') {
+			return true;
+		} else if (node.type === 'MemberExpression') {
+			node = node.object;
+		} else {
+			return false;
+		}
+	}
+}
+
+const grouped_expression_types = [
+	'ImportDeclaration',
+	'VariableDeclaration',
+	'ExportDefaultDeclaration',
+	'ExportNamedDeclaration'
+];
+
+/**
+ * @param {import('estree').Node[]} nodes
+ * @param {import('./types').State} state
+ */
+const handle_body = (nodes, state) => {
+	let last_statement = /** @type {import('estree').Node} */ ({ type: 'EmptyStatement' });
+	let first = true;
+	let needs_margin = false;
+
+	for (const statement of nodes) {
+		if (statement.type === 'EmptyStatement') continue;
+
+		const margin = create_sequence();
+
+		if (!first) state.commands.push(margin, newline);
+		first = false;
+
+		const leadingComments = statement.leadingComments;
+		delete statement.leadingComments;
+
+		if (leadingComments && leadingComments.length > 0) {
+			prepend_comments(leadingComments, state, true);
+		}
+
+		const child_state = { ...state, multiline: false };
+		handle(statement, child_state);
+
+		if (
+			child_state.multiline ||
+			needs_margin ||
+			((grouped_expression_types.includes(statement.type) ||
+				grouped_expression_types.includes(last_statement.type)) &&
+				last_statement.type !== statement.type)
+		) {
+			margin.children.push('\n');
+		}
+
+		let add_newline = false;
+
+		while (state.comments.length) {
+			const comment = /** @type {import('estree').Comment} */ (state.comments.shift());
+
+			state.commands.push(add_newline ? newline : ' ', { type: 'Comment', comment });
+			add_newline = comment.type === 'Line';
+		}
+
+		needs_margin = child_state.multiline;
+		last_statement = statement;
+	}
+};
+
+/**
+ * @param {import('estree').VariableDeclaration} node
+ * @param {import('./types').State} state
+ */
+const handle_var_declaration = (node, state) => {
+	const index = state.commands.length;
+
+	const open = create_sequence();
+	const join = create_sequence();
+	const child_state = { ...state, multiline: false };
+
+	state.commands.push(`${node.kind} `, open);
+
+	let first = true;
+
+	for (const d of node.declarations) {
+		if (!first) state.commands.push(join);
+		first = false;
+
+		handle(d, child_state);
+	}
+
+	const multiline =
+		child_state.multiline || (node.declarations.length > 1 && measure(state.commands, index) > 50);
+
+	if (multiline) {
+		state.multiline = true;
+		if (node.declarations.length > 1) open.children.push(indent);
+		join.children.push(',', newline);
+		if (node.declarations.length > 1) state.commands.push(dedent);
+	} else {
+		join.children.push(', ');
+	}
+};
+
+/**
+ * @template {import('estree').Node} T
+ * @param {Array<T | null>} nodes
+ * @param {import('./types').State} state
+ * @param {boolean} spaces
+ * @param {(node: T, state: import('./types').State) => void} fn
+ */
+function sequence(nodes, state, spaces, fn) {
+	if (nodes.length === 0) return;
+
+	const index = state.commands.length;
+
+	const open = create_sequence();
+	const join = create_sequence();
+	const close = create_sequence();
+
+	state.commands.push(open);
+
+	const child_state = { ...state, multiline: false };
+
+	let prev;
+
+	for (let i = 0; i < nodes.length; i += 1) {
+		const node = nodes[i];
+		const is_first = i === 0;
+		const is_last = i === nodes.length - 1;
+
+		if (node) {
+			if (!is_first && !prev) {
+				state.commands.push(join);
+			}
+
+			fn(node, child_state);
+
+			if (!is_last) {
+				state.commands.push(',');
+			}
+
+			if (state.comments.length > 0) {
+				state.commands.push(' ');
+
+				while (state.comments.length) {
+					const comment = /** @type {import('estree').Comment} */ (state.comments.shift());
+					state.commands.push({ type: 'Comment', comment });
+					if (!is_last) state.commands.push(join);
+				}
+
+				child_state.multiline = true;
+			} else {
+				if (!is_last) state.commands.push(join);
+			}
+		} else {
+			// This is only used for ArrayPattern and ArrayExpression, but
+			// it makes more sense to have the logic here than there, because
+			// otherwise we'd duplicate a lot more stuff
+			state.commands.push(',');
+		}
+
+		prev = node;
+	}
+
+	state.commands.push(close);
+
+	const multiline = child_state.multiline || measure(state.commands, index) > 50;
+
+	if (multiline) {
+		state.multiline = true;
+
+		open.children.push(indent, newline);
+		join.children.push(newline);
+		close.children.push(dedent, newline);
+	} else {
+		if (spaces) open.children.push(' ');
+		join.children.push(' ');
+		if (spaces) close.children.push(' ');
+	}
+}
+
+/** @satisfies {Record<string, (node: any, state: import('./types').State) => undefined>} */
+const shared = {
+	/**
+	 * @param {import('estree').ArrayExpression | import('estree').ArrayPattern} node
+	 * @param {import('./types').State} state
+	 */
+	'ArrayExpression|ArrayPattern': (node, state) => {
+		state.commands.push('[');
+		sequence(/** @type {import('estree').Node[]} */ (node.elements), state, false, handle);
+		state.commands.push(']');
+	},
+
+	/**
+	 * @param {import('estree').BinaryExpression | import('estree').LogicalExpression} node
+	 * @param {import('./types').State} state
+	 */
+	'BinaryExpression|LogicalExpression': (node, state) => {
+		// TODO
+		// const is_in = node.operator === 'in';
+		// if (is_in) {
+		// 	// Avoids confusion in `for` loops initializers
+		// 	chunks.push(c('('));
+		// }
+
+		if (needs_parens(node.left, node, false)) {
+			state.commands.push('(');
+			handle(node.left, state);
+			state.commands.push(')');
+		} else {
+			handle(node.left, state);
+		}
+
+		state.commands.push(` ${node.operator} `);
+
+		if (needs_parens(node.right, node, true)) {
+			state.commands.push('(');
+			handle(node.right, state);
+			state.commands.push(')');
+		} else {
+			handle(node.right, state);
+		}
+	},
+
+	/**
+	 * @param {import('estree').BlockStatement | import('estree').ClassBody} node
+	 * @param {import('./types').State} state
+	 */
+	'BlockStatement|ClassBody': (node, state) => {
+		if (node.body.length === 0) {
+			state.commands.push('{}');
+			return;
+		}
+
+		state.multiline = true;
+
+		state.commands.push('{', indent, newline);
+		handle_body(node.body, state);
+		state.commands.push(dedent, newline, '}');
+	},
+
+	/**
+	 * @param {import('estree').CallExpression | import('estree').NewExpression} node
+	 * @param {import('./types').State} state
+	 */
+	'CallExpression|NewExpression': (node, state) => {
+		const index = state.commands.length;
+
+		if (node.type === 'NewExpression') {
+			state.commands.push('new ');
+		}
+
+		const needs_parens =
+			EXPRESSIONS_PRECEDENCE[node.callee.type] < EXPRESSIONS_PRECEDENCE.CallExpression ||
+			(node.type === 'NewExpression' && has_call_expression(node.callee));
+
+		if (needs_parens) {
+			state.commands.push('(');
+			handle(node.callee, state);
+			state.commands.push(')');
+		} else {
+			handle(node.callee, state);
+		}
+
+		if (/** @type {import('estree').SimpleCallExpression} */ (node).optional) {
+			state.commands.push('?.');
+		}
+
+		const open = create_sequence();
+		const join = create_sequence();
+		const close = create_sequence();
+
+		state.commands.push('(', open);
+
+		// if the final argument is multiline, it doesn't need to force all the
+		// other arguments to also be multiline
+		const child_state = { ...state, multiline: false };
+		const final_state = { ...state, multiline: false };
+
+		for (let i = 0; i < node.arguments.length; i += 1) {
+			if (i > 0) {
+				if (state.comments.length > 0) {
+					state.commands.push(', ');
+
+					while (state.comments.length) {
+						const comment = /** @type {import('estree').Comment} */ (state.comments.shift());
+
+						state.commands.push({ type: 'Comment', comment });
+
+						if (comment.type === 'Line') {
+							child_state.multiline = true;
+							state.commands.push(newline);
+						} else {
+							state.commands.push(' ');
+						}
+					}
+				} else {
+					state.commands.push(join);
+				}
+			}
+
+			const p = node.arguments[i];
+
+			handle(p, i === node.arguments.length - 1 ? final_state : child_state);
+		}
+
+		state.commands.push(close, ')');
+
+		const multiline = child_state.multiline;
+
+		if (multiline || final_state.multiline) {
+			state.multiline = true;
+		}
+
+		if (multiline) {
+			open.children.push(indent, newline);
+			join.children.push(',', newline);
+			close.children.push(dedent, newline);
+		} else {
+			join.children.push(', ');
+		}
+	},
+
+	/**
+	 * @param {import('estree').ClassDeclaration | import('estree').ClassExpression} node
+	 * @param {import('./types').State} state
+	 */
+	'ClassDeclaration|ClassExpression': (node, state) => {
+		state.commands.push('class ');
+
+		if (node.id) {
+			handle(node.id, state);
+			state.commands.push(' ');
+		}
+
+		if (node.superClass) {
+			state.commands.push('extends ');
+			handle(node.superClass, state);
+			state.commands.push(' ');
+		}
+
+		handle(node.body, state);
+	},
+
+	/**
+	 * @param {import('estree').ForInStatement | import('estree').ForOfStatement} node
+	 * @param {import('./types').State} state
+	 */
+	'ForInStatement|ForOfStatement': (node, state) => {
+		state.commands.push('for ');
+		if (node.type === 'ForOfStatement' && node.await) state.commands.push('await ');
+		state.commands.push('(');
+
+		if (node.left.type === 'VariableDeclaration') {
+			handle_var_declaration(node.left, state);
+		} else {
+			handle(node.left, state);
+		}
+
+		state.commands.push(node.type === 'ForInStatement' ? ` in ` : ` of `);
+		handle(node.right, state);
+		state.commands.push(') ');
+		handle(node.body, state);
+	},
+
+	/**
+	 * @param {import('estree').FunctionDeclaration | import('estree').FunctionExpression} node
+	 * @param {import('./types').State} state
+	 */
+	'FunctionDeclaration|FunctionExpression': (node, state) => {
+		if (node.async) state.commands.push('async ');
+		state.commands.push(node.generator ? 'function* ' : 'function ');
+		if (node.id) handle(node.id, state);
+
+		state.commands.push('(');
+		sequence(node.params, state, false, handle);
+		state.commands.push(') ');
+
+		handle(node.body, state);
+	},
+
+	/**
+	 * @param {import('estree').RestElement | import('estree').SpreadElement} node
+	 * @param {import('./types').State} state
+	 */
+	'RestElement|SpreadElement': (node, state) => {
+		state.commands.push('...');
+		handle(node.argument, state);
+	}
+};
+
+/** @type {import('./types').Handlers} */
+const handlers = {
+	ArrayExpression: shared['ArrayExpression|ArrayPattern'],
+
+	ArrayPattern: shared['ArrayExpression|ArrayPattern'],
+
+	ArrowFunctionExpression: (node, state) => {
+		if (node.async) state.commands.push('async ');
+
+		state.commands.push('(');
+		sequence(node.params, state, false, handle);
+		state.commands.push(') => ');
+
+		if (
+			node.body.type === 'ObjectExpression' ||
+			(node.body.type === 'AssignmentExpression' && node.body.left.type === 'ObjectPattern') ||
+			(node.body.type === 'LogicalExpression' && node.body.left.type === 'ObjectExpression') ||
+			(node.body.type === 'ConditionalExpression' && node.body.test.type === 'ObjectExpression')
+		) {
+			state.commands.push('(');
+			handle(node.body, state);
+			state.commands.push(')');
+		} else {
+			handle(node.body, state);
+		}
+	},
+
+	AssignmentExpression(node, state) {
+		handle(node.left, state);
+		state.commands.push(` ${node.operator} `);
+		handle(node.right, state);
+	},
+
+	AssignmentPattern(node, state) {
+		handle(node.left, state);
+		state.commands.push(' = ');
+		handle(node.right, state);
+	},
+
+	AwaitExpression(node, state) {
+		if (node.argument) {
+			const precedence = EXPRESSIONS_PRECEDENCE[node.argument.type];
+
+			if (precedence && precedence < EXPRESSIONS_PRECEDENCE.AwaitExpression) {
+				state.commands.push('await (');
+				handle(node.argument, state);
+				state.commands.push(')');
+			} else {
+				state.commands.push('await ');
+				handle(node.argument, state);
+			}
+		} else {
+			state.commands.push('await');
+		}
+	},
+
+	BinaryExpression: shared['BinaryExpression|LogicalExpression'],
+
+	BlockStatement: shared['BlockStatement|ClassBody'],
+
+	BreakStatement(node, state) {
+		if (node.label) {
+			state.commands.push('break ');
+			handle(node.label, state);
+			state.commands.push(';');
+		} else {
+			state.commands.push('break;');
+		}
+	},
+
+	CallExpression: shared['CallExpression|NewExpression'],
+
+	ChainExpression(node, state) {
+		handle(node.expression, state);
+	},
+
+	ClassBody: shared['BlockStatement|ClassBody'],
+
+	ClassDeclaration: shared['ClassDeclaration|ClassExpression'],
+
+	ClassExpression: shared['ClassDeclaration|ClassExpression'],
+
+	ConditionalExpression(node, state) {
+		if (EXPRESSIONS_PRECEDENCE[node.test.type] > EXPRESSIONS_PRECEDENCE.ConditionalExpression) {
+			handle(node.test, state);
+		} else {
+			state.commands.push('(');
+			handle(node.test, state);
+			state.commands.push(')');
+		}
+
+		const if_true = create_sequence();
+		const if_false = create_sequence();
+
+		const child_state = { ...state, multiline: false };
+
+		state.commands.push(if_true);
+		handle(node.consequent, child_state);
+		state.commands.push(if_false);
+		handle(node.alternate, child_state);
+
+		const multiline = child_state.multiline;
+
+		if (multiline) {
+			if_true.children.push(indent, newline, '? ');
+			if_false.children.push(newline, ': ');
+			state.commands.push(dedent);
+		} else {
+			if_true.children.push(' ? ');
+			if_false.children.push(' : ');
+		}
+	},
+
+	ContinueStatement(node, state) {
+		if (node.label) {
+			state.commands.push('continue ');
+			handle(node.label, state);
+			state.commands.push(';');
+		} else {
+			state.commands.push('continue;');
+		}
+	},
+
+	DebuggerStatement(node, state) {
+		state.commands.push(c('debugger', node), ';');
+	},
+
+	DoWhileStatement(node, state) {
+		state.commands.push('do ');
+		handle(node.body, state);
+		state.commands.push(' while (');
+		handle(node.test, state);
+		state.commands.push(');');
+	},
+
+	EmptyStatement(node, state) {
+		state.commands.push(';');
+	},
+
+	ExportAllDeclaration(node, state) {
+		state.commands.push('export * from ');
+		handle(node.source, state);
+		state.commands.push(';');
+	},
+
+	ExportDefaultDeclaration(node, state) {
+		state.commands.push('export default ');
+
+		handle(node.declaration, state);
+
+		if (node.declaration.type !== 'FunctionDeclaration') {
+			state.commands.push(';');
+		}
+	},
+
+	ExportNamedDeclaration(node, state) {
+		state.commands.push('export ');
+
+		if (node.declaration) {
+			handle(node.declaration, state);
+			return;
+		}
+
+		state.commands.push('{');
+		sequence(node.specifiers, state, true, (s, state) => {
+			handle(s.local, state);
+
+			if (s.local.name !== s.exported.name) {
+				state.commands.push(' as ');
+				handle(s.exported, state);
+			}
+		});
+		state.commands.push('}');
+
+		if (node.source) {
+			state.commands.push(' from ');
+			handle(node.source, state);
+		}
+
+		state.commands.push(';');
+	},
+
+	ExpressionStatement(node, state) {
+		if (
+			node.expression.type === 'AssignmentExpression' &&
+			node.expression.left.type === 'ObjectPattern'
+		) {
+			// is an AssignmentExpression to an ObjectPattern
+			state.commands.push('(');
+			handle(node.expression, state);
+			state.commands.push(');');
+			return;
+		}
+
+		handle(node.expression, state);
+		state.commands.push(';');
+	},
+
+	ForStatement: (node, state) => {
+		state.commands.push('for (');
+
+		if (node.init) {
+			if (node.init.type === 'VariableDeclaration') {
+				handle_var_declaration(node.init, state);
+			} else {
+				handle(node.init, state);
+			}
+		}
+
+		state.commands.push('; ');
+		if (node.test) handle(node.test, state);
+		state.commands.push('; ');
+		if (node.update) handle(node.update, state);
+
+		state.commands.push(') ');
+		handle(node.body, state);
+	},
+
+	ForInStatement: shared['ForInStatement|ForOfStatement'],
+
+	ForOfStatement: shared['ForInStatement|ForOfStatement'],
+
+	FunctionDeclaration: shared['FunctionDeclaration|FunctionExpression'],
+
+	FunctionExpression: shared['FunctionDeclaration|FunctionExpression'],
+
+	Identifier(node, state) {
+		let name = node.name;
+		state.commands.push(c(name, node));
+	},
+
+	IfStatement(node, state) {
+		state.commands.push('if (');
+		handle(node.test, state);
+		state.commands.push(') ');
+		handle(node.consequent, state);
+
+		if (node.alternate) {
+			state.commands.push(' else ');
+			handle(node.alternate, state);
+		}
+	},
+
+	ImportDeclaration(node, state) {
+		if (node.specifiers.length === 0) {
+			state.commands.push('import ');
+			handle(node.source, state);
+			state.commands.push(';');
+			return;
+		}
+
+		/** @type {import('estree').ImportNamespaceSpecifier | null} */
+		let namespace_specifier = null;
+
+		/** @type {import('estree').ImportDefaultSpecifier | null} */
+		let default_specifier = null;
+
+		/** @type {import('estree').ImportSpecifier[]} */
+		const named_specifiers = [];
+
+		for (const s of node.specifiers) {
+			if (s.type === 'ImportNamespaceSpecifier') {
+				namespace_specifier = s;
+			} else if (s.type === 'ImportDefaultSpecifier') {
+				default_specifier = s;
+			} else {
+				named_specifiers.push(s);
+			}
+		}
+
+		state.commands.push('import ');
+
+		if (default_specifier) {
+			state.commands.push(c(default_specifier.local.name, default_specifier));
+			if (namespace_specifier || named_specifiers.length > 0) state.commands.push(', ');
+		}
+
+		if (namespace_specifier) {
+			state.commands.push(c('* as ' + namespace_specifier.local.name, namespace_specifier));
+		}
+
+		if (named_specifiers.length > 0) {
+			state.commands.push('{');
+			sequence(named_specifiers, state, true, (s, state) => {
+				if (s.local.name !== s.imported.name) {
+					handle(s.imported, state);
+					state.commands.push(' as ');
+				}
+
+				handle(s.local, state);
+			});
+			state.commands.push('}');
+		}
+
+		state.commands.push(' from ');
+		handle(node.source, state);
+		state.commands.push(';');
+	},
+
+	ImportExpression(node, state) {
+		state.commands.push('import(');
+		handle(node.source, state);
+		state.commands.push(')');
+	},
+
+	LabeledStatement(node, state) {
+		handle(node.label, state);
+		state.commands.push(': ');
+		handle(node.body, state);
+	},
+
+	Literal(node, state) {
+		// TODO do we need to handle weird unicode characters somehow?
+		// str.replace(/\\u(\d{4})/g, (m, n) => String.fromCharCode(+n))
+		const value =
+			node.raw ??
+			(typeof node.value === 'string' ? JSON.stringify(node.value) : String(node.value));
+
+		state.commands.push(c(value, node));
+	},
+
+	LogicalExpression: shared['BinaryExpression|LogicalExpression'],
+
+	MemberExpression(node, state) {
+		if (EXPRESSIONS_PRECEDENCE[node.object.type] < EXPRESSIONS_PRECEDENCE.MemberExpression) {
+			state.commands.push('(');
+			handle(node.object, state);
+			state.commands.push(')');
+		} else {
+			handle(node.object, state);
+		}
+
+		if (node.computed) {
+			if (node.optional) {
+				state.commands.push('?.');
+			}
+			state.commands.push('[');
+			handle(node.property, state);
+			state.commands.push(']');
+		} else {
+			state.commands.push(node.optional ? '?.' : '.');
+			handle(node.property, state);
+		}
+	},
+
+	MetaProperty(node, state) {
+		handle(node.meta, state);
+		state.commands.push('.');
+		handle(node.property, state);
+	},
+
+	MethodDefinition(node, state) {
+		if (node.static) {
+			state.commands.push('static ');
+		}
+
+		if (node.kind === 'get' || node.kind === 'set') {
+			// Getter or setter
+			state.commands.push(node.kind + ' ');
+		}
+
+		if (node.value.async) {
+			state.commands.push('async ');
+		}
+
+		if (node.value.generator) {
+			state.commands.push('*');
+		}
+
+		if (node.computed) state.commands.push('[');
+		handle(node.key, state);
+		if (node.computed) state.commands.push(']');
+
+		state.commands.push('(');
+		sequence(node.value.params, state, false, handle);
+		state.commands.push(') ');
+
+		handle(node.value.body, state);
+	},
+
+	NewExpression: shared['CallExpression|NewExpression'],
+
+	ObjectExpression(node, state) {
+		state.commands.push('{');
+		sequence(node.properties, state, true, (p, state) => {
+			if (p.type === 'Property' && p.value.type === 'FunctionExpression') {
+				const fn = /** @type {import('estree').FunctionExpression} */ (p.value);
+
+				if (p.kind === 'get' || p.kind === 'set') {
+					state.commands.push(p.kind + ' ');
+				} else {
+					if (fn.async) state.commands.push('async ');
+					if (fn.generator) state.commands.push('*');
+				}
+
+				if (p.computed) state.commands.push('[');
+				handle(p.key, state);
+				if (p.computed) state.commands.push(']');
+
+				state.commands.push('(');
+				sequence(fn.params, state, false, handle);
+				state.commands.push(') ');
+
+				handle(fn.body, state);
+			} else {
+				handle(p, state);
+			}
+		});
+		state.commands.push('}');
+	},
+
+	ObjectPattern(node, state) {
+		state.commands.push('{');
+		sequence(node.properties, state, true, handle);
+		state.commands.push('}');
+	},
+
+	// @ts-expect-error this isn't a real node type, but Acorn produces it
+	ParenthesizedExpression(node, state) {
+		return handle(node.expression, state);
+	},
+
+	PrivateIdentifier(node, state) {
+		state.commands.push('#', c(node.name, node));
+	},
+
+	Program(node, state) {
+		handle_body(node.body, state);
+	},
+
+	Property(node, state) {
+		const value = node.value.type === 'AssignmentPattern' ? node.value.left : node.value;
+
+		const shorthand =
+			!node.computed &&
+			node.kind === 'init' &&
+			node.key.type === 'Identifier' &&
+			value.type === 'Identifier' &&
+			node.key.name === value.name;
+
+		if (shorthand) {
+			handle(node.value, state);
+			return;
+		}
+
+		if (node.computed) state.commands.push('[');
+		handle(node.key, state);
+		state.commands.push(node.computed ? ']: ' : ': ');
+		handle(node.value, state);
+	},
+
+	PropertyDefinition(node, state) {
+		if (node.static) {
+			state.commands.push('static ');
+		}
+
+		if (node.computed) {
+			state.commands.push('[');
+			handle(node.key, state);
+			state.commands.push(']');
+		} else {
+			handle(node.key, state);
+		}
+
+		if (node.value) {
+			state.commands.push(' = ');
+
+			handle(node.value, state);
+		}
+
+		state.commands.push(';');
+	},
+
+	RestElement: shared['RestElement|SpreadElement'],
+
+	ReturnStatement(node, state) {
+		if (node.argument) {
+			const contains_comment =
+				node.argument.leadingComments &&
+				node.argument.leadingComments.some((comment) => comment.type === 'Line');
+
+			state.commands.push(contains_comment ? 'return (' : 'return ');
+			handle(node.argument, state);
+			state.commands.push(contains_comment ? ');' : ';');
+		} else {
+			state.commands.push('return;');
+		}
+	},
+
+	SequenceExpression(node, state) {
+		state.commands.push('(');
+		sequence(node.expressions, state, false, handle);
+		state.commands.push(')');
+	},
+
+	SpreadElement: shared['RestElement|SpreadElement'],
+
+	StaticBlock(node, state) {
+		state.commands.push(indent, 'static {', newline);
+
+		handle_body(node.body, state);
+
+		state.commands.push(dedent, newline, '}');
+	},
+
+	Super(node, state) {
+		state.commands.push(c('super', node));
+	},
+
+	SwitchStatement(node, state) {
+		state.commands.push('switch (');
+		handle(node.discriminant, state);
+		state.commands.push(') {', indent);
+
+		let first = true;
+
+		for (const block of node.cases) {
+			if (!first) state.commands.push('\n');
+			first = false;
+
+			if (block.test) {
+				state.commands.push(newline, `case `);
+				handle(block.test, state);
+				state.commands.push(':');
+			} else {
+				state.commands.push(newline, `default:`);
+			}
+
+			state.commands.push(indent);
+
+			for (const statement of block.consequent) {
+				state.commands.push(newline);
+				handle(statement, state);
+			}
+
+			state.commands.push(dedent);
+		}
+
+		state.commands.push(dedent, newline, `}`);
+	},
+
+	TaggedTemplateExpression(node, state) {
+		handle(node.tag, state);
+		handle(node.quasi, state);
+	},
+
+	TemplateLiteral(node, state) {
+		state.commands.push('`');
+
+		const { quasis, expressions } = node;
+
+		for (let i = 0; i < expressions.length; i++) {
+			const raw = quasis[i].value.raw;
+
+			state.commands.push(raw, '${');
+			handle(expressions[i], state);
+			state.commands.push('}');
+
+			if (/\n/.test(raw)) state.multiline = true;
+		}
+
+		const raw = quasis[quasis.length - 1].value.raw;
+
+		state.commands.push(raw, '`');
+		if (/\n/.test(raw)) state.multiline = true;
+	},
+
+	ThisExpression(node, state) {
+		state.commands.push(c('this', node));
+	},
+
+	ThrowStatement(node, state) {
+		state.commands.push('throw ');
+		handle(node.argument, state);
+		state.commands.push(';');
+	},
+
+	TryStatement(node, state) {
+		state.commands.push('try ');
+		handle(node.block, state);
+
+		if (node.handler) {
+			if (node.handler.param) {
+				state.commands.push(' catch(');
+				handle(node.handler.param, state);
+				state.commands.push(') ');
+			} else {
+				state.commands.push(' catch ');
+			}
+
+			handle(node.handler.body, state);
+		}
+
+		if (node.finalizer) {
+			state.commands.push(' finally ');
+			handle(node.finalizer, state);
+		}
+	},
+
+	UnaryExpression(node, state) {
+		state.commands.push(node.operator);
+
+		if (node.operator.length > 1) {
+			state.commands.push(' ');
+		}
+
+		if (EXPRESSIONS_PRECEDENCE[node.argument.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression) {
+			state.commands.push('(');
+			handle(node.argument, state);
+			state.commands.push(')');
+		} else {
+			handle(node.argument, state);
+		}
+	},
+
+	UpdateExpression(node, state) {
+		if (node.prefix) {
+			state.commands.push(node.operator);
+			handle(node.argument, state);
+		} else {
+			handle(node.argument, state);
+			state.commands.push(node.operator);
+		}
+	},
+
+	VariableDeclaration(node, state) {
+		handle_var_declaration(node, state);
+		state.commands.push(';');
+	},
+
+	VariableDeclarator(node, state) {
+		handle(node.id, state);
+
+		if (node.init) {
+			state.commands.push(' = ');
+			handle(node.init, state);
+		}
+	},
+
+	WhileStatement(node, state) {
+		state.commands.push('while (');
+		handle(node.test, state);
+		state.commands.push(') ');
+		handle(node.body, state);
+	},
+
+	WithStatement(node, state) {
+		state.commands.push('with (');
+		handle(node.object, state);
+		state.commands.push(') ');
+		handle(node.body, state);
+	},
+
+	YieldExpression(node, state) {
+		if (node.argument) {
+			state.commands.push(node.delegate ? `yield* ` : `yield `);
+			handle(node.argument, state);
+		} else {
+			state.commands.push(node.delegate ? `yield*` : `yield`);
+		}
+	}
+};

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/src/index.js

@@ -0,0 +1,179 @@
+import { handle } from './handlers.js';
+import { encode } from '@jridgewell/sourcemap-codec';
+
+/** @type {(str: string) => string} str */
+let btoa = () => {
+	throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+};
+
+if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+	btoa = (str) => window.btoa(unescape(encodeURIComponent(str)));
+	// @ts-expect-error
+} else if (typeof Buffer === 'function') {
+	// @ts-expect-error
+	btoa = (str) => Buffer.from(str, 'utf-8').toString('base64');
+}
+
+/**
+ * @typedef {{
+ *   sourceMapSource?: string;
+ *   sourceMapContent?: string;
+ *   sourceMapEncodeMappings?: boolean; // default true
+ * }} PrintOptions
+ */
+
+/**
+ * @param {import('estree').Node} node
+ * @param {PrintOptions} opts
+ * @returns {{ code: string, map: any }} // TODO
+ */
+export function print(node, opts = {}) {
+	if (Array.isArray(node)) {
+		return print(
+			{
+				type: 'Program',
+				body: node,
+				sourceType: 'module'
+			},
+			opts
+		);
+	}
+
+	/** @type {import('./types').State} */
+	const state = {
+		commands: [],
+		comments: [],
+		multiline: false
+	};
+
+	handle(node, state);
+
+	/** @typedef {[number, number, number, number]} Segment */
+
+	let code = '';
+	let current_column = 0;
+
+	/** @type {Segment[][]} */
+	let mappings = [];
+
+	/** @type {Segment[]} */
+	let current_line = [];
+
+	/** @param {string} str */
+	function append(str) {
+		code += str;
+
+		for (let i = 0; i < str.length; i += 1) {
+			if (str[i] === '\n') {
+				mappings.push(current_line);
+				current_line = [];
+				current_column = 0;
+			} else {
+				current_column += 1;
+			}
+		}
+	}
+
+	let newline = '\n';
+
+	/** @param {import('./types').Command} command */
+	function run(command) {
+		if (typeof command === 'string') {
+			append(command);
+			return;
+		}
+
+		switch (command.type) {
+			case 'Chunk':
+				const loc = command.loc;
+
+				if (loc) {
+					current_line.push([
+						current_column,
+						0, // source index is always zero
+						loc.start.line - 1,
+						loc.start.column
+					]);
+				}
+
+				append(command.content);
+
+				if (loc) {
+					current_line.push([
+						current_column,
+						0, // source index is always zero
+						loc.end.line - 1,
+						loc.end.column
+					]);
+				}
+
+				break;
+
+			case 'Newline':
+				append(newline);
+				break;
+
+			case 'Indent':
+				newline += '\t';
+				break;
+
+			case 'Dedent':
+				newline = newline.slice(0, -1);
+				break;
+
+			case 'Sequence':
+				for (let i = 0; i < command.children.length; i += 1) {
+					run(command.children[i]);
+				}
+
+				break;
+
+			case 'Comment':
+				if (command.comment.type === 'Line') {
+					append(`//${command.comment.value}`);
+				} else {
+					append(`/*${command.comment.value.replace(/\n/g, newline)}*/`);
+				}
+
+				break;
+		}
+	}
+
+	for (let i = 0; i < state.commands.length; i += 1) {
+		run(state.commands[i]);
+	}
+
+	mappings.push(current_line);
+
+	const map = {
+		version: 3,
+		/** @type {string[]} */
+		names: [],
+		sources: [opts.sourceMapSource || null],
+		sourcesContent: [opts.sourceMapContent || null],
+		mappings:
+			opts.sourceMapEncodeMappings == undefined || opts.sourceMapEncodeMappings
+				? encode(mappings)
+				: mappings
+	};
+
+	Object.defineProperties(map, {
+		toString: {
+			enumerable: false,
+			value: function toString() {
+				return JSON.stringify(this);
+			}
+		},
+		toUrl: {
+			enumerable: false,
+			value: function toUrl() {
+				return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+			}
+		}
+	});
+
+	return {
+		code,
+		map
+	};
+}

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/src/types.d.ts

@@ -0,0 +1,53 @@
+import { Comment, Node } from 'estree';
+
+type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+type Handler<T> = (node: T, state: State) => undefined;
+
+export type Handlers = {
+	[K in Node['type']]: Handler<NodeOf<K, Node>>;
+};
+
+export interface State {
+	commands: Command[];
+	comments: Comment[];
+	multiline: boolean;
+}
+
+export interface Chunk {
+	type: 'Chunk';
+	content: string;
+	loc: null | {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+}
+
+export interface Newline {
+	type: 'Newline';
+}
+
+export interface Indent {
+	type: 'Indent';
+}
+
+export interface Dedent {
+	type: 'Dedent';
+}
+
+export interface IndentChange {
+	type: 'IndentChange';
+	offset: number;
+}
+
+export interface Sequence {
+	type: 'Sequence';
+	children: Command[];
+}
+
+export interface CommentChunk {
+	type: 'Comment';
+	comment: Comment;
+}
+
+export type Command = string | Chunk | Newline | Indent | Dedent | Sequence | CommentChunk;

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/types/index.d.ts

@@ -0,0 +1,16 @@
+declare module 'esrap' {
+	/**
+	 * @returns // TODO
+	 */
+	export function print(node: import('estree').Node, opts?: PrintOptions): {
+		code: string;
+		map: any;
+	};
+	export type PrintOptions = {
+		sourceMapSource?: string;
+		sourceMapContent?: string;
+		sourceMapEncodeMappings?: boolean;
+	};
+}
+
+//# sourceMappingURL=index.d.ts.map

tools/ui/node_modules/svelte-ast-print/node_modules/esrap/types/index.d.ts.map

@@ -0,0 +1,14 @@
+{
+	"version": 3,
+	"file": "index.d.ts",
+	"names": [
+		"print"
+	],
+	"sources": [
+		"../src/index.js"
+	],
+	"sourcesContent": [
+		null
+	],
+	"mappings": ";;;;iBA6BgBA,KAAKA"
+}

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 [these people](https://github.com/Rich-Harris/zimmerframe/graphs/contributors)
+
+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.

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/README.md

@@ -0,0 +1,180 @@
+# zimmerframe
+
+A tool for walking.
+
+Specifically, it's a tool for walking an abstract syntax tree (AST), where every node is an object with a `type: string`. This includes [ESTree](https://github.com/estree/estree) nodes, such as you might generate with [Acorn](https://github.com/acornjs/acorn) or [Meriyah](https://github.com/meriyah/meriyah), but also includes things like [CSSTree](https://github.com/csstree/csstree) or an arbitrary AST of your own devising.
+
+## Usage
+
+```ts
+import { walk } from 'zimmerframe';
+import { parse } from 'acorn';
+import { Node } from 'estree';
+
+const program = parse(`
+let message = 'hello';
+console.log(message);
+
+if (true) {
+  let answer = 42;
+  console.log(answer);
+}
+`);
+
+// You can pass in arbitrary state
+const state = {
+  declarations: [],
+  depth: 0
+};
+
+const transformed = walk(program as Node, state, {
+  _(node, { state, next }) {
+    // the `_` visitor is 'universal' — if provided,
+    // it will run for every node, before deferring
+    // to specialised visitors. you can pass a new
+    // `state` object to `next`
+    next({ ...state, answer: 42 });
+  },
+  VariableDeclarator(node, { state }) {
+    // `state` is passed into each visitor
+    if (node.id.type === 'Identifier') {
+      state.declarations.push({
+        depth: state.depth,
+        name: node.id.name
+      });
+    }
+  },
+  BlockStatement(node, { state, next, stop }) {
+    // you must call `next()` or `next(childState)`
+    // to visit child nodes
+    console.log('entering BlockStatement');
+    next({ ...state, depth: state.depth + 1 });
+    console.log('leaving BlockStatement');
+  },
+  Literal(node) {
+    // if you return something, it will replace
+    // the current node
+    if (node.value === 'hello') {
+      return {
+        ...node,
+        value: 'goodbye'
+      };
+    }
+  },
+  IfStatement(node, { visit }) {
+    // normally, returning a value will halt
+    // traversal into child nodes. you can
+    // transform children with the current
+    // visitors using `visit(node, state?)`
+    if (node.test.type === 'Literal' && node.test.value === true) {
+      return visit(node.consequent);
+    }
+  }
+});
+```
+
+The `transformed` AST would look like this:
+
+```js
+let message = 'goodbye';
+console.log(message);
+
+{
+  let answer = 42;
+  console.log(answer);
+}
+```
+
+## Types
+
+The type of `node` in each visitor is inferred from the visitor's name. For example:
+
+```ts
+walk(ast as estree.Node, state, {
+  ArrowFunctionExpression(node) {
+    // `node` is of type estree.ArrowFunctionExpression
+  }
+});
+```
+
+For this to work, the first argument should be casted to an union of all the types you plan to visit.
+
+You can import types from 'zimmerframe':
+
+```ts
+import {
+  walk,
+  type Visitor,
+  type Visitors,
+  type Context
+} from 'zimmerframe';
+import type { Node } from 'estree';
+
+interface State {...}
+
+const node: Node = {...};
+const state: State = {...};
+const visitors: Visitors<Node, State> =  {...}
+
+walk(node, state, visitors);
+```
+
+## Context
+
+Each visitor receives a second argument, `context`, which is an object with the following properties and methods:
+
+- `next(state?: State): void` — a function that allows you to control when child nodes are visited, and which state they are visited with. If child visitors transform their inputs, this will return the transformed node (if not, returns `undefined`)
+- `path: Node[]` — an array of parent nodes. For example, to get the root node you would do `path.at(0)`; to get the current node's immediate parent you would do `path.at(-1)`
+- `state: State` — an object of the same type as the second argument to `walk`. Visitors can pass new state objects to their children with `next(childState)` or `visit(node, childState)`
+- `stop(): void` — prevents any subsequent traversal
+- `visit(node: Node, state?: State): Node` — returns the result of visiting `node` with the current set of visitors. If no `state` is provided, children will inherit the current state
+
+## Immutability
+
+ASTs are regarded as immutable. If you return a transformed node from a visitor, then all parents of the node will be replaced with clones, but unchanged subtrees will reuse the existing nodes.
+
+For example in this case, no transformation takes place, meaning that the returned value is identical to the original AST:
+
+```js
+const transformed = walk(original, state, {
+  Literal(node) {
+    console.log(node.value);
+  }
+});
+
+transformed === original; // true
+```
+
+In this case, however, we replace one of the nodes:
+
+```js
+const original = {
+  type: 'BinaryExpression',
+  operator: '+',
+  left: {
+    type: 'Identifier',
+    name: 'foo'
+  },
+  left: {
+    type: 'Identifier',
+    name: 'bar'
+  }
+};
+
+const transformed = walk(original, state, {
+  Identifier(node) {
+    if (node.name === 'bar') {
+      return { ...node, name: 'baz' };
+    }
+  }
+});
+
+transformed === original; // false, the BinaryExpression node is cloned
+transformed.left === original.left; // true, we can safely reuse this node
+```
+
+This makes it very easy to transform parts of your AST without incurring the performance and memory overhead of cloning the entire thing, and without the footgun of mutating it in place.
+
+## License
+
+MIT

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "zimmerframe",
+	"description": "A tool for walking ASTs",
+	"version": "1.1.2",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Rich-Harris/zimmerframe"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./types/index.d.ts",
+			"import": "./src/walk.js"
+		}
+	},
+	"types": "./types/index.d.ts",
+	"files": [
+		"src",
+		"types"
+	],
+	"devDependencies": {
+		"dts-buddy": "^0.1.13",
+		"typescript": "^5.1.6",
+		"vitest": "^0.34.2"
+	},
+	"scripts": {
+		"prepublishOnly": "dts-buddy -m zimmerframe:src/index.d.ts",
+		"check": "tsc",
+		"test": "vitest --run",
+		"test:watch": "vitest"
+	},
+	"license": "MIT",
+	"packageManager": "pnpm@8.6.12"
+}

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './walk.js';
+export * from './types.d.ts';

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/src/types.d.ts

@@ -0,0 +1,21 @@
+type BaseNode = { type: string };
+
+type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+type SpecialisedVisitors<T extends BaseNode, U> = {
+	[K in T['type']]?: Visitor<NodeOf<K, T>, U, T>;
+};
+
+export type Visitor<T, U, V> = (node: T, context: Context<V, U>) => V | void;
+
+export type Visitors<T extends BaseNode, U> = T['type'] extends '_'
+	? never
+	: SpecialisedVisitors<T, U> & { _?: Visitor<T, U, T> };
+
+export interface Context<T, U> {
+	next: (state?: U) => T | void;
+	path: T[];
+	state: U;
+	stop: () => void;
+	visit: (node: T, state?: U) => T;
+}

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/src/walk.js

@@ -0,0 +1,159 @@
+/**
+ * @template {{type: string}} T
+ * @template {Record<string, any> | null} U
+ * @param {T} node
+ * @param {U} state
+ * @param {import('./types').Visitors<T, U>} visitors
+ */
+export function walk(node, state, visitors) {
+	const universal = visitors._;
+
+	let stopped = false;
+
+	/** @type {import('./types').Visitor<T, U, T>} _ */
+	function default_visitor(_, { next, state }) {
+		next(state);
+	}
+
+	/**
+	 * @param {T} node
+	 * @param {T[]} path
+	 * @param {U} state
+	 * @returns {T | undefined}
+	 */
+	function visit(node, path, state) {
+		// Don't return the node here or it could lead to false-positive mutation detection
+		if (stopped) return;
+		if (!node.type) return;
+
+		/** @type {T | void} */
+		let result;
+
+		/** @type {Record<string, any>} */
+		const mutations = {};
+
+		/** @type {import('./types').Context<T, U>} */
+		const context = {
+			path,
+			state,
+			next: (next_state = state) => {
+				path.push(node);
+				for (const key in node) {
+					if (key === 'type') continue;
+
+					const child_node = node[key];
+					if (child_node && typeof child_node === 'object') {
+						if (Array.isArray(child_node)) {
+							/** @type {Record<number, T>} */
+							const array_mutations = {};
+
+							child_node.forEach((node, i) => {
+								if (node && typeof node === 'object') {
+									const result = visit(node, path, next_state);
+									if (result) array_mutations[i] = result;
+								}
+							});
+
+							if (Object.keys(array_mutations).length > 0) {
+								mutations[key] = child_node.map(
+									(node, i) => array_mutations[i] ?? node
+								);
+							}
+						} else {
+							const result = visit(
+								/** @type {T} */ (child_node),
+								path,
+								next_state
+							);
+
+							// @ts-ignore
+							if (result) {
+								mutations[key] = result;
+							}
+						}
+					}
+				}
+				path.pop();
+
+				if (Object.keys(mutations).length > 0) {
+					return apply_mutations(node, mutations);
+				}
+			},
+			stop: () => {
+				stopped = true;
+			},
+			visit: (next_node, next_state = state) => {
+				path.push(node);
+				const result = visit(next_node, path, next_state) ?? next_node;
+				path.pop();
+				return result;
+			}
+		};
+
+		let visitor = /** @type {import('./types').Visitor<T, U, T>} */ (
+			visitors[/** @type {T['type']} */ (node.type)] ?? default_visitor
+		);
+
+		if (universal) {
+			/** @type {T | void} */
+			let inner_result;
+
+			result = universal(node, {
+				...context,
+				/** @param {U} next_state */
+				next: (next_state = state) => {
+					state = next_state; // make it the default for subsequent specialised visitors
+
+					inner_result = visitor(node, {
+						...context,
+						state: next_state
+					});
+
+					return inner_result;
+				}
+			});
+
+			// @ts-expect-error TypeScript doesn't understand that `context.next(...)` is called immediately
+			if (!result && inner_result) {
+				result = inner_result;
+			}
+		} else {
+			result = visitor(node, context);
+		}
+
+		if (!result) {
+			if (Object.keys(mutations).length > 0) {
+				result = apply_mutations(node, mutations);
+			}
+		}
+
+		if (result) {
+			return result;
+		}
+	}
+
+	return visit(node, [], state) ?? node;
+}
+
+/**
+ * @template {Record<string, any>} T
+ * @param {T} node
+ * @param {Record<string, any>} mutations
+ * @returns {T}
+ */
+function apply_mutations(node, mutations) {
+	/** @type {Record<string, any>} */
+	const obj = {};
+
+	const descriptors = Object.getOwnPropertyDescriptors(node);
+
+	for (const key in descriptors) {
+		Object.defineProperty(obj, key, descriptors[key]);
+	}
+
+	for (const key in mutations) {
+		obj[key] = mutations[key];
+	}
+
+	return /** @type {T} */ (obj);
+}

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/types/index.d.ts

@@ -0,0 +1,28 @@
+declare module 'zimmerframe' {
+	export function walk<T extends {
+		type: string;
+	}, U extends Record<string, any> | null>(node: T, state: U, visitors: Visitors<T, U>): T;
+	type BaseNode = { type: string };
+
+	type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+	type SpecialisedVisitors<T extends BaseNode, U> = {
+		[K in T['type']]?: Visitor<NodeOf<K, T>, U, T>;
+	};
+
+	export type Visitor<T, U, V> = (node: T, context: Context<V, U>) => V | void;
+
+	export type Visitors<T extends BaseNode, U> = T['type'] extends '_'
+		? never
+		: SpecialisedVisitors<T, U> & { _?: Visitor<T, U, T> };
+
+	export interface Context<T, U> {
+		next: (state?: U) => T | void;
+		path: T[];
+		state: U;
+		stop: () => void;
+		visit: (node: T, state?: U) => T;
+	}
+}
+
+//# sourceMappingURL=index.d.ts.map

tools/ui/node_modules/svelte-ast-print/node_modules/zimmerframe/types/index.d.ts.map

@@ -0,0 +1,19 @@
+{
+	"version": 3,
+	"file": "index.d.ts",
+	"names": [
+		"walk",
+		"Visitor",
+		"Visitors",
+		"Context"
+	],
+	"sources": [
+		"../src/walk.js",
+		"../src/types.d.ts"
+	],
+	"sourcesContent": [
+		null,
+		null
+	],
+	"mappings": ";iBAOgBA,IAAIA;;;;;;;;;;;aCCRC,OAAOA;;aAEPC,QAAQA;;;;kBAIHC,OAAOA"
+}

tools/ui/node_modules/svelte-ast-print/package.json

@@ -0,0 +1,130 @@
+{
+	"$schema": "https://json.schemastore.org/package",
+	"name": "svelte-ast-print",
+	"version": "0.4.2",
+	"type": "module",
+	"description": "Print Svelte AST nodes as a string. Aka parse in reverse.",
+	"keywords": [
+		"svelte",
+		"ast",
+		"print"
+	],
+	"license": "MIT",
+	"author": {
+		"name": "Mateusz Kadlubowski",
+		"email": "xeho91@pm.me",
+		"url": "https://github.com/xeho91"
+	},
+	"homepage": "https://github.com/xeho91/svelte-ast-print",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xeho91/svelte-ast-print.git"
+	},
+	"bugs": "https://github.com/xeho91/svelte-ast-print/issues",
+	"funding": [
+		{
+			"type": "github",
+			"url": "https://github.com/sponsors/xeho91"
+		},
+		{
+			"type": "opencollective",
+			"url": "https://opencollective.com/xeho91"
+		}
+	],
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"files": [
+		"src/",
+		"types/"
+	],
+	"imports": {
+		"#tests/*": {
+			"types": "./tests/*.ts",
+			"development": "./tests/*.ts"
+		},
+		"#*": {
+			"types": "./src/*.js",
+			"development": "./src/*.js",
+			"default": "./src/*.js"
+		}
+	},
+	"exports": {
+		".": {
+			"types": "./types/mod.d.ts",
+			"default": "./src/mod.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"types": "./types/mod.d.ts",
+	"packageManager": "pnpm@9.9.0+sha512.60c18acd138bff695d339be6ad13f7e936eea6745660d4cc4a776d5247c540d0edee1a563695c183a66eb917ef88f2b4feb1fc25f32a7adcadc7aaf3438e99c1",
+	"scripts": {
+		"build": "pnpm run \"/^build:.*/\" ",
+		"build:doc": "typedoc",
+		"build:types": "dts-buddy",
+		"clean": "pnpm run \"/^clean:.*/\"; rm -rf \"./**/node_modules\" ",
+		"clean:cache": "rm -rf \"./node_modules/.cache\" ",
+		"clean:doc": "rm -rf \"./docs\" ",
+		"clean:test": "rm -rf \"./coverage\" ",
+		"clean:types": "rm -rf \"./types\" ",
+		"dev": "pnpm run \"/^dev:.*/\" ",
+		"dev:doc": "typedoc --watch",
+		"dev:test": "pnpm vitest watch --passWithNoTests --ui",
+		"fix": "pnpm run \"/^fix:.*/\" ",
+		"fix:biome": "biome check . --verbose --write",
+		"fix:format": "biome format . --verbose --write",
+		"fix:js": "biome lint . --verbose --fix --unsafe",
+		"fix:md": "markdownlint-cli2 \"**/*.md\" \"#**/node_modules\" \"#./CHANGELOG.md\" --fix",
+		"fix:typos": "typos --verbose --write-changes",
+		"lint": "pnpm run \"/^lint:.*/\" ",
+		"lint:biome": "biome check . --verbose",
+		"lint:format": "biome format . --verbose",
+		"lint:js": "biome lint . --verbose",
+		"lint:md": "markdownlint-cli2 \"**/*.md\" \"#**/node_modules\" \"#./CHANGELOG.md\" ",
+		"lint:ts": "tsc --noEmit",
+		"lint:typos": "typos --verbose",
+		"prepare": "pnpm build:types",
+		"prepublishOnly": "pnpm test && pnpm build:types",
+		"release": "pnpm build:types && pnpm auto shipit",
+		"serve:doc": "serve \"./docs\" ",
+		"test": "vitest run . --passWithNoTests"
+	},
+	"dependencies": {
+		"esrap": "1.2.2",
+		"zimmerframe": "1.1.2"
+	},
+	"devDependencies": {
+		"@auto-it/all-contributors": "11.3.0",
+		"@auto-it/conventional-commits": "11.3.0",
+		"@auto-it/first-time-contributor": "11.3.0",
+		"@auto-it/npm": "11.3.0",
+		"@auto-it/released": "11.3.0",
+		"@biomejs/biome": "1.9.4",
+		"@total-typescript/ts-reset": "0.6.1",
+		"@total-typescript/tsconfig": "1.0.4",
+		"@types/estree": "1.0.6",
+		"@types/node": "22.8.4",
+		"@vitest/coverage-v8": "2.1.4",
+		"@vitest/ui": "2.1.4",
+		"all-contributors-cli": "6.26.1",
+		"auto": "11.3.0",
+		"dedent": "1.5.3",
+		"dts-buddy": "0.5.3",
+		"markdownlint-cli2": "0.14.0",
+		"serve": "14.2.4",
+		"svelte": "5.1.4",
+		"type-fest": "4.26.1",
+		"typedoc": "0.26.10",
+		"typedoc-plugin-coverage": "3.3.0",
+		"typedoc-plugin-mdn-links": "3.3.5",
+		"typescript": "5.6.3",
+		"vitest": "2.1.4"
+	},
+	"peerDependencies": {
+		"svelte": "^5.0.0"
+	}
+}

tools/ui/node_modules/svelte-ast-print/src/mod.js

@@ -0,0 +1,1587 @@
+/**
+ * @import * as EstreeAST from "estree";
+ * @import { AST as SvelteAST } from "svelte/compiler";
+ * @import { Context } from "zimmerframe";
+ *
+ * @import { Node, SvelteNode } from "./nodes.js";
+ */
+
+import { print as print_es } from "esrap";
+import { walk } from "zimmerframe";
+
+import { is_attribute_like_node, is_element_like_node, is_svelte_node } from "./nodes.js";
+import { Options } from "./options.js";
+
+export {
+	is_attribute_like_node as isAttributeLikeNode,
+	is_block_node as isBlockNode,
+	is_css_node as isCssNode,
+	is_element_like_node as isElementLikeNode,
+	is_html_node as isHtmlNode,
+	is_svelte_node as isSvelteNode,
+	is_tag_node as isTagNode,
+	is_template_node as isTemplateNode,
+} from "./nodes.js";
+
+/**
+ * Print AST {@link SvelteAST.BaseNode} as a string.
+ * Aka parse in reverse.
+ *
+ * ## How does it work under the hood?
+ *
+ * 1. Firstly, it determines whether the provided AST node is unique node for Svelte {@link SvelteAST.Node}.
+ * 2. Based on type check guard from above:
+ *    - it uses either this package's {@link Printer} to print Svelte AST node,
+ *    - otherwise it uses `esrap` {@link print_es} to print ESTree specification-complaint AST node
+ *
+ * ## How to use it?
+ *
+ * @example writing a codemode using Node.js
+   ```js
+   import fs from "node:fs";
+
+   import { print } from "svelte-ast-print";
+   import { parse } from "svelte/compiler";
+
+   const originalSvelteCode = fs.readFileSync("src/App.svelte", "utf-8");
+   let svelteAST = parse(originalSvelteCode, { modern: true });
+   //                                          👆 For now, only modern is supported.
+   //                                             By default is 'false'.
+   //                                             Is it planned to be 'true' from Svelte v6+
+
+   // ...
+   // Do some modifications on this AST...
+   // e.g. transform `<slot />` to `{@render children()}`
+   // ...
+
+   const output = print(svelteAST); // AST is now a stringified code output! 🎉
+
+   fs.writeFileSync("src/App.svelte", output, { encoding: " utf-8" });
+   ```
+ *
+ * @param {Node} node - Svelte or ESTree AST node
+ * @param {Partial<ConstructorParameters<typeof Options>[0]>} options - printing options
+ * @returns {string} Stringified Svelte AST node
+ * TODO: Ask Svelte maintainers if `Script` and `SvelteOptions` were omittted from `SvelteNode` intentionally - possibly forgotten to include
+ */
+export function print(node, options = {}) {
+	if (is_svelte_node(node)) {
+		return new Printer(node, new Options(options)).toString();
+	}
+
+	return print_es(node).code;
+}
+
+class Printer {
+	/**
+	 * @type {SvelteNode}
+	 */
+	#node;
+	/**
+	 * @type {Options}
+	 */
+	#options;
+
+	/**
+	 * @type {number}
+	 */
+	#depth = 0;
+	/**
+	 * @type {string}
+	 */
+	#output = "";
+	/**
+	 * @type {Set<string>}
+	 */
+	#attributes = new Set();
+	/**
+	 * @type {boolean}
+	 */
+	#has_template_literal = false;
+
+	/**
+	 * @param {Node} node - Svelte or ESTree AST node
+	 * @param {Options} options - transformed options
+	 */
+	constructor(node, options) {
+		this.#node = node;
+		this.#options = options;
+		this.#produce();
+	}
+
+	/**
+	 * @returns {string}
+	 */
+	toString() {
+		if (is_attribute_like_node(this.#node)) {
+			return this.#stringified_attributes;
+		}
+		return this.#output;
+	}
+
+	/**
+	 * @param {string} code
+	 * @returns {void}
+	 */
+	#print(code) {
+		this.#output += code;
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	#print_new_line() {
+		this.#output += "\n";
+	}
+
+	#print_opening_new_line() {
+		if (this.#is_last_output_script_closing_tag) {
+			this.#print_new_line();
+			this.#print_new_line();
+		} else if (
+			this.#is_last_output_closing_block ||
+			this.#is_last_output_closing_comment ||
+			this.#is_last_output_opening_element_like ||
+			this.#is_last_output_closing_element_like
+		) {
+			this.#print_new_line();
+		}
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	#print_space() {
+		this.#output += " ";
+	}
+
+	/**
+	 * Depth aware indent
+	 * @returns {string}
+	 */
+	get #indent() {
+		const { indent } = this.#options;
+		return Array(this.#depth).fill(indent).join("");
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	#print_indent() {
+		this.#output += this.#indent;
+	}
+
+	get #stringified_attributes() {
+		// TODO: Determine what join should be, space or new line, based on options.
+		if (this.#attributes.size > 0) {
+			return [...this.#attributes].join(" ");
+		}
+		return "";
+	}
+
+	/**
+	 * @typedef PrintEsNodeOptions
+	 * @property {boolean} [skip_indent]
+	 */
+
+	/**
+	 * @param {Parameters<typeof print_es>[0]} node
+	 * @param {Partial<PrintEsNodeOptions> | undefined} options
+	 * @returns {void}
+	 */
+	#print_es_node(node, options = {}) {
+		const { skip_indent = false } = options;
+		let { code } = print_es(node);
+		if (skip_indent) this.#output += code;
+		else {
+			code = code.replace(/^(?=.+)/gm, this.#indent);
+			this.#output += code.replace(
+				// NOTE: This temporary solution is supposed to remove auto-indentation from the content inside
+				// `TemplateLiteral`.
+				// Reference: https://github.com/storybookjs/addon-svelte-csf/issues/227
+				/`[^`].*[^`]*`/g,
+				(match) => {
+					return match.replace(new RegExp(this.#indent, "g"), "");
+				},
+			);
+		}
+	}
+
+	/**
+	 * By default we assume everything starts with an indent or new line
+	 * @type {boolean}
+	 */
+	#was_last_text_indent_or_space_only = true;
+
+	/**
+	 * @param {SvelteAST.Text} node
+	 * @returns {boolean}
+	 */
+	#is_text_new_line_or_indents_only(node) {
+		// TODO: Refactor, there's probably a smarter regex to achieve it
+		const { raw } = node;
+		if (raw === " ") return this.#was_last_text_indent_or_space_only;
+		if (this.#depth === 0) return /^(?: {1,}|\t|\n)*$/.test(raw);
+		return /^(?: {2,}|\t|\n)*$/.test(raw);
+	}
+
+	/**
+	 * @param {SvelteAST.Fragment} fragment
+	 * @returns {boolean}
+	 */
+	#has_fragment_element_like_node(fragment) {
+		const { nodes } = fragment;
+		for (const node of nodes) {
+			if (is_element_like_node(node)) return true;
+			if (node.type === "Text" && this.#is_text_new_line_or_indents_only(node)) continue;
+			break;
+		}
+		return false;
+	}
+
+	/**
+	 * @param {SvelteAST.Fragment} fragment
+	 * @returns {boolean}
+	 */
+	#is_fragment_empty(fragment) {
+		return fragment.nodes.length === 0;
+	}
+
+	/**
+	 * @param {"await" | "each" | "if" | "key" | "snippet"} name
+	 * @param {string} content
+	 * @returns {void}
+	 */
+	#print_block_opening_tag(name, content) {
+		this.#print_opening_new_line();
+		this.#print_indent();
+		this.#print("{");
+		this.#print("#");
+		this.#print(name);
+		this.#print_space();
+		this.#print(content);
+		this.#print("}");
+	}
+
+	/**
+	 * @param {"then" | "catch" | "else if" | "else"} name
+	 * @param {string} [content]
+	 * @returns {void}
+	 */
+	#print_block_middle_tag(name, content) {
+		this.#print_opening_new_line();
+		if (this.#is_last_output_new_line) this.#print_indent();
+		this.#print("{:");
+		this.#print(name);
+		if (content) {
+			this.#print_space();
+			this.#print(content);
+		}
+		this.#print("}");
+	}
+
+	/**
+	 * @param {"await" | "each" | "if" | "key" | "snippet"} name
+	 * @returns {void}
+	 */
+	#print_block_closing_tag(name) {
+		this.#print_new_line();
+		this.#print_indent();
+		this.#print("{/");
+		this.#print(name);
+		this.#print("}");
+	}
+
+	/**
+	 * @param {SvelteAST.Fragment} node
+	 * @param {Context<Node, typeof this>} context
+	 * @returns {void}
+	 */
+	#print_block_fragment(node, context) {
+		const { visit } = context;
+		this.#print_new_line();
+		this.#depth++;
+		visit(node, this);
+		if (this.#depth > 0) this.#depth--;
+	}
+
+	/**
+	 * @typedef PrintElementLikeOpeningTagOptions
+	 * @property {boolean}[self_close]
+	 */
+
+	/**
+	 * @param {string} name
+	 * @param {Partial<PrintElementLikeOpeningTagOptions>} [options]
+	 * @returns {void}
+	 */
+	#print_element_like_opening_tag(name, options = {}) {
+		const { self_close = false } = options;
+		this.#print_opening_new_line();
+		if (this.#is_last_output_new_line) this.#print_indent();
+		this.#print("<");
+		this.#print(name);
+		if (this.#attributes.size > 0) {
+			this.#print_space();
+			this.#print(this.#stringified_attributes);
+			this.#attributes.clear();
+		}
+		if (self_close) {
+			if (!this.#is_last_output_new_line) this.#print_space();
+			this.#print("/");
+		}
+		this.#print(">");
+	}
+
+	/**
+	 * @param {string} name
+	 * @returns {void}
+	 */
+	#print_element_like_closing_tag(name) {
+		if (this.#is_last_output_closing_element_like || this.#is_last_output_closing_block) this.#print_new_line();
+		if (this.#is_last_output_new_line) this.#print_indent();
+		this.#print("<");
+		this.#print("/");
+		this.#print(name);
+		this.#print(">");
+	}
+
+	/**
+	 * @param {SvelteAST.Fragment} node
+	 * @param {Context<Node, typeof this>} context
+	 * @returns {void}
+	 */
+	#print_element_like_fragment(node, context) {
+		const { visit } = context;
+		if (this.#has_fragment_element_like_node(node)) this.#print_new_line();
+		visit(node, this);
+	}
+
+	/**
+	 * @param {SvelteAST.ElementLike} node
+	 * @param {Context<Node, typeof this>} context
+	 * @returns {void}
+	 */
+	#print_element_like(node, context) {
+		const { attributes, fragment, name } = node;
+		const { state, visit } = context;
+		const is_self_closing = this.#is_fragment_empty(fragment);
+		for (const attribute_like of attributes) {
+			visit(attribute_like, state);
+		}
+		this.#print_element_like_opening_tag(name, { self_close: is_self_closing });
+		if (fragment && !is_self_closing) {
+			this.#depth++;
+			this.#print_element_like_fragment(fragment, context);
+			this.#depth--;
+			this.#print_element_like_closing_tag(name);
+		}
+	}
+
+	/**
+	 * @param {SvelteAST.ExpressionTag} node
+	 * @returns {string}
+	 */
+	#serialize_expression_tag(node) {
+		const { expression } = node;
+		return `{${print_es(expression).code}}`;
+	}
+
+	/**
+	 * @param {SvelteAST.Text | SvelteAST.ExpressionTag} node
+	 * @returns {string}
+	 */
+	#serialize_attribute_like_text_or_expression_tag(node) {
+		if (node.type === "Text") {
+			const { raw } = node;
+			return `"${raw}"`;
+		}
+		return this.#serialize_expression_tag(node);
+	}
+
+	/**
+	 * @typedef StringifyDirectiveParams
+	 * @property {"animate" | "bind" | "class" | "let" | "on" | "style" | "in" | "out" | "transition" | "use"} directive
+	 * @property {string} name
+	 * @property {EstreeAST.Expression | EstreeAST.MemberExpression | null} expression
+	 * @property {string[]} [modifiers]
+	 */
+
+	/**
+	 * @param {StringifyDirectiveParams["directive"]} directive
+	 * @param {StringifyDirectiveParams["name"]} name
+	 * @returns {string}
+	 */
+	#stringify_directive_name(directive, name) {
+		return `${directive}:${name}`;
+	}
+
+	/**
+	 * @param {NonNullable<StringifyDirectiveParams["modifiers"]>} modifiers
+	 * @returns {string}
+	 */
+	#stringify_directive_modifiers(modifiers) {
+		let results = "";
+		if (modifiers?.length > 0) {
+			results += "|";
+			results += modifiers.join("|");
+		}
+		return results;
+	}
+
+	/**
+	 * @param {StringifyDirectiveParams} params
+	 * @returns {string}
+	 */
+	#stringify_directive(params) {
+		const { directive, name, expression, modifiers } = params;
+		const is_shorthand = expression?.type === "Identifier" && expression.name === name;
+		let results = this.#stringify_directive_name(directive, name);
+		if (modifiers) results += this.#stringify_directive_modifiers(modifiers);
+		if (!is_shorthand && expression) {
+			results += "=";
+			results += "{";
+			results += print_es(expression).code;
+			results += "}";
+		}
+		return results;
+	}
+
+	/**
+	 * @param {true | SvelteAST.ExpressionTag | (SvelteAST.Text | SvelteAST.ExpressionTag)[]} node
+	 * @param {string} name
+	 * @returns {boolean}
+	 */
+	#is_attribute_shorthand_expression_tag(node, name) {
+		if (node === true) return false;
+		if (Array.isArray(node)) {
+			if (!node[0]) return false;
+			if (node[0].type === "Text") return node[0].raw === name;
+			const { expression } = node[0];
+			return expression.type === "Identifier" && expression.name === name;
+		}
+		const { expression } = node;
+		return expression.type === "Identifier" && expression.name === name;
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_closing_block() {
+		return /\{\/\w*\}$$/.test(this.#output);
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_opening_element_like() {
+		return /<(?!\/).*>$/s.test(this.#output);
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_closing_element_like() {
+		return /(<\/[^>:]+(:[^>]+)?>|\/>)$/.test(this.#output);
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_closing_comment() {
+		return /-->$/.test(this.#output);
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_new_line() {
+		return /\n$/.test(this.#output);
+	}
+
+	/**
+	 * @returns {boolean}
+	 */
+	get #is_last_output_script_closing_tag() {
+		return /<\/script>$/.test(this.#output);
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	#produce() {
+		walk(this.#node, this, {
+			_(_node, context) {
+				const { next, state } = context;
+				next(state);
+			},
+
+			Root(node, context) {
+				const { state, stop, visit } = context;
+				const { order } = state.#options;
+				for (const name of order) {
+					const root_node = node[name];
+					if (name === "options" && node.options) {
+						//  @ts-ignore FIXME: This is likely a bug - at runtime Svelte AST node `SvelteOptions` _(aliased as SvelteOptionsRaw)_ doesn't have 'type' & 'name' entry
+						visit({ ...node.options, type: "SvelteOptions", name: "svelte:options" }, state);
+						//  @ts-ignore FIXME: Typing issue `SvelteOptions` and `SvelteOptionsRaw` are incompatible
+					} else if (root_node) visit(root_node, state);
+				}
+				// NOTE: There can't be anything next to Root
+				stop();
+			},
+
+			Script(/** @type {SvelteAST.Script} */ node, context) {
+				const { attributes, content } = node;
+				const { state, visit } = context;
+				state.#print_opening_new_line();
+				for (const attribute of attributes) {
+					visit(attribute, state);
+				}
+				state.#print_element_like_opening_tag("script");
+				state.#print_new_line();
+				state.#depth++;
+				state.#print_es_node(content);
+				state.#depth--;
+				state.#print_new_line();
+				state.#print_element_like_closing_tag("script");
+			},
+
+			Fragment(node, context) {
+				const { nodes } = node;
+				const { state, visit } = context;
+				for (const node of nodes) {
+					visit(node, state);
+				}
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Comment}
+			 *
+			 * @example pattern
+			 * ```html
+			 * <!--data-->
+			 * ```
+			 */
+			Comment(node, context) {
+				const { data } = node;
+				const { state } = context;
+				if (state.#is_last_output_script_closing_tag) {
+					state.#print_new_line();
+					state.#print_new_line();
+				} else if (
+					state.#is_last_output_closing_block ||
+					state.#is_last_output_closing_comment ||
+					state.#is_last_output_closing_element_like
+				) {
+					state.#print_new_line();
+				}
+				if (state.#is_last_output_new_line) state.#print_indent();
+				state.#print("<!--");
+				state.#print(data);
+				state.#print("-->");
+			},
+
+			Text(node, context) {
+				const { raw } = node;
+				const { state } = context;
+				if (state.#is_text_new_line_or_indents_only(node)) {
+					state.#was_last_text_indent_or_space_only = true;
+				} else {
+					state.#was_last_text_indent_or_space_only = false;
+					state.#print(raw);
+				}
+			},
+
+			Attribute(node, context) {
+				const { name, value } = node;
+				const { state } = context;
+				const is_shorthand_expression_tag = state.#is_attribute_shorthand_expression_tag(value, name);
+				let stringified = "";
+				if (!is_shorthand_expression_tag) stringified += name;
+				if (value !== true && Array.isArray(value)) {
+					if (!is_shorthand_expression_tag) stringified += "=";
+					const is_single_expression_tag = value.length === 1 && value[0].type === "ExpressionTag";
+					if (!is_single_expression_tag) stringified += '"';
+					for (const text_or_expression_tag of value) {
+						if (text_or_expression_tag.type === "Text") stringified += text_or_expression_tag.raw;
+						else stringified += state.#serialize_expression_tag(text_or_expression_tag);
+					}
+					if (!is_single_expression_tag) stringified += '"';
+				}
+				// NOTE: This is e.g. `<button disabled />`,
+				// so its a shorthand - we don't need to append anything
+				if (value !== true && !Array.isArray(value) && value.type === "ExpressionTag") {
+					if (!is_shorthand_expression_tag) stringified += "=";
+					stringified += state.#serialize_expression_tag(value);
+				}
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/basic-markup#attributes-and-props}
+			 *
+			 * @example
+			 * ```svelte
+			 * <Widget {...things} />
+			 * ```
+			 */
+			SpreadAttribute(node, context) {
+				const { expression } = node;
+				const { state } = context;
+				let stringified = "{";
+				stringified += "...";
+				stringified += print_es(expression).code;
+				stringified += "}";
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#animate-fn}
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * animate:name={expression}
+			 * ```
+			 *
+			 * @example shorthand - when variable - expression as identifier - name is same
+			 * ```svelte
+			 * animate:name
+			 * ```
+			 */
+			AnimateDirective(node, context) {
+				const { name, expression } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "animate", name, expression });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#bind-property}
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * bind:name={variable}
+			 * ```
+			 *
+			 * @example shorthand - when variable - expression as identifier - name is same
+			 * ```svelte
+			 * bind:name
+			 * ```
+			 */
+			BindDirective(node, context) {
+				const { name, expression } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "bind", name, expression });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#class-name}
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * class:name={expression}
+			 * ```
+			 *
+			 * @example shorthand - when variable - expression as identifier - name is same
+			 * ```svelte
+			 * class:name
+			 * ```
+			 */
+			ClassDirective(node, context) {
+				const { name, expression } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "class", name, expression });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-elements#slot-slot-key-value}
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * let:name={expression}
+			 * ```
+			 *
+			 * @example shorthand - when variable - expression as identifier - name is same
+			 * ```svelte
+			 * let:name
+			 * ```
+			 */
+			LetDirective(node, context) {
+				const { name, expression } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "let", name, expression });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-elements#on-eventname}
+			 *
+			 * @example without modifiers
+			 * ```svelte
+			 * on:name={expression}
+			 * ```
+			 *
+			 * @example with modifiers
+			 * ```svelte
+			 * on:name|modifiers={handler}
+			 * ```
+			 */
+			OnDirective(node, context) {
+				const { name, expression, modifiers } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "on", name, expression, modifiers });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#style-property}
+			 *
+			 * @example with expression tag
+			 * ```svelte
+			 * style:name={value}
+			 * ```
+			 *
+			 * @example with text expression
+			 * ```svelte
+			 * style:name="text"
+			 * ```
+			 *
+			 * @example without expression
+			 * ```svelte
+			 * style:name
+			 * ```
+			 *
+			 * @example with modifiers
+			 * ```svelte
+			 * style:name|modifiers="text"
+			 */
+			StyleDirective(node, context) {
+				const { name, modifiers, value } = node;
+				const { state } = context;
+				let stringified = state.#stringify_directive_name("style", name);
+				stringified += state.#stringify_directive_modifiers(modifiers);
+				if (value.type === "ExpressionTag") {
+					stringified += "=";
+					stringified += state.#serialize_attribute_like_text_or_expression_tag(value);
+				}
+				if (Array.isArray(value) && (value[0].type === "ExpressionTag" || value[0]?.type === "Text")) {
+					stringified += "=";
+					stringified += state.#serialize_attribute_like_text_or_expression_tag(value[0]);
+				}
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#transition-fn}
+			 * @see {@link https://svelte.dev/docs/element-directives#in-fn-out-fn}
+			 *
+			 * @example without expression
+			 * ```svelte
+			 * transition|in|out:name
+			 * ```
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * transition|in|out:name={expression}
+			 * ```
+			 *
+			 * @example with global modifier and without expression
+			 * ```svelte
+			 * transition|in|out:name|global
+			 * ```
+			 *
+			 * @example with global modifier and with expression
+			 * ```svelte
+			 * transition|in|out:name|global={expression}
+			 * ```
+			 *
+			 * @example with local modifier and without expression
+			 * ```svelte
+			 * transition|in|out:name|local
+			 * ```
+			 *
+			 * @example with local modifier and with expression
+			 * ```svelte
+			 * transition|in|out:name|local={expression}
+			 * ```
+			 */
+			TransitionDirective(node, context) {
+				const { expression, intro, modifiers, name, outro } = node;
+				const { state } = context;
+				/** @type {"in" | "out" | "transition"} */
+				let directive;
+				if (intro && !outro) directive = "in";
+				else if (!intro && outro) directive = "out";
+				else directive = "transition";
+				const stringified = state.#stringify_directive({ directive, name, expression, modifiers });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/element-directives#use-action}
+			 *
+			 * @example with expression
+			 * ```svelte
+			 * use:name={expression}
+			 * ```
+			 *
+			 * @example shorthand - when variable - expression as identifier - name is same
+			 * ```svelte
+			 * use:name
+			 * ```
+			 */
+			UseDirective(node, context) {
+				const { expression, name } = node;
+				const { state } = context;
+				const stringified = state.#stringify_directive({ directive: "use", name, expression });
+				state.#attributes.add(stringified);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/logic-blocks#await}
+			 *
+			 * @example standard
+			 * ```svelte
+			 * {#await expression}...{:then name}...{:catch name}...{/await}
+			 * ```
+			 *
+			 * @example without catch
+			 * ```svelte
+			 * {#if expression}...{:else if expression}...{/if}
+			 * ```
+			 *
+			 * @example without pending body
+			 * ```svelte
+			 * {#await expression then name}...{/await}
+			 * ```
+			 *
+			 * @example with catch body only
+			 * ```svelte
+			 * {#await expression catch name}...{/await}
+			 * ```
+			 */
+			AwaitBlock(node, context) {
+				const name = "await";
+				const { catch: catch_, error, expression, pending, then, value } = node;
+				const { state } = context;
+				let await_block_content = print_es(expression).code;
+				if (then && !pending) {
+					await_block_content += " then";
+					if (value) {
+						await_block_content += " ";
+						await_block_content += print_es(value).code;
+					}
+				}
+				if (catch_ && !pending) {
+					await_block_content += " catch";
+					if (error) {
+						await_block_content += " ";
+						await_block_content += print_es(error).code;
+					}
+				}
+				state.#print_block_opening_tag(name, await_block_content);
+				if (pending) {
+					state.#print_block_fragment(pending, context);
+				}
+				if (then) {
+					if (pending) {
+						const then_block_content = value ? print_es(value).code : undefined;
+						state.#print_block_middle_tag("then", then_block_content);
+					}
+					state.#print_block_fragment(then, context);
+				}
+				if (catch_) {
+					if (pending) {
+						const catch_block_content = error ? print_es(error).code : undefined;
+						state.#print_block_middle_tag("catch", catch_block_content);
+					}
+					state.#print_block_fragment(catch_, context);
+				}
+				state.#print_block_closing_tag(name);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/logic-blocks#each}
+			 *
+			 * @example simple
+			 * ```svelte
+			 * {#each expression as name}...{/each}
+			 * ```
+			 *
+			 * @example with index
+			 * ```svelte
+			 * {#each expression as name, index}...{/each}
+			 * ```
+			 *
+			 * @example keyed
+			 * ```svelte
+			 * {#each expression as name (key)}...{/each}
+			 * ```
+			 *
+			 * @example with index and keyed
+			 * ```svelte
+			 * {#each expression as name, index (key)}...{/each}
+			 * ```
+			 *
+			 * @example with else clause for when list is empty
+			 * ```svelte
+			 * {#each expression as name}...{:else}...{/each}
+			 * ```
+			 */
+			EachBlock(node, context) {
+				const name = "each";
+				const { body, context: node_context, expression, fallback, index, key } = node;
+				const { state } = context;
+				let content = print_es(expression).code;
+				content += " as ";
+				content += print_es(node_context).code;
+				if (index) {
+					content += ",";
+					content += " ";
+					content += index;
+				}
+				if (key) {
+					content += " ";
+					content += "(";
+					content += print_es(key).code;
+					content += ")";
+				}
+				state.#print_block_opening_tag(name, content);
+				state.#print_block_fragment(body, context);
+				if (fallback) {
+					state.#print_block_middle_tag("else");
+					state.#print_block_fragment(fallback, context);
+				}
+				state.#print_block_closing_tag(name);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/logic-blocks#if}
+			 *
+			 * @example simple
+			 * ```svelte
+			 * {#if expression}...{/if}
+			 * ```
+			 *
+			 * @example with else if
+			 * ```svelte
+			 * {#if expression}...{:else if expression}...{/if}
+			 * ```
+			 *
+			 * @example with else
+			 * ```svelte
+			 * {#if expression}...{:else}...{/if}
+			 * ```
+			 *
+			 * @example with else if and else
+			 * ```svelte
+			 * {#if expression}...{:else if expression}...{:else}...{/if}
+			 * ```
+			 *
+			 * @example with multiple else if and else
+			 * ```svelte
+			 * {#if expression}...{:else if expression}...{:else if expression}...{:else}...{/if}
+			 * ```
+			 */
+			IfBlock(node, context) {
+				const name = "if";
+				const { alternate, consequent, elseif, test } = node;
+				const { state } = context;
+				/** @param {SvelteAST.Fragment} node */
+				const has_alternate_else_if = (node) => node.nodes.some((n) => n.type === "IfBlock");
+				if (elseif) {
+					state.#depth--;
+					state.#print_block_middle_tag("else if", print_es(test).code);
+					// FIXME: Temporary workaround - needs refactor when working on formatting features
+					if (consequent.nodes.length === 1 && consequent.nodes[0].type === "Text") {
+						consequent.nodes[0].raw = consequent.nodes[0].raw.replace(/\n/g, "");
+					}
+					state.#print_block_fragment(consequent, context);
+					if (alternate) {
+						if (!has_alternate_else_if(alternate)) {
+							// FIXME: Temporary workaround - needs refactor when working on formatting features
+							state.#print_new_line();
+							state.#print_block_middle_tag("else");
+						}
+						// FIXME: Temporary workaround - needs refactor when working on formatting features
+						if (alternate.nodes.length === 1 && alternate.nodes[0].type === "Text") {
+							alternate.nodes[0].raw = alternate.nodes[0].raw.replace(/\n/g, "");
+						}
+						state.#print_block_fragment(alternate, context);
+					}
+					state.#depth++;
+				} else {
+					state.#print_block_opening_tag("if", print_es(test).code);
+					// FIXME: Temporary workaround - needs refactor when working on formatting features
+					if (consequent.nodes.length === 1 && consequent.nodes[0].type === "Text") {
+						consequent.nodes[0].raw = consequent.nodes[0].raw.replace(/\n/g, "");
+					}
+					state.#print_block_fragment(consequent, context);
+					if (alternate) {
+						if (!has_alternate_else_if(alternate)) {
+							state.#print_block_middle_tag("else");
+						}
+						if (alternate.nodes.length === 1 && alternate.nodes[0].type === "Text") {
+							alternate.nodes[0].raw = alternate.nodes[0].raw.replace(/\n/g, "");
+						}
+						state.#print_block_fragment(alternate, context);
+					}
+					state.#print_block_closing_tag(name);
+				}
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/logic-blocks#key}
+			 *
+			 * @example pattern
+			 * ```svelte
+			 * {#key expression}...{/key}
+			 * ```
+			 */
+			KeyBlock(node, context) {
+				const name = "key";
+				const { expression, fragment } = node;
+				const { state } = context;
+				state.#print_block_opening_tag(name, print_es(expression).code);
+				state.#print_block_fragment(fragment, context);
+				state.#print_block_closing_tag(name);
+			},
+
+			/**
+			 *
+			 * TODO: Update link to the official doc once Svelte v5 is released
+			 * @see {@link https://svelte-5-preview.vercel.app/docs/snippets}
+			 *
+			 * @example pattern
+			 * ```svelte
+			 * {#snippet expression(parameters)}...{/snippet}
+			 * ```
+			 */
+			SnippetBlock(node, context) {
+				const name = "snippet";
+				const { body, expression, parameters } = node;
+				const { state } = context;
+				let content = print_es(expression).code;
+				content += "(";
+				content += parameters.map((pattern) => print_es(pattern).code).join(", ");
+				content += ")";
+				state.#print_block_opening_tag(name, content);
+				state.#print_block_fragment(body, context);
+				state.#print_block_closing_tag(name);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/svelte-components}
+			 */
+			Component(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/svelte-components}
+			 */
+			RegularElement(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-elements#slot}
+			 */
+			SlotElement(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/special-elements#svelte-body}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:body on:event={handler} />
+			 * ```
+			 */
+			SvelteBody(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/special-elements#svelte-component}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:component this={currentSelection.component} foo={bar} />
+			 * ```
+			 */
+			SvelteComponent(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-elements#svelte-document}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:document bind:prop={value} on:visibilitychange={handleVisibilityChange} use:someAction />
+			 * ```
+			 */
+			SvelteDocument(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-elements#svelte-element}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:element this={tag} on:click={handler}>Foo</svelte:element>
+			 * ```
+			 */
+			SvelteElement(node, context) {
+				const { attributes, fragment, name, tag } = node;
+				const { state, visit } = context;
+				// WARN: Workaround to convert `this` into attribute
+				visit(
+					{
+						type: "Attribute",
+						name: "this",
+						value: [
+							{
+								type: "ExpressionTag",
+								expression: tag,
+							},
+						],
+					},
+					state,
+				);
+				for (const attribute_like of attributes) {
+					visit(attribute_like, state);
+				}
+				const is_self_closing = state.#is_fragment_empty(fragment);
+				state.#print_element_like_opening_tag(name, { self_close: is_self_closing });
+				if (!is_self_closing && fragment) {
+					state.#depth++;
+					state.#print_element_like_fragment(fragment, context);
+					state.#depth--;
+					state.#print_element_like_closing_tag(name);
+				}
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-fragments#svelte-fragment}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:fragment slot="footer">
+			 *     <p>All rights reserved.</p>
+			 *     <p>Copyright (c) 2019 Svelte Industries</p>
+			 * </svelte:fragment>
+			 * ```
+			 */
+			SvelteFragment(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-heads#svelte-head}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:head>
+			 *     <title>Hello world!</title>
+			 *     <meta name="description" content="This is where the description goes for SEO" />
+			 * </svelte:head>
+			 * ```
+			 */
+			SvelteHead(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/special-optionss#svelte-options}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:options option={value} />
+			 * ```
+			 *
+			 * WARN: This one is different, because it can be extracted only from {@link SvelteAST.Root}
+			 */
+			SvelteOptions(node, context) {
+				const { attributes, name } = node;
+				const { state, visit } = context;
+				for (const attribute_like of attributes) {
+					visit(attribute_like, state);
+				}
+				state.#print_element_like_opening_tag(name, { self_close: true });
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/special-selfs#svelte-self}
+			 *
+			 * @example
+			 * ```svelte
+			 *  <svelte:self count={count - 1} />
+			 * ```
+			 */
+			SvelteSelf(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/special-windows#svelte-window}
+			 *
+			 * @example
+			 * ```svelte
+			 * <svelte:window bind:prop={value} on:keydown={handleKeydown} />
+			 * ```
+			 */
+			SvelteWindow(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title}
+			 */
+			TitleElement(node, context) {
+				const { state } = context;
+				state.#print_element_like(node, context);
+			},
+
+			/**
+			 *
+			 * @see {@link https://svelte.dev/docs/special-tags#const}
+			 *
+			 * @example pattern
+			 * ```svelte
+			 * {@const assignment}
+			 * ```
+			 */
+			ConstTag(node, context) {
+				const { declaration } = node;
+				const { state } = context;
+				state.#print("{@");
+				// NOTE: This is unique, because we need to remove a semicolon at the end.
+				state.#print(print_es(declaration).code.slice(0, -1));
+				state.#print("}");
+			},
+
+			/**
+			 */
+			DebugTag(node, context) {
+				const { identifiers } = node;
+				const { state } = context;
+				state.#print("{@debug");
+				identifiers.forEach((identifier, index) => {
+					state.#print_space();
+					state.#print_es_node(identifier);
+					if (identifiers[index + 1]) {
+						state.#print(",");
+						state.#print_space();
+					}
+				});
+				state.#print("}");
+			},
+
+			/**
+			 * Print Svelte AST node {@link ExpressionTag} as string.
+			 *
+			 * @example expression - a possibly reactive template expression
+			 * ```svelte
+			 * {...}
+			 * ```
+			 */
+			ExpressionTag(node, context) {
+				const { expression } = node;
+				const { state } = context;
+				state.#print("{");
+				state.#print_es_node(expression, { skip_indent: true });
+				state.#print("}");
+			},
+
+			/**
+			 */
+			HtmlTag(node, context) {
+				const { expression } = node;
+				const { state } = context;
+				state.#print("{@html");
+				state.#print_space();
+				state.#print_es_node(expression);
+				state.#print("}");
+			},
+
+			/**
+			 * Print Svelte AST node {@link RenderTag} as string.
+			 * TODO: Update link once Svelte v5 is released
+			 * @see {@link https://svelte.dev/docs/special-tags#html}
+			 *
+			 * @example pattern
+			 * ```svelte
+			 * {@render expression}
+			 * ```
+			 */
+			RenderTag(node, context) {
+				const { expression } = node;
+				const { state } = context;
+				state.#print("{@render");
+				state.#print_space();
+				state.#print_es_node(expression);
+				state.#print("}");
+			},
+
+			/**
+			 * @see {@link https://svelte.dev/docs/svelte-components#style}
+			 */
+			StyleSheet(node, context) {
+				const { attributes, children } = node;
+				const { state, visit } = context;
+				if (state.#is_last_output_closing_element_like) {
+					state.#print_new_line();
+					state.#print_new_line();
+				}
+				for (const attribute of attributes) {
+					visit(attribute, state);
+				}
+				state.#print_element_like_opening_tag("style");
+				state.#print_new_line();
+				state.#depth++;
+				children.forEach((child, index) => {
+					if (index > 0) state.#print_new_line();
+					state.#print_indent();
+					visit(child, state);
+					if (children[index + 1]) state.#print_new_line();
+				});
+				state.#depth--;
+				state.#print_new_line();
+				state.#print_element_like_closing_tag("style");
+			},
+
+			Atrule(node, context) {
+				const { block, name, prelude } = node;
+				const { state, visit } = context;
+				state.#print("@");
+				state.#print(name);
+				state.#print_space();
+				state.#print(prelude);
+				if (block) {
+					state.#print_space();
+					visit(block, state);
+				}
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors}
+			 *
+			 * @example syntax
+			 * ```css
+			 * [name<?matcher><?"value"> flags?]
+			 * ```
+			 */
+			AttributeSelector(node, context) {
+				const { flags, matcher, name, value } = node;
+				const { state } = context;
+				state.#print("[");
+				state.#print(name);
+				if (matcher) state.#print(matcher);
+				if (value) {
+					state.#print('"');
+					state.#print(value);
+					state.#print('"');
+				}
+				if (flags) {
+					state.#print_space();
+					state.#print(flags);
+				}
+				state.#print("]");
+			},
+
+			Block(node, context) {
+				const { children } = node;
+				const { state, visit } = context;
+				state.#print("{");
+				state.#print_new_line();
+				state.#depth++;
+				for (const child of children) {
+					state.#print_indent();
+					visit(child, state);
+					state.#print_new_line();
+				}
+				state.#depth--;
+				state.#print_indent();
+				state.#print("}");
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Class_selectors}
+			 *
+			 * @example simple
+			 * ```css
+			 * .class_name { style properties }
+			 * ```
+			 *
+			 * @example equivalent
+			 * ```css
+			 * [class~=class_name] { style properties }
+			 * ```
+			 */
+			ClassSelector(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print(".");
+				state.#print(name);
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors/Selectors_and_combinators#combinators}
+			 */
+			Combinator(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print(name);
+			},
+
+			ComplexSelector(node, context) {
+				const { children } = node;
+				const { state, visit } = context;
+				for (const relative_selector of children) {
+					visit(relative_selector, state);
+				}
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model/CSS_Declaration}
+			 */
+			Declaration(node, context) {
+				const { property, value } = node;
+				const { state } = context;
+				state.#print(property);
+				state.#print(":");
+				state.#print_space();
+				// NOTE: It removes any existing indentation, because output will look uglier
+				state.#print(value.split(/[\s\t\n]+/).join(" "));
+				state.#print(";");
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/ID_selectors}
+			 *
+			 * @example pattern
+			 * ```css
+			 * #name
+			 * ```
+			 */
+			IdSelector(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print("#");
+				state.#print(name);
+			},
+
+			NestingSelector(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print(name);
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-child}
+			 *
+			 * @example pattern
+			 * ```css
+			 * :nth-child(<nth> [of <complex-selector-list>]?) { }
+			 */
+			Nth(node, context) {
+				const { value } = node;
+				const { state } = context;
+				state.#print(":nth-child(");
+				state.#print(value);
+				state.#print(")");
+			},
+
+			Percentage(node, context) {
+				const { value } = node;
+				const { state } = context;
+				state.#print(value);
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes}
+			 */
+			PseudoClassSelector(node, context) {
+				const { args, name } = node;
+				const { state, visit } = context;
+				state.#print(":");
+				state.#print(name);
+				if (args) {
+					state.#print("(");
+					visit(args, state);
+					state.#print(")");
+				}
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements}
+			 * WARN: It doesn't support args, e.g. `::part()` or  `::slotted()`
+			 */
+			PseudoElementSelector(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print("::");
+				state.#print(name);
+			},
+
+			Rule(node, context) {
+				const { block, prelude } = node;
+				const { state, visit } = context;
+				visit(prelude, state);
+				state.#print_space();
+				visit(block, state);
+			},
+
+			RelativeSelector(node, context) {
+				const { combinator, selectors } = node;
+				const { state, visit } = context;
+				if (combinator) {
+					state.#print_space();
+					visit(combinator, state);
+				}
+				for (const selector of selectors) {
+					visit(selector, state);
+				}
+			},
+
+			SelectorList(node, context) {
+				const { children } = node;
+				const { state, visit } = context;
+				for (const complex_selector of children) {
+					visit(complex_selector, state);
+				}
+			},
+
+			/**
+			 * @see {@link https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors/Type_Class_and_ID_Selectors}
+			 */
+			TypeSelector(node, context) {
+				const { name } = node;
+				const { state } = context;
+				state.#print(name);
+			},
+		});
+	}
+}

tools/ui/node_modules/svelte-ast-print/src/nodes.js

@@ -0,0 +1,247 @@
+/**
+ * @import * as _reset from "@total-typescript/ts-reset";
+ * @import { Node as ESTreeNode } from "estree";
+ * @import { AST, Css, parse } from "svelte/compiler";
+ */
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L514
+ * FIXME: Include `Css.Node` when exposed to public
+ * @typedef {ESTreeNode | TemplateNode | AST.Fragment} SvelteNode
+ */
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L476
+ * @typedef {AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.SpreadAttribute | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective} Directive
+ */
+
+/** @typedef {AST.Attribute | AST.SpreadAttribute | Directive} AttributeLike */
+const ATTRIBUTE_LIKE_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		"AnimateDirective",
+		"Attribute",
+		"BindDirective",
+		"ClassDirective",
+		"LetDirective",
+		"OnDirective",
+		"SpreadAttribute",
+		"StyleDirective",
+		"TransitionDirective",
+		"UseDirective",
+	]),
+);
+
+/**
+ * Type check guard to see if provided AST node is {@link AttributeLike}.
+ *
+ * - Standard attribute _({@link AST.Attribute})_ - {@link https://developer.mozilla.org/en-US/docs/Glossary/Attribute}
+ * - Spread attribute _({@link AST.SpreadAttribute})_ - {@link https://svelte.dev/docs/basic-markup#attributes-and-props}
+ * - Directive _({@link AST.Directive})_ - can be for:
+ *   - component - {@link https://svelte.dev/docs/component-directives}
+ *   - element - {@link https://svelte.dev/docs/element-directives}
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is AttributeLike}
+ */
+export const is_attribute_like_node = (node) => ATTRIBUTE_LIKE_NODE_NAMES.has(node.type);
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L486
+ * @typedef {AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock} Block
+ */
+
+const BLOCK_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		//
+		"AwaitBlock",
+		"Block",
+		"EachBlock",
+		"IfBlock",
+		"KeyBlock",
+		"SnippetBlock",
+	]),
+);
+
+/**
+ * Type check guard to see if provided AST node is a logic block {@link Block}.
+ *
+ * @see {@link https://svelte.dev/docs/logic-blocks}
+ *
+ * NOTE: Svelte v5 includes a new block {@link AST.SnippetBlock}
+ * @see {@link https://svelte-5-preview.vercel.app/docs/snippets}
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is Block}
+ */
+export const is_block_node = (node) => BLOCK_NODE_NAMES.has(node.type);
+
+const CSS_AST_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		"Atrule",
+		"AttributeSelector",
+		"Block",
+		"ClassSelector",
+		"Combinator",
+		"ComplexSelector",
+		"Declaration",
+		"IdSelector",
+		"NestingSelector",
+		"Nth",
+		"Percentage",
+		"PseudoClassSelector",
+		"PseudoElementSelector",
+		"RelativeSelector",
+		"Rule",
+		"SelectorList",
+		"StyleSheet",
+		"TypeSelector",
+	]),
+);
+/**
+ * FIXME: `Css` is not exported
+ * Type check guard to see if provided AST node is a CSS based {@link Css.Node}.
+ *
+ * WARN: Good to know: they're not same _(complaint)_ with `css-tree`!
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is AST.Css.Node}
+ */
+export const is_css_node = (node) => CSS_AST_NODE_NAMES.has(node.type);
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L488
+ * @typedef {AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow} ElementLike */
+
+const ELEMENT_LIKE_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		"Component",
+		"RegularElement",
+		"SlotElement",
+		"SvelteBody",
+		"SvelteComponent",
+		"SvelteDocument",
+		"SvelteElement",
+		"SvelteFragment",
+		"SvelteHead",
+		"SvelteOptionsRaw",
+		"SvelteSelf",
+		"SvelteWindow",
+		"TitleElement",
+	]),
+);
+/**
+ * Type check guard to see if provided AST node is "element-like" {@link ElementLike}.
+ *
+ * Those are:
+ *
+ * - standard Svelte-based component - {@link AST.Component}
+ * - regular element _(HTML based)_ - {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element}
+ * - special Svelte elements - {@link https://svelte.dev/docs/special-elements}
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is ElementLike}
+ */
+export const is_element_like_node = (node) => ELEMENT_LIKE_NODE_NAMES.has(node.type);
+
+/** @typedef {AST.Comment | AST.Text} HtmlNode */
+
+const HTML_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		//
+		"Comment",
+		"Text",
+	]),
+);
+/**
+ * Type check guard to see if provided AST node is standard HTML node {@link HtmlNode}.
+ *
+ * Those are:
+ *
+ * - text that is included between HTML tags - {@link AST.Text}
+ * - HTML comment - {@link AST.Comment}
+ *
+ * @param {SvelteNode} node
+ * @returns {node is HtmlNode}
+ */
+export const is_html_node = (node) => HTML_NODE_NAMES.has(node.type);
+
+const TAG_NODE_NAMES = new Set(
+	/** @type {const} */ ([
+		//
+		"ExpressionTag",
+		"HtmlTag",
+		"ConstTag",
+		"DebugTag",
+		"RenderTag",
+	]),
+);
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L474
+ * @typedef {AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag} Tag
+ */
+
+/**
+ * Type check guard to see if provided AST node is "tag-like" {@link Tag}.
+ *
+ * @see {@link https://svelte.dev/docs/special-tags}
+ *
+ * Not included in the documentation:
+ *
+ * - expression tag _({@link AST.ExpressionTag})_
+ * - render tag _({@link AST.RenderTag})_ - part of Svelte v5
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is Tag}
+ */
+export const is_tag_node = (node) => TAG_NODE_NAMES.has(node.type);
+
+/**
+ * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L503
+ * @typedef {AST.Root | AST.Text | Tag | ElementLike | AST.Attribute | AST.SpreadAttribute | Directive | AST.Comment | Block} TemplateNode
+ */
+
+/**
+ * Type check guard to see if provided AST node is part of node used for templating {@link TemplateNode}.
+ *
+ * Those are:
+ *
+ * - root - what you obtain from the results of from using {@link parse}
+ * - text that is included between HTML tags - {@link AST.Text}
+ * - HTML comment - {@link AST.Comment}
+ *
+ * @param {SvelteNode} node - Supported AST node to narrow down its inferred type
+ * @returns {node is TemplateNode}
+ */
+export const is_template_node = (node) =>
+	node.type === "Root" ||
+	node.type === "Fragment" ||
+	is_attribute_like_node(node) ||
+	is_block_node(node) ||
+	is_css_node(node) ||
+	is_element_like_node(node) ||
+	is_html_node(node) ||
+	is_tag_node(node);
+
+// TODO: Ask Svelte maintainers if `Script` and `SvelteOptions` were omittted from `SvelteNode` intentionally
+/**
+ * Not all of the nodes are bundled together with {@link AST.BaseNode}.
+ * This type wraps them together as supported ones for printing.
+ *
+ * @typedef {AST.Script | AST.BaseNode | AST.SvelteOptionsRaw | SvelteNode} SupportedSvelteNode
+ */
+
+/**
+ * Bundle together Svelte and ESTree specification complaint nodes, so we can support printing both.
+ *
+ * @typedef {ESTreeNode | SupportedSvelteNode} Node
+ */
+
+/**
+ * Type check guard to see if provided AST node is unique to Svelte AST only {@link SupportedSvelteNode}.
+ *
+ * @param {Node} node - ESTree or Svelte AST node
+ * @returns {node is SupportedSvelteNode}
+ */
+export const is_svelte_node = (node) =>
+	node.type === "SvelteOptions" || node.type === "Script" || is_template_node(node);

tools/ui/node_modules/svelte-ast-print/src/options.js

@@ -0,0 +1,107 @@
+/**
+ * @import { Css, Fragment, Root, Script, SvelteOptionsRaw } from "svelte/compiler";
+ * @import { IterableElement, ReadonlyTuple } from "type-fest";
+ *
+ * @import { print } from "./mod.js";
+ */
+
+/**
+ * Options for {@link print} defined by user.
+ *
+ * @typedef PrintOptions
+ * @property {Partial<FormatOptions>} [format] - formatting options
+ * @property {Partial<RootOptions>} [root] - Svelte AST node {@link Root} based options
+ */
+
+/**
+ * Name _(alias)_ for indentation type. This package will automatically determine a desired indent.
+ * @typedef {IterableElement<typeof Options.INDENT>[0]} IndentName
+ */
+
+/**
+ * @satisfies {IndentName}
+ */
+export const DEFAULT_INDENT = "tab";
+
+/**
+ * Options related to formatting.
+ * Provided for building a stable API - gives an space for expansion on future improvements/features.
+ *
+ * @typedef FormatOptions
+ * @property {IndentName} [indent] - defaults to {@link DEFAULT_INDENT}
+ */
+
+/**
+ * @typedef {Extract<keyof Root, "css" | "fragment" | "instance" | "module" | "options">} RootNode
+ */
+
+/**
+ * Specified order of {@link Root} child AST nodes to print out.
+ *
+ * ## Legend
+ *
+ * - `"options"` - {@link SvelteOptionsRaw}
+ * - `"module"` - {@link Script}
+ * - `"instance"` - {@link Script}
+ * - `"fragment"` - {@link Fragment}
+ * - `"css"` - {@link Css.StyleSheet}
+ *
+ * @typedef {ReadonlyTuple<RootNode, 5>} RootOrder
+ */
+
+// TODO: Use generic type parameter, so we use it only when passed node is {@link Root}
+/**
+ * Options related to {@link Root} Svelte AST node.
+ * @typedef RootOptions
+ * @property {RootOrder} [order] - defaults to {@link DEFAULT_ORDER}
+ */
+
+/**
+ * @satisfies {ReadonlyTuple<RootNode, 5>}
+ */
+export const DEFAULT_ORDER = /** @type {const} */ (["options", "module", "instance", "fragment", "css"]);
+
+/**
+ * This class is for internal use only.
+ * Give sa a better control on transforming passed options to the second argument of {@link print}
+ *
+ * @private
+ * @internal
+ */
+export class Options {
+	static INDENT = new Map(
+		/** @type {const} */ ([
+			["tab", "\t"],
+			["2-space", "  "],
+			["4-space", "    "],
+		]),
+	);
+
+	/**
+	 * @type {PrintOptions} raw options - _(before transformation)_ - for better DX
+	 */
+	#raw;
+
+	/**
+	 * @param {PrintOptions} raw - provided options by user - before transformation
+	 */
+	constructor(raw) {
+		this.#raw = raw;
+	}
+
+	get indent() {
+		const { format } = this.#raw;
+		const transformed = Options.INDENT.get(format?.indent ?? DEFAULT_INDENT);
+		if (!transformed) {
+			throw new Error(`Unrecognized indent name - ${format?.indent}, allowed are: ${[...Options.INDENT.keys()]}`);
+		}
+		return transformed;
+	}
+
+	/** @type {RootOrder} */
+	get order() {
+		const { root } = this.#raw;
+
+		return root?.order ?? DEFAULT_ORDER;
+	}
+}

tools/ui/node_modules/svelte-ast-print/types/mod.d.ts

@@ -0,0 +1,142 @@
+declare module 'svelte-ast-print' {
+	import type { Node as ESTreeNode } from 'estree';
+	import type { AST } from 'svelte/compiler';
+   /**
+	* Print AST {@link SvelteAST.BaseNode} as a string.
+	* Aka parse in reverse.
+	*
+	* ## How does it work under the hood?
+	*
+	* 1. Firstly, it determines whether the provided AST node is unique node for Svelte {@link SvelteAST.Node}.
+	* 2. Based on type check guard from above:
+	*    - it uses either this package's {@link Printer} to print Svelte AST node,
+	*    - otherwise it uses `esrap` {@link print_es} to print ESTree specification-complaint AST node
+	*
+	* ## How to use it?
+	*
+	* @example writing a codemode using Node.js
+	  ```js
+	  import fs from "node:fs";
+
+	  import { print } from "svelte-ast-print";
+	  import { parse } from "svelte/compiler";
+
+	  const originalSvelteCode = fs.readFileSync("src/App.svelte", "utf-8");
+	  let svelteAST = parse(originalSvelteCode, { modern: true });
+	  //                                          👆 For now, only modern is supported.
+	  //                                             By default is 'false'.
+	  //                                             Is it planned to be 'true' from Svelte v6+
+
+	  // ...
+	  // Do some modifications on this AST...
+	  // e.g. transform `<slot />` to `{@render children()}`
+	  // ...
+
+	  const output = print(svelteAST); // AST is now a stringified code output! 🎉
+
+	  fs.writeFileSync("src/App.svelte", output, { encoding: " utf-8" });
+	  ```
+	*
+	* @param node - Svelte or ESTree AST node
+	* @param options - printing options
+	* @returns Stringified Svelte AST node
+	* TODO: Ask Svelte maintainers if `Script` and `SvelteOptions` were omittted from `SvelteNode` intentionally - possibly forgotten to include
+	*/
+   export function print(node: Node, options?: Partial<ConstructorParameters<typeof Options>[0]>): string;
+	export function isAttributeLikeNode(node: SvelteNode): node is AttributeLike;
+	export function isBlockNode(node: SvelteNode): node is Block;
+	export function isCssNode(node: SvelteNode): node is AST.Css.Node;
+	export function isElementLikeNode(node: SvelteNode): node is ElementLike;
+	export function isHtmlNode(node: SvelteNode): node is HtmlNode;
+	export function isTagNode(node: SvelteNode): node is Tag;
+	export function isTemplateNode(node: SvelteNode): node is TemplateNode;
+	export function isSvelteNode(node: Node): node is SupportedSvelteNode;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L514
+	 * FIXME: Include `Css.Node` when exposed to public
+	 */
+	type SvelteNode = ESTreeNode | TemplateNode | AST.Fragment;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L476
+	 */
+	type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.SpreadAttribute | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
+	type AttributeLike = AST.Attribute | AST.SpreadAttribute | Directive;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L486
+	 */
+	type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L488
+	 */
+	type ElementLike = AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow;
+	type HtmlNode = AST.Comment | AST.Text;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L474
+	 */
+	type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag;
+	/**
+	 * TODO: Svelte could expose this type to public too: https://github.com/sveltejs/svelte/blob/2b362ddc63e930726b67a1010d2829a3a4f6bb85/packages/svelte/src/compiler/types/template.d.ts#L503
+	 */
+	type TemplateNode = AST.Root | AST.Text | Tag | ElementLike | AST.Attribute | AST.SpreadAttribute | Directive | AST.Comment | Block;
+	/**
+	 * Not all of the nodes are bundled together with {@link AST.BaseNode}.
+	 * This type wraps them together as supported ones for printing.
+	 */
+	type SupportedSvelteNode = AST.Script | AST.BaseNode | AST.SvelteOptionsRaw | SvelteNode;
+	/**
+	 * Bundle together Svelte and ESTree specification complaint nodes, so we can support printing both.
+	 */
+	type Node = ESTreeNode | SupportedSvelteNode;
+	/**
+	 * This class is for internal use only.
+	 * Give sa a better control on transforming passed options to the second argument of {@link print}
+	 *
+	 * */
+	class Options {
+		static INDENT: Map<"tab" | "2-space" | "4-space", "\t" | "  " | "    ">;
+		/**
+		 * @param raw - provided options by user - before transformation
+		 */
+		constructor(raw: PrintOptions);
+		get indent(): "\t" | "  " | "    ";
+		
+		get order(): readonly [never, never, never, never, never];
+		#private;
+	}
+	/**
+	 * Options for {@link print} defined by user.
+	 */
+	type PrintOptions = {
+		/**
+		 * - formatting options
+		 */
+		format?: Partial<FormatOptions> | undefined;
+		/**
+		 * - Svelte AST node {@link Root} based options
+		 */
+		root?: Partial<RootOptions> | undefined;
+	};
+	/**
+	 * Options related to formatting.
+	 * Provided for building a stable API - gives an space for expansion on future improvements/features.
+	 */
+	type FormatOptions = {
+		/**
+		 * - defaults to {@link DEFAULT_INDENT}
+		 */
+		indent?: "tab" | "2-space" | "4-space" | undefined;
+	};
+	/**
+	 * Options related to {@link Root} Svelte AST node.
+	 */
+	type RootOptions = {
+		/**
+		 * - defaults to {@link DEFAULT_ORDER}
+		 */
+		order?: readonly [never, never, never, never, never] | undefined;
+	};
+
+	export {};
+}
+
+//# sourceMappingURL=mod.d.ts.map

tools/ui/node_modules/svelte-ast-print/types/mod.d.ts.map

@@ -0,0 +1,30 @@
+{
+	"version": 3,
+	"file": "mod.d.ts",
+	"names": [
+		"print",
+		"SvelteNode",
+		"Directive",
+		"AttributeLike",
+		"Block",
+		"ElementLike",
+		"HtmlNode",
+		"Tag",
+		"TemplateNode",
+		"SupportedSvelteNode",
+		"Node",
+		"Options"
+	],
+	"sources": [
+		"../src/mod.js",
+		"../src/nodes.js",
+		"../src/options.js"
+	],
+	"sourcesContent": [
+		null,
+		null,
+		null
+	],
+	"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkEgBA,KAAKA;;;;;;;;;;;;;MCzDkCC,UAAUA;;;;MAKwIC,SAASA;MAGnJC,aAAaA;;;;MAgCiBC,KAAKA;;;;MA+DqKC,WAAWA;MAiC5OC,QAAQA;;;;MAmC8CC,GAAGA;;;;MAoB+BC,YAAYA;;;;;MA8B9DC,mBAAmBA;;;;MAMhDC,IAAIA;;;;;;OCtKtCC,OAAOA",
+	"ignoreList": []
+}

tools/ui/node_modules/svelte-check/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2020-Present [these people](https://github.com/sveltejs/language-tools/graphs/contributors) 
+
+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.

tools/ui/node_modules/svelte-check/README.md

@@ -0,0 +1,136 @@
+# Check your code with svelte-check
+
+Provides CLI diagnostics checks for:
+
+-   Unused CSS
+-   Svelte A11y hints
+-   JavaScript/TypeScript compiler errors
+
+Requires Node 16 or later.
+
+### Usage:
+
+#### Local / in your project
+
+Installation:
+
+`npm i svelte-check --save-dev`
+
+Package.json:
+
+```json
+{
+    // ...
+    "scripts": {
+        "svelte-check": "svelte-check"
+        // ...
+    },
+    // ...
+    "devDependencies": {
+        "svelte-check": "..."
+        // ...
+    }
+}
+```
+
+Usage:
+
+`npm run svelte-check`
+
+#### Global (not recommended)
+
+Installation:
+
+`npm i svelte-check svelte -g`
+
+Usage:
+
+1. Go to folder where to start checking
+2. `svelte-check`
+
+### Args:
+
+| Flag                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                              |
+| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--workspace <path>`                                            | Path to your workspace. All subdirectories except node_modules and those listed in `--ignore` are checked                                                                                                                                                                                                                                                                                                |
+| `--output <human\|human-verbose\|machine\|machine-verbose>`     |
+| `--watch`                                                       | Will not exit after one pass but keep watching files for changes and rerun diagnostics                                                                                                                                                                                                                                                                                                                   |
+| `--preserveWatchOutput`                                         | Do not clear the screen in watch mode                                                                                                                                                                                                                                                                                                                                                                    |
+| `--tsconfig <path>`                                             | Pass a path to a tsconfig or jsconfig file. The path can be relative to the workspace path or absolute. Doing this means that only files matched by the files/include/exclude pattern of the config file are diagnosed. It also means that errors from TypeScript and JavaScript files are reported. If not given, will do an upwards traversal looking for the next jsconfig/tsconfig.json              |
+| `--no-tsconfig`                                                 | Use this if you only want to check the Svelte files found in the current directory and below and ignore any JS/TS files (they will not be type-checked)                                                                                                                                                                                                                                                  |
+| `--ignore <path1,path2>`                                        | Can only be used in conjunction with `--no-tsconfig`. Files/folders to ignore - relative to workspace root, comma-separated, inside quotes. Example: `--ignore "dist,build"`.                                                                                                                                                                                                                            |
+| `--fail-on-warnings`                                            | Will also exit with error code when there are warnings                                                                                                                                                                                                                                                                                                                                                   |
+| `--compiler-warnings <code1:error\|ignore,code2:error\|ignore>` | A list of Svelte compiler warning codes. Each entry defines whether that warning should be ignored or treated as an error. Warnings are comma-separated, between warning code and error level is a colon; all inside quotes. Example: `--compiler-warnings "css-unused-selector:ignore,unused-export-let:error"`                                                                                         |
+| `--diagnostic-sources <js,svelte,css>`                          | A list of diagnostic sources which should run diagnostics on your code. Possible values are `js` (includes TS), `svelte`, `css`. Comma-separated, inside quotes. By default all are active. Example: `--diagnostic-sources "js,svelte"`                                                                                                                                                                  |
+| `--threshold <error\|warning>`                                  | Filters the diagnostics to display. `error` will output only errors while `warning` will output warnings and errors.                                                                                                                                                                                                                                                                                     |
+| `--incremental`                                                 | Opts into TypeScript's incremental build cache, which speeds up subsequent runs. Saved within `.svelte-kit` or if not available within `.svelte-check`. This might result in slightly different type check outcomes, and certain patterns are not supported. Specifically, anything that is not in the root dir of your tsconfig.json and is a Svelte file will not be properly loaded and type-checked. |
+| `--tsgo`                                                        | Use TypeScript's Go implementation. Needs to have `@typescript/native-preview` installed. Subject to the same limitations as `--incremental`                                                                                                                                                                                                                                                             |
+
+### FAQ
+
+#### Why is there no option to only check specific files (for example only staged files)?
+
+`svelte-check` needs to know the whole project to do valid checks. Imagine you alter a component property `export let foo` to `export let bar`, but you don't update any of the component usages. They all have errors now but you would not catch them if you only run checks on changed files.
+
+### More docs, preprocessor setup and troubleshooting
+
+[See here](/docs/README.md).
+
+### Machine-Readable Output
+
+Setting the `--output` to `machine` or `machine-verbose` will format output in a way that is easier to read
+by machines, e.g. inside CI pipelines, for code quality checks, etc.
+
+Each row corresponds to a new record. Rows are made up of columns that are separated by a
+single space character. The first column of every row contains a timestamp in milliseconds
+which can be used for monitoring purposes. The second column gives us the "row type", based
+on which the number and types of subsequent columns may differ.
+
+The first row is of type `START` and contains the workspace folder (wrapped in quotes).
+
+###### Example:
+
+```
+1590680325583 START "/home/user/language-tools/packages/language-server/test/plugins/typescript/testfiles"
+```
+
+Any number of `ERROR` or `WARNING` records may follow. Their structure is identical and depends on the output argoument.
+
+If the argument is `machine` it will tell us the filename, the starting line and column numbers, and the error message. The filename is relative to the workspace directory. The filename and the message are both wrapped in quotes.
+
+###### Example:
+
+```
+1590680326283 ERROR "codeactions.svelte" 1:16 "Cannot find module 'blubb' or its corresponding type declarations."
+1590680326778 WARNING "imported-file.svelte" 0:37 "Component has unused export property 'prop'. If it is for external reference only, please consider using `export const prop`"
+```
+
+If the argument is `machine-verbose` it will tell us the filename, the starting line and column numbers, the ending line and column numbers, the error message, the code of diagnostic, the human-friendly description of the code and the human-friendly source of the diagnostic (eg. svelte/typescript). The filename is relative to the workspace directory. Each diagnostic is represented as an [ndjson](https://en.wikipedia.org/wiki/JSON_streaming#Newline-Delimited_JSON) line prefixed by the timestamp of the log.
+
+###### Example:
+
+```
+1590680326283 {"type":"ERROR","fn":"codeaction.svelte","start":{"line":1,"character":16},"end":{"line":1,"character":23},"message":"Cannot find module 'blubb' or its corresponding type declarations.","code":2307,"source":"js"}
+1590680326778 {"type":"WARNING","filename":"imported-file.svelte","start":{"line":0,"character":37},"end":{"line":0,"character":51},"message":"Component has unused export property 'prop'. If it is for external reference only, please consider using `export
+const prop`","code":"unused-export-let","source":"svelte"}
+```
+
+The output concludes with a `COMPLETED` message that summarizes total numbers of files, errors and warnings that were encountered during the check.
+
+###### Example:
+
+```
+1590680326807 COMPLETED 20 FILES 21 ERRORS 1 WARNINGS 3 FILES_WITH_PROBLEMS
+```
+
+If the application experiences a runtime error, this error will appear as a `FAILURE` record.
+
+###### Example:
+
+```
+1590680328921 FAILURE "Connection closed"
+```
+
+### Credits
+
+-   Vue's [VTI](https://github.com/vuejs/vetur/tree/master/vti) which laid the foundation for `svelte-check`

tools/ui/node_modules/svelte-check/bin/svelte-check

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/src/index.js');

tools/ui/node_modules/svelte-check/dist/src/svelte-jsx-v4.d.ts

@@ -0,0 +1,230 @@
+/// <reference lib="dom" />
+
+declare namespace svelteHTML {
+
+  // Every namespace eligible for use needs to implement the following two functions
+  /**
+   * @internal do not use
+   */
+  function mapElementTag<K extends keyof ElementTagNameMap>(
+    tag: K
+  ): ElementTagNameMap[K];
+  function mapElementTag<K extends keyof SVGElementTagNameMap>(
+    tag: K
+  ): SVGElementTagNameMap[K];
+  function mapElementTag(
+    tag: any
+  ): any; // needs to be any because used in context of <svelte:element>
+
+  /**
+   * @internal do not use
+   */
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrs: string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements, T>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrsEnhancers: T, attrs: (string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]) & T
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+
+  // For backwards-compatibility and ease-of-use, in case someone enhanced the typings from import('svelte/elements').HTMLAttributes/SVGAttributes
+  interface HTMLAttributes<T extends EventTarget = any> {}
+  interface SVGAttributes<T extends EventTarget = any> {}
+
+  /**
+   * @internal do not use
+   */
+  type HTMLProps<Property extends string, Override> =
+    Omit<import('svelte/elements').SvelteHTMLElements[Property], keyof Override> & Override;
+
+  interface IntrinsicElements {
+    a: HTMLProps<'a', HTMLAttributes>;
+    abbr: HTMLProps<'abbr', HTMLAttributes>;
+    address: HTMLProps<'address', HTMLAttributes>;
+    area: HTMLProps<'area', HTMLAttributes>;
+    article: HTMLProps<'article', HTMLAttributes>;
+    aside: HTMLProps<'aside', HTMLAttributes>;
+    audio: HTMLProps<'audio', HTMLAttributes>;
+    b: HTMLProps<'b', HTMLAttributes>;
+    base: HTMLProps<'base', HTMLAttributes>;
+    bdi: HTMLProps<'bdi', HTMLAttributes>;
+    bdo: HTMLProps<'bdo', HTMLAttributes>;
+    big: HTMLProps<'big', HTMLAttributes>;
+    blockquote: HTMLProps<'blockquote', HTMLAttributes>;
+    body: HTMLProps<'body', HTMLAttributes>;
+    br: HTMLProps<'br', HTMLAttributes>;
+    button: HTMLProps<'button', HTMLAttributes>;
+    canvas: HTMLProps<'canvas', HTMLAttributes>;
+    caption: HTMLProps<'caption', HTMLAttributes>;
+    cite: HTMLProps<'cite', HTMLAttributes>;
+    code: HTMLProps<'code', HTMLAttributes>;
+    col: HTMLProps<'col', HTMLAttributes>;
+    colgroup: HTMLProps<'colgroup', HTMLAttributes>;
+    data: HTMLProps<'data', HTMLAttributes>;
+    datalist: HTMLProps<'datalist', HTMLAttributes>;
+    dd: HTMLProps<'dd', HTMLAttributes>;
+    del: HTMLProps<'del', HTMLAttributes>;
+    details: HTMLProps<'details', HTMLAttributes>;
+    dfn: HTMLProps<'dfn', HTMLAttributes>;
+    dialog: HTMLProps<'dialog', HTMLAttributes>;
+    div: HTMLProps<'div', HTMLAttributes>;
+    dl: HTMLProps<'dl', HTMLAttributes>;
+    dt: HTMLProps<'dt', HTMLAttributes>;
+    em: HTMLProps<'em', HTMLAttributes>;
+    embed: HTMLProps<'embed', HTMLAttributes>;
+    fieldset: HTMLProps<'fieldset', HTMLAttributes>;
+    figcaption: HTMLProps<'figcaption', HTMLAttributes>;
+    figure: HTMLProps<'figure', HTMLAttributes>;
+    footer: HTMLProps<'footer', HTMLAttributes>;
+    form: HTMLProps<'form', HTMLAttributes>;
+    h1: HTMLProps<'h1', HTMLAttributes>;
+    h2: HTMLProps<'h2', HTMLAttributes>;
+    h3: HTMLProps<'h3', HTMLAttributes>;
+    h4: HTMLProps<'h4', HTMLAttributes>;
+    h5: HTMLProps<'h5', HTMLAttributes>;
+    h6: HTMLProps<'h6', HTMLAttributes>;
+    head: HTMLProps<'head', HTMLAttributes>;
+    header: HTMLProps<'header', HTMLAttributes>;
+    hgroup: HTMLProps<'hgroup', HTMLAttributes>;
+    hr: HTMLProps<'hr', HTMLAttributes>;
+    html: HTMLProps<'html', HTMLAttributes>;
+    i: HTMLProps<'i', HTMLAttributes>;
+    iframe: HTMLProps<'iframe', HTMLAttributes>;
+    img: HTMLProps<'img', HTMLAttributes>;
+    input: HTMLProps<'input', HTMLAttributes>;
+    ins: HTMLProps<'ins', HTMLAttributes>;
+    kbd: HTMLProps<'kbd', HTMLAttributes>;
+    keygen: HTMLProps<'keygen', HTMLAttributes>;
+    label: HTMLProps<'label', HTMLAttributes>;
+    legend: HTMLProps<'legend', HTMLAttributes>;
+    li: HTMLProps<'li', HTMLAttributes>;
+    link: HTMLProps<'link', HTMLAttributes>;
+    main: HTMLProps<'main', HTMLAttributes>;
+    map: HTMLProps<'map', HTMLAttributes>;
+    mark: HTMLProps<'mark', HTMLAttributes>;
+    menu: HTMLProps<'menu', HTMLAttributes>;
+    menuitem: HTMLProps<'menuitem', HTMLAttributes>;
+    meta: HTMLProps<'meta', HTMLAttributes>;
+    meter: HTMLProps<'meter', HTMLAttributes>;
+    nav: HTMLProps<'nav', HTMLAttributes>;
+    noscript: HTMLProps<'noscript', HTMLAttributes>;
+    object: HTMLProps<'object', HTMLAttributes>;
+    ol: HTMLProps<'ol', HTMLAttributes>;
+    optgroup: HTMLProps<'optgroup', HTMLAttributes>;
+    option: HTMLProps<'option', HTMLAttributes>;
+    output: HTMLProps<'output', HTMLAttributes>;
+    p: HTMLProps<'p', HTMLAttributes>;
+    param: HTMLProps<'param', HTMLAttributes>;
+    picture: HTMLProps<'picture', HTMLAttributes>;
+    pre: HTMLProps<'pre', HTMLAttributes>;
+    progress: HTMLProps<'progress', HTMLAttributes>;
+    q: HTMLProps<'q', HTMLAttributes>;
+    rp: HTMLProps<'rp', HTMLAttributes>;
+    rt: HTMLProps<'rt', HTMLAttributes>;
+    ruby: HTMLProps<'ruby', HTMLAttributes>;
+    s: HTMLProps<'s', HTMLAttributes>;
+    samp: HTMLProps<'samp', HTMLAttributes>;
+    slot: HTMLProps<'slot', HTMLAttributes>;
+    script: HTMLProps<'script', HTMLAttributes>;
+    section: HTMLProps<'section', HTMLAttributes>;
+    select: HTMLProps<'select', HTMLAttributes>;
+    small: HTMLProps<'small', HTMLAttributes>;
+    source: HTMLProps<'source', HTMLAttributes>;
+    span: HTMLProps<'span', HTMLAttributes>;
+    strong: HTMLProps<'strong', HTMLAttributes>;
+    style: HTMLProps<'style', HTMLAttributes>;
+    sub: HTMLProps<'sub', HTMLAttributes>;
+    summary: HTMLProps<'summary', HTMLAttributes>;
+    sup: HTMLProps<'sup', HTMLAttributes>;
+    table: HTMLProps<'table', HTMLAttributes>;
+    template: HTMLProps<'template', HTMLAttributes>;
+    tbody: HTMLProps<'tbody', HTMLAttributes>;
+    td: HTMLProps<'td', HTMLAttributes>;
+    textarea: HTMLProps<'textarea', HTMLAttributes>;
+    tfoot: HTMLProps<'tfoot', HTMLAttributes>;
+    th: HTMLProps<'th', HTMLAttributes>;
+    thead: HTMLProps<'thead', HTMLAttributes>;
+    time: HTMLProps<'time', HTMLAttributes>;
+    title: HTMLProps<'title', HTMLAttributes>;
+    tr: HTMLProps<'tr', HTMLAttributes>;
+    track: HTMLProps<'track', HTMLAttributes>;
+    u: HTMLProps<'u', HTMLAttributes>;
+    ul: HTMLProps<'ul', HTMLAttributes>;
+    var: HTMLProps<'var', HTMLAttributes>;
+    video: HTMLProps<'video', HTMLAttributes>;
+    wbr: HTMLProps<'wbr', HTMLAttributes>;
+    webview: HTMLProps<'webview', HTMLAttributes>;
+    // SVG
+    svg: HTMLProps<'svg', SVGAttributes>;
+
+    animate: HTMLProps<'animate', SVGAttributes>;
+    animateMotion: HTMLProps<'animateMotion', SVGAttributes>;
+    animateTransform: HTMLProps<'animateTransform', SVGAttributes>;
+    circle: HTMLProps<'circle', SVGAttributes>;
+    clipPath: HTMLProps<'clipPath', SVGAttributes>;
+    defs: HTMLProps<'defs', SVGAttributes>;
+    desc: HTMLProps<'desc', SVGAttributes>;
+    ellipse: HTMLProps<'ellipse', SVGAttributes>;
+    feBlend: HTMLProps<'feBlend', SVGAttributes>;
+    feColorMatrix: HTMLProps<'feColorMatrix', SVGAttributes>;
+    feComponentTransfer: HTMLProps<'feComponentTransfer', SVGAttributes>;
+    feComposite: HTMLProps<'feComposite', SVGAttributes>;
+    feConvolveMatrix: HTMLProps<'feConvolveMatrix', SVGAttributes>;
+    feDiffuseLighting: HTMLProps<'feDiffuseLighting', SVGAttributes>;
+    feDisplacementMap: HTMLProps<'feDisplacementMap', SVGAttributes>;
+    feDistantLight: HTMLProps<'feDistantLight', SVGAttributes>;
+    feDropShadow: HTMLProps<'feDropShadow', SVGAttributes>;
+    feFlood: HTMLProps<'feFlood', SVGAttributes>;
+    feFuncA: HTMLProps<'feFuncA', SVGAttributes>;
+    feFuncB: HTMLProps<'feFuncB', SVGAttributes>;
+    feFuncG: HTMLProps<'feFuncG', SVGAttributes>;
+    feFuncR: HTMLProps<'feFuncR', SVGAttributes>;
+    feGaussianBlur: HTMLProps<'feGaussianBlur', SVGAttributes>;
+    feImage: HTMLProps<'feImage', SVGAttributes>;
+    feMerge: HTMLProps<'feMerge', SVGAttributes>;
+    feMergeNode: HTMLProps<'feMergeNode', SVGAttributes>;
+    feMorphology: HTMLProps<'feMorphology', SVGAttributes>;
+    feOffset: HTMLProps<'feOffset', SVGAttributes>;
+    fePointLight: HTMLProps<'fePointLight', SVGAttributes>;
+    feSpecularLighting: HTMLProps<'feSpecularLighting', SVGAttributes>;
+    feSpotLight: HTMLProps<'feSpotLight', SVGAttributes>;
+    feTile: HTMLProps<'feTile', SVGAttributes>;
+    feTurbulence: HTMLProps<'feTurbulence', SVGAttributes>;
+    filter: HTMLProps<'filter', SVGAttributes>;
+    foreignObject: HTMLProps<'foreignObject', SVGAttributes>;
+    g: HTMLProps<'g', SVGAttributes>;
+    image: HTMLProps<'image', SVGAttributes>;
+    line: HTMLProps<'line', SVGAttributes>;
+    linearGradient: HTMLProps<'linearGradient', SVGAttributes>;
+    marker: HTMLProps<'marker', SVGAttributes>;
+    mask: HTMLProps<'mask', SVGAttributes>;
+    metadata: HTMLProps<'metadata', SVGAttributes>;
+    mpath: HTMLProps<'mpath', SVGAttributes>;
+    path: HTMLProps<'path', SVGAttributes>;
+    pattern: HTMLProps<'pattern', SVGAttributes>;
+    polygon: HTMLProps<'polygon', SVGAttributes>;
+    polyline: HTMLProps<'polyline', SVGAttributes>;
+    radialGradient: HTMLProps<'radialGradient', SVGAttributes>;
+    rect: HTMLProps<'rect', SVGAttributes>;
+    stop: HTMLProps<'stop', SVGAttributes>;
+    switch: HTMLProps<'switch', SVGAttributes>;
+    symbol: HTMLProps<'symbol', SVGAttributes>;
+    text: HTMLProps<'text', SVGAttributes>;
+    textPath: HTMLProps<'textPath', SVGAttributes>;
+    tspan: HTMLProps<'tspan', SVGAttributes>;
+    use: HTMLProps<'use', SVGAttributes>;
+    view: HTMLProps<'view', SVGAttributes>;
+
+    // Svelte specific
+    'svelte:window': HTMLProps<'svelte:window', HTMLAttributes>;
+    'svelte:body': HTMLProps<'svelte:body', HTMLAttributes>;
+    'svelte:document': HTMLProps<'svelte:document', HTMLAttributes>;
+    'svelte:fragment': { slot?: string };
+    'svelte:options': { [name: string]: any };
+    'svelte:head': { [name: string]: any };
+
+    [name: string]: { [name: string]: any };
+  }
+
+}

tools/ui/node_modules/svelte-check/dist/src/svelte-jsx.d.ts

@@ -0,0 +1,1492 @@
+/// <reference lib="dom" />
+// @ts-nocheck
+// nocheck because we don't want to adjust this anymore (only used for Svelte 3)
+
+declare namespace svelteHTML {
+
+  // Every namespace eligible for use needs to implement the following two functions
+  /**
+   * @internal do not use
+   */
+  function mapElementTag<K extends keyof ElementTagNameMap>(
+    tag: K
+  ): ElementTagNameMap[K];
+  function mapElementTag<K extends keyof SVGElementTagNameMap>(
+    tag: K
+  ): SVGElementTagNameMap[K];
+  function mapElementTag(
+    tag: any
+  ): any; // needs to be any because used in context of <svelte:element>
+
+  /**
+   * @internal do not use
+   */
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrs: string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements, T>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrsEnhancers: T, attrs: (string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]) & T
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+
+  // For backwards-compatibility and ease-of-use, in case someone enhanced the typings from import('svelte/elements').HTMLAttributes/SVGAttributes
+  interface HTMLAttributes<T extends EventTarget = any> {}
+  interface SVGAttributes<T extends EventTarget = any> {}
+
+  /**
+   * @internal do not use
+   */
+  type EventsWithColon<T> = {[Property in keyof T as Property extends `on${infer Key}` ? `on:${Key}` : Property]?: T[Property] }
+  /**
+   * @internal do not use
+   */
+  type HTMLProps<Property extends string, Override> =
+    // This omit chain ensures that properties manually defined in the new transformation take precedence
+    // over those manually defined in the old, taking precendence over the defaults, to make sth like this possible
+    // https://github.com/sveltejs/language-tools/issues/1352#issuecomment-1248627516
+    // The AttributeNames Omit is necessary because the old transformation only has HTMLAttributes on which types for all
+    // elements are defined, which would silence type errors in the new transformation.
+    Omit<
+      Omit<import('svelte/elements').SvelteHTMLElements[Property], keyof EventsWithColon<Omit<svelte.JSX.IntrinsicElements[Property & string], svelte.JSX.AttributeNames>>> & EventsWithColon<Omit<svelte.JSX.IntrinsicElements[Property & string], svelte.JSX.AttributeNames>>,
+      keyof Override
+    > & Override;
+  /**
+   * @internal do not use
+   */
+  type RemoveIndex<T> = {
+    [ K in keyof T as string extends K ? never : K ] : T[K]
+  };
+
+  // the following type construct makes sure that we can use the new typings while maintaining backwards-compatibility in case someone enhanced the old typings
+  interface IntrinsicElements extends Omit<RemoveIndex<svelte.JSX.IntrinsicElements>, keyof RemoveIndex<import('svelte/elements').SvelteHTMLElements>> {
+    a: HTMLProps<'a', HTMLAttributes>;
+    abbr: HTMLProps<'abbr', HTMLAttributes>;
+    address: HTMLProps<'address', HTMLAttributes>;
+    area: HTMLProps<'area', HTMLAttributes>;
+    article: HTMLProps<'article', HTMLAttributes>;
+    aside: HTMLProps<'aside', HTMLAttributes>;
+    audio: HTMLProps<'audio', HTMLAttributes>;
+    b: HTMLProps<'b', HTMLAttributes>;
+    base: HTMLProps<'base', HTMLAttributes>;
+    bdi: HTMLProps<'bdi', HTMLAttributes>;
+    bdo: HTMLProps<'bdo', HTMLAttributes>;
+    big: HTMLProps<'big', HTMLAttributes>;
+    blockquote: HTMLProps<'blockquote', HTMLAttributes>;
+    body: HTMLProps<'body', HTMLAttributes>;
+    br: HTMLProps<'br', HTMLAttributes>;
+    button: HTMLProps<'button', HTMLAttributes>;
+    canvas: HTMLProps<'canvas', HTMLAttributes>;
+    caption: HTMLProps<'caption', HTMLAttributes>;
+    cite: HTMLProps<'cite', HTMLAttributes>;
+    code: HTMLProps<'code', HTMLAttributes>;
+    col: HTMLProps<'col', HTMLAttributes>;
+    colgroup: HTMLProps<'colgroup', HTMLAttributes>;
+    data: HTMLProps<'data', HTMLAttributes>;
+    datalist: HTMLProps<'datalist', HTMLAttributes>;
+    dd: HTMLProps<'dd', HTMLAttributes>;
+    del: HTMLProps<'del', HTMLAttributes>;
+    details: HTMLProps<'details', HTMLAttributes>;
+    dfn: HTMLProps<'dfn', HTMLAttributes>;
+    dialog: HTMLProps<'dialog', HTMLAttributes>;
+    div: HTMLProps<'div', HTMLAttributes>;
+    dl: HTMLProps<'dl', HTMLAttributes>;
+    dt: HTMLProps<'dt', HTMLAttributes>;
+    em: HTMLProps<'em', HTMLAttributes>;
+    embed: HTMLProps<'embed', HTMLAttributes>;
+    fieldset: HTMLProps<'fieldset', HTMLAttributes>;
+    figcaption: HTMLProps<'figcaption', HTMLAttributes>;
+    figure: HTMLProps<'figure', HTMLAttributes>;
+    footer: HTMLProps<'footer', HTMLAttributes>;
+    form: HTMLProps<'form', HTMLAttributes>;
+    h1: HTMLProps<'h1', HTMLAttributes>;
+    h2: HTMLProps<'h2', HTMLAttributes>;
+    h3: HTMLProps<'h3', HTMLAttributes>;
+    h4: HTMLProps<'h4', HTMLAttributes>;
+    h5: HTMLProps<'h5', HTMLAttributes>;
+    h6: HTMLProps<'h6', HTMLAttributes>;
+    head: HTMLProps<'head', HTMLAttributes>;
+    header: HTMLProps<'header', HTMLAttributes>;
+    hgroup: HTMLProps<'hgroup', HTMLAttributes>;
+    hr: HTMLProps<'hr', HTMLAttributes>;
+    html: HTMLProps<'html', HTMLAttributes>;
+    i: HTMLProps<'i', HTMLAttributes>;
+    iframe: HTMLProps<'iframe', HTMLAttributes>;
+    img: HTMLProps<'img', HTMLAttributes>;
+    input: HTMLProps<'input', HTMLAttributes>;
+    ins: HTMLProps<'ins', HTMLAttributes>;
+    kbd: HTMLProps<'kbd', HTMLAttributes>;
+    keygen: HTMLProps<'keygen', HTMLAttributes>;
+    label: HTMLProps<'label', HTMLAttributes>;
+    legend: HTMLProps<'legend', HTMLAttributes>;
+    li: HTMLProps<'li', HTMLAttributes>;
+    link: HTMLProps<'link', HTMLAttributes>;
+    main: HTMLProps<'main', HTMLAttributes>;
+    map: HTMLProps<'map', HTMLAttributes>;
+    mark: HTMLProps<'mark', HTMLAttributes>;
+    menu: HTMLProps<'menu', HTMLAttributes>;
+    menuitem: HTMLProps<'menuitem', HTMLAttributes>;
+    meta: HTMLProps<'meta', HTMLAttributes>;
+    meter: HTMLProps<'meter', HTMLAttributes>;
+    nav: HTMLProps<'nav', HTMLAttributes>;
+    noscript: HTMLProps<'noscript', HTMLAttributes>;
+    object: HTMLProps<'object', HTMLAttributes>;
+    ol: HTMLProps<'ol', HTMLAttributes>;
+    optgroup: HTMLProps<'optgroup', HTMLAttributes>;
+    option: HTMLProps<'option', HTMLAttributes>;
+    output: HTMLProps<'output', HTMLAttributes>;
+    p: HTMLProps<'p', HTMLAttributes>;
+    param: HTMLProps<'param', HTMLAttributes>;
+    picture: HTMLProps<'picture', HTMLAttributes>;
+    pre: HTMLProps<'pre', HTMLAttributes>;
+    progress: HTMLProps<'progress', HTMLAttributes>;
+    q: HTMLProps<'q', HTMLAttributes>;
+    rp: HTMLProps<'rp', HTMLAttributes>;
+    rt: HTMLProps<'rt', HTMLAttributes>;
+    ruby: HTMLProps<'ruby', HTMLAttributes>;
+    s: HTMLProps<'s', HTMLAttributes>;
+    samp: HTMLProps<'samp', HTMLAttributes>;
+    slot: HTMLProps<'slot', HTMLAttributes>;
+    script: HTMLProps<'script', HTMLAttributes>;
+    section: HTMLProps<'section', HTMLAttributes>;
+    select: HTMLProps<'select', HTMLAttributes>;
+    small: HTMLProps<'small', HTMLAttributes>;
+    source: HTMLProps<'source', HTMLAttributes>;
+    span: HTMLProps<'span', HTMLAttributes>;
+    strong: HTMLProps<'strong', HTMLAttributes>;
+    style: HTMLProps<'style', HTMLAttributes>;
+    sub: HTMLProps<'sub', HTMLAttributes>;
+    summary: HTMLProps<'summary', HTMLAttributes>;
+    sup: HTMLProps<'sup', HTMLAttributes>;
+    table: HTMLProps<'table', HTMLAttributes>;
+    template: HTMLProps<'template', HTMLAttributes>;
+    tbody: HTMLProps<'tbody', HTMLAttributes>;
+    td: HTMLProps<'td', HTMLAttributes>;
+    textarea: HTMLProps<'textarea', HTMLAttributes>;
+    tfoot: HTMLProps<'tfoot', HTMLAttributes>;
+    th: HTMLProps<'th', HTMLAttributes>;
+    thead: HTMLProps<'thead', HTMLAttributes>;
+    time: HTMLProps<'time', HTMLAttributes>;
+    title: HTMLProps<'title', HTMLAttributes>;
+    tr: HTMLProps<'tr', HTMLAttributes>;
+    track: HTMLProps<'track', HTMLAttributes>;
+    u: HTMLProps<'u', HTMLAttributes>;
+    ul: HTMLProps<'ul', HTMLAttributes>;
+    var: HTMLProps<'var', HTMLAttributes>;
+    video: HTMLProps<'video', HTMLAttributes>;
+    wbr: HTMLProps<'wbr', HTMLAttributes>;
+    webview: HTMLProps<'webview', HTMLAttributes>;
+    // SVG
+    svg: HTMLProps<'svg', SVGAttributes>;
+
+    animate: HTMLProps<'animate', SVGAttributes>;
+    animateMotion: HTMLProps<'animateMotion', SVGAttributes>;
+    animateTransform: HTMLProps<'animateTransform', SVGAttributes>;
+    circle: HTMLProps<'circle', SVGAttributes>;
+    clipPath: HTMLProps<'clipPath', SVGAttributes>;
+    defs: HTMLProps<'defs', SVGAttributes>;
+    desc: HTMLProps<'desc', SVGAttributes>;
+    ellipse: HTMLProps<'ellipse', SVGAttributes>;
+    feBlend: HTMLProps<'feBlend', SVGAttributes>;
+    feColorMatrix: HTMLProps<'feColorMatrix', SVGAttributes>;
+    feComponentTransfer: HTMLProps<'feComponentTransfer', SVGAttributes>;
+    feComposite: HTMLProps<'feComposite', SVGAttributes>;
+    feConvolveMatrix: HTMLProps<'feConvolveMatrix', SVGAttributes>;
+    feDiffuseLighting: HTMLProps<'feDiffuseLighting', SVGAttributes>;
+    feDisplacementMap: HTMLProps<'feDisplacementMap', SVGAttributes>;
+    feDistantLight: HTMLProps<'feDistantLight', SVGAttributes>;
+    feDropShadow: HTMLProps<'feDropShadow', SVGAttributes>;
+    feFlood: HTMLProps<'feFlood', SVGAttributes>;
+    feFuncA: HTMLProps<'feFuncA', SVGAttributes>;
+    feFuncB: HTMLProps<'feFuncB', SVGAttributes>;
+    feFuncG: HTMLProps<'feFuncG', SVGAttributes>;
+    feFuncR: HTMLProps<'feFuncR', SVGAttributes>;
+    feGaussianBlur: HTMLProps<'feGaussianBlur', SVGAttributes>;
+    feImage: HTMLProps<'feImage', SVGAttributes>;
+    feMerge: HTMLProps<'feMerge', SVGAttributes>;
+    feMergeNode: HTMLProps<'feMergeNode', SVGAttributes>;
+    feMorphology: HTMLProps<'feMorphology', SVGAttributes>;
+    feOffset: HTMLProps<'feOffset', SVGAttributes>;
+    fePointLight: HTMLProps<'fePointLight', SVGAttributes>;
+    feSpecularLighting: HTMLProps<'feSpecularLighting', SVGAttributes>;
+    feSpotLight: HTMLProps<'feSpotLight', SVGAttributes>;
+    feTile: HTMLProps<'feTile', SVGAttributes>;
+    feTurbulence: HTMLProps<'feTurbulence', SVGAttributes>;
+    filter: HTMLProps<'filter', SVGAttributes>;
+    foreignObject: HTMLProps<'foreignObject', SVGAttributes>;
+    g: HTMLProps<'g', SVGAttributes>;
+    image: HTMLProps<'image', SVGAttributes>;
+    line: HTMLProps<'line', SVGAttributes>;
+    linearGradient: HTMLProps<'linearGradient', SVGAttributes>;
+    marker: HTMLProps<'marker', SVGAttributes>;
+    mask: HTMLProps<'mask', SVGAttributes>;
+    metadata: HTMLProps<'metadata', SVGAttributes>;
+    mpath: HTMLProps<'mpath', SVGAttributes>;
+    path: HTMLProps<'path', SVGAttributes>;
+    pattern: HTMLProps<'pattern', SVGAttributes>;
+    polygon: HTMLProps<'polygon', SVGAttributes>;
+    polyline: HTMLProps<'polyline', SVGAttributes>;
+    radialGradient: HTMLProps<'radialGradient', SVGAttributes>;
+    rect: HTMLProps<'rect', SVGAttributes>;
+    stop: HTMLProps<'stop', SVGAttributes>;
+    switch: HTMLProps<'switch', SVGAttributes>;
+    symbol: HTMLProps<'symbol', SVGAttributes>;
+    text: HTMLProps<'text', SVGAttributes>;
+    textPath: HTMLProps<'textPath', SVGAttributes>;
+    tspan: HTMLProps<'tspan', SVGAttributes>;
+    use: HTMLProps<'use', SVGAttributes>;
+    view: HTMLProps<'view', SVGAttributes>;
+
+    // Svelte specific
+    'svelte:window': HTMLProps<'svelte:window', HTMLAttributes>;
+    'svelte:body': HTMLProps<'svelte:body', HTMLAttributes>;
+    'svelte:document': HTMLProps<'svelte:document', HTMLAttributes>;
+    'svelte:fragment': { slot?: string };
+    'svelte:options': { [name: string]: any };
+    'svelte:head': { [name: string]: any };
+
+    [name: string]: { [name: string]: any };
+  }
+
+}
+
+// Keep svelte.JSX for backwards compatibility, in case someone enhanced it with their own typings,
+// which we can transform to the new svelteHTML namespace.
+/**
+ * @deprecated use the types from `svelte/elements` instead, or the `svelteHTML` namespace.
+ * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+ */
+declare namespace svelte.JSX {
+
+  /* svelte specific */
+  interface ElementClass {
+      $$prop_def: any;
+  }
+
+  interface ElementAttributesProperty {
+      $$prop_def: any; // specify the property name to use
+  }
+
+  /* html jsx */
+
+  interface IntrinsicAttributes {
+    slot?: string;
+  }
+
+  //
+  // Event Handler Types
+  // ----------------------------------------------------------------------
+  type EventHandler<E extends Event = Event, T extends EventTarget = HTMLElement> =
+    (event: E & { currentTarget: EventTarget & T}) => any;
+
+  type ClipboardEventHandler<T extends EventTarget> = EventHandler<ClipboardEvent, T>;
+  type CompositionEventHandler<T extends EventTarget> = EventHandler<CompositionEvent, T>;
+  type DragEventHandler<T extends EventTarget> = EventHandler<DragEvent, T>;
+  type FocusEventHandler<T extends EventTarget> = EventHandler<FocusEvent, T>;
+  type FormEventHandler<T extends EventTarget> = EventHandler<Event, T>;
+  type ChangeEventHandler<T extends EventTarget> = EventHandler<Event, T>;
+  type KeyboardEventHandler<T extends EventTarget> = EventHandler<KeyboardEvent, T>;
+  type MouseEventHandler<T extends EventTarget> = EventHandler<MouseEvent, T>;
+  type TouchEventHandler<T extends EventTarget> = EventHandler<TouchEvent, T>;
+  type PointerEventHandler<T extends EventTarget> = EventHandler<PointerEvent, T>;
+  type UIEventHandler<T extends EventTarget> = EventHandler<UIEvent, T>;
+  type WheelEventHandler<T extends EventTarget> = EventHandler<WheelEvent, T>;
+  type AnimationEventHandler<T extends EventTarget> = EventHandler<AnimationEvent, T>;
+  type TransitionEventHandler<T extends EventTarget> = EventHandler<TransitionEvent, T>;
+  type MessageEventHandler<T extends EventTarget> = EventHandler<MessageEvent, T>;
+
+  /** @deprecated DO NOT USE, WILL BE REMOVED SOON */
+  type AttributeNames =
+  |'oncopy'
+  |'oncut'
+  |'onpaste'
+  |'oncompositionend'
+  |'oncompositionstart'
+  |'oncompositionupdate'
+  |'onfocus'
+  |'onfocusin'
+  |'onfocusout'
+  |'onblur'
+  |'onchange'
+  |'oninput'
+  |'onreset'
+  |'onsubmit'
+  |'oninvalid'
+  |'onbeforeinput'
+  |'onload'
+  |'onerror'
+  |'ontoggle'
+  |'onkeydown'
+  |'onkeypress'
+  |'onkeyup'
+  |'onabort'
+  |'oncanplay'
+  |'oncanplaythrough'
+  |'oncuechange'
+  |'ondurationchange'
+  |'onemptied'
+  |'onencrypted'
+  |'onended'
+  |'onloadeddata'
+  |'onloadedmetadata'
+  |'onloadstart'
+  |'onpause'
+  |'onplay'
+  |'onplaying'
+  |'onprogress'
+  |'onratechange'
+  |'onseeked'
+  |'onseeking'
+  |'onstalled'
+  |'onsuspend'
+  |'ontimeupdate'
+  |'onvolumechange'
+  |'onwaiting'
+  |'onauxclick'
+  |'onclick'
+  |'oncontextmenu'
+  |'ondblclick'
+  |'ondrag'
+  |'ondragend'
+  |'ondragenter'
+  |'ondragexit'
+  |'ondragleave'
+  |'ondragover'
+  |'ondragstart'
+  |'ondrop'
+  |'onmousedown'
+  |'onmouseenter'
+  |'onmouseleave'
+  |'onmousemove'
+  |'onmouseout'
+  |'onmouseover'
+  |'onmouseup'
+  |'onselect'
+  |'onselectionchange'
+  |'onselectstart'
+  |'ontouchcancel'
+  |'ontouchend'
+  |'ontouchmove'
+  |'ontouchstart'
+  |'ongotpointercapture'
+  |'onpointercancel'
+  |'onpointerdown'
+  |'onpointerenter'
+  |'onpointerleave'
+  |'onpointermove'
+  |'onpointerout'
+  |'onpointerover'
+  |'onpointerup'
+  |'onlostpointercapture'
+  |'onscroll'
+  |'onresize'
+  |'onwheel'
+  |'onanimationstart'
+  |'onanimationend'
+  |'onanimationiteration'
+  |'ontransitionstart'
+  |'ontransitionrun'
+  |'ontransitionend'
+  |'ontransitioncancel'
+  |'onoutrostart'
+  |'onoutroend'
+  |'onintrostart'
+  |'onintroend'
+  |'onmessage'
+  |'onmessageerror'
+  |'oncancel'
+  |'onclose'
+  |'onfullscreenchange'
+  |'onfullscreenerror'
+  |'class'
+  |'dataset'
+  |'accept'
+  |'acceptcharset'
+  |'accesskey'
+  |'action'
+  |'allow'
+  |'allowfullscreen'
+  |'allowtransparency'
+  |'allowpaymentrequest'
+  |'alt'
+  |'as'
+  |'async'
+  |'autocomplete'
+  |'autofocus'
+  |'autoplay'
+  |'capture'
+  |'cellpadding'
+  |'cellspacing'
+  |'charset'
+  |'challenge'
+  |'checked'
+  |'cite'
+  |'classid'
+  |'cols'
+  |'colspan'
+  |'content'
+  |'contenteditable'
+  |'innerHTML'
+  |'textContent'
+  |'contextmenu'
+  |'controls'
+  |'coords'
+  |'crossorigin'
+  |'currenttime'
+  |'decoding'
+  |'data'
+  |'datetime'
+  |'default'
+  |'defaultmuted'
+  |'defaultplaybackrate'
+  |'defer'
+  |'dir'
+  |'dirname'
+  |'disabled'
+  |'download'
+  |'draggable'
+  |'enctype'
+  |'enterkeyhint'
+  |'for'
+  |'form'
+  |'formaction'
+  |'formenctype'
+  |'formmethod'
+  |'formnovalidate'
+  |'formtarget'
+  |'frameborder'
+  |'headers'
+  |'height'
+  |'hidden'
+  |'high'
+  |'href'
+  |'hreflang'
+  |'htmlfor'
+  |'httpequiv'
+  |'id'
+  |'inputmode'
+  |'integrity'
+  |'is'
+  |'ismap'
+  |'keyparams'
+  |'keytype'
+  |'kind'
+  |'label'
+  |'lang'
+  |'list'
+  |'loading'
+  |'loop'
+  |'low'
+  |'manifest'
+  |'marginheight'
+  |'marginwidth'
+  |'max'
+  |'maxlength'
+  |'media'
+  |'mediagroup'
+  |'method'
+  |'min'
+  |'minlength'
+  |'multiple'
+  |'muted'
+  |'name'
+  |'nonce'
+  |'novalidate'
+  |'open'
+  |'optimum'
+  |'part'
+  |'pattern'
+  |'placeholder'
+  |'playsinline'
+  |'ping'
+  |'poster'
+  |'preload'
+  |'radiogroup'
+  |'readonly'
+  |'referrerpolicy'
+  |'rel'
+  |'required'
+  |'reversed'
+  |'role'
+  |'rows'
+  |'rowspan'
+  |'sandbox'
+  |'scope'
+  |'scoped'
+  |'scrolling'
+  |'seamless'
+  |'selected'
+  |'shape'
+  |'size'
+  |'sizes'
+  |'slot'
+  |'span'
+  |'spellcheck'
+  |'src'
+  |'srcdoc'
+  |'srclang'
+  |'srcset'
+  |'start'
+  |'step'
+  |'style'
+  |'summary'
+  |'tabindex'
+  |'target'
+  |'title'
+  |'translate'
+  |'type'
+  |'usemap'
+  |'value'
+  |'volume'
+  |'width'
+  |'wmode'
+  |'wrap'
+  |'about'
+  |'datatype'
+  |'inlist'
+  |'prefix'
+  |'property'
+  |'resource'
+  |'typeof'
+  |'vocab'
+  |'autocapitalize'
+  |'autocorrect'
+  |'autosave'
+  |'color'
+  |'controlslist'
+  |'inert'
+  |'itemprop'
+  |'itemscope'
+  |'itemtype'
+  |'itemid'
+  |'itemref'
+  |'results'
+  |'security'
+  |'unselectable';
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface DOMAttributes<T extends EventTarget> {
+    oncopy?: ClipboardEventHandler<T> | undefined | null;
+    oncut?: ClipboardEventHandler<T> | undefined | null;
+    onpaste?: ClipboardEventHandler<T> | undefined | null;
+    oncompositionend?: CompositionEventHandler<T> | undefined | null;
+    oncompositionstart?: CompositionEventHandler<T> | undefined | null;
+    oncompositionupdate?: CompositionEventHandler<T> | undefined | null;
+    onfocus?: FocusEventHandler<T> | undefined | null;
+    onfocusin?: FocusEventHandler<T> | undefined | null;
+    onfocusout?: FocusEventHandler<T> | undefined | null;
+    onblur?: FocusEventHandler<T> | undefined | null;
+    onchange?: FormEventHandler<T> | undefined | null;
+    oninput?: FormEventHandler<T> | undefined | null;
+    onreset?: FormEventHandler<T> | undefined | null;
+    onsubmit?: EventHandler<SubmitEvent, T> | undefined | null;
+    oninvalid?: EventHandler<Event, T> | undefined | null;
+    onbeforeinput?: EventHandler<InputEvent, T> | undefined | null;
+    onload?: EventHandler | undefined | null;
+    onerror?: EventHandler | undefined | null; // also a Media Event
+    ontoggle?: EventHandler<Event, T> | undefined | null;
+    onkeydown?: KeyboardEventHandler<T> | undefined | null;
+    onkeypress?: KeyboardEventHandler<T> | undefined | null;
+    onkeyup?: KeyboardEventHandler<T> | undefined | null;
+    onabort?: EventHandler<Event, T> | undefined | null;
+    oncanplay?: EventHandler<Event, T> | undefined | null;
+    oncanplaythrough?: EventHandler<Event, T> | undefined | null;
+    oncuechange?: EventHandler<Event, T> | undefined | null;
+    ondurationchange?: EventHandler<Event, T> | undefined | null;
+    onemptied?: EventHandler<Event, T> | undefined | null;
+    onencrypted?: EventHandler<Event, T> | undefined | null;
+    onended?: EventHandler<Event, T> | undefined | null;
+    onloadeddata?: EventHandler<Event, T> | undefined | null;
+    onloadedmetadata?: EventHandler<Event, T> | undefined | null;
+    onloadstart?: EventHandler<Event, T> | undefined | null;
+    onpause?: EventHandler<Event, T> | undefined | null;
+    onplay?: EventHandler<Event, T> | undefined | null;
+    onplaying?: EventHandler<Event, T> | undefined | null;
+    onprogress?: EventHandler<Event, T> | undefined | null;
+    onratechange?: EventHandler<Event, T> | undefined | null;
+    onseeked?: EventHandler<Event, T> | undefined | null;
+    onseeking?: EventHandler<Event, T> | undefined | null;
+    onstalled?: EventHandler<Event, T> | undefined | null;
+    onsuspend?: EventHandler<Event, T> | undefined | null;
+    ontimeupdate?: EventHandler<Event, T> | undefined | null;
+    onvolumechange?: EventHandler<Event, T> | undefined | null;
+    onwaiting?: EventHandler<Event, T> | undefined | null;
+    onauxclick?: MouseEventHandler<T> | undefined | null;
+    onclick?: MouseEventHandler<T> | undefined | null;
+    oncontextmenu?: MouseEventHandler<T> | undefined | null;
+    ondblclick?: MouseEventHandler<T> | undefined | null;
+    ondrag?: DragEventHandler<T> | undefined | null;
+    ondragend?: DragEventHandler<T> | undefined | null;
+    ondragenter?: DragEventHandler<T> | undefined | null;
+    ondragexit?: DragEventHandler<T> | undefined | null;
+    ondragleave?: DragEventHandler<T> | undefined | null;
+    ondragover?: DragEventHandler<T> | undefined | null;
+    ondragstart?: DragEventHandler<T> | undefined | null;
+    ondrop?: DragEventHandler<T> | undefined | null;
+    onmousedown?: MouseEventHandler<T> | undefined | null;
+    onmouseenter?: MouseEventHandler<T> | undefined | null;
+    onmouseleave?: MouseEventHandler<T> | undefined | null;
+    onmousemove?: MouseEventHandler<T> | undefined | null;
+    onmouseout?: MouseEventHandler<T> | undefined | null;
+    onmouseover?: MouseEventHandler<T> | undefined | null;
+    onmouseup?: MouseEventHandler<T> | undefined | null;
+    onselect?: EventHandler<Event, T> | undefined | null;
+    onselectionchange?: EventHandler<Event, T> | undefined | null;
+    onselectstart?: EventHandler<Event, T> | undefined | null;
+    ontouchcancel?: TouchEventHandler<T> | undefined | null;
+    ontouchend?: TouchEventHandler<T> | undefined | null;
+    ontouchmove?: TouchEventHandler<T> | undefined | null;
+    ontouchstart?: TouchEventHandler<T> | undefined | null;
+    ongotpointercapture?: PointerEventHandler<T> | undefined | null;
+    onpointercancel?: PointerEventHandler<T> | undefined | null;
+    onpointerdown?: PointerEventHandler<T> | undefined | null;
+    onpointerenter?: PointerEventHandler<T> | undefined | null;
+    onpointerleave?: PointerEventHandler<T> | undefined | null;
+    onpointermove?: PointerEventHandler<T> | undefined | null;
+    onpointerout?: PointerEventHandler<T> | undefined | null;
+    onpointerover?: PointerEventHandler<T> | undefined | null;
+    onpointerup?: PointerEventHandler<T> | undefined | null;
+    onlostpointercapture?: PointerEventHandler<T> | undefined | null;
+    onscroll?: UIEventHandler<T> | undefined | null;
+    onresize?: UIEventHandler<T> | undefined | null;
+    onwheel?: WheelEventHandler<T> | undefined | null;
+    onanimationstart?: AnimationEventHandler<T> | undefined | null;
+    onanimationend?: AnimationEventHandler<T> | undefined | null;
+    onanimationiteration?: AnimationEventHandler<T> | undefined | null;
+    ontransitionstart?: TransitionEventHandler<T> | undefined | null;
+    ontransitionrun?: TransitionEventHandler<T> | undefined | null;
+    ontransitionend?: TransitionEventHandler<T> | undefined | null;
+    ontransitioncancel?: TransitionEventHandler<T> | undefined | null;
+    onoutrostart?: EventHandler<CustomEvent<null>, T> | undefined | null;
+    onoutroend?: EventHandler<CustomEvent<null>, T> | undefined | null;
+    onintrostart?: EventHandler<CustomEvent<null>, T> | undefined | null;
+    onintroend?: EventHandler<CustomEvent<null>, T> | undefined | null;
+    onmessage?: MessageEventHandler<T> | undefined | null;
+    onmessageerror?: MessageEventHandler<T> | undefined | null;
+    oncancel?: EventHandler<Event, T> | undefined | null;
+    onclose?: EventHandler<Event, T> | undefined | null;
+    onfullscreenchange?: EventHandler<Event, T> | undefined | null;
+    onfullscreenerror?: EventHandler<Event, T> | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface AriaAttributes {
+      'aria-activedescendant'?: string | undefined | null;
+      'aria-atomic'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both' | undefined | null;
+      'aria-busy'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-checked'?: boolean | 'false' | 'mixed' | 'true' | undefined | null;
+      'aria-colcount'?: number | undefined | null;
+      'aria-colindex'?: number | undefined | null;
+      'aria-colspan'?: number | undefined | null;
+      'aria-controls'?: string | undefined | null;
+      'aria-current'?: boolean | 'false' | 'true' | 'page' | 'step' | 'location' | 'date' | 'time' | undefined | null;
+      'aria-describedby'?: string | undefined | null;
+      'aria-details'?: string | undefined | null;
+      'aria-disabled'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-dropeffect'?: 'none' | 'copy' | 'execute' | 'link' | 'move' | 'popup' | undefined | null;
+      'aria-errormessage'?: string | undefined | null;
+      'aria-expanded'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-flowto'?: string | undefined | null;
+      'aria-grabbed'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-haspopup'?: boolean | 'false' | 'true' | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | undefined | null;
+      'aria-hidden'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling' | undefined | null;
+      'aria-keyshortcuts'?: string | undefined | null;
+      'aria-label'?: string | undefined | null;
+      'aria-labelledby'?: string | undefined | null;
+      'aria-level'?: number | undefined | null;
+      'aria-live'?: 'off' | 'assertive' | 'polite' | undefined | null;
+      'aria-modal'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-multiline'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-multiselectable'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-orientation'?: 'horizontal' | 'vertical' | undefined | null;
+      'aria-owns'?: string | undefined | null;
+      'aria-placeholder'?: string | undefined | null;
+      'aria-posinset'?: number | undefined | null;
+      'aria-pressed'?: boolean | 'false' | 'mixed' | 'true' | undefined | null;
+      'aria-readonly'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-relevant'?: 'additions' | 'additions removals' | 'additions text' | 'all' | 'removals' | 'removals additions' | 'removals text' | 'text' | 'text additions' | 'text removals' | undefined | null;
+      'aria-required'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-roledescription'?: string | undefined | null;
+      'aria-rowcount'?: number | undefined | null;
+      'aria-rowindex'?: number | undefined | null;
+      'aria-rowspan'?: number | undefined | null;
+      'aria-selected'?: boolean | 'false' | 'true' | undefined | null;
+      'aria-setsize'?: number | undefined | null;
+      'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other' | undefined | null;
+      'aria-valuemax'?: number | undefined | null;
+      'aria-valuemin'?: number | undefined | null;
+      'aria-valuenow'?: number | undefined | null;
+      'aria-valuetext'?: string | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface HTMLAttributes<T extends EventTarget> extends AriaAttributes, DOMAttributes<T> {
+    class?: string | undefined | null;
+    dataset?: object | undefined | null;
+    accept?: string | undefined | null;
+    acceptcharset?: string | undefined | null;
+    accesskey?: string | undefined | null;
+    action?: string | undefined | null;
+    allow?: string | undefined | null;
+    allowfullscreen?: boolean | undefined | null;
+    allowtransparency?: boolean | undefined | null;
+    allowpaymentrequest?: boolean | undefined | null;
+    alt?: string | undefined | null;
+    as?: string | undefined | null;
+    async?: boolean | undefined | null;
+    autocomplete?: string | undefined | null;
+    autofocus?: boolean | undefined | null;
+    autoplay?: boolean | undefined | null;
+    capture?: 'environment' | 'user' | boolean | undefined | null;
+    cellpadding?: number | string | undefined | null;
+    cellspacing?: number | string | undefined | null;
+    charset?: string | undefined | null;
+    challenge?: string | undefined | null;
+    checked?: boolean | undefined | null;
+    cite?: string | undefined | null;
+    classid?: string | undefined | null;
+    cols?: number | undefined | null;
+    colspan?: number | undefined | null;
+    content?: string | undefined | null;
+    contenteditable?: 'true' | 'false' | boolean | undefined | null;
+    innerHTML?: string | undefined | null;
+    textContent?: string | undefined | null;
+    contextmenu?: string | undefined | null;
+    controls?: boolean | undefined | null;
+    coords?: string | undefined | null;
+    crossorigin?: string | undefined | null;
+    currenttime?: number | undefined | null;
+    decoding?: 'async' | 'sync' | 'auto' | undefined | null;
+    data?: string | undefined | null;
+    datetime?: string | undefined | null;
+    default?: boolean | undefined | null;
+    defaultmuted?: boolean | undefined | null;
+    defaultplaybackrate?: number | undefined | null;
+    defer?: boolean | undefined | null;
+    dir?: string | undefined | null;
+    dirname?: string | undefined | null;
+    disabled?: boolean | undefined | null;
+    download?: any | undefined | null;
+    draggable?: boolean | 'true' | 'false' | undefined | null;
+    enctype?: string | undefined | null;
+    enterkeyhint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send' | undefined | null;
+    for?: string | undefined | null;
+    form?: string | undefined | null;
+    formaction?: string | undefined | null;
+    formenctype?: string | undefined | null;
+    formmethod?: string | undefined | null;
+    formnovalidate?: boolean | undefined | null;
+    formtarget?: string | undefined | null;
+    frameborder?: number | string | undefined | null;
+    headers?: string | undefined | null;
+    height?: number | string | undefined | null;
+    hidden?: boolean | undefined | null;
+    high?: number | undefined | null;
+    href?: string | undefined | null;
+    hreflang?: string | undefined | null;
+    htmlfor?: string | undefined | null;
+    httpequiv?: string | undefined | null;
+    id?: string | undefined | null;
+    inputmode?: string | undefined | null;
+    integrity?: string | undefined | null;
+    is?: string | undefined | null;
+    ismap?: boolean | undefined | null;
+    keyparams?: string | undefined | null;
+    keytype?: string | undefined | null;
+    kind?: string | undefined | null;
+    label?: string | undefined | null;
+    lang?: string | undefined | null;
+    list?: string | undefined | null;
+    loading?: string | undefined | null;
+    loop?: boolean | undefined | null;
+    low?: number | undefined | null;
+    manifest?: string | undefined | null;
+    marginheight?: number | undefined | null;
+    marginwidth?: number | undefined | null;
+    max?: number | string | undefined | null;
+    maxlength?: number | undefined | null;
+    media?: string | undefined | null;
+    mediagroup?: string | undefined | null;
+    method?: string | undefined | null;
+    min?: number | string | undefined | null;
+    minlength?: number | undefined | null;
+    multiple?: boolean | undefined | null;
+    muted?: boolean | undefined | null;
+    name?: string | undefined | null;
+    nonce?: string | undefined | null;
+    novalidate?: boolean | undefined | null;
+    open?: boolean | undefined | null;
+    optimum?: number | undefined | null;
+    part?: string | undefined | null;
+    pattern?: string | undefined | null;
+    placeholder?: string | undefined | null;
+    playsinline?: boolean | undefined | null;
+    ping?: string | undefined | null;
+    poster?: string | undefined | null;
+    preload?: string | undefined | null;
+    radiogroup?: string | undefined | null;
+    readonly?: boolean | undefined | null;
+    referrerpolicy?: string | undefined | null;
+    rel?: string | undefined | null;
+    required?: boolean | undefined | null;
+    reversed?: boolean | undefined | null;
+    role?: string | undefined | null;
+    rows?: number | undefined | null;
+    rowspan?: number | undefined | null;
+    sandbox?: string | undefined | null;
+    scope?: string | undefined | null;
+    scoped?: boolean | undefined | null;
+    scrolling?: string | undefined | null;
+    seamless?: boolean | undefined | null;
+    selected?: boolean | undefined | null;
+    shape?: string | undefined | null;
+    size?: number | undefined | null;
+    sizes?: string | undefined | null;
+    slot?: string | undefined | null;
+    span?: number | undefined | null;
+    spellcheck?: boolean | 'true' | 'false' | undefined | null;
+    src?: string | undefined | null;
+    srcdoc?: string | undefined | null;
+    srclang?: string | undefined | null;
+    srcset?: string | undefined | null;
+    start?: number | undefined | null;
+    step?: number | string | undefined | null;
+    style?: string | undefined | null;
+    summary?: string | undefined | null;
+    tabindex?: number | undefined | null;
+    target?: string | undefined | null;
+    title?: string | undefined | null;
+    translate?: "yes" | "no" | "" | undefined | null;
+    type?: string | undefined | null;
+    usemap?: string | undefined | null;
+    value?: any | undefined | null;
+    volume?: number | undefined | null;
+    width?: number | string | undefined | null;
+    wmode?: string | undefined | null;
+    wrap?: string | undefined | null;
+    about?: string | undefined | null;
+    datatype?: string | undefined | null;
+    inlist?: any | undefined | null;
+    prefix?: string | undefined | null;
+    property?: string | undefined | null;
+    resource?: string | undefined | null;
+    typeof?: string | undefined | null;
+    vocab?: string | undefined | null;
+    autocapitalize?: string | undefined | null;
+    autocorrect?: string | undefined | null;
+    autosave?: string | undefined | null;
+    color?: string | undefined | null;
+    controlslist?: 'nodownload' | 'nofullscreen' | 'noplaybackrate' | 'noremoteplayback';
+    inert?: boolean | undefined | null;
+    itemprop?: string | undefined | null;
+    itemscope?: boolean | undefined | null;
+    itemtype?: string | undefined | null;
+    itemid?: string | undefined | null;
+    itemref?: string | undefined | null;
+    results?: number | undefined | null;
+    security?: string | undefined | null;
+    unselectable?: boolean | undefined | null;
+
+    'data-sveltekit-keepfocus'?: true | '' | 'off' | undefined | null;
+    'data-sveltekit-noscroll'?: true | '' | 'off' | undefined | null;
+    'data-sveltekit-preload-code'?: true | '' | 'eager' | 'viewport' | 'hover' | 'tap' | 'off' | undefined | null;
+    'data-sveltekit-preload-data'?: true | '' | 'hover' | 'tap' | 'off' | undefined | null;
+    'data-sveltekit-reload'?: true | '' | 'off' | undefined | null;
+    'data-sveltekit-replacestate'?: true | '' | 'off' | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SVGAttributes<T extends EventTarget> extends AriaAttributes, DOMAttributes<T> {
+    className?: string | undefined | null;
+    class?: string | undefined | null;
+    color?: string | undefined | null;
+    height?: number | string | undefined | null;
+    id?: string | undefined | null;
+    lang?: string | undefined | null;
+    max?: number | string | undefined | null;
+    media?: string | undefined | null;
+    method?: string | undefined | null;
+    min?: number | string | undefined | null;
+    name?: string | undefined | null;
+    style?: string | undefined | null;
+    target?: string | undefined | null;
+    type?: string | undefined | null;
+    width?: number | string | undefined | null;
+    role?: string | undefined | null;
+    tabindex?: number | undefined | null;
+    crossorigin?: 'anonymous' | 'use-credentials' | '' | undefined | null;
+    'accent-height'?: number | string | undefined | null;
+    accumulate?: 'none' | 'sum' | undefined | null;
+    additive?: 'replace' | 'sum' | undefined | null;
+    'alignment-baseline'?: 'auto' | 'baseline' | 'before-edge' | 'text-before-edge' | 'middle' |
+      'central' | 'after-edge' | 'text-after-edge' | 'ideographic' | 'alphabetic' | 'hanging' |
+      'mathematical' | 'inherit' | undefined | null;
+    allowReorder?: 'no' | 'yes' | undefined | null;
+    alphabetic?: number | string | undefined | null;
+    amplitude?: number | string | undefined | null;
+    'arabic-form'?: 'initial' | 'medial' | 'terminal' | 'isolated' | undefined | null;
+    ascent?: number | string | undefined | null;
+    attributeName?: string | undefined | null;
+    attributeType?: string | undefined | null;
+    autoReverse?: number | string | undefined | null;
+    azimuth?: number | string | undefined | null;
+    baseFrequency?: number | string | undefined | null;
+    'baseline-shift'?: number | string | undefined | null;
+    baseProfile?: number | string | undefined | null;
+    bbox?: number | string | undefined | null;
+    begin?: number | string | undefined | null;
+    bias?: number | string | undefined | null;
+    by?: number | string | undefined | null;
+    calcMode?: number | string | undefined | null;
+    'cap-height'?: number | string | undefined | null;
+    clip?: number | string | undefined | null;
+    'clip-path'?: string | undefined | null;
+    clipPathUnits?: number | string | undefined | null;
+    'clip-rule'?: number | string | undefined | null;
+    'color-interpolation'?: number | string | undefined | null;
+    'color-interpolation-filters'?: 'auto' | 'sRGB' | 'linearRGB' | 'inherit' | undefined | null;
+    'color-profile'?: number | string | undefined | null;
+    'color-rendering'?: number | string | undefined | null;
+    contentScriptType?: number | string | undefined | null;
+    contentStyleType?: number | string | undefined | null;
+    cursor?: number | string | undefined | null;
+    cx?: number | string | undefined | null;
+    cy?: number | string | undefined | null;
+    d?: string | undefined | null;
+    decelerate?: number | string | undefined | null;
+    descent?: number | string | undefined | null;
+    diffuseConstant?: number | string | undefined | null;
+    direction?: number | string | undefined | null;
+    display?: number | string | undefined | null;
+    divisor?: number | string | undefined | null;
+    'dominant-baseline'?: number | string | undefined | null;
+    dur?: number | string | undefined | null;
+    dx?: number | string | undefined | null;
+    dy?: number | string | undefined | null;
+    edgeMode?: number | string | undefined | null;
+    elevation?: number | string | undefined | null;
+    'enable-background'?: number | string | undefined | null;
+    end?: number | string | undefined | null;
+    exponent?: number | string | undefined | null;
+    externalResourcesRequired?: number | string | undefined | null;
+    fill?: string | undefined | null;
+    'fill-opacity'?: number | string | undefined | null;
+    'fill-rule'?: 'nonzero' | 'evenodd' | 'inherit' | undefined | null;
+    filter?: string | undefined | null;
+    filterRes?: number | string | undefined | null;
+    filterUnits?: number | string | undefined | null;
+    'flood-color'?: number | string | undefined | null;
+    'flood-opacity'?: number | string | undefined | null;
+    focusable?: number | string | undefined | null;
+    'font-family'?: string | undefined | null;
+    'font-size'?: number | string | undefined | null;
+    'font-size-adjust'?: number | string | undefined | null;
+    'font-stretch'?: number | string | undefined | null;
+    'font-style'?: number | string | undefined | null;
+    'font-variant'?: number | string | undefined | null;
+    'font-weight'?: number | string | undefined | null;
+    format?: number | string | undefined | null;
+    from?: number | string | undefined | null;
+    fx?: number | string | undefined | null;
+    fy?: number | string | undefined | null;
+    g1?: number | string | undefined | null;
+    g2?: number | string | undefined | null;
+    'glyph-name'?: number | string | undefined | null;
+    'glyph-orientation-horizontal'?: number | string | undefined | null;
+    'glyph-orientation-vertical'?: number | string | undefined | null;
+    glyphRef?: number | string | undefined | null;
+    gradientTransform?: string | undefined | null;
+    gradientUnits?: string | undefined | null;
+    hanging?: number | string | undefined | null;
+    href?: string | undefined | null;
+    'horiz-adv-x'?: number | string | undefined | null;
+    'horiz-origin-x'?: number | string | undefined | null;
+    ideographic?: number | string | undefined | null;
+    'image-rendering'?: number | string | undefined | null;
+    in2?: number | string | undefined | null;
+    in?: string | undefined | null;
+    intercept?: number | string | undefined | null;
+    k1?: number | string | undefined | null;
+    k2?: number | string | undefined | null;
+    k3?: number | string | undefined | null;
+    k4?: number | string | undefined | null;
+    k?: number | string | undefined | null;
+    kernelMatrix?: number | string | undefined | null;
+    kernelUnitLength?: number | string | undefined | null;
+    kerning?: number | string | undefined | null;
+    keyPoints?: number | string | undefined | null;
+    keySplines?: number | string | undefined | null;
+    keyTimes?: number | string | undefined | null;
+    lengthAdjust?: number | string | undefined | null;
+    'letter-spacing'?: number | string | undefined | null;
+    'lighting-color'?: number | string | undefined | null;
+    limitingConeAngle?: number | string | undefined | null;
+    local?: number | string | undefined | null;
+    'marker-end'?: string | undefined | null;
+    markerHeight?: number | string | undefined | null;
+    'marker-mid'?: string | undefined | null;
+    'marker-start'?: string | undefined | null;
+    markerUnits?: number | string | undefined | null;
+    markerWidth?: number | string | undefined | null;
+    mask?: string | undefined | null;
+    maskContentUnits?: number | string | undefined | null;
+    maskUnits?: number | string | undefined | null;
+    mathematical?: number | string | undefined | null;
+    mode?: number | string | undefined | null;
+    numOctaves?: number | string | undefined | null;
+    offset?: number | string | undefined | null;
+    opacity?: number | string | undefined | null;
+    operator?: number | string | undefined | null;
+    order?: number | string | undefined | null;
+    orient?: number | string | undefined | null;
+    orientation?: number | string | undefined | null;
+    origin?: number | string | undefined | null;
+    overflow?: number | string | undefined | null;
+    'overline-position'?: number | string | undefined | null;
+    'overline-thickness'?: number | string | undefined | null;
+    'paint-order'?: number | string | undefined | null;
+    'panose-1'?: number | string | undefined | null;
+    path?: string | undefined | null;
+    pathLength?: number | string | undefined | null;
+    patternContentUnits?: string | undefined | null;
+    patternTransform?: number | string | undefined | null;
+    patternUnits?: string | undefined | null;
+    'pointer-events'?: number | string | undefined | null;
+    points?: string | undefined | null;
+    pointsAtX?: number | string | undefined | null;
+    pointsAtY?: number | string | undefined | null;
+    pointsAtZ?: number | string | undefined | null;
+    preserveAlpha?: number | string | undefined | null;
+    preserveAspectRatio?: string | undefined | null;
+    primitiveUnits?: number | string | undefined | null;
+    r?: number | string | undefined | null;
+    radius?: number | string | undefined | null;
+    refX?: number | string | undefined | null;
+    refY?: number | string | undefined | null;
+    'rendering-intent'?: number | string | undefined | null;
+    repeatCount?: number | string | undefined | null;
+    repeatDur?: number | string | undefined | null;
+    requiredExtensions?: number | string | undefined | null;
+    requiredFeatures?: number | string | undefined | null;
+    restart?: number | string | undefined | null;
+    result?: string | undefined | null;
+    rotate?: number | string | undefined | null;
+    rx?: number | string | undefined | null;
+    ry?: number | string | undefined | null;
+    scale?: number | string | undefined | null;
+    seed?: number | string | undefined | null;
+    'shape-rendering'?: number | string | undefined | null;
+    slope?: number | string | undefined | null;
+    spacing?: number | string | undefined | null;
+    specularConstant?: number | string | undefined | null;
+    specularExponent?: number | string | undefined | null;
+    speed?: number | string | undefined | null;
+    spreadMethod?: string | undefined | null;
+    startOffset?: number | string | undefined | null;
+    stdDeviation?: number | string | undefined | null;
+    stemh?: number | string | undefined | null;
+    stemv?: number | string | undefined | null;
+    stitchTiles?: number | string | undefined | null;
+    'stop-color'?: string | undefined | null;
+    'stop-opacity'?: number | string | undefined | null;
+    'strikethrough-position'?: number | string | undefined | null;
+    'strikethrough-thickness'?: number | string | undefined | null;
+    string?: number | string | undefined | null;
+    stroke?: string | undefined | null;
+    'stroke-dasharray'?: string | number | undefined | null;
+    'stroke-dashoffset'?: string | number | undefined | null;
+    'stroke-linecap'?: 'butt' | 'round' | 'square' | 'inherit' | undefined | null;
+    'stroke-linejoin'?: 'miter' | 'round' | 'bevel' | 'inherit' | undefined | null;
+    'stroke-miterlimit'?: string | undefined | null;
+    'stroke-opacity'?: number | string | undefined | null;
+    'stroke-width'?: number | string | undefined | null;
+    surfaceScale?: number | string | undefined | null;
+    systemLanguage?: number | string | undefined | null;
+    tableValues?: number | string | undefined | null;
+    targetX?: number | string | undefined | null;
+    targetY?: number | string | undefined | null;
+    'text-anchor'?: string | undefined | null;
+    'text-decoration'?: number | string | undefined | null;
+    textLength?: number | string | undefined | null;
+    'text-rendering'?: number | string | undefined | null;
+    to?: number | string | undefined | null;
+    transform?: string | undefined | null;
+    u1?: number | string | undefined | null;
+    u2?: number | string | undefined | null;
+    'underline-position'?: number | string | undefined | null;
+    'underline-thickness'?: number | string | undefined | null;
+    unicode?: number | string | undefined | null;
+    'unicode-bidi'?: number | string | undefined | null;
+    'unicode-range'?: number | string | undefined | null;
+    'units-per-em'?: number | string | undefined | null;
+    'v-alphabetic'?: number | string | undefined | null;
+    values?: string | undefined | null;
+    'vector-effect'?: number | string | undefined | null;
+    version?: string | undefined | null;
+    'vert-adv-y'?: number | string | undefined | null;
+    'vert-origin-x'?: number | string | undefined | null;
+    'vert-origin-y'?: number | string | undefined | null;
+    'v-hanging'?: number | string | undefined | null;
+    'v-ideographic'?: number | string | undefined | null;
+    viewBox?: string | undefined | null;
+    viewTarget?: number | string | undefined | null;
+    visibility?: number | string | undefined | null;
+    'v-mathematical'?: number | string | undefined | null;
+    widths?: number | string | undefined | null;
+    'word-spacing'?: number | string | undefined | null;
+    'writing-mode'?: number | string | undefined | null;
+    x1?: number | string | undefined | null;
+    x2?: number | string | undefined | null;
+    x?: number | string | undefined | null;
+    xChannelSelector?: string | undefined | null;
+    'x-height'?: number | string | undefined | null;
+    xlinkActuate?: string | undefined | null;
+    xlinkArcrole?: string | undefined | null;
+    xlinkHref?: string | undefined | null;
+    xlinkRole?: string | undefined | null;
+    xlinkShow?: string | undefined | null;
+    xlinkTitle?: string | undefined | null;
+    xlinkType?: string | undefined | null;
+    xmlBase?: string | undefined | null;
+    xmlLang?: string | undefined | null;
+    xmlns?: string | undefined | null;
+    xmlnsXlink?: string | undefined | null;
+    xmlSpace?: string | undefined | null;
+    y1?: number | string | undefined | null;
+    y2?: number | string | undefined | null;
+    y?: number | string | undefined | null;
+    yChannelSelector?: string | undefined | null;
+    z?: number | string | undefined | null;
+    zoomAndPan?: string | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface HTMLProps<T extends EventTarget> extends HTMLAttributes<T> {}
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SVGProps<T extends EventTarget> extends SVGAttributes<T> {}
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SvelteInputProps extends HTMLProps<HTMLInputElement> {
+    group?: any | undefined | null;
+    files?: FileList | undefined | null;
+    indeterminate?: boolean | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SvelteWindowProps  {
+    readonly innerWidth?: Window['innerWidth'] | undefined | null;
+    readonly innerHeight?: Window['innerHeight'] | undefined | null;
+    readonly outerWidth?: Window['outerWidth'] | undefined | null;
+    readonly outerHeight?: Window['outerHeight'] | undefined | null;
+    scrollX?: Window['scrollX'] | undefined | null;
+    scrollY?: Window['scrollY'] | undefined | null;
+    readonly online?: Window['navigator']['onLine'] | undefined | null;
+
+    // Transformed from on:sveltekit:xy
+    'onsveltekit:start'?: EventHandler<CustomEvent, Window> | undefined | null;
+    'onsveltekit:navigation-start'?: EventHandler<CustomEvent, Window> | undefined | null;
+    'onsveltekit:navigation-end'?: EventHandler<CustomEvent, Window> | undefined | null;
+
+    ondevicelight?: EventHandler<Event, Window> | undefined | null;
+    onbeforeinstallprompt?: EventHandler<Event, Window> | undefined | null;
+    ondeviceproximity?: EventHandler<Event, Window> | undefined | null;
+    onpaint?: EventHandler<Event, Window> | undefined | null;
+    onuserproximity?: EventHandler<Event, Window> | undefined | null;
+    onbeforeprint?: EventHandler<Event, Window> | undefined | null;
+    onafterprint?: EventHandler<Event, Window> | undefined | null;
+    onlanguagechange?: EventHandler<Event, Window> | undefined | null;
+    onorientationchange?: EventHandler<Event, Window> | undefined | null;
+    onmessage?: EventHandler<MessageEvent, Window> | undefined | null;
+    onmessageerror?: EventHandler<MessageEvent, Window> | undefined | null;
+    onoffline?: EventHandler<Event, Window> | undefined | null;
+    ononline?: EventHandler<Event, Window> | undefined | null;
+    onbeforeunload?: EventHandler<BeforeUnloadEvent, Window> | undefined | null;
+    onunload?: EventHandler<Event, Window> | undefined | null;
+    onstorage?: EventHandler<StorageEvent, Window> | undefined | null;
+    onhashchange?: EventHandler<HashChangeEvent, Window> | undefined | null;
+    onpagehide?: EventHandler<PageTransitionEvent, Window> | undefined | null;
+    onpageshow?: EventHandler<PageTransitionEvent, Window> | undefined | null;
+    onpopstate?: EventHandler<PopStateEvent, Window> | undefined | null;
+    ondevicemotion?: EventHandler<DeviceMotionEvent> | undefined | null;
+    ondeviceorientation?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
+    ondeviceorientationabsolute?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
+    onunhandledrejection?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
+    onrejectionhandled?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SapperAnchorProps {
+      // transformed from sapper:noscroll so it should be camel case
+      sapperNoscroll?: true | undefined | null;
+      sapperPrefetch?: true | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SvelteMediaTimeRange {
+      start: number;
+      end: number;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SvelteMediaProps {
+      readonly duration?: number | undefined | null;
+      readonly buffered?: SvelteMediaTimeRange[] | undefined | null;
+      readonly played?: SvelteMediaTimeRange[] | undefined | null;
+      readonly seekable?: SvelteMediaTimeRange[] | undefined | null;
+      readonly seeking?: boolean | undefined | null;
+      readonly ended?: boolean | undefined | null;
+
+      /**
+       * the current playback time in the video, in seconds
+       */
+      currentTime?: number | undefined | null;
+      /**
+       * the current playback time in the video, in seconds
+       */
+      currenttime?: number | undefined | null;
+      // Doesn't work when used as HTML Attribute
+      /**
+       * how fast or slow to play the video, where 1 is 'normal'
+       */
+      playbackRate?: number | undefined | null;
+
+      paused?: boolean | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface SvelteVideoProps extends SvelteMediaProps {
+      // Binding only, don't need lowercase variant
+      readonly videoWidth?: number | undefined | null;
+      readonly videoHeight?: number | undefined | null;
+  }
+
+  /**
+   * @deprecated use the types from `svelte/elements` instead
+   * For more info see https://github.com/sveltejs/language-tools/blob/master/docs/preprocessors/typescript.md#im-getting-deprecation-warnings-for-sveltejsx--i-want-to-migrate-to-the-new-typings
+   */
+  interface IntrinsicElements {
+    // HTML
+    a: HTMLProps<HTMLAnchorElement> & SapperAnchorProps;
+    abbr: HTMLProps<HTMLElement>;
+    address: HTMLProps<HTMLElement>;
+    area: HTMLProps<HTMLAreaElement>;
+    article: HTMLProps<HTMLElement>;
+    aside: HTMLProps<HTMLElement>;
+    audio: HTMLProps<HTMLAudioElement> & SvelteMediaProps;
+    b: HTMLProps<HTMLElement>;
+    base: HTMLProps<HTMLBaseElement>;
+    bdi: HTMLProps<HTMLElement>;
+    bdo: HTMLProps<HTMLElement>;
+    big: HTMLProps<HTMLElement>;
+    blockquote: HTMLProps<HTMLElement>;
+    body: HTMLProps<HTMLBodyElement>;
+    br: HTMLProps<HTMLBRElement>;
+    button: HTMLProps<HTMLButtonElement>;
+    canvas: HTMLProps<HTMLCanvasElement>;
+    caption: HTMLProps<HTMLElement>;
+    cite: HTMLProps<HTMLElement>;
+    code: HTMLProps<HTMLElement>;
+    col: HTMLProps<HTMLTableColElement>;
+    colgroup: HTMLProps<HTMLTableColElement>;
+    data: HTMLProps<HTMLElement>;
+    datalist: HTMLProps<HTMLDataListElement>;
+    dd: HTMLProps<HTMLElement>;
+    del: HTMLProps<HTMLElement>;
+    details: HTMLProps<HTMLElement>;
+    dfn: HTMLProps<HTMLElement>;
+    dialog: HTMLProps<HTMLElement>;
+    div: HTMLProps<HTMLDivElement>;
+    dl: HTMLProps<HTMLDListElement>;
+    dt: HTMLProps<HTMLElement>;
+    em: HTMLProps<HTMLElement>;
+    embed: HTMLProps<HTMLEmbedElement>;
+    fieldset: HTMLProps<HTMLFieldSetElement>;
+    figcaption: HTMLProps<HTMLElement>;
+    figure: HTMLProps<HTMLElement>;
+    footer: HTMLProps<HTMLElement>;
+    form: HTMLProps<HTMLFormElement>;
+    h1: HTMLProps<HTMLHeadingElement>;
+    h2: HTMLProps<HTMLHeadingElement>;
+    h3: HTMLProps<HTMLHeadingElement>;
+    h4: HTMLProps<HTMLHeadingElement>;
+    h5: HTMLProps<HTMLHeadingElement>;
+    h6: HTMLProps<HTMLHeadingElement>;
+    head: HTMLProps<HTMLHeadElement>;
+    header: HTMLProps<HTMLElement>;
+    hgroup: HTMLProps<HTMLElement>;
+    hr: HTMLProps<HTMLHRElement>;
+    html: HTMLProps<HTMLHtmlElement>;
+    i: HTMLProps<HTMLElement>;
+    iframe: HTMLProps<HTMLIFrameElement>;
+    img: HTMLProps<HTMLImageElement>;
+    input: SvelteInputProps;
+    ins: HTMLProps<HTMLModElement>;
+    kbd: HTMLProps<HTMLElement>;
+    keygen: HTMLProps<HTMLElement>;
+    label: HTMLProps<HTMLLabelElement>;
+    legend: HTMLProps<HTMLLegendElement>;
+    li: HTMLProps<HTMLLIElement>;
+    link: HTMLProps<HTMLLinkElement>;
+    main: HTMLProps<HTMLElement>;
+    map: HTMLProps<HTMLMapElement>;
+    mark: HTMLProps<HTMLElement>;
+    menu: HTMLProps<HTMLElement>;
+    menuitem: HTMLProps<HTMLElement>;
+    meta: HTMLProps<HTMLMetaElement>;
+    meter: HTMLProps<HTMLElement>;
+    nav: HTMLProps<HTMLElement>;
+    noindex: HTMLProps<HTMLElement>;
+    noscript: HTMLProps<HTMLElement>;
+    object: HTMLProps<HTMLObjectElement>;
+    ol: HTMLProps<HTMLOListElement>;
+    optgroup: HTMLProps<HTMLOptGroupElement>;
+    option: HTMLProps<HTMLOptionElement>;
+    output: HTMLProps<HTMLElement>;
+    p: HTMLProps<HTMLParagraphElement>;
+    param: HTMLProps<HTMLParamElement>;
+    picture: HTMLProps<HTMLElement>;
+    pre: HTMLProps<HTMLPreElement>;
+    progress: HTMLProps<HTMLProgressElement>;
+    q: HTMLProps<HTMLQuoteElement>;
+    rp: HTMLProps<HTMLElement>;
+    rt: HTMLProps<HTMLElement>;
+    ruby: HTMLProps<HTMLElement>;
+    s: HTMLProps<HTMLElement>;
+    samp: HTMLProps<HTMLElement>;
+    script: HTMLProps<HTMLElement>;
+    section: HTMLProps<HTMLElement>;
+    select: HTMLProps<HTMLSelectElement>;
+    small: HTMLProps<HTMLElement>;
+    source: HTMLProps<HTMLSourceElement>;
+    span: HTMLProps<HTMLSpanElement>;
+    strong: HTMLProps<HTMLElement>;
+    style: HTMLProps<HTMLStyleElement>;
+    sub: HTMLProps<HTMLElement>;
+    summary: HTMLProps<HTMLElement>;
+    sup: HTMLProps<HTMLElement>;
+    table: HTMLProps<HTMLTableElement>;
+    tbody: HTMLProps<HTMLTableSectionElement>;
+    td: HTMLProps<HTMLTableDataCellElement>;
+    textarea: HTMLProps<HTMLTextAreaElement>;
+    tfoot: HTMLProps<HTMLTableSectionElement>;
+    th: HTMLProps<HTMLTableHeaderCellElement>;
+    thead: HTMLProps<HTMLTableSectionElement>;
+    time: HTMLProps<HTMLElement>;
+    title: HTMLProps<HTMLTitleElement>;
+    tr: HTMLProps<HTMLTableRowElement>;
+    track: HTMLProps<HTMLTrackElement>;
+    u: HTMLProps<HTMLElement>;
+    ul: HTMLProps<HTMLUListElement>;
+    var: HTMLProps<HTMLElement>;
+    video: HTMLProps<HTMLVideoElement> & SvelteVideoProps;
+    wbr: HTMLProps<HTMLElement>;
+
+    svg: SVGProps<SVGSVGElement>;
+
+    animate: SVGProps<SVGElement>; // @TODO: It is SVGAnimateElement but not in dom.d.ts for now.
+    circle: SVGProps<SVGCircleElement>;
+    clipPath: SVGProps<SVGClipPathElement>;
+    defs: SVGProps<SVGDefsElement>;
+    desc: SVGProps<SVGDescElement>;
+    ellipse: SVGProps<SVGEllipseElement>;
+    feBlend: SVGProps<SVGFEBlendElement>;
+    feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
+    feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
+    feComposite: SVGProps<SVGFECompositeElement>;
+    feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
+    feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
+    feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
+    feDistantLight: SVGProps<SVGFEDistantLightElement>;
+    feFlood: SVGProps<SVGFEFloodElement>;
+    feFuncA: SVGProps<SVGFEFuncAElement>;
+    feFuncB: SVGProps<SVGFEFuncBElement>;
+    feFuncG: SVGProps<SVGFEFuncGElement>;
+    feFuncR: SVGProps<SVGFEFuncRElement>;
+    feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
+    feImage: SVGProps<SVGFEImageElement>;
+    feMerge: SVGProps<SVGFEMergeElement>;
+    feMergeNode: SVGProps<SVGFEMergeNodeElement>;
+    feMorphology: SVGProps<SVGFEMorphologyElement>;
+    feOffset: SVGProps<SVGFEOffsetElement>;
+    fePointLight: SVGProps<SVGFEPointLightElement>;
+    feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
+    feSpotLight: SVGProps<SVGFESpotLightElement>;
+    feTile: SVGProps<SVGFETileElement>;
+    feTurbulence: SVGProps<SVGFETurbulenceElement>;
+    filter: SVGProps<SVGFilterElement>;
+    foreignObject: SVGProps<SVGForeignObjectElement>;
+    g: SVGProps<SVGGElement>;
+    image: SVGProps<SVGImageElement>;
+    line: SVGProps<SVGLineElement>;
+    linearGradient: SVGProps<SVGLinearGradientElement>;
+    marker: SVGProps<SVGMarkerElement>;
+    mask: SVGProps<SVGMaskElement>;
+    metadata: SVGProps<SVGMetadataElement>;
+    path: SVGProps<SVGPathElement>;
+    pattern: SVGProps<SVGPatternElement>;
+    polygon: SVGProps<SVGPolygonElement>;
+    polyline: SVGProps<SVGPolylineElement>;
+    radialGradient: SVGProps<SVGRadialGradientElement>;
+    rect: SVGProps<SVGRectElement>;
+    stop: SVGProps<SVGStopElement>;
+    switch: SVGProps<SVGSwitchElement>;
+    symbol: SVGProps<SVGSymbolElement>;
+    text: SVGProps<SVGTextElement>;
+    textPath: SVGProps<SVGTextPathElement>;
+    tspan: SVGProps<SVGTSpanElement>;
+    use: SVGProps<SVGUseElement>;
+    view: SVGProps<SVGViewElement>;
+
+    // Svelte specific
+    sveltewindow: HTMLProps<Window> & SvelteWindowProps;
+    sveltebody: HTMLProps<HTMLElement>;
+    sveltefragment: { slot?: string; };
+    svelteoptions: { [name: string]: any };
+    sveltehead: { [name: string]: any };
+    svelteelement: { 'this': string | undefined | null; } & HTMLProps<any> & SVGProps<any> & SapperAnchorProps;
+    // Needed due to backwards compatibility type which hits these
+    'svelte:window': HTMLProps<Window> & SvelteWindowProps;
+    'svelte:body': HTMLProps<HTMLElement>;
+    'svelte:fragment': { slot?: string; };
+    'svelte:options': { [name: string]: any };
+    'svelte:head': { [name: string]: any };
+  }
+}

tools/ui/node_modules/svelte-check/dist/src/svelte-native-jsx.d.ts

@@ -0,0 +1,32 @@
+declare namespace svelteNative.JSX {
+
+    // Every namespace eligible for use needs to implement the following two functions
+    function mapElementTag(
+        tag: string
+    ): any;
+
+    function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+        element: Key | undefined | null, attrs: Elements[Key]
+    ): any;
+    function createElement<Elements extends IntrinsicElements, Key extends keyof Elements, T>(
+        element: Key | undefined | null, attrEnhancers: T, attrs: Elements[Key] & T
+    ): any;
+
+
+    /* svelte specific */
+    interface ElementClass {
+        $$prop_def: any;
+    }
+
+    interface ElementAttributesProperty {
+        $$prop_def: any; // specify the property name to use
+    }
+
+    // Add empty IntrinsicAttributes to prevent fallback to the one in the JSX namespace
+    interface IntrinsicAttributes {
+    }
+
+    interface IntrinsicElements {
+        [name: string]: { [name: string]: any };
+    }
+}

tools/ui/node_modules/svelte-check/dist/src/svelte-shims-v4.d.ts

@@ -0,0 +1,290 @@
+// Whenever a ambient declaration changes, its number should be increased
+// This way, we avoid the situation where multiple ambient versions of svelte2tsx
+// are loaded and their declarations conflict each other
+// See https://github.com/sveltejs/language-tools/issues/1059 for an example bug that stems from it
+// If you change anything in this file, think about whether or not it should be backported to svelte-shims.d.ts
+
+type AConstructorTypeOf<T, U extends any[] = any[]> = new (...args: U) => T;
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void
+} | void
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionReturnType = SvelteTransitionConfig | (() => SvelteTransitionConfig)
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteWithOptionalProps<Props, Keys extends keyof Props> = Omit<Props, Keys> & Partial<Pick<Props, Keys>>;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAllProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SveltePropsAnyFallback<Props> = {[K in keyof Props]: Props[K] extends never ? never : Props[K] extends undefined ? any : Props[K]}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlotsAnyFallback<Slots> = {[K in keyof Slots]: {[S in keyof Slots[K]]: Slots[K][S] extends undefined ? any : Slots[K][S]}}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteRestProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlots = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteStore<T> = { subscribe: (run: (value: T) => any, invalidate?: any) => any }
+
+// Forces TypeScript to look into the type which results in a better representation of it
+// which helps for error messages and is necessary for d.ts file transformation so that
+// no ambient type references are left in the output
+/** @internal PRIVATE API, DO NOT USE */
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+/** @internal PRIVATE API, DO NOT USE */
+type KeysMatching<Obj, V> = {[K in keyof Obj]-?: Obj[K] extends V ? K : never}[keyof Obj]
+/** @internal PRIVATE API, DO NOT USE */
+declare type __sveltets_2_CustomEvents<T> = {[K in KeysMatching<T, CustomEvent>]: T[K] extends CustomEvent ? T[K]['detail']: T[K]}
+
+declare function __sveltets_2_ensureRightProps<Props>(props: Props): {};
+declare function __sveltets_2_instanceOf<T = any>(type: AConstructorTypeOf<T>): T;
+declare function __sveltets_2_allPropsType(): SvelteAllProps
+declare function __sveltets_2_restPropsType(): SvelteRestProps
+declare function __sveltets_2_slotsType<Slots, Key extends keyof Slots>(slots: Slots): Record<Key, boolean>;
+
+// Overload of the following two functions is necessary.
+// An empty array of optionalProps makes OptionalProps type any, which means we lose the prop typing.
+// optionalProps need to be first or its type cannot be infered correctly.
+
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SveltePropsAnyFallback<Props>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SveltePropsAnyFallback<Props> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>>, exports?: Exports, bindings?: Bindings }
+
+
+declare function __sveltets_2_with_any<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Expand<Props & SvelteAllProps>, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_with_any_event<Props = {}, Events = {}, Slots = {}, Exports = {}, Bindings = string>(
+    render: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }
+): {props: Props, events: Events & {[evt: string]: CustomEvent<any>;}, slots: Slots, exports?: Exports, bindings?: Bindings }
+
+declare function __sveltets_2_store_get<T = any>(store: SvelteStore<T>): T
+declare function __sveltets_2_store_get<Store extends SvelteStore<any> | undefined | null>(store: Store): Store extends SvelteStore<infer T> ? T : Store;
+declare function __sveltets_2_any(dummy: any): any;
+declare function __sveltets_2_invalidate<T>(getValue: () => T): T
+
+declare function __sveltets_2_mapWindowEvent<K extends keyof HTMLBodyElementEventMap>(
+    event: K
+): HTMLBodyElementEventMap[K];
+declare function __sveltets_2_mapBodyEvent<K extends keyof WindowEventMap>(
+    event: K
+): WindowEventMap[K];
+declare function __sveltets_2_mapElementEvent<K extends keyof HTMLElementEventMap>(
+    event: K
+): HTMLElementEventMap[K];
+
+declare function __sveltets_2_bubbleEventDef<Events, K extends keyof Events>(
+    events: Events, eventKey: K
+): Events[K];
+declare function __sveltets_2_bubbleEventDef(
+    events: any, eventKey: string
+): any;
+
+declare const __sveltets_2_customEvent: CustomEvent<any>;
+declare function __sveltets_2_toEventTypings<Typings>(): {[Key in keyof Typings]: CustomEvent<Typings[Key]>};
+
+declare function __sveltets_2_unionType<T1, T2>(t1: T1, t2: T2): T1 | T2;
+declare function __sveltets_2_unionType<T1, T2, T3>(t1: T1, t2: T2, t3: T3): T1 | T2 | T3;
+declare function __sveltets_2_unionType<T1, T2, T3, T4>(t1: T1, t2: T2, t3: T3, t4: T4): T1 | T2 | T3 | T4;
+declare function __sveltets_2_unionType(...types: any[]): any;
+
+declare function __sveltets_2_createSvelte2TsxComponent<Props extends {}, Events extends {}, Slots extends {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): typeof import("svelte").SvelteComponent<Props, Events, Slots>;
+
+declare function __sveltets_2_unwrapArr<T>(arr: ArrayLike<T>): T
+declare function __sveltets_2_unwrapPromiseLike<T>(promise: PromiseLike<T> | T): T
+
+// v2
+declare function __sveltets_2_createCreateSlot<Slots = Record<string, Record<string, any>>>(): <SlotName extends keyof Slots>(slotName: SlotName, attrs: Slots[SlotName]) => Record<string, any>;
+declare function __sveltets_2_createComponentAny(props: Record<string, any>): import("svelte").SvelteComponent<any, any, any>;
+
+declare function __sveltets_2_any(...dummy: any[]): any;
+declare function __sveltets_2_empty(...dummy: any[]): {};
+declare function __sveltets_2_union<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(t1:T1,t2?:T2,t3?:T3,t4?:T4,t5?:T5,t6?:T6,t7?:T7,t8?:T8,t9?:T9,t10?:T10): T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10;
+declare function __sveltets_2_nonNullable<T>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_cssProp(prop: Record<string, any>): {};
+
+// @ts-ignore Svelte v3/v4 don't have this
+declare function __sveltets_2_ensureSnippet(val: ReturnType<import('svelte').Snippet> | undefined | null): any;
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+declare var __sveltets_2_AnimationMove: { from: DOMRect, to: DOMRect }
+declare function __sveltets_2_ensureAnimation(animationCall: __sveltets_2_SvelteAnimationReturnType): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void,
+    $$_attributes?: Record<string, any>,
+} | void
+declare function __sveltets_2_ensureAction<T extends __sveltets_2_SvelteActionReturnType>(actionCall: T): T extends  {$$_attributes?: any} ? T['$$_attributes'] : {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionReturnType = __sveltets_2_SvelteTransitionConfig | (() => __sveltets_2_SvelteTransitionConfig)
+declare function __sveltets_2_ensureTransition(transitionCall: __sveltets_2_SvelteTransitionReturnType): {};
+
+// Includes undefined and null for all types as all usages also allow these
+declare function __sveltets_2_ensureType<T>(type: AConstructorTypeOf<T>, el: T | undefined | null): {};
+declare function __sveltets_2_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2 | undefined | null): {};
+
+// The following is necessary because there are two clashing errors that can't be solved at the same time
+// when using Svelte2TsxComponent, more precisely the event typings in
+// __sveltets_2_ensureComponent<T extends new (..) => _SvelteComponent<any,||any||<-this,any>>(type: T): T;
+// If we type it as "any", we have an error when using sth like {a: CustomEvent<any>}
+// If we type it as "{}", we have an error when using sth like {[evt: string]: CustomEvent<any>}
+// If we type it as "unknown", we get all kinds of follow up errors which we want to avoid
+// Therefore introduce two more base classes just for this case.
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT
+ */
+declare type ATypedSvelteComponent = {
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$prop_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$events_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$slot_def: any;
+
+    $on(event: string, handler: any): () => void;
+}
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT.
+ * 
+ * If you're looking for the type of a Svelte Component, use `SvelteComponent` and `ComponentType` instead:
+ *
+ * ```ts
+ * import type { ComponentType, SvelteComponent } from "svelte";
+ * let myComponentConstructor: ComponentType<SvelteComponent> = ..;
+ * ```
+ */
+declare type ConstructorOfATypedSvelteComponent = new (args: {target: any, props?: any}) => ATypedSvelteComponent
+// Usage note: Cannot properly transform generic function components to class components due to TypeScript limitations
+declare function __sveltets_2_ensureComponent<
+    T extends
+        | ConstructorOfATypedSvelteComponent
+        | (typeof import('svelte') extends { mount: any }
+              ? // @ts-ignore svelte.Component doesn't exist in Svelte 4
+                import('svelte').Component<any, any, any>
+              : never)
+        | null
+        | undefined
+>(
+    type: T
+): NonNullable<
+    T extends ConstructorOfATypedSvelteComponent
+        ? T
+        : typeof import('svelte') extends { mount: any }
+          ? // @ts-ignore svelte.Component doesn't exist in Svelte 4
+            T extends import('svelte').Component<
+                infer Props extends Record<string, any>,
+                infer Exports extends Record<string, any>,
+                infer Bindings extends string
+            >
+              ? new (
+                    options: import('svelte').ComponentConstructorOptions<Props>
+                ) => import('svelte').SvelteComponent<Props, Props['$$events'], Props['$$slots']> &
+                    Exports & { $$bindings: Bindings }
+              : never
+          : never
+>;
+
+declare function __sveltets_2_ensureArray<T extends ArrayLike<unknown> | Iterable<unknown>>(
+    // Svelte 5 allows undefined or null here, Svelte 4 doesn't
+    array: T | (typeof import('svelte') extends { mount: any } ? (undefined | null) : never)
+): T extends ArrayLike<infer U> ? U[] : T extends Iterable<infer U> ? Iterable<U> : any[];
+
+type __sveltets_2_PropsWithChildren<Props, Slots> = Props &
+    (Slots extends { default: any }
+        // This is unfortunate because it means "accepts no props" turns into "accepts any prop"
+        // but the alternative is non-fixable type errors because of the way TypeScript index
+        // signatures work (they will always take precedence and make an impossible-to-satisfy children type).
+        ? Props extends Record<string, never>
+        ? any
+        : { children?: any }
+        : {});
+declare function __sveltets_2_runes_constructor<Props extends {}>(render: {props: Props }): import("svelte").ComponentConstructorOptions<Props>;
+
+declare function __sveltets_2_get_set_binding<T>(get: (() => T) | null | undefined, set: (t: T) => void): T;
+
+declare function __sveltets_$$bindings<Bindings extends string[]>(...bindings: Bindings): Bindings[number];
+
+declare function __sveltets_2_fn_component<
+    Props extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+    // @ts-ignore Svelte 5 only
+>(klass: {props: Props, exports?: Exports, bindings?: Bindings }): import('svelte').Component<Props, Exports, Bindings>;
+
+interface __sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & { $$bindings?: Bindings } & Exports;
+    (internal: unknown, props: Props extends Record<string, never> ? {$$events?: Events, $$slots?: Slots} : Props & {$$events?: Events, $$slots?: Slots}): Exports & { $set?: any, $on?: any };
+    z_$$bindings?: Bindings;
+}
+
+declare function __sveltets_2_isomorphic_component<
+    Props extends Record<string, any>, Events extends Record<string, any>, Slots extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+>(klass: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }): __sveltets_2_IsomorphicComponent<Props, Events, Slots, Exports, Bindings>;
+
+declare function __sveltets_2_isomorphic_component_slots<
+    Props extends Record<string, any>, Events extends Record<string, any>, Slots extends Record<string, any>, Exports extends Record<string, any>, Bindings extends string
+>(klass: {props: Props, events: Events, slots: Slots, exports?: Exports, bindings?: Bindings }): __sveltets_2_IsomorphicComponent<__sveltets_2_PropsWithChildren<Props, Slots>, Events, Slots, Exports, Bindings>;

tools/ui/node_modules/svelte-check/dist/src/svelte-shims.d.ts

@@ -0,0 +1,305 @@
+// @ts-nocheck
+// nocheck because we don't want to adjust this anymore (only used for Svelte 3)
+// Whenever a ambient declaration changes, its number should be increased
+// This way, we avoid the situation where multiple ambient versions of svelte2tsx
+// are loaded and their declarations conflict each other
+// See https://github.com/sveltejs/language-tools/issues/1059 for an example bug that stems from it
+// If you change anything in this file, think about whether or not it should also be added to svelte-shims-v4.d.ts
+
+// -- start svelte-ls-remove --
+declare module '*.svelte' {
+    type _SvelteComponent<Props=any,Events=any,Slots=any> = import("svelte").SvelteComponentTyped<Props,Events,Slots>;
+    export default _SvelteComponent
+}
+// -- end svelte-ls-remove --
+
+/**
+ * @deprecated This will be removed soon. Use `SvelteComponentTyped` instead:
+ * ```ts
+ * import type { SvelteComponentTyped } from 'svelte';
+ * ```
+ */
+declare class Svelte2TsxComponent<
+    Props extends {} = {},
+    Events extends {} = {},
+    Slots extends {} = {}
+> {
+    // svelte2tsx-specific
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$prop_def: Props;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$events_def: Events;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$slot_def: Slots;
+    // https://svelte.dev/docs#Client-side_component_API
+    constructor(options: Svelte2TsxComponentConstructorParameters<Props>);
+    /**
+     * Causes the callback function to be called whenever the component dispatches an event.
+     * A function is returned that will remove the event listener when called.
+     */
+    $on<K extends keyof Events & string>(event: K, handler: ((e: Events[K]) => any) | null | undefined): () => void;
+    /**
+     * Removes a component from the DOM and triggers any `onDestroy` handlers.
+     */
+    $destroy(): void;
+    /**
+     * Programmatically sets props on an instance.
+     * `component.$set({ x: 1 })` is equivalent to `x = 1` inside the component's `<script>` block.
+     * Calling this method schedules an update for the next microtask — the DOM is __not__ updated synchronously.
+     */
+    $set(props?: Partial<Props>): void;
+    // From SvelteComponent(Dev) definition
+    $$: any;
+    $capture_state(): void;
+    $inject_state(): void;
+}
+
+/** @deprecated PRIVATE API, DO NOT USE, REMOVED SOON */
+interface Svelte2TsxComponentConstructorParameters<Props extends {}> {
+    /**
+     * An HTMLElement to render to. This option is required.
+     */
+    target: Element | Document | ShadowRoot;
+    /**
+     * A child of `target` to render the component immediately before.
+     */
+    anchor?: Element;
+    /**
+     * An object of properties to supply to the component.
+     */
+    props?: Props;
+    context?: Map<any, any>;
+    hydrate?: boolean;
+    intro?: boolean;
+    $$inline?: boolean;
+}
+
+type AConstructorTypeOf<T, U extends any[] = any[]> = new (...args: U) => T;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteComponentConstructor<T, U extends import('svelte').ComponentConstructorOptions<any>> = new (options: U) => T;
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void
+} | void
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionReturnType = SvelteTransitionConfig | (() => SvelteTransitionConfig)
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteWithOptionalProps<Props, Keys extends keyof Props> = Omit<Props, Keys> & Partial<Pick<Props, Keys>>;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAllProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SveltePropsAnyFallback<Props> = {[K in keyof Props]: Props[K] extends never ? never : Props[K] extends undefined ? any : Props[K]}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlotsAnyFallback<Slots> = {[K in keyof Slots]: {[S in keyof Slots[K]]: Slots[K][S] extends undefined ? any : Slots[K][S]}}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteRestProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlots = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteStore<T> = { subscribe: (run: (value: T) => any, invalidate?: any) => any }
+
+// Forces TypeScript to look into the type which results in a better representation of it
+// which helps for error messages and is necessary for d.ts file transformation so that
+// no ambient type references are left in the output
+/** @internal PRIVATE API, DO NOT USE */
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+/** @internal PRIVATE API, DO NOT USE */
+type KeysMatching<Obj, V> = {[K in keyof Obj]-?: Obj[K] extends V ? K : never}[keyof Obj]
+/** @internal PRIVATE API, DO NOT USE */
+declare type __sveltets_2_CustomEvents<T> = {[K in KeysMatching<T, CustomEvent>]: T[K] extends CustomEvent ? T[K]['detail']: T[K]}
+
+declare function __sveltets_2_ensureRightProps<Props>(props: Props): {};
+declare function __sveltets_2_instanceOf<T = any>(type: AConstructorTypeOf<T>): T;
+declare function __sveltets_2_allPropsType(): SvelteAllProps
+declare function __sveltets_2_restPropsType(): SvelteRestProps
+declare function __sveltets_2_slotsType<Slots, Key extends keyof Slots>(slots: Slots): Record<Key, boolean>;
+
+// Overload of the following two functions is necessary.
+// An empty array of optionalProps makes OptionalProps type any, which means we lose the prop typing.
+// optionalProps need to be first or its type cannot be infered correctly.
+
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SveltePropsAnyFallback<Props>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SveltePropsAnyFallback<Props> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+
+
+declare function __sveltets_2_with_any<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<Props & SvelteAllProps>, events: Events, slots: Slots }
+
+declare function __sveltets_2_with_any_event<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Props, events: Events & {[evt: string]: CustomEvent<any>;}, slots: Slots }
+
+declare function __sveltets_2_store_get<T = any>(store: SvelteStore<T>): T
+declare function __sveltets_2_store_get<Store extends SvelteStore<any> | undefined | null>(store: Store): Store extends SvelteStore<infer T> ? T : Store;
+declare function __sveltets_2_any(dummy: any): any;
+// declare function __sveltets_1_empty(...dummy: any[]): {};
+// declare function __sveltets_1_componentType(): AConstructorTypeOf<import("svelte").SvelteComponentTyped<any, any, any>>
+declare function __sveltets_2_invalidate<T>(getValue: () => T): T
+
+declare function __sveltets_2_mapWindowEvent<K extends keyof HTMLBodyElementEventMap>(
+    event: K
+): HTMLBodyElementEventMap[K];
+declare function __sveltets_2_mapBodyEvent<K extends keyof WindowEventMap>(
+    event: K
+): WindowEventMap[K];
+declare function __sveltets_2_mapElementEvent<K extends keyof HTMLElementEventMap>(
+    event: K
+): HTMLElementEventMap[K];
+
+declare function __sveltets_2_bubbleEventDef<Events, K extends keyof Events>(
+    events: Events, eventKey: K
+): Events[K];
+declare function __sveltets_2_bubbleEventDef(
+    events: any, eventKey: string
+): any;
+
+declare const __sveltets_2_customEvent: CustomEvent<any>;
+declare function __sveltets_2_toEventTypings<Typings>(): {[Key in keyof Typings]: CustomEvent<Typings[Key]>};
+
+declare function __sveltets_2_unionType<T1, T2>(t1: T1, t2: T2): T1 | T2;
+declare function __sveltets_2_unionType<T1, T2, T3>(t1: T1, t2: T2, t3: T3): T1 | T2 | T3;
+declare function __sveltets_2_unionType<T1, T2, T3, T4>(t1: T1, t2: T2, t3: T3, t4: T4): T1 | T2 | T3 | T4;
+declare function __sveltets_2_unionType(...types: any[]): any;
+
+declare function __sveltets_2_createSvelte2TsxComponent<Props, Events, Slots>(
+    render: {props: Props, events: Events, slots: Slots }
+): SvelteComponentConstructor<import("svelte").SvelteComponentTyped<Props, Events, Slots>,import('svelte').ComponentConstructorOptions<Props>>;
+
+declare function __sveltets_2_unwrapArr<T>(arr: ArrayLike<T>): T
+declare function __sveltets_2_unwrapPromiseLike<T>(promise: PromiseLike<T> | T): T
+
+// v2
+declare function __sveltets_2_createCreateSlot<Slots = Record<string, Record<string, any>>>(): <SlotName extends keyof Slots>(slotName: SlotName, attrs: Slots[SlotName]) => Record<string, any>;
+declare function __sveltets_2_createComponentAny(props: Record<string, any>): import("svelte").SvelteComponentTyped<any, any, any>;
+
+declare function __sveltets_2_any(...dummy: any[]): any;
+declare function __sveltets_2_empty(...dummy: any[]): {};
+declare function __sveltets_2_union<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(t1:T1,t2?:T2,t3?:T3,t4?:T4,t5?:T5,t6?:T6,t7?:T7,t8?:T8,t9?:T9,t10?:T10): T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10;
+declare function __sveltets_2_nonNullable<T>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_cssProp(prop: Record<string, any>): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+declare var __sveltets_2_AnimationMove: { from: DOMRect, to: DOMRect }
+declare function __sveltets_2_ensureAnimation(animationCall: __sveltets_2_SvelteAnimationReturnType): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void,
+    $$_attributes?: Record<string, any>,
+} | void
+declare function __sveltets_2_ensureAction<T extends __sveltets_2_SvelteActionReturnType>(actionCall: T): T extends  {$$_attributes?: any} ? T['$$_attributes'] : {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionReturnType = __sveltets_2_SvelteTransitionConfig | (() => __sveltets_2_SvelteTransitionConfig)
+declare function __sveltets_2_ensureTransition(transitionCall: __sveltets_2_SvelteTransitionReturnType): {};
+
+// Includes undefined and null for all types as all usages also allow these
+declare function __sveltets_2_ensureType<T>(type: AConstructorTypeOf<T>, el: T | undefined | null): {};
+declare function __sveltets_2_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2 | undefined | null): {};
+
+// The following is necessary because there are two clashing errors that can't be solved at the same time
+// when using Svelte2TsxComponent, more precisely the event typings in
+// __sveltets_2_ensureComponent<T extends new (..) => _SvelteComponent<any,||any||<-this,any>>(type: T): T;
+// If we type it as "any", we have an error when using sth like {a: CustomEvent<any>}
+// If we type it as "{}", we have an error when using sth like {[evt: string]: CustomEvent<any>}
+// If we type it as "unknown", we get all kinds of follow up errors which we want to avoid
+// Therefore introduce two more base classes just for this case.
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT
+ */
+declare type ATypedSvelteComponent = {
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$prop_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$events_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$slot_def: any;
+
+    $on(event: string, handler: ((e: any) => any) | null | undefined): () => void;
+}
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT.
+ * 
+ * If you're looking for the type of a Svelte Component, use `SvelteComponentTyped` and `ComponentType` instead:
+ *
+ * ```ts
+ * import type { ComponentType, SvelteComponentTyped } from "svelte";
+ * let myComponentConstructor: ComponentType<SvelteComponentTyped> = ..;
+ * ```
+ */
+declare type ConstructorOfATypedSvelteComponent = new (args: {target: any, props?: any}) => ATypedSvelteComponent
+declare function __sveltets_2_ensureComponent<T extends ConstructorOfATypedSvelteComponent | null | undefined>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_ensureArray<T extends ArrayLike<unknown>>(array: T): T extends ArrayLike<infer U> ? U[] : any[];

tools/ui/node_modules/svelte-check/node_modules/chokidar/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Paul Miller (https://paulmillr.com), Elan Shanker
+
+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.

tools/ui/node_modules/svelte-check/node_modules/chokidar/README.md

@@ -0,0 +1,305 @@
+# Chokidar [![Weekly downloads](https://img.shields.io/npm/dw/chokidar.svg)](https://github.com/paulmillr/chokidar)
+
+> Minimal and efficient cross-platform file watching library
+
+## Why?
+
+There are many reasons to prefer Chokidar to raw fs.watch / fs.watchFile in 2024:
+
+- Events are properly reported
+    - macOS events report filenames
+    - events are not reported twice
+    - changes are reported as add / change / unlink instead of useless `rename`
+- Atomic writes are supported, using `atomic` option
+    - Some file editors use them
+- Chunked writes are supported, using `awaitWriteFinish` option
+    - Large files are commonly written in chunks
+- File / dir filtering is supported
+- Symbolic links are supported
+- Recursive watching is always supported, instead of partial when using raw events
+    - Includes a way to limit recursion depth
+
+Chokidar relies on the Node.js core `fs` module, but when using
+`fs.watch` and `fs.watchFile` for watching, it normalizes the events it
+receives, often checking for truth by getting file stats and/or dir contents.
+The `fs.watch`-based implementation is the default, which
+avoids polling and keeps CPU usage down. Be advised that chokidar will initiate
+watchers recursively for everything within scope of the paths that have been
+specified, so be judicious about not wasting system resources by watching much
+more than needed. For some cases, `fs.watchFile`, which utilizes polling and uses more resources, is used.
+
+Made for [Brunch](https://brunch.io/) in 2012,
+it is now used in [~30 million repositories](https://www.npmjs.com/browse/depended/chokidar) and
+has proven itself in production environments.
+
+**Sep 2024 update:** v4 is out! It decreases dependency count from 13 to 1, removes
+support for globs, adds support for ESM / Common.js modules, and bumps minimum node.js version from v8 to v14.
+Check out [upgrading](#upgrading).
+
+## Getting started
+
+Install with npm:
+
+```sh
+npm install chokidar
+```
+
+Use it in your code:
+
+```javascript
+import chokidar from 'chokidar';
+
+// One-liner for current directory
+chokidar.watch('.').on('all', (event, path) => {
+  console.log(event, path);
+});
+
+
+// Extended options
+// ----------------
+
+// Initialize watcher.
+const watcher = chokidar.watch('file, dir, or array', {
+  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
+  persistent: true
+});
+
+// Something to use when events are received.
+const log = console.log.bind(console);
+// Add event listeners.
+watcher
+  .on('add', path => log(`File ${path} has been added`))
+  .on('change', path => log(`File ${path} has been changed`))
+  .on('unlink', path => log(`File ${path} has been removed`));
+
+// More possible events.
+watcher
+  .on('addDir', path => log(`Directory ${path} has been added`))
+  .on('unlinkDir', path => log(`Directory ${path} has been removed`))
+  .on('error', error => log(`Watcher error: ${error}`))
+  .on('ready', () => log('Initial scan complete. Ready for changes'))
+  .on('raw', (event, path, details) => { // internal
+    log('Raw event info:', event, path, details);
+  });
+
+// 'add', 'addDir' and 'change' events also receive stat() results as second
+// argument when available: https://nodejs.org/api/fs.html#fs_class_fs_stats
+watcher.on('change', (path, stats) => {
+  if (stats) console.log(`File ${path} changed size to ${stats.size}`);
+});
+
+// Watch new files.
+watcher.add('new-file');
+watcher.add(['new-file-2', 'new-file-3']);
+
+// Get list of actual paths being watched on the filesystem
+let watchedPaths = watcher.getWatched();
+
+// Un-watch some files.
+await watcher.unwatch('new-file');
+
+// Stop watching. The method is async!
+await watcher.close().then(() => console.log('closed'));
+
+// Full list of options. See below for descriptions.
+// Do not use this example!
+chokidar.watch('file', {
+  persistent: true,
+
+  // ignore .txt files
+  ignored: (file) => file.endsWith('.txt'),
+  // watch only .txt files
+  // ignored: (file, _stats) => _stats?.isFile() && !file.endsWith('.txt'),
+
+  awaitWriteFinish: true, // emit single event when chunked writes are completed
+  atomic: true, // emit proper events when "atomic writes" (mv _tmp file) are used
+
+  // The options also allow specifying custom intervals in ms
+  // awaitWriteFinish: {
+  //   stabilityThreshold: 2000,
+  //   pollInterval: 100
+  // },
+  // atomic: 100,
+
+  interval: 100,
+  binaryInterval: 300,
+
+  cwd: '.',
+  depth: 99,
+
+  followSymlinks: true,
+  ignoreInitial: false,
+  ignorePermissionErrors: false,
+  usePolling: false,
+  alwaysStat: false,
+});
+
+```
+
+`chokidar.watch(paths, [options])`
+
+* `paths` (string or array of strings). Paths to files, dirs to be watched
+recursively.
+* `options` (object) Options object as defined below:
+
+#### Persistence
+
+* `persistent` (default: `true`). Indicates whether the process
+should continue to run as long as files are being watched.
+
+#### Path filtering
+
+* `ignored` function, regex, or path. Defines files/paths to be ignored.
+The whole relative or absolute path is tested, not just filename. If a function with two arguments
+is provided, it gets called twice per path - once with a single argument (the path), second
+time with two arguments (the path and the
+[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)
+object of that path).
+* `ignoreInitial` (default: `false`). If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+* `followSymlinks` (default: `true`). When `false`, only the
+symlinks themselves will be watched for changes instead of following
+the link references and bubbling events through the link's path.
+* `cwd` (no default). The base directory from which watch `paths` are to be
+derived. Paths emitted with events will be relative to this.
+
+#### Performance
+
+* `usePolling` (default: `false`).
+Whether to use fs.watchFile (backed by polling), or fs.watch. If polling
+leads to high CPU utilization, consider setting this to `false`. It is
+typically necessary to **set this to `true` to successfully watch files over
+a network**, and it may be necessary to successfully watch files in other
+non-standard situations. Setting to `true` explicitly on MacOS overrides the
+`useFsEvents` default. You may also set the CHOKIDAR_USEPOLLING env variable
+to true (1) or false (0) in order to override this option.
+* _Polling-specific settings_ (effective when `usePolling: true`)
+  * `interval` (default: `100`). Interval of file system polling, in milliseconds. You may also
+    set the CHOKIDAR_INTERVAL env variable to override this option.
+  * `binaryInterval` (default: `300`). Interval of file system
+  polling for binary files.
+  ([see list of binary extensions](https://github.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+* `alwaysStat` (default: `false`). If relying upon the
+[`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats)
+object that may get passed with `add`, `addDir`, and `change` events, set
+this to `true` to ensure it is provided even in cases where it wasn't
+already available from the underlying watch events.
+* `depth` (default: `undefined`). If set, limits how many levels of
+subdirectories will be traversed.
+* `awaitWriteFinish` (default: `false`).
+By default, the `add` event will fire when a file first appears on disk, before
+the entire file has been written. Furthermore, in some cases some `change`
+events will be emitted while the file is being written. In some cases,
+especially when watching for large files there will be a need to wait for the
+write operation to finish before responding to a file creation or modification.
+Setting `awaitWriteFinish` to `true` (or a truthy value) will poll file size,
+holding its `add` and `change` events until the size does not change for a
+configurable amount of time. The appropriate duration setting is heavily
+dependent on the OS and hardware. For accurate detection this parameter should
+be relatively high, making file watching much less responsive.
+Use with caution.
+  * *`options.awaitWriteFinish` can be set to an object in order to adjust
+  timing params:*
+  * `awaitWriteFinish.stabilityThreshold` (default: 2000). Amount of time in
+  milliseconds for a file size to remain constant before emitting its event.
+  * `awaitWriteFinish.pollInterval` (default: 100). File size polling interval, in milliseconds.
+
+#### Errors
+
+* `ignorePermissionErrors` (default: `false`). Indicates whether to watch files
+that don't have read permissions if possible. If watching fails due to `EPERM`
+or `EACCES` with this set to `true`, the errors will be suppressed silently.
+* `atomic` (default: `true` if `useFsEvents` and `usePolling` are `false`).
+Automatically filters out artifacts that occur when using editors that use
+"atomic writes" instead of writing directly to the source file. If a file is
+re-added within 100 ms of being deleted, Chokidar emits a `change` event
+rather than `unlink` then `add`. If the default of 100 ms does not work well
+for you, you can override it by setting `atomic` to a custom value, in
+milliseconds.
+
+### Methods & Events
+
+`chokidar.watch()` produces an instance of `FSWatcher`. Methods of `FSWatcher`:
+
+* `.add(path / paths)`: Add files, directories for tracking.
+Takes an array of strings or just one string.
+* `.on(event, callback)`: Listen for an FS event.
+Available events: `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `ready`,
+`raw`, `error`.
+Additionally `all` is available which gets emitted with the underlying event
+name and path for every event other than `ready`, `raw`, and `error`.  `raw` is internal, use it carefully.
+* `.unwatch(path / paths)`: Stop watching files or directories.
+Takes an array of strings or just one string.
+* `.close()`: **async** Removes all listeners from watched files. Asynchronous, returns Promise. Use with `await` to ensure bugs don't happen.
+* `.getWatched()`: Returns an object representing all the paths on the file
+system being watched by this `FSWatcher` instance. The object's keys are all the
+directories (using absolute paths unless the `cwd` option was used), and the
+values are arrays of the names of the items contained in each directory.
+
+### CLI
+
+Check out third party [chokidar-cli](https://github.com/open-cli-tools/chokidar-cli),
+which allows to execute a command on each change, or get a stdio stream of change events.
+
+## Troubleshooting
+
+Sometimes, Chokidar runs out of file handles, causing `EMFILE` and `ENOSP` errors:
+
+* `bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell`
+* `Error: watch /home/ ENOSPC`
+
+There are two things that can cause it.
+
+1. Exhausted file handles for generic fs operations
+    - Can be solved by using [graceful-fs](https://www.npmjs.com/package/graceful-fs),
+      which can monkey-patch native `fs` module used by chokidar: `let fs = require('fs'); let grfs = require('graceful-fs'); grfs.gracefulify(fs);`
+    - Can also be solved by tuning OS: `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p`.
+2. Exhausted file handles for `fs.watch`
+    - Can't seem to be solved by graceful-fs or OS tuning
+    - It's possible to start using `usePolling: true`, which will switch backend to resource-intensive `fs.watchFile`
+
+All fsevents-related issues (`WARN optional dep failed`, `fsevents is not a constructor`) are solved by upgrading to v4+.
+
+## Changelog
+
+- **v4 (Sep 2024):** remove glob support and bundled fsevents. Decrease dependency count from 13 to 1. Rewrite in typescript. Bumps minimum node.js requirement to v14+
+- **v3 (Apr 2019):** massive CPU & RAM consumption improvements; reduces deps / package size by a factor of 17x and bumps Node.js requirement to v8.16+.
+- **v2 (Dec 2017):** globs are now posix-style-only. Tons of bugfixes.
+- **v1 (Apr 2015):** glob support, symlink support, tons of bugfixes. Node 0.8+ is supported
+- **v0.1 (Apr 2012):** Initial release, extracted from [Brunch](https://github.com/brunch/brunch/blob/9847a065aea300da99bd0753f90354cde9de1261/src/helpers.coffee#L66)
+
+### Upgrading
+
+If you've used globs before and want do replicate the functionality with v4:
+
+```js
+// v3
+chok.watch('**/*.js');
+chok.watch("./directory/**/*");
+
+// v4
+chok.watch('.', {
+  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
+});
+chok.watch('./directory');
+
+// other way
+import { glob } from 'node:fs/promises';
+const watcher = watch(await Array.fromAsync(glob('**/*.js')));
+
+// unwatching
+// v3
+chok.unwatch('**/*.js');
+// v4
+chok.unwatch(await glob('**/*.js'));
+```
+
+## Also
+
+Why was chokidar named this way? What's the meaning behind it?
+
+>Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four). This word is also used in other languages like Urdu as (چوکیدار) which is widely used in Pakistan and India. 
+
+## License
+
+MIT (c) Paul Miller (<https://paulmillr.com>), see [LICENSE](LICENSE) file.

tools/ui/node_modules/svelte-check/node_modules/chokidar/esm/handler.d.ts

@@ -0,0 +1,90 @@
+import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs';
+import type { FSWatcher, WatchHelper, Throttler } from './index.js';
+import type { EntryInfo } from 'readdirp';
+export type Path = string;
+export declare const STR_DATA = "data";
+export declare const STR_END = "end";
+export declare const STR_CLOSE = "close";
+export declare const EMPTY_FN: () => void;
+export declare const IDENTITY_FN: (val: unknown) => unknown;
+export declare const isWindows: boolean;
+export declare const isMacos: boolean;
+export declare const isLinux: boolean;
+export declare const isFreeBSD: boolean;
+export declare const isIBMi: boolean;
+export declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+export type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+export type FsWatchContainer = {
+    listeners: (path: string) => void | Set<any>;
+    errHandlers: (err: unknown) => void | Set<any>;
+    rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set<any>;
+    watcher: NativeFsWatcher;
+    watcherUnusable?: boolean;
+};
+export interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+/**
+ * @mixin
+ */
+export declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}

tools/ui/node_modules/svelte-check/node_modules/chokidar/esm/handler.js

@@ -0,0 +1,629 @@
+import { watchFile, unwatchFile, watch as fs_watch } from 'fs';
+import { open, stat, lstat, realpath as fsrealpath } from 'fs/promises';
+import * as sysPath from 'path';
+import { type as osType } from 'os';
+export const STR_DATA = 'data';
+export const STR_END = 'end';
+export const STR_CLOSE = 'close';
+export const EMPTY_FN = () => { };
+export const IDENTITY_FN = (val) => val;
+const pl = process.platform;
+export const isWindows = pl === 'win32';
+export const isMacos = pl === 'darwin';
+export const isLinux = pl === 'linux';
+export const isFreeBSD = pl === 'freebsd';
+export const isIBMi = osType() === 'OS400';
+export const EVENTS = {
+    ALL: 'all',
+    READY: 'ready',
+    ADD: 'add',
+    CHANGE: 'change',
+    ADD_DIR: 'addDir',
+    UNLINK: 'unlink',
+    UNLINK_DIR: 'unlinkDir',
+    RAW: 'raw',
+    ERROR: 'error',
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = 'watch';
+const statMethods = { lstat, stat };
+const KEY_LISTENERS = 'listeners';
+const KEY_ERR = 'errHandlers';
+const KEY_RAW = 'rawEmitters';
+const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+// prettier-ignore
+const binaryExtensions = new Set([
+    '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai',
+    'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi',
+    'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2',
+    'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu',
+    'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts',
+    'dtshd', 'dvb', 'dwg', 'dxf',
+    'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe',
+    'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt',
+    'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip',
+    'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso',
+    'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx',
+    'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo',
+    'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng',
+    'mobi', 'mov', 'movie', 'mp3',
+    'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu',
+    'nef', 'npx', 'numbers', 'nupkg',
+    'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott',
+    'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm',
+    'potx', 'ppa', 'ppam',
+    'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv',
+    'qt',
+    'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz',
+    's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so',
+    'stl', 'suo', 'sub', 'swf',
+    'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz',
+    'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu',
+    'viv', 'vob',
+    'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma',
+    'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx',
+    'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm',
+    'xmind', 'xpi', 'xpm', 'xwd', 'xz',
+    'z', 'zip', 'zipx',
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+    if (val instanceof Set) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+};
+const addAndConvert = (main, prop, item) => {
+    let container = main[prop];
+    if (!(container instanceof Set)) {
+        main[prop] = container = new Set([container]);
+    }
+    container.add(item);
+};
+const clearItem = (cont) => (key) => {
+    const set = cont[key];
+    if (set instanceof Set) {
+        set.clear();
+    }
+    else {
+        delete cont[key];
+    }
+};
+const delFromSet = (main, prop, item) => {
+    const container = main[prop];
+    if (container instanceof Set) {
+        container.delete(item);
+    }
+    else if (container === item) {
+        delete main[prop];
+    }
+};
+const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val);
+const FsWatchInstances = new Map();
+/**
+ * Instantiates the fs_watch interface
+ * @param path to be watched
+ * @param options to be passed to fs_watch
+ * @param listener main event handler
+ * @param errHandler emits info about errors
+ * @param emitRaw emits raw event data
+ * @returns {NativeFsWatcher}
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+    const handleEvent = (rawEvent, evPath) => {
+        listener(path);
+        emitRaw(rawEvent, evPath, { watchedPath: path });
+        // emit based on events occurring for files from a directory's watcher in
+        // case the file's watcher misses it (and rely on throttling to de-dupe)
+        if (evPath && path !== evPath) {
+            fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+        }
+    };
+    try {
+        return fs_watch(path, {
+            persistent: options.persistent,
+        }, handleEvent);
+    }
+    catch (error) {
+        errHandler(error);
+        return undefined;
+    }
+}
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param fullPath absolute path bound to fs_watch instance
+ */
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+    const cont = FsWatchInstances.get(fullPath);
+    if (!cont)
+        return;
+    foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+    });
+};
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path
+ * @param fullPath absolute path
+ * @param options to be passed to fs_watch
+ * @param handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+    const { listener, errHandler, rawEmitter } = handlers;
+    let cont = FsWatchInstances.get(fullPath);
+    let watcher;
+    if (!options.persistent) {
+        watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+            return;
+        return watcher.close.bind(watcher);
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here
+        fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+        if (!watcher)
+            return;
+        watcher.on(EV.ERROR, async (error) => {
+            const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+            if (cont)
+                cont.watcherUnusable = true; // documented since Node 10.4.1
+            // Workaround for https://github.com/joyent/node/issues/4337
+            if (isWindows && error.code === 'EPERM') {
+                try {
+                    const fd = await open(path, 'r');
+                    await fd.close();
+                    broadcastErr(error);
+                }
+                catch (err) {
+                    // do nothing
+                }
+            }
+            else {
+                broadcastErr(error);
+            }
+        });
+        cont = {
+            listeners: listener,
+            errHandlers: errHandler,
+            rawEmitters: rawEmitter,
+            watcher,
+        };
+        FsWatchInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // removes this instance's listeners and closes the underlying fs_watch
+    // instance if there are no more listeners left
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            // Check to protect against issue gh-730.
+            // if (cont.watcherUnusable) {
+            cont.watcher.close();
+            // }
+            FsWatchInstances.delete(fullPath);
+            HANDLER_KEYS.forEach(clearItem(cont));
+            // @ts-ignore
+            cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+// fs_watchFile helpers
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path to be watched
+ * @param fullPath absolute path
+ * @param options options to be passed to fs_watchFile
+ * @param handlers container for event listener functions
+ * @returns closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+    const { listener, rawEmitter } = handlers;
+    let cont = FsWatchFileInstances.get(fullPath);
+    // let listeners = new Set();
+    // let rawEmitters = new Set();
+    const copts = cont && cont.options;
+    if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        // "Upgrade" the watcher to persistence or a quicker interval.
+        // This creates some unlikely edge case issues if the user mixes
+        // settings in a very weird way, but solving for those cases
+        // doesn't seem worthwhile for the added complexity.
+        // listeners = cont.listeners;
+        // rawEmitters = cont.rawEmitters;
+        unwatchFile(fullPath);
+        cont = undefined;
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        // TODO
+        // listeners.add(listener);
+        // rawEmitters.add(rawEmitter);
+        cont = {
+            listeners: listener,
+            rawEmitters: rawEmitter,
+            options,
+            watcher: watchFile(fullPath, options, (curr, prev) => {
+                foreach(cont.rawEmitters, (rawEmitter) => {
+                    rawEmitter(EV.CHANGE, fullPath, { curr, prev });
+                });
+                const currmtime = curr.mtimeMs;
+                if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+                    foreach(cont.listeners, (listener) => listener(path, curr));
+                }
+            }),
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // Removes this instance's listeners and closes the underlying fs_watchFile
+    // instance if there are no more listeners left.
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            FsWatchFileInstances.delete(fullPath);
+            unwatchFile(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+/**
+ * @mixin
+ */
+export class NodeFsHandler {
+    constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+    }
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path);
+        const basename = sysPath.basename(path);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename);
+        const absolutePath = sysPath.resolve(path);
+        const options = {
+            persistent: opts.persistent,
+        };
+        if (!listener)
+            listener = EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+            const enableBin = opts.interval !== opts.binaryInterval;
+            options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+            closer = setFsWatchFileListener(path, absolutePath, options, {
+                listener,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        else {
+            closer = setFsWatchListener(path, absolutePath, options, {
+                listener,
+                errHandler: this._boundHandleError,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        return closer;
+    }
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const dirname = sysPath.dirname(file);
+        const basename = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname);
+        // stats is always present
+        let prevStats = stats;
+        // if the file is already being watched, do nothing
+        if (parent.has(basename))
+            return;
+        const listener = async (path, newStats) => {
+            if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+                return;
+            if (!newStats || newStats.mtimeMs === 0) {
+                try {
+                    const newStats = await stat(file);
+                    if (this.fsw.closed)
+                        return;
+                    // Check that change event was not fired because of changed only accessTime.
+                    const at = newStats.atimeMs;
+                    const mt = newStats.mtimeMs;
+                    if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                        this.fsw._emit(EV.CHANGE, file, newStats);
+                    }
+                    if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+                        this.fsw._closeFile(path);
+                        prevStats = newStats;
+                        const closer = this._watchWithNodeFs(file, listener);
+                        if (closer)
+                            this.fsw._addPathCloser(path, closer);
+                    }
+                    else {
+                        prevStats = newStats;
+                    }
+                }
+                catch (error) {
+                    // Fix issues where mtime is null but file is still present
+                    this.fsw._remove(dirname, basename);
+                }
+                // add is about to be emitted if file not already tracked in parent
+            }
+            else if (parent.has(basename)) {
+                // Check that change event was not fired because of changed only accessTime.
+                const at = newStats.atimeMs;
+                const mt = newStats.mtimeMs;
+                if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                    this.fsw._emit(EV.CHANGE, file, newStats);
+                }
+                prevStats = newStats;
+            }
+        };
+        // kick off the watcher
+        const closer = this._watchWithNodeFs(file, listener);
+        // emit an add event if we're supposed to
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+            if (!this.fsw._throttle(EV.ADD, file, 0))
+                return;
+            this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+    }
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+            // watch symlink directly (don't follow) and detect changes
+            this.fsw._incrReadyCount();
+            let linkPath;
+            try {
+                linkPath = await fsrealpath(path);
+            }
+            catch (e) {
+                this.fsw._emitReady();
+                return true;
+            }
+            if (this.fsw.closed)
+                return;
+            if (dir.has(item)) {
+                if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+                    this.fsw._symlinkPaths.set(full, linkPath);
+                    this.fsw._emit(EV.CHANGE, path, entry.stats);
+                }
+            }
+            else {
+                dir.add(item);
+                this.fsw._symlinkPaths.set(full, linkPath);
+                this.fsw._emit(EV.ADD, path, entry.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+        }
+        // don't follow the same symlink more than once
+        if (this.fsw._symlinkPaths.has(full)) {
+            return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+    }
+    _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        // Normalize the directory name on Windows
+        directory = sysPath.join(directory, '');
+        throttler = this.fsw._throttle('readdir', directory, 1000);
+        if (!throttler)
+            return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = new Set();
+        let stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry) => wh.filterPath(entry),
+            directoryFilter: (entry) => wh.filterDir(entry),
+        });
+        if (!stream)
+            return;
+        stream
+            .on(STR_DATA, async (entry) => {
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            const item = entry.path;
+            let path = sysPath.join(directory, item);
+            current.add(item);
+            if (entry.stats.isSymbolicLink() &&
+                (await this._handleSymlink(entry, directory, path, item))) {
+                return;
+            }
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            // Files that present in current directory snapshot
+            // but absent in previous are added to watch list and
+            // emit `add` event.
+            if (item === target || (!target && !previous.has(item))) {
+                this.fsw._incrReadyCount();
+                // ensure relativeness of path is preserved in case of watcher reuse
+                path = sysPath.join(dir, sysPath.relative(dir, path));
+                this._addToNodeFs(path, initialAdd, wh, depth + 1);
+            }
+        })
+            .on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve, reject) => {
+            if (!stream)
+                return reject();
+            stream.once(STR_END, () => {
+                if (this.fsw.closed) {
+                    stream = undefined;
+                    return;
+                }
+                const wasThrottled = throttler ? throttler.clear() : false;
+                resolve(undefined);
+                // Files that absent in current directory snapshot
+                // but present in previous emit `remove` event
+                // and are removed from @watched[directory].
+                previous
+                    .getChildren()
+                    .filter((item) => {
+                    return item !== directory && !current.has(item);
+                })
+                    .forEach((item) => {
+                    this.fsw._remove(directory, item);
+                });
+                stream = undefined;
+                // one more time for any missed in case changes came in extremely quickly
+                if (wasThrottled)
+                    this._handleRead(directory, false, wh, target, dir, depth, throttler);
+            });
+        });
+    }
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+            this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        // ensure dir is tracked (harmless if redundant)
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+            if (!target) {
+                await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+                if (this.fsw.closed)
+                    return;
+            }
+            closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+                // if current directory is removed, do nothing
+                if (stats && stats.mtimeMs === 0)
+                    return;
+                this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+            });
+        }
+        return closer;
+    }
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) {
+            ready();
+            return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path);
+        if (priorWh) {
+            wh.filterPath = (entry) => priorWh.filterPath(entry);
+            wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        // evaluate what is at the path we're being asked to watch
+        try {
+            const stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed)
+                return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) {
+                ready();
+                return false;
+            }
+            const follow = this.fsw.options.followSymlinks;
+            let closer;
+            if (stats.isDirectory()) {
+                const absPath = sysPath.resolve(path);
+                const targetPath = follow ? await fsrealpath(path) : path;
+                if (this.fsw.closed)
+                    return;
+                closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (absPath !== targetPath && targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(absPath, targetPath);
+                }
+            }
+            else if (stats.isSymbolicLink()) {
+                const targetPath = follow ? await fsrealpath(path) : path;
+                if (this.fsw.closed)
+                    return;
+                const parent = sysPath.dirname(wh.watchPath);
+                this.fsw._getWatchedDir(parent).add(wh.watchPath);
+                this.fsw._emit(EV.ADD, wh.watchPath, stats);
+                closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+                }
+            }
+            else {
+                closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            }
+            ready();
+            if (closer)
+                this.fsw._addPathCloser(path, closer);
+            return false;
+        }
+        catch (error) {
+            if (this.fsw._handleError(error)) {
+                ready();
+                return path;
+            }
+        }
+    }
+}

tools/ui/node_modules/svelte-check/node_modules/chokidar/esm/index.d.ts

@@ -0,0 +1,215 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { Stats } from 'fs';
+import { EventEmitter } from 'events';
+import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp';
+import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js';
+type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+export type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+export type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+export type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+export type EmitArgs = [path: Path, stats?: Stats];
+export type EmitErrorArgs = [error: Error, stats?: Stats];
+export type EmitArgsWithName = [event: EventName, ...EmitArgs];
+export type MatchFunction = (val: string, stats?: Stats) => boolean;
+export interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+export type Matcher = string | RegExp | MatchFunction | MatcherObject;
+/**
+ * Directory entry.
+ */
+declare class DirEntry {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+export declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+export interface FSWatcherKnownEventMap {
+    [EV.READY]: [];
+    [EV.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EV.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EV.ALL]: [event: EventName, ...EmitArgs];
+}
+export type FSWatcherEventMap = FSWatcherKnownEventMap & {
+    [k in Exclude<EventName, keyof FSWatcherKnownEventMap>]: EmitArgs;
+};
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+};
+export default _default;

tools/ui/node_modules/svelte-check/node_modules/chokidar/esm/index.js

@@ -0,0 +1,798 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { stat as statcb } from 'fs';
+import { stat, readdir } from 'fs/promises';
+import { EventEmitter } from 'events';
+import * as sysPath from 'path';
+import { readdirp } from 'readdirp';
+import { NodeFsHandler, EVENTS as EV, isWindows, isIBMi, EMPTY_FN, STR_CLOSE, STR_END, } from './handler.js';
+const SLASH = '/';
+const SLASH_SLASH = '//';
+const ONE_DOT = '.';
+const TWO_DOTS = '..';
+const STRING_TYPE = 'string';
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+    return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+    if (typeof matcher === 'function')
+        return matcher;
+    if (typeof matcher === 'string')
+        return (string) => matcher === string;
+    if (matcher instanceof RegExp)
+        return (string) => matcher.test(string);
+    if (typeof matcher === 'object' && matcher !== null) {
+        return (string) => {
+            if (matcher.path === string)
+                return true;
+            if (matcher.recursive) {
+                const relative = sysPath.relative(matcher.path, string);
+                if (!relative) {
+                    return false;
+                }
+                return !relative.startsWith('..') && !sysPath.isAbsolute(relative);
+            }
+            return false;
+        };
+    }
+    return () => false;
+}
+function normalizePath(path) {
+    if (typeof path !== 'string')
+        throw new Error('string expected');
+    path = sysPath.normalize(path);
+    path = path.replace(/\\/g, '/');
+    let prepend = false;
+    if (path.startsWith('//'))
+        prepend = true;
+    const DOUBLE_SLASH_RE = /\/\//;
+    while (path.match(DOUBLE_SLASH_RE))
+        path = path.replace(DOUBLE_SLASH_RE, '/');
+    if (prepend)
+        path = '/' + path;
+    return path;
+}
+function matchPatterns(patterns, testString, stats) {
+    const path = normalizePath(testString);
+    for (let index = 0; index < patterns.length; index++) {
+        const pattern = patterns[index];
+        if (pattern(path, stats)) {
+            return true;
+        }
+    }
+    return false;
+}
+function anymatch(matchers, testString) {
+    if (matchers == null) {
+        throw new TypeError('anymatch: specify first argument');
+    }
+    // Early cache for matchers.
+    const matchersArray = arrify(matchers);
+    const patterns = matchersArray.map((matcher) => createPattern(matcher));
+    if (testString == null) {
+        return (testString, stats) => {
+            return matchPatterns(patterns, testString, stats);
+        };
+    }
+    return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+    const paths = arrify(paths_).flat();
+    if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+    }
+    return paths.map(normalizePathToUnix);
+};
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+    let str = string.replace(BACK_SLASH_RE, SLASH);
+    let prepend = false;
+    if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+    }
+    while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+    }
+    if (prepend) {
+        str = SLASH + str;
+    }
+    return str;
+};
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+// TODO: refactor
+const normalizeIgnored = (cwd = '') => (path) => {
+    if (typeof path === 'string') {
+        return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+    }
+    else {
+        return path;
+    }
+};
+const getAbsolutePath = (path, cwd) => {
+    if (sysPath.isAbsolute(path)) {
+        return path;
+    }
+    return sysPath.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(new Set());
+/**
+ * Directory entry.
+ */
+class DirEntry {
+    constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = new Set();
+    }
+    add(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+            items.add(item);
+    }
+    async remove(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        items.delete(item);
+        if (items.size > 0)
+            return;
+        const dir = this.path;
+        try {
+            await readdir(dir);
+        }
+        catch (err) {
+            if (this._removeWatcher) {
+                this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+            }
+        }
+    }
+    has(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        return items.has(item);
+    }
+    getChildren() {
+        const { items } = this;
+        if (!items)
+            return [];
+        return [...items.values()];
+    }
+    dispose() {
+        this.items.clear();
+        this.path = '';
+        this._removeWatcher = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+    }
+}
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+export class WatchHelper {
+    constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, '');
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+            if (parts.length > 1)
+                parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+    }
+    entryPath(entry) {
+        return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+    }
+    filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+            return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        // TODO: what if stats is undefined? remove !
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+    }
+    filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+    }
+}
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+export class FSWatcher extends EventEmitter {
+    // Not indenting methods for history sake; for now.
+    constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = new Map();
+        this._ignoredPaths = new Set();
+        this._throttled = new Map();
+        this._streams = new Set();
+        this._symlinkPaths = new Map();
+        this._watched = new Map();
+        this._pendingWrites = new Map();
+        this._pendingUnlinks = new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+        const opts = {
+            // Defaults
+            persistent: true,
+            ignoreInitial: false,
+            ignorePermissionErrors: false,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: true,
+            usePolling: false,
+            // useAsync: false,
+            atomic: true, // NOTE: overwritten later (depends on usePolling)
+            ..._opts,
+            // Change format
+            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+            awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false,
+        };
+        // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+        if (isIBMi)
+            opts.usePolling = true;
+        // Editor atomic write normalization enabled by default with fs.watch
+        if (opts.atomic === undefined)
+            opts.atomic = !opts.usePolling;
+        // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100;
+        // Global override. Useful for developers, who need to force polling for all
+        // instances of chokidar, regardless of usage / dependency depth
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== undefined) {
+            const envLower = envPoll.toLowerCase();
+            if (envLower === 'false' || envLower === '0')
+                opts.usePolling = false;
+            else if (envLower === 'true' || envLower === '1')
+                opts.usePolling = true;
+            else
+                opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+            opts.interval = Number.parseInt(envInterval, 10);
+        // This is done to emit ready only once, but each 'add' will increase that?
+        let readyCalls = 0;
+        this._emitReady = () => {
+            readyCalls++;
+            if (readyCalls >= this._readyCount) {
+                this._emitReady = EMPTY_FN;
+                this._readyEmitted = true;
+                // use process.nextTick to allow time for listener to be bound
+                process.nextTick(() => this.emit(EV.READY));
+            }
+        };
+        this._emitRaw = (...args) => this.emit(EV.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        // You’re frozen when your heart’s not open.
+        Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+            // return early if we already have a deeply equal matcher object
+            for (const ignored of this._ignoredPaths) {
+                if (isMatcherObject(ignored) &&
+                    ignored.path === matcher.path &&
+                    ignored.recursive === matcher.recursive) {
+                    return;
+                }
+            }
+        }
+        this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        // now find any matcher objects with the matcher as path
+        if (typeof matcher === 'string') {
+            for (const ignored of this._ignoredPaths) {
+                // TODO (43081j): make this more efficient.
+                // probably just make a `this._ignoredDirectories` or some
+                // such thing.
+                if (isMatcherObject(ignored) && ignored.path === matcher) {
+                    this._ignoredPaths.delete(ignored);
+                }
+            }
+        }
+    }
+    // Public methods
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = undefined;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+            paths = paths.map((path) => {
+                const absPath = getAbsolutePath(path, cwd);
+                // Check `path` instead of `absPath` because the cwd portion can't be a glob
+                return absPath;
+            });
+        }
+        paths.forEach((path) => {
+            this._removeIgnoredPath(path);
+        });
+        this._userIgnored = undefined;
+        if (!this._readyCount)
+            this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path) => {
+            const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+            if (res)
+                this._emitReady();
+            return res;
+        })).then((results) => {
+            if (this.closed)
+                return;
+            results.forEach((item) => {
+                if (item)
+                    this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+            });
+        });
+        return this;
+    }
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_) {
+        if (this.closed)
+            return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+            // convert to absolute path unless relative path already matches
+            if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+                if (cwd)
+                    path = sysPath.join(cwd, path);
+                path = sysPath.resolve(path);
+            }
+            this._closePath(path);
+            this._addIgnoredPath(path);
+            if (this._watched.has(path)) {
+                this._addIgnoredPath({
+                    path,
+                    recursive: true,
+                });
+            }
+            // reset the cached userIgnored anymatch fn
+            // to make ignoredPaths changes effective
+            this._userIgnored = undefined;
+        });
+        return this;
+    }
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close() {
+        if (this._closePromise) {
+            return this._closePromise;
+        }
+        this.closed = true;
+        // Memory management.
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+            const promise = closer();
+            if (promise instanceof Promise)
+                closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = undefined;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length
+            ? Promise.all(closers).then(() => undefined)
+            : Promise.resolve();
+        return this._closePromise;
+    }
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+            const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+            const index = key || ONE_DOT;
+            watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+    }
+    emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== EV.ERROR)
+            this.emit(EV.ALL, event, ...args);
+    }
+    // Common helpers
+    // --------------
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    async _emit(event, path, stats) {
+        if (this.closed)
+            return;
+        const opts = this.options;
+        if (isWindows)
+            path = sysPath.normalize(path);
+        if (opts.cwd)
+            path = sysPath.relative(opts.cwd, path);
+        const args = [path];
+        if (stats != null)
+            args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+            pw.lastChange = new Date();
+            return this;
+        }
+        if (opts.atomic) {
+            if (event === EV.UNLINK) {
+                this._pendingUnlinks.set(path, [event, ...args]);
+                setTimeout(() => {
+                    this._pendingUnlinks.forEach((entry, path) => {
+                        this.emit(...entry);
+                        this.emit(EV.ALL, ...entry);
+                        this._pendingUnlinks.delete(path);
+                    });
+                }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+                return this;
+            }
+            if (event === EV.ADD && this._pendingUnlinks.has(path)) {
+                event = EV.CHANGE;
+                this._pendingUnlinks.delete(path);
+            }
+        }
+        if (awf && (event === EV.ADD || event === EV.CHANGE) && this._readyEmitted) {
+            const awfEmit = (err, stats) => {
+                if (err) {
+                    event = EV.ERROR;
+                    args[0] = err;
+                    this.emitWithAll(event, args);
+                }
+                else if (stats) {
+                    // if stats doesn't exist the file must have been deleted
+                    if (args.length > 1) {
+                        args[1] = stats;
+                    }
+                    else {
+                        args.push(stats);
+                    }
+                    this.emitWithAll(event, args);
+                }
+            };
+            this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+            return this;
+        }
+        if (event === EV.CHANGE) {
+            const isThrottled = !this._throttle(EV.CHANGE, path, 50);
+            if (isThrottled)
+                return this;
+        }
+        if (opts.alwaysStat &&
+            stats === undefined &&
+            (event === EV.ADD || event === EV.ADD_DIR || event === EV.CHANGE)) {
+            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            let stats;
+            try {
+                stats = await stat(fullPath);
+            }
+            catch (err) {
+                // do nothing
+            }
+            // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+            if (!stats || this.closed)
+                return;
+            args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+    }
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error) {
+        const code = error && error.code;
+        if (error &&
+            code !== 'ENOENT' &&
+            code !== 'ENOTDIR' &&
+            (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) {
+            this.emit(EV.ERROR, error);
+        }
+        return error || this.closed;
+    }
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+            this._throttled.set(actionType, new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+            throw new Error('invalid throttle');
+        const actionPath = action.get(path);
+        if (actionPath) {
+            actionPath.count++;
+            return false;
+        }
+        // eslint-disable-next-line prefer-const
+        let timeoutObject;
+        const clear = () => {
+            const item = action.get(path);
+            const count = item ? item.count : 0;
+            action.delete(path);
+            clearTimeout(timeoutObject);
+            if (item)
+                clearTimeout(item.timeoutObject);
+            return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== 'object')
+            return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+            fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+            statcb(fullPath, (err, curStat) => {
+                if (err || !writes.has(path)) {
+                    if (err && err.code !== 'ENOENT')
+                        awfEmit(err);
+                    return;
+                }
+                const now = Number(new Date());
+                if (prevStat && curStat.size !== prevStat.size) {
+                    writes.get(path).lastChange = now;
+                }
+                const pw = writes.get(path);
+                const df = now - pw.lastChange;
+                if (df >= threshold) {
+                    writes.delete(path);
+                    awfEmit(undefined, curStat);
+                }
+                else {
+                    timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+                }
+            });
+        }
+        if (!writes.has(path)) {
+            writes.set(path, {
+                lastChange: now,
+                cancelWait: () => {
+                    writes.delete(path);
+                    clearTimeout(timeoutHandler);
+                    return event;
+                },
+            });
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+    }
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+            return true;
+        if (!this._userIgnored) {
+            const { cwd } = this.options;
+            const ign = this.options.ignored;
+            const ignored = (ign || []).map(normalizeIgnored(cwd));
+            const ignoredPaths = [...this._ignoredPaths];
+            const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+            this._userIgnored = anymatch(list, undefined);
+        }
+        return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+    }
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    // Directory helpers
+    // -----------------
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory) {
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+            this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+    }
+    // File helpers
+    // ------------
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+            return true;
+        return Boolean(Number(stats.mode) & 0o400);
+    }
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory, item, isDirectory) {
+        // if what is being deleted is a directory, get that directory's paths
+        // for recursive deleting and cleaning of watched object
+        // if it is not a directory, nestedDirectoryChildren will be empty array
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.resolve(path);
+        isDirectory =
+            isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        // prevent duplicate handling in case of arriving here nearly simultaneously
+        // via multiple paths (such as _handleFile and _handleDir)
+        if (!this._throttle('remove', path, 100))
+            return;
+        // if the only watched file is removed, watch for its return
+        if (!isDirectory && this._watched.size === 1) {
+            this.add(directory, item, true);
+        }
+        // This will create a new entry in the watched object in either case
+        // so we got to do the directory check beforehand
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        // Recursively remove children directories / files.
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        // Check if item was on the watched list and remove it
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+        // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+        // but never removed from the map in case the path was deleted.
+        // This leads to an incorrect state if the path was recreated:
+        // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+        if (this._symlinkPaths.has(fullPath)) {
+            this._symlinkPaths.delete(fullPath);
+        }
+        // If we wait for this file to be fully written, cancel the wait.
+        let relPath = path;
+        if (this.options.cwd)
+            relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+            const event = this._pendingWrites.get(relPath).cancelWait();
+            if (event === EV.ADD)
+                return;
+        }
+        // The Entry will either be a directory that just got removed
+        // or a bogus entry to a file, in either case we have to remove it
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EV.UNLINK_DIR : EV.UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+            this._emit(eventName, path);
+        // Avoid conflicts if we later create another file with the same name
+        this._closePath(path);
+    }
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+    }
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+            return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+    }
+    _addPathCloser(path, closer) {
+        if (!closer)
+            return;
+        let list = this._closers.get(path);
+        if (!list) {
+            list = [];
+            this._closers.set(path, list);
+        }
+        list.push(closer);
+    }
+    _readdirp(root, opts) {
+        if (this.closed)
+            return;
+        const options = { type: EV.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+            stream = undefined;
+        });
+        stream.once(STR_END, () => {
+            if (stream) {
+                this._streams.delete(stream);
+                stream = undefined;
+            }
+        });
+        return stream;
+    }
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+export function watch(paths, options = {}) {
+    const watcher = new FSWatcher(options);
+    watcher.add(paths);
+    return watcher;
+}
+export default { watch, FSWatcher };

tools/ui/node_modules/svelte-check/node_modules/chokidar/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module", "sideEffects": false }

tools/ui/node_modules/svelte-check/node_modules/chokidar/handler.d.ts

@@ -0,0 +1,90 @@
+import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs';
+import type { FSWatcher, WatchHelper, Throttler } from './index.js';
+import type { EntryInfo } from 'readdirp';
+export type Path = string;
+export declare const STR_DATA = "data";
+export declare const STR_END = "end";
+export declare const STR_CLOSE = "close";
+export declare const EMPTY_FN: () => void;
+export declare const IDENTITY_FN: (val: unknown) => unknown;
+export declare const isWindows: boolean;
+export declare const isMacos: boolean;
+export declare const isLinux: boolean;
+export declare const isFreeBSD: boolean;
+export declare const isIBMi: boolean;
+export declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+export type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+export type FsWatchContainer = {
+    listeners: (path: string) => void | Set<any>;
+    errHandlers: (err: unknown) => void | Set<any>;
+    rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set<any>;
+    watcher: NativeFsWatcher;
+    watcherUnusable?: boolean;
+};
+export interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+/**
+ * @mixin
+ */
+export declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}

tools/ui/node_modules/svelte-check/node_modules/chokidar/handler.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFsHandler = exports.EVENTS = exports.isIBMi = exports.isFreeBSD = exports.isLinux = exports.isMacos = exports.isWindows = exports.IDENTITY_FN = exports.EMPTY_FN = exports.STR_CLOSE = exports.STR_END = exports.STR_DATA = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const sysPath = require("path");
+const os_1 = require("os");
+exports.STR_DATA = 'data';
+exports.STR_END = 'end';
+exports.STR_CLOSE = 'close';
+const EMPTY_FN = () => { };
+exports.EMPTY_FN = EMPTY_FN;
+const IDENTITY_FN = (val) => val;
+exports.IDENTITY_FN = IDENTITY_FN;
+const pl = process.platform;
+exports.isWindows = pl === 'win32';
+exports.isMacos = pl === 'darwin';
+exports.isLinux = pl === 'linux';
+exports.isFreeBSD = pl === 'freebsd';
+exports.isIBMi = (0, os_1.type)() === 'OS400';
+exports.EVENTS = {
+    ALL: 'all',
+    READY: 'ready',
+    ADD: 'add',
+    CHANGE: 'change',
+    ADD_DIR: 'addDir',
+    UNLINK: 'unlink',
+    UNLINK_DIR: 'unlinkDir',
+    RAW: 'raw',
+    ERROR: 'error',
+};
+const EV = exports.EVENTS;
+const THROTTLE_MODE_WATCH = 'watch';
+const statMethods = { lstat: promises_1.lstat, stat: promises_1.stat };
+const KEY_LISTENERS = 'listeners';
+const KEY_ERR = 'errHandlers';
+const KEY_RAW = 'rawEmitters';
+const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+// prettier-ignore
+const binaryExtensions = new Set([
+    '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai',
+    'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi',
+    'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2',
+    'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu',
+    'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts',
+    'dtshd', 'dvb', 'dwg', 'dxf',
+    'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe',
+    'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt',
+    'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip',
+    'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso',
+    'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx',
+    'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo',
+    'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng',
+    'mobi', 'mov', 'movie', 'mp3',
+    'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu',
+    'nef', 'npx', 'numbers', 'nupkg',
+    'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott',
+    'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm',
+    'potx', 'ppa', 'ppam',
+    'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv',
+    'qt',
+    'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz',
+    's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so',
+    'stl', 'suo', 'sub', 'swf',
+    'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz',
+    'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu',
+    'viv', 'vob',
+    'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma',
+    'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx',
+    'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm',
+    'xmind', 'xpi', 'xpm', 'xwd', 'xz',
+    'z', 'zip', 'zipx',
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+    if (val instanceof Set) {
+        val.forEach(fn);
+    }
+    else {
+        fn(val);
+    }
+};
+const addAndConvert = (main, prop, item) => {
+    let container = main[prop];
+    if (!(container instanceof Set)) {
+        main[prop] = container = new Set([container]);
+    }
+    container.add(item);
+};
+const clearItem = (cont) => (key) => {
+    const set = cont[key];
+    if (set instanceof Set) {
+        set.clear();
+    }
+    else {
+        delete cont[key];
+    }
+};
+const delFromSet = (main, prop, item) => {
+    const container = main[prop];
+    if (container instanceof Set) {
+        container.delete(item);
+    }
+    else if (container === item) {
+        delete main[prop];
+    }
+};
+const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val);
+const FsWatchInstances = new Map();
+/**
+ * Instantiates the fs_watch interface
+ * @param path to be watched
+ * @param options to be passed to fs_watch
+ * @param listener main event handler
+ * @param errHandler emits info about errors
+ * @param emitRaw emits raw event data
+ * @returns {NativeFsWatcher}
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+    const handleEvent = (rawEvent, evPath) => {
+        listener(path);
+        emitRaw(rawEvent, evPath, { watchedPath: path });
+        // emit based on events occurring for files from a directory's watcher in
+        // case the file's watcher misses it (and rely on throttling to de-dupe)
+        if (evPath && path !== evPath) {
+            fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+        }
+    };
+    try {
+        return (0, fs_1.watch)(path, {
+            persistent: options.persistent,
+        }, handleEvent);
+    }
+    catch (error) {
+        errHandler(error);
+        return undefined;
+    }
+}
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param fullPath absolute path bound to fs_watch instance
+ */
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+    const cont = FsWatchInstances.get(fullPath);
+    if (!cont)
+        return;
+    foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+    });
+};
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path
+ * @param fullPath absolute path
+ * @param options to be passed to fs_watch
+ * @param handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+    const { listener, errHandler, rawEmitter } = handlers;
+    let cont = FsWatchInstances.get(fullPath);
+    let watcher;
+    if (!options.persistent) {
+        watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+            return;
+        return watcher.close.bind(watcher);
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here
+        fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+        if (!watcher)
+            return;
+        watcher.on(EV.ERROR, async (error) => {
+            const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+            if (cont)
+                cont.watcherUnusable = true; // documented since Node 10.4.1
+            // Workaround for https://github.com/joyent/node/issues/4337
+            if (exports.isWindows && error.code === 'EPERM') {
+                try {
+                    const fd = await (0, promises_1.open)(path, 'r');
+                    await fd.close();
+                    broadcastErr(error);
+                }
+                catch (err) {
+                    // do nothing
+                }
+            }
+            else {
+                broadcastErr(error);
+            }
+        });
+        cont = {
+            listeners: listener,
+            errHandlers: errHandler,
+            rawEmitters: rawEmitter,
+            watcher,
+        };
+        FsWatchInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // removes this instance's listeners and closes the underlying fs_watch
+    // instance if there are no more listeners left
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            // Check to protect against issue gh-730.
+            // if (cont.watcherUnusable) {
+            cont.watcher.close();
+            // }
+            FsWatchInstances.delete(fullPath);
+            HANDLER_KEYS.forEach(clearItem(cont));
+            // @ts-ignore
+            cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+// fs_watchFile helpers
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param path to be watched
+ * @param fullPath absolute path
+ * @param options options to be passed to fs_watchFile
+ * @param handlers container for event listener functions
+ * @returns closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+    const { listener, rawEmitter } = handlers;
+    let cont = FsWatchFileInstances.get(fullPath);
+    // let listeners = new Set();
+    // let rawEmitters = new Set();
+    const copts = cont && cont.options;
+    if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        // "Upgrade" the watcher to persistence or a quicker interval.
+        // This creates some unlikely edge case issues if the user mixes
+        // settings in a very weird way, but solving for those cases
+        // doesn't seem worthwhile for the added complexity.
+        // listeners = cont.listeners;
+        // rawEmitters = cont.rawEmitters;
+        (0, fs_1.unwatchFile)(fullPath);
+        cont = undefined;
+    }
+    if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+    }
+    else {
+        // TODO
+        // listeners.add(listener);
+        // rawEmitters.add(rawEmitter);
+        cont = {
+            listeners: listener,
+            rawEmitters: rawEmitter,
+            options,
+            watcher: (0, fs_1.watchFile)(fullPath, options, (curr, prev) => {
+                foreach(cont.rawEmitters, (rawEmitter) => {
+                    rawEmitter(EV.CHANGE, fullPath, { curr, prev });
+                });
+                const currmtime = curr.mtimeMs;
+                if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+                    foreach(cont.listeners, (listener) => listener(path, curr));
+                }
+            }),
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+    }
+    // const index = cont.listeners.indexOf(listener);
+    // Removes this instance's listeners and closes the underlying fs_watchFile
+    // instance if there are no more listeners left.
+    return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+            FsWatchFileInstances.delete(fullPath);
+            (0, fs_1.unwatchFile)(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+        }
+    };
+};
+/**
+ * @mixin
+ */
+class NodeFsHandler {
+    constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+    }
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path);
+        const basename = sysPath.basename(path);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename);
+        const absolutePath = sysPath.resolve(path);
+        const options = {
+            persistent: opts.persistent,
+        };
+        if (!listener)
+            listener = exports.EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+            const enableBin = opts.interval !== opts.binaryInterval;
+            options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+            closer = setFsWatchFileListener(path, absolutePath, options, {
+                listener,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        else {
+            closer = setFsWatchListener(path, absolutePath, options, {
+                listener,
+                errHandler: this._boundHandleError,
+                rawEmitter: this.fsw._emitRaw,
+            });
+        }
+        return closer;
+    }
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const dirname = sysPath.dirname(file);
+        const basename = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname);
+        // stats is always present
+        let prevStats = stats;
+        // if the file is already being watched, do nothing
+        if (parent.has(basename))
+            return;
+        const listener = async (path, newStats) => {
+            if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+                return;
+            if (!newStats || newStats.mtimeMs === 0) {
+                try {
+                    const newStats = await (0, promises_1.stat)(file);
+                    if (this.fsw.closed)
+                        return;
+                    // Check that change event was not fired because of changed only accessTime.
+                    const at = newStats.atimeMs;
+                    const mt = newStats.mtimeMs;
+                    if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                        this.fsw._emit(EV.CHANGE, file, newStats);
+                    }
+                    if ((exports.isMacos || exports.isLinux || exports.isFreeBSD) && prevStats.ino !== newStats.ino) {
+                        this.fsw._closeFile(path);
+                        prevStats = newStats;
+                        const closer = this._watchWithNodeFs(file, listener);
+                        if (closer)
+                            this.fsw._addPathCloser(path, closer);
+                    }
+                    else {
+                        prevStats = newStats;
+                    }
+                }
+                catch (error) {
+                    // Fix issues where mtime is null but file is still present
+                    this.fsw._remove(dirname, basename);
+                }
+                // add is about to be emitted if file not already tracked in parent
+            }
+            else if (parent.has(basename)) {
+                // Check that change event was not fired because of changed only accessTime.
+                const at = newStats.atimeMs;
+                const mt = newStats.mtimeMs;
+                if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                    this.fsw._emit(EV.CHANGE, file, newStats);
+                }
+                prevStats = newStats;
+            }
+        };
+        // kick off the watcher
+        const closer = this._watchWithNodeFs(file, listener);
+        // emit an add event if we're supposed to
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+            if (!this.fsw._throttle(EV.ADD, file, 0))
+                return;
+            this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+    }
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) {
+            return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+            // watch symlink directly (don't follow) and detect changes
+            this.fsw._incrReadyCount();
+            let linkPath;
+            try {
+                linkPath = await (0, promises_1.realpath)(path);
+            }
+            catch (e) {
+                this.fsw._emitReady();
+                return true;
+            }
+            if (this.fsw.closed)
+                return;
+            if (dir.has(item)) {
+                if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+                    this.fsw._symlinkPaths.set(full, linkPath);
+                    this.fsw._emit(EV.CHANGE, path, entry.stats);
+                }
+            }
+            else {
+                dir.add(item);
+                this.fsw._symlinkPaths.set(full, linkPath);
+                this.fsw._emit(EV.ADD, path, entry.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+        }
+        // don't follow the same symlink more than once
+        if (this.fsw._symlinkPaths.has(full)) {
+            return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+    }
+    _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        // Normalize the directory name on Windows
+        directory = sysPath.join(directory, '');
+        throttler = this.fsw._throttle('readdir', directory, 1000);
+        if (!throttler)
+            return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = new Set();
+        let stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry) => wh.filterPath(entry),
+            directoryFilter: (entry) => wh.filterDir(entry),
+        });
+        if (!stream)
+            return;
+        stream
+            .on(exports.STR_DATA, async (entry) => {
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            const item = entry.path;
+            let path = sysPath.join(directory, item);
+            current.add(item);
+            if (entry.stats.isSymbolicLink() &&
+                (await this._handleSymlink(entry, directory, path, item))) {
+                return;
+            }
+            if (this.fsw.closed) {
+                stream = undefined;
+                return;
+            }
+            // Files that present in current directory snapshot
+            // but absent in previous are added to watch list and
+            // emit `add` event.
+            if (item === target || (!target && !previous.has(item))) {
+                this.fsw._incrReadyCount();
+                // ensure relativeness of path is preserved in case of watcher reuse
+                path = sysPath.join(dir, sysPath.relative(dir, path));
+                this._addToNodeFs(path, initialAdd, wh, depth + 1);
+            }
+        })
+            .on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve, reject) => {
+            if (!stream)
+                return reject();
+            stream.once(exports.STR_END, () => {
+                if (this.fsw.closed) {
+                    stream = undefined;
+                    return;
+                }
+                const wasThrottled = throttler ? throttler.clear() : false;
+                resolve(undefined);
+                // Files that absent in current directory snapshot
+                // but present in previous emit `remove` event
+                // and are removed from @watched[directory].
+                previous
+                    .getChildren()
+                    .filter((item) => {
+                    return item !== directory && !current.has(item);
+                })
+                    .forEach((item) => {
+                    this.fsw._remove(directory, item);
+                });
+                stream = undefined;
+                // one more time for any missed in case changes came in extremely quickly
+                if (wasThrottled)
+                    this._handleRead(directory, false, wh, target, dir, depth, throttler);
+            });
+        });
+    }
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+            this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        // ensure dir is tracked (harmless if redundant)
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+            if (!target) {
+                await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+                if (this.fsw.closed)
+                    return;
+            }
+            closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+                // if current directory is removed, do nothing
+                if (stats && stats.mtimeMs === 0)
+                    return;
+                this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+            });
+        }
+        return closer;
+    }
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) {
+            ready();
+            return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path);
+        if (priorWh) {
+            wh.filterPath = (entry) => priorWh.filterPath(entry);
+            wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        // evaluate what is at the path we're being asked to watch
+        try {
+            const stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed)
+                return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) {
+                ready();
+                return false;
+            }
+            const follow = this.fsw.options.followSymlinks;
+            let closer;
+            if (stats.isDirectory()) {
+                const absPath = sysPath.resolve(path);
+                const targetPath = follow ? await (0, promises_1.realpath)(path) : path;
+                if (this.fsw.closed)
+                    return;
+                closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (absPath !== targetPath && targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(absPath, targetPath);
+                }
+            }
+            else if (stats.isSymbolicLink()) {
+                const targetPath = follow ? await (0, promises_1.realpath)(path) : path;
+                if (this.fsw.closed)
+                    return;
+                const parent = sysPath.dirname(wh.watchPath);
+                this.fsw._getWatchedDir(parent).add(wh.watchPath);
+                this.fsw._emit(EV.ADD, wh.watchPath, stats);
+                closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+                if (this.fsw.closed)
+                    return;
+                // preserve this symlink's target path
+                if (targetPath !== undefined) {
+                    this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+                }
+            }
+            else {
+                closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            }
+            ready();
+            if (closer)
+                this.fsw._addPathCloser(path, closer);
+            return false;
+        }
+        catch (error) {
+            if (this.fsw._handleError(error)) {
+                ready();
+                return path;
+            }
+        }
+    }
+}
+exports.NodeFsHandler = NodeFsHandler;

tools/ui/node_modules/svelte-check/node_modules/chokidar/index.d.ts

@@ -0,0 +1,215 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { Stats } from 'fs';
+import { EventEmitter } from 'events';
+import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp';
+import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js';
+type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+export type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+export type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+export type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+export type EmitArgs = [path: Path, stats?: Stats];
+export type EmitErrorArgs = [error: Error, stats?: Stats];
+export type EmitArgsWithName = [event: EventName, ...EmitArgs];
+export type MatchFunction = (val: string, stats?: Stats) => boolean;
+export interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+export type Matcher = string | RegExp | MatchFunction | MatcherObject;
+/**
+ * Directory entry.
+ */
+declare class DirEntry {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+export declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+export interface FSWatcherKnownEventMap {
+    [EV.READY]: [];
+    [EV.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EV.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EV.ALL]: [event: EventName, ...EmitArgs];
+}
+export type FSWatcherEventMap = FSWatcherKnownEventMap & {
+    [k in Exclude<EventName, keyof FSWatcherKnownEventMap>]: EmitArgs;
+};
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+};
+export default _default;

tools/ui/node_modules/svelte-check/node_modules/chokidar/index.js

@@ -0,0 +1,804 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSWatcher = exports.WatchHelper = void 0;
+exports.watch = watch;
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const events_1 = require("events");
+const sysPath = require("path");
+const readdirp_1 = require("readdirp");
+const handler_js_1 = require("./handler.js");
+const SLASH = '/';
+const SLASH_SLASH = '//';
+const ONE_DOT = '.';
+const TWO_DOTS = '..';
+const STRING_TYPE = 'string';
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+    return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+    if (typeof matcher === 'function')
+        return matcher;
+    if (typeof matcher === 'string')
+        return (string) => matcher === string;
+    if (matcher instanceof RegExp)
+        return (string) => matcher.test(string);
+    if (typeof matcher === 'object' && matcher !== null) {
+        return (string) => {
+            if (matcher.path === string)
+                return true;
+            if (matcher.recursive) {
+                const relative = sysPath.relative(matcher.path, string);
+                if (!relative) {
+                    return false;
+                }
+                return !relative.startsWith('..') && !sysPath.isAbsolute(relative);
+            }
+            return false;
+        };
+    }
+    return () => false;
+}
+function normalizePath(path) {
+    if (typeof path !== 'string')
+        throw new Error('string expected');
+    path = sysPath.normalize(path);
+    path = path.replace(/\\/g, '/');
+    let prepend = false;
+    if (path.startsWith('//'))
+        prepend = true;
+    const DOUBLE_SLASH_RE = /\/\//;
+    while (path.match(DOUBLE_SLASH_RE))
+        path = path.replace(DOUBLE_SLASH_RE, '/');
+    if (prepend)
+        path = '/' + path;
+    return path;
+}
+function matchPatterns(patterns, testString, stats) {
+    const path = normalizePath(testString);
+    for (let index = 0; index < patterns.length; index++) {
+        const pattern = patterns[index];
+        if (pattern(path, stats)) {
+            return true;
+        }
+    }
+    return false;
+}
+function anymatch(matchers, testString) {
+    if (matchers == null) {
+        throw new TypeError('anymatch: specify first argument');
+    }
+    // Early cache for matchers.
+    const matchersArray = arrify(matchers);
+    const patterns = matchersArray.map((matcher) => createPattern(matcher));
+    if (testString == null) {
+        return (testString, stats) => {
+            return matchPatterns(patterns, testString, stats);
+        };
+    }
+    return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+    const paths = arrify(paths_).flat();
+    if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+    }
+    return paths.map(normalizePathToUnix);
+};
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+    let str = string.replace(BACK_SLASH_RE, SLASH);
+    let prepend = false;
+    if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+    }
+    while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+    }
+    if (prepend) {
+        str = SLASH + str;
+    }
+    return str;
+};
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+// TODO: refactor
+const normalizeIgnored = (cwd = '') => (path) => {
+    if (typeof path === 'string') {
+        return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+    }
+    else {
+        return path;
+    }
+};
+const getAbsolutePath = (path, cwd) => {
+    if (sysPath.isAbsolute(path)) {
+        return path;
+    }
+    return sysPath.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(new Set());
+/**
+ * Directory entry.
+ */
+class DirEntry {
+    constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = new Set();
+    }
+    add(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+            items.add(item);
+    }
+    async remove(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        items.delete(item);
+        if (items.size > 0)
+            return;
+        const dir = this.path;
+        try {
+            await (0, promises_1.readdir)(dir);
+        }
+        catch (err) {
+            if (this._removeWatcher) {
+                this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+            }
+        }
+    }
+    has(item) {
+        const { items } = this;
+        if (!items)
+            return;
+        return items.has(item);
+    }
+    getChildren() {
+        const { items } = this;
+        if (!items)
+            return [];
+        return [...items.values()];
+    }
+    dispose() {
+        this.items.clear();
+        this.path = '';
+        this._removeWatcher = handler_js_1.EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+    }
+}
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+    constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, '');
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+            if (parts.length > 1)
+                parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+    }
+    entryPath(entry) {
+        return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+    }
+    filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+            return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        // TODO: what if stats is undefined? remove !
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+    }
+    filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+    }
+}
+exports.WatchHelper = WatchHelper;
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends events_1.EventEmitter {
+    // Not indenting methods for history sake; for now.
+    constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = new Map();
+        this._ignoredPaths = new Set();
+        this._throttled = new Map();
+        this._streams = new Set();
+        this._symlinkPaths = new Map();
+        this._watched = new Map();
+        this._pendingWrites = new Map();
+        this._pendingUnlinks = new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+        const opts = {
+            // Defaults
+            persistent: true,
+            ignoreInitial: false,
+            ignorePermissionErrors: false,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: true,
+            usePolling: false,
+            // useAsync: false,
+            atomic: true, // NOTE: overwritten later (depends on usePolling)
+            ..._opts,
+            // Change format
+            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+            awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false,
+        };
+        // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+        if (handler_js_1.isIBMi)
+            opts.usePolling = true;
+        // Editor atomic write normalization enabled by default with fs.watch
+        if (opts.atomic === undefined)
+            opts.atomic = !opts.usePolling;
+        // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100;
+        // Global override. Useful for developers, who need to force polling for all
+        // instances of chokidar, regardless of usage / dependency depth
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== undefined) {
+            const envLower = envPoll.toLowerCase();
+            if (envLower === 'false' || envLower === '0')
+                opts.usePolling = false;
+            else if (envLower === 'true' || envLower === '1')
+                opts.usePolling = true;
+            else
+                opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+            opts.interval = Number.parseInt(envInterval, 10);
+        // This is done to emit ready only once, but each 'add' will increase that?
+        let readyCalls = 0;
+        this._emitReady = () => {
+            readyCalls++;
+            if (readyCalls >= this._readyCount) {
+                this._emitReady = handler_js_1.EMPTY_FN;
+                this._readyEmitted = true;
+                // use process.nextTick to allow time for listener to be bound
+                process.nextTick(() => this.emit(handler_js_1.EVENTS.READY));
+            }
+        };
+        this._emitRaw = (...args) => this.emit(handler_js_1.EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new handler_js_1.NodeFsHandler(this);
+        // You’re frozen when your heart’s not open.
+        Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+            // return early if we already have a deeply equal matcher object
+            for (const ignored of this._ignoredPaths) {
+                if (isMatcherObject(ignored) &&
+                    ignored.path === matcher.path &&
+                    ignored.recursive === matcher.recursive) {
+                    return;
+                }
+            }
+        }
+        this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        // now find any matcher objects with the matcher as path
+        if (typeof matcher === 'string') {
+            for (const ignored of this._ignoredPaths) {
+                // TODO (43081j): make this more efficient.
+                // probably just make a `this._ignoredDirectories` or some
+                // such thing.
+                if (isMatcherObject(ignored) && ignored.path === matcher) {
+                    this._ignoredPaths.delete(ignored);
+                }
+            }
+        }
+    }
+    // Public methods
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = undefined;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+            paths = paths.map((path) => {
+                const absPath = getAbsolutePath(path, cwd);
+                // Check `path` instead of `absPath` because the cwd portion can't be a glob
+                return absPath;
+            });
+        }
+        paths.forEach((path) => {
+            this._removeIgnoredPath(path);
+        });
+        this._userIgnored = undefined;
+        if (!this._readyCount)
+            this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path) => {
+            const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+            if (res)
+                this._emitReady();
+            return res;
+        })).then((results) => {
+            if (this.closed)
+                return;
+            results.forEach((item) => {
+                if (item)
+                    this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+            });
+        });
+        return this;
+    }
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_) {
+        if (this.closed)
+            return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+            // convert to absolute path unless relative path already matches
+            if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+                if (cwd)
+                    path = sysPath.join(cwd, path);
+                path = sysPath.resolve(path);
+            }
+            this._closePath(path);
+            this._addIgnoredPath(path);
+            if (this._watched.has(path)) {
+                this._addIgnoredPath({
+                    path,
+                    recursive: true,
+                });
+            }
+            // reset the cached userIgnored anymatch fn
+            // to make ignoredPaths changes effective
+            this._userIgnored = undefined;
+        });
+        return this;
+    }
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close() {
+        if (this._closePromise) {
+            return this._closePromise;
+        }
+        this.closed = true;
+        // Memory management.
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+            const promise = closer();
+            if (promise instanceof Promise)
+                closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = undefined;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length
+            ? Promise.all(closers).then(() => undefined)
+            : Promise.resolve();
+        return this._closePromise;
+    }
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+            const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+            const index = key || ONE_DOT;
+            watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+    }
+    emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== handler_js_1.EVENTS.ERROR)
+            this.emit(handler_js_1.EVENTS.ALL, event, ...args);
+    }
+    // Common helpers
+    // --------------
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    async _emit(event, path, stats) {
+        if (this.closed)
+            return;
+        const opts = this.options;
+        if (handler_js_1.isWindows)
+            path = sysPath.normalize(path);
+        if (opts.cwd)
+            path = sysPath.relative(opts.cwd, path);
+        const args = [path];
+        if (stats != null)
+            args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+            pw.lastChange = new Date();
+            return this;
+        }
+        if (opts.atomic) {
+            if (event === handler_js_1.EVENTS.UNLINK) {
+                this._pendingUnlinks.set(path, [event, ...args]);
+                setTimeout(() => {
+                    this._pendingUnlinks.forEach((entry, path) => {
+                        this.emit(...entry);
+                        this.emit(handler_js_1.EVENTS.ALL, ...entry);
+                        this._pendingUnlinks.delete(path);
+                    });
+                }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+                return this;
+            }
+            if (event === handler_js_1.EVENTS.ADD && this._pendingUnlinks.has(path)) {
+                event = handler_js_1.EVENTS.CHANGE;
+                this._pendingUnlinks.delete(path);
+            }
+        }
+        if (awf && (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.CHANGE) && this._readyEmitted) {
+            const awfEmit = (err, stats) => {
+                if (err) {
+                    event = handler_js_1.EVENTS.ERROR;
+                    args[0] = err;
+                    this.emitWithAll(event, args);
+                }
+                else if (stats) {
+                    // if stats doesn't exist the file must have been deleted
+                    if (args.length > 1) {
+                        args[1] = stats;
+                    }
+                    else {
+                        args.push(stats);
+                    }
+                    this.emitWithAll(event, args);
+                }
+            };
+            this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+            return this;
+        }
+        if (event === handler_js_1.EVENTS.CHANGE) {
+            const isThrottled = !this._throttle(handler_js_1.EVENTS.CHANGE, path, 50);
+            if (isThrottled)
+                return this;
+        }
+        if (opts.alwaysStat &&
+            stats === undefined &&
+            (event === handler_js_1.EVENTS.ADD || event === handler_js_1.EVENTS.ADD_DIR || event === handler_js_1.EVENTS.CHANGE)) {
+            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            let stats;
+            try {
+                stats = await (0, promises_1.stat)(fullPath);
+            }
+            catch (err) {
+                // do nothing
+            }
+            // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+            if (!stats || this.closed)
+                return;
+            args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+    }
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error) {
+        const code = error && error.code;
+        if (error &&
+            code !== 'ENOENT' &&
+            code !== 'ENOTDIR' &&
+            (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) {
+            this.emit(handler_js_1.EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+    }
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+            this._throttled.set(actionType, new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+            throw new Error('invalid throttle');
+        const actionPath = action.get(path);
+        if (actionPath) {
+            actionPath.count++;
+            return false;
+        }
+        // eslint-disable-next-line prefer-const
+        let timeoutObject;
+        const clear = () => {
+            const item = action.get(path);
+            const count = item ? item.count : 0;
+            action.delete(path);
+            clearTimeout(timeoutObject);
+            if (item)
+                clearTimeout(item.timeoutObject);
+            return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== 'object')
+            return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+            fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+            (0, fs_1.stat)(fullPath, (err, curStat) => {
+                if (err || !writes.has(path)) {
+                    if (err && err.code !== 'ENOENT')
+                        awfEmit(err);
+                    return;
+                }
+                const now = Number(new Date());
+                if (prevStat && curStat.size !== prevStat.size) {
+                    writes.get(path).lastChange = now;
+                }
+                const pw = writes.get(path);
+                const df = now - pw.lastChange;
+                if (df >= threshold) {
+                    writes.delete(path);
+                    awfEmit(undefined, curStat);
+                }
+                else {
+                    timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+                }
+            });
+        }
+        if (!writes.has(path)) {
+            writes.set(path, {
+                lastChange: now,
+                cancelWait: () => {
+                    writes.delete(path);
+                    clearTimeout(timeoutHandler);
+                    return event;
+                },
+            });
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+    }
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+            return true;
+        if (!this._userIgnored) {
+            const { cwd } = this.options;
+            const ign = this.options.ignored;
+            const ignored = (ign || []).map(normalizeIgnored(cwd));
+            const ignoredPaths = [...this._ignoredPaths];
+            const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+            this._userIgnored = anymatch(list, undefined);
+        }
+        return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+    }
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    // Directory helpers
+    // -----------------
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory) {
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+            this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+    }
+    // File helpers
+    // ------------
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+            return true;
+        return Boolean(Number(stats.mode) & 0o400);
+    }
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory, item, isDirectory) {
+        // if what is being deleted is a directory, get that directory's paths
+        // for recursive deleting and cleaning of watched object
+        // if it is not a directory, nestedDirectoryChildren will be empty array
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.resolve(path);
+        isDirectory =
+            isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        // prevent duplicate handling in case of arriving here nearly simultaneously
+        // via multiple paths (such as _handleFile and _handleDir)
+        if (!this._throttle('remove', path, 100))
+            return;
+        // if the only watched file is removed, watch for its return
+        if (!isDirectory && this._watched.size === 1) {
+            this.add(directory, item, true);
+        }
+        // This will create a new entry in the watched object in either case
+        // so we got to do the directory check beforehand
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        // Recursively remove children directories / files.
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        // Check if item was on the watched list and remove it
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+        // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+        // but never removed from the map in case the path was deleted.
+        // This leads to an incorrect state if the path was recreated:
+        // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+        if (this._symlinkPaths.has(fullPath)) {
+            this._symlinkPaths.delete(fullPath);
+        }
+        // If we wait for this file to be fully written, cancel the wait.
+        let relPath = path;
+        if (this.options.cwd)
+            relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+            const event = this._pendingWrites.get(relPath).cancelWait();
+            if (event === handler_js_1.EVENTS.ADD)
+                return;
+        }
+        // The Entry will either be a directory that just got removed
+        // or a bogus entry to a file, in either case we have to remove it
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? handler_js_1.EVENTS.UNLINK_DIR : handler_js_1.EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+            this._emit(eventName, path);
+        // Avoid conflicts if we later create another file with the same name
+        this._closePath(path);
+    }
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+    }
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+            return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+    }
+    _addPathCloser(path, closer) {
+        if (!closer)
+            return;
+        let list = this._closers.get(path);
+        if (!list) {
+            list = [];
+            this._closers.set(path, list);
+        }
+        list.push(closer);
+    }
+    _readdirp(root, opts) {
+        if (this.closed)
+            return;
+        const options = { type: handler_js_1.EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = (0, readdirp_1.readdirp)(root, options);
+        this._streams.add(stream);
+        stream.once(handler_js_1.STR_CLOSE, () => {
+            stream = undefined;
+        });
+        stream.once(handler_js_1.STR_END, () => {
+            if (stream) {
+                this._streams.delete(stream);
+                stream = undefined;
+            }
+        });
+        return stream;
+    }
+}
+exports.FSWatcher = FSWatcher;
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+function watch(paths, options = {}) {
+    const watcher = new FSWatcher(options);
+    watcher.add(paths);
+    return watcher;
+}
+exports.default = { watch, FSWatcher };

tools/ui/node_modules/svelte-check/node_modules/chokidar/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "chokidar",
+  "description": "Minimal and efficient cross-platform file watching library",
+  "version": "4.0.3",
+  "homepage": "https://github.com/paulmillr/chokidar",
+  "author": "Paul Miller (https://paulmillr.com)",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "handler.js",
+    "handler.d.ts",
+    "esm"
+  ],
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./handler.js": {
+      "import": "./esm/handler.js",
+      "require": "./handler.js"
+    }
+  },
+  "dependencies": {
+    "readdirp": "^4.0.1"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.2.1",
+    "@types/node": "20.14.8",
+    "chai": "4.3.4",
+    "prettier": "3.1.1",
+    "rimraf": "5.0.5",
+    "sinon": "12.0.1",
+    "sinon-chai": "3.7.0",
+    "typescript": "5.5.2",
+    "upath": "2.0.1"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 14.16.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paulmillr/chokidar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/paulmillr/chokidar/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "lint": "prettier --check src",
+    "format": "prettier --write src",
+    "test": "node --test"
+  },
+  "keywords": [
+    "fs",
+    "watch",
+    "watchFile",
+    "watcher",
+    "watching",
+    "file",
+    "fsevents"
+  ],
+  "funding": "https://paulmillr.com/funding/"
+}

tools/ui/node_modules/svelte-check/node_modules/readdirp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
+
+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.

tools/ui/node_modules/svelte-check/node_modules/readdirp/README.md

@@ -0,0 +1,120 @@
+# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
+
+Recursive version of fs.readdir. Exposes a **stream API** (with small RAM & CPU footprint) and a **promise API**.
+
+```sh
+npm install readdirp
+jsr add jsr:@paulmillr/readdirp
+```
+
+```javascript
+// Use streams to achieve small RAM & CPU footprint.
+// 1) Streams example with for-await.
+import readdirp from 'readdirp';
+for await (const entry of readdirp('.')) {
+  const {path} = entry;
+  console.log(`${JSON.stringify({path})}`);
+}
+
+// 2) Streams example, non for-await.
+// Print out all JS files along with their size within the current folder & subfolders.
+import readdirp from 'readdirp';
+readdirp('.', {alwaysStat: true, fileFilter: (f) => f.basename.endsWith('.js')})
+  .on('data', (entry) => {
+    const {path, stats: {size}} = entry;
+    console.log(`${JSON.stringify({path, size})}`);
+  })
+  // Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted
+  .on('warn', error => console.error('non-fatal error', error))
+  .on('error', error => console.error('fatal error', error))
+  .on('end', () => console.log('done'));
+
+// 3) Promise example. More RAM and CPU than streams / for-await.
+import { readdirpPromise } from 'readdirp';
+const files = await readdirpPromise('.');
+console.log(files.map(file => file.path));
+
+// Other options.
+import readdirp from 'readdirp';
+readdirp('test', {
+  fileFilter: (f) => f.basename.endsWith('.js'),
+  directoryFilter: (d) => d.basename !== '.git',
+  // directoryFilter: (di) => di.basename.length === 9
+  type: 'files_directories',
+  depth: 1
+});
+```
+
+## API
+
+`const stream = readdirp(root[, options])` — **Stream API**
+
+- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo)
+- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`).
+- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir.
+- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user.
+- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed.
+- `on('end')` — we are done. Called when all entries were found and no more will be emitted.
+- `on('close')` — stream is destroyed via `stream.destroy()`.
+  Could be useful if you want to manually abort even on a non fatal error.
+  At that point the stream is no longer `readable` and no more entries, warning or errors are emitted
+- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html)
+  or the [stream-handbook](https://github.com/substack/stream-handbook)
+
+`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo).
+
+First argument is awalys `root`, path in which to start reading and recursing into subdirectories.
+
+### options
+
+- `fileFilter`: filter to include or exclude files
+    - **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry
+- `directoryFilter`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into.
+- `depth: 5`: depth at which to stop recursing even if more subdirectories are found
+- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes.
+- `alwaysStat: false`: always return `stats` property for every file. Default is `false`, readdirp will return `Dirent` entries. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0.
+- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat`
+
+### `EntryInfo`
+
+Has the following properties:
+
+- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root)
+- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found
+- `basename: 'react.js'`: name of the file/directory
+- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false`
+- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true`
+
+## Changelog
+
+- 4.0 (Aug 25, 2024) rewritten in typescript, producing hybrid common.js / esm module.
+    - Remove glob support and all dependencies
+    - Make sure you're using `let {readdirp} = require('readdirp')` in common.js
+- 3.5 (Oct 13, 2020) disallows recursive directory-based symlinks.
+  Before, it could have entered infinite loop.
+- 3.4 (Mar 19, 2020) adds support for directory-based symlinks.
+- 3.3 (Dec 6, 2019) stabilizes RAM consumption and enables perf management with `highWaterMark` option. Fixes race conditions related to `for-await` looping.
+- 3.2 (Oct 14, 2019) improves performance by 250% and makes streams implementation more idiomatic.
+- 3.1 (Jul 7, 2019) brings `bigint` support to `stat` output on Windows. This is backwards-incompatible for some cases. Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions".
+- 3.0 brings huge performance improvements and stream backpressure support.
+- Upgrading 2.x to 3.x:
+    - Signature changed from `readdirp(options)` to `readdirp(root, options)`
+    - Replaced callback API with promise API.
+    - Renamed `entryType` option to `type`
+    - Renamed `entryType: 'both'` to `'files_directories'`
+    - `EntryInfo`
+        - Renamed `stat` to `stats`
+            - Emitted only when `alwaysStat: true`
+            - `dirent` is emitted instead of `stats` by default with `alwaysStat: false`
+        - Renamed `name` to `basename`
+        - Removed `parentDir` and `fullParentDir` properties
+- Supported node.js versions:
+    - 4.x: node 14+
+    - 3.x: node 8+
+    - 2.x: node 0.6+
+
+## License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (<https://paulmillr.com>)
+
+MIT License, see [LICENSE](LICENSE) file.

tools/ui/node_modules/svelte-check/node_modules/readdirp/esm/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Recursive version of readdir. Exposes a streaming API and promise API.
+ * Streaming API allows to use a small amount of RAM.
+ *
+ * @module
+ * @example
+```js
+import readdirp from 'readdirp';
+for await (const entry of readdirp('.')) {
+  const {path} = entry;
+  console.log(`${JSON.stringify({path})}`);
+}
+```
+ */
+/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */
+import type { Stats, Dirent } from 'node:fs';
+import { Readable } from 'node:stream';
+/** Path in file system. */
+export type Path = string;
+/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
+export interface EntryInfo {
+    path: string;
+    fullPath: string;
+    stats?: Stats;
+    dirent?: Dirent;
+    basename: string;
+}
+/** Path or dir entries (files) */
+export type PathOrDirent = Dirent | Path;
+/** Filterer for files */
+export type Tester = (entryInfo: EntryInfo) => boolean;
+export type Predicate = string[] | string | Tester;
+export declare const EntryTypes: {
+    readonly FILE_TYPE: "files";
+    readonly DIR_TYPE: "directories";
+    readonly FILE_DIR_TYPE: "files_directories";
+    readonly EVERYTHING_TYPE: "all";
+};
+export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
+/**
+ * Options for readdirp.
+ * * type: files, directories, or both
+ * * lstat: whether to use symlink-friendly stat
+ * * depth: max depth
+ * * alwaysStat: whether to use stat (more resources) or dirent
+ * * highWaterMark: streaming param, specifies max amount of resources per entry
+ */
+export type ReaddirpOptions = {
+    root: string;
+    fileFilter?: Predicate;
+    directoryFilter?: Predicate;
+    type?: EntryType;
+    lstat?: boolean;
+    depth?: number;
+    alwaysStat?: boolean;
+    highWaterMark?: number;
+};
+/** Directory entry. Contains path, depth count, and files. */
+export interface DirEntry {
+    files: PathOrDirent[];
+    depth: number;
+    path: Path;
+}
+/** Readable readdir stream, emitting new files as they're being listed. */
+export declare class ReaddirpStream extends Readable {
+    parents: any[];
+    reading: boolean;
+    parent?: DirEntry;
+    _stat: Function;
+    _maxDepth: number;
+    _wantsDir: boolean;
+    _wantsFile: boolean;
+    _wantsEverything: boolean;
+    _root: Path;
+    _isDirent: boolean;
+    _statsProp: 'dirent' | 'stats';
+    _rdOptions: {
+        encoding: 'utf8';
+        withFileTypes: boolean;
+    };
+    _fileFilter: Tester;
+    _directoryFilter: Tester;
+    constructor(options?: Partial<ReaddirpOptions>);
+    _read(batch: number): Promise<void>;
+    _exploreDir(path: Path, depth: number): Promise<{
+        files: string[] | undefined;
+        depth: number;
+        path: string;
+    }>;
+    _formatEntry(dirent: PathOrDirent, path: Path): Promise<EntryInfo | undefined>;
+    _onError(err: Error): void;
+    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
+    _includeAsFile(entry: EntryInfo): boolean | undefined;
+}
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+export declare function readdirp(root: Path, options?: Partial<ReaddirpOptions>): ReaddirpStream;
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+export declare function readdirpPromise(root: Path, options?: Partial<ReaddirpOptions>): Promise<EntryInfo[]>;
+export default readdirp;

tools/ui/node_modules/svelte-check/node_modules/readdirp/esm/index.js

@@ -0,0 +1,257 @@
+import { stat, lstat, readdir, realpath } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from 'node:path';
+export const EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+export class ReaddirpStream extends Readable {
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? lstat : stat;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = presolve(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await readdir(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = presolve(pjoin(path, basename));
+            entry = { path: prelative(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await realpath(full);
+                const entryRealPathStats = await lstat(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+export function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+export function readdirpPromise(root, options = {}) {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        readdirp(root, options)
+            .on('data', (entry) => files.push(entry))
+            .on('end', () => resolve(files))
+            .on('error', (error) => reject(error));
+    });
+}
+export default readdirp;

tools/ui/node_modules/svelte-check/node_modules/readdirp/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module", "sideEffects": false }