@vitejs/devtools 0.1.5 → 0.1.9

package/dist/{dist-D2Z6bwqJ.js → dist-CCdqIez-.js}

@@ -1,4 +1,4 @@
-import { B as onScopeDispose, C as nextTick, G as shallowRef, H as readonly, I as customRef, J as toValue, K as toRef$1, L as getCurrentScope, M as watch, N as watchEffect, R as isRef, S as inject, T as onMounted, U as ref, W as shallowReadonly, Y as unref, l as computed, x as hasInjectionContext, y as getCurrentInstance } from "./vue.runtime.esm-bundler-CS1wMbap.js";
+import { computed, customRef, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, isRef, nextTick, onMounted, onScopeDispose, readonly, ref, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
 //#region ../../node_modules/.pnpm/@vueuse+shared@14.2.1_vue@3.5.30_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
 /**
 * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
@@ -44,8 +44,8 @@ function getIsIOS() {
 	var _window, _window2, _window3;
 	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.navigator.userAgent));
 }
-function toRef(...args) {
-	if (args.length !== 1) return toRef$1(...args);
+function toRef$1(...args) {
+	if (args.length !== 1) return toRef(...args);
 	const r = args[0];
 	return typeof r === "function" ? readonly(customRef(() => ({
 		get: r,
@@ -119,7 +119,7 @@ function debounceFilter(ms, options = {}) {
 */
 function pausableFilter(extendFilter = bypassFilter, options = {}) {
 	const { initialState = "active" } = options;
-	const isActive = toRef(initialState === "active");
+	const isActive = toRef$1(initialState === "active");
 	function pause() {
 		isActive.value = false;
 	}
@@ -576,6 +576,17 @@ function getHandlers() {
 function getSSRHandler(key, fallback) {
 	return handlers[key] || fallback;
 }
+/**
+* Reactive dark theme preference.
+*
+* @see https://vueuse.org/usePreferredDark
+* @param [options]
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function usePreferredDark(options) {
+	return useMediaQuery("(prefers-color-scheme: dark)", options);
+}
 function guessSerializerType(rawInit) {
 	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
 }
@@ -730,6 +741,86 @@ function useStorage(key, defaults$1, storage, options = {}) {
 	}
 	return data;
 }
+const CSS_DISABLE_TRANS = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";
+/**
+* Reactive color mode with auto data persistence.
+*
+* @see https://vueuse.org/useColorMode
+* @param options
+*/
+function useColorMode(options = {}) {
+	const { selector = "html", attribute = "class", initialValue = "auto", window: window$1 = defaultWindow, storage, storageKey = "vueuse-color-scheme", listenToStorageChanges = true, storageRef, emitAuto, disableTransition = true } = options;
+	const modes = {
+		auto: "",
+		light: "light",
+		dark: "dark",
+		...options.modes || {}
+	};
+	const preferredDark = usePreferredDark({ window: window$1 });
+	const system = computed(() => preferredDark.value ? "dark" : "light");
+	const store = storageRef || (storageKey == null ? toRef$1(initialValue) : useStorage(storageKey, initialValue, storage, {
+		window: window$1,
+		listenToStorageChanges
+	}));
+	const state = computed(() => store.value === "auto" ? system.value : store.value);
+	const updateHTMLAttrs = getSSRHandler("updateHTMLAttrs", (selector$1, attribute$1, value) => {
+		const el = typeof selector$1 === "string" ? window$1 === null || window$1 === void 0 ? void 0 : window$1.document.querySelector(selector$1) : unrefElement(selector$1);
+		if (!el) return;
+		const classesToAdd = /* @__PURE__ */ new Set();
+		const classesToRemove = /* @__PURE__ */ new Set();
+		let attributeToChange = null;
+		if (attribute$1 === "class") {
+			const current = value.split(/\s/g);
+			Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => {
+				if (current.includes(v)) classesToAdd.add(v);
+				else classesToRemove.add(v);
+			});
+		} else attributeToChange = {
+			key: attribute$1,
+			value
+		};
+		if (classesToAdd.size === 0 && classesToRemove.size === 0 && attributeToChange === null) return;
+		let style;
+		if (disableTransition) {
+			style = window$1.document.createElement("style");
+			style.appendChild(document.createTextNode(CSS_DISABLE_TRANS));
+			window$1.document.head.appendChild(style);
+		}
+		for (const c of classesToAdd) el.classList.add(c);
+		for (const c of classesToRemove) el.classList.remove(c);
+		if (attributeToChange) el.setAttribute(attributeToChange.key, attributeToChange.value);
+		if (disableTransition) {
+			window$1.getComputedStyle(style).opacity;
+			document.head.removeChild(style);
+		}
+	});
+	function defaultOnChanged(mode) {
+		var _modes$mode;
+		updateHTMLAttrs(selector, attribute, (_modes$mode = modes[mode]) !== null && _modes$mode !== void 0 ? _modes$mode : mode);
+	}
+	function onChanged(mode) {
+		if (options.onChanged) options.onChanged(mode, defaultOnChanged);
+		else defaultOnChanged(mode);
+	}
+	watch(state, onChanged, {
+		flush: "post",
+		immediate: true
+	});
+	tryOnMounted(() => onChanged(state.value));
+	const auto = computed({
+		get() {
+			return emitAuto ? store.value : state.value;
+		},
+		set(v) {
+			store.value = v;
+		}
+	});
+	return Object.assign(auto, {
+		store,
+		system,
+		state
+	});
+}
 /**
 * Manipulate CSS variables.
 *
@@ -769,6 +860,38 @@ function useCssVar(prop, target, options = {}) {
 	return variable;
 }
 /**
+* Reactive dark mode with auto data persistence.
+*
+* @see https://vueuse.org/useDark
+* @param options
+*/
+function useDark(options = {}) {
+	const { valueDark = "dark", valueLight = "" } = options;
+	const mode = useColorMode({
+		...options,
+		onChanged: (mode$1, defaultHandler) => {
+			var _options$onChanged;
+			if (options.onChanged) (_options$onChanged = options.onChanged) === null || _options$onChanged === void 0 || _options$onChanged.call(options, mode$1 === "dark", defaultHandler, mode$1);
+			else defaultHandler(mode$1);
+		},
+		modes: {
+			dark: valueDark,
+			light: valueLight
+		}
+	});
+	const system = computed(() => mode.system.value);
+	return computed({
+		get() {
+			return mode.value === "dark";
+		},
+		set(v) {
+			const modeVal = v ? "dark" : "light";
+			if (system.value === modeVal) mode.value = "auto";
+			else mode.value = modeVal;
+		}
+	});
+}
+/**
 * Reports changes to the dimensions of an Element's content or the border-box
 *
 * @see https://vueuse.org/useResizeObserver
@@ -1110,4 +1233,4 @@ function useWindowSize(options = {}) {
 	};
 }
 //#endregion
-export { useScreenSafeArea as a, useDebounceFn as c, useLocalStorage as i, watchDebounced as l, useElementBounding as n, useTimeAgo as o, useEventListener as r, useWindowSize as s, onClickOutside as t, watchImmediate as u };
+export { useLocalStorage as a, useWindowSize as c, watchImmediate as d, useEventListener as i, useDebounceFn as l, useDark as n, useScreenSafeArea as o, useElementBounding as r, useTimeAgo as s, onClickOutside as t, watchDebounced as u };

package/dist/dist-DpLy3ojW.js

@@ -0,0 +1,229 @@
+import { i as __exportAll } from "./constants-DfEeYo9W.js";
+import "node:path";
+import { networkInterfaces } from "node:os";
+import { createServer } from "node:net";
+import "node:fs/promises";
+//#region ../../node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	checkPort: () => checkPort,
+	getPort: () => getPort,
+	getRandomPort: () => getRandomPort,
+	isSafePort: () => isSafePort,
+	isUnsafePort: () => isUnsafePort
+});
+const unsafePorts = /* @__PURE__ */ new Set([
+	1,
+	7,
+	9,
+	11,
+	13,
+	15,
+	17,
+	19,
+	20,
+	21,
+	22,
+	23,
+	25,
+	37,
+	42,
+	43,
+	53,
+	69,
+	77,
+	79,
+	87,
+	95,
+	101,
+	102,
+	103,
+	104,
+	109,
+	110,
+	111,
+	113,
+	115,
+	117,
+	119,
+	123,
+	135,
+	137,
+	139,
+	143,
+	161,
+	179,
+	389,
+	427,
+	465,
+	512,
+	513,
+	514,
+	515,
+	526,
+	530,
+	531,
+	532,
+	540,
+	548,
+	554,
+	556,
+	563,
+	587,
+	601,
+	636,
+	989,
+	990,
+	993,
+	995,
+	1719,
+	1720,
+	1723,
+	2049,
+	3659,
+	4045,
+	5060,
+	5061,
+	6e3,
+	6566,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669,
+	6697,
+	10080
+]);
+function isUnsafePort(port) {
+	return unsafePorts.has(port);
+}
+function isSafePort(port) {
+	return !isUnsafePort(port);
+}
+var GetPortError = class extends Error {
+	constructor(message, opts) {
+		super(message, opts);
+		this.message = message;
+	}
+	name = "GetPortError";
+};
+function _log(verbose, message) {
+	if (verbose) console.log(`[get-port] ${message}`);
+}
+function _generateRange(from, to) {
+	if (to < from) return [];
+	const r = [];
+	for (let index = from; index <= to; index++) r.push(index);
+	return r;
+}
+function _tryPort(port, host) {
+	return new Promise((resolve) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", () => {
+			resolve(false);
+		});
+		server.listen({
+			port,
+			host
+		}, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(isSafePort(port2) && port2);
+			});
+		});
+	});
+}
+function _getLocalHosts(additional) {
+	const hosts = new Set(additional);
+	for (const _interface of Object.values(networkInterfaces())) for (const config of _interface || []) if (config.address && !config.internal && !config.address.startsWith("fe80::") && !config.address.startsWith("169.254")) hosts.add(config.address);
+	return [...hosts];
+}
+async function _findPort(ports, host) {
+	for (const port of ports) {
+		const r = await _tryPort(port, host);
+		if (r) return r;
+	}
+}
+function _fmtOnHost(hostname) {
+	return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+}
+const HOSTNAME_RE = /^(?!-)[\d.:A-Za-z-]{1,63}(?<!-)$/;
+function _validateHostname(hostname, _public, verbose) {
+	if (hostname && !HOSTNAME_RE.test(hostname)) {
+		const fallbackHost = _public ? "0.0.0.0" : "127.0.0.1";
+		_log(verbose, `Invalid hostname: ${JSON.stringify(hostname)}. Using ${JSON.stringify(fallbackHost)} as fallback.`);
+		return fallbackHost;
+	}
+	return hostname;
+}
+async function getPort(_userOptions = {}) {
+	if (typeof _userOptions === "number" || typeof _userOptions === "string") _userOptions = { port: Number.parseInt(_userOptions + "") || 0 };
+	const _port = Number(_userOptions.port ?? process.env.PORT);
+	const _userSpecifiedAnyPort = Boolean(_userOptions.port || _userOptions.ports?.length || _userOptions.portRange?.length);
+	const options = {
+		random: _port === 0,
+		ports: [],
+		portRange: [],
+		alternativePortRange: _userSpecifiedAnyPort ? [] : [3e3, 3100],
+		verbose: false,
+		..._userOptions,
+		port: _port,
+		host: _validateHostname(_userOptions.host ?? process.env.HOST, _userOptions.public, _userOptions.verbose)
+	};
+	if (options.random && !_userSpecifiedAnyPort) return getRandomPort(options.host);
+	const portsToCheck = [
+		options.port,
+		...options.ports,
+		..._generateRange(...options.portRange)
+	].filter((port) => {
+		if (!port) return false;
+		if (!isSafePort(port)) {
+			_log(options.verbose, `Ignoring unsafe port: ${port}`);
+			return false;
+		}
+		return true;
+	});
+	if (portsToCheck.length === 0) portsToCheck.push(3e3);
+	let availablePort = await _findPort(portsToCheck, options.host);
+	if (!availablePort && options.alternativePortRange.length > 0) {
+		availablePort = await _findPort(_generateRange(...options.alternativePortRange), options.host);
+		if (portsToCheck.length > 0) {
+			let message = `Unable to find an available port (tried ${portsToCheck.join("-")} ${_fmtOnHost(options.host)}).`;
+			if (availablePort) message += ` Using alternative port ${availablePort}.`;
+			_log(options.verbose, message);
+		}
+	}
+	if (!availablePort && _userOptions.random !== false) {
+		availablePort = await getRandomPort(options.host);
+		if (availablePort) _log(options.verbose, `Using random port ${availablePort}`);
+	}
+	if (!availablePort) {
+		const triedRanges = [
+			options.port,
+			options.portRange.join("-"),
+			options.alternativePortRange.join("-")
+		].filter(Boolean).join(", ");
+		throw new GetPortError(`Unable to find an available port ${_fmtOnHost(options.host)} (tried ${triedRanges})`);
+	}
+	return availablePort;
+}
+async function getRandomPort(host) {
+	const port = await checkPort(0, host);
+	if (port === false) throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
+	return port;
+}
+async function checkPort(port, host = process.env.HOST, verbose) {
+	if (!host) host = _getLocalHosts([void 0, "0.0.0.0"]);
+	if (!Array.isArray(host)) return _tryPort(port, host);
+	for (const _host of host) {
+		const _port = await _tryPort(port, _host);
+		if (_port === false) {
+			if (port < 1024 && verbose) _log(verbose, `Unable to listen to the privileged port ${port} ${_fmtOnHost(_host)}`);
+			return false;
+		}
+		if (port === 0 && _port !== 0) port = _port;
+	}
+	return port;
+}
+//#endregion
+export { getPort as n, dist_exports as t };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { n as InternalAnonymousAuthStorage, t as DevToolsInternalContext } from "./context-internal-Du6FuGIu.js";
-import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import { n as InternalAnonymousAuthStorage, t as DevToolsInternalContext } from "./context-internal-Ys7Zu3q3.js";
 import { SharedStatePatch } from "@vitejs/devtools-kit/utils/shared-state";
 import * as _vitejs_devtools_rpc0 from "@vitejs/devtools-rpc";
 import { RpcFunctionsCollectorBase } from "@vitejs/devtools-rpc";
 import * as _vitejs_devtools_kit0 from "@vitejs/devtools-kit";
