@tamagui/language-service 0.0.0-bootstrap.0 → 3.0.0-beta.637.1

package/README.md

@@ -1 +1,140 @@
-# @tamagui/language-service
+# `@tamagui/language-service`
+
+TypeScript language-service completions for Tamagui flat style values. The
+plugin reads the `.tamagui/tamagui.config.json` file emitted from the active
+Tamagui runtime config, then delegates its vocabulary, parsing, and
+property-family validation to `@tamagui/style-grammar`.
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [{ "name": "@tamagui/language-service" }]
+  }
+}
+```
+
+VS Code must also be able to resolve the plugin package. Select the workspace
+TypeScript version, or add this machine setting and restart the TypeScript
+server:
+
+```json
+{
+  "js/ts.tsserver.pluginPaths": ["node_modules"]
+}
+```
+
+`js/ts.tsserver.pluginPaths` is machine-scoped, so VS Code ignores it in a
+workspace `.vscode/settings.json` file.
+
+VS Code also disables automatic suggestions inside strings by default. Enable
+them for TSX if completion should open after typing a space in a value:
+
+```json
+{
+  "[typescriptreact]": {
+    "editor.quickSuggestions": {
+      "strings": "on"
+    }
+  }
+}
+```
+
+VS Code's TypeScript provider does not register `:` as a completion trigger.
+The companion Tamagui Language Service extension retriggers suggestions after a
+modifier colon and delegates the resulting request back to this plugin.
+
+If the generated config lives elsewhere, set `configPath` relative to the
+TypeScript project:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "@tamagui/language-service",
+        "configPath": ".tamagui/tamagui.config.json"
+      }
+    ]
+  }
+}
+```
+
+The plugin completes configured values and modifiers in base values and
+conditional clause payloads on components carrying Tamagui's `staticConfig`
+type marker and configurations passed to the core Tamagui `styled()` export.
+TypeScript's contextual prop type remains the authority for whether the host
+accepts that property and value.
+
+Modifier suggestions are sorted as state, group, media, container, root theme,
+then platform. `hover:` and `press:` lead the state group. Nested themes remain
+valid `<Theme>` targets but are not flat-value modifiers, so an active
+`dark_blue` theme matches `dark:` and never adds a `dark_blue:` suggestion.
+After a modifier colon, the plugin offers both property values and another
+modifier, so `margin="4 sm:h"` completes to `margin="4 sm:hover:"`.
+State continuations such as `hover:` and `press:` sort first, followed by the
+other modifier categories and configured property values. A finished chain such
+as `margin="4 web:sm:hover:"` still includes its payload tokens in that list.
+Modifier completion traverses a trie derived from the generated config. The
+canonical authoring order is platform, root theme, container, viewport media,
+group state, then subject state. A trie node omits conditions already used,
+aliases of used conditions, additional platforms or root themes, earlier
+categories, and conditions beyond the emitter's five non-platform limit.
+Each category occupies one slot in a clause. For example, `hover:` offers
+payload values and never another subject state such as `press:`, while `sm:`
+never offers another viewport-media modifier.
+Runtime parsing remains order-insensitive for compatibility, but tooling only
+authors the canonical shape. A completed payload resets traversal, so every new
+space-delimited clause starts from the trie root at arbitrary program length.
+
+Container conditions include their size: `@sm:` targets the nearest container
+and `@sm/layout:` targets a named container. `@container:` is not a modifier.
+
+It does not carry a fallback vocabulary. A missing or invalid generated config
+produces no Tamagui completions, so the editor cannot suggest names the runtime
+config does not define. The generated config is watched and its vocabulary is
+reloaded without restarting tsserver.
+
+## Package layout: one engine, many hosts
+
+`@tamagui/style-grammar` owns what every value MEANS. This package projects
+that engine into editor- and checker-shaped results, and each host stays a
+thin adapter:
+
+| entry | runs in | provides |
+| --- | --- | --- |
+| `@tamagui/language-service` | tsserver | completions, diagnostics, hover (quick info) |
+| `@tamagui/language-service/core` | anywhere (browser-safe) | `createStyleTooling(configJson)`: completions, diagnostics, annotations, hover, color swatches for one prop/value |
+| `@tamagui/language-service/document` | anywhere (browser-safe) | `createDocumentStyleTooling(tooling, extract)`: the same, mapped to file offsets |
+| `@tamagui/language-service/extract-sucrase` | anywhere (browser-safe) | token-stream site extraction; inject your own sucrase `parse`/`TokenType` so bundles never duplicate it |
+| `@tamagui/language-service/extract-estree` | anywhere | the same site contract from any ESTree program (eslint, oxc-parser) |
+| `@tamagui/language-service/check` | node | `checkStyleFiles` + `formatCheckResults`, the engine behind `tamagui check` |
+
+Every path takes the same input: the `.tamagui/tamagui.config.json` artifact
+the compiler emits. `core`, `document`, and `extract-sucrase` have no node,
+typescript, or sucrase imports — bundled together they are ~15KB gzipped — so
+an in-browser IDE embeds them directly:
+
+```ts
+import { createStyleTooling } from '@tamagui/language-service/core'
+import { createDocumentStyleTooling } from '@tamagui/language-service/document'
+import { createSucraseStyleSiteExtractor } from '@tamagui/language-service/extract-sucrase'
+import { parse } from 'sucrase/dist/parser/index.js'
+import { TokenType } from 'sucrase/dist/parser/tokenizer/types.js'
+
+const tooling = createStyleTooling(configJson)
+const document = createDocumentStyleTooling(
+  tooling,
+  createSucraseStyleSiteExtractor({ parse, TokenType }, {
+    isStyleProp: (name) => tooling.isStyleProp(name),
+  })
+)
+document.completionsAt(source, offset)
+document.diagnostics(source)
+document.hoverAt(source, offset)
+document.colors(source)
+```
+
+The VS Code extension (`code/core/language-service-vscode`) contributes this
+plugin through `typescriptServerPlugins` (zero per-project tsconfig setup),
+adds inline color swatches through the document API, and retriggers
+completions after modifier colons.

