Upload folder using huggingface_hub (part 47)

tools/ui/node_modules/prettier-plugin-tailwindcss/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Tailwind Labs Inc.
+
+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/prettier-plugin-tailwindcss/README.md

@@ -0,0 +1,328 @@
+<img src="https://raw.githubusercontent.com/tailwindlabs/prettier-plugin-tailwindcss/main/.github/banner.jpg" alt="prettier-plugin-tailwindcss" />
+
+A [Prettier v3+](https://prettier.io/) plugin for Tailwind CSS v3.0+ that automatically sorts classes based on [our recommended class order](https://tailwindcss.com/blog/automatic-class-sorting-with-prettier#how-classes-are-sorted).
+
+## Installation
+
+To get started, install `prettier-plugin-tailwindcss` as a dev-dependency:
+
+```sh
+npm install -D prettier prettier-plugin-tailwindcss
+```
+
+Then add the plugin to your [Prettier configuration](https://prettier.io/docs/en/configuration.html):
+
+```json5
+// .prettierrc
+{
+  "plugins": ["prettier-plugin-tailwindcss"]
+}
+```
+
+When using a JavaScript config, you can import the types for IntelliSense:
+
+```js
+// prettier.config.js
+
+/** @type {import('prettier').Config & import('prettier-plugin-tailwindcss').PluginOptions} */
+export default {
+  plugins: ["prettier-plugin-tailwindcss"],
+}
+```
+
+## Upgrading to v0.5.x
+
+As of v0.5.x, this plugin now requires Prettier v3 and is ESM-only. This means it cannot be loaded via `require()`. For more information see our [upgrade guide](https://github.com/tailwindlabs/prettier-plugin-tailwindcss/issues/207#issuecomment-1698071122).
+
+## Options
+
+### Specifying your Tailwind stylesheet path (Tailwind CSS v4+)
+
+When using Tailwind CSS v4 you must specify your CSS file entry point, which includes your theme, custom utilities, and other Tailwind configuration options. To do this, use the `tailwindStylesheet` option in your Prettier configuration.
+
+Note that paths are resolved relative to the Prettier configuration file.
+
+```json5
+// .prettierrc
+{
+  "tailwindStylesheet": "./resources/css/app.css"
+}
+```
+
+### Specifying your Tailwind JavaScript config path (Tailwind CSS v3)
+
+To ensure that the class sorting takes into consideration any of your project's Tailwind customizations, it needs access to your [Tailwind configuration file](https://tailwindcss.com/docs/configuration) (`tailwind.config.js`).
+
+By default the plugin will look for this file in the same directory as your Prettier configuration file. However, if your Tailwind configuration is somewhere else, you can specify this using the `tailwindConfig` option in your Prettier configuration.
+
+Note that paths are resolved relative to the Prettier configuration file.
+
+```json5
+// .prettierrc
+{
+  "tailwindConfig": "./styles/tailwind.config.js"
+}
+```
+
+If a local configuration file cannot be found the plugin will fallback to the default Tailwind configuration.
+
+## Sorting non-standard attributes
+
+By default this plugin sorts classes in the `class` attribute, any framework-specific equivalents like `className`, `:class`, `[ngClass]`, and any Tailwind `@apply` directives.
+
+You can sort additional attributes using the `tailwindAttributes` option, which takes an array of attribute names:
+
+```json5
+// .prettierrc
+{
+  "tailwindAttributes": ["myClassList"]
+}
+```
+
+With this configuration, any classes found in the `myClassList` attribute will be sorted:
+
+```jsx
+function MyButton({ children }) {
+  return (
+    <button myClassList="rounded bg-blue-500 px-4 py-2 text-base text-white">
+      {children}
+    </button>
+  );
+}
+```
+
+### Using regex patterns
+
+You can also use regular expressions to match multiple attributes. Patterns should be enclosed in forward slashes. Note that JS regex literals are not supported with Prettier:
+
+```json5
+// .prettierrc
+{
+  "tailwindAttributes": ["myClassList", "/data-.*/"]
+}
+```
+
+This example will sort classes in the `myClassList` attribute as well as any attribute starting with `data-`:
+
+```jsx
+function MyButton({ children }) {
+  return (
+    <button
+      myClassList="rounded bg-blue-500 px-4 py-2 text-base text-white"
+      data-theme="dark:bg-gray-800 bg-white"
+      data-classes="flex items-center"
+    >
+      {children}
+    </button>
+  );
+}
+```
+
+## Sorting classes in function calls
+
+In addition to sorting classes in attributes, you can also sort classes in strings provided to function calls. This is useful when working with libraries like [clsx](https://github.com/lukeed/clsx) or [cva](https://cva.style/).
+
+You can sort classes in function calls using the `tailwindFunctions` option, which takes a list of function names:
+
+```json5
+// .prettierrc
+{
+  "tailwindFunctions": ["clsx"]
+}
+```
+
+With this configuration, any classes in `clsx()` function calls will be sorted:
+
+```jsx
+import clsx from 'clsx'
+
+function MyButton({ isHovering, children }) {
+  let classes = clsx(
+    'rounded bg-blue-500 px-4 py-2 text-base text-white',
+    {
+      'bg-blue-700 text-gray-100': isHovering,
+    },
+  )
+
+  return (
+    <button className={classes}>
+      {children}
+    </button>
+  )
+}
+```
+
+## Sorting classes in template literals
+
+This plugin also enables sorting of classes in tagged template literals.
+
+You can sort classes in template literals using the `tailwindFunctions` option, which takes a list of function names:
+
+```json5
+// .prettierrc
+{
+  "tailwindFunctions": ["tw"],
+}
+```
+
+With this configuration, any classes in template literals tagged with `tw` will automatically be sorted:
+
+```jsx
+import { View, Text } from 'react-native'
+import tw from 'twrnc'
+
+function MyScreen() {
+  return (
+    <View style={tw`bg-white p-4 dark:bg-black`}>
+      <Text style={tw`text-md text-black dark:text-white`}>Hello World</Text>
+    </View>
+  )
+}
+```
+
+This feature can be used with third-party libraries like `twrnc` or you can create your own tagged template by defining this "identity" function:
+
+```js
+const tw = (strings, ...values) => String.raw({ raw: strings }, ...values)
+```
+
+Once added, tag your strings with the function and the plugin will sort them:
+
+```js
+const mySortedClasses = tw`bg-white p-4 dark:bg-black`
+```
+
+## Public API
+
+If you want to use the Tailwind class sorting logic outside of Prettier, import from the
+`sorter` entrypoint:
+
+```js
+import { createSorter } from 'prettier-plugin-tailwindcss/sorter'
+
+let sorter = await createSorter({
+  base: '/path/to/project',
+  stylesheetPath: './app.css',
+})
+
+// Sort HTML class attributes (space-separated strings)
+let sorted = sorter.sortClassAttributes([
+  'sm:bg-tomato bg-red-500',
+  'p-4 m-2'
+])
+// Returns: ['bg-red-500 sm:bg-tomato', 'm-2 p-4']
+
+// Sort class lists (arrays of class names)
+let sortedLists = sorter.sortClassLists([
+  ['sm:bg-tomato', 'bg-red-500'],
+  ['p-4', 'm-2']
+])
+// Returns: [['bg-red-500', 'sm:bg-tomato'], ['m-2', 'p-4']]
+```
+
+### API Options
+
+The `createSorter` function accepts the following options:
+
+- **`base`** (optional): The directory used to resolve relative file paths. Defaults to the current working directory.
+- **`filepath`** (optional): The path to the file being formatted. When provided, Tailwind CSS is resolved relative to this path.
+- **`configPath`** (optional): Path to the Tailwind CSS config file (v3). Paths are resolved relative to `base`.
+- **`stylesheetPath`** (optional): Path to the CSS stylesheet used by Tailwind CSS (v4+). Paths are resolved relative to `base`.
+- **`preserveWhitespace`** (optional): Whether to preserve whitespace around classes. Default: `false`.
+- **`preserveDuplicates`** (optional): Whether to preserve duplicate classes. Default: `false`.
+
+### Sorter Methods
+
+The sorter object returned by `createSorter` has two methods:
+
+- **`sortClassAttributes(classes: string[]): string[]`**
+  Sorts one or more HTML class attributes. Each element should be a space-separated string of class names (like the value of an HTML `class` attribute).
+
+- **`sortClassLists(classes: string[][]): (string | null)[][]`**
+  Sorts one or more class lists. Each element should be an array of individual class names. When removing duplicates (default behavior), duplicate classes are replaced with `null` in the output.
+
+### Using regex patterns
+
+Like the `tailwindAttributes` option, the `tailwindFunctions` option also supports regular expressions to match multiple function names. Patterns should be enclosed in forward slashes. Note that JS regex literals are not supported with Prettier.
+
+## Preserving whitespace
+
+This plugin automatically removes unnecessary whitespace between classes to ensure consistent formatting. If you prefer to preserve whitespace, you can use the `tailwindPreserveWhitespace` option:
+
+```json5
+// .prettierrc
+{
+  "tailwindPreserveWhitespace": true,
+}
+```
+
+With this configuration, any whitespace surrounding classes will be preserved:
+
+```jsx
+import clsx from 'clsx'
+
+function MyButton({ isHovering, children }) {
+  return (
+    <button className=" rounded  bg-blue-500 px-4  py-2     text-base text-white ">
+      {children}
+    </button>
+  )
+}
+```
+
+## Preserving duplicate classes
+
+This plugin automatically removes duplicate classes from your class lists. However, this can cause issues in some templating languages, like Fluid or Blade, where we can't distinguish between classes and the templating syntax.
+
+If removing duplicate classes is causing issues in your project, you can use the `tailwindPreserveDuplicates` option to disable this behavior:
+
+```json5
+// .prettierrc
+{
+  "tailwindPreserveDuplicates": true,
+}
+```
+
+With this configuration, anything we perceive as duplicate classes will be preserved:
+
+```html
+<div
+  class="
+    {f:if(condition: isCompact, then: 'grid-cols-3', else: 'grid-cols-5')}
+    {f:if(condition: isDark, then: 'bg-black/50', else: 'bg-white/50')}
+    grid gap-4 p-4
+  "
+>
+</div>
+```
+
+## Compatibility with other Prettier plugins
+
+This plugin uses Prettier APIs that can only be used by one plugin at a time, making it incompatible with other Prettier plugins implemented the same way. To solve this we've added explicit per-plugin workarounds that enable compatibility with the following Prettier plugins:
+
+- `@ianvs/prettier-plugin-sort-imports`
+- `@prettier/plugin-pug`
+- `@shopify/prettier-plugin-liquid`
+- `@trivago/prettier-plugin-sort-imports`
+- `prettier-plugin-astro`
+- `prettier-plugin-css-order`
+- `prettier-plugin-jsdoc`
+- `prettier-plugin-multiline-arrays`
+- `prettier-plugin-organize-attributes`
+- `prettier-plugin-organize-imports`
+- `prettier-plugin-svelte`
+- `prettier-plugin-sort-imports`
+
+One limitation with this approach is that `prettier-plugin-tailwindcss` *must* be loaded last.
+
+```json5
+// .prettierrc
+{
+  // ..
+  "plugins": [
+    "prettier-plugin-svelte",
+    "prettier-plugin-organize-imports",
+    "prettier-plugin-tailwindcss" // MUST come last
+  ]
+}
+```

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/chunk-DSjvVL_1.mjs

@@ -0,0 +1,34 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+export { __toESM as a, __require as i, __esmMin as n, __exportAll as r, __commonJSMin as t };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/index.d.mts

@@ -0,0 +1,50 @@
+import * as prettier0 from "prettier";
+import { SupportOption } from "prettier";
+
+//#region src/options.d.ts
+declare const options: Record<string, SupportOption>;
+//#endregion
+//#region src/index.d.ts
+declare const parsers: Record<string, prettier0.Parser<any> | (() => Promise<prettier0.Parser<any> | undefined>) | undefined>, printers: Record<string, prettier0.Printer<any> | (() => Promise<prettier0.Printer<any> | undefined>) | undefined>;
+interface PluginOptions {
+  /**
+   * Path to the Tailwind config file.
+   */
+  tailwindConfig?: string;
+  /**
+   * Path to the CSS stylesheet used by Tailwind CSS (v4+)
+   */
+  tailwindStylesheet?: string;
+  /**
+   * Path to the CSS stylesheet used by Tailwind CSS (v4+)
+   *
+   * @deprecated Use `tailwindStylesheet` instead
+   */
+  tailwindEntryPoint?: string;
+  /**
+   * List of custom function and tag names that contain classes.
+   *
+   * Default: []
+   */
+  tailwindFunctions?: string[];
+  /**
+   * List of custom attributes that contain classes.
+   *
+   * Default: []
+   */
+  tailwindAttributes?: string[];
+  /**
+   * Preserve whitespace around Tailwind classes when sorting.
+   *
+   * Default: false
+   */
+  tailwindPreserveWhitespace?: boolean;
+  /**
+   * Preserve duplicate classes inside a class list when sorting.
+   *
+   * Default: false
+   */
+  tailwindPreserveDuplicates?: boolean;
+}
+//#endregion
+export { PluginOptions, options, parsers, printers };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/index.mjs

@@ -0,0 +1,1208 @@
+import { a as __toESM, t as __commonJSMin } from "./chunk-DSjvVL_1.mjs";
+import { a as error, i as sortClasses, n as getTailwindConfig$1, o as warn, r as sortClassList } from "./sorter-BZkvDMjt.mjs";
+import { a as expiringMap, n as maybeResolve, t as loadIfExists } from "./resolve-pWjAK-4f.mjs";
+import { i as visit, n as cacheForDirs, r as spliceChangesIntoString } from "./utils-D8dQkKEd.mjs";
+import * as prettierParserAngular from "prettier/plugins/angular";
+import * as prettierParserBabel from "prettier/plugins/babel";
+import * as prettierParserCss from "prettier/plugins/postcss";
+import { isAbsolute } from "path";
+import * as path from "node:path";
+import prettier from "prettier";
+var require_isarray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toString = {}.toString;
+	module.exports = Array.isArray || function(arr) {
+		return toString.call(arr) == "[object Array]";
+	};
+}));
+/*!
+* isobject <https://github.com/jonschlinkert/isobject>
+*
+* Copyright (c) 2014-2015, Jon Schlinkert.
+* Licensed under the MIT License.
+*/
+var require_isobject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isarray();
+	module.exports = function isObject(val) {
+		return val != null && typeof val === "object" && isArray(val) === false;
+	};
+}));
+var import_line_column = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isarray();
+	var isObject = require_isobject();
+	Array.prototype.slice;
+	module.exports = LineColumnFinder;
+	function LineColumnFinder(str, options) {
+		if (!(this instanceof LineColumnFinder)) {
+			if (typeof options === "number") return new LineColumnFinder(str).fromIndex(options);
+			return new LineColumnFinder(str, options);
+		}
+		this.str = str || "";
+		this.lineToIndex = buildLineToIndex(this.str);
+		options = options || {};
+		this.origin = typeof options.origin === "undefined" ? 1 : options.origin;
+	}
+	LineColumnFinder.prototype.fromIndex = function(index) {
+		if (index < 0 || index >= this.str.length || isNaN(index)) return null;
+		var line = findLowerIndexInRangeArray(index, this.lineToIndex);
+		return {
+			line: line + this.origin,
+			col: index - this.lineToIndex[line] + this.origin
+		};
+	};
+	LineColumnFinder.prototype.toIndex = function(line, column) {
+		if (typeof column === "undefined") {
+			if (isArray(line) && line.length >= 2) return this.toIndex(line[0], line[1]);
+			if (isObject(line) && "line" in line && ("col" in line || "column" in line)) return this.toIndex(line.line, "col" in line ? line.col : line.column);
+			return -1;
+		}
+		if (isNaN(line) || isNaN(column)) return -1;
+		line -= this.origin;
+		column -= this.origin;
+		if (line >= 0 && column >= 0 && line < this.lineToIndex.length) {
+			var lineIndex = this.lineToIndex[line];
+			var nextIndex = line === this.lineToIndex.length - 1 ? this.str.length : this.lineToIndex[line + 1];
+			if (column < nextIndex - lineIndex) return lineIndex + column;
+		}
+		return -1;
+	};
+	function buildLineToIndex(str) {
+		var lines = str.split("\n"), lineToIndex = new Array(lines.length), index = 0;
+		for (var i = 0, l = lines.length; i < l; i++) {
+			lineToIndex[i] = index;
+			index += lines[i].length + 1;
+		}
+		return lineToIndex;
+	}
+	function findLowerIndexInRangeArray(value, arr) {
+		if (value >= arr[arr.length - 1]) return arr.length - 1;
+		var min = 0, max = arr.length - 2, mid;
+		while (min < max) {
+			mid = min + (max - min >> 1);
+			if (value < arr[mid]) max = mid - 1;
+			else if (value >= arr[mid + 1]) min = mid + 1;
+			else {
+				min = mid;
+				break;
+			}
+		}
+		return min;
+	}
+})))(), 1);
+let prettierConfigCache = expiringMap(1e4);
+async function resolvePrettierConfigDir(filePath, inputDir) {
+	let cached = prettierConfigCache.get(inputDir);
+	if (cached !== void 0) return cached ?? process.cwd();
+	const resolve = async () => {
+		try {
+			return await prettier.resolveConfigFile(filePath);
+		} catch (err) {
+			error("prettier-config-not-found", "Failed to resolve Prettier Config");
+			error("prettier-config-not-found-err", err);
+			return null;
+		}
+	};
+	let prettierConfig = await resolve();
+	if (prettierConfig) {
+		let configDir = path.dirname(prettierConfig);
+		cacheForDirs(prettierConfigCache, inputDir, configDir, configDir);
+		return configDir;
+	} else {
+		prettierConfigCache.set(inputDir, null);
+		return process.cwd();
+	}
+}
+async function getTailwindConfig(options) {
+	let cwd = process.cwd();
+	let inputDir = options.filepath ? path.dirname(options.filepath) : cwd;
+	let needsPrettierConfig = options.tailwindConfig && !path.isAbsolute(options.tailwindConfig) || options.tailwindStylesheet && !path.isAbsolute(options.tailwindStylesheet) || options.tailwindEntryPoint && !path.isAbsolute(options.tailwindEntryPoint);
+	let configDir;
+	if (needsPrettierConfig) configDir = await resolvePrettierConfigDir(options.filepath, inputDir);
+	else configDir = cwd;
+	let configPath = options.tailwindConfig && !options.tailwindConfig.endsWith(".css") ? options.tailwindConfig : void 0;
+	let stylesheetPath = options.tailwindStylesheet;
+	if (!stylesheetPath && options.tailwindEntryPoint) {
+		warn("entrypoint-is-deprecated", configDir, "Deprecated: Use the `tailwindStylesheet` option for v4 projects instead of `tailwindEntryPoint`.");
+		stylesheetPath = options.tailwindEntryPoint;
+	}
+	if (!stylesheetPath && options.tailwindConfig && options.tailwindConfig.endsWith(".css")) {
+		warn("config-as-css-is-deprecated", configDir, "Deprecated: Use the `tailwindStylesheet` option for v4 projects instead of `tailwindConfig`.");
+		stylesheetPath = options.tailwindConfig;
+	}
+	return getTailwindConfig$1({
+		base: configDir,
+		filepath: options.filepath,
+		configPath,
+		stylesheetPath,
+		packageName: options.tailwindPackageName
+	});
+}
+const options = {
+	tailwindConfig: {
+		type: "string",
+		category: "Tailwind CSS",
+		description: "Path to Tailwind configuration file"
+	},
+	tailwindEntryPoint: {
+		type: "string",
+		category: "Tailwind CSS",
+		description: "Path to the CSS entrypoint in your Tailwind project (v4+)"
+	},
+	tailwindStylesheet: {
+		type: "string",
+		category: "Tailwind CSS",
+		description: "Path to the CSS stylesheet in your Tailwind project (v4+)"
+	},
+	tailwindAttributes: {
+		type: "string",
+		array: true,
+		default: [{ value: [] }],
+		category: "Tailwind CSS",
+		description: "List of attributes/props that contain sortable Tailwind classes"
+	},
+	tailwindFunctions: {
+		type: "string",
+		array: true,
+		default: [{ value: [] }],
+		category: "Tailwind CSS",
+		description: "List of functions and tagged templates that contain sortable Tailwind classes"
+	},
+	tailwindPreserveWhitespace: {
+		type: "boolean",
+		default: false,
+		category: "Tailwind CSS",
+		description: "Preserve whitespace around Tailwind classes when sorting"
+	},
+	tailwindPreserveDuplicates: {
+		type: "boolean",
+		default: false,
+		category: "Tailwind CSS",
+		description: "Preserve duplicate classes inside a class list when sorting"
+	},
+	tailwindPackageName: {
+		type: "string",
+		default: "tailwindcss",
+		category: "Tailwind CSS",
+		description: "The package name to use when loading Tailwind CSS"
+	}
+};
+function createMatcher(options, parser, defaults) {
+	let staticAttrs = new Set(defaults.staticAttrs);
+	let dynamicAttrs = new Set(defaults.dynamicAttrs);
+	let functions = new Set(defaults.functions);
+	let staticAttrsRegex = [...defaults.staticAttrsRegex];
+	let functionsRegex = [...defaults.functionsRegex];
+	for (let attr of options.tailwindAttributes ?? []) {
+		let regex = parseRegex(attr);
+		if (regex) staticAttrsRegex.push(regex);
+		else if (parser === "vue" && attr.startsWith(":")) staticAttrs.add(attr.slice(1));
+		else if (parser === "vue" && attr.startsWith("v-bind:")) staticAttrs.add(attr.slice(7));
+		else if (parser === "vue" && attr.startsWith("v-")) dynamicAttrs.add(attr);
+		else if (parser === "angular" && attr.startsWith("[") && attr.endsWith("]")) staticAttrs.add(attr.slice(1, -1));
+		else staticAttrs.add(attr);
+	}
+	for (let attr of staticAttrs) if (parser === "vue") {
+		dynamicAttrs.add(`:${attr}`);
+		dynamicAttrs.add(`v-bind:${attr}`);
+	} else if (parser === "angular") dynamicAttrs.add(`[${attr}]`);
+	for (let fn of options.tailwindFunctions ?? []) {
+		let regex = parseRegex(fn);
+		if (regex) functionsRegex.push(regex);
+		else functions.add(fn);
+	}
+	return {
+		hasStaticAttr: (name) => {
+			if (nameFromDynamicAttr(name, parser)) return false;
+			return hasMatch(name, staticAttrs, staticAttrsRegex);
+		},
+		hasDynamicAttr: (name) => {
+			if (hasMatch(name, dynamicAttrs, [])) return true;
+			let newName = nameFromDynamicAttr(name, parser);
+			if (!newName) return false;
+			return hasMatch(newName, staticAttrs, staticAttrsRegex);
+		},
+		hasFunction: (name) => hasMatch(name, functions, functionsRegex)
+	};
+}
+function nameFromDynamicAttr(name, parser) {
+	if (parser === "vue") {
+		if (name.startsWith(":")) return name.slice(1);
+		if (name.startsWith("v-bind:")) return name.slice(7);
+		if (name.startsWith("v-")) return name;
+		return null;
+	}
+	if (parser === "angular") {
+		if (name.startsWith("[") && name.endsWith("]")) return name.slice(1, -1);
+		return null;
+	}
+	return null;
+}
+function hasMatch(name, list, patterns) {
+	if (list.has(name)) return true;
+	for (let regex of patterns) if (regex.test(name)) return true;
+	return false;
+}
+function parseRegex(str) {
+	if (!str.startsWith("/")) return null;
+	let lastSlash = str.lastIndexOf("/");
+	if (lastSlash <= 0) return null;
+	try {
+		let pattern = str.slice(1, lastSlash);
+		let flags = str.slice(lastSlash + 1);
+		return new RegExp(pattern, flags);
+	} catch {
+		return null;
+	}
+}
+function createPlugin(transforms) {
+	let parsers = Object.create(null);
+	let printers = Object.create(null);
+	for (let opts of transforms) {
+		for (let [name, meta] of Object.entries(opts.parsers)) parsers[name] = async () => {
+			var _plugin$parsers;
+			let original = (_plugin$parsers = (await loadPlugins(meta.load ?? opts.load ?? [])).parsers) === null || _plugin$parsers === void 0 ? void 0 : _plugin$parsers[name];
+			if (!original) return;
+			parsers[name] = await createParser({
+				name,
+				original,
+				opts
+			});
+			return parsers[name];
+		};
+		for (let [name, _meta] of Object.entries(opts.printers ?? {})) printers[name] = async () => {
+			var _plugin$printers;
+			let original = (_plugin$printers = (await loadPlugins(opts.load ?? [])).printers) === null || _plugin$printers === void 0 ? void 0 : _plugin$printers[name];
+			if (!original) return;
+			printers[name] = createPrinter({
+				original,
+				opts
+			});
+			return printers[name];
+		};
+	}
+	return {
+		parsers,
+		printers
+	};
+}
+async function createParser({ name, original, opts }) {
+	let parser = { ...original };
+	async function load(options) {
+		let parser = { ...original };
+		for (const pluginName of opts.compatible || []) {
+			var _plugin$parsers2;
+			let plugin = await findEnabledPlugin(options, pluginName);
+			if (plugin === null || plugin === void 0 || (_plugin$parsers2 = plugin.parsers) === null || _plugin$parsers2 === void 0 ? void 0 : _plugin$parsers2[name]) Object.assign(parser, plugin.parsers[name]);
+		}
+		return parser;
+	}
+	parser.preprocess = async (code, options) => {
+		let parser = await load(options);
+		return parser.preprocess ? parser.preprocess(code, options) : code;
+	};
+	parser.parse = async (code, options) => {
+		let ast = await (await load(options)).parse(code, options, options);
+		let env = await loadTailwindCSS({
+			opts,
+			options
+		});
+		transformAst({
+			ast,
+			env,
+			opts,
+			options
+		});
+		options.__tailwindcss__ = env;
+		return ast;
+	};
+	return parser;
+}
+function createPrinter({ original, opts }) {
+	let printer = { ...original };
+	let reprint = opts.reprint;
+	if (reprint) {
+		printer.print = new Proxy(original.print, { apply(target, thisArg, args) {
+			let [path, options] = args;
+			let env = options.__tailwindcss__;
+			reprint(path, {
+				...env,
+				options
+			});
+			return Reflect.apply(target, thisArg, args);
+		} });
+		if (original.embed) printer.embed = new Proxy(original.embed, { apply(target, thisArg, args) {
+			let [path, options] = args;
+			let env = options.__tailwindcss__;
+			reprint(path, {
+				...env,
+				options
+			});
+			return Reflect.apply(target, thisArg, args);
+		} });
+	}
+	return printer;
+}
+async function loadPlugins(fns) {
+	let plugin = {
+		parsers: Object.create(null),
+		printers: Object.create(null),
+		options: Object.create(null),
+		defaultOptions: Object.create(null),
+		languages: []
+	};
+	for (let source of fns) {
+		let loaded = await loadPlugin(source);
+		Object.assign(plugin.parsers, loaded.parsers ?? {});
+		Object.assign(plugin.printers, loaded.printers ?? {});
+		Object.assign(plugin.options, loaded.options ?? {});
+		Object.assign(plugin.defaultOptions, loaded.defaultOptions ?? {});
+		plugin.languages = [...plugin.languages ?? [], ...loaded.languages ?? []];
+	}
+	return plugin;
+}
+const EMPTY_PLUGIN = {
+	parsers: {},
+	printers: {},
+	languages: [],
+	options: {},
+	defaultOptions: {}
+};
+async function loadPlugin(source) {
+	if ("importer" in source && typeof source.importer === "function") return normalizePlugin(await source.importer());
+	return source;
+}
+function normalizePlugin(source) {
+	if (source === null || typeof source !== "object") return EMPTY_PLUGIN;
+	let plugin = source.default;
+	return plugin && typeof plugin === "object" ? plugin : source;
+}
+function findEnabledPlugin(options, name) {
+	for (let plugin of options.plugins) {
+		if (plugin instanceof URL) {
+			if (plugin.protocol !== "file:") continue;
+			if (plugin.hostname !== "") continue;
+			plugin = plugin.pathname;
+		}
+		if (typeof plugin !== "string") {
+			if (!plugin.name) continue;
+			plugin = plugin.name;
+		}
+		if (plugin === name || isAbsolute(plugin) && plugin.includes(name) && maybeResolve(name) === plugin) return loadIfExists(name);
+	}
+}
+async function loadTailwindCSS({ options, opts }) {
+	var _parsers$parser, _parsers$parser2;
+	let parsers = opts.parsers;
+	let parser = options.parser;
+	return {
+		context: await getTailwindConfig(options),
+		matcher: createMatcher(options, parser, {
+			staticAttrs: new Set(((_parsers$parser = parsers[parser]) === null || _parsers$parser === void 0 ? void 0 : _parsers$parser.staticAttrs) ?? opts.staticAttrs ?? []),
+			dynamicAttrs: new Set(((_parsers$parser2 = parsers[parser]) === null || _parsers$parser2 === void 0 ? void 0 : _parsers$parser2.dynamicAttrs) ?? opts.dynamicAttrs ?? []),
+			functions: /* @__PURE__ */ new Set(),
+			staticAttrsRegex: [],
+			dynamicAttrsRegex: [],
+			functionsRegex: []
+		}),
+		options,
+		changes: []
+	};
+}
+function transformAst({ ast, env, opts }) {
+	let transform = opts.transform;
+	if (transform) transform(ast, env);
+}
+function defineTransform(opts) {
+	return opts;
+}
+const ESCAPE_SEQUENCE_PATTERN = /\\(['"\\nrtbfv0-7xuU])/g;
+function tryParseAngularAttribute(value, env) {
+	try {
+		return prettierParserAngular.parsers.__ng_directive.parse(value, env.options);
+	} catch (err) {
+		console.warn("prettier-plugin-tailwindcss: Unable to parse angular directive");
+		console.warn(err);
+		return null;
+	}
+}
+function transformDynamicAngularAttribute(attr, env) {
+	let directiveAst = tryParseAngularAttribute(attr.value, env);
+	if (!directiveAst) return;
+	let changes = [];
+	visit(directiveAst, {
+		StringLiteral(node, path) {
+			if (!node.value) return;
+			let collapseWhitespace = canCollapseWhitespaceIn(path, env);
+			changes.push({
+				start: node.start + 1,
+				end: node.end - 1,
+				before: node.value,
+				after: sortClasses(node.value, {
+					env,
+					collapseWhitespace
+				})
+			});
+		},
+		TemplateLiteral(node, path) {
+			if (!node.quasis.length) return;
+			let collapseWhitespace = canCollapseWhitespaceIn(path, env);
+			for (let i = 0; i < node.quasis.length; i++) {
+				let quasi = node.quasis[i];
+				changes.push({
+					start: quasi.start,
+					end: quasi.end,
+					before: quasi.value.raw,
+					after: sortClasses(quasi.value.raw, {
+						env,
+						ignoreFirst: i > 0 && !/^\s/.test(quasi.value.raw),
+						ignoreLast: i < node.expressions.length && !/\s$/.test(quasi.value.raw),
+						collapseWhitespace: collapseWhitespace ? {
+							start: collapseWhitespace.start && i === 0,
+							end: collapseWhitespace.end && i >= node.expressions.length
+						} : false
+					})
+				});
+			}
+		}
+	});
+	attr.value = spliceChangesIntoString(attr.value, changes);
+}
+function transformDynamicJsAttribute(attr, env) {
+	let { matcher } = env;
+	let source = `let __prettier_temp__ = ${attr.value}`;
+	let ast = prettierParserBabel.parsers["babel-ts"].parse(source, env.options);
+	let didChange = false;
+	let changes = [];
+	function findConcatEntry(path) {
+		return path.find((entry) => {
+			var _entry$parent;
+			return ((_entry$parent = entry.parent) === null || _entry$parent === void 0 ? void 0 : _entry$parent.type) === "BinaryExpression" && entry.parent.operator === "+";
+		});
+	}
+	function addChange(start, end, after) {
+		if (start == null || end == null) return;
+		let offsetStart = start - 24;
+		let offsetEnd = end - 24;
+		if (offsetStart < 0 || offsetEnd < 0) return;
+		didChange = true;
+		changes.push({
+			start: offsetStart,
+			end: offsetEnd,
+			before: attr.value.slice(offsetStart, offsetEnd),
+			after
+		});
+	}
+	visit(ast, {
+		StringLiteral(node, path) {
+			let concat = findConcatEntry(path);
+			if (sortStringLiteral(node, {
+				env,
+				collapseWhitespace: {
+					start: (concat === null || concat === void 0 ? void 0 : concat.key) !== "right",
+					end: (concat === null || concat === void 0 ? void 0 : concat.key) !== "left"
+				}
+			})) {
+				var _node$extra;
+				let raw = ((_node$extra = node.extra) === null || _node$extra === void 0 ? void 0 : _node$extra.raw) ?? node.raw;
+				if (typeof raw === "string") addChange(node.start, node.end, raw);
+			}
+		},
+		Literal(node, path) {
+			if (!isStringLiteral(node)) return;
+			let concat = findConcatEntry(path);
+			if (sortStringLiteral(node, {
+				env,
+				collapseWhitespace: {
+					start: (concat === null || concat === void 0 ? void 0 : concat.key) !== "right",
+					end: (concat === null || concat === void 0 ? void 0 : concat.key) !== "left"
+				}
+			})) {
+				var _node$extra2;
+				let raw = ((_node$extra2 = node.extra) === null || _node$extra2 === void 0 ? void 0 : _node$extra2.raw) ?? node.raw;
+				if (typeof raw === "string") addChange(node.start, node.end, raw);
+			}
+		},
+		TemplateLiteral(node, path) {
+			let concat = findConcatEntry(path);
+			let originalQuasis = node.quasis.map((quasi) => quasi.value.raw);
+			if (sortTemplateLiteral(node, {
+				env,
+				collapseWhitespace: {
+					start: (concat === null || concat === void 0 ? void 0 : concat.key) !== "right",
+					end: (concat === null || concat === void 0 ? void 0 : concat.key) !== "left"
+				}
+			})) for (let i = 0; i < node.quasis.length; i++) {
+				let quasi = node.quasis[i];
+				if (quasi.value.raw !== originalQuasis[i]) addChange(quasi.start, quasi.end, quasi.value.raw);
+			}
+		},
+		TaggedTemplateExpression(node, path) {
+			if (!isSortableTemplateExpression(node, matcher)) return;
+			let concat = findConcatEntry(path);
+			let originalQuasis = node.quasi.quasis.map((quasi) => quasi.value.raw);
+			if (sortTemplateLiteral(node.quasi, {
+				env,
+				collapseWhitespace: {
+					start: (concat === null || concat === void 0 ? void 0 : concat.key) !== "right",
+					end: (concat === null || concat === void 0 ? void 0 : concat.key) !== "left"
+				}
+			})) for (let i = 0; i < node.quasi.quasis.length; i++) {
+				let quasi = node.quasi.quasis[i];
+				if (quasi.value.raw !== originalQuasis[i]) addChange(quasi.start, quasi.end, quasi.value.raw);
+			}
+		}
+	});
+	if (didChange) attr.value = spliceChangesIntoString(attr.value, changes);
+}
+function transformHtml(ast, env) {
+	let { matcher } = env;
+	let { parser } = env.options;
+	for (let attr of ast.attrs ?? []) if (matcher.hasStaticAttr(attr.name)) attr.value = sortClasses(attr.value, { env });
+	else if (matcher.hasDynamicAttr(attr.name)) {
+		if (!/[`'"]/.test(attr.value)) continue;
+		if (parser === "angular") transformDynamicAngularAttribute(attr, env);
+		else transformDynamicJsAttribute(attr, env);
+	}
+	for (let child of ast.children ?? []) transformHtml(child, env);
+}
+function transformGlimmer(ast, env) {
+	let { matcher } = env;
+	visit(ast, {
+		AttrNode(attr, _path, meta) {
+			if (matcher.hasStaticAttr(attr.name) && attr.value) meta.sortTextNodes = true;
+		},
+		TextNode(node, path, meta) {
+			if (!meta.sortTextNodes) return;
+			let concat = path.find((entry) => {
+				return entry.parent && entry.parent.type === "ConcatStatement";
+			});
+			let siblings = {
+				prev: concat === null || concat === void 0 ? void 0 : concat.parent.parts[concat.index - 1],
+				next: concat === null || concat === void 0 ? void 0 : concat.parent.parts[concat.index + 1]
+			};
+			node.chars = sortClasses(node.chars, {
+				env,
+				ignoreFirst: siblings.prev && !/^\s/.test(node.chars),
+				ignoreLast: siblings.next && !/\s$/.test(node.chars),
+				collapseWhitespace: {
+					start: !siblings.prev,
+					end: !siblings.next
+				}
+			});
+		},
+		StringLiteral(node, path, meta) {
+			if (!meta.sortTextNodes) return;
+			let concat = path.find((entry) => {
+				return entry.parent && entry.parent.type === "SubExpression" && entry.parent.path.original === "concat";
+			});
+			node.value = sortClasses(node.value, {
+				env,
+				ignoreLast: Boolean(concat) && !/[^\S\r\n]$/.test(node.value),
+				collapseWhitespace: {
+					start: false,
+					end: !concat
+				}
+			});
+		}
+	});
+}
+function transformLiquid(ast, env) {
+	let { matcher } = env;
+	function isClassAttr(node) {
+		return Array.isArray(node.name) ? node.name.every((n) => n.type === "TextNode" && matcher.hasStaticAttr(n.value)) : matcher.hasStaticAttr(node.name);
+	}
+	function hasSurroundingQuotes(str) {
+		let start = str[0];
+		return start === str[str.length - 1] && (start === "\"" || start === "'" || start === "`");
+	}
+	let sources = [];
+	let changes = [];
+	function sortAttribute(attr) {
+		for (let i = 0; i < attr.value.length; i++) {
+			let node = attr.value[i];
+			if (node.type === "TextNode") {
+				let after = sortClasses(node.value, {
+					env,
+					ignoreFirst: i > 0 && !/^\s/.test(node.value),
+					ignoreLast: i < attr.value.length - 1 && !/\s$/.test(node.value),
+					removeDuplicates: false,
+					collapseWhitespace: false
+				});
+				changes.push({
+					start: node.position.start,
+					end: node.position.end,
+					before: node.value,
+					after
+				});
+			} else if ((node.type === "LiquidDrop" || node.type === "LiquidVariableOutput") && typeof node.markup === "object" && node.markup.type === "LiquidVariable") visit(node.markup.expression, { String(node) {
+				let pos = { ...node.position };
+				if (hasSurroundingQuotes(node.source.slice(pos.start, pos.end))) {
+					pos.start += 1;
+					pos.end -= 1;
+				}
+				let after = sortClasses(node.value, { env });
+				changes.push({
+					start: pos.start,
+					end: pos.end,
+					before: node.value,
+					after
+				});
+			} });
+		}
+	}
+	visit(ast, {
+		LiquidTag(node) {
+			sources.push(node);
+		},
+		HtmlElement(node) {
+			sources.push(node);
+		},
+		AttrSingleQuoted(node) {
+			if (isClassAttr(node)) {
+				sources.push(node);
+				sortAttribute(node);
+			}
+		},
+		AttrDoubleQuoted(node) {
+			if (isClassAttr(node)) {
+				sources.push(node);
+				sortAttribute(node);
+			}
+		}
+	});
+	for (let node of sources) node.source = spliceChangesIntoString(node.source, changes);
+}
+function sortStringLiteral(node, { env, removeDuplicates, collapseWhitespace = {
+	start: true,
+	end: true
+} }) {
+	var _node$extra3, _node$extra4;
+	let result = sortClasses(node.value, {
+		env,
+		removeDuplicates,
+		collapseWhitespace
+	});
+	if (!(result !== node.value)) return false;
+	node.value = result;
+	let raw = ((_node$extra3 = node.extra) === null || _node$extra3 === void 0 ? void 0 : _node$extra3.raw) ?? node.raw;
+	let quote = raw[0];
+	let originalRawContent = raw.slice(1, -1);
+	let originalValue = ((_node$extra4 = node.extra) === null || _node$extra4 === void 0 ? void 0 : _node$extra4.rawValue) ?? node.value;
+	if (node.extra) {
+		if (originalRawContent !== originalValue && originalValue.includes("\\")) result = result.replace(ESCAPE_SEQUENCE_PATTERN, "\\\\$1");
+		node.extra = {
+			...node.extra,
+			rawValue: result,
+			raw: quote + result + quote
+		};
+	} else node.raw = quote + result + quote;
+	return true;
+}
+function isStringLiteral(node) {
+	return node.type === "StringLiteral" || node.type === "Literal" && typeof node.value === "string";
+}
+function sortTemplateLiteral(node, { env, removeDuplicates, collapseWhitespace = {
+	start: true,
+	end: true
+} }) {
+	let didChange = false;
+	for (let i = 0; i < node.quasis.length; i++) {
+		let quasi = node.quasis[i];
+		let same = quasi.value.raw === quasi.value.cooked;
+		let originalRaw = quasi.value.raw;
+		let originalCooked = quasi.value.cooked;
+		quasi.value.raw = sortClasses(quasi.value.raw, {
+			env,
+			removeDuplicates,
+			ignoreFirst: i > 0 && !/^\s/.test(quasi.value.raw),
+			ignoreLast: i < node.expressions.length && !/\s$/.test(quasi.value.raw),
+			collapseWhitespace: collapseWhitespace && {
+				start: collapseWhitespace && collapseWhitespace.start && i === 0,
+				end: collapseWhitespace && collapseWhitespace.end && i >= node.expressions.length
+			}
+		});
+		quasi.value.cooked = same ? quasi.value.raw : sortClasses(quasi.value.cooked, {
+			env,
+			ignoreFirst: i > 0 && !/^\s/.test(quasi.value.cooked),
+			ignoreLast: i < node.expressions.length && !/\s$/.test(quasi.value.cooked),
+			removeDuplicates,
+			collapseWhitespace: collapseWhitespace && {
+				start: collapseWhitespace && collapseWhitespace.start && i === 0,
+				end: collapseWhitespace && collapseWhitespace.end && i >= node.expressions.length
+			}
+		});
+		if (quasi.value.raw !== originalRaw || quasi.value.cooked !== originalCooked) didChange = true;
+	}
+	return didChange;
+}
+function isSortableTemplateExpression(node, matcher) {
+	return isSortableExpression(node.tag, matcher);
+}
+function isSortableCallExpression(node, matcher) {
+	var _node$arguments;
+	if (!((_node$arguments = node.arguments) === null || _node$arguments === void 0 ? void 0 : _node$arguments.length)) return false;
+	return isSortableExpression(node.callee, matcher);
+}
+function isSortableExpression(node, matcher) {
+	while (node.type === "CallExpression" || node.type === "MemberExpression") if (node.type === "CallExpression") node = node.callee;
+	else if (node.type === "MemberExpression") node = node.object;
+	if (node.type === "Identifier") return matcher.hasFunction(node.name);
+	return false;
+}
+function canCollapseWhitespaceIn(path, env) {
+	if (env.options.tailwindPreserveWhitespace) return false;
+	let start = true;
+	let end = true;
+	for (let entry of path) {
+		if (!entry.parent) continue;
+		if (entry.parent.type === "BinaryExpression" && entry.parent.operator === "+") {
+			start && (start = entry.key !== "right");
+			end && (end = entry.key !== "left");
+		}
+		if (entry.parent.type === "TemplateLiteral") {
+			let nodeStart = entry.node.start ?? null;
+			let nodeEnd = entry.node.end ?? null;
+			for (let quasi of entry.parent.quasis) {
+				let quasiStart = quasi.start ?? null;
+				let quasiEnd = quasi.end ?? null;
+				if (nodeStart !== null && quasiEnd !== null && nodeStart - quasiEnd <= 2) start && (start = /^\s/.test(quasi.value.raw));
+				if (nodeEnd !== null && quasiStart !== null && nodeEnd - quasiStart <= 2) end && (end = /\s$/.test(quasi.value.raw));
+			}
+		}
+	}
+	return {
+		start,
+		end
+	};
+}
+function transformJavaScript(ast, env) {
+	let { matcher } = env;
+	function sortInside(ast) {
+		visit(ast, (node, path) => {
+			let collapseWhitespace = canCollapseWhitespaceIn(path, env);
+			if (isStringLiteral(node)) sortStringLiteral(node, {
+				env,
+				collapseWhitespace
+			});
+			else if (node.type === "TemplateLiteral") sortTemplateLiteral(node, {
+				env,
+				collapseWhitespace
+			});
+			else if (node.type === "TaggedTemplateExpression") {
+				if (isSortableTemplateExpression(node, matcher)) sortTemplateLiteral(node.quasi, {
+					env,
+					collapseWhitespace
+				});
+			}
+		});
+	}
+	visit(ast, {
+		JSXAttribute(node) {
+			node = node;
+			if (!node.value) return;
+			if (typeof node.name.name !== "string") return;
+			if (!matcher.hasStaticAttr(node.name.name)) return;
+			if (isStringLiteral(node.value)) sortStringLiteral(node.value, { env });
+			else if (node.value.type === "JSXExpressionContainer") sortInside(node.value);
+		},
+		CallExpression(node) {
+			node = node;
+			if (!isSortableCallExpression(node, matcher)) return;
+			node.arguments.forEach((arg) => sortInside(arg));
+		},
+		TaggedTemplateExpression(node, path) {
+			node = node;
+			if (!isSortableTemplateExpression(node, matcher)) return;
+			let collapseWhitespace = canCollapseWhitespaceIn(path, env);
+			sortTemplateLiteral(node.quasi, {
+				env,
+				collapseWhitespace
+			});
+		}
+	});
+}
+function transformCss(ast, env) {
+	function tryParseAtRuleParams(name, params) {
+		if (typeof params !== "string") return params;
+		try {
+			return prettierParserCss.parsers.css.parse(`@import ${params};`, { ...env.options }).nodes[0].params;
+		} catch (err) {
+			console.warn(`[prettier-plugin-tailwindcss] Unable to parse at rule`);
+			console.warn({
+				name,
+				params
+			});
+			console.warn(err);
+		}
+		return params;
+	}
+	ast.walk((node) => {
+		if (node.name === "plugin" || node.name === "config" || node.name === "source") node.params = tryParseAtRuleParams(node.name, node.params);
+		if (node.type === "css-atrule" && node.name === "apply") {
+			let isImportant = /\s+(?:!important|#{(['"]*)!important\1})\s*$/.test(node.params);
+			let classList = node.params;
+			let prefix = "";
+			let suffix = "";
+			if (classList.startsWith("~\"") && classList.endsWith("\"")) {
+				prefix = "~\"";
+				suffix = "\"";
+				classList = classList.slice(2, -1);
+				isImportant = false;
+			} else if (classList.startsWith("~'") && classList.endsWith("'")) {
+				prefix = "~'";
+				suffix = "'";
+				classList = classList.slice(2, -1);
+				isImportant = false;
+			}
+			classList = sortClasses(classList, {
+				env,
+				ignoreLast: isImportant,
+				collapseWhitespace: {
+					start: false,
+					end: !isImportant
+				}
+			});
+			node.params = `${prefix}${classList}${suffix}`;
+		}
+	});
+}
+function transformAstro(ast, env) {
+	let { matcher } = env;
+	if (ast.type === "element" || ast.type === "custom-element" || ast.type === "component") {
+		for (let attr of ast.attributes ?? []) if (matcher.hasStaticAttr(attr.name) && attr.type === "attribute" && attr.kind === "quoted") attr.value = sortClasses(attr.value, { env });
+		else if (matcher.hasDynamicAttr(attr.name) && attr.type === "attribute" && attr.kind === "expression" && typeof attr.value === "string") transformDynamicJsAttribute(attr, env);
+	}
+	for (let child of ast.children ?? []) transformAstro(child, env);
+}
+function transformMarko(ast, env) {
+	let { matcher } = env;
+	const nodesToVisit = [ast];
+	while (nodesToVisit.length > 0) {
+		const currentNode = nodesToVisit.pop();
+		switch (currentNode.type) {
+			case "File":
+				nodesToVisit.push(currentNode.program);
+				break;
+			case "Program":
+				nodesToVisit.push(...currentNode.body);
+				break;
+			case "MarkoTag":
+				nodesToVisit.push(...currentNode.attributes);
+				nodesToVisit.push(currentNode.body);
+				break;
+			case "MarkoTagBody":
+				nodesToVisit.push(...currentNode.body);
+				break;
+			case "MarkoAttribute":
+				if (!matcher.hasStaticAttr(currentNode.name)) break;
+				switch (currentNode.value.type) {
+					case "ArrayExpression":
+						const classList = currentNode.value.elements;
+						for (const node of classList) if (node.type === "StringLiteral") node.value = sortClasses(node.value, { env });
+						break;
+					case "StringLiteral":
+						currentNode.value.value = sortClasses(currentNode.value.value, { env });
+						break;
+				}
+				break;
+		}
+	}
+}
+function transformTwig(ast, env) {
+	let { matcher } = env;
+	for (let child of ast.expressions ?? []) transformTwig(child, env);
+	visit(ast, {
+		Attribute(node, _path, meta) {
+			if (!matcher.hasStaticAttr(node.name.name)) return;
+			meta.sortTextNodes = true;
+		},
+		CallExpression(node, _path, meta) {
+			while (node.type === "CallExpression" || node.type === "MemberExpression") if (node.type === "CallExpression") node = node.callee;
+			else if (node.type === "MemberExpression") node = node.property;
+			if (node.type === "Identifier") {
+				if (!matcher.hasFunction(node.name)) return;
+			}
+			meta.sortTextNodes = true;
+		},
+		StringLiteral(node, path, meta) {
+			if (!meta.sortTextNodes) return;
+			const concat = path.find((entry) => {
+				return entry.parent && (entry.parent.type === "BinaryConcatExpression" || entry.parent.type === "BinaryAddExpression");
+			});
+			node.value = sortClasses(node.value, {
+				env,
+				ignoreFirst: (concat === null || concat === void 0 ? void 0 : concat.key) === "right" && !/^[^\S\r\n]/.test(node.value),
+				ignoreLast: (concat === null || concat === void 0 ? void 0 : concat.key) === "left" && !/[^\S\r\n]$/.test(node.value),
+				collapseWhitespace: {
+					start: (concat === null || concat === void 0 ? void 0 : concat.key) !== "right",
+					end: (concat === null || concat === void 0 ? void 0 : concat.key) !== "left"
+				}
+			});
+		}
+	});
+}
+function transformPug(ast, env) {
+	let { matcher } = env;
+	for (const token of ast.tokens) if (token.type === "attribute" && matcher.hasStaticAttr(token.name)) token.val = [
+		token.val.slice(0, 1),
+		sortClasses(token.val.slice(1, -1), { env }),
+		token.val.slice(-1)
+	].join("");
+	let startIdx = -1;
+	let endIdx = -1;
+	let ranges = [];
+	for (let i = 0; i < ast.tokens.length; i++) if (ast.tokens[i].type === "class") {
+		startIdx = startIdx === -1 ? i : startIdx;
+		endIdx = i;
+	} else if (startIdx !== -1) {
+		ranges.push([startIdx, endIdx]);
+		startIdx = -1;
+		endIdx = -1;
+	}
+	if (startIdx !== -1) {
+		ranges.push([startIdx, endIdx]);
+		startIdx = -1;
+		endIdx = -1;
+	}
+	for (const [startIdx, endIdx] of ranges) {
+		const { classList } = sortClassList({
+			classList: ast.tokens.slice(startIdx, endIdx + 1).map((token) => token.val),
+			api: env.context,
+			removeDuplicates: false
+		});
+		for (let i = startIdx; i <= endIdx; i++) ast.tokens[i].val = classList[i - startIdx];
+	}
+}
+function transformSvelte(ast, env) {
+	let { matcher, changes } = env;
+	for (let attr of ast.attributes ?? []) {
+		if (!matcher.hasStaticAttr(attr.name) || attr.type !== "Attribute") continue;
+		for (let i = 0; i < attr.value.length; i++) {
+			let value = attr.value[i];
+			if (value.type === "Text") {
+				let same = value.raw === value.data;
+				value.raw = sortClasses(value.raw, {
+					env,
+					ignoreFirst: i > 0 && !/^\s/.test(value.raw),
+					ignoreLast: i < attr.value.length - 1 && !/\s$/.test(value.raw),
+					removeDuplicates: true,
+					collapseWhitespace: false
+				});
+				value.data = same ? value.raw : sortClasses(value.data, {
+					env,
+					ignoreFirst: i > 0 && !/^\s/.test(value.data),
+					ignoreLast: i < attr.value.length - 1 && !/\s$/.test(value.data),
+					removeDuplicates: true,
+					collapseWhitespace: false
+				});
+			} else if (value.type === "MustacheTag") visit(value.expression, {
+				Literal(node) {
+					if (isStringLiteral(node)) {
+						let before = node.raw;
+						if (sortStringLiteral(node, {
+							env,
+							removeDuplicates: false,
+							collapseWhitespace: false
+						})) changes.push({
+							before,
+							after: node.raw,
+							start: node.loc.start,
+							end: node.loc.end
+						});
+					}
+				},
+				TemplateLiteral(node) {
+					let before = node.quasis.map((quasi) => quasi.value.raw);
+					if (sortTemplateLiteral(node, {
+						env,
+						removeDuplicates: false,
+						collapseWhitespace: false
+					})) for (let [idx, quasi] of node.quasis.entries()) changes.push({
+						before: before[idx],
+						after: quasi.value.raw,
+						start: quasi.loc.start,
+						end: quasi.loc.end
+					});
+				}
+			});
+		}
+	}
+	for (let child of ast.children ?? []) transformSvelte(child, env);
+	if (ast.type === "IfBlock") {
+		var _ast$else;
+		for (let child of ((_ast$else = ast.else) === null || _ast$else === void 0 ? void 0 : _ast$else.children) ?? []) transformSvelte(child, env);
+	}
+	if (ast.type === "AwaitBlock") {
+		let nodes = [
+			ast.pending,
+			ast.then,
+			ast.catch
+		];
+		for (let child of nodes) transformSvelte(child, env);
+	}
+	if (ast.html) transformSvelte(ast.html, env);
+}
+const { parsers, printers } = createPlugin([
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "prettier/plugins/html",
+			importer: () => import("prettier/plugins/html")
+		}],
+		compatible: ["prettier-plugin-organize-attributes"],
+		parsers: {
+			html: {},
+			lwc: {},
+			angular: { dynamicAttrs: ["[ngClass]"] },
+			vue: { dynamicAttrs: [":class", "v-bind:class"] }
+		},
+		transform: transformHtml
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "prettier/plugins/glimmer",
+			importer: () => import("prettier/plugins/glimmer")
+		}],
+		parsers: { glimmer: {} },
+		transform: transformGlimmer
+	}),
+	defineTransform({
+		load: [prettierParserCss],
+		compatible: ["prettier-plugin-css-order"],
+		parsers: {
+			css: {},
+			scss: {},
+			less: {}
+		},
+		transform: transformCss
+	}),
+	defineTransform({
+		staticAttrs: ["class", "className"],
+		compatible: [
+			"prettier-plugin-multiline-arrays",
+			"@ianvs/prettier-plugin-sort-imports",
+			"@trivago/prettier-plugin-sort-imports",
+			"prettier-plugin-organize-imports",
+			"prettier-plugin-sort-imports",
+			"prettier-plugin-jsdoc"
+		],
+		parsers: {
+			babel: { load: [prettierParserBabel] },
+			"babel-flow": { load: [prettierParserBabel] },
+			"babel-ts": { load: [prettierParserBabel] },
+			__js_expression: { load: [prettierParserBabel] },
+			typescript: { load: [{
+				name: "prettier/plugins/typescript",
+				importer: () => import("prettier/plugins/typescript")
+			}] },
+			meriyah: { load: [{
+				name: "prettier/plugins/meriyah",
+				importer: () => import("prettier/plugins/meriyah")
+			}] },
+			acorn: { load: [{
+				name: "prettier/plugins/acorn",
+				importer: () => import("prettier/plugins/acorn")
+			}] },
+			flow: { load: [{
+				name: "prettier/plugins/flow",
+				importer: () => import("prettier/plugins/flow")
+			}] },
+			oxc: { load: [{
+				name: "@prettier/plugin-oxc",
+				importer: () => import("@prettier/plugin-oxc")
+			}] },
+			"oxc-ts": { load: [{
+				name: "@prettier/plugin-oxc",
+				importer: () => import("@prettier/plugin-oxc")
+			}] },
+			hermes: { load: [{
+				name: "@prettier/plugin-hermes",
+				importer: () => import("@prettier/plugin-hermes")
+			}] },
+			astroExpressionParser: {
+				load: [{
+					name: "prettier-plugin-astro",
+					importer: () => {
+						return import("prettier-plugin-astro");
+					}
+				}],
+				staticAttrs: ["class"],
+				dynamicAttrs: ["class:list"]
+			}
+		},
+		transform: transformJavaScript
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "prettier-plugin-svelte",
+			importer: () => import("prettier-plugin-svelte")
+		}],
+		parsers: { svelte: {} },
+		printers: { "svelte-ast": {} },
+		transform: transformSvelte,
+		reprint(path, { options, changes }) {
+			if (options.__mutatedOriginalText) return;
+			options.__mutatedOriginalText = true;
+			if (!(changes === null || changes === void 0 ? void 0 : changes.length)) return;
+			let finder = (0, import_line_column.default)(options.originalText);
+			let stringChanges = changes.map((change) => ({
+				...change,
+				start: finder.toIndex(change.start.line, change.start.column + 1),
+				end: finder.toIndex(change.end.line, change.end.column + 1)
+			}));
+			options.originalText = spliceChangesIntoString(options.originalText, stringChanges);
+		}
+	}),
+	defineTransform({
+		staticAttrs: ["class", "className"],
+		dynamicAttrs: ["class:list", "className"],
+		load: [{
+			name: "prettier-plugin-astro",
+			importer: () => {
+				return import("prettier-plugin-astro");
+			}
+		}],
+		parsers: { astro: {} },
+		transform: transformAstro
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "prettier-plugin-marko",
+			importer: () => import("prettier-plugin-marko")
+		}],
+		parsers: { marko: {} },
+		transform: transformMarko
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "@zackad/prettier-plugin-twig",
+			importer: () => {
+				return import("@zackad/prettier-plugin-twig");
+			}
+		}],
+		parsers: { twig: {} },
+		transform: transformTwig
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "@prettier/plugin-pug",
+			importer: () => import("@prettier/plugin-pug")
+		}],
+		parsers: { pug: {} },
+		transform: transformPug
+	}),
+	defineTransform({
+		staticAttrs: ["class"],
+		load: [{
+			name: "@shopify/prettier-plugin-liquid",
+			importer: () => import("@shopify/prettier-plugin-liquid")
+		}],
+		parsers: { "liquid-html": {} },
+		transform: transformLiquid
+	})
+]);
+export { options, parsers, printers };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/@babel/types/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other 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/prettier-plugin-tailwindcss/dist/licenses/@ianvs/prettier-plugin-sort-imports/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/@prettier/plugin-hermes/LICENSE

