From 4c92db20b91f139796451adb3f6d1511b1f2c0a2 Mon Sep 17 00:00:00 2001
From: Emanuele Stoppa <my.burning@gmail.com>
Date: Fri, 1 Mar 2024 11:12:15 +0000
Subject: [PATCH] fix(format): correctly apply trailing comma to formatting
 (#1944)

---
 CHANGELOG.md                                  |  17 +-
 Cargo.lock                                    |   4 +
 crates/biome_cli/src/execute/migrate.rs       |   8 +-
 .../execute/process_file/workspace_file.rs    |   5 +-
 crates/biome_cli/src/execute/std_in.rs        |   9 +-
 crates/biome_cli/tests/commands/format.rs     |  69 ++--
 .../applies_custom_bracket_same_line.snap     |   4 +-
 .../applies_custom_jsx_quote_style.snap       |   4 +-
 ...ormat_json_when_allow_trailing_commas.snap |  11 +-
 ...json_when_allow_trailing_commas_write.snap |  34 ++
 crates/biome_css_syntax/Cargo.toml            |   5 +
 crates/biome_css_syntax/src/file_source.rs    |  10 +-
 crates/biome_js_parser/Cargo.toml             |   2 +-
 crates/biome_js_syntax/Cargo.toml             |   7 +-
 crates/biome_js_syntax/src/file_source.rs     |  88 ++++-
 crates/biome_js_syntax/src/syntax_node.rs     |   4 +-
 crates/biome_json_formatter/src/context.rs    |   8 +-
 .../src/json/lists/array_element_list.rs      |  11 +-
 .../src/json/lists/member_list.rs             |   7 +-
 crates/biome_json_formatter/src/separated.rs  |  13 +-
 crates/biome_json_syntax/Cargo.toml           |   5 +
 crates/biome_json_syntax/src/file_source.rs   |  26 +-
 .../biome_lsp/src/handlers/text_document.rs   |   6 +-
 crates/biome_service/Cargo.toml               |   4 +-
 crates/biome_service/src/diagnostics.rs       |  21 +-
 .../biome_service/src/file_handlers/astro.rs  |  24 +-
 crates/biome_service/src/file_handlers/css.rs |  37 +-
 .../src/file_handlers/javascript.rs           | 132 +++----
 .../biome_service/src/file_handlers/json.rs   |  62 +--
 crates/biome_service/src/file_handlers/mod.rs | 360 ++++++++++--------
 .../biome_service/src/file_handlers/svelte.rs |  26 +-
 .../src/file_handlers/unknown.rs              |   4 -
 crates/biome_service/src/file_handlers/vue.rs |  25 +-
 crates/biome_service/src/settings.rs          |   9 +-
 crates/biome_service/src/workspace.rs         |  12 +-
 crates/biome_service/src/workspace/server.rs  |  87 +++--
 crates/biome_service/tests/workspace.rs       |   7 +-
 .../@biomejs/backend-jsonrpc/src/workspace.ts |  57 ++-
 packages/@biomejs/js-api/tsconfig.json        |   4 +-
 .../src/content/docs/internals/changelog.md   |  17 +-
 website/tsconfig.json                         |   6 +-
 41 files changed, 785 insertions(+), 466 deletions(-)
 create mode 100644 crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas_write.snap

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d88431fc58c..aca9d05ddd57 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -33,10 +33,10 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
   ```diff
   <script setup lang="ts">
-     - import Button from "./components/Button.vue";
-     - import * as vueUse from "vue-use";
-     + import * as vueUse from "vue-use";
-     + import Button from "./components/Button.vue";
+  - import Button from "./components/Button.vue";
+  - import * as vueUse from "vue-use";
+  + import * as vueUse from "vue-use";
+  + import Button from "./components/Button.vue";
   </script/>
 
   <template></template>
@@ -47,10 +47,10 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
   ```diff
   <script setup lang="ts">
-    - import Button from "./components/Button.svelte";
-    - import * as svelteUse from "svelte-use";
-    + import * as svelteUse from "svelte-use";
-    + import Button from "./components/Button.svelte";
+  - import Button from "./components/Button.svelte";
+  - import * as svelteUse from "svelte-use";
+  + import * as svelteUse from "svelte-use";
+  + import Button from "./components/Button.svelte";
   </script/>
 
   <div></div>
@@ -296,6 +296,7 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
 - Fix [#1218](https://github.com/biomejs/biome/issues/1218), by correctly preserving empty lines in member chains.
   Contributed by @ah-yu
+- Fix [#1659](https://github.com/biomejs/biome/issues/1659) and [#1662](https://github.com/biomejs/biome/issues/1662), by correctly taking into account the leading comma inside the formatter options. Contributed by @ematipico
 
 ### JavaScript APIs
 
diff --git a/Cargo.lock b/Cargo.lock
index 1634fbc2877c..476177059d63 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -301,6 +301,8 @@ name = "biome_css_syntax"
 version = "0.4.0"
 dependencies = [
  "biome_rowan",
+ "schemars",
+ "serde",
 ]
 
 [[package]]
@@ -675,6 +677,8 @@ name = "biome_json_syntax"
 version = "0.4.0"
 dependencies = [
  "biome_rowan",
+ "schemars",
+ "serde",
 ]
 
 [[package]]
diff --git a/crates/biome_cli/src/execute/migrate.rs b/crates/biome_cli/src/execute/migrate.rs
index 2771ed6e0230..d1d96fa1b3e6 100644
--- a/crates/biome_cli/src/execute/migrate.rs
+++ b/crates/biome_cli/src/execute/migrate.rs
@@ -11,12 +11,10 @@ use biome_diagnostics::Diagnostic;
 use biome_diagnostics::{category, PrintDiagnostic};
 use biome_fs::{BiomePath, ConfigName, FileSystemExt, OpenOptions};
 use biome_json_parser::{parse_json_with_cache, JsonParserOptions};
-use biome_json_syntax::JsonRoot;
+use biome_json_syntax::{JsonFileSource, JsonRoot};
 use biome_migrate::{migrate_configuration, ControlFlow};
 use biome_rowan::{AstNode, NodeCache};
-use biome_service::workspace::{
-    ChangeFileParams, FixAction, FormatFileParams, Language, OpenFileParams,
-};
+use biome_service::workspace::{ChangeFileParams, FixAction, FormatFileParams, OpenFileParams};
 use biome_service::{PartialConfiguration, VERSION};
 use std::borrow::Cow;
 use std::ffi::OsStr;
@@ -65,7 +63,7 @@ pub(crate) fn run(migrate_payload: MigratePayload) -> Result<(), CliDiagnostic>
         path: biome_path.clone(),
         content: configuration_content.to_string(),
         version: 0,
-        language_hint: Language::Json,
+        document_file_source: JsonFileSource::json().into(),
     })?;
 
     let parsed = parse_json_with_cache(
diff --git a/crates/biome_cli/src/execute/process_file/workspace_file.rs b/crates/biome_cli/src/execute/process_file/workspace_file.rs
index 5b693c9b800d..29738d285d1b 100644
--- a/crates/biome_cli/src/execute/process_file/workspace_file.rs
+++ b/crates/biome_cli/src/execute/process_file/workspace_file.rs
@@ -2,8 +2,7 @@ use crate::execute::diagnostics::{ResultExt, ResultIoExt};
 use crate::execute::process_file::SharedTraversalOptions;
 use biome_diagnostics::{category, Error};
 use biome_fs::{BiomePath, File, OpenOptions};
-use biome_service::file_handlers::Language;
-use biome_service::workspace::{FileGuard, OpenFileParams};
+use biome_service::workspace::{DocumentFileSource, FileGuard, OpenFileParams};
 use biome_service::{Workspace, WorkspaceError};
 use std::path::{Path, PathBuf};
 
@@ -37,7 +36,7 @@ impl<'ctx, 'app> WorkspaceFile<'ctx, 'app> {
         let guard = FileGuard::open(
             ctx.workspace,
             OpenFileParams {
-                language_hint: Language::from_path(&biome_path),
+                document_file_source: DocumentFileSource::from_path(&biome_path),
                 path: biome_path,
                 version: 0,
                 content: input.clone(),
diff --git a/crates/biome_cli/src/execute/std_in.rs b/crates/biome_cli/src/execute/std_in.rs
index 9335a5603593..9456364e6834 100644
--- a/crates/biome_cli/src/execute/std_in.rs
+++ b/crates/biome_cli/src/execute/std_in.rs
@@ -8,8 +8,9 @@ use biome_diagnostics::Diagnostic;
 use biome_diagnostics::PrintDiagnostic;
 use biome_fs::BiomePath;
 use biome_service::workspace::{
-    ChangeFileParams, FeaturesBuilder, FixFileParams, FormatFileParams, Language, OpenFileParams,
-    OrganizeImportsParams, PullDiagnosticsParams, RuleCategories, SupportsFeatureParams,
+    ChangeFileParams, DocumentFileSource, FeaturesBuilder, FixFileParams, FormatFileParams,
+    OpenFileParams, OrganizeImportsParams, PullDiagnosticsParams, RuleCategories,
+    SupportsFeatureParams,
 };
 use biome_service::WorkspaceError;
 use std::borrow::Cow;
@@ -48,7 +49,7 @@ pub(crate) fn run<'a>(
                 path: biome_path.clone(),
                 version: 0,
                 content: content.into(),
-                language_hint: Language::default(),
+                document_file_source: DocumentFileSource::default(),
             })?;
             let printed = workspace.format_file(FormatFileParams { path: biome_path })?;
 
@@ -71,7 +72,7 @@ pub(crate) fn run<'a>(
             path: biome_path.clone(),
             version: 0,
             content: content.into(),
-            language_hint: Language::default(),
+            document_file_source: DocumentFileSource::default(),
         })?;
         // apply fix file of the linter
         let file_features = workspace.file_features(SupportsFeatureParams {
diff --git a/crates/biome_cli/tests/commands/format.rs b/crates/biome_cli/tests/commands/format.rs
index df06c641058b..c669e89741b2 100644
--- a/crates/biome_cli/tests/commands/format.rs
+++ b/crates/biome_cli/tests/commands/format.rs
@@ -606,7 +606,7 @@ fn applies_custom_jsx_quote_style() {
     let mut fs = MemoryFileSystem::default();
     let mut console = BufferConsole::default();
 
-    let file_path = Path::new("file.js");
+    let file_path = Path::new("file.jsx");
     fs.insert(file_path.into(), APPLY_JSX_QUOTE_STYLE_BEFORE.as_bytes());
 
     let result = run_cli(
@@ -850,17 +850,8 @@ fn applies_custom_bracket_spacing() {
 
     assert!(result.is_ok(), "run_cli returned {result:?}");
 
-    let mut file = fs
-        .open(file_path)
-        .expect("formatting target file was removed by the CLI");
-
-    let mut content = String::new();
-    file.read_to_string(&mut content)
-        .expect("failed to read file from memory FS");
-
-    assert_eq!(content, APPLY_BRACKET_SPACING_AFTER);
+    assert_file_contents(&fs, file_path, APPLY_BRACKET_SPACING_AFTER);
 
-    drop(file);
     assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "applies_custom_bracket_spacing",
@@ -875,7 +866,7 @@ fn applies_custom_bracket_same_line() {
     let mut fs = MemoryFileSystem::default();
     let mut console = BufferConsole::default();
 
-    let file_path = Path::new("file.js");
+    let file_path = Path::new("file.jsx");
     fs.insert(file_path.into(), APPLY_BRACKET_SAME_LINE_BEFORE.as_bytes());
 
     let result = run_cli(
@@ -895,17 +886,8 @@ fn applies_custom_bracket_same_line() {
 
     assert!(result.is_ok(), "run_cli returned {result:?}");
 
-    let mut file = fs
-        .open(file_path)
-        .expect("formatting target file was removed by the CLI");
+    assert_file_contents(&fs, file_path, APPLY_BRACKET_SAME_LINE_AFTER);
 
-    let mut content = String::new();
-    file.read_to_string(&mut content)
-        .expect("failed to read file from memory FS");
-
-    assert_eq!(content, APPLY_BRACKET_SAME_LINE_AFTER);
-
-    drop(file);
     assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "applies_custom_bracket_same_line",
@@ -2251,6 +2233,49 @@ fn format_json_when_allow_trailing_commas() {
     ));
 }
 
+#[test]
+fn format_json_when_allow_trailing_commas_write() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let config_json = r#"{
+    "json": {
+        "parser": { "allowTrailingCommas": true }
+    }
+}"#;
+    let biome_config = "biome.json";
+    let code = r#"{   "loreum_ipsum_lorem_ipsum":   "bar", "loreum_ipsum_lorem_ipsum":   "bar", "loreum_ipsum_lorem_ipsum":   "bar", "loreum_ipsum_lorem_ipsum":   "bar", "loreum_ipsum_lorem_ipsum":   "bar",
+}"#;
+    let file_path = Path::new("file.json");
+    fs.insert(file_path.into(), code.as_bytes());
+    fs.insert(biome_config.into(), config_json);
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                "--write",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_file_contents(&fs, Path::new(file_path), "{\n\t\"loreum_ipsum_lorem_ipsum\": \"bar\",\n\t\"loreum_ipsum_lorem_ipsum\": \"bar\",\n\t\"loreum_ipsum_lorem_ipsum\": \"bar\",\n\t\"loreum_ipsum_lorem_ipsum\": \"bar\",\n\t\"loreum_ipsum_lorem_ipsum\": \"bar\",\n}\n");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "format_json_when_allow_trailing_commas_write",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn treat_known_json_files_as_jsonc_files() {
     let mut fs = MemoryFileSystem::default();
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_bracket_same_line.snap b/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_bracket_same_line.snap
index 05046160ebd2..d62f284c4c63 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_bracket_same_line.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_bracket_same_line.snap
@@ -2,9 +2,9 @@
 source: crates/biome_cli/tests/snap_test.rs
 expression: content
 ---
-## `file.js`
+## `file.jsx`
 
-```js
+```jsx
 <Foo
 	className={style}
 	reallyLongAttributeName1={longComplexValue}
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_jsx_quote_style.snap b/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_jsx_quote_style.snap
index 2519a207d7fa..ccb61f7b9ed8 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_jsx_quote_style.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/applies_custom_jsx_quote_style.snap
@@ -2,9 +2,9 @@
 source: crates/biome_cli/tests/snap_test.rs
 expression: content
 ---
-## `file.js`
+## `file.jsx`
 
-```js
+```jsx
 <div bar='foo' baz={"foo"} />;
 
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas.snap b/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas.snap
index de7222eb4d96..5b1c3d1f59b1 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas.snap
@@ -40,11 +40,14 @@ file.json format ━━━━━━━━━━━━━━━━━━━━━
 
   i Formatter would have printed the following content:
   
-    3 3 │           1,
-    4 4 │       ],
+    1 1 │   {
+    2   │ - ····"array":·[
+    3   │ - ········1,
+    4   │ - ····],
     5   │ - }
-      5 │ + }
-      6 │ + 
+      2 │ + → "array":·[1],
+      3 │ + }
+      4 │ + 
   
 
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas_write.snap b/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas_write.snap
new file mode 100644
index 000000000000..c266c6725bc3
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/format_json_when_allow_trailing_commas_write.snap
@@ -0,0 +1,34 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{
+  "json": {
+    "parser": { "allowTrailingCommas": true }
+  }
+}
+```
+
+## `file.json`
+
+```json
+{
+	"loreum_ipsum_lorem_ipsum": "bar",
+	"loreum_ipsum_lorem_ipsum": "bar",
+	"loreum_ipsum_lorem_ipsum": "bar",
+	"loreum_ipsum_lorem_ipsum": "bar",
+	"loreum_ipsum_lorem_ipsum": "bar",
+}
+
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file in <TIME>. Fixed 1 file.
+```
+
+
diff --git a/crates/biome_css_syntax/Cargo.toml b/crates/biome_css_syntax/Cargo.toml
index 55450817ed88..32bbc86641b9 100644
--- a/crates/biome_css_syntax/Cargo.toml
+++ b/crates/biome_css_syntax/Cargo.toml
@@ -14,6 +14,11 @@ version              = "0.4.0"
 
 [dependencies]
 biome_rowan = { workspace = true }
+schemars    = { workspace = true, optional = true }
+serde       = { workspace = true, features = ["derive"] }
+
+[features]
+schema = ["schemars", "biome_rowan/serde"]
 
 [lints]
 workspace = true
diff --git a/crates/biome_css_syntax/src/file_source.rs b/crates/biome_css_syntax/src/file_source.rs
index 8860c0ffd98f..c07d0415d26a 100644
--- a/crates/biome_css_syntax/src/file_source.rs
+++ b/crates/biome_css_syntax/src/file_source.rs
@@ -1,7 +1,10 @@
 use biome_rowan::FileSourceError;
 use std::path::Path;
 
-#[derive(Debug, Default, Clone, Copy)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub struct CssFileSource {
     // Unused until we potentially support postcss/less/sass
     #[allow(unused)]
@@ -12,7 +15,10 @@ pub struct CssFileSource {
 ///
 /// Currently, Biome only supports plain CSS, and aims to be compatible with
 /// the latest Recommendation level standards.
-#[derive(Debug, Default, Clone, Copy)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 enum CssVariant {
     #[default]
     Standard,
diff --git a/crates/biome_js_parser/Cargo.toml b/crates/biome_js_parser/Cargo.toml
index 6a5f1ab82049..03fcfcf78a9b 100644
--- a/crates/biome_js_parser/Cargo.toml
+++ b/crates/biome_js_parser/Cargo.toml
@@ -38,7 +38,7 @@ tests_macros      = { workspace = true }
 
 [features]
 schemars = ["dep:schemars"]
-serde    = ["biome_js_syntax/serde"]
+serde    = ["biome_js_syntax/schema"]
 tests    = []
 
 # cargo-workspaces metadata
diff --git a/crates/biome_js_syntax/Cargo.toml b/crates/biome_js_syntax/Cargo.toml
index 0ff2997a81fd..2cf04c8d8516 100644
--- a/crates/biome_js_syntax/Cargo.toml
+++ b/crates/biome_js_syntax/Cargo.toml
@@ -14,15 +14,16 @@ version              = "0.4.0"
 biome_console     = { workspace = true }
 biome_diagnostics = { workspace = true }
 biome_rowan       = { workspace = true }
-schemars          = { version = "0.8.10", optional = true }
-serde             = { version = "1.0.136", features = ["derive"], optional = true }
+schemars          = { workspace = true, optional = true }
+serde             = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]
 biome_js_factory = { path = "../biome_js_factory" }
 biome_js_parser  = { path = "../biome_js_parser" }
 
 [features]
-serde = ["dep:serde", "schemars", "biome_rowan/serde"]
+schema = ["schemars", "biome_rowan/serde"]
+serde  = ["biome_rowan/serde"]
 
 [lints]
 workspace = true
diff --git a/crates/biome_js_syntax/src/file_source.rs b/crates/biome_js_syntax/src/file_source.rs
index dabbf418cd26..18f83b6df0bd 100644
--- a/crates/biome_js_syntax/src/file_source.rs
+++ b/crates/biome_js_syntax/src/file_source.rs
@@ -5,7 +5,8 @@ use std::path::Path;
 /// The versions are ordered in increasing order; The newest version comes last.
 ///
 /// Defaults to the latest stable ECMAScript standard.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 pub enum LanguageVersion {
     ES2022,
 
@@ -28,7 +29,10 @@ impl Default for LanguageVersion {
 
 /// Is the source file an ECMAScript Module or Script.
 /// Changes the parsing semantic.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema,))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub enum ModuleKind {
     /// An ECMAScript [Script](https://tc39.es/ecma262/multipage/ecmascript-language-scripts-and-modules.html#sec-scripts)
     Script,
@@ -47,7 +51,10 @@ impl ModuleKind {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Copy, Clone, Eq, PartialEq, Hash, Default, serde::Serialize, serde::Deserialize,
+)]
 pub enum LanguageVariant {
     /// Standard JavaScript or TypeScript syntax without any extensions
     #[default]
@@ -72,7 +79,10 @@ impl LanguageVariant {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Copy, Clone, Eq, PartialEq, Default, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub enum Language {
     #[default]
     JavaScript,
@@ -99,13 +109,41 @@ impl Language {
         )
     }
 }
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
+pub enum EmbeddingKind {
+    Astro,
+    Vue,
+    Svelte,
+    #[default]
+    None,
+}
 
-#[derive(Clone, Copy, Debug, Default)]
+impl EmbeddingKind {
+    pub const fn is_astro(&self) -> bool {
+        matches!(self, EmbeddingKind::Astro)
+    }
+    pub const fn is_vue(&self) -> bool {
+        matches!(self, EmbeddingKind::Vue)
+    }
+    pub const fn is_svelte(&self) -> bool {
+        matches!(self, EmbeddingKind::Svelte)
+    }
+}
+
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub struct JsFileSource {
     language: Language,
     variant: LanguageVariant,
     module_kind: ModuleKind,
     version: LanguageVersion,
+    /// Used to mark if the source is being used for an Astro, Svelte or Vue file
+    embedding_kind: EmbeddingKind,
 }
 
 impl JsFileSource {
@@ -155,6 +193,21 @@ impl JsFileSource {
         }
     }
 
+    /// Astro file definition
+    pub fn astro() -> Self {
+        Self::ts().with_embedding_kind(EmbeddingKind::Astro)
+    }
+
+    /// Vue file definition
+    pub fn vue() -> Self {
+        Self::js_module().with_embedding_kind(EmbeddingKind::Vue)
+    }
+
+    /// Svelte file definition
+    pub fn svelte() -> Self {
+        Self::js_module().with_embedding_kind(EmbeddingKind::Svelte)
+    }
+
     pub const fn with_module_kind(mut self, kind: ModuleKind) -> Self {
         self.module_kind = kind;
         self
@@ -170,15 +223,20 @@ impl JsFileSource {
         self
     }
 
-    pub fn language(&self) -> Language {
+    pub const fn with_embedding_kind(mut self, kind: EmbeddingKind) -> Self {
+        self.embedding_kind = kind;
+        self
+    }
+
+    pub const fn language(&self) -> Language {
         self.language
     }
 
-    pub fn variant(&self) -> LanguageVariant {
+    pub const fn variant(&self) -> LanguageVariant {
         self.variant
     }
 
-    pub fn version(&self) -> LanguageVersion {
+    pub const fn version(&self) -> LanguageVersion {
         self.version
     }
 
@@ -194,6 +252,14 @@ impl JsFileSource {
         self.language.is_typescript()
     }
 
+    pub const fn is_jsx(&self) -> bool {
+        self.variant.is_jsx()
+    }
+
+    pub const fn as_embedding_kind(&self) -> &EmbeddingKind {
+        &self.embedding_kind
+    }
+
     pub fn file_extension(&self) -> &str {
         match self.language {
             Language::JavaScript => {
@@ -254,9 +320,9 @@ fn compute_source_type_from_path_or_extension(
             "mts" | "cts" => JsFileSource::ts_restricted(),
             "tsx" => JsFileSource::tsx(),
             // TODO: Remove once we have full support of astro files
-            "astro" => JsFileSource::ts(),
-            "vue" => JsFileSource::ts(),
-            "svelte" => JsFileSource::ts(),
+            "astro" => JsFileSource::astro(),
+            "vue" => JsFileSource::vue(),
+            "svelte" => JsFileSource::svelte(),
             _ => {
                 return Err(FileSourceError::UnknownExtension(
                     file_name.into(),
diff --git a/crates/biome_js_syntax/src/syntax_node.rs b/crates/biome_js_syntax/src/syntax_node.rs
index 70e476bdedbb..b14609ab4639 100644
--- a/crates/biome_js_syntax/src/syntax_node.rs
+++ b/crates/biome_js_syntax/src/syntax_node.rs
@@ -7,11 +7,11 @@
 
 use crate::{AnyJsRoot, JsSyntaxKind};
 use biome_rowan::Language;
-#[cfg(feature = "serde")]
+#[cfg(feature = "schema")]
 use serde::Serialize;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", derive(Serialize, schemars::JsonSchema))]
 pub struct JsLanguage;
 
 impl Language for JsLanguage {
diff --git a/crates/biome_json_formatter/src/context.rs b/crates/biome_json_formatter/src/context.rs
index 8a8e00aa45ef..f80bbdbebaf9 100644
--- a/crates/biome_json_formatter/src/context.rs
+++ b/crates/biome_json_formatter/src/context.rs
@@ -62,13 +62,13 @@ pub struct JsonFormatOptions {
     line_ending: LineEnding,
     line_width: LineWidth,
     attribute_position: AttributePosition,
-    _file_source: JsonFileSource,
+    file_source: JsonFileSource,
 }
 
 impl JsonFormatOptions {
     pub fn new(file_source: JsonFileSource) -> Self {
         Self {
-            _file_source: file_source,
+            file_source,
             indent_style: IndentStyle::default(),
             indent_width: IndentWidth::default(),
             line_ending: LineEnding::default(),
@@ -112,6 +112,10 @@ impl JsonFormatOptions {
     pub fn set_line_width(&mut self, line_width: LineWidth) {
         self.line_width = line_width;
     }
+
+    pub fn allows_trailing_separator(&self) -> bool {
+        self.file_source.allows_trailing_comma()
+    }
 }
 
 impl FormatOptions for JsonFormatOptions {
diff --git a/crates/biome_json_formatter/src/json/lists/array_element_list.rs b/crates/biome_json_formatter/src/json/lists/array_element_list.rs
index 3236d86fea84..af30e71f27fe 100644
--- a/crates/biome_json_formatter/src/json/lists/array_element_list.rs
+++ b/crates/biome_json_formatter/src/json/lists/array_element_list.rs
@@ -16,11 +16,15 @@ impl FormatRule<JsonArrayElementList> for FormatJsonArrayElementList {
             ArrayLayout::OnePerLine
         };
 
+        let allow_trailing_separator = f.options().allows_trailing_separator();
         match layout {
             ArrayLayout::Fill => {
                 let mut filler = f.fill();
 
-                for (element, formatted) in node.iter().zip(node.format_separated(",")) {
+                for (element, formatted) in node
+                    .iter()
+                    .zip(node.format_separated(",", allow_trailing_separator))
+                {
                     filler.entry(
                         &format_once(|f| {
                             if get_lines_before(element?.syntax()) > 1 {
@@ -39,7 +43,10 @@ impl FormatRule<JsonArrayElementList> for FormatJsonArrayElementList {
             ArrayLayout::OnePerLine => {
                 let mut join = f.join_nodes_with_soft_line();
 
-                for (element, formatted) in node.elements().zip(node.format_separated(",")) {
+                for (element, formatted) in node
+                    .elements()
+                    .zip(node.format_separated(",", allow_trailing_separator))
+                {
                     join.entry(element.node()?.syntax(), &formatted);
                 }
 
diff --git a/crates/biome_json_formatter/src/json/lists/member_list.rs b/crates/biome_json_formatter/src/json/lists/member_list.rs
index 2ee79cf98a9d..605bf2133466 100644
--- a/crates/biome_json_formatter/src/json/lists/member_list.rs
+++ b/crates/biome_json_formatter/src/json/lists/member_list.rs
@@ -9,9 +9,14 @@ pub(crate) struct FormatJsonMemberList;
 impl FormatRule<JsonMemberList> for FormatJsonMemberList {
     type Context = JsonFormatContext;
     fn fmt(&self, node: &JsonMemberList, f: &mut JsonFormatter) -> FormatResult<()> {
+        let options = f.options();
+        let allow_trailing_separator = options.allows_trailing_separator();
         let mut join = f.join_nodes_with_soft_line();
 
-        for (element, formatted) in node.elements().zip(node.format_separated(",")) {
+        for (element, formatted) in node
+            .elements()
+            .zip(node.format_separated(",", allow_trailing_separator))
+        {
             join.entry(element.node()?.syntax(), &formatted);
         }
 
diff --git a/crates/biome_json_formatter/src/separated.rs b/crates/biome_json_formatter/src/separated.rs
index b3fec97aeb95..ec6b11b2d56f 100644
--- a/crates/biome_json_formatter/src/separated.rs
+++ b/crates/biome_json_formatter/src/separated.rs
@@ -46,13 +46,22 @@ pub(crate) trait FormatAstSeparatedListExtension:
     /// created by calling the `separator_factory` function.
     /// The last trailing separator in the list will only be printed
     /// if the outer group breaks.
-    fn format_separated(&self, separator: &'static str) -> JsonFormatSeparatedIter<Self::Node> {
+    fn format_separated(
+        &self,
+        separator: &'static str,
+        allow_trailing_separator: bool,
+    ) -> JsonFormatSeparatedIter<Self::Node> {
+        let trailing_separator = if allow_trailing_separator {
+            TrailingSeparator::Allowed
+        } else {
+            TrailingSeparator::Disallowed
+        };
         JsonFormatSeparatedIter::new(
             self.elements(),
             separator,
             JsonFormatSeparatedElementRule { node: PhantomData },
         )
-        .with_trailing_separator(TrailingSeparator::Disallowed)
+        .with_trailing_separator(trailing_separator)
     }
 }
 
diff --git a/crates/biome_json_syntax/Cargo.toml b/crates/biome_json_syntax/Cargo.toml
index de6175d76092..1c45814a4a90 100644
--- a/crates/biome_json_syntax/Cargo.toml
+++ b/crates/biome_json_syntax/Cargo.toml
@@ -14,6 +14,11 @@ version              = "0.4.0"
 
 [dependencies]
 biome_rowan = { workspace = true }
+schemars    = { workspace = true, optional = true }
+serde       = { workspace = true, features = ["derive"] }
+
+[features]
+schema = ["biome_rowan/serde", "schemars"]
 
 [lints]
 workspace = true
diff --git a/crates/biome_json_syntax/src/file_source.rs b/crates/biome_json_syntax/src/file_source.rs
index 8802b7628a6f..860596b603ec 100644
--- a/crates/biome_json_syntax/src/file_source.rs
+++ b/crates/biome_json_syntax/src/file_source.rs
@@ -1,12 +1,19 @@
 use biome_rowan::FileSourceError;
 use std::path::Path;
 
-#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 pub struct JsonFileSource {
     variant: JsonVariant,
+    allow_trailing_comma: bool,
 }
 
-#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
 enum JsonVariant {
     #[default]
     Standard,
@@ -17,15 +24,30 @@ impl JsonFileSource {
     pub fn json() -> Self {
         Self {
             variant: JsonVariant::Standard,
+            allow_trailing_comma: false,
         }
     }
 
     pub fn jsonc() -> Self {
         Self {
             variant: JsonVariant::Jsonc,
+            allow_trailing_comma: false,
         }
     }
 
+    pub fn with_trailing_comma(mut self, option_value: bool) -> Self {
+        self.allow_trailing_comma = option_value;
+        self
+    }
+
+    pub fn set_allow_trailing_comma(&mut self, option_value: bool) {
+        self.allow_trailing_comma = option_value;
+    }
+
+    pub fn allows_trailing_comma(&self) -> bool {
+        self.allow_trailing_comma
+    }
+
     pub const fn is_jsonc(&self) -> bool {
         matches!(self.variant, JsonVariant::Jsonc)
     }
diff --git a/crates/biome_lsp/src/handlers/text_document.rs b/crates/biome_lsp/src/handlers/text_document.rs
index 6e6d239e03e0..706102a11697 100644
--- a/crates/biome_lsp/src/handlers/text_document.rs
+++ b/crates/biome_lsp/src/handlers/text_document.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use biome_service::workspace::{
-    ChangeFileParams, CloseFileParams, GetFileContentParams, Language, OpenFileParams,
+    ChangeFileParams, CloseFileParams, DocumentFileSource, GetFileContentParams, OpenFileParams,
 };
 use tower_lsp::lsp_types;
 use tracing::{error, field};
@@ -17,7 +17,7 @@ pub(crate) async fn did_open(
     let url = params.text_document.uri;
     let version = params.text_document.version;
     let content = params.text_document.text;
-    let language_hint = Language::from_language_id(&params.text_document.language_id);
+    let language_hint = DocumentFileSource::from_language_id(&params.text_document.language_id);
 
     let biome_path = session.file_path(&url)?;
     let doc = Document::new(version, &content);
@@ -26,7 +26,7 @@ pub(crate) async fn did_open(
         path: biome_path,
         version,
         content,
-        language_hint,
+        document_file_source: language_hint,
     })?;
 
     session.insert_document(url.clone(), doc);
diff --git a/crates/biome_service/Cargo.toml b/crates/biome_service/Cargo.toml
index 453556894968..0522cb76598d 100644
--- a/crates/biome_service/Cargo.toml
+++ b/crates/biome_service/Cargo.toml
@@ -30,7 +30,7 @@ biome_js_factory         = { workspace = true, optional = true }
 biome_js_formatter       = { workspace = true, features = ["serde"] }
 biome_js_parser          = { workspace = true }
 biome_js_semantic        = { workspace = true }
-biome_js_syntax          = { workspace = true, features = ["serde"] }
+biome_js_syntax          = { workspace = true, features = ["schema"] }
 biome_json_analyze       = { workspace = true }
 biome_json_formatter     = { workspace = true }
 biome_json_parser        = { workspace = true }
@@ -59,6 +59,8 @@ schema = [
   "biome_formatter/serde",
   "biome_js_factory",
   "biome_text_edit/schemars",
+  "biome_json_syntax/schema",
+  "biome_css_syntax/schema",
 ]
 
 [dev-dependencies]
diff --git a/crates/biome_service/src/diagnostics.rs b/crates/biome_service/src/diagnostics.rs
index 7a46e96f1e8f..3447875b70f6 100644
--- a/crates/biome_service/src/diagnostics.rs
+++ b/crates/biome_service/src/diagnostics.rs
@@ -1,4 +1,4 @@
-use crate::file_handlers::Language;
+use crate::workspace::DocumentFileSource;
 use crate::ConfigurationDiagnostic;
 use biome_console::fmt::Bytes;
 use biome_console::markup;
@@ -80,12 +80,12 @@ impl WorkspaceError {
     }
 
     pub fn source_file_not_supported(
-        language: Language,
+        language: DocumentFileSource,
         path: String,
         extension: Option<String>,
     ) -> Self {
         Self::SourceFileNotSupported(SourceFileNotSupported {
-            language,
+            file_source: language,
             path,
             extension,
         })
@@ -472,7 +472,7 @@ impl Diagnostic for FileTooLarge {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct SourceFileNotSupported {
-    language: Language,
+    file_source: DocumentFileSource,
     path: String,
     extension: Option<String>,
 }
@@ -491,9 +491,9 @@ impl Diagnostic for SourceFileNotSupported {
     }
 
     fn message(&self, fmt: &mut biome_console::fmt::Formatter<'_>) -> std::io::Result<()> {
-        if self.language != Language::Unknown {
+        if self.file_source != DocumentFileSource::Unknown {
             fmt.write_markup(markup! {
-                "Biome doesn't support this feature for the language "{{&self.language}}
+                "Biome doesn't support this feature for the language "{{&self.file_source}}
             })
         } else if let Some(ext) = self.extension.as_ref() {
             fmt.write_markup(markup! {
@@ -519,9 +519,10 @@ impl Diagnostic for SourceFileNotSupported {
 }
 
 pub fn extension_error(path: &BiomePath) -> WorkspaceError {
-    let language = Language::from_path_and_known_filename(path).or(Language::from_path(path));
+    let file_source = DocumentFileSource::from_path_and_known_filename(path)
+        .or(DocumentFileSource::from_path(path));
     WorkspaceError::source_file_not_supported(
-        language,
+        file_source,
         path.clone().display().to_string(),
         path.clone()
             .extension()
@@ -720,7 +721,7 @@ mod test {
         CantReadDirectory, CantReadFile, DirtyWorkspace, FileIgnored, FileTooLarge, NotFound,
         SourceFileNotSupported,
     };
-    use crate::file_handlers::Language;
+    use crate::file_handlers::DocumentFileSource;
     use crate::{TransportError, WorkspaceError};
     use biome_diagnostics::{print_diagnostic_to_string, DiagnosticExt, Error};
     use biome_formatter::FormatError;
@@ -798,7 +799,7 @@ mod test {
         snap_diagnostic(
             "source_file_not_supported",
             WorkspaceError::SourceFileNotSupported(SourceFileNotSupported {
-                language: Language::Unknown,
+                file_source: DocumentFileSource::Unknown,
                 path: path.display().to_string(),
                 extension: path
                     .extension()
diff --git a/crates/biome_service/src/file_handlers/astro.rs b/crates/biome_service/src/file_handlers/astro.rs
index 1f6cff991e96..9bbe3e077f61 100644
--- a/crates/biome_service/src/file_handlers/astro.rs
+++ b/crates/biome_service/src/file_handlers/astro.rs
@@ -1,10 +1,12 @@
 use crate::file_handlers::{
     javascript, AnalyzerCapabilities, Capabilities, CodeActionsParams, DebugCapabilities,
-    ExtensionHandler, FixAllParams, FormatterCapabilities, Language, LintParams, LintResults, Mime,
+    ExtensionHandler, FixAllParams, FormatterCapabilities, LintParams, LintResults, Mime,
     ParseResult, ParserCapabilities,
 };
 use crate::settings::SettingsHandle;
-use crate::workspace::{FixFileResult, OrganizeImportsResult, PullActionsResult};
+use crate::workspace::{
+    DocumentFileSource, FixFileResult, OrganizeImportsResult, PullActionsResult,
+};
 use crate::WorkspaceError;
 use biome_formatter::Printed;
 use biome_fs::BiomePath;
@@ -64,10 +66,6 @@ impl AstroFileHandler {
 }
 
 impl ExtensionHandler for AstroFileHandler {
-    fn language(&self) -> Language {
-        Language::TypeScript
-    }
-
     fn mime(&self) -> Mime {
         Mime::Javascript
     }
@@ -98,7 +96,7 @@ impl ExtensionHandler for AstroFileHandler {
 
 fn parse(
     _rome_path: &BiomePath,
-    _language_hint: Language,
+    _file_source: DocumentFileSource,
     text: &str,
     _settings: SettingsHandle,
     cache: &mut NodeCache,
@@ -119,35 +117,37 @@ fn parse(
             root.as_send().unwrap(),
             diagnostics,
         ),
-        language: Some(Language::TypeScript),
+        language: Some(JsFileSource::ts().into()),
     }
 }
 
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 fn format(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format(biome_path, parse, settings)
+    javascript::format(biome_path, document_file_source, parse, settings)
 }
-
 pub(crate) fn format_range(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_range(biome_path, parse, settings, range)
+    javascript::format_range(biome_path, document_file_source, parse, settings, range)
 }
 
 pub(crate) fn format_on_type(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_on_type(biome_path, parse, settings, offset)
+    javascript::format_on_type(biome_path, document_file_source, parse, settings, offset)
 }
 
 pub(crate) fn lint(params: LintParams) -> LintResults {
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index ce166c0a77ca..dcb98e669743 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -1,13 +1,13 @@
 use super::{ExtensionHandler, Mime, ParseResult};
+use crate::file_handlers::DebugCapabilities;
 use crate::file_handlers::{
     AnalyzerCapabilities, Capabilities, FormatterCapabilities, ParserCapabilities,
 };
-use crate::file_handlers::{DebugCapabilities, Language as LanguageId};
 use crate::settings::{
     FormatSettings, Language, LanguageListSettings, LanguageSettings, OverrideSettings,
     SettingsHandle,
 };
-use crate::workspace::GetSyntaxTreeResult;
+use crate::workspace::{DocumentFileSource, GetSyntaxTreeResult};
 use crate::WorkspaceError;
 use biome_css_formatter::context::CssFormatOptions;
 use biome_css_formatter::{can_format_css_yet, format_node};
@@ -53,6 +53,7 @@ impl Language for CssLanguage {
         overrides: &OverrideSettings,
         language: &Self::FormatterSettings,
         path: &BiomePath,
+        document_file_source: &DocumentFileSource,
     ) -> Self::FormatOptions {
         let indent_style = if let Some(indent_style) = language.indent_style {
             indent_style
@@ -72,11 +73,15 @@ impl Language for CssLanguage {
 
         overrides.override_css_format_options(
             path,
-            CssFormatOptions::new(path.as_path().try_into().unwrap_or_default())
-                .with_indent_style(indent_style)
-                .with_indent_width(indent_width)
-                .with_line_width(line_width)
-                .with_quote_style(language.quote_style.unwrap_or_default()),
+            CssFormatOptions::new(
+                document_file_source
+                    .to_css_file_source()
+                    .unwrap_or_default(),
+            )
+            .with_indent_style(indent_style)
+            .with_indent_width(indent_width)
+            .with_line_width(line_width)
+            .with_quote_style(language.quote_style.unwrap_or_default()),
         )
     }
 }
@@ -85,10 +90,6 @@ impl Language for CssLanguage {
 pub(crate) struct CssFileHandler;
 
 impl ExtensionHandler for CssFileHandler {
-    fn language(&self) -> super::Language {
-        super::Language::Css
-    }
-
     fn mime(&self) -> super::Mime {
         Mime::Css
     }
@@ -136,7 +137,7 @@ impl ExtensionHandler for CssFileHandler {
 
 fn parse(
     biome_path: &BiomePath,
-    _language_hint: LanguageId,
+    _file_source: DocumentFileSource,
     text: &str,
     settings: SettingsHandle,
     cache: &mut NodeCache,
@@ -173,10 +174,11 @@ fn debug_syntax_tree(_rome_path: &BiomePath, parse: AnyParse) -> GetSyntaxTreeRe
 
 fn debug_formatter_ir(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<String, WorkspaceError> {
-    let options = settings.format_options::<CssLanguage>(biome_path);
+    let options = settings.format_options::<CssLanguage>(biome_path, document_file_source);
 
     let tree = parse.syntax();
     let formatted = format_node(options, &tree)?;
@@ -188,10 +190,11 @@ fn debug_formatter_ir(
 #[tracing::instrument(level = "debug", skip(parse))]
 fn format(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<CssLanguage>(biome_path);
+    let options = settings.format_options::<CssLanguage>(biome_path, document_file_source);
 
     tracing::debug!("Format with the following options: \n{}", options);
 
@@ -206,11 +209,12 @@ fn format(
 
 fn format_range(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<CssLanguage>(biome_path);
+    let options = settings.format_options::<CssLanguage>(biome_path, document_file_source);
 
     let tree = parse.syntax();
     let printed = biome_css_formatter::format_range(options, &tree, range)?;
@@ -219,11 +223,12 @@ fn format_range(
 
 fn format_on_type(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<CssLanguage>(biome_path);
+    let options = settings.format_options::<CssLanguage>(biome_path, document_file_source);
 
     let tree = parse.syntax();
 
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index e7906cfff39a..228ae3eb40be 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -4,9 +4,9 @@ use super::{
 };
 use crate::configuration::to_analyzer_rules;
 use crate::diagnostics::extension_error;
-use crate::file_handlers::{is_diagnostic_error, FixAllParams, Language as LanguageId};
+use crate::file_handlers::{is_diagnostic_error, FixAllParams};
 use crate::settings::OverrideSettings;
-use crate::workspace::OrganizeImportsResult;
+use crate::workspace::{DocumentFileSource, OrganizeImportsResult};
 use crate::{
     settings::{FormatSettings, Language, LanguageListSettings, LanguageSettings, SettingsHandle},
     workspace::{
@@ -97,46 +97,52 @@ impl Language for JsLanguage {
         overrides: &OverrideSettings,
         language: &JsFormatterSettings,
         path: &BiomePath,
+        document_file_source: &DocumentFileSource,
     ) -> JsFormatOptions {
-        let options = JsFormatOptions::new(path.as_path().try_into().unwrap_or_default())
-            .with_indent_style(
-                language
-                    .indent_style
-                    .or(global.indent_style)
-                    .unwrap_or_default(),
-            )
-            .with_indent_width(
-                language
-                    .indent_width
-                    .or(global.indent_width)
-                    .unwrap_or_default(),
-            )
-            .with_line_width(
-                language
-                    .line_width
-                    .or(global.line_width)
-                    .unwrap_or_default(),
-            )
-            .with_line_ending(
-                language
-                    .line_ending
-                    .or(global.line_ending)
-                    .unwrap_or_default(),
-            )
-            .with_quote_style(language.quote_style.unwrap_or_default())
-            .with_jsx_quote_style(language.jsx_quote_style.unwrap_or_default())
-            .with_quote_properties(language.quote_properties.unwrap_or_default())
-            .with_trailing_comma(language.trailing_comma.unwrap_or_default())
-            .with_semicolons(language.semicolons.unwrap_or_default())
-            .with_arrow_parentheses(language.arrow_parentheses.unwrap_or_default())
-            .with_bracket_spacing(language.bracket_spacing.unwrap_or_default())
-            .with_bracket_same_line(language.bracket_same_line.unwrap_or_default())
-            .with_attribute_position(
-                language
-                    .attribute_position
-                    .or(global.attribute_position)
-                    .unwrap_or_default(),
-            );
+        let options = JsFormatOptions::new(
+            document_file_source
+                .to_js_file_source()
+                .or(JsFileSource::try_from(path.as_path()).ok())
+                .unwrap_or_default(),
+        )
+        .with_indent_style(
+            language
+                .indent_style
+                .or(global.indent_style)
+                .unwrap_or_default(),
+        )
+        .with_indent_width(
+            language
+                .indent_width
+                .or(global.indent_width)
+                .unwrap_or_default(),
+        )
+        .with_line_width(
+            language
+                .line_width
+                .or(global.line_width)
+                .unwrap_or_default(),
+        )
+        .with_line_ending(
+            language
+                .line_ending
+                .or(global.line_ending)
+                .unwrap_or_default(),
+        )
+        .with_quote_style(language.quote_style.unwrap_or_default())
+        .with_jsx_quote_style(language.jsx_quote_style.unwrap_or_default())
+        .with_quote_properties(language.quote_properties.unwrap_or_default())
+        .with_trailing_comma(language.trailing_comma.unwrap_or_default())
+        .with_semicolons(language.semicolons.unwrap_or_default())
+        .with_arrow_parentheses(language.arrow_parentheses.unwrap_or_default())
+        .with_bracket_spacing(language.bracket_spacing.unwrap_or_default())
+        .with_bracket_same_line(language.bracket_same_line.unwrap_or_default())
+        .with_attribute_position(
+            language
+                .attribute_position
+                .or(global.attribute_position)
+                .unwrap_or_default(),
+        );
 
         overrides.override_js_format_options(path, options)
     }
@@ -146,10 +152,6 @@ impl Language for JsLanguage {
 pub(crate) struct JsFileHandler;
 
 impl ExtensionHandler for JsFileHandler {
-    fn language(&self) -> super::Language {
-        super::Language::JavaScript
-    }
-
     fn mime(&self) -> Mime {
         Mime::Javascript
     }
@@ -184,18 +186,11 @@ impl ExtensionHandler for JsFileHandler {
 
 fn parse(
     biome_path: &BiomePath,
-    language_hint: LanguageId,
+    file_source: DocumentFileSource,
     text: &str,
     settings: SettingsHandle,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    let source_type =
-        JsFileSource::try_from(biome_path.as_path()).unwrap_or_else(|_| match language_hint {
-            LanguageId::JavaScriptReact => JsFileSource::jsx(),
-            LanguageId::TypeScript => JsFileSource::ts(),
-            LanguageId::TypeScriptReact => JsFileSource::tsx(),
-            _ => JsFileSource::js_module(),
-        });
     let parser_settings = &settings.as_ref().languages.javascript.parser;
     let overrides = &settings.as_ref().override_settings;
     let options = overrides.override_js_parser_options(
@@ -204,7 +199,8 @@ fn parse(
             parse_class_parameter_decorators: parser_settings.parse_class_parameter_decorators,
         },
     );
-    let parse = biome_js_parser::parse_js_with_cache(text, source_type, options, cache);
+    let file_source = file_source.to_js_file_source().unwrap_or_default();
+    let parse = biome_js_parser::parse_js_with_cache(text, file_source, options, cache);
     let root = parse.syntax();
     let diagnostics = parse.into_diagnostics();
     ParseResult {
@@ -271,11 +267,12 @@ fn debug_control_flow(parse: AnyParse, cursor: TextSize) -> String {
 }
 
 fn debug_formatter_ir(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<String, WorkspaceError> {
-    let options = settings.format_options::<JsLanguage>(biome_path);
+    let options = settings.format_options::<JsLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
     let formatted = format_node(options, &tree)?;
@@ -290,7 +287,7 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
             let settings = params.settings.as_ref();
             let Some(file_source) = params
                 .language
-                .as_js_file_source()
+                .to_js_file_source()
                 .or(JsFileSource::try_from(params.path.as_path()).ok())
             else {
                 return LintResults {
@@ -478,7 +475,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
             let analyzer_options =
                 compute_analyzer_options(&settings, PathBuf::from(path.as_path()));
 
-            let Some(source_type) = language.as_js_file_source() else {
+            let Some(source_type) = language.to_js_file_source() else {
                 error!("Could not determine the file source of the file");
                 return PullActionsResult { actions: vec![] };
             };
@@ -523,11 +520,11 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         biome_path,
         mut filter,
         manifest,
-        language,
+        document_file_source,
     } = params;
 
-    let Some(file_source) = language
-        .as_js_file_source()
+    let Some(file_source) = document_file_source
+        .to_js_file_source()
         .or(JsFileSource::try_from(biome_path.as_path()).ok())
     else {
         return Err(extension_error(biome_path));
@@ -614,7 +611,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
             None => {
                 let code = if should_format {
                     format_node(
-                        settings.format_options::<JsLanguage>(biome_path),
+                        settings.format_options::<JsLanguage>(biome_path, &document_file_source),
                         tree.syntax(),
                     )?
                     .print()?
@@ -636,10 +633,11 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 pub(crate) fn format(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsLanguage>(biome_path);
+    let options = settings.format_options::<JsLanguage>(biome_path, document_file_source);
 
     debug!("Options used for format: \n{}", options);
 
@@ -658,11 +656,12 @@ pub(crate) fn format(
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 pub(crate) fn format_range(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsLanguage>(biome_path);
+    let options = settings.format_options::<JsLanguage>(biome_path, document_file_source);
 
     let tree = parse.syntax();
     let printed = biome_js_formatter::format_range(options, &tree, range)?;
@@ -671,12 +670,13 @@ pub(crate) fn format_range(
 
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 pub(crate) fn format_on_type(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsLanguage>(biome_path);
+    let options = settings.format_options::<JsLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
 
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index 020583f41264..dd18f393ee14 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -1,10 +1,10 @@
-use super::{CodeActionsParams, ExtensionHandler, Mime, ParseResult};
+use super::{CodeActionsParams, DocumentFileSource, ExtensionHandler, Mime, ParseResult};
 use crate::configuration::{to_analyzer_rules, PartialConfiguration};
+use crate::file_handlers::DebugCapabilities;
 use crate::file_handlers::{
     AnalyzerCapabilities, Capabilities, FixAllParams, FormatterCapabilities, LintParams,
     LintResults, ParserCapabilities,
 };
-use crate::file_handlers::{DebugCapabilities, Language as LanguageId};
 use crate::settings::{
     FormatSettings, Language, LanguageListSettings, LanguageSettings, OverrideSettings,
     SettingsHandle,
@@ -24,7 +24,7 @@ use biome_json_analyze::analyze;
 use biome_json_formatter::context::JsonFormatOptions;
 use biome_json_formatter::format_node;
 use biome_json_parser::JsonParserOptions;
-use biome_json_syntax::{JsonFileSource, JsonLanguage, JsonRoot, JsonSyntaxNode};
+use biome_json_syntax::{JsonLanguage, JsonRoot, JsonSyntaxNode};
 use biome_parser::AnyParse;
 use biome_rowan::{AstNode, NodeCache};
 use biome_rowan::{TextRange, TextSize, TokenAtOffset};
@@ -62,6 +62,7 @@ impl Language for JsonLanguage {
         overrides: &OverrideSettings,
         language: &Self::FormatterSettings,
         path: &BiomePath,
+        document_file_source: &DocumentFileSource,
     ) -> Self::FormatOptions {
         let indent_style = if let Some(indent_style) = language.indent_style {
             indent_style
@@ -87,11 +88,15 @@ impl Language for JsonLanguage {
 
         overrides.override_json_format_options(
             path,
-            JsonFormatOptions::new(path.as_path().try_into().unwrap_or_default())
-                .with_line_ending(line_ending)
-                .with_indent_style(indent_style)
-                .with_indent_width(indent_width)
-                .with_line_width(line_width),
+            JsonFormatOptions::new(
+                document_file_source
+                    .to_json_file_source()
+                    .unwrap_or_default(),
+            )
+            .with_line_ending(line_ending)
+            .with_indent_style(indent_style)
+            .with_indent_width(indent_width)
+            .with_line_width(line_width),
         )
     }
 }
@@ -100,10 +105,6 @@ impl Language for JsonLanguage {
 pub(crate) struct JsonFileHandler;
 
 impl ExtensionHandler for JsonFileHandler {
-    fn language(&self) -> super::Language {
-        super::Language::Json
-    }
-
     fn mime(&self) -> super::Mime {
         Mime::Json
     }
@@ -140,7 +141,7 @@ fn is_file_allowed(path: &Path) -> bool {
     path.file_name()
         .and_then(|f| f.to_str())
         .map(|f| {
-            super::Language::KNOWN_FILES_AS_JSONC
+            super::DocumentFileSource::KNOWN_FILES_AS_JSONC
                 .binary_search(&f)
                 .is_ok()
         })
@@ -150,28 +151,25 @@ fn is_file_allowed(path: &Path) -> bool {
 
 fn parse(
     biome_path: &BiomePath,
-    language_hint: LanguageId,
+    mut file_source: DocumentFileSource,
     text: &str,
     settings: SettingsHandle,
     cache: &mut NodeCache,
 ) -> ParseResult {
     let parser = &settings.as_ref().languages.json.parser;
     let overrides = &settings.as_ref().override_settings;
-    let source_type =
-        JsonFileSource::try_from(biome_path.as_path()).unwrap_or_else(|_| match language_hint {
-            LanguageId::Json => JsonFileSource::json(),
-            LanguageId::Jsonc => JsonFileSource::jsonc(),
-            _ => JsonFileSource::json(),
-        });
     let options: JsonParserOptions = overrides.override_json_parser_options(
         biome_path,
         JsonParserOptions {
             allow_comments: parser.allow_comments
-                || source_type.is_jsonc()
+                || file_source.to_json_file_source().map(|fs| fs.is_jsonc()) == Some(true)
                 || is_file_allowed(biome_path),
             allow_trailing_commas: parser.allow_trailing_commas || is_file_allowed(biome_path),
         },
     );
+    if let DocumentFileSource::Json(file_source) = &mut file_source {
+        file_source.set_allow_trailing_comma(options.allow_trailing_commas);
+    }
     let parse = biome_json_parser::parse_json_with_cache(text, cache, options);
     let root = parse.syntax();
     let diagnostics = parse.into_diagnostics();
@@ -182,7 +180,7 @@ fn parse(
             root.as_send().unwrap(),
             diagnostics,
         ),
-        language: None,
+        language: Some(file_source),
     }
 }
 
@@ -196,11 +194,12 @@ fn debug_syntax_tree(_rome_path: &BiomePath, parse: AnyParse) -> GetSyntaxTreeRe
 }
 
 fn debug_formatter_ir(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<String, WorkspaceError> {
-    let options = settings.format_options::<JsonLanguage>(biome_path);
+    let options = settings.format_options::<JsonLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
     let formatted = format_node(options, &tree)?;
@@ -211,11 +210,12 @@ fn debug_formatter_ir(
 
 #[tracing::instrument(level = "debug", skip(parse, settings))]
 fn format(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsonLanguage>(biome_path);
+    let options = settings.format_options::<JsonLanguage>(path, document_file_source);
 
     tracing::debug!("Format with the following options: \n{}", options);
 
@@ -229,12 +229,13 @@ fn format(
 }
 
 fn format_range(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsonLanguage>(biome_path);
+    let options = settings.format_options::<JsonLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
     let printed = biome_json_formatter::format_range(options, &tree, range)?;
@@ -242,12 +243,13 @@ fn format_range(
 }
 
 fn format_on_type(
-    biome_path: &BiomePath,
+    path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    let options = settings.format_options::<JsonLanguage>(biome_path);
+    let options = settings.format_options::<JsonLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
 
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index d77f46ee4358..6627b1cd8c38 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -15,10 +15,12 @@ use biome_analyze::{AnalysisFilter, AnalyzerDiagnostic, RuleCategories};
 use biome_console::fmt::Formatter;
 use biome_console::markup;
 use biome_css_formatter::can_format_css_yet;
+use biome_css_syntax::CssFileSource;
 use biome_diagnostics::{Diagnostic, Severity};
 use biome_formatter::Printed;
 use biome_fs::BiomePath;
-use biome_js_syntax::{JsFileSource, TextRange, TextSize};
+use biome_js_syntax::{EmbeddingKind, JsFileSource, ModuleKind, TextRange, TextSize};
+use biome_json_syntax::JsonFileSource;
 use biome_parser::AnyParse;
 use biome_project::PackageJson;
 use biome_rowan::NodeCache;
@@ -34,36 +36,46 @@ mod svelte;
 mod unknown;
 mod vue;
 
-/// Supported languages by Biome
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Default, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub enum Language {
-    /// JavaScript
-    JavaScript,
-    /// JSX
-    JavaScriptReact,
-    /// TypeScript
-    TypeScript,
-    /// TSX
-    TypeScriptReact,
-    /// JSON
-    Json,
-    /// JSONC
-    Jsonc,
-    /// CSS
-    Css,
-    ///
-    Astro,
-    ///
-    Vue,
-    ///
-    Svelte,
-    /// Any language that is not supported
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
+pub enum DocumentFileSource {
+    Js(JsFileSource),
+    Json(JsonFileSource),
+    Css(CssFileSource),
     #[default]
     Unknown,
 }
 
-impl Language {
+impl From<JsFileSource> for DocumentFileSource {
+    fn from(value: JsFileSource) -> Self {
+        Self::Js(value)
+    }
+}
+
+impl From<JsonFileSource> for DocumentFileSource {
+    fn from(value: JsonFileSource) -> Self {
+        Self::Json(value)
+    }
+}
+
+impl From<CssFileSource> for DocumentFileSource {
+    fn from(value: CssFileSource) -> Self {
+        Self::Css(value)
+    }
+}
+
+impl From<&Path> for DocumentFileSource {
+    fn from(value: &Path) -> Self {
+        JsFileSource::try_from(value)
+            .map(Into::into)
+            .or(JsonFileSource::try_from(value).map(Into::into))
+            .unwrap_or(DocumentFileSource::Unknown)
+    }
+}
+
+impl DocumentFileSource {
     /// Sorted array of files that are known as JSONC (JSON with comments).
     pub(crate) const KNOWN_FILES_AS_JSONC: &'static [&'static str; 15] = &[
         ".babelrc",
@@ -83,28 +95,60 @@ impl Language {
         "typescript.json",
     ];
 
-    /// Returns the language corresponding to this file extension
+    /// Returns the language corresponding to this language ID
+    ///
+    /// See the [microsoft spec]
+    /// for a list of language identifiers
+    ///
+    /// [microsoft spec]: https://code.visualstudio.com/docs/languages/identifiers
     pub fn from_extension(s: &str) -> Self {
         match s.to_lowercase().as_str() {
-            "js" | "mjs" | "cjs" => Language::JavaScript,
-            "jsx" => Language::JavaScriptReact,
-            "ts" | "mts" | "cts" => Language::TypeScript,
-            "tsx" => Language::TypeScriptReact,
-            "json" => Language::Json,
-            "jsonc" => Language::Jsonc,
-            "astro" => Language::Astro,
-            "vue" => Language::Vue,
-            "svelte" => Language::Svelte,
-            "css" => Language::Css,
-            _ => Language::Unknown,
+            "js" | "mjs" => JsFileSource::jsx().into(),
+            "cjs" => JsFileSource::js_script().into(),
+            "jsx" => JsFileSource::jsx().into(),
+            "ts" | "mts" => JsFileSource::ts().into(),
+            "cts" => JsFileSource::ts()
+                .with_module_kind(ModuleKind::Script)
+                .into(),
+            "tsx" => JsFileSource::tsx().into(),
+            "json" => JsonFileSource::json().into(),
+            "jsonc" => JsonFileSource::jsonc().into(),
+            "astro" => JsFileSource::astro().into(),
+            "vue" => JsFileSource::vue().into(),
+            "svelte" => JsFileSource::svelte().into(),
+            "css" => CssFileSource::css().into(),
+            _ => DocumentFileSource::Unknown,
+        }
+    }
+
+    /// Returns the language corresponding to this language ID
+    ///
+    /// See the [microsoft spec]
+    /// for a list of language identifiers
+    ///
+    /// [microsoft spec]: https://code.visualstudio.com/docs/languages/identifiers
+    pub fn from_language_id(s: &str) -> Self {
+        match s.to_lowercase().as_str() {
+            "javascript" => JsFileSource::js_module().into(),
+            "typescript" => JsFileSource::ts().into(),
+            "javascriptreact" => JsFileSource::jsx().into(),
+            "typescriptreact" => JsFileSource::tsx().into(),
+            "json" => JsonFileSource::json().into(),
+            "jsonc" => JsonFileSource::json().into(),
+            "astro" => JsFileSource::astro().into(),
+            "vue" => JsFileSource::vue().into(),
+            "svelte" => JsFileSource::svelte().into(),
+            // TODO: remove this when we are ready to handle CSS files
+            "css" => DocumentFileSource::Unknown,
+            _ => DocumentFileSource::Unknown,
         }
     }
 
     pub fn from_known_filename(s: &str) -> Self {
         if Self::KNOWN_FILES_AS_JSONC.binary_search(&s).is_ok() {
-            Language::Jsonc
+            JsonFileSource::jsonc().into()
         } else {
-            Language::Unknown
+            DocumentFileSource::Unknown
         }
     }
 
@@ -112,8 +156,8 @@ impl Language {
     pub fn from_path(path: &Path) -> Self {
         path.extension()
             .and_then(|path| path.to_str())
-            .map(Language::from_extension)
-            .unwrap_or(Language::Unknown)
+            .map(DocumentFileSource::from_extension)
+            .unwrap_or(DocumentFileSource::Unknown)
     }
 
     /// Returns the language corresponding to the file path
@@ -121,61 +165,40 @@ impl Language {
     pub fn from_path_and_known_filename(path: &Path) -> Self {
         path.extension()
             .and_then(OsStr::to_str)
-            .map(Language::from_extension)
+            .map(DocumentFileSource::from_extension)
             .or(path
                 .file_name()
                 .and_then(OsStr::to_str)
-                .map(Language::from_known_filename))
+                .map(DocumentFileSource::from_known_filename))
             .unwrap_or_default()
     }
 
-    /// Returns the language corresponding to this language ID
-    ///
-    /// See the [microsoft spec]
-    /// for a list of language identifiers
-    ///
-    /// [microsoft spec]: https://code.visualstudio.com/docs/languages/identifiers
-    pub fn from_language_id(s: &str) -> Self {
-        match s.to_lowercase().as_str() {
-            "javascript" => Language::JavaScript,
-            "typescript" => Language::TypeScript,
-            "javascriptreact" => Language::JavaScriptReact,
-            "typescriptreact" => Language::TypeScriptReact,
-            "json" => Language::Json,
-            "jsonc" => Language::Jsonc,
-            "astro" => Language::Astro,
-            "vue" => Language::Vue,
-            "svelte" => Language::Svelte,
-            // TODO: remove this when we are ready to handle CSS files
-            "css" => Language::Unknown,
-            _ => Language::Unknown,
-        }
-    }
-
     /// Returns the language if it's not unknown, otherwise returns `other`.
     ///
     /// # Examples
     ///
     /// ```
-    /// # use biome_service::workspace::Language;
-    /// let x = Language::JavaScript;
-    /// let y = Language::Unknown;
-    /// assert_eq!(x.or(y), Language::JavaScript);
+    /// use biome_js_syntax::JsFileSource;
+    /// use biome_json_syntax::JsonFileSource;
+    /// use biome_service::workspace::DocumentFileSource;
+    /// let x = DocumentFileSource::from(JsFileSource::js_module());
+    /// let y = DocumentFileSource::Unknown;
+    /// assert_eq!(x.or(y), JsFileSource::js_module().into());
     ///
-    /// let x = Language::Unknown;
-    /// let y = Language::JavaScript;
-    /// assert_eq!(x.or(y), Language::JavaScript);
+    /// let x = DocumentFileSource::Unknown;
+    /// let y = DocumentFileSource::from(JsFileSource::js_module());
+    /// assert_eq!(x.or(y), JsFileSource::js_module().into());
     ///
-    /// let x = Language::JavaScript;
-    /// let y = Language::Json;
-    /// assert_eq!(x.or(y), Language::JavaScript);
+    /// let x = DocumentFileSource::from(JsFileSource::js_module());
+    /// let y = DocumentFileSource::from(JsonFileSource::json());
+    /// assert_eq!(x.or(y), JsFileSource::js_module().into());
     ///
-    /// let x = Language::Unknown;
-    /// let y = Language::Unknown;
-    /// assert_eq!(x.or(y), Language::Unknown);
+    /// let x = DocumentFileSource::Unknown;
+    /// let y = DocumentFileSource::Unknown;
+    /// assert_eq!(x.or(y), DocumentFileSource::Unknown);
     /// ```
-    pub fn or(self, other: Language) -> Language {
-        if self != Language::Unknown {
+    pub fn or(self, other: DocumentFileSource) -> DocumentFileSource {
+        if self != DocumentFileSource::Unknown {
             self
         } else {
             other
@@ -183,70 +206,85 @@ impl Language {
     }
 
     pub const fn is_javascript_like(&self) -> bool {
-        matches!(
-            self,
-            Language::JavaScript
-                | Language::TypeScript
-                | Language::JavaScriptReact
-                | Language::TypeScriptReact
-                | Language::Astro
-                | Language::Vue
-        )
+        matches!(self, DocumentFileSource::Js(_))
     }
 
     pub const fn is_json_like(&self) -> bool {
-        matches!(self, Language::Json | Language::Jsonc)
+        matches!(self, DocumentFileSource::Json(_))
     }
 
     pub const fn is_css_like(&self) -> bool {
-        matches!(self, Language::Css)
+        matches!(self, DocumentFileSource::Css(_))
     }
 
-    pub fn as_js_file_source(&self) -> Option<JsFileSource> {
+    pub fn to_js_file_source(&self) -> Option<JsFileSource> {
         match self {
-            Language::JavaScript => Some(JsFileSource::js_module()),
-            Language::JavaScriptReact => Some(JsFileSource::jsx()),
-            Language::TypeScript => Some(JsFileSource::tsx()),
-            Language::TypeScriptReact => Some(JsFileSource::tsx()),
-            Language::Astro => Some(JsFileSource::ts()),
-            Language::Vue => Some(JsFileSource::ts()),
-            Language::Svelte => Some(JsFileSource::ts()),
-            Language::Json | Language::Jsonc | Language::Css | Language::Unknown => None,
+            DocumentFileSource::Js(file_source) => Some(*file_source),
+            DocumentFileSource::Json(_)
+            | DocumentFileSource::Css(_)
+            | DocumentFileSource::Unknown => None,
+        }
+    }
+
+    pub fn to_json_file_source(&self) -> Option<JsonFileSource> {
+        match self {
+            DocumentFileSource::Json(json) => Some(*json),
+            DocumentFileSource::Js(_)
+            | DocumentFileSource::Css(_)
+            | DocumentFileSource::Unknown => None,
+        }
+    }
+
+    pub fn to_css_file_source(&self) -> Option<CssFileSource> {
+        match self {
+            DocumentFileSource::Css(css) => Some(*css),
+            DocumentFileSource::Js(_)
+            | DocumentFileSource::Json(_)
+            | DocumentFileSource::Unknown => None,
         }
     }
 
     pub fn can_parse(path: &Path, content: &str) -> bool {
-        let language = Language::from_path(path);
-        match language {
-            Language::JavaScript
-            | Language::JavaScriptReact
-            | Language::TypeScript
-            | Language::TypeScriptReact
-            | Language::Json
-            | Language::Css
-            | Language::Jsonc => true,
-            Language::Astro => ASTRO_FENCE.is_match(content),
-            Language::Vue => VUE_FENCE.is_match(content),
-            Language::Svelte => SVELTE_FENCE.is_match(content),
-            Language::Unknown => false,
+        let file_source = DocumentFileSource::from_path(path);
+        match file_source {
+            DocumentFileSource::Js(js) => match js.as_embedding_kind() {
+                EmbeddingKind::Astro => ASTRO_FENCE.is_match(content),
+                EmbeddingKind::Vue => VUE_FENCE.is_match(content),
+                EmbeddingKind::Svelte => SVELTE_FENCE.is_match(content),
+                EmbeddingKind::None => true,
+            },
+            DocumentFileSource::Json(_) | DocumentFileSource::Css(_) => true,
+            DocumentFileSource::Unknown => false,
         }
     }
 }
 
-impl biome_console::fmt::Display for Language {
+impl biome_console::fmt::Display for DocumentFileSource {
     fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {
         match self {
-            Language::JavaScript => fmt.write_markup(markup! { "JavaScript" }),
-            Language::JavaScriptReact => fmt.write_markup(markup! { "JSX" }),
-            Language::TypeScript => fmt.write_markup(markup! { "TypeScript" }),
-            Language::TypeScriptReact => fmt.write_markup(markup! { "TSX" }),
-            Language::Json => fmt.write_markup(markup! { "JSON" }),
-            Language::Jsonc => fmt.write_markup(markup! { "JSONC" }),
-            Language::Css => fmt.write_markup(markup! { "CSS" }),
-            Language::Astro => fmt.write_markup(markup! { "Astro" }),
-            Language::Vue => fmt.write_markup(markup! { "Vue" }),
-            Language::Svelte => fmt.write_markup(markup! { "Svelte" }),
-            Language::Unknown => fmt.write_markup(markup! { "Unknown" }),
+            DocumentFileSource::Js(js) => {
+                let is_jsx = js.is_jsx();
+                if js.is_typescript() {
+                    if is_jsx {
+                        fmt.write_markup(markup! { "TSX" })
+                    } else {
+                        fmt.write_markup(markup! { "TypeScript" })
+                    }
+                } else if is_jsx {
+                    fmt.write_markup(markup! { "JSX" })
+                } else {
+                    fmt.write_markup(markup! { "JavaScript" })
+                }
+            }
+            DocumentFileSource::Json(json) => {
+                if json.is_jsonc() {
+                    fmt.write_markup(markup! { "JSONC" })
+                } else {
+                    fmt.write_markup(markup! { "JSON" })
+                }
+            }
+            DocumentFileSource::Css(_) => fmt.write_markup(markup! { "CSS" }),
+            DocumentFileSource::Unknown => fmt.write_markup(markup! { "Unknown" }),
         }
     }
 }
@@ -287,7 +325,7 @@ pub struct FixAllParams<'a> {
     pub(crate) should_format: bool,
     pub(crate) biome_path: &'a BiomePath,
     pub(crate) manifest: Option<PackageJson>,
-    pub(crate) language: Language,
+    pub(crate) document_file_source: DocumentFileSource,
 }
 
 #[derive(Default)]
@@ -302,10 +340,11 @@ pub struct Capabilities {
 #[derive(Clone)]
 pub struct ParseResult {
     pub(crate) any_parse: AnyParse,
-    pub(crate) language: Option<Language>,
+    pub(crate) language: Option<DocumentFileSource>,
 }
 
-type Parse = fn(&BiomePath, Language, &str, SettingsHandle, &mut NodeCache) -> ParseResult;
+type Parse =
+    fn(&BiomePath, DocumentFileSource, &str, SettingsHandle, &mut NodeCache) -> ParseResult;
 
 #[derive(Default)]
 pub struct ParserCapabilities {
@@ -315,7 +354,8 @@ pub struct ParserCapabilities {
 
 type DebugSyntaxTree = fn(&BiomePath, AnyParse) -> GetSyntaxTreeResult;
 type DebugControlFlow = fn(AnyParse, TextSize) -> String;
-type DebugFormatterIR = fn(&BiomePath, AnyParse, SettingsHandle) -> Result<String, WorkspaceError>;
+type DebugFormatterIR =
+    fn(&BiomePath, &DocumentFileSource, AnyParse, SettingsHandle) -> Result<String, WorkspaceError>;
 
 #[derive(Default)]
 pub struct DebugCapabilities {
@@ -330,7 +370,7 @@ pub struct DebugCapabilities {
 pub(crate) struct LintParams<'a> {
     pub(crate) parse: AnyParse,
     pub(crate) settings: SettingsHandle<'a>,
-    pub(crate) language: Language,
+    pub(crate) language: DocumentFileSource,
     pub(crate) max_diagnostics: u32,
     pub(crate) path: &'a BiomePath,
     pub(crate) categories: RuleCategories,
@@ -350,7 +390,7 @@ pub(crate) struct CodeActionsParams<'a> {
     pub(crate) settings: SettingsHandle<'a>,
     pub(crate) path: &'a BiomePath,
     pub(crate) manifest: Option<PackageJson>,
-    pub(crate) language: Language,
+    pub(crate) language: DocumentFileSource,
 }
 
 type Lint = fn(LintParams) -> LintResults;
@@ -373,11 +413,26 @@ pub struct AnalyzerCapabilities {
     pub(crate) organize_imports: Option<OrganizeImports>,
 }
 
-type Format = fn(&BiomePath, AnyParse, SettingsHandle) -> Result<Printed, WorkspaceError>;
-type FormatRange =
-    fn(&BiomePath, AnyParse, SettingsHandle, TextRange) -> Result<Printed, WorkspaceError>;
-type FormatOnType =
-    fn(&BiomePath, AnyParse, SettingsHandle, TextSize) -> Result<Printed, WorkspaceError>;
+type Format = fn(
+    &BiomePath,
+    &DocumentFileSource,
+    AnyParse,
+    SettingsHandle,
+) -> Result<Printed, WorkspaceError>;
+type FormatRange = fn(
+    &BiomePath,
+    &DocumentFileSource,
+    AnyParse,
+    SettingsHandle,
+    TextRange,
+) -> Result<Printed, WorkspaceError>;
+type FormatOnType = fn(
+    &BiomePath,
+    &DocumentFileSource,
+    AnyParse,
+    SettingsHandle,
+    TextSize,
+) -> Result<Printed, WorkspaceError>;
 
 #[derive(Default)]
 pub(crate) struct FormatterCapabilities {
@@ -391,10 +446,6 @@ pub(crate) struct FormatterCapabilities {
 
 /// Main trait to use to add a new language to Biome
 pub(crate) trait ExtensionHandler {
-    /// The language of the file. It can be a super language.
-    /// For example, a ".js" file can have [Language::Ts]
-    fn language(&self) -> Language;
-
     /// MIME types used to identify a certain language
     fn mime(&self) -> Mime;
 
@@ -445,15 +496,17 @@ impl Features {
     pub(crate) fn get_capabilities(
         &self,
         biome_path: &BiomePath,
-        language_hint: Language,
+        language_hint: DocumentFileSource,
     ) -> Capabilities {
-        match Language::from_path_and_known_filename(biome_path).or(language_hint) {
-            Language::JavaScript
-            | Language::JavaScriptReact
-            | Language::TypeScript
-            | Language::TypeScriptReact => self.js.capabilities(),
-            Language::Json | Language::Jsonc => self.json.capabilities(),
-            Language::Css => {
+        match DocumentFileSource::from_path_and_known_filename(biome_path).or(language_hint) {
+            DocumentFileSource::Js(source) => match source.as_embedding_kind() {
+                EmbeddingKind::Astro => self.astro.capabilities(),
+                EmbeddingKind::Vue => self.vue.capabilities(),
+                EmbeddingKind::Svelte => self.svelte.capabilities(),
+                EmbeddingKind::None => self.js.capabilities(),
+            },
+            DocumentFileSource::Json(_) => self.json.capabilities(),
+            DocumentFileSource::Css(_) => {
                 // TODO: change this when we are ready to handle CSS files
                 if can_format_css_yet() {
                     self.css.capabilities()
@@ -461,10 +514,7 @@ impl Features {
                     self.unknown.capabilities()
                 }
             }
-            Language::Astro => self.astro.capabilities(),
-            Language::Vue => self.vue.capabilities(),
-            Language::Svelte => self.svelte.capabilities(),
-            Language::Unknown => self.unknown.capabilities(),
+            DocumentFileSource::Unknown => self.unknown.capabilities(),
         }
     }
 }
@@ -491,7 +541,7 @@ pub(crate) fn is_diagnostic_error(
 
 #[test]
 fn test_order() {
-    for items in Language::KNOWN_FILES_AS_JSONC.windows(2) {
+    for items in DocumentFileSource::KNOWN_FILES_AS_JSONC.windows(2) {
         assert!(items[0] < items[1], "{} < {}", items[0], items[1]);
     }
 }
diff --git a/crates/biome_service/src/file_handlers/svelte.rs b/crates/biome_service/src/file_handlers/svelte.rs
index b8c17d19b1bc..97d50654d116 100644
--- a/crates/biome_service/src/file_handlers/svelte.rs
+++ b/crates/biome_service/src/file_handlers/svelte.rs
@@ -1,10 +1,12 @@
 use crate::file_handlers::{
     javascript, AnalyzerCapabilities, Capabilities, CodeActionsParams, DebugCapabilities,
-    ExtensionHandler, FixAllParams, FormatterCapabilities, Language, LintParams, LintResults, Mime,
+    ExtensionHandler, FixAllParams, FormatterCapabilities, LintParams, LintResults, Mime,
     ParseResult, ParserCapabilities,
 };
 use crate::settings::SettingsHandle;
-use crate::workspace::{FixFileResult, OrganizeImportsResult, PullActionsResult};
+use crate::workspace::{
+    DocumentFileSource, FixFileResult, OrganizeImportsResult, PullActionsResult,
+};
 use crate::WorkspaceError;
 use biome_formatter::Printed;
 use biome_fs::BiomePath;
@@ -83,10 +85,6 @@ impl SvelteFileHandler {
 }
 
 impl ExtensionHandler for SvelteFileHandler {
-    fn language(&self) -> Language {
-        Language::TypeScript
-    }
-
     fn mime(&self) -> Mime {
         Mime::Javascript
     }
@@ -117,7 +115,7 @@ impl ExtensionHandler for SvelteFileHandler {
 
 fn parse(
     _rome_path: &BiomePath,
-    _language_hint: Language,
+    _file_source: DocumentFileSource,
     text: &str,
     _settings: SettingsHandle,
     cache: &mut NodeCache,
@@ -149,9 +147,9 @@ fn parse(
             diagnostics,
         ),
         language: Some(if language.is_typescript() {
-            Language::TypeScript
+            JsFileSource::ts().into()
         } else {
-            Language::JavaScript
+            JsFileSource::js_module().into()
         }),
     }
 }
@@ -159,28 +157,30 @@ fn parse(
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 fn format(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format(biome_path, parse, settings)
+    javascript::format(biome_path, document_file_source, parse, settings)
 }
-
 pub(crate) fn format_range(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_range(biome_path, parse, settings, range)
+    javascript::format_range(biome_path, document_file_source, parse, settings, range)
 }
 
 pub(crate) fn format_on_type(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_on_type(biome_path, parse, settings, offset)
+    javascript::format_on_type(biome_path, document_file_source, parse, settings, offset)
 }
 
 pub(crate) fn lint(params: LintParams) -> LintResults {
diff --git a/crates/biome_service/src/file_handlers/unknown.rs b/crates/biome_service/src/file_handlers/unknown.rs
index defc74666d17..c1ce8cbf9789 100644
--- a/crates/biome_service/src/file_handlers/unknown.rs
+++ b/crates/biome_service/src/file_handlers/unknown.rs
@@ -4,10 +4,6 @@ use super::ExtensionHandler;
 pub(crate) struct UnknownFileHandler {}
 
 impl ExtensionHandler for UnknownFileHandler {
-    fn language(&self) -> super::Language {
-        super::Language::Unknown
-    }
-
     fn mime(&self) -> super::Mime {
         super::Mime::Text
     }
diff --git a/crates/biome_service/src/file_handlers/vue.rs b/crates/biome_service/src/file_handlers/vue.rs
index c87714630324..ff38fc40f857 100644
--- a/crates/biome_service/src/file_handlers/vue.rs
+++ b/crates/biome_service/src/file_handlers/vue.rs
@@ -1,10 +1,12 @@
 use crate::file_handlers::{
     javascript, AnalyzerCapabilities, Capabilities, CodeActionsParams, DebugCapabilities,
-    ExtensionHandler, FixAllParams, FormatterCapabilities, Language, LintParams, LintResults, Mime,
+    ExtensionHandler, FixAllParams, FormatterCapabilities, LintParams, LintResults, Mime,
     ParseResult, ParserCapabilities,
 };
 use crate::settings::SettingsHandle;
-use crate::workspace::{FixFileResult, OrganizeImportsResult, PullActionsResult};
+use crate::workspace::{
+    DocumentFileSource, FixFileResult, OrganizeImportsResult, PullActionsResult,
+};
 use crate::WorkspaceError;
 use biome_formatter::Printed;
 use biome_fs::BiomePath;
@@ -83,10 +85,6 @@ impl VueFileHandler {
 }
 
 impl ExtensionHandler for VueFileHandler {
-    fn language(&self) -> Language {
-        Language::TypeScript
-    }
-
     fn mime(&self) -> Mime {
         Mime::Javascript
     }
@@ -117,7 +115,7 @@ impl ExtensionHandler for VueFileHandler {
 
 fn parse(
     _rome_path: &BiomePath,
-    _language_hint: Language,
+    _file_source: DocumentFileSource,
     text: &str,
     _settings: SettingsHandle,
     cache: &mut NodeCache,
@@ -138,9 +136,9 @@ fn parse(
             diagnostics,
         ),
         language: Some(if language.is_typescript() {
-            Language::TypeScript
+            JsFileSource::ts().into()
         } else {
-            Language::JavaScript
+            JsFileSource::js_module().into()
         }),
     }
 }
@@ -148,28 +146,31 @@ fn parse(
 #[tracing::instrument(level = "trace", skip(parse, settings))]
 fn format(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format(biome_path, parse, settings)
+    javascript::format(biome_path, document_file_source, parse, settings)
 }
 
 pub(crate) fn format_range(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     range: TextRange,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_range(biome_path, parse, settings, range)
+    javascript::format_range(biome_path, document_file_source, parse, settings, range)
 }
 
 pub(crate) fn format_on_type(
     biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
     parse: AnyParse,
     settings: SettingsHandle,
     offset: TextSize,
 ) -> Result<Printed, WorkspaceError> {
-    javascript::format_on_type(biome_path, parse, settings, offset)
+    javascript::format_on_type(biome_path, document_file_source, parse, settings, offset)
 }
 
 pub(crate) fn lint(params: LintParams) -> LintResults {
diff --git a/crates/biome_service/src/settings.rs b/crates/biome_service/src/settings.rs
index 5a1b50b480a4..81696616e0ca 100644
--- a/crates/biome_service/src/settings.rs
+++ b/crates/biome_service/src/settings.rs
@@ -6,6 +6,7 @@ use crate::configuration::{
     push_to_analyzer_rules, to_override_settings, CssConfiguration, FormatterConfiguration,
     JavascriptConfiguration, JsonConfiguration, LinterConfiguration, PartialConfiguration,
 };
+use crate::workspace::DocumentFileSource;
 use crate::{
     configuration::FilesConfiguration, ConfigurationDiagnostic, Matcher, Rules, WorkspaceError,
 };
@@ -391,6 +392,7 @@ pub trait Language: biome_rowan::Language {
         overrides: &OverrideSettings,
         language: &Self::FormatterSettings,
         path: &BiomePath,
+        file_source: &DocumentFileSource,
     ) -> Self::FormatOptions;
 }
 
@@ -502,7 +504,11 @@ impl<'a> AsRef<WorkspaceSettings> for SettingsHandle<'a> {
 
 impl<'a> SettingsHandle<'a> {
     /// Resolve the formatting context for the given language
-    pub(crate) fn format_options<L>(self, path: &BiomePath) -> L::FormatOptions
+    pub(crate) fn format_options<L>(
+        self,
+        path: &BiomePath,
+        file_source: &DocumentFileSource,
+    ) -> L::FormatOptions
     where
         L: Language,
     {
@@ -511,6 +517,7 @@ impl<'a> SettingsHandle<'a> {
             &self.inner.override_settings,
             &L::lookup_settings(&self.inner.languages).formatter,
             path,
+            file_source,
         )
     }
 }
diff --git a/crates/biome_service/src/workspace.rs b/crates/biome_service/src/workspace.rs
index e59b5db7d90f..ef96c513cb13 100644
--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@ -70,7 +70,7 @@ use tracing::debug;
 
 pub use self::client::{TransportRequest, WorkspaceClient, WorkspaceTransport};
 use crate::configuration::PartialConfiguration;
-pub use crate::file_handlers::Language;
+pub use crate::file_handlers::DocumentFileSource;
 use crate::settings::WorkspaceSettings;
 
 mod client;
@@ -149,17 +149,17 @@ impl FileFeaturesResult {
     pub(crate) fn with_settings_and_language(
         mut self,
         settings: &WorkspaceSettings,
-        language: &Language,
+        file_source: &DocumentFileSource,
         path: &Path,
     ) -> Self {
         let formatter_disabled =
             if let Some(disabled) = settings.override_settings.formatter_disabled(path) {
                 disabled
-            } else if language.is_javascript_like() {
+            } else if file_source.is_javascript_like() {
                 !settings.formatter().enabled || settings.javascript_formatter_disabled()
-            } else if language.is_json_like() {
+            } else if file_source.is_json_like() {
                 !settings.formatter().enabled || settings.json_formatter_disabled()
-            } else if language.is_css_like() {
+            } else if file_source.is_css_like() {
                 !can_format_css_yet()
                     || !settings.formatter().enabled
                     || settings.css_formatter_disabled()
@@ -416,7 +416,7 @@ pub struct OpenFileParams {
     pub content: String,
     pub version: i32,
     #[serde(default)]
-    pub language_hint: Language,
+    pub document_file_source: DocumentFileSource,
 }
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index ac2e9eb315a2..8a3176aed216 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -6,7 +6,7 @@ use super::{
     SupportsFeatureParams, UpdateProjectParams, UpdateSettingsParams,
 };
 use crate::file_handlers::{
-    Capabilities, CodeActionsParams, FixAllParams, Language, LintParams, ParseResult,
+    Capabilities, CodeActionsParams, DocumentFileSource, FixAllParams, LintParams, ParseResult,
 };
 use crate::workspace::{
     FileFeaturesResult, GetFileContentParams, IsPathIgnoredParams, OrganizeImportsParams,
@@ -24,10 +24,12 @@ use biome_diagnostics::{
 use biome_formatter::Printed;
 use biome_fs::{BiomePath, ConfigName};
 use biome_json_parser::{parse_json_with_cache, JsonParserOptions};
+use biome_json_syntax::JsonFileSource;
 use biome_parser::AnyParse;
 use biome_project::NodeJsProject;
 use biome_rowan::NodeCache;
 use dashmap::{mapref::entry::Entry, DashMap};
+use indexmap::IndexSet;
 use std::borrow::Borrow;
 use std::ffi::OsStr;
 use std::path::Path;
@@ -49,6 +51,8 @@ pub(super) struct WorkspaceServer {
     manifests: DashMap<BiomePath, NodeJsProject>,
     /// The current focused project
     current_project_path: RwLock<Option<BiomePath>>,
+    /// Stores the document sources used across the workspace
+    file_sources: RwLock<IndexSet<DocumentFileSource>>,
 }
 
 /// The `Workspace` object is long-lived, so we want it to be able to cross
@@ -63,7 +67,9 @@ impl RefUnwindSafe for WorkspaceServer {}
 pub(crate) struct Document {
     pub(crate) content: String,
     pub(crate) version: i32,
-    pub(crate) language_hint: Language,
+    /// The index of where the original file source is saved
+    /// Use `WorkspaceServer#file_sources` to retrieve the file source that belongs to the document.
+    pub(crate) file_source_index: usize,
     node_cache: NodeCache,
 }
 
@@ -82,6 +88,7 @@ impl WorkspaceServer {
             file_features: DashMap::default(),
             manifests: DashMap::default(),
             current_project_path: RwLock::default(),
+            file_sources: RwLock::default(),
         }
     }
 
@@ -91,18 +98,21 @@ impl WorkspaceServer {
 
     /// Get the supported capabilities for a given file path
     fn get_file_capabilities(&self, path: &BiomePath) -> Capabilities {
-        let language = self.get_language(path);
+        let language = self.get_file_source(path);
 
         debug!("File capabilities: {:?} {:?}", &language, &path);
         self.features.get_capabilities(path, language)
     }
 
     /// Retrieves the supported language of a file
-    fn get_language(&self, path: &BiomePath) -> Language {
+    fn get_file_source(&self, path: &BiomePath) -> DocumentFileSource {
         self.documents
             .get(path)
-            .map(|doc| doc.language_hint)
-            .unwrap_or_default()
+            .map(|doc| doc.file_source_index)
+            .and_then(|index| self.file_sources.read().unwrap().get_index(index).copied())
+            .unwrap_or(
+                DocumentFileSource::from_path(path)
+            )
     }
 
     /// Return an error factory function for unsupported features at a given path
@@ -112,13 +122,9 @@ impl WorkspaceServer {
         // feature_name: &'a str,
     ) -> impl FnOnce() -> WorkspaceError + 'a {
         move || {
-            let language_hint = self
-                .documents
-                .get(path)
-                .map(|doc| doc.language_hint)
-                .unwrap_or_default();
+            let file_source = self.get_file_source(path);
 
-            let language = Language::from_path_and_known_filename(path).or(language_hint);
+            let language = DocumentFileSource::from_path_and_known_filename(path).or(file_source);
             WorkspaceError::source_file_not_supported(
                 language,
                 path.clone().display().to_string(),
@@ -203,9 +209,13 @@ impl WorkspaceServer {
                 }
 
                 let settings = self.settings();
+                let mut file_sources = self.file_sources.write().unwrap();
+                let Some(file_source) = file_sources.get_index(document.file_source_index) else {
+                    return Err(WorkspaceError::not_found());
+                };
                 let parsed = parse(
                     biome_path,
-                    document.language_hint,
+                    *file_source,
                     document.content.as_str(),
                     settings,
                     &mut document.node_cache,
@@ -215,7 +225,8 @@ impl WorkspaceServer {
                     any_parse,
                 } = parsed;
                 if let Some(language) = language {
-                    document.language_hint = language
+                    let (index, _) = file_sources.insert_full(language);
+                    document.file_source_index = index;
                 }
                 Ok(entry.insert(any_parse).clone())
             }
@@ -301,7 +312,7 @@ impl Workspace for WorkspaceServer {
             }
             Entry::Vacant(entry) => {
                 let capabilities = self.get_file_capabilities(&params.path);
-                let language = Language::from_path_and_known_filename(&params.path);
+                let language = DocumentFileSource::from_path_and_known_filename(&params.path);
                 let path = params.path.as_path();
                 let settings = self.settings.read().unwrap();
                 let mut file_features = FileFeaturesResult::new();
@@ -311,8 +322,8 @@ impl Workspace for WorkspaceServer {
                     .with_settings_and_language(&settings, &language, path);
 
                 if settings.files.ignore_unknown
-                    && language == Language::Unknown
-                    && self.get_language(&params.path) == Language::Unknown
+                    && language == DocumentFileSource::Unknown
+                    && self.get_file_source(&params.path) == DocumentFileSource::Unknown
                 {
                     file_features.ignore_not_supported();
                 } else if file_name == Some(ConfigName::biome_json())
@@ -367,27 +378,31 @@ impl Workspace for WorkspaceServer {
 
     /// Add a new file to the workspace
     fn open_file(&self, params: OpenFileParams) -> Result<(), WorkspaceError> {
+        let mut file_sources = self.file_sources.write().unwrap();
+        let (index, _) = file_sources.insert_full(params.document_file_source);
         self.syntax.remove(&params.path);
         self.documents.insert(
             params.path,
             Document {
                 content: params.content,
                 version: params.version,
-                language_hint: params.language_hint,
                 node_cache: NodeCache::default(),
+                file_source_index: index,
             },
         );
         Ok(())
     }
 
     fn open_project(&self, params: OpenProjectParams) -> Result<(), WorkspaceError> {
+        let mut file_sources = self.file_sources.write().unwrap();
+        let (index, _) = file_sources.insert_full(JsonFileSource::json().into());
         self.syntax.remove(&params.path);
         self.documents.insert(
             params.path,
             Document {
                 content: params.content,
                 version: params.version,
-                language_hint: Language::Json,
+                file_source_index: index,
                 node_cache: NodeCache::default(),
             },
         );
@@ -445,8 +460,9 @@ impl Workspace for WorkspaceServer {
         if !settings.as_ref().formatter().format_with_errors && parse.has_errors() {
             return Err(WorkspaceError::format_with_errors_disabled());
         }
+        let document_file_source = self.get_file_source(&params.path);
 
-        debug_formatter_ir(&params.path, parse, settings)
+        debug_formatter_ir(&params.path, &document_file_source, parse, settings)
     }
 
     fn get_file_content(&self, params: GetFileContentParams) -> Result<String, WorkspaceError> {
@@ -498,7 +514,7 @@ impl Workspace for WorkspaceServer {
                         settings: self.settings(),
                         max_diagnostics: params.max_diagnostics as u32,
                         path: &params.path,
-                        language: self.get_language(&params.path),
+                        language: self.get_file_source(&params.path),
                         categories: params.categories,
                         manifest,
                     });
@@ -547,7 +563,7 @@ impl Workspace for WorkspaceServer {
         let settings = self.settings.read().unwrap();
         let rules = settings.linter().rules.as_ref();
         let manifest = self.get_current_project()?.map(|pr| pr.manifest);
-        let language = self.get_language(&params.path);
+        let language = self.get_file_source(&params.path);
         Ok(code_actions(CodeActionsParams {
             parse,
             range: params.range,
@@ -573,8 +589,8 @@ impl Workspace for WorkspaceServer {
         if !settings.as_ref().formatter().format_with_errors && parse.has_errors() {
             return Err(WorkspaceError::format_with_errors_disabled());
         }
-
-        format(&params.path, parse, settings)
+        let document_file_source = self.get_file_source(&params.path);
+        format(&params.path, &document_file_source, parse, settings)
     }
 
     fn format_range(&self, params: FormatRangeParams) -> Result<Printed, WorkspaceError> {
@@ -589,8 +605,14 @@ impl Workspace for WorkspaceServer {
         if !settings.as_ref().formatter().format_with_errors && parse.has_errors() {
             return Err(WorkspaceError::format_with_errors_disabled());
         }
-
-        format_range(&params.path, parse, settings, params.range)
+        let document_file_source = self.get_file_source(&params.path);
+        format_range(
+            &params.path,
+            &document_file_source,
+            parse,
+            settings,
+            params.range,
+        )
     }
 
     fn format_on_type(&self, params: FormatOnTypeParams) -> Result<Printed, WorkspaceError> {
@@ -605,8 +627,15 @@ impl Workspace for WorkspaceServer {
         if !settings.as_ref().formatter().format_with_errors && parse.has_errors() {
             return Err(WorkspaceError::format_with_errors_disabled());
         }
+        let document_file_source = self.get_file_source(&params.path);
 
-        format_on_type(&params.path, parse, settings, params.offset)
+        format_on_type(
+            &params.path,
+            &document_file_source,
+            parse,
+            settings,
+            params.offset,
+        )
     }
 
     fn fix_file(&self, params: super::FixFileParams) -> Result<FixFileResult, WorkspaceError> {
@@ -628,7 +657,7 @@ impl Workspace for WorkspaceServer {
             .collect::<Vec<_>>();
         let filter = AnalysisFilter::from_enabled_rules(Some(rule_filter_list.as_slice()));
         let manifest = self.get_current_project()?.map(|pr| pr.manifest);
-        let language = self.get_language(&params.path);
+        let language = self.get_file_source(&params.path);
         fix_all(FixAllParams {
             parse,
             rules: rules.as_ref().map(|x| x.borrow()),
@@ -638,7 +667,7 @@ impl Workspace for WorkspaceServer {
             should_format: params.should_format,
             biome_path: &params.path,
             manifest,
-            language,
+            document_file_source: language,
         })
     }
 
diff --git a/crates/biome_service/tests/workspace.rs b/crates/biome_service/tests/workspace.rs
index 2cca85c212a3..b7b68af8366f 100644
--- a/crates/biome_service/tests/workspace.rs
+++ b/crates/biome_service/tests/workspace.rs
@@ -1,6 +1,7 @@
 use biome_fs::BiomePath;
-use biome_js_syntax::TextSize;
-use biome_service::workspace::{server, FileGuard, Language, OpenFileParams};
+use biome_js_syntax::{JsFileSource, TextSize};
+use biome_service::file_handlers::DocumentFileSource;
+use biome_service::workspace::{server, FileGuard, OpenFileParams};
 
 #[test]
 fn debug_control_flow() {
@@ -18,7 +19,7 @@ fn debug_control_flow() {
             path: BiomePath::new("file.js"),
             content: SOURCE.into(),
             version: 0,
-            language_hint: Language::JavaScript,
+            document_file_source: DocumentFileSource::from(JsFileSource::default()),
         },
     )
     .unwrap();
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index 36e9d09e594b..f3159c1435a1 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -1661,25 +1661,54 @@ export interface OpenProjectParams {
 }
 export interface OpenFileParams {
 	content: string;
-	language_hint?: Language;
+	document_file_source?: DocumentFileSource;
 	path: BiomePath;
 	version: number;
 }
-/**
- * Supported languages by Biome
- */
+export type DocumentFileSource =
+	| "Unknown"
+	| { Js: JsFileSource }
+	| { Json: JsonFileSource }
+	| { Css: CssFileSource };
+export interface JsFileSource {
+	/**
+	 * Used to mark if the source is being used for an Astro, Svelte or Vue file
+	 */
+	embedding_kind: EmbeddingKind;
+	language: Language;
+	module_kind: ModuleKind;
+	variant: LanguageVariant;
+	version: LanguageVersion;
+}
+export interface JsonFileSource {
+	allow_trailing_comma: boolean;
+	variant: JsonVariant;
+}
+export interface CssFileSource {
+	variant: CssVariant;
+}
+export type EmbeddingKind = "Astro" | "Vue" | "Svelte" | "None";
 export type Language =
-	| "Astro"
-	| "Vue"
-	| "Svelte"
 	| "JavaScript"
-	| "JavaScriptReact"
-	| "TypeScript"
-	| "TypeScriptReact"
-	| "Json"
-	| "Jsonc"
-	| "Css"
-	| "Unknown";
+	| { TypeScript: { definition_file: boolean } };
+/**
+ * Is the source file an ECMAScript Module or Script. Changes the parsing semantic.
+ */
+export type ModuleKind = "Script" | "Module";
+export type LanguageVariant = "Standard" | "StandardRestricted" | "Jsx";
+/**
+	* Enum of the different ECMAScript standard versions. The versions are ordered in increasing order; The newest version comes last.
+
+Defaults to the latest stable ECMAScript standard. 
+	 */
+export type LanguageVersion = "ES2022" | "ESNext";
+export type JsonVariant = "Standard" | "Jsonc";
+/**
+	* The style of CSS contained in the file.
+
+Currently, Biome only supports plain CSS, and aims to be compatible with the latest Recommendation level standards. 
+	 */
+export type CssVariant = "Standard";
 export interface ChangeFileParams {
 	content: string;
 	path: BiomePath;
diff --git a/packages/@biomejs/js-api/tsconfig.json b/packages/@biomejs/js-api/tsconfig.json
index 78fe443d7bf5..426b5b01a20f 100644
--- a/packages/@biomejs/js-api/tsconfig.json
+++ b/packages/@biomejs/js-api/tsconfig.json
@@ -12,8 +12,8 @@
 		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
 		"strict": true /* Enable all strict type-checking options. */,
 		"skipLibCheck": true /* Skip type checking all .d.ts files. */,
-		"lib": ["ES2021"]
+		"lib": ["ES2021"],
 	},
 	"exclude": ["./tests", "./dist"],
-	"include": ["./src"]
+	"include": ["./src"],
 }
diff --git a/website/src/content/docs/internals/changelog.md b/website/src/content/docs/internals/changelog.md
index cc031b853094..dacc86f5e5bc 100644
--- a/website/src/content/docs/internals/changelog.md
+++ b/website/src/content/docs/internals/changelog.md
@@ -39,10 +39,10 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
   ```diff
   <script setup lang="ts">
-     - import Button from "./components/Button.vue";
-     - import * as vueUse from "vue-use";
-     + import * as vueUse from "vue-use";
-     + import Button from "./components/Button.vue";
+  - import Button from "./components/Button.vue";
+  - import * as vueUse from "vue-use";
+  + import * as vueUse from "vue-use";
+  + import Button from "./components/Button.vue";
   </script/>
 
   <template></template>
@@ -53,10 +53,10 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
   ```diff
   <script setup lang="ts">
-    - import Button from "./components/Button.svelte";
-    - import * as svelteUse from "svelte-use";
-    + import * as svelteUse from "svelte-use";
-    + import Button from "./components/Button.svelte";
+  - import Button from "./components/Button.svelte";
+  - import * as svelteUse from "svelte-use";
+  + import * as svelteUse from "svelte-use";
+  + import Button from "./components/Button.svelte";
   </script/>
 
   <div></div>
@@ -302,6 +302,7 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
 - Fix [#1218](https://github.com/biomejs/biome/issues/1218), by correctly preserving empty lines in member chains.
   Contributed by @ah-yu
+- Fix [#1659](https://github.com/biomejs/biome/issues/1659) and [#1662](https://github.com/biomejs/biome/issues/1662), by correctly taking into account the leading comma inside the formatter options. Contributed by @ematipico
 
 ### JavaScript APIs
 
diff --git a/website/tsconfig.json b/website/tsconfig.json
index 75ebcb44b8f0..852006664fe2 100644
--- a/website/tsconfig.json
+++ b/website/tsconfig.json
@@ -5,9 +5,9 @@
 		"jsx": "react-jsx",
 		"baseUrl": ".",
 		"paths": {
-		"@/*": ["src/*"],
-	}
+			"@/*": ["src/*"],
+		},
 	},
 	"extends": "astro/tsconfigs/strictest",
-	"include": ["./src"]
+	"include": ["./src"],
 }