Prettier

Parses source code into an Abstract Syntax Tree (AST) and re-prints it with deterministic, opinionated formatting rules (spacing, indentation, quote style, semicolons, line wrapping). Unlike regex-based formatters, AST parsing ensures structural correctness and handles complex nested syntax accurately across 15+ languages. The formatter applies consistent rules without requiring manual configuration of individual style preferences.

Integrates into VS Code's save workflow to automatically trigger code formatting when a file is saved. Configuration is language-specific via VS Code settings (e.g., `[javascript]`, `[typescript]`), allowing different formatters or settings per file type. The extension registers itself as the default formatter and respects VS Code's `editor.formatOnSave` and `editor.defaultFormatter` settings, enabling seamless workflow integration without manual command invocation.

Automatically inserts or removes semicolons at statement ends based on a configurable setting (`semi` option, default: true). The formatter uses AST analysis to determine where semicolons are syntactically required or optional, avoiding incorrect removal in edge cases (e.g., statements starting with `[` or `(`). Language-specific rules apply (e.g., CSS and JSON have different semicolon conventions than JavaScript).

Normalizes indentation across code by enforcing a consistent tab width (default: 2 spaces, configurable via `tabWidth` setting) and indentation style (spaces or tabs, configurable via `useTabs` setting). The formatter re-indents all nested code blocks, function arguments, and multi-line expressions to match the configured style, eliminating mixed indentation and inconsistent nesting levels.

Automatically inserts or removes trailing commas in multi-line arrays, objects, function parameters, and imports based on a configurable setting (`trailingComma` option with values: `none`, `es5`, `all`). The formatter uses AST analysis to identify multi-line structures and applies language-specific rules (e.g., trailing commas are valid in modern JavaScript but not in older versions). This reduces diff noise in version control and prevents syntax errors when adding new items.

Automatically normalizes spacing around brackets and braces in object literals, imports, and destructuring assignments based on configurable settings (`bracketSpacing` for `{ }` spacing, `bracketSameLine` for closing bracket placement). The formatter ensures consistent spacing (e.g., `{ foo: 'bar' }` vs `{foo: 'bar'}`) and places closing brackets on the same line or new line based on configuration. This eliminates spacing inconsistencies in object-heavy code.

Supports 15+ programming and markup languages (JavaScript, TypeScript, JSX, JSON, CSS, SCSS, Less, HTML, Vue, Angular, Handlebars, GraphQL, Markdown, YAML) through language-specific AST parsers bundled with Prettier. Each language has dedicated parsing logic and formatting rules, allowing a single tool to enforce consistent style across polyglot projects. The extension automatically detects file type via VS Code language identifiers and routes to the appropriate parser.

Implements a three-tier version resolution strategy: (1) checks for Prettier in the project's local `node_modules` (highest priority), (2) optionally resolves global Prettier installation if `prettier.resolveGlobalModules` is enabled, (3) falls back to bundled Prettier 3.x if neither local nor global version is found. This allows projects to pin exact Prettier versions in `package.json` for reproducibility while maintaining a fallback for quick setup. The extension respects semantic versioning and uses the resolved version's formatting rules.

Reads `.prettierignore` files in the project root to exclude files and directories from formatting. Uses glob pattern matching (e.g., `node_modules/`, `dist/`, `*.min.js`) to specify exclusion rules, preventing formatting of generated code, dependencies, and other non-source files. The extension respects `.prettierignore` during both automatic format-on-save and manual formatting operations, ensuring excluded files are never reformatted.

Integrates deeply with VS Code's settings system to register Prettier as the default formatter via `editor.defaultFormatter` and `editor.formatOnSave` settings. Supports language-specific configuration using VS Code's `[language]` syntax (e.g., `[javascript]`, `[typescript]`, `[css]`), allowing different formatters or settings per file type within the same workspace. The extension reads these settings at runtime and applies them without requiring project-level configuration files.

Implements a security model where the extension prompts users for confirmation before loading Prettier modules from the project's `node_modules` directory. This prevents automatic execution of potentially malicious code in dependencies while maintaining the convenience of local version resolution. The prompt appears once per project and can be dismissed to allow future loads without confirmation.

Produces byte-for-byte identical formatting output across different machines, operating systems, and CI/CD environments when using the same Prettier version. This is achieved through deterministic AST parsing and rule application with no randomization or environment-specific behavior. Combined with version pinning via `package.json`, this enables reproducible builds where formatting is guaranteed to be consistent in local development, pull request checks, and production deployments.

Enforces a configurable maximum line length (default 80 characters, customizable via `printWidth` setting) by intelligently wrapping code at appropriate break points. The formatter analyzes the AST to identify optimal wrapping locations (e.g., after commas, operators, or function arguments) rather than naively breaking at character boundaries. This produces readable, properly-indented wrapped code that respects language syntax rules.

Normalizes quote styles across code by converting all string literals to a consistent quote type (single or double quotes, configurable via `singleQuote` setting). The formatter respects language conventions (e.g., HTML attributes use double quotes by default) and intelligently handles edge cases like strings containing quotes (e.g., `"don't"` vs `'don\'t'`). This eliminates quote style inconsistencies without requiring manual editing.