@@ -0,0 +1,7 @@
+Copyright © James Long and 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/prettier-plugin-tailwindcss/dist/licenses/@prettier/plugin-oxc/LICENSE

@@ -0,0 +1,7 @@
+Copyright © James Long and 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/prettier-plugin-tailwindcss/dist/licenses/@prettier/plugin-pug/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2025 Christopher Quadflieg
+
+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/prettier-plugin-tailwindcss/dist/licenses/@shopify/prettier-plugin-liquid/README.md

@@ -0,0 +1,158 @@
+<h1 align="center" style="position: relative;" >
+  <br>
+    <img src="https://github.com/Shopify/theme-check-vscode/blob/main/images/shopify_glyph.png?raw=true" alt="logo" width="141" height="160">
+  <br>
+  Shopify Liquid Prettier Plugin
+</h1>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@shopify/prettier-plugin-liquid"><img src="https://img.shields.io/npm/v/@shopify/prettier-plugin-liquid.svg?sanitize=true" alt="Version"></a>
+  <a href="https://github.com/Shopify/prettier-plugin-liquid/blob/main/LICENSE.md"><img src="https://img.shields.io/npm/l/@shopify/prettier-plugin-liquid.svg?sanitize=true" alt="License"></a>
+  <a href="https://github.com/Shopify/prettier-plugin-liquid-prototype/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/Shopify/prettier-plugin-liquid-prototype/actions/workflows/ci.yml/badge.svg"></a>
+  <!--
+    <a href="https://npmcharts.com/compare/@shopify/prettier-plugin-liquid?minimal=true"><img src="https://img.shields.io/npm/dm/@shopify/prettier-plugin-liquid.svg?sanitize=true" alt="Downloads"></a>
+  -->
+</p>
+
+<div align="center">
+
+🗣 [Slack](https://join.slack.com/t/shopifypartners/shared_invite/zt-sdr2quab-mGkzkttZ2hnVm0~8noSyvw) | 💬 [Discussions](https://github.com/Shopify/prettier-plugin-liquid/discussions) | 📝 [Changelog](./CHANGELOG.md)
+
+</div>
+
+[Prettier](https://prettier.io) is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary.
+
+![demo](https://github.com/Shopify/prettier-plugin-liquid/blob/main/docs/demo.gif?raw=true)
+
+## Can this be used in production?
+
+Yes! It's also available in the [Online Store Code Editor](https://shopify.dev/themes/tools/code-editor#formatting-theme-code).
+
+## Installation
+
+```bash
+# with npm
+npm install --save-dev prettier @shopify/prettier-plugin-liquid
+
+# with yarn
+yarn add --dev prettier @shopify/prettier-plugin-liquid
+```
+
+For Prettier version 3 and above, the plugin must also be declared in the [configuration](https://prettier.io/docs/en/configuration.html).
+
+```
+{
+  "plugins": ["@shopify/prettier-plugin-liquid"]
+}
+```
+
+## Usage
+
+See our [Wiki](https://github.com/Shopify/prettier-plugin-liquid/wiki) pages on the subject:
+
+- [In the terminal](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-in-your-terminal) (with Node.js)
+- [In the browser](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-in-the-browser)
+- [In your editor](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-in-your-editor)
+- [In a CI workflow](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-in-CI)
+- [As a pre-commit hook](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-as-a-pre-commit-hook)
+- [With a bundler](https://github.com/shopify/prettier-plugin-liquid/wiki/Use-it-with-a-bundler)
+
+## Playground
+
+You can try it out in your browser in the [playground](https://shopify.github.io/prettier-plugin-liquid/).
+
+## Configuration
+
+Prettier for Liquid supports the following options.
+
+| Name                           | Default  | Description                                                                                                                                                      |
+| ------------------------------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `printWidth`                   | `120`    | Changed from Prettier's default (`80`) ([see prettier docs](https://prettier.io/docs/en/options.html#print-width))                                               |
+| `tabWidth`                     | `2`      | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width))                                                                    |
+| `useTabs`                      | `false`  | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tabs))                                                                         |
+| `singleQuote`                  | `false`  | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#quotes))                                                                       |
+| `bracketSameLine`              | `false`  | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#bracket-line))                                                                 |
+| `liquidSingleQuote`            | `true`   | Use single quotes instead of double quotes in Liquid tag and objects (since v0.2.0).                                                                             |
+| `embeddedSingleQuote`          | `true`   | Use single quotes instead of double quotes in embedded languages (JavaScript, CSS, TypeScript inside `<script>`, `<style>` or Liquid equivalent) (since v0.4.0). |
+| `htmlWhitespaceSensitivity`    | `css`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#html-whitespace-sensitivity))                                                  |
+| `captureWhitespaceSensitivity` | `strict` | Specify the default whitespace sensitivity of the `capture` Liquid tag. Valid options: `"strict"` \| `"ignore"`.                                                 |
+| `singleLineLinkTags`           | `false`  | If set to `true`, will print `<link>` tags on a single line to remove clutter                                                                                    |
+| `indentSchema`                 | `false`  | If set to `true`, will indent the contents of the `{% schema %}` tag                                                                                             |
+
+## Ignoring code
+
+We support the following comments (either via HTML or Liquid comments):
+
+- `prettier-ignore`
+- `prettier-ignore-attribute`
+- `prettier-ignore-attributes` (alias)
+
+They target the next node in the tree. Unparseable code can't be ignored and will throw an error.
+
+```liquid
+{% # prettier-ignore %}
+<div         class="x"       >hello world</div            >
+
+{% # prettier-ignore-attributes %}
+<div
+  [[#if Condition]]
+    class="a b c"
+  [[/if ]]
+></div>
+```
+
+## Whitespace handling
+
+You'll quickly notice that the default value for `--htmlWhitespaceSensitivity` is set to `css` (like [Prettier's](https://prettier.io/blog/2018/11/07/1.15.0#whitespace-sensitive-formatting)).
+
+If you want to change this behaviour for a specific tag that has a different default, you can use either the `display` or `white-space` comment to alter the behaviour.
+
+Examples:
+
+```liquid
+{% # this tag is whitespace sensitive by default, since the value of the string shouldn't change by formatting. %}
+{% capture value %}
+  Hello {% name %}
+{% endcapture %}
+
+{% # here we alter its white-space property so that we allow pretty printing of its body %}
+{% # white-space: normal %}
+{% capture _ %}
+  <div>
+    {% render 'snip' %}
+  </div>
+{% endcapture %}
+
+{% # this will prevent prettier from formatting it %}
+{% # white-space: pre %}
+{% capture _ %}
+  <div>
+    {% render 'snip' %}
+  </div>
+{% endcapture %}
+
+{% # a span is normally sensitive to whitespace on both ends %}
+<span
+  ><b
+    >hi</b
+  ></span
+>
+
+{% # with display: block, it isn't %}
+{% # display: block %}
+<span>
+  <b>hi</b>
+</span>
+```
+
+## Known issues
+
+Take a look at our [known issues](./KNOWN_ISSUES.md) and [open issues](https://github.com/Shopify/prettier-plugin-liquid/issues).
+
+## Contributing
+
+[Read our contributing guide](CONTRIBUTING.md)
+
+## License
+
+MIT.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/@trivago/prettier-plugin-sort-imports/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/@types/node/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/prettier-plugin-tailwindcss/dist/licenses/@zackad/prettier-plugin-twig/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/clear-module/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.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/prettier-plugin-tailwindcss/dist/licenses/dedent/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+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/prettier-plugin-tailwindcss/dist/licenses/enhanced-resolve/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other 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/prettier-plugin-tailwindcss/dist/licenses/escalade/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.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/prettier-plugin-tailwindcss/dist/licenses/fast-glob/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+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/prettier-plugin-tailwindcss/dist/licenses/import-sort-style-module/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2016, Renke Grunwald
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/jiti/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+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/prettier-plugin-tailwindcss/dist/licenses/line-column/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 IRIDE Monad <iride.monad@gmail.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/prettier-plugin-tailwindcss/dist/licenses/marko/README.md

@@ -0,0 +1,161 @@
+<div align="center">
+
+# [<img alt="Marko" src="https://raw.githubusercontent.com/marko-js/branding/master/marko-logo-medium-cropped.png" width="250">](https://markojs.com/)
+
+**A declarative, HTML-based language that makes building web apps fun 🔥**
+
+[![NPM](https://img.shields.io/npm/v/marko.svg)](https://www.npmjs.com/package/marko)
+[![Discord Chat](https://img.shields.io/badge/discord-chat-7188da.svg)](https://discord.gg/RFGxYGs)
+[![Continuous Integration status](https://github.com/marko-js/marko/actions/workflows/ci.yml/badge.svg)](https://github.com/marko-js/marko/actions/workflows/ci.yml)
+[![Code coverage %](https://codecov.io/gh/marko-js/marko/branch/master/graph/badge.svg)](https://codecov.io/gh/marko-js/marko)
+[![# of monthly downloads](https://img.shields.io/npm/dm/marko.svg)](https://npm-stat.com/charts.html?package=marko)
+[![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7029/badge)](https://bestpractices.coreinfrastructure.org/projects/7029)
+
+[Docs](https://markojs.com/docs/getting-started/) ∙ [Try Online](https://markojs.com/try-online/) ∙ [Contribute](#contributors) ∙ [Get Support](#community--support)
+
+</div>
+
+## Intro
+
+Marko is HTML _reimagined_ as a language for building dynamic and reactive user interfaces. Almost any valid HTML is valid Marko, and Marko extends HTML for building modern applications more declaratively. Among these extensions are [conditionals and lists](https://markojs.com/docs/conditionals-and-lists/), [state](https://markojs.com/docs/state/), and [components](https://markojs.com/docs/class-components/).
+
+Marko supports both single-file components and components across separate files.
+
+### Single-file component
+
+The following renders a button and a counter of how many times the button has been pressed:
+
+**click-count.marko**
+
+```marko
+class {
+  onCreate() {
+    this.state = { count: 0 };
+  }
+  increment() {
+    this.state.count++;
+  }
+}
+
+style {
+  .count {
+    color: #09c;
+    font-size: 3em;
+  }
+  .press-me {
+    padding: 0.5em;
+  }
+}
+
+<output.count>
+  ${state.count}
+</output>
+<button.press-me on-click('increment')>
+  Press me!
+</button>
+```
+
+### Multi-file component
+
+The same component as above, but split into:
+
+- `index.marko` template file
+- `component.js` component JS logic file
+- `style.css` component styles file
+
+**index.marko**
+
+```marko
+<output.count>
+  ${state.count}
+</output>
+<button.press-me on-click('increment')>
+  Press me!
+</button>
+```
+
+**component.js**
+
+```js
+export default {
+  onCreate() {
+    this.state = { count: 0 };
+  },
+  increment() {
+    this.state.count++;
+  },
+};
+```
+
+**style.css**
+
+```css
+.count {
+  color: #09c;
+  font-size: 3em;
+}
+.press-me {
+  padding: 0.5em;
+}
+```
+
+## Concise Syntax
+
+Marko also supports [a beautifully concise syntax as an alternative](https://markojs.com/docs/concise/) to its HTML syntax:
+
+<table><thead><tr><th>Concise syntax<th>HTML syntax
+<tbody><tr>
+<td>
+
+```marko
+ul.example-list
+  for|color| of=[a, b, c]
+    li -- ${color}
+```
+
+<td>
+
+```marko
+<ul class="example-list">
+  <for|color| of=[a, b, c]>
+    <li>${color}</li>
+  </for>
+</ul>
+```
+
+</table>
+
+## Getting Started
+
+1. `npm install marko`
+2. Read the [docs](https://markojs.com/docs/getting-started/)
+
+## Community & Support
+
+<table>
+<thead><tr>
+  <th><img alt="Stack Overflow" src="https://user-images.githubusercontent.com/1958812/56055468-619b3e00-5d0e-11e9-92ae-200c212cafb8.png" width="205"> 
+  <th><img alt="Discord" src="https://user-images.githubusercontent.com/4985201/89313514-6edbea80-d62d-11ea-8447-ca2fd8983661.png" width="162">
+  <th><img alt="Twitter" src="https://user-images.githubusercontent.com/1958812/56055707-07e74380-5d0f-11e9-8a59-d529fbb5a81e.png" width="53">
+<tbody><tr><td>
+  
+  Ask and answer [StackOverflow questions with the `#marko` tag](https://stackoverflow.com/questions/tagged/marko)<td>
+
+Come [hang out in our Discord chat](https://discord.gg/RFGxYGs), ask questions, and discuss project direction<td>
+
+[Tweet to `@MarkoDevTeam`](https://twitter.com/MarkoDevTeam), or with the [`#markojs` hashtag](https://twitter.com/search?q=%23markojs&f=live)
+
+</table>
+
+### Contributors
+
+Marko would not be what it is without all those who have contributed ✨
+
+[![All marko-js/marko GitHub contributors](https://opencollective.com/marko-js/contributors.svg?width=890&button=false)](https://github.com/marko-js/marko/graphs/contributors)
+
+### Get Involved!
+
+- Pull requests are welcome!
+- Submit [GitHub issues](https://github.com/marko-js/marko/issues) for any feature enhancements, bugs, or documentation problems
+- [Read the Contribution Tips and Guidelines](.github/CONTRIBUTING.md)
+- Participants in this project agree to abide by [its Code of Conduct](https://github.com/eBay/.github/blob/main/CODE_OF_CONDUCT.md)

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/oxlint-tsgolint/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 July-present VoidZero Inc. & Contributors
+Copyright (c) 2025 July typescript-eslint and other 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/prettier-plugin-tailwindcss/dist/licenses/oxlint/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & Contributors
+Copyright (c) 2023 Boshen
+
+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/prettier-plugin-tailwindcss/dist/licenses/postcss-import/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Maxime Thirouin, Jason Campbell & Kevin Mårtensson
+
+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/prettier-plugin-tailwindcss/dist/licenses/postcss/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-astro/LICENSE

@@ -0,0 +1,48 @@
+MIT License
+
+Copyright (c) 2021 Nate Moore
+
+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.
+
+---
+
+Substantial portions of this code are adopted from https://github.com/sveltejs/prettier-plugin-svelte
+under the following license:
+
+MIT License
+
+Copyright (c) 2019 [Contributors](https://github.com/sveltejs/prettier-plugin-svelte/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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-css-order/license.md

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c)
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-jsdoc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hossein Mohammadi
+
+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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-marko/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 eBay Inc. and 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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-multiline-arrays/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-organize-attributes/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Niklas Portmann
+
+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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-organize-imports/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Simon Hänisch
+
+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/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-sort-imports/README.md

@@ -0,0 +1,96 @@
+# Prettier Plugin: Sort imports
+
+A prettier plugin that sorts import statements by either their length or alphabetically.
+
+Example:
+![](./images/transform.png)
+
+![NPM Downloads](https://img.shields.io/npm/dt/prettier-plugin-sort-imports)
+
+## Installation
+
+```sh
+npm install --save-dev prettier-plugin-sort-imports
+```
+
+## Usage
+
+The plugin will be loaded by Prettier automatically. No configuration needed. It will sort by import statement length by default.
+
+### Add to Prettier Config
+
+1. Create a file named `prettier.config.js` in your project's root directory.
+2. Add the following contents:
+
+```js
+module.exports = {
+	// For prettier 3
+	sortingMethod: 'lineLength',
+	plugins: ['./node_modules/prettier-plugin-sort-imports/dist/index.js'],
+};
+```
+
+```js
+module.exports = {
+	// For prettier 2
+	sortingMethod: 'lineLength',
+	pluginSearchDirs: ['./node_modules'],
+	plugins: ['./node_modules/prettier-plugin-sort-imports/dist/index.2.js'],
+};
+```
+
+## Known issues
+
+### When using with certain other plugins
+
+When combined with other prettier plugins that also modify the way JS/TS are formatted (such as `prettier-plugin-tailwindcss`) some issues may occur. See [this issue](https://github.com/SanderRonde/prettier-plugin-sort-imports/issues/2#issuecomment-1237556280) for more details and the fix.
+
+### Options:
+
+-   `sortingMethod`: `'alphabetical' | 'lineLength' (default)` - What to sort the individual lines by. `alphabetical` sorts by the import path and `lineLength` sorts by the length of the import. Note that alphabetical sorting looks at the **whole** import path, so imports starting with `../` are ranked lower.
+-   `sortingOrder`: `'ascending' | 'descending' (default)` -  Determines the order of imports. If set to 'ascending', imports will be sorted in ascending order and vice versa.
+-   `stripNewlines`: `true | false (default)`. Determines whether newlines between blocks of imports are stripped. If the only thing between two blocks is whitespace or comments, the whitespace will be stripped and the blocks are sorted as one big one. The comment sticks to whichever import it was above initially.
+-   `importTypeOrder`: `('NPMPackages' | 'localImportsValue' | 'localImportsType' | 'localImports' | 'all')[]`. An array that determines the order in which different import types are sorted. The default is `['all']`, which does no sorting of different import types. Import type are sorted according to the order in which they appear in this array. Note that, other than the `'all'` type, you can not specify an imcomplete array. See different types for which other types they can be combined with. Explanations of different types:
+    -   `'NPMPackages'`: All NPM packges that are listed in your `package.json` fall into this category. If you have multiple `package.json` files you can specify them using the `packageJSONFiles` option. Can only be used with one of the other local import types (either `'localImportsValue', 'localImportsType' `or` 'localImports'`)
+    -   `'localImportsValue'`: All local imports that are declared with a value `import foo from './foo'` falls into this category. Can only be used if `NPMPackages` is also specified and if `localImportsType` is also specified.
+    -   `'localImportsType'`: All local imports that are imported as a type. `import type foo from './foo'` falls into this category. Only available in typecript. Can only be used if `NPMPackages` is also specified and if `localImportsValue` is also specified.
+    -   `'localImports'`: All local imports that are declared with a value or a type. `import foo from './foo'` and `import type foo from './foo'` both fall into this category. Can only be used if `NPMPackages` is also specified.
+    -   `'all'`: All imports fall into this category.
+-   `packageJSONFiles`: `string[]`. Set to `['package.json']` by default. Lists the `package.json` files to be used for the `'NPMPackages'` import type. Note that if you specified `['all']` for the `importTypeOrder` option (or specified none at all), this is not used.
+-   `newlineBetweenTypes`: `boolean`. Set to `false` by default. Determines whether a newline should be inserted between different import types.
+
+Files containing the string `// sort-imports-ignore` are skipped. You can also ignore sections by using `// sort-imports-begin-ignore` and `// sort-imports-end-ignore`.
+
+## Changelog
+
+### 1.8.7
+
+-   Add `sortingOrder` option to sort imports in ascending or descending order
+
+### 1.8.5
+
+-   When sorting by line length, adjecent subgroups are also sorted together
+
+### 1.8.4
+
+-   Add `.prettierrc.mjs` and `prettier.config.mjs` to the list of possible config files
+
+### 1.8.3
+
+-   Remove some logs from release
+
+### 1.8.2
+
+-   Fix bug where `package.json` files were not resolved relative to prettier config file but only to CWD
+
+### 1.8.1
+
+-   Fix bug where reading of `package.json` files was not try-catched
+
+### 1.7.2
+
+-   Fix peer dependency version
+
+### 1.7.0
+
+-   Rewrite newline re-ordering to be more robust

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/licenses/prettier-plugin-svelte/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 [Contributors](https://github.com/sveltejs/prettier-plugin-svelte/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/prettier-plugin-tailwindcss/dist/licenses/pug-lexer/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Forbes Lindesay
+
+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/prettier-plugin-tailwindcss/dist/licenses/tsdown/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present VoidZero Inc. & Contributors
+Copyright (c) 2024 Kevin Deng (https://github.com/sxzz)
+
+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/prettier-plugin-tailwindcss/dist/sorter-BZkvDMjt.mjs

@@ -0,0 +1,210 @@
+import { a as expiringMap, i as resolveJsFrom } from "./resolve-pWjAK-4f.mjs";
+import { n as cacheForDirs, t as bigSign } from "./utils-D8dQkKEd.mjs";
+import { dirname, resolve } from "path";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { readdirSync, statSync } from "fs";
+let seen = /* @__PURE__ */ new Set();
+function warn(key, arg, ...args) {
+	if (seen.has(key)) return;
+	seen.add(key);
+	console.warn(arg, ...args);
+}
+function error(key, arg, ...args) {
+	if (seen.has(key)) return;
+	seen.add(key);
+	console.error(arg, ...args);
+}
+function sync_default(start, callback) {
+	let dir = resolve(".", start);
+	let tmp;
+	if (!statSync(dir).isDirectory()) dir = dirname(dir);
+	while (true) {
+		tmp = callback(dir, readdirSync(dir));
+		if (tmp) return resolve(dir, tmp);
+		dir = dirname(tmp = dir);
+		if (tmp === dir) break;
+	}
+}
+function sortClasses(classStr, { env, ignoreFirst = false, ignoreLast = false, removeDuplicates = true, collapseWhitespace = {
+	start: true,
+	end: true
+} }) {
+	if (typeof classStr !== "string" || classStr === "") return classStr;
+	if (classStr.includes("{{")) return classStr;
+	if (env.options.tailwindPreserveWhitespace) collapseWhitespace = false;
+	if (env.options.tailwindPreserveDuplicates) removeDuplicates = false;
+	if (collapseWhitespace && /^[\t\r\f\n ]+$/.test(classStr)) return " ";
+	let result = "";
+	let parts = classStr.split(/([\t\r\f\n ]+)/);
+	let classes = parts.filter((_, i) => i % 2 === 0);
+	let whitespace = parts.filter((_, i) => i % 2 !== 0);
+	if (classes[classes.length - 1] === "") classes.pop();
+	if (collapseWhitespace) whitespace = whitespace.map(() => " ");
+	let prefix = "";
+	if (ignoreFirst) prefix = `${classes.shift() ?? ""}${whitespace.shift() ?? ""}`;
+	let suffix = "";
+	if (ignoreLast) suffix = `${whitespace.pop() ?? ""}${classes.pop() ?? ""}`;
+	let { classList, removedIndices } = sortClassList({
+		classList: classes,
+		api: env.context,
+		removeDuplicates
+	});
+	whitespace = whitespace.filter((_, index) => !removedIndices.has(index + 1));
+	for (let i = 0; i < classList.length; i++) result += `${classList[i]}${whitespace[i] ?? ""}`;
+	if (collapseWhitespace) {
+		prefix = prefix.replace(/\s+$/g, " ");
+		suffix = suffix.replace(/^\s+/g, " ");
+		result = result.replace(/^\s+/, collapseWhitespace.start ? "" : " ").replace(/\s+$/, collapseWhitespace.end ? "" : " ");
+	}
+	return prefix + result + suffix;
+}
+function sortClassList({ classList, api, removeDuplicates }) {
+	let orderedClasses = api.getClassOrder(classList);
+	orderedClasses.sort(([nameA, a], [nameZ, z]) => {
+		if (nameA === "..." || nameA === "…") return 1;
+		if (nameZ === "..." || nameZ === "…") return -1;
+		if (a === z) return 0;
+		if (a === null) return -1;
+		if (z === null) return 1;
+		return bigSign(a - z);
+	});
+	let removedIndices = /* @__PURE__ */ new Set();
+	if (removeDuplicates) {
+		let seenClasses = /* @__PURE__ */ new Set();
+		orderedClasses = orderedClasses.filter(([cls, order], index) => {
+			if (seenClasses.has(cls)) {
+				removedIndices.add(index);
+				return false;
+			}
+			if (order !== null) seenClasses.add(cls);
+			return true;
+		});
+	}
+	return {
+		classList: orderedClasses.map(([className]) => className),
+		removedIndices
+	};
+}
+function resolveIfRelative(base, filePath) {
+	if (!filePath) return null;
+	return path.isAbsolute(filePath) ? filePath : path.resolve(base, filePath);
+}
+let pathToApiMap = expiringMap(1e4);
+async function getTailwindConfig(options) {
+	let base = options.base ?? process.cwd();
+	let inputDir = options.filepath ? path.dirname(options.filepath) : base;
+	let configPath = resolveIfRelative(base, options.configPath);
+	let stylesheetPath = resolveIfRelative(base, options.stylesheetPath);
+	let [mod, pkgDir] = await resolveTailwindPath({ packageName: options.packageName }, inputDir);
+	let stylesheet = resolveStylesheet(stylesheetPath, base);
+	let jsConfig = resolveJsConfigPath(configPath);
+	if (!stylesheet && !(mod === null || mod === void 0 ? void 0 : mod.__unstable__loadDesignSystem)) jsConfig = jsConfig ?? findClosestJsConfig(inputDir);
+	if (jsConfig) {
+		if (!stylesheet) return pathToApiMap.remember(`${pkgDir}:${jsConfig}`, async () => {
+			const { loadV3 } = await import("./v3-D-mr2VVh.mjs");
+			return loadV3(pkgDir, jsConfig);
+		});
+		error("explicit-stylesheet-and-config-together", base, `You have specified a Tailwind CSS stylesheet and a Tailwind CSS config at the same time. Use stylesheetPath unless you are using v3. Preferring the stylesheet.`);
+	}
+	if (mod && !mod.__unstable__loadDesignSystem) {
+		if (!stylesheet) return pathToApiMap.remember(`${pkgDir}:${jsConfig}`, async () => {
+			const { loadV3 } = await import("./v3-D-mr2VVh.mjs");
+			return loadV3(pkgDir, jsConfig);
+		});
+		mod = null;
+		error("stylesheet-unsupported", base, "You have specified a Tailwind CSS stylesheet but your installed version of Tailwind CSS does not support this feature.");
+	}
+	if (mod && mod.__unstable__loadDesignSystem && pkgDir) stylesheet ?? (stylesheet = `${pkgDir}/theme.css`);
+	return pathToApiMap.remember(`${pkgDir}:${stylesheet}`, async () => {
+		const { loadV4 } = await import("./v4-C-HWEQJm.mjs");
+		return loadV4(mod, stylesheet);
+	});
+}
+let resolvedModCache = expiringMap(1e4);
+async function resolveTailwindPath(options, baseDir) {
+	let pkgName = options.packageName ?? "tailwindcss";
+	let makeKey = (dir) => `${pkgName}:${dir}`;
+	let cached = resolvedModCache.get(makeKey(baseDir));
+	if (cached !== void 0) return cached;
+	let resolve = async () => {
+		let pkgDir = null;
+		let mod = null;
+		try {
+			mod = await import(pathToFileURL(resolveJsFrom(baseDir, pkgName)).toString());
+			let pkgFile = resolveJsFrom(baseDir, `${pkgName}/package.json`);
+			pkgDir = path.dirname(pkgFile);
+		} catch {}
+		return [mod, pkgDir];
+	};
+	let result = await resolve();
+	let [, pkgDir] = result;
+	if (pkgDir) cacheForDirs(resolvedModCache, baseDir, result, pkgDir, makeKey);
+	else resolvedModCache.set(makeKey(baseDir), result);
+	return result;
+}
+function resolveJsConfigPath(configPath) {
+	if (!configPath) return null;
+	if (configPath.endsWith(".css")) return null;
+	return configPath;
+}
+let configPathCache = /* @__PURE__ */ new Map();
+function findClosestJsConfig(inputDir) {
+	let cached = configPathCache.get(inputDir);
+	if (cached !== void 0) return cached;
+	let configPath = null;
+	try {
+		configPath = sync_default(inputDir, (_, names) => {
+			if (names.includes("tailwind.config.js")) return "tailwind.config.js";
+			if (names.includes("tailwind.config.cjs")) return "tailwind.config.cjs";
+			if (names.includes("tailwind.config.mjs")) return "tailwind.config.mjs";
+			if (names.includes("tailwind.config.ts")) return "tailwind.config.ts";
+		}) ?? null;
+	} catch {}
+	if (configPath) cacheForDirs(configPathCache, inputDir, configPath, path.dirname(configPath));
+	else configPathCache.set(inputDir, null);
+	return configPath;
+}
+function resolveStylesheet(stylesheetPath, base) {
+	if (!stylesheetPath) return null;
+	if (stylesheetPath.endsWith(".js") || stylesheetPath.endsWith(".mjs") || stylesheetPath.endsWith(".cjs") || stylesheetPath.endsWith(".ts") || stylesheetPath.endsWith(".mts") || stylesheetPath.endsWith(".cts")) error("stylesheet-is-js-file", base, "Your `stylesheetPath` option points to a JS/TS config file. You must point to your project's `.css` file for v4 projects.");
+	else if (stylesheetPath.endsWith(".sass") || stylesheetPath.endsWith(".scss") || stylesheetPath.endsWith(".less") || stylesheetPath.endsWith(".styl")) error("stylesheet-is-preprocessor-file", base, "Your `stylesheetPath` option points to a preprocessor file. This is unsupported and you may get unexpected results.");
+	else if (!stylesheetPath.endsWith(".css")) error("stylesheet-is-not-css-file", base, "Your `stylesheetPath` option does not point to a CSS file. This is unsupported and you may get unexpected results.");
+	return stylesheetPath;
+}
+async function createSorter(opts) {
+	let preserveDuplicates = opts.preserveDuplicates ?? false;
+	let preserveWhitespace = opts.preserveWhitespace ?? false;
+	let api = await getTailwindConfig({
+		base: opts.base,
+		filepath: opts.filepath,
+		configPath: opts.configPath,
+		stylesheetPath: opts.stylesheetPath,
+		packageName: opts.packageName
+	});
+	let env = {
+		context: api,
+		changes: [],
+		options: {
+			tailwindPreserveWhitespace: preserveWhitespace,
+			tailwindPreserveDuplicates: preserveDuplicates,
+			tailwindPackageName: opts.packageName
+		},
+		matcher: void 0
+	};
+	return {
+		sortClassLists(classes) {
+			return classes.map((list) => {
+				return sortClassList({
+					api,
+					classList: list,
+					removeDuplicates: !preserveDuplicates
+				}).classList;
+			});
+		},
+		sortClassAttributes(classes) {
+			return classes.map((list) => sortClasses(list, { env }));
+		}
+	};
+}
+export { error as a, sortClasses as i, getTailwindConfig as n, warn as o, sortClassList as r, createSorter as t };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/sorter.d.mts

@@ -0,0 +1,78 @@
+//#region src/sorter.d.ts
+interface SorterOptions {
+  /**
+   * The directory used to resolve relative file paths.
+   *
+   * When not provided this will be:
+   * - The current working directory
+   */
+  base?: string;
+  /**
+   * The path to the file being formatted.
+   *
+   * When provided, Tailwind CSS is resolved relative to this path; otherwise,
+   * it is resolved relative to `base`.
+   */
+  filepath?: string;
+  /**
+   * Path to the Tailwind CSS config file (v3).
+   *
+   * Paths are resolved relative to `base`.
+   */
+  configPath?: string;
+  /**
+   * Path to the CSS stylesheet used by Tailwind CSS (v4+).
+   *
+   * Paths are resolved relative to `base`.
+   */
+  stylesheetPath?: string;
+  /**
+   * Whether or not to preserve whitespace around classes.
+   *
+   * Default: false
+   */
+  preserveWhitespace?: boolean;
+  /**
+   * Whether or not to preserve duplicate classes.
+   *
+   * Default: false
+   */
+  preserveDuplicates?: boolean;
+}
+interface Sorter {
+  /**
+   * Sort one or more class attributes.
+   *
+   * Each element is the value of an HTML `class` attribute (or similar). i.e. a
+   * space separated list of class names as a string.
+   */
+  sortClassAttributes(classes: string[]): string[];
+  /**
+   * Sort one or more class lists.
+   *
+   * Each element is an array of class names. Passing a space separated class
+   * list in each element is not supported.
+   *
+   * Duplicates are removed by default unless `preserveDuplicates` is enabled.
+   */
+  sortClassLists(classes: string[][]): string[][];
+}
+/**
+ * Creates a sorter instance for sorting Tailwind CSS classes.
+ *
+ * This function initializes a sorter with the specified Tailwind CSS configuration.
+ * The sorter can be used to sort class attributes (space-separated strings) or
+ * class lists (arrays of class names).
+
+ * @example
+ * ```ts
+ * const sorter = await createSorter({})
+ *
+ * // Sort class lists
+ * const sorted = sorter.sortClassLists([['p-4', 'm-2']])
+ * // Returns: [['m-2', 'p-4']]
+ * ```
+ */
+declare function createSorter(opts: SorterOptions): Promise<Sorter>;
+//#endregion
+export { Sorter, SorterOptions, createSorter };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/sorter.mjs

@@ -0,0 +1,3 @@
+import { n as getTailwindConfig, t as createSorter } from "./sorter-BZkvDMjt.mjs";
+import "./resolve-pWjAK-4f.mjs";
+export { createSorter, getTailwindConfig };

tools/ui/node_modules/prettier-plugin-tailwindcss/dist/utils-D8dQkKEd.mjs

@@ -0,0 +1,79 @@
+import * as path from "node:path";
+function isNodeLike(value) {
+	return typeof (value === null || value === void 0 ? void 0 : value.type) === "string";
+}
+function visit(ast, callbackMap) {
+	function _visit(node, path, meta) {
+		if (typeof callbackMap === "function") {
+			if (callbackMap(node, path, meta) === false) return;
+		} else if (node.type in callbackMap) {
+			if (callbackMap[node.type](node, path, meta) === false) return;
+		}
+		const keys = Object.keys(node);
+		for (let i = 0; i < keys.length; i++) {
+			const child = node[keys[i]];
+			if (Array.isArray(child)) {
+				for (let j = 0; j < child.length; j++) if (isNodeLike(child[j])) {
+					let newMeta = { ...meta };
+					let newPath = [{
+						node: child[j],
+						parent: node,
+						key: keys[i],
+						index: j,
+						meta: newMeta
+					}, ...path];
+					_visit(child[j], newPath, newMeta);
+				}
+			} else if (isNodeLike(child)) {
+				let newMeta = { ...meta };
+				_visit(child, [{
+					node: child,
+					parent: node,
+					key: keys[i],
+					index: i,
+					meta: newMeta
+				}, ...path], newMeta);
+			}
+		}
+	}
+	let newMeta = {};
+	_visit(ast, [{
+		node: ast,
+		parent: null,
+		key: null,
+		index: null,
+		meta: newMeta
+	}], newMeta);
+}
+function spliceChangesIntoString(str, changes) {
+	if (!changes[0]) return str;
+	changes.sort((a, b) => {
+		return a.end - b.end || a.start - b.start;
+	});
+	let result = "";
+	let previous = changes[0];
+	result += str.slice(0, previous.start);
+	result += previous.after;
+	for (let i = 1; i < changes.length; ++i) {
+		let change = changes[i];
+		result += str.slice(previous.end, change.start);
+		result += change.after;
+		previous = change;
+	}
+	result += str.slice(previous.end);
+	return result;
+}
+function bigSign(bigIntValue) {
+	return Number(bigIntValue > 0n) - Number(bigIntValue < 0n);
+}
+function cacheForDirs(cache, inputDir, value, targetDir, makeKey = (dir) => dir) {
+	let dir = inputDir;
+	while (dir !== path.dirname(dir) && dir.length >= targetDir.length) {
+		const key = makeKey(dir);
+		if (cache.get(key) !== void 0) break;
+		cache.set(key, value);
+		if (dir === targetDir) break;
+		dir = path.dirname(dir);
+	}
+}
+export { visit as i, cacheForDirs as n, spliceChangesIntoString as r, bigSign as t };

tools/ui/node_modules/prettier-plugin-tailwindcss/package.json

@@ -0,0 +1,170 @@
+{
+  "type": "module",
+  "name": "prettier-plugin-tailwindcss",
+  "version": "0.8.0",
+  "description": "A Prettier plugin for sorting Tailwind CSS classes.",
+  "license": "MIT",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./sorter": {
+      "types": "./dist/sorter.d.mts",
+      "import": "./dist/sorter.mjs",
+      "default": "./dist/sorter.mjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tailwindlabs/prettier-plugin-tailwindcss"
+  },
+  "bugs": {
+    "url": "https://github.com/tailwindlabs/prettier-plugin-tailwindcss/issues"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.28.2",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.0",
+    "@marko/compiler": "^5.39.49",
+    "@prettier/plugin-hermes": "^0.1.2",
+    "@prettier/plugin-oxc": "^0.1.2",
+    "@prettier/plugin-pug": "^3.4.2",
+    "@shopify/prettier-plugin-liquid": "^1.10.0",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.0",
+    "@types/node": "^24.3.0",
+    "@zackad/prettier-plugin-twig": "^0.16.0",
+    "clear-module": "^4.1.2",
+    "dedent": "^1.6.0",
+    "enhanced-resolve": "^5.18.3",
+    "escalade": "^3.2.0",
+    "fast-glob": "^3.3.3",
+    "import-sort-style-module": "^6.0.0",
+    "jiti": "^2.6.0",
+    "knip": "^5.83.0",
+    "license-checker": "^25.0.1",
+    "line-column": "^1.0.2",
+    "marko": "^5.37.46",
+    "oxlint": "^1.43.0",
+    "oxlint-tsgolint": "^0.11.4",
+    "postcss": "^8.5.6",
+    "postcss-import": "^16.1.1",
+    "prettier": "^3.7.3",
+    "prettier-plugin-astro": "^0.14.1",
+    "prettier-plugin-css-order": "^2.1.2",
+    "prettier-plugin-jsdoc": "^1.3.3",
+    "prettier-plugin-marko": "^3.3.2",
+    "prettier-plugin-multiline-arrays": "^4.0.3",
+    "prettier-plugin-organize-attributes": "^1.0.0",
+    "prettier-plugin-organize-imports": "^4.2.0",
+    "prettier-plugin-sort-imports": "^1.8.8",
+    "prettier-plugin-svelte": "^3.4.0",
+    "pug-lexer": "^5.0.1",
+    "svelte": "^5.38.2",
+    "tailwindcss-v3": "npm:tailwindcss@^3.4.18",
+    "tailwindcss-v4": "npm:tailwindcss@^4.1.14",
+    "tsdown": "^0.20.1",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "*",
+    "@prettier/plugin-hermes": "*",
+    "@prettier/plugin-oxc": "*",
+    "@prettier/plugin-pug": "*",
+    "@shopify/prettier-plugin-liquid": "*",
+    "@trivago/prettier-plugin-sort-imports": "*",
+    "@zackad/prettier-plugin-twig": "*",
+    "prettier": "^3.0",
+    "prettier-plugin-astro": "*",
+    "prettier-plugin-css-order": "*",
+    "prettier-plugin-jsdoc": "*",
+    "prettier-plugin-marko": "*",
+    "prettier-plugin-multiline-arrays": "*",
+    "prettier-plugin-organize-attributes": "*",
+    "prettier-plugin-organize-imports": "*",
+    "prettier-plugin-sort-imports": "*",
+    "prettier-plugin-svelte": "*"
+  },
+  "peerDependenciesMeta": {
+    "@ianvs/prettier-plugin-sort-imports": {
+      "optional": true
+    },
+    "@prettier/plugin-hermes": {
+      "optional": true
+    },
+    "@prettier/plugin-oxc": {
+      "optional": true
+    },
+    "@prettier/plugin-pug": {
+      "optional": true
+    },
+    "@shopify/prettier-plugin-liquid": {
+      "optional": true
+    },
+    "@trivago/prettier-plugin-sort-imports": {
+      "optional": true
+    },
+    "@zackad/prettier-plugin-twig": {
+      "optional": true
+    },
+    "prettier-plugin-astro": {
+      "optional": true
+    },
+    "prettier-plugin-css-order": {
+      "optional": true
+    },
+    "prettier-plugin-jsdoc": {
+      "optional": true
+    },
+    "prettier-plugin-marko": {
+      "optional": true
+    },
+    "prettier-plugin-multiline-arrays": {
+      "optional": true
+    },
+    "prettier-plugin-organize-attributes": {
+      "optional": true
+    },
+    "prettier-plugin-organize-imports": {
+      "optional": true
+    },
+    "prettier-plugin-sort-imports": {
+      "optional": true
+    },
+    "prettier-plugin-svelte": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "importSort": {
+    ".js, .jsx, .ts, .tsx": {
+      "style": "module"
+    }
+  },
+  "jest": {
+    "testTimeout": 15000
+  },
+  "overrides": {
+    "@ianvs/prettier-plugin-sort-imports": {
+      "@prettier/plugin-oxc": "^0.1.2"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "pretest": "node scripts/install-fixture-deps.js",
+    "test": "vitest",
+    "format": "prettier \"src/**/*.ts\" \"scripts/**/*.js\" \"tests/*.ts\" --write --print-width 100 --single-quote --no-semi",
+    "lint": "knip && oxlint --type-aware src tests/*.ts",
+    "release-channel": "node ./scripts/release-channel.js",
+    "release-notes": "node ./scripts/release-notes.js"
+  }
+}

tools/ui/node_modules/pretty-bytes/index.d.ts

@@ -0,0 +1,140 @@
+export type Options = {
+	/**
+	Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.
+
+	@default false
+	*/
+	readonly signed?: boolean;
+
+	/**
+	- If `false`: Output won't be localized.
+	- If `true`: Localize the output using the system/browser locale.
+	- If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
+	- If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
+
+	@default false
+	*/
+	readonly locale?: boolean | string | readonly string[];
+
+	/**
+	Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).
+
+	@default false
+
+	@example
+	```
+	import prettyBytes from 'pretty-bytes';
+
+	prettyBytes(1337, {bits: true});
+	//=> '1.34 kbit'
+	```
+	*/
+	readonly bits?: boolean;
+
+	/**
+	Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.
+
+	@default false
+
+	@example
+	```
+	import prettyBytes from 'pretty-bytes';
+
+	prettyBytes(1000, {binary: true});
+	//=> '1000 bit'
+
+	prettyBytes(1024, {binary: true});
+	//=> '1 kiB'
+	```
+	*/
+	readonly binary?: boolean;
+
+	/**
+	The minimum number of fraction digits to display.
+
+	If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
+
+	@default undefined
+
+	@example
+	```
+	import prettyBytes from 'pretty-bytes';
+
+	// Show the number with at least 3 fractional digits
+	prettyBytes(1900, {minimumFractionDigits: 3});
+	//=> '1.900 kB'
+
+	prettyBytes(1900);
+	//=> '1.9 kB'
+	```
+	*/
+	readonly minimumFractionDigits?: number;
+
+	/**
+	The maximum number of fraction digits to display.
+
+	If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
+
+	@default undefined
+
+	@example
+	```
+	import prettyBytes from 'pretty-bytes';
+
+	// Show the number with at most 1 fractional digit
+	prettyBytes(1920, {maximumFractionDigits: 1});
+	//=> '1.9 kB'
+
+	prettyBytes(1920);
+	//=> '1.92 kB'
+	```
+	*/
+	readonly maximumFractionDigits?: number;
+
+	/**
+	Put a space between the number and unit.
+
+	@default true
+
+	@example
+	```
+	import prettyBytes from 'pretty-bytes';
+
+	prettyBytes(1920, {space: false});
+	//=> '1.9kB'
+
+	prettyBytes(1920);
+	//=> '1.92 kB'
+	```
+	*/
+	readonly space?: boolean;
+};
+
+/**
+Convert bytes to a human readable string: `1337` → `1.34 kB`.
+
+@param number - The number to format.
+
+@example
+```
+import prettyBytes from 'pretty-bytes';
+
+prettyBytes(1337);
+//=> '1.34 kB'
+
+prettyBytes(100);
+//=> '100 B'
+
+// Display file size differences
+prettyBytes(42, {signed: true});
+//=> '+42 B'
+
+// Localized output using German locale
+prettyBytes(1337, {locale: 'de'});
+//=> '1,34 kB'
+```
+*/
+export default function prettyBytes(
+	number: number,
+	options?: Options
+): string;