Prettier

Parses source code into an abstract syntax tree (AST) and re-prints it according to fixed formatting rules, ensuring consistent style across JavaScript, TypeScript, CSS, HTML, JSON, Markdown, and GraphQL. Unlike regex-based formatters, this approach preserves code semantics while enforcing maximum line length constraints, indentation, spacing, and bracket placement through a unified rule engine that applies identically across all supported languages.

Integrates into VS Code's native formatter API as the designated `editor.defaultFormatter` for specified languages, enabling automatic code formatting on file save when `editor.formatOnSave` is enabled. The extension hooks into VS Code's document save lifecycle, intercepts the save event, invokes Prettier's formatting engine on the file content, and writes the formatted result back to the editor buffer without requiring 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.

Implements a three-tier version resolution strategy that prioritizes local project installations of Prettier (in `node_modules/prettier`), falls back to globally installed modules if `prettier.resolveGlobalModules` is enabled, and finally uses a bundled Prettier 3.x as a last-resort fallback. This approach ensures projects can pin specific Prettier versions in `package.json` while allowing developers to use global installations for consistency across projects, with transparent version detection and reporting.

Automatically discovers and applies Prettier configuration from project-level files (`.prettierrc`, `.prettierrc.json`, `.prettierrc.yaml`, `prettier.config.js`, or `package.json` with `prettier` key) without requiring manual configuration in VS Code settings. The extension uses Prettier's native configuration resolution algorithm, which searches from the current file's directory up the directory tree until a configuration file is found, enabling per-project formatting rules that apply consistently across all team members.

Respects `.prettierignore` files in the project root, which use gitignore-style glob patterns to exclude files from formatting. When a file matches an ignore pattern, the extension skips formatting for that file even if format-on-save is enabled, allowing developers to exclude generated code, vendor files, or other non-source files from Prettier's formatting pipeline without modifying VS Code settings.

Allows designation of Prettier as the default formatter for specific languages via VS Code's `[language].editor.defaultFormatter` setting, enabling selective use of Prettier for some languages while using alternative formatters for others. This prevents formatter conflicts by explicitly routing each language to its designated formatter, with clear precedence rules when multiple formatters target the same language.

Implements a security mechanism that prompts users to confirm loading of Prettier modules from untrusted sources, preventing malicious code execution from compromised or untrusted Prettier installations. When loading a Prettier module (especially from global or project-specific locations), the extension displays a trust prompt: 'You will be prompted to confirm that you want the extension to load a Prettier module', allowing users to audit the module source before execution.

Applies a unified set of formatting rules (line length, indentation, quotes, semicolons, trailing commas, bracket placement, etc.) consistently across JavaScript, TypeScript, CSS, HTML, JSON, Markdown, GraphQL, and YAML, using language-specific parsers to understand syntax while enforcing identical style principles. This approach ensures that projects with multiple languages maintain consistent formatting philosophy without requiring separate configuration per language.

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.