package/dist/cjs/check.cjs

@@ -0,0 +1,173 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var check_exports = {};
+__export(check_exports, {
+	MissingConfigArtifactError: () => MissingConfigArtifactError,
+	checkStyleFiles: () => checkStyleFiles,
+	createProjectExtractor: () => createProjectExtractor,
+	formatCheckResults: () => formatCheckResults
+});
+module.exports = __toCommonJS(check_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_parser = require("sucrase/dist/parser/index.js");
+var import_types = require("sucrase/dist/parser/tokenizer/types.js");
+var import_core = require("./core.cjs");
+var import_document = require("./document.cjs");
+var import_extract_sucrase = require("./extract-sucrase.cjs");
+const sourceExtensions = /\.(tsx|jsx)$/;
+const skippedDirectories = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".git",
+	".next",
+	".expo",
+	".tamagui"
+]);
+var MissingConfigArtifactError = class extends Error {
+	constructor(configPath) {
+		super(`no Tamagui config artifact at ${configPath} \u2014 run your dev server or \`tamagui generate\` once so the compiler emits it`);
+		this.name = "MissingConfigArtifactError";
+	}
+};
+function walkSourceFiles(directory, results) {
+	for (const entry of (0, import_node_fs.readdirSync)(directory, { withFileTypes: true })) {
+		if (entry.isDirectory()) {
+			if (!skippedDirectories.has(entry.name) && !entry.name.startsWith(".")) {
+				walkSourceFiles((0, import_node_path.join)(directory, entry.name), results);
+			}
+			continue;
+		}
+		if (sourceExtensions.test(entry.name)) results.push((0, import_node_path.join)(directory, entry.name));
+	}
+}
+function createProjectExtractor(isStyleProp) {
+	return (0, import_extract_sucrase.createSucraseStyleSiteExtractor)({
+		parse: import_parser.parse,
+		TokenType: import_types.TokenType
+	}, { isStyleProp });
+}
+function checkStyleFiles(options) {
+	const configPath = options.configPath ?? (0, import_node_path.join)(options.root, ".tamagui", "tamagui.config.json");
+	let contents;
+	try {
+		contents = (0, import_node_fs.readFileSync)(configPath, "utf8");
+	} catch {
+		throw new MissingConfigArtifactError(configPath);
+	}
+	const tooling = (0, import_core.createStyleTooling)(JSON.parse(contents));
+	if (!tooling) throw new MissingConfigArtifactError(configPath);
+	const document = (0, import_document.createDocumentStyleTooling)(tooling, createProjectExtractor((name) => tooling.isStyleProp(name)));
+	let files;
+	if (options.files) {
+		files = [...options.files];
+	} else {
+		files = [];
+		walkSourceFiles(options.root, files);
+		files.sort();
+	}
+	const checked = [];
+	let diagnosticCount = 0;
+	for (const file of files) {
+		let source;
+		try {
+			source = (0, import_node_fs.readFileSync)(file, "utf8");
+		} catch {
+			continue;
+		}
+		let diagnostics;
+		try {
+			diagnostics = document.diagnostics(source);
+		} catch {
+			continue;
+		}
+		if (diagnostics.length === 0) continue;
+		diagnosticCount += diagnostics.length;
+		checked.push({
+			file: (0, import_node_path.relative)(options.root, file),
+			source,
+			diagnostics
+		});
+	}
+	return {
+		files: checked,
+		checkedFileCount: files.length,
+		diagnosticCount
+	};
+}
+const ansi = {
+	red: (text) => `\x1B[31m${text}\x1B[39m`,
+	dim: (text) => `\x1B[2m${text}\x1B[22m`,
+	bold: (text) => `\x1B[1m${text}\x1B[22m`,
+	cyan: (text) => `\x1B[36m${text}\x1B[39m`
+};
+const plain = {
+	red: (text) => text,
+	dim: (text) => text,
+	bold: (text) => text,
+	cyan: (text) => text
+};
+function lineStarts(source) {
+	const starts = [0];
+	for (let index = 0; index < source.length; index++) {
+		if (source.charCodeAt(index) === 10) starts.push(index + 1);
+	}
+	return starts;
+}
+function positionOf(starts, offset) {
+	let low = 0;
+	let high = starts.length - 1;
+	while (low < high) {
+		const mid = low + high + 1 >> 1;
+		if (starts[mid] <= offset) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		line: low,
+		column: offset - starts[low]
+	};
+}
+function formatCheckResults(result, options = {}) {
+	const paint = options.color === false ? plain : ansi;
+	const output = [];
+	for (const checked of result.files) {
+		const starts = lineStarts(checked.source);
+		const lines = checked.source.split("\n");
+		for (const diagnostic of checked.diagnostics) {
+			const start = positionOf(starts, diagnostic.start);
+			const end = positionOf(starts, diagnostic.end);
+			output.push(`${paint.bold(checked.file)}${paint.dim(`:${start.line + 1}:${start.column + 1}`)} ${paint.red("error")} ${diagnostic.message}`);
+			const line = lines[start.line] ?? "";
+			const gutter = String(start.line + 1);
+			output.push(`  ${paint.dim(`${gutter} \u2502`)} ${line}`);
+			const underlineLength = end.line === start.line ? Math.max(1, end.column - start.column) : Math.max(1, line.length - start.column);
+			output.push(`  ${paint.dim(`${" ".repeat(gutter.length)} \u2502`)} ${" ".repeat(start.column)}${paint.red("^".repeat(underlineLength))}`);
+			output.push("");
+		}
+	}
+	const summary = result.diagnosticCount === 0 ? `${paint.bold("✓")} ${result.checkedFileCount} files, no flat value problems` : `${paint.red(paint.bold(`\u2717 ${result.diagnosticCount} problem${result.diagnosticCount === 1 ? "" : "s"}`))} in ${result.files.length} file${result.files.length === 1 ? "" : "s"} ${paint.dim(`(${result.checkedFileCount} checked)`)}`;
+	output.push(summary);
+	return output.join("\n");
+}