-import { DevToolsDockEntry, DevToolsDocksUserSettings, DevToolsLogEntry, DevToolsNodeContext, DevToolsTerminalSessionStreamChunkEvent, RpcDefinitionsToFunctions } from "@vitejs/devtools-kit";
+import { DevToolsCommandShortcutOverrides, DevToolsDockEntry, DevToolsDocksUserSettings, DevToolsLogEntry, DevToolsNodeContext, DevToolsServerCommandEntry, DevToolsTerminalSessionStreamChunkEvent, RpcDefinitionsToFunctions } from "@vitejs/devtools-kit";
 import * as h3 from "h3";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import * as birpc from "birpc";
 
 //#region src/node/context.d.ts
@@ -64,6 +64,28 @@ declare const builtinRpcDeclarations: readonly [{
   dump?: _vitejs_devtools_rpc0.RpcDump<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
   __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>> | undefined;
   __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>>> | undefined;
+}, {
+  name: "devtoolskit:internal:commands:execute";
+  type?: "action" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  setup?: ((context: _vitejs_devtools_kit0.DevToolsNodeContext) => _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>>>) | undefined;
+  handler?: ((id: string, ...args: any[]) => Promise<unknown>) | undefined;
+  dump?: _vitejs_devtools_rpc0.RpcDump<[id: string, ...args: any[]], Promise<unknown>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
+  __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>> | undefined;
+  __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>>> | undefined;
+}, {
+  name: "devtoolskit:internal:commands:list";
+  type?: "static" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  setup?: ((context: _vitejs_devtools_kit0.DevToolsNodeContext) => _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>>>) | undefined;
+  handler?: (() => Promise<DevToolsServerCommandEntry[]>) | undefined;
+  dump?: _vitejs_devtools_rpc0.RpcDump<[], Promise<DevToolsServerCommandEntry[]>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
+  __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>> | undefined;
+  __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>>> | undefined;
 }, {
   name: "devtoolskit:internal:docks:on-launch";
   type?: "action" | undefined;
@@ -255,6 +277,8 @@ declare module '@vitejs/devtools-kit' {
     'devtoolskit:internal:terminals:updated': () => Promise<void>;
   }
   interface DevToolsRpcSharedStates {
+    'devtoolskit:internal:command-shortcuts': DevToolsCommandShortcutOverrides;
+    'devtoolskit:internal:commands': DevToolsServerCommandEntry[];
     'devtoolskit:internal:docks': DevToolsDockEntry[];
     'devtoolskit:internal:user-settings': DevToolsDocksUserSettings;
   }
@@ -268,6 +292,22 @@ interface DevToolsOptions {
    * @default true
    */
   builtinDevTools?: boolean;
+  /**
+   * Options for building static DevTools output alongside `vite build`.
+   */
+  build?: {
+    /**
+     * Automatically build DevTools when running `vite build`.
+     *
+     * @default false
+     */
+    withApp?: boolean;
+    /**
+     * Output directory for the DevTools build (relative to root).
+     * Defaults to Vite's `build.outDir`.
+     */
+    outDir?: string;
+  };
 }
 declare function DevTools(options?: DevToolsOptions): Promise<Plugin[]>;
 //#endregion

package/dist/index.js

@@ -1,2 +1,4 @@
-import { a as createDevToolsContext, r as createDevToolsMiddleware, t as DevTools } from "./plugins-DiuKIPkS.js";
+import { n as createDevToolsContext } from "./context-DmXts6Ac.js";
+import { t as DevTools } from "./plugins-vfc-N600.js";
+import { t as createDevToolsMiddleware } from "./server-DSh-GQIq.js";
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/internal.d.ts

@@ -1,2 +1,2 @@
-import { n as InternalAnonymousAuthStorage, r as getInternalContext, t as DevToolsInternalContext } from "./context-internal-Du6FuGIu.js";
+import { n as InternalAnonymousAuthStorage, r as getInternalContext, t as DevToolsInternalContext } from "./context-internal-Ys7Zu3q3.js";
 export { type DevToolsInternalContext, type InternalAnonymousAuthStorage, getInternalContext };

package/dist/internal.js

@@ -1,2 +1,2 @@
-import { t as getInternalContext } from "./context-internal-CvIHbZq4.js";
+import { t as getInternalContext } from "./context-internal-DZpoJjMz.js";
 export { getInternalContext };

package/dist/plugins-vfc-N600.js

@@ -0,0 +1,59 @@
+import { n as ansis_default } from "./constants-DfEeYo9W.js";
+import { dirDist } from "./dirs.js";
+import { t as DevToolsServer } from "./server-DH39-LHL.js";
+import { join, normalize, resolve } from "pathe";
+import process from "node:process";
+//#region src/node/plugins/build.ts
+function DevToolsBuild(options = {}) {
+	let context;
+	let resolvedConfig;
+	return {
+		name: "vite:devtools:build",
+		apply: "build",
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		async buildStart() {
+			const { createDevToolsContext } = await import("./context-DmXts6Ac.js").then((n) => n.t);
+			context = await createDevToolsContext(resolvedConfig);
+		},
+		async closeBundle() {
+			console.log(ansis_default.cyan`${"⬢"} Building static Vite DevTools...`);
+			const outDir = options.outDir ? resolve(resolvedConfig.root, options.outDir) : resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+			const { buildStaticDevTools } = await import("./build-static-zB8LrlMJ.js");
+			await buildStaticDevTools({
+				context,
+				outDir
+			});
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/injection.ts
+function DevToolsInjection() {
+	return {
+		name: "vite:devtools:injection",
+		enforce: "post",
+		transformIndexHtml() {
+			return [{
+				tag: "script",
+				attrs: {
+					src: `/@fs/${process.env.VITE_DEVTOOLS_LOCAL_DEV ? normalize(join(dirDist, "..", "src/client/inject/index.ts")) : normalize(join(dirDist, "client/inject.js"))}`,
+					type: "module"
+				},
+				injectTo: "body"
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/index.ts
+async function DevTools(options = {}) {
+	const { builtinDevTools = true, build } = options;
+	const plugins = [DevToolsInjection(), DevToolsServer()];
+	if (build?.withApp) plugins.push(DevToolsBuild({ outDir: build.outDir }));
+	if (builtinDevTools) plugins.push(await import("@vitejs/devtools-rolldown").then((m) => m.DevToolsRolldownUI()));
+	return plugins;
+}
+//#endregion
+export { DevTools as t };