@treelsp/cli 0.0.2 → 0.0.4

package/README.md

@@ -1,6 +1,6 @@
 # @treelsp/cli
 
-CLI tool for [treelsp](https://github.com/dhrubomoy/treelsp) — generate Tree-sitter grammars, WASM parsers, and language servers from TypeScript definitions.
+CLI tool for [treelsp](https://github.com/dhrubomoy/treelsp) — generate parsers and language servers from TypeScript grammar definitions. Supports Tree-sitter and Lezer backends.
 
 ## Installation
 
@@ -20,15 +20,15 @@ Scaffold a new language project interactively.
 treelsp init
 ```
 
-Prompts for a language name and file extension, then creates a project directory with:
-- `grammar.ts` — language definition template
-- `package.json` — dependencies and scripts
-- `tsconfig.json` — TypeScript configuration
-- `.gitignore`
+Prompts for a language name, file extension, and parser backend (Tree-sitter or Lezer), then creates a pnpm monorepo with two packages:
+- `packages/language/` — grammar definition (`grammar.ts`) and generated files
+- `packages/extension/` — VS Code extension that launches the language server
+
+Also generates root config files (`treelsp-config.json`, `pnpm-workspace.yaml`, `.vscode/launch.json`).
 
 ### `treelsp generate`
 
-Generate grammar.js, AST types, manifest, and syntax highlighting queries from a language definition.
+Generate grammar files, AST types, manifest, and syntax highlighting queries from a language definition.
 
 ```
 Usage: treelsp generate [options]
@@ -38,16 +38,26 @@ Options:
   -w, --watch        watch for changes
 ```
 
-**Output files** (written to the output directory, default `generated/`):
+**Output files** depend on the backend:
+
+**Tree-sitter** (default, written to `generated/`):
 - `grammar.js` — Tree-sitter grammar (CommonJS)
 - `ast.ts` — typed AST interfaces
 - `treelsp.json` — manifest for VS Code extension discovery
+- `syntax.tmLanguage.json` — TextMate grammar
 - `queries/highlights.scm` — Tree-sitter syntax highlighting
 - `queries/locals.scm` — Tree-sitter scope/locals
 
+**Lezer** (written to `generated-lezer/` or custom `out` path):
+- `grammar.lezer` — Lezer grammar specification
+- `parser-meta.json` — field/node metadata
+- `ast.ts` — typed AST interfaces
+- `treelsp.json` — manifest for VS Code extension discovery
+- `syntax.tmLanguage.json` — TextMate grammar
+
 ### `treelsp build`
 
-Compile the generated grammar to WASM and bundle the language server.
+Compile the generated grammar and bundle the language server.
 
 ```
 Usage: treelsp build [options]
@@ -56,13 +66,22 @@ Options:
   -f, --file <file>  path to treelsp-config.json or package.json with treelsp field
 ```
 
-Requires the [tree-sitter CLI](https://github.com/tree-sitter/tree-sitter/blob/master/cli/README.md) to be installed (`npm install -g tree-sitter-cli` or `cargo install tree-sitter-cli`).
+**Tree-sitter backend** requires the [tree-sitter CLI](https://github.com/tree-sitter/tree-sitter/blob/master/cli/README.md) (`npm install -g tree-sitter-cli` or `cargo install tree-sitter-cli`).
+
+**Lezer backend** requires no external tools (pure JavaScript compilation).
 
 **Output files:**
+
+Tree-sitter:
 - `grammar.wasm` — compiled WebAssembly parser
 - `server.bundle.cjs` — self-contained language server bundle
 - `tree-sitter.wasm` — web-tree-sitter runtime
 
+Lezer:
+- `parser.js` — compiled Lezer parser
+- `parser.bundle.js` — self-contained parser bundle (includes @lezer/lr)
+- `server.bundle.cjs` — self-contained language server bundle
+
 ### `treelsp watch`
 
 Watch mode — re-runs `generate` + `build` automatically when grammar files change.
@@ -76,7 +95,7 @@ Options:
 
 ## Configuration
 
-By default, treelsp looks for `grammar.ts` in the current directory and outputs to `generated/`. For multi-language projects, create a config file to specify all languages.
+By default, treelsp looks for `grammar.ts` in the current directory and outputs to `generated/` using the Tree-sitter backend. For multi-language or multi-backend projects, create a config file.
 
 ### Config discovery order
 
@@ -91,8 +110,8 @@ When `-f` is not provided, the CLI searches from the current directory upward fo
 ```json
 {
   "languages": [
-    { "grammar": "mini-lang/grammar.ts" },
-    { "grammar": "schema-lang/grammar.ts" }
+    { "grammar": "packages/language/grammar.ts" },
+    { "grammar": "packages/language/grammar.ts", "backend": "lezer", "out": "packages/language/generated-lezer" }
   ]
 }
 ```
@@ -116,24 +135,33 @@ When `-f` is not provided, the CLI searches from the current directory upward fo
 | `languages` | array | yes | List of language projects |
 | `languages[].grammar` | string | yes | Path to `grammar.ts`, relative to the config file |
 | `languages[].out` | string | no | Output directory (default: `<grammar dir>/generated`) |
+| `languages[].backend` | string | no | Parser backend: `"tree-sitter"` (default) or `"lezer"` |
 
 ## Typical Workflow
 
-**Single language (no config needed):**
+**New project:**
 
 ```bash
-treelsp init           # scaffold project
+treelsp init           # scaffold project with language + extension packages
 cd my-lang
-npm install
-treelsp generate       # generate grammar.js, ast.ts, etc.
-treelsp build          # compile WASM + bundle server
+pnpm install
+pnpm build             # generate + compile + bundle
+# Press F5 in VS Code to launch the extension
 ```
 
-**Multi-language monorepo:**
+**Generate for both backends:**
+
+```json
+{
+  "languages": [
+    { "grammar": "packages/language/grammar.ts" },
+    { "grammar": "packages/language/grammar.ts", "backend": "lezer", "out": "packages/language/generated-lezer" }
+  ]
+}
+```
 
 ```bash
-# treelsp-config.json at repo root
-treelsp generate       # generates all languages
-treelsp build          # builds all languages
+treelsp generate       # generates for all configured backends
+treelsp build          # builds all configured backends
 treelsp watch          # watches all grammar files
 ```

package/dist/index.js

@@ -28,28 +28,48 @@ async function getCliVersion() {
 }
 async function init() {
 	console.log(pc.bold("treelsp init\n"));
-	const answers = await prompts([{
-		type: "text",
-		name: "name",
-		message: "Language name:",
-		initial: "my-lang",
-		validate: (value) => value.length > 0 || "Name is required"
-	}, {
-		type: "text",
-		name: "extension",
-		message: "File extension:",
-		initial: ".mylang",
-		validate: (value) => {
-			if (!value.startsWith(".")) return "Extension must start with a dot";
-			if (value.length < 2) return "Extension is too short";
-			return true;
+	const answers = await prompts([
+		{
+			type: "text",
+			name: "name",
+			message: "Language name:",
+			initial: "my-lang",
+			validate: (value) => value.length > 0 || "Name is required"
+		},
+		{
+			type: "text",
+			name: "extension",
+			message: "File extension:",
+			initial: ".mylang",
+			validate: (value) => {
+				if (!value.startsWith(".")) return "Extension must start with a dot";
+				if (value.length < 2) return "Extension is too short";
+				return true;
+			}
+		},
+		{
+			type: "select",
+			name: "backend",
+			message: "Parser backend:",
+			choices: [{
+				title: "Tree-sitter",
+				description: "Default — generates WASM parser, requires tree-sitter CLI",
+				value: "tree-sitter"
+			}, {
+				title: "Lezer",
+				description: "Pure JavaScript — no external CLI required",
+				value: "lezer"
+			}],
+			initial: 0
 		}
-	}]);
-	if (!answers.name || !answers.extension) {
+	]);
+	if (!answers.name || !answers.extension || !answers.backend) {
 		console.log(pc.dim("\nCancelled"));
 		process.exit(0);
 	}
-	const { name, extension } = answers;
+	const { name, extension, backend } = answers;
+	const capitalizedName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+	const languageId = name.replace(/-/g, "").toLowerCase();
 	const spinner = ora("Creating project structure...").start();
 	try {
 		const projectDir = resolve(process.cwd(), name);
@@ -58,38 +78,178 @@ async function init() {
 			console.log(pc.dim("\nChoose a different name or remove the existing directory"));
 			process.exit(1);
 		}
-		await mkdir(projectDir);
+		await mkdir(resolve(projectDir, ".vscode"), { recursive: true });
+		await mkdir(resolve(projectDir, "packages", "language"), { recursive: true });
+		await mkdir(resolve(projectDir, "packages", "extension", "src"), { recursive: true });
 		const version = await getCliVersion();
 		const versionRange = `^${version}`;
-		const packageJson = {
-			name,
-			version: "0.1.0",
-			type: "module",
-			dependencies: { treelsp: versionRange },
-			devDependencies: {
-				"@treelsp/cli": versionRange,
-				typescript: "^5.7.3"
-			},
-			scripts: {
-				generate: "treelsp generate",
-				build: "treelsp build",
-				watch: "treelsp watch"
-			}
-		};
-		await writeFile(resolve(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
-		const tsconfig = {
-			compilerOptions: {
-				target: "ES2022",
-				module: "NodeNext",
-				moduleResolution: "NodeNext",
-				strict: true,
-				outDir: "./dist"
-			},
-			include: ["grammar.ts"]
-		};
-		await writeFile(resolve(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
-		const capitalizedName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-		const grammarTemplate = `/**
+		const files = [
+			["pnpm-workspace.yaml", pnpmWorkspaceYaml()],
+			["package.json", rootPackageJson(name, versionRange)],
+			["treelsp-config.json", treelspConfigJson(backend)],
+			[".gitignore", rootGitignore()],
+			["README.md", rootReadme(capitalizedName, backend)],
+			[".vscode/launch.json", vscodeLaunchJson()],
+			[".vscode/tasks.json", vscodeTasksJson()],
+			["packages/language/package.json", languagePackageJson(name, versionRange)],
+			["packages/language/tsconfig.json", languageTsconfig()],
+			["packages/language/grammar.ts", grammarTemplate(capitalizedName, extension)],
+			["packages/extension/package.json", extensionPackageJson(name, capitalizedName, languageId, extension)],
+			["packages/extension/tsconfig.json", extensionTsconfig()],
+			["packages/extension/tsdown.config.ts", extensionTsdownConfig()],
+			["packages/extension/.vscodeignore", extensionVscodeignore()],
+			["packages/extension/src/extension.ts", extensionTs(capitalizedName, languageId)]
+		];
+		for (const [filePath, content] of files) await writeFile(resolve(projectDir, filePath), content, "utf-8");
+		spinner.succeed("Project created!");
+		console.log(pc.dim("\nNext steps:"));
+		console.log(pc.dim(`  cd ${name}`));
+		console.log(pc.dim("  pnpm install"));
+		console.log(pc.dim("  Edit packages/language/grammar.ts to define your language"));
+		console.log(pc.dim("  pnpm build"));
+		console.log(pc.dim("  Press F5 in VS Code to launch the extension"));
+	} catch (error) {
+		spinner.fail("Failed to create project");
+		if (error instanceof Error) console.error(pc.red(`\n${error.message}`));
+		process.exit(1);
+	}
+}
+function pnpmWorkspaceYaml() {
+	return `packages:\n  - 'packages/*'\n`;
+}
+function rootPackageJson(name, versionRange) {
+	const pkg = {
+		name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		scripts: {
+			generate: "treelsp generate",
+			build: "treelsp generate && treelsp build",
+			"build:extension": `pnpm --filter ${name}-extension build`,
+			watch: "treelsp watch"
+		},
+		devDependencies: {
+			"@treelsp/cli": versionRange,
+			typescript: "^5.7.3"
+		}
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function treelspConfigJson(backend) {
+	const entry = { grammar: "packages/language/grammar.ts" };
+	if (backend !== "tree-sitter") entry["backend"] = backend;
+	const config = { languages: [entry] };
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function rootGitignore() {
+	return `node_modules
+dist
+generated/
+generated-lezer/
+*.wasm
+*.log
+*.tsbuildinfo
+.DS_Store
+`;
+}
+function rootReadme(capitalizedName, backend) {
+	const generatedDir = backend === "lezer" ? "generated-lezer" : "generated";
+	return `# ${capitalizedName}
+
+A language powered by [treelsp](https://github.com/dhrubomoy/treelsp) using the ${backend} parser backend.
+
+## Getting Started
+
+Install dependencies:
+
+\`\`\`bash
+pnpm install
+\`\`\`
+
+Generate grammar and build parser:
+
+\`\`\`bash
+pnpm build
+\`\`\`
+
+Launch the VS Code extension for development:
+
+\`\`\`
+Press F5 in VS Code, or:
+pnpm build:extension
+\`\`\`
+
+Development workflow:
+
+\`\`\`bash
+pnpm watch     # Auto-rebuild grammar on changes
+\`\`\`
+
+## Project Structure
+
+- \`packages/language/grammar.ts\` - Language definition (grammar, semantics, validation, LSP)
+- \`packages/language/${generatedDir}/\` - Generated files (parser, AST types, server bundle)
+- \`packages/extension/\` - VS Code extension that launches the language server
+
+## License
+
+MIT
+`;
+}
+function vscodeLaunchJson() {
+	const config = {
+		version: "0.2.0",
+		configurations: [{
+			name: "Launch Extension",
+			type: "extensionHost",
+			request: "launch",
+			args: ["--extensionDevelopmentPath=${workspaceFolder}/packages/extension", "${workspaceFolder}/packages/language"],
+			outFiles: ["${workspaceFolder}/packages/extension/dist/**/*.js"],
+			preLaunchTask: "build"
+		}]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function vscodeTasksJson() {
+	const config = {
+		version: "2.0.0",
+		tasks: [{
+			label: "build",
+			type: "shell",
+			command: "pnpm build && pnpm build:extension",
+			group: "build",
+			problemMatcher: []
+		}]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function languagePackageJson(name, versionRange) {
+	const pkg = {
+		name: `${name}-language`,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		dependencies: { treelsp: versionRange },
+		devDependencies: { typescript: "^5.7.3" }
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function languageTsconfig() {
+	const config = {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			strict: true,
+			outDir: "./dist"
+		},
+		include: ["grammar.ts"]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function grammarTemplate(capitalizedName, extension) {
+	return `/**
  * ${capitalizedName} - Language definition for treelsp
  */
 
@@ -184,70 +344,228 @@ export default defineLanguage({
   },
 });
 `;
-		await writeFile(resolve(projectDir, "grammar.ts"), grammarTemplate, "utf-8");
-		const gitignore = `node_modules
-dist
-generated/
-*.wasm
-*.log
+}
+function extensionPackageJson(name, capitalizedName, languageId, extension) {
+	const pkg = {
+		name: `${name}-extension`,
+		displayName: capitalizedName,
+		description: `VS Code extension for ${capitalizedName}`,
+		version: "0.1.0",
+		private: true,
+		publisher: name,
+		engines: { vscode: "^1.80.0" },
+		categories: ["Programming Languages"],
+		activationEvents: ["workspaceContains:**/generated/treelsp.json", "workspaceContains:**/generated-lezer/treelsp.json"],
+		main: "./dist/extension.js",
+		contributes: { languages: [{
+			id: languageId,
+			extensions: [extension],
+			aliases: [capitalizedName]
+		}] },
+		scripts: {
+			build: "tsdown",
+			dev: "tsdown --watch",
+			package: "vsce package"
+		},
+		dependencies: { "vscode-languageclient": "^9.0.1" },
+		devDependencies: {
+			"@types/vscode": "^1.80.0",
+			tsdown: "^0.2.17",
+			typescript: "^5.7.3"
+		}
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function extensionTsconfig() {
+	const config = {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			strict: true,
+			outDir: "./dist",
+			rootDir: "./src",
+			lib: ["ES2022"]
+		},
+		include: ["src/**/*"],
+		exclude: ["node_modules", "dist"]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function extensionTsdownConfig() {
+	return `import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: ['src/extension.ts'],
+  format: ['cjs'],
+  dts: false,
+  clean: true,
+  platform: 'node',
+  external: ['vscode'],
+});
+`;
+}
+function extensionVscodeignore() {
+	return `src/
+node_modules/
+.gitignore
+tsconfig.json
+tsdown.config.ts
 *.tsbuildinfo
-.DS_Store
 `;
-		await writeFile(resolve(projectDir, ".gitignore"), gitignore, "utf-8");
-		const readme = `# ${capitalizedName}
-
-A language definition for treelsp.
-
-## Getting Started
-
-Install dependencies:
-
-\`\`\`bash
-npm install
-# or: pnpm install
-\`\`\`
-
-Generate grammar and build parser:
-
-\`\`\`bash
-npm run generate  # Generates grammar.js, ast.ts, server.ts
-npm run build     # Compiles to WASM
-\`\`\`
-
-Development workflow:
+}
+function extensionTs(capitalizedName, languageId) {
+	return `/**
+ * ${capitalizedName} - VS Code Extension
+ * Discovers and launches the treelsp-generated language server.
+ */
 
-\`\`\`bash
-npm run watch     # Auto-rebuild on changes
-\`\`\`
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind,
+  State,
+} from 'vscode-languageclient/node';
+
+interface TreelspManifest {
+  name: string;
+  languageId: string;
+  fileExtensions: string[];
+  server: string;
+  textmateGrammar?: string;
+}
 
-## Project Structure
+const clients = new Map<string, LanguageClient>();
+
+export async function activate(context: vscode.ExtensionContext) {
+  const manifests = await discoverManifests();
+
+  for (const { manifest, manifestPath } of manifests) {
+    await startLanguageClient(manifest, manifestPath, context);
+  }
+
+  // Watch for new or updated manifests
+  for (const pattern of ['**/generated/treelsp.json', '**/generated-lezer/treelsp.json']) {
+    const watcher = vscode.workspace.createFileSystemWatcher(pattern);
+    watcher.onDidCreate(async (uri) => {
+      const data = await readManifest(uri.fsPath);
+      if (data) await startLanguageClient(data, uri.fsPath, context);
+    });
+    watcher.onDidChange(async (uri) => {
+      await stopClient(uri.fsPath);
+      const data = await readManifest(uri.fsPath);
+      if (data) await startLanguageClient(data, uri.fsPath, context);
+    });
+    watcher.onDidDelete(async (uri) => {
+      await stopClient(uri.fsPath);
+    });
+    context.subscriptions.push(watcher);
+  }
+}
 
-- \`grammar.ts\` - Language definition (grammar, semantic, validation, LSP)
-- \`generated/\` - Generated files (grammar.js, WASM, types)
-- \`package.json\` - Project dependencies
+export async function deactivate(): Promise<void> {
+  const stops = [...clients.values()].map(c => c.stop());
+  await Promise.all(stops);
+  clients.clear();
+}
 
-## Documentation
+async function discoverManifests(): Promise<Array<{ manifest: TreelspManifest; manifestPath: string }>> {
+  const results: Array<{ manifest: TreelspManifest; manifestPath: string }> = [];
+  for (const pattern of ['**/generated/treelsp.json', '**/generated-lezer/treelsp.json']) {
+    const uris = await vscode.workspace.findFiles(pattern, '**/node_modules/**');
+    for (const uri of uris) {
+      const data = await readManifest(uri.fsPath);
+      if (data) results.push({ manifest: data, manifestPath: uri.fsPath });
+    }
+  }
+  return results;
+}
 
-- [treelsp Documentation](https://github.com/yourusername/treelsp)
-- [Tree-sitter](https://tree-sitter.github.io/tree-sitter/)
+async function readManifest(fsPath: string): Promise<TreelspManifest | null> {
+  try {
+    const doc = await vscode.workspace.openTextDocument(fsPath);
+    const data = JSON.parse(doc.getText()) as TreelspManifest;
+    if (!data.name || !data.languageId || !data.fileExtensions || !data.server) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
 
-## License
+async function startLanguageClient(
+  manifest: TreelspManifest,
+  manifestPath: string,
+  context: vscode.ExtensionContext,
+): Promise<void> {
+  if (clients.has(manifestPath)) return;
+
+  const generatedDir = path.dirname(manifestPath);
+  const serverModule = path.resolve(generatedDir, manifest.server);
+
+  if (!fs.existsSync(serverModule)) {
+    void vscode.window.showErrorMessage(
+      '${capitalizedName}: Server bundle not found. Run "pnpm build" first.',
+    );
+    return;
+  }
+
+  const serverOptions: ServerOptions = {
+    run: { module: serverModule, transport: TransportKind.stdio },
+    debug: {
+      module: serverModule,
+      transport: TransportKind.stdio,
+      options: { execArgv: ['--nolazy', '--inspect=6009'] },
+    },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: manifest.fileExtensions.map(ext => ({
+      scheme: 'file' as const,
+      language: manifest.languageId,
+      pattern: \`**/*\${ext}\`,
+    })),
+    outputChannelName: '${capitalizedName} Language Server',
+  };
+
+  const client = new LanguageClient(
+    '${languageId}',
+    '${capitalizedName} Language Server',
+    serverOptions,
+    clientOptions,
+  );
+
+  client.onDidChangeState((event) => {
+    if (event.oldState === State.Running && event.newState === State.Stopped) {
+      void vscode.window.showWarningMessage(
+        '${capitalizedName}: Language server stopped unexpectedly.',
+      );
+    }
+  });
+
+  clients.set(manifestPath, client);
+  context.subscriptions.push(client);
+
+  try {
+    await client.start();
+  } catch (e) {
+    clients.delete(manifestPath);
+    void vscode.window.showErrorMessage(
+      \`${capitalizedName}: Failed to start language server: \${e instanceof Error ? e.message : String(e)}\`,
+    );
+  }
+}
 
-MIT
+async function stopClient(key: string): Promise<void> {
+  const client = clients.get(key);
+  if (!client) return;
+  await client.stop();
+  clients.delete(key);
+}
 `;
-		await writeFile(resolve(projectDir, "README.md"), readme, "utf-8");
-		spinner.succeed("Project created!");
-		console.log(pc.dim("\nNext steps:"));
-		console.log(pc.dim(`  cd ${name}`));
-		console.log(pc.dim("  npm install"));
-		console.log(pc.dim("  Edit grammar.ts to define your language"));
-		console.log(pc.dim("  npm run generate"));
-		console.log(pc.dim("  npm run build"));
-	} catch (error) {
-		spinner.fail("Failed to create project");
-		if (error instanceof Error) console.error(pc.red(`\n${error.message}`));
-		process.exit(1);
-	}
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treelsp/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "publishConfig": {
     "access": "public"
   },
@@ -41,7 +41,7 @@
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
     "tree-sitter-cli": "^0.26.5",
-    "treelsp": "0.0.2"
+    "treelsp": "0.0.4"
   },
   "devDependencies": {
     "@types/prompts": "^2.4.9",