package/dist/cjs/check.native.cjs

@@ -0,0 +1,369 @@
+"use strict";
+
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var check_exports = {};
+__export(check_exports, {
+	MissingConfigArtifactError: () => MissingConfigArtifactError,
+	checkStyleFiles: () => checkStyleFiles,
+	createProjectExtractor: () => createProjectExtractor,
+	formatCheckResults: () => formatCheckResults
+});
+module.exports = __toCommonJS(check_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_parser = require("sucrase/dist/parser/index.js");
+var import_types = require("sucrase/dist/parser/tokenizer/types.js");
+var import_core = require("./core.native.js");
+var import_document = require("./document.native.js");
+var import_extract_sucrase = require("./extract-sucrase.native.js");
+function _assert_this_initialized(self) {
+	if (self === void 0) {
+		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	}
+	return self;
+}
+function _call_super(_this, derived, args) {
+	derived = _get_prototype_of(derived);
+	return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+	if (!(instance instanceof Constructor)) {
+		throw new TypeError("Cannot call a class as a function");
+	}
+}
+function _construct(Parent, args, Class) {
+	if (_is_native_reflect_construct()) {
+		_construct = Reflect.construct;
+	} else {
+		_construct = function construct(Parent2, args2, Class2) {
+			var a = [null];
+			a.push.apply(a, args2);
+			var Constructor = Function.bind.apply(Parent2, a);
+			var instance = new Constructor();
+			if (Class2) _set_prototype_of(instance, Class2.prototype);
+			return instance;
+		};
+	}
+	return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+	_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+		return o2.__proto__ || Object.getPrototypeOf(o2);
+	};
+	return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+	if (typeof superClass !== "function" && superClass !== null) {
+		throw new TypeError("Super expression must either be null or a function");
+	}
+	subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+		value: subClass,
+		writable: true,
+		configurable: true
+	} });
+	if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+	return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+	if (call && (_type_of(call) === "object" || typeof call === "function")) {
+		return call;
+	}
+	return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+	_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+		o2.__proto__ = p2;
+		return o2;
+	};
+	return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+	var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+	_wrap_native_super = function wrapNativeSuper(Class2) {
+		if (Class2 === null || !_is_native_function(Class2)) return Class2;
+		if (typeof Class2 !== "function") {
+			throw new TypeError("Super expression must either be null or a function");
+		}
+		if (typeof _cache !== "undefined") {
+			if (_cache.has(Class2)) return _cache.get(Class2);
+			_cache.set(Class2, Wrapper);
+		}
+		function Wrapper() {
+			return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+		}
+		Wrapper.prototype = Object.create(Class2.prototype, { constructor: {
+			value: Wrapper,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		return _set_prototype_of(Wrapper, Class2);
+	};
+	return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+	try {
+		var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+	} catch (_) {}
+	return (_is_native_reflect_construct = function() {
+		return !!result;
+	})();
+}
+var sourceExtensions = /\.(tsx|jsx)$/;
+var skippedDirectories = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".git",
+	".next",
+	".expo",
+	".tamagui"
+]);
+var MissingConfigArtifactError = /* @__PURE__ */ (function(Error1) {
+	"use strict";
+	_inherits(MissingConfigArtifactError2, Error1);
+	function MissingConfigArtifactError2(configPath) {
+		_class_call_check(this, MissingConfigArtifactError2);
+		var _this;
+		_this = _call_super(this, MissingConfigArtifactError2, [`no Tamagui config artifact at ${configPath} \u2014 run your dev server or \`tamagui generate\` once so the compiler emits it`]);
+		_this.name = "MissingConfigArtifactError";
+		return _this;
+	}
+	return MissingConfigArtifactError2;
+})(_wrap_native_super(Error));
+function walkSourceFiles(directory, results) {
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = (0, import_fs.readdirSync)(directory, { withFileTypes: true })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var entry = _step.value;
+			if (entry.isDirectory()) {
+				if (!skippedDirectories.has(entry.name) && !entry.name.startsWith(".")) {
+					walkSourceFiles((0, import_path.join)(directory, entry.name), results);
+				}
+				continue;
+			}
+			if (sourceExtensions.test(entry.name)) results.push((0, import_path.join)(directory, entry.name));
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+}
+function createProjectExtractor(isStyleProp) {
+	return (0, import_extract_sucrase.createSucraseStyleSiteExtractor)({
+		parse: import_parser.parse,
+		TokenType: import_types.TokenType
+	}, { isStyleProp });
+}
+function checkStyleFiles(options) {
+	var _options_configPath;
+	var configPath = (_options_configPath = options.configPath) !== null && _options_configPath !== void 0 ? _options_configPath : (0, import_path.join)(options.root, ".tamagui", "tamagui.config.json");
+	var contents;
+	try {
+		contents = (0, import_fs.readFileSync)(configPath, "utf8");
+	} catch (e) {
+		throw new MissingConfigArtifactError(configPath);
+	}
+	var tooling = (0, import_core.createStyleTooling)(JSON.parse(contents));
+	if (!tooling) throw new MissingConfigArtifactError(configPath);
+	var document = (0, import_document.createDocumentStyleTooling)(tooling, createProjectExtractor(function(name) {
+		return tooling.isStyleProp(name);
+	}));
+	var files;
+	if (options.files) {
+		files = [...options.files];
+	} else {
+		files = [];
+		walkSourceFiles(options.root, files);
+		files.sort();
+	}
+	var checked = [];
+	var diagnosticCount = 0;
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var file = _step.value;
+			var source = void 0;
+			try {
+				source = (0, import_fs.readFileSync)(file, "utf8");
+			} catch (e) {
+				continue;
+			}
+			var diagnostics = void 0;
+			try {
+				diagnostics = document.diagnostics(source);
+			} catch (e) {
+				continue;
+			}
+			if (diagnostics.length === 0) continue;
+			diagnosticCount += diagnostics.length;
+			checked.push({
+				file: (0, import_path.relative)(options.root, file),
+				source,
+				diagnostics
+			});
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return {
+		files: checked,
+		checkedFileCount: files.length,
+		diagnosticCount
+	};
+}
+var ansi = {
+	red: function(text) {
+		return `\x1B[31m${text}\x1B[39m`;
+	},
+	dim: function(text) {
+		return `\x1B[2m${text}\x1B[22m`;
+	},
+	bold: function(text) {
+		return `\x1B[1m${text}\x1B[22m`;
+	},
+	cyan: function(text) {
+		return `\x1B[36m${text}\x1B[39m`;
+	}
+};
+var plain = {
+	red: function(text) {
+		return text;
+	},
+	dim: function(text) {
+		return text;
+	},
+	bold: function(text) {
+		return text;
+	},
+	cyan: function(text) {
+		return text;
+	}
+};
+function lineStarts(source) {
+	var starts = [0];
+	for (var index = 0; index < source.length; index++) {
+		if (source.charCodeAt(index) === 10) starts.push(index + 1);
+	}
+	return starts;
+}
+function positionOf(starts, offset) {
+	var low = 0;
+	var high = starts.length - 1;
+	while (low < high) {
+		var mid = low + high + 1 >> 1;
+		if (starts[mid] <= offset) low = mid;
+		else high = mid - 1;
+	}
+	return {
+		line: low,
+		column: offset - starts[low]
+	};
+}
+function formatCheckResults(result) {
+	var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+	var paint = options.color === false ? plain : ansi;
+	var output = [];
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = result.files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var checked = _step.value;
+			var starts = lineStarts(checked.source);
+			var lines = checked.source.split("\n");
+			var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+			try {
+				for (var _iterator1 = checked.diagnostics[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+					var diagnostic = _step1.value;
+					var start = positionOf(starts, diagnostic.start);
+					var end = positionOf(starts, diagnostic.end);
+					output.push(`${paint.bold(checked.file)}${paint.dim(`:${start.line + 1}:${start.column + 1}`)} ${paint.red("error")} ${diagnostic.message}`);
+					var _lines_start_line;
+					var line = (_lines_start_line = lines[start.line]) !== null && _lines_start_line !== void 0 ? _lines_start_line : "";
+					var gutter = String(start.line + 1);
+					output.push(`  ${paint.dim(`${gutter} \u2502`)} ${line}`);
+					var underlineLength = end.line === start.line ? Math.max(1, end.column - start.column) : Math.max(1, line.length - start.column);
+					output.push(`  ${paint.dim(`${" ".repeat(gutter.length)} \u2502`)} ${" ".repeat(start.column)}${paint.red("^".repeat(underlineLength))}`);
+					output.push("");
+				}
+			} catch (err) {
+				_didIteratorError1 = true;
+				_iteratorError1 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+						_iterator1.return();
+					}
+				} finally {
+					if (_didIteratorError1) {
+						throw _iteratorError1;
+					}
+				}
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	var summary = result.diagnosticCount === 0 ? `${paint.bold("✓")} ${result.checkedFileCount} files, no flat value problems` : `${paint.red(paint.bold(`\u2717 ${result.diagnosticCount} problem${result.diagnosticCount === 1 ? "" : "s"}`))} in ${result.files.length} file${result.files.length === 1 ? "" : "s"} ${paint.dim(`(${result.checkedFileCount} checked)`)}`;
+	output.push(summary);
+	return output.join("\n");
+}