diff --git a/.changeset/silly-oranges-worry.md b/.changeset/silly-oranges-worry.md
new file mode 100644
index 0000000..da16fa5
--- /dev/null
+++ b/.changeset/silly-oranges-worry.md
@@ -0,0 +1,5 @@
+---
+"codemirror-json-schema": minor
+---
+
+Added YAML support, switched back to markdown for messages, provide markdown rendering, and fix some autocompletion issues
diff --git a/dev/index.html b/dev/index.html
index eecd032..f81ced3 100644
--- a/dev/index.html
+++ b/dev/index.html
@@ -29,6 +29,7 @@
     <style>
       :root {
         --bg-color: #282c34;
+        --fbc-light-gray: #f0f0f4;
       }
       h1,
       h2,
@@ -66,10 +67,15 @@
       }
       .cm6-json-schema-hover,
       .cm-editor .cm-diagnostic-error {
+        font-size: 12px;
         padding: 0.5rem;
       }
       .cm6-json-schema-hover--description {
         margin-bottom: 0.5rem;
+        max-width: 600px;
+      }
+      .cm6-json-schema-hover--code-wrapper {
+        border-top: 1px solid #888;
       }
       .grid-row {
         display: grid;
@@ -110,6 +116,10 @@ <h2><code>package.json</code> demo</h2>
         <h2><code>package.json5</code> demo</h2>
         <div id="editor-json5"></div>
       </div>
+      <div>
+        <h2><code>package.yaml</code> demo</h2>
+        <div id="editor-yaml"></div>
+      </div>
     </div>
     <script type="module" src="./index.ts"></script>
   </body>
diff --git a/dev/index.ts b/dev/index.ts
index cbb68bc..5717875 100644
--- a/dev/index.ts
+++ b/dev/index.ts
@@ -29,7 +29,7 @@ import {
 import { JSONSchema7 } from "json-schema";
 
 // sample data
-import { jsonText, json5Text } from "./sample-text";
+import { jsonText, json5Text, yamlText } from "./sample-text";
 import packageJsonSchema from "./package.schema.json";
 
 // json4
@@ -38,6 +38,8 @@ import { jsonSchema, updateSchema } from "../src/index";
 // json5
 import { json5Schema } from "../src/json5";
 
+import { yamlSchema } from "../src/yaml";
+
 const schema = packageJsonSchema as JSONSchema7;
 
 /**
@@ -99,9 +101,23 @@ const editor2 = new EditorView({
   parent: document.querySelector("#editor-json5")!,
 });
 
+/**
+ * yaml!
+ */
+const yamlState = EditorState.create({
+  doc: yamlText,
+  extensions: [commonExtensions, yamlSchema(schema)],
+});
+
+const editor3 = new EditorView({
+  state: yamlState,
+  parent: document.querySelector("#editor-yaml")!,
+});
+
 const handleSchemaChange = (newSchema: JSONSchema7) => {
   updateSchema(editor1, newSchema);
   updateSchema(editor2, newSchema);
+  updateSchema(editor3, newSchema);
 };
 
 // new EditorState.fi(editor1, editor2);
diff --git a/dev/sample-text.ts b/dev/sample-text.ts
index da8261b..1294f88 100644
--- a/dev/sample-text.ts
+++ b/dev/sample-text.ts
@@ -19,3 +19,12 @@ export const json5Text = `{
   }],
   'type': '',
 }`;
+
+export const yamlText = `name: lexunicon
+version: 0.0.0
+description: A lexicon for the unicon programming language
+contributors:
+  - email: email
+    url: h
+type: ''
+`;
diff --git a/package.json b/package.json
index 521c599..d1db0b9 100644
--- a/package.json
+++ b/package.json
@@ -42,21 +42,30 @@
       "default": "./cjs/index.js"
     },
     "./json5": {
-      "import": "./dist/json5.js",
-      "types": "./dist/json5.d.ts",
-      "require": "./cjs/json5.js",
-      "default": "./cjs/json5.js"
+      "import": "./dist/json5/index.js",
+      "types": "./dist/json5/index.d.ts",
+      "require": "./cjs/json5/index.js",
+      "default": "./cjs/json5/index.js"
+    },
+    "./yaml": {
+      "import": "./dist/yaml/index.js",
+      "types": "./dist/yaml/index.d.ts",
+      "require": "./cjs/yaml/index.js",
+      "default": "./cjs/yaml/index.js"
     }
   },
   "repository": "github:acao/codemirror-json-schema",
   "homepage": "https://codemirror-json-schema.netlify.app/",
   "dependencies": {
     "@changesets/changelog-github": "^0.4.8",
+    "@codemirror/lang-yaml": "^6.0.0",
     "@sagold/json-pointer": "^5.1.1",
     "@types/json-schema": "^7.0.12",
     "@types/node": "^20.4.2",
     "json-schema": "^0.4.0",
-    "json-schema-library": "^9.1.2"
+    "json-schema-library": "^9.1.2",
+    "markdown-it": "^14.0.0",
+    "yaml": "^2.3.4"
   },
   "optionalDependencies": {
     "@codemirror/lang-json": "^6.0.1",
@@ -82,6 +91,7 @@
     "@codemirror/view": "^6.14.1",
     "@evilmartians/lefthook": "^1.4.6",
     "@lezer/common": "^1.0.3",
+    "@types/markdown-it": "^13.0.7",
     "@vitest/coverage-v8": "^0.34.6",
     "codemirror": "^6.0.1",
     "codemirror-json5": "^1.0.3",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 16255d2..f57e211 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,9 @@ dependencies:
   '@changesets/changelog-github':
     specifier: ^0.4.8
     version: 0.4.8
+  '@codemirror/lang-yaml':
+    specifier: ^6.0.0
+    version: 6.0.0(@codemirror/view@6.14.1)
   '@sagold/json-pointer':
     specifier: ^5.1.1
     version: 5.1.1
@@ -23,6 +26,12 @@ dependencies:
   json-schema-library:
     specifier: ^9.1.2
     version: 9.1.2
+  markdown-it:
+    specifier: ^14.0.0
+    version: 14.0.0
+  yaml:
+    specifier: ^2.3.4
+    version: 2.3.4
 
 optionalDependencies:
   '@codemirror/lang-json':
@@ -69,6 +78,9 @@ devDependencies:
   '@lezer/common':
     specifier: ^1.0.3
     version: 1.0.3
+  '@types/markdown-it':
+    specifier: ^13.0.7
+    version: 13.0.7
   '@vitest/coverage-v8':
     specifier: ^0.34.6
     version: 0.34.6(vitest@0.34.6)
@@ -365,6 +377,20 @@ packages:
       '@lezer/common': 1.0.3
     dev: true
 
+  /@codemirror/autocomplete@6.8.1(@codemirror/language@6.8.0)(@codemirror/state@6.2.1)(@codemirror/view@6.14.1)(@lezer/common@1.2.1):
+    resolution: {integrity: sha512-HpphvDcTdOx+9R3eUw9hZK9JA77jlaBF0kOt2McbyfvY0rX9pnMoO8rkkZc0GzSbzhIY4m5xJ0uHHgjfqHNmXQ==}
+    peerDependencies:
+      '@codemirror/language': ^6.0.0
+      '@codemirror/state': ^6.0.0
+      '@codemirror/view': ^6.0.0
+      '@lezer/common': ^1.0.0
+    dependencies:
+      '@codemirror/language': 6.8.0
+      '@codemirror/state': 6.2.1
+      '@codemirror/view': 6.14.1
+      '@lezer/common': 1.2.1
+    dev: false
+
   /@codemirror/basic-setup@0.20.0:
     resolution: {integrity: sha512-W/ERKMLErWkrVLyP5I8Yh8PXl4r+WFNkdYVSzkXYPQv2RMPSkWpr2BgggiSJ8AHF/q3GuApncDD8I4BZz65fyg==}
     deprecated: In version 6.0, this package has been renamed to just 'codemirror'
@@ -405,6 +431,18 @@ packages:
     dev: false
     optional: true
 
+  /@codemirror/lang-yaml@6.0.0(@codemirror/view@6.14.1):
+    resolution: {integrity: sha512-fVPapdX1oYr5HMC5bou1MHscGnNCvOHuhUW6C+V2gfIeIRcughvVfznV0OuUyHy0AdXoBCjOehjzFcmLRumu2Q==}
+    dependencies:
+      '@codemirror/autocomplete': 6.8.1(@codemirror/language@6.8.0)(@codemirror/state@6.2.1)(@codemirror/view@6.14.1)(@lezer/common@1.2.1)
+      '@codemirror/language': 6.8.0
+      '@codemirror/state': 6.2.1
+      '@lezer/common': 1.2.1
+      '@lezer/yaml': 1.0.2
+    transitivePeerDependencies:
+      - '@codemirror/view'
+    dev: false
+
   /@codemirror/language@0.20.2:
     resolution: {integrity: sha512-WB3Bnuusw0xhVvhBocieYKwJm04SOk5bPoOEYksVHKHcGHFOaYaw+eZVxR4gIqMMcGzOIUil0FsCmFk8yrhHpw==}
     dependencies:
@@ -748,6 +786,10 @@ packages:
   /@lezer/common@1.0.3:
     resolution: {integrity: sha512-JH4wAXCgUOcCGNekQPLhVeUtIqjH0yPBs7vvUdSjyQama9618IOKFJwkv2kcqdhF0my8hQEgCTEJU0GIgnahvA==}
 
+  /@lezer/common@1.2.1:
+    resolution: {integrity: sha512-yemX0ZD2xS/73llMZIK6KplkjIjf2EvAHcinDi/TfJ9hS25G0388+ClHt6/3but0oOxinTcQHJLDXh6w1crzFQ==}
+    dev: false
+
   /@lezer/highlight@0.16.0:
     resolution: {integrity: sha512-iE5f4flHlJ1g1clOStvXNLbORJoiW4Kytso6ubfYzHnaNo/eo5SKhxs4wv/rtvwZQeZrK3we8S9SyA7OGOoRKQ==}
     dependencies:
@@ -779,6 +821,20 @@ packages:
     dependencies:
       '@lezer/common': 1.0.3
 
+  /@lezer/lr@1.4.0:
+    resolution: {integrity: sha512-Wst46p51km8gH0ZUmeNrtpRYmdlRHUpN1DQd3GFAyKANi8WVz8c2jHYTf1CVScFaCjQw1iO3ZZdqGDxQPRErTg==}
+    dependencies:
+      '@lezer/common': 1.2.1
+    dev: false
+
+  /@lezer/yaml@1.0.2:
+    resolution: {integrity: sha512-XCkwuxe+eumJ28nA9e1S6XKsXz9W7V/AG+WBiWOtiIuUpKcZ/bHuvN8bLxSDREIcybSRpEd/jvphh4vgm6Ed2g==}
+    dependencies:
+      '@lezer/common': 1.2.1
+      '@lezer/highlight': 1.1.6
+      '@lezer/lr': 1.4.0
+    dev: false
+
   /@manypkg/find-root@1.1.0:
     resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==}
     dependencies:
@@ -859,6 +915,21 @@ packages:
     resolution: {integrity: sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==}
     dev: false
 
+  /@types/linkify-it@3.0.5:
+    resolution: {integrity: sha512-yg6E+u0/+Zjva+buc3EIb+29XEg4wltq7cSmd4Uc2EE/1nUVmxyzpX6gUXD0V8jIrG0r7YeOGVIbYRkxeooCtw==}
+    dev: true
+
+  /@types/markdown-it@13.0.7:
+    resolution: {integrity: sha512-U/CBi2YUUcTHBt5tjO2r5QV/x0Po6nsYwQU4Y04fBS6vfoImaiZ6f8bi3CjTCxBPQSO1LMyUqkByzi8AidyxfA==}
+    dependencies:
+      '@types/linkify-it': 3.0.5
+      '@types/mdurl': 1.0.5
+    dev: true
+
+  /@types/mdurl@1.0.5:
+    resolution: {integrity: sha512-6L6VymKTzYSrEf4Nev4Xa1LCHKrlTlYCBMTlQKFuddo1CvQcE52I0mwfOJayueUC7MJuXOeHTcIU683lzd0cUA==}
+    dev: true
+
   /@types/minimist@1.2.2:
     resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
     dev: true
@@ -987,6 +1058,10 @@ packages:
       sprintf-js: 1.0.3
     dev: true
 
+  /argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+    dev: false
+
   /aria-query@5.3.0:
     resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
     dependencies:
@@ -1384,7 +1459,6 @@ packages:
   /entities@4.5.0:
     resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
     engines: {node: '>=0.12'}
-    dev: true
 
   /error-ex@1.3.2:
     resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
@@ -2096,6 +2170,12 @@ packages:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
 
+  /linkify-it@5.0.0:
+    resolution: {integrity: sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==}
+    dependencies:
+      uc.micro: 2.0.0
+    dev: false
+
   /load-yaml-file@0.2.0:
     resolution: {integrity: sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==}
     engines: {node: '>=6'}
@@ -2181,12 +2261,28 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /markdown-it@14.0.0:
+    resolution: {integrity: sha512-seFjF0FIcPt4P9U39Bq1JYblX0KZCjDLFFQPHpL5AzHpqPEKtosxmdq/LTVZnjfH7tjt9BxStm+wXcDBNuYmzw==}
+    hasBin: true
+    dependencies:
+      argparse: 2.0.1
+      entities: 4.5.0
+      linkify-it: 5.0.0
+      mdurl: 2.0.0
+      punycode.js: 2.3.1
+      uc.micro: 2.0.0
+    dev: false
+
   /marked@4.3.0:
     resolution: {integrity: sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==}
     engines: {node: '>= 12'}
     hasBin: true
     dev: true
 
+  /mdurl@2.0.0:
+    resolution: {integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==}
+    dev: false
+
   /meow@6.1.1:
     resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==}
     engines: {node: '>=8'}
@@ -2501,6 +2597,11 @@ packages:
     resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==}
     dev: true
 
+  /punycode.js@2.3.1:
+    resolution: {integrity: sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==}
+    engines: {node: '>=6'}
+    dev: false
+
   /queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
     dev: true
@@ -3029,6 +3130,10 @@ packages:
     hasBin: true
     dev: true
 
+  /uc.micro@2.0.0:
+    resolution: {integrity: sha512-DffL94LsNOccVn4hyfRe5rdKa273swqeA5DJpMOeFmEn1wCDc7nAbbB0gXlgBCL7TNzeTv6G7XVWzan7iJtfig==}
+    dev: false
+
   /ufo@1.1.2:
     resolution: {integrity: sha512-TrY6DsjTQQgyS3E3dBaOXf0TpPD8u9FVrVYmKVegJuFw51n/YB9XPt+U6ydzFG5ZIN7+DIjPbNmXoBj9esYhgQ==}
     dev: true
@@ -3350,6 +3455,11 @@ packages:
     resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
     dev: true
 
+  /yaml@2.3.4:
+    resolution: {integrity: sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA==}
+    engines: {node: '>= 14'}
+    dev: false
+
   /yargs-parser@18.1.3:
     resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==}
     engines: {node: '>=6'}
diff --git a/src/__tests__/__helpers__/completion.ts b/src/__tests__/__helpers__/completion.ts
index 1ae90fb..6a5118e 100644
--- a/src/__tests__/__helpers__/completion.ts
+++ b/src/__tests__/__helpers__/completion.ts
@@ -1,8 +1,5 @@
 import { expect, vitest } from "vitest";
 
-import { json, jsonLanguage } from "@codemirror/lang-json";
-import { json5, json5Language } from "codemirror-json5";
-
 import { EditorState } from "@codemirror/state";
 import {
   Completion,
@@ -10,11 +7,12 @@ import {
   CompletionResult,
   CompletionSource,
 } from "@codemirror/autocomplete";
-import { jsonCompletion } from "../../json-completion.js";
 import { JSONSchema7 } from "json-schema";
 import { testSchema2 } from "../__fixtures__/schemas.js";
 import { EditorView } from "@codemirror/view";
-import { stateExtensions } from "../../state.js";
+import { JSONMode } from "../../types.js";
+import { MODES } from "../../constants.js";
+import { getExtensions } from "./index.js";
 
 vitest.mock("@codemirror/autocomplete", async () => {
   const mod = await vitest.importActual<
@@ -45,25 +43,17 @@ export async function expectCompletion(
   conf: {
     explicit?: boolean;
     schema?: JSONSchema7;
-    mode?: "json" | "json5";
+    mode?: JSONMode;
   } = {}
 ) {
   let cur = doc.indexOf("|"),
     currentSchema = conf?.schema || testSchema2;
   doc = doc.slice(0, cur) + doc.slice(cur + 1);
-  const jsonMode = conf?.mode === "json5" ? json5 : json;
-  const jsonLang = conf?.mode === "json5" ? json5Language : jsonLanguage;
 
   let state = EditorState.create({
     doc,
     selection: { anchor: cur },
-    extensions: [
-      jsonMode(),
-      stateExtensions(currentSchema),
-      jsonLang.data.of({
-        autocomplete: jsonCompletion({ mode: conf.mode }),
-      }),
-    ],
+    extensions: getExtensions(conf.mode ?? MODES.JSON, currentSchema),
   });
   const view = new EditorView({ state });
 
@@ -79,6 +69,7 @@ export async function expectCompletion(
     info: item.info,
     label: item.label,
     type: item.type,
+    apply: typeof item.apply === "string" ? item.apply : undefined,
     // @ts-expect-error
     template: item?.TESTONLY_template as string | undefined,
   }));
diff --git a/src/__tests__/__helpers__/index.ts b/src/__tests__/__helpers__/index.ts
new file mode 100644
index 0000000..30f1f1a
--- /dev/null
+++ b/src/__tests__/__helpers__/index.ts
@@ -0,0 +1,17 @@
+import { JSONMode } from "../../types";
+import { MODES } from "../../constants";
+import { JSONSchema7 } from "json-schema";
+import { jsonSchema } from "../../bundled";
+import { json5Schema } from "../../json5/bundled";
+import { yamlSchema } from "../../yaml/bundled";
+
+export const getExtensions = (mode: JSONMode, schema?: JSONSchema7) => {
+  switch (mode) {
+    case MODES.JSON:
+      return jsonSchema(schema);
+    case MODES.JSON5:
+      return json5Schema(schema);
+    case MODES.YAML:
+      return yamlSchema(schema);
+  }
+};
diff --git a/src/__tests__/json-completion.spec.ts b/src/__tests__/json-completion.spec.ts
index e3f03ba..650a897 100644
--- a/src/__tests__/json-completion.spec.ts
+++ b/src/__tests__/json-completion.spec.ts
@@ -1,10 +1,14 @@
 import { describe, it } from "vitest";
 
 import { expectCompletion } from "./__helpers__/completion.js";
+import { MODES } from "../constants.js";
 
-describe("jsonCompletion", () => {
-  it("should return completion data for simple types", async () => {
-    await expectCompletion('{ "f| }', [
+describe.each([
+  {
+    name: "return completion data for simple types",
+    mode: MODES.JSON,
+    docs: ['{ "f| }', "{ f| }"],
+    expectedResults: [
       {
         label: "foo",
         type: "property",
@@ -12,10 +16,13 @@ describe("jsonCompletion", () => {
         info: "",
         template: '"foo": "#{}"',
       },
-    ]);
-  });
-  it("should return completion data for simple types", async () => {
-    await expectCompletion('{ "one| }', [
+    ],
+  },
+  {
+    name: "return completion data for simple types (multiple)",
+    mode: MODES.JSON,
+    docs: ['{ "one| }'],
+    expectedResults: [
       {
         label: "oneOfEg",
         type: "property",
@@ -37,10 +44,13 @@ describe("jsonCompletion", () => {
         template: '"oneOfObject": #{}',
         type: "property",
       },
-    ]);
-  });
-  it("should include defaults for enum when available", async () => {
-    await expectCompletion('{ "en| }', [
+    ],
+  },
+  {
+    name: "include defaults for enum when available",
+    mode: MODES.JSON,
+    docs: ['{ "en| }'],
+    expectedResults: [
       {
         label: "enum1",
         type: "property",
@@ -55,30 +65,42 @@ describe("jsonCompletion", () => {
         info: "an example enum without default",
         template: '"enum2": #{}',
       },
-    ]);
-  });
-  it("should include value completions for enum", async () => {
-    await expectCompletion('{ "enum1": "|" }', [
+    ],
+  },
+  {
+    name: "include value completions for enum",
+    mode: MODES.JSON,
+    docs: ['{ "enum1": "|" }'],
+    expectedResults: [
       {
-        label: '"foo"',
+        label: "foo",
+        apply: '"foo"',
         info: "an example enum with default bar",
       },
       {
-        label: '"bar"',
+        label: "bar",
+        apply: '"bar"',
         detail: "Default value",
       },
-    ]);
-  });
-  it("should include value completions for enum with filter", async () => {
-    await expectCompletion('{ "enum1": "f|" }', [
+    ],
+  },
+  {
+    name: "include value completions for enum with filter",
+    mode: MODES.JSON,
+    docs: ['{ "enum1": "f|" }'],
+    expectedResults: [
       {
-        label: '"foo"',
+        label: "foo",
+        apply: '"foo"',
         info: "an example enum with default bar",
       },
-    ]);
-  });
-  it("should include defaults for boolean when available", async () => {
-    await expectCompletion('{ "booleanW| }', [
+    ],
+  },
+  {
+    name: "include defaults for boolean when available",
+    mode: MODES.JSON,
+    docs: ['{ "booleanW| }'],
+    expectedResults: [
       {
         type: "property",
         detail: "boolean",
@@ -86,23 +108,31 @@ describe("jsonCompletion", () => {
         label: "booleanWithDefault",
         template: '"booleanWithDefault": ${true}',
       },
-    ]);
-  });
+    ],
+  },
   // TODO: should provide true/false completions
-  it.skip("should include value completions for boolean", async () => {
-    await expectCompletion('{ "booleanWithDefault": | }', [
-      {
-        detail: "boolean",
-        label: "true",
-      },
-      {
-        detail: "boolean",
-        label: "false",
-      },
-    ]);
-  });
-  it("should include insert text for objects", async () => {
-    await expectCompletion('{ "ob| }', [
+  // {
+  //   name: "include value completions for boolean",
+  // mode: MODES.JSON,
+  // docs: ['{ "booleanWithDefault": | }',
+  //  },
+  //   ],
+  //   expectedResults: [
+  //     {
+  //       detail: "boolean",
+  //       label: "true",
+  //     },
+  //     {
+  //       detail: "boolean",
+  //       label: "false",
+  //     },
+  //   ],
+  // },
+  {
+    name: "include insert text for objects",
+    mode: MODES.JSON,
+    docs: ['{ "ob| }'],
+    expectedResults: [
       {
         type: "property",
         detail: "object",
@@ -110,23 +140,14 @@ describe("jsonCompletion", () => {
         label: "object",
         template: '"object": {#{}}',
       },
-    ]);
-  });
+    ],
+  },
   // this has regressed for json4 only for some reason
-  it("should include insert text for nested object properties", async () => {
-    await expectCompletion('{ "object": { "|" } }', [
-      {
-        detail: "string",
-        info: "an elegant string",
-        label: "foo",
-        template: '"foo": "#{}"',
-        type: "property",
-      },
-    ]);
-  });
-  // TODO: accidentally steps up to the parent pointer
-  it("should include insert text for nested object properties", async () => {
-    await expectCompletion(`{ "object": { '| } }`, [
+  {
+    name: "include insert text for nested object properties",
+    mode: MODES.JSON,
+    docs: ['{ "object": { "|" } }', '{ "object": { "| } }'],
+    expectedResults: [
       {
         detail: "string",
         info: "an elegant string",
@@ -134,10 +155,13 @@ describe("jsonCompletion", () => {
         template: '"foo": "#{}"',
         type: "property",
       },
-    ]);
-  });
-  it("should include insert text for nested object properties with filter", async () => {
-    await expectCompletion('{ "object": { "f|" } }', [
+    ],
+  },
+  {
+    name: "include insert text for nested object properties with filter",
+    mode: MODES.JSON,
+    docs: ['{ "object": { "f|" } }'],
+    expectedResults: [
       {
         detail: "string",
         info: "an elegant string",
@@ -145,10 +169,13 @@ describe("jsonCompletion", () => {
         template: '"foo": "#{}"',
         type: "property",
       },
-    ]);
-  });
-  it("should autocomplete for oneOf with nested definitions and filter", async () => {
-    await expectCompletion('{ "oneOfObject": { "f|" } }', [
+    ],
+  },
+  {
+    name: "autocomplete for oneOf with nested definitions and filter",
+    mode: MODES.JSON,
+    docs: ['{ "oneOfObject": { "f|" } }'],
+    expectedResults: [
       {
         detail: "string",
         info: "",
@@ -156,10 +183,13 @@ describe("jsonCompletion", () => {
         template: '"foo": "#{}"',
         type: "property",
       },
-    ]);
-  });
-  it("should autocomplete for oneOf with nested definitions", async () => {
-    await expectCompletion('{ "oneOfObject": { "|" } }', [
+    ],
+  },
+  {
+    name: "autocomplete for oneOf with nested definitions",
+    mode: MODES.JSON,
+    docs: ['{ "oneOfObject": { "|" } }'],
+    expectedResults: [
       {
         detail: "string",
         info: "",
@@ -188,43 +218,14 @@ describe("jsonCompletion", () => {
         template: '"banana": #{0}',
         type: "property",
       },
-    ]);
-    it("should autocomplete for oneOf without quotes", async () => {
-      await expectCompletion('{ "oneOfObject": { | } }', [
-        {
-          detail: "string",
-          info: "",
-          label: "foo",
-          template: '"foo": "#{}"',
-          type: "property",
-        },
-        {
-          detail: "number",
-          info: "",
-          label: "bar",
-          template: '"bar": #{0}',
-          type: "property",
-        },
-        {
-          detail: "string",
-          info: "",
-          label: "apple",
-          template: '"apple": "#{}"',
-          type: "property",
-        },
-        {
-          detail: "number",
-          info: "",
-          label: "banana",
-          template: '"banana": #{0}',
-          type: "property",
-        },
-      ]);
-    });
-  });
+    ],
+  },
   // TODO: completion for array of objects should enhance the template
-  it('should autocomplete for array of objects with "items"', async () => {
-    await expectCompletion('{ "array| }', [
+  {
+    name: "autocomplete for array of objects with items",
+    mode: MODES.JSON,
+    docs: ['{ "array| }'],
+    expectedResults: [
       {
         type: "property",
         detail: "array",
@@ -239,10 +240,13 @@ describe("jsonCompletion", () => {
         label: "arrayOfOneOf",
         template: '"arrayOfOneOf": [#{}]',
       },
-    ]);
-  });
-  it('should autocomplete for array of objects with "items"', async () => {
-    await expectCompletion('{ "arrayOfObjects": [ { "|" } ] }', [
+    ],
+  },
+  {
+    name: "autocomplete for array of objects with items (array of objects)",
+    mode: MODES.JSON,
+    docs: ['{ "arrayOfObjects": [ { "|" } ] }'],
+    expectedResults: [
       {
         detail: "string",
         info: "",
@@ -257,10 +261,13 @@ describe("jsonCompletion", () => {
         template: '"bar": #{0}',
         type: "property",
       },
-    ]);
-  });
-  it('should autocomplete for array of objects with "items"', async () => {
-    await expectCompletion('{ "arrayOfOneOf": [ { "|" } ] }', [
+    ],
+  },
+  {
+    name: "autocomplete for array of objects with items (array of oneOf)",
+    mode: MODES.JSON,
+    docs: ['{ "arrayOfOneOf": [ { "|" } ] }'],
+    expectedResults: [
       {
         detail: "string",
         info: "",
@@ -289,176 +296,365 @@ describe("jsonCompletion", () => {
         template: '"banana": #{0}',
         type: "property",
       },
-    ]);
-  });
-});
-
-describe("json5Completion", () => {
-  it("should return bare property key when no quotes are used", async () => {
-    await expectCompletion(
-      "{ f| }",
-      [
-        {
-          label: "foo",
-          type: "property",
-          detail: "string",
-          info: "",
-          template: "foo: '#{}'",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
-  it("should return template for '", async () => {
-    await expectCompletion(
-      "{ 'one|' }",
-      [
-        {
-          label: "oneOfEg",
-          type: "property",
-          detail: "",
-          info: "an example oneOf",
-          template: "'oneOfEg': #{}",
-        },
-        {
-          label: "oneOfEg2",
-          type: "property",
-          detail: "",
-          info: "",
-          template: "'oneOfEg2': #{}",
-        },
-        {
-          detail: "",
-          info: "",
-          label: "oneOfObject",
-          template: "'oneOfObject': #{}",
-          type: "property",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
-  it("should include defaults for enum when available", async () => {
-    await expectCompletion(
-      "{ en| }",
-      [
-        {
-          label: "enum1",
-          type: "property",
-          detail: "",
-          info: "an example enum with default bar",
-          template: 'enum1: "${bar}"',
-        },
-        {
-          label: "enum2",
-          type: "property",
-          detail: "",
-          info: "an example enum without default",
-          template: "enum2: #{}",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
+    ],
+  },
+  // JSON5
+  {
+    name: "return bare property key when no quotes are used",
+    mode: MODES.JSON5,
+    docs: ["{ f| }", "{ f| }"],
+    expectedResults: [
+      {
+        label: "foo",
+        type: "property",
+        detail: "string",
+        info: "",
+        template: "foo: '#{}'",
+      },
+    ],
+  },
+  {
+    name: "return template for '",
+    mode: MODES.JSON5,
+    docs: ["{ 'one|' }"],
+    expectedResults: [
+      {
+        label: "oneOfEg",
+        type: "property",
+        detail: "",
+        info: "an example oneOf",
+        template: "'oneOfEg': #{}",
+      },
+      {
+        label: "oneOfEg2",
+        type: "property",
+        detail: "",
+        info: "",
+        template: "'oneOfEg2': #{}",
+      },
+      {
+        detail: "",
+        info: "",
+        label: "oneOfObject",
+        template: "'oneOfObject': #{}",
+        type: "property",
+      },
+    ],
+  },
+  {
+    name: "include defaults for enum when available",
+    mode: MODES.JSON5,
+    docs: ["{ en| }"],
+    expectedResults: [
+      {
+        label: "enum1",
+        type: "property",
+        detail: "",
+        info: "an example enum with default bar",
+        template: "enum1: '${bar}'",
+      },
+      {
+        label: "enum2",
+        type: "property",
+        detail: "",
+        info: "an example enum without default",
+        template: "enum2: #{}",
+      },
+    ],
+  },
   // TODO: should autocomplete for boolean values
-  it.skip("should include value completions for boolean", async () => {
-    await expectCompletion(
-      '{ "booleanWithDefault": | }',
-      [
-        {
-          detail: "boolean",
-          label: "true",
-        },
-        {
-          detail: "boolean",
-          label: "false",
-        },
-      ],
-      {
-        mode: "json5",
-      }
-    );
-  });
-  it("should provide enum values on completion", async () => {
-    await expectCompletion(
-      "{ enum1: '| }",
-      [
-        {
-          label: '"foo"',
-          info: "an example enum with default bar",
-        },
-        {
-          label: '"bar"',
-          detail: "Default value",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
-  it("should include defaults for boolean when available", async () => {
-    await expectCompletion(
-      "{ booleanW| }",
-      [
-        {
-          type: "property",
-          detail: "boolean",
-          info: "an example boolean with default",
-          label: "booleanWithDefault",
-          template: "booleanWithDefault: ${true}",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
-  it("should include insert text for nested object properties", async () => {
-    await expectCompletion(
-      "{ object: { f|  }",
-      [
-        {
-          type: "property",
-          detail: "string",
-          info: "an elegant string",
-          label: "foo",
-          template: "foo: '#{}'",
-        },
-      ],
-      { mode: "json5" }
-    );
-  });
-  it("should include insert text for nested oneOf object properties with a single quote", async () => {
-    await expectCompletion(
-      "{ oneOfObject: { '|'  }",
-      [
-        {
-          type: "property",
-          detail: "string",
-          info: "",
-          label: "foo",
-          template: "'foo': '#{}'",
-        },
-        {
-          type: "property",
-          detail: "number",
-          info: "",
-          label: "bar",
-          template: "'bar': #{0}",
-        },
-        {
-          type: "property",
-          detail: "string",
-          info: "",
-          label: "apple",
-          template: "'apple': '#{}'",
-        },
-        {
-          type: "property",
-          detail: "number",
-          info: "",
-          label: "banana",
-          template: "'banana': #{0}",
-        },
-      ],
-      { mode: "json5" }
-    );
+  // {
+  //   name: "include value completions for boolean",
+  //   mode: MODES.JSON5,
+  //   docs: ['{ "booleanWithDefault": | }'],
+  //   expectedResults: [
+  //     {
+  //       detail: "boolean",
+  //       label: "true",
+  //     },
+  //     {
+  //       detail: "boolean",
+  //       label: "false",
+  //     },
+  //   ],
+  // },
+  {
+    name: "provide enum values on completion",
+    mode: MODES.JSON5,
+    docs: ["{ enum1: '| }"],
+    expectedResults: [
+      {
+        label: "foo",
+        apply: "'foo'",
+        info: "an example enum with default bar",
+      },
+      {
+        label: "bar",
+        apply: "'bar'",
+        detail: "Default value",
+      },
+    ],
+  },
+  {
+    name: "include defaults for boolean when available",
+    mode: MODES.JSON5,
+    docs: ["{ booleanW| }"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "boolean",
+        info: "an example boolean with default",
+        label: "booleanWithDefault",
+        template: "booleanWithDefault: ${true}",
+      },
+    ],
+  },
+  {
+    name: "include insert text for nested object properties",
+    mode: MODES.JSON5,
+    docs: ["{ object: { f|  }"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "string",
+        info: "an elegant string",
+        label: "foo",
+        template: "foo: '#{}'",
+      },
+    ],
+  },
+  {
+    name: "include insert text for nested oneOf object properties with a single quote",
+    mode: MODES.JSON5,
+    docs: ["{ oneOfObject: { '|  }"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "string",
+        info: "",
+        label: "foo",
+        template: "'foo': '#{}'",
+      },
+      {
+        type: "property",
+        detail: "number",
+        info: "",
+        label: "bar",
+        template: "'bar': #{0}",
+      },
+      {
+        type: "property",
+        detail: "string",
+        info: "",
+        label: "apple",
+        template: "'apple': '#{}'",
+      },
+      {
+        type: "property",
+        detail: "number",
+        info: "",
+        label: "banana",
+        template: "'banana': #{0}",
+      },
+    ],
+  },
+  // YAML
+  {
+    name: "return completion data for simple types",
+    mode: MODES.YAML,
+    docs: ["f|"],
+    expectedResults: [
+      {
+        label: "foo",
+        type: "property",
+        detail: "string",
+        info: "",
+        template: "foo: #{}",
+      },
+    ],
+  },
+  {
+    name: "return completion data for simple types (multiple)",
+    mode: MODES.YAML,
+    docs: ["one|"],
+    expectedResults: [
+      {
+        label: "oneOfEg",
+        type: "property",
+        detail: "",
+        info: "an example oneOf",
+        template: "oneOfEg: #{}",
+      },
+      {
+        label: "oneOfEg2",
+        type: "property",
+        detail: "",
+        info: "",
+        template: "oneOfEg2: #{}",
+      },
+      {
+        detail: "",
+        info: "",
+        label: "oneOfObject",
+        template: "oneOfObject: #{}",
+        type: "property",
+      },
+    ],
+  },
+  {
+    name: "include defaults for enum when available",
+    mode: MODES.YAML,
+    docs: ["en|"],
+    expectedResults: [
+      {
+        label: "enum1",
+        type: "property",
+        detail: "",
+        info: "an example enum with default bar",
+        template: "enum1: ${bar}",
+      },
+      {
+        label: "enum2",
+        type: "property",
+        detail: "",
+        info: "an example enum without default",
+        template: "enum2: #{}",
+      },
+    ],
+  },
+  {
+    name: "include value completions for enum",
+    mode: MODES.YAML,
+    docs: ["enum1: f|"],
+    expectedResults: [
+      {
+        label: "foo",
+        apply: "foo",
+        info: "an example enum with default bar",
+      },
+    ],
+  },
+  {
+    name: "include defaults for boolean when available",
+    mode: MODES.YAML,
+    docs: ["booleanW|"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "boolean",
+        info: "an example boolean with default",
+        label: "booleanWithDefault",
+        template: "booleanWithDefault: ${true}",
+      },
+    ],
+  },
+  {
+    name: "include insert text for objects",
+    mode: MODES.YAML,
+    docs: ["ob|"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "object",
+        info: "",
+        label: "object",
+        template: "object: #{}",
+      },
+    ],
+  },
+  {
+    name: "include insert text for nested object properties",
+    mode: MODES.YAML,
+    docs: ["object: { f|  }"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "string",
+        info: "an elegant string",
+        label: "foo",
+        template: "foo: #{}",
+      },
+    ],
+  },
+  {
+    name: "include insert text for nested oneOf object properties",
+    mode: MODES.YAML,
+    docs: ["oneOfObject: { b|  }"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "number",
+        info: "",
+        label: "bar",
+        template: "bar: #{0}",
+      },
+      {
+        type: "property",
+        detail: "number",
+        info: "",
+        label: "banana",
+        template: "banana: #{0}",
+      },
+    ],
+  },
+  {
+    name: "autocomplete for array of objects with items",
+    mode: MODES.YAML,
+    docs: ["array|"],
+    expectedResults: [
+      {
+        type: "property",
+        detail: "array",
+        info: "",
+        label: "arrayOfObjects",
+        template: "arrayOfObjects: [#{}]",
+      },
+      {
+        type: "property",
+        detail: "array",
+        info: "",
+        label: "arrayOfOneOf",
+        template: "arrayOfOneOf: [#{}]",
+      },
+    ],
+  },
+  {
+    name: "autocomplete for array of objects with items (array of objects)",
+    mode: MODES.YAML,
+    docs: ["arrayOfObjects: [ { f| } ]"],
+    expectedResults: [
+      {
+        detail: "string",
+        info: "",
+        label: "foo",
+        template: "foo: #{}",
+        type: "property",
+      },
+    ],
+  },
+  {
+    name: "autocomplete for array of objects with items (array of oneOf)",
+    mode: MODES.YAML,
+    docs: ["arrayOfOneOf: [ { b| } ]"],
+    expectedResults: [
+      {
+        detail: "number",
+        info: "",
+        label: "bar",
+        template: "bar: #{0}",
+        type: "property",
+      },
+      {
+        detail: "number",
+        info: "",
+        label: "banana",
+        template: "banana: #{0}",
+        type: "property",
+      },
+    ],
+  },
+])("jsonCompletion", ({ name, docs, mode, expectedResults }) => {
+  it.each(docs)(`${name} (mode: ${mode})`, async (doc) => {
+    await expectCompletion(doc, expectedResults, { mode });
   });
 });
diff --git a/src/__tests__/json-hover.spec.ts b/src/__tests__/json-hover.spec.ts
index 789b73c..04a3328 100644
--- a/src/__tests__/json-hover.spec.ts
+++ b/src/__tests__/json-hover.spec.ts
@@ -6,129 +6,191 @@ import "vitest-dom/extend-expect";
 import { JSONSchema7 } from "json-schema";
 import { FoundCursorData, JSONHover } from "../json-hover.js";
 
-import { json } from "@codemirror/lang-json";
 import { EditorView } from "@codemirror/view";
 import { testSchema, testSchema2 } from "./__fixtures__/schemas.js";
 import { Draft } from "json-schema-library";
-import { stateExtensions } from "../state.js";
+import { MODES } from "../constants.js";
+import { JSONMode } from "../types.js";
+import { getExtensions } from "./__helpers__/index.js";
 
 const getHoverData = (
   jsonString: string,
   pos: number,
+  mode: JSONMode,
   schema?: JSONSchema7
 ) => {
   const view = new EditorView({
     doc: jsonString,
-    extensions: [json(), stateExtensions(schema || testSchema)],
+    extensions: [getExtensions(mode, schema ?? testSchema)],
   });
-  return new JSONHover().getDataForCursor(view, pos, 1);
+  return new JSONHover({ mode }).getDataForCursor(view, pos, 1);
 };
 
 const getHoverResult = async (
   jsonString: string,
   pos: number,
+  mode: JSONMode,
   schema?: JSONSchema7
 ) => {
   const view = new EditorView({
     doc: jsonString,
-    extensions: [json(), stateExtensions(schema || testSchema)],
+    extensions: [getExtensions(mode, schema ?? testSchema)],
   });
-  const hoverResult = await new JSONHover().doHover(view, pos, 1);
+  const hoverResult = await new JSONHover({ mode }).doHover(view, pos, 1);
   return hoverResult;
 };
 
 const getHoverTexts = async (
   jsonString: string,
   pos: number,
+  mode: JSONMode,
   schema?: JSONSchema7
 ) => {
   const view = new EditorView({
     doc: jsonString,
-    extensions: [json(), stateExtensions(schema || testSchema)],
+    extensions: [getExtensions(mode, schema ?? testSchema)],
   });
-  const hover = new JSONHover();
+  const hover = new JSONHover({ mode });
   const data = hover.getDataForCursor(view, pos, 1) as FoundCursorData;
   const hoverResult = hover.getHoverTexts(data, schema as Draft);
   return hoverResult;
 };
 
 describe("JSONHover#getDataForCursor", () => {
-  it("should return schema descriptions as expected", () => {
-    expect(
-      getHoverData('{"object": { "foo": true }, "bar": 123}', 14, testSchema2)
-    ).toEqual({
-      pointer: "/object/foo",
-      schema: {
-        description: "an elegant string",
-        type: "string",
+  it.each([
+    {
+      mode: MODES.JSON,
+      doc: '{"object": { "foo": true }, "bar": 123}',
+      pos: 14,
+      schema: testSchema2,
+      expected: {
+        pointer: "/object/foo",
+        schema: {
+          description: "an elegant string",
+          type: "string",
+        },
       },
-    });
-  });
+    },
+    {
+      mode: MODES.JSON5,
+      doc: "{object: { foo: true }, bar: 123}",
+      pos: 11,
+      schema: testSchema2,
+      expected: {
+        pointer: "/object/foo",
+        schema: {
+          description: "an elegant string",
+          type: "string",
+        },
+      },
+    },
+    {
+      mode: MODES.YAML,
+      doc: `---
+object:
+  foo: true
+bar: 123
+`,
+      pos: 14,
+      schema: testSchema2,
+      expected: {
+        pointer: "/object/foo",
+        schema: {
+          description: "an elegant string",
+          type: "string",
+        },
+      },
+    },
+  ])(
+    "should return schema descriptions as expected (mode: $mode)",
+    ({ mode, doc, pos, schema, expected }) => {
+      expect(getHoverData(doc, pos, mode, schema)).toEqual(expected);
+    }
+  );
 });
 
 describe("JSONHover#getHoverTexts", () => {
-  it("should provide oneOf texts despite invalid values", async () => {
-    const hoverTexts = await getHoverTexts(
-      '{"oneOfEg": { "foo": true }, "bar": 123}',
-      3,
-      testSchema2
-    );
-    expect(hoverTexts).toEqual({
-      message: "an example oneOf",
-      typeInfo:
-        "oneOf: <code>string</code>, <code>array</code>, or <code>boolean</code>",
-    });
-  });
-  it("should provide oneOf texts with valid values", async () => {
-    const hoverTexts = await getHoverTexts(
-      '{"oneOfEg": { "foo": "example" }, "bar": 123}',
-      3,
-      testSchema2
-    );
-    expect(hoverTexts).toEqual({
-      message: "an example oneOf",
-      typeInfo:
-        "oneOf: <code>string</code>, <code>array</code>, or <code>boolean</code>",
-    });
-  });
+  it.each([
+    {
+      name: "oneOf despite invalid values",
+      mode: MODES.JSON,
+      doc: '{"oneOfEg": { "foo": true }, "bar": 123}',
+      pos: 3,
+      schema: testSchema2,
+      expected: {
+        message: "an example oneOf",
+        typeInfo: "oneOf: `string`, `array`, or `boolean`",
+      },
+    },
+    {
+      name: "oneOf with valid values",
+      mode: MODES.JSON,
+      doc: '{"oneOfEg": { "foo": "example" }, "bar": 123}',
+      pos: 3,
+      schema: testSchema2,
+      expected: {
+        message: "an example oneOf",
+        typeInfo: "oneOf: `string`, `array`, or `boolean`",
+      },
+    },
+  ])(
+    "should return hover texts as expected ($name, mode: $mode)",
+    async ({ mode, doc, pos, schema, expected }) => {
+      expect(await getHoverTexts(doc, pos, mode, schema)).toEqual(expected);
+    }
+  );
 });
 
 describe("JSONHover#doHover", () => {
-  it("should return Tooltip data", async () => {
-    const hoverResult = await getHoverResult(
-      '{"object": { "foo": true }, "bar": 123}',
-      14,
-      testSchema2
-    );
-    expect(hoverResult).toEqual({
-      arrow: true,
-      end: 14,
+  it.each([
+    {
+      name: "",
+      mode: MODES.JSON,
+      doc: '{"object": { "foo": true }, "bar": 123}',
       pos: 14,
-      above: true,
-      create: expect.any(Function),
-    });
-    const hoverEl = hoverResult?.create(new EditorView({})).dom;
-    expect(hoverEl).toContainHTML(
-      [
-        `<div class="cm6-json-schema-hover"><div class="cm6-json-schema-hover--description">an elegant string</div>`,
-        `<div class="cm6-json-schema-hover--code-wrapper"><code class="cm6-json-schema-hover--code">string</code></div></div>`,
-      ].join("")
-    );
-  });
-
-  it("should return just typeInfo if there is no description", async () => {
-    const hoverResult = await getHoverResult('{ "foo": true }', 4, testSchema2);
-    expect(hoverResult).toEqual({
-      arrow: true,
-      end: 4,
+      schema: testSchema2,
+      expected: {
+        arrow: true,
+        end: 14,
+        pos: 14,
+        above: true,
+        create: expect.any(Function),
+      },
+      expectedHTMLContents: [
+        [
+          `<div class="cm6-json-schema-hover"><div class="cm6-json-schema-hover--description">an elegant string</div>`,
+          `<div class="cm6-json-schema-hover--code-wrapper"><div class="cm6-json-schema-hover--code">string</div></div></div>`,
+        ].join(""),
+      ],
+    },
+    {
+      name: "with no description",
+      mode: MODES.JSON,
+      doc: '{ "foo": true }',
       pos: 4,
-      above: true,
-      create: expect.any(Function),
-    });
-    const hoverEl = hoverResult?.create(new EditorView({})).dom.toString();
-    expect(hoverEl).toContain("cm6-json-schema-hover--code-wrapper");
-    expect(hoverEl).toContain("cm6-json-schema-hover--code");
-    expect(hoverEl).toContain("string</code>");
-    expect(hoverEl).not.toContain("cm6-json-schema-hover--description");
-  });
+      schema: testSchema,
+      expected: {
+        arrow: true,
+        end: 4,
+        pos: 4,
+        above: true,
+        create: expect.any(Function),
+      },
+      expectedHTMLContents: [
+        "cm6-json-schema-hover--code-wrapper",
+        "cm6-json-schema-hover--code",
+        "string</code>",
+      ],
+    },
+  ])(
+    "should return Tooltip data ($name, mode: $mode)",
+    async ({ mode, doc, pos, schema, expected, expectedHTMLContents }) => {
+      const hoverResult = await getHoverResult(doc, pos, mode, schema);
+      expect(hoverResult).toEqual(expected);
+      const hoverEl = hoverResult?.create(new EditorView({})).dom;
+      expectedHTMLContents.forEach((content) => {
+        expect(hoverEl).toContainHTML(content);
+      });
+    }
+  );
 });
diff --git a/src/__tests__/json-validation.spec.ts b/src/__tests__/json-validation.spec.ts
index a8b5318..ad0e458 100644
--- a/src/__tests__/json-validation.spec.ts
+++ b/src/__tests__/json-validation.spec.ts
@@ -2,18 +2,23 @@ import { JSONSchema7 } from "json-schema";
 import { JSONValidation } from "../json-validation";
 import type { Diagnostic } from "@codemirror/lint";
 import { describe, it, expect } from "vitest";
-import { json } from "@codemirror/lang-json";
 import { EditorView } from "@codemirror/view";
 
 import { testSchema, testSchema2 } from "./__fixtures__/schemas.js";
-import { stateExtensions } from "../state";
+import { JSONMode } from "../types.js";
+import { getExtensions } from "./__helpers__/index.js";
+import { MODES } from "../constants.js";
 
-const getErrors = (jsonString: string, schema?: JSONSchema7) => {
+const getErrors = (
+  jsonString: string,
+  mode: JSONMode,
+  schema?: JSONSchema7
+) => {
   const view = new EditorView({
     doc: jsonString,
-    extensions: [json(), stateExtensions(schema ?? testSchema)],
+    extensions: [getExtensions(mode, schema ?? testSchema)],
   });
-  return new JSONValidation().doValidation(view);
+  return new JSONValidation({ mode }).doValidation(view);
 };
 
 const common = {
@@ -24,9 +29,10 @@ const common = {
 const expectErrors = (
   jsonString: string,
   errors: [from: number | undefined, to: number | undefined, message: string][],
+  mode: JSONMode,
   schema?: JSONSchema7
 ) => {
-  const filteredErrors = getErrors(jsonString, schema).map(
+  const filteredErrors = getErrors(jsonString, mode, schema).map(
     ({ renderMessage, ...error }) => error
   );
   expect(filteredErrors).toEqual(
@@ -35,70 +41,306 @@ const expectErrors = (
 };
 
 describe("json-validation", () => {
-  it("should provide range for a value error", () => {
-    expectErrors('{"foo": 123}', [
-      [8, 11, "Expected <code>string</code> but received <code>number</code>"],
-    ]);
-  });
-  it("should provide range for an unknown key error", () => {
-    expectErrors('{"foo": "example", "bar": 123}', [
-      [19, 24, "Additional property <code>bar</code> is not allowed"],
-    ]);
-  });
-  it("should not handle invalid json", () => {
-    expectErrors('{"foo": "example" "bar": 123}', []);
-  });
-  it("should provide range for invalid multiline json", () => {
-    expectErrors(
-      `{
+  it.each([
+    {
+      name: "provide range for a value error",
+      mode: MODES.JSON,
+      doc: '{"foo": 123}',
+      errors: [
+        {
+          from: 8,
+          to: 11,
+          message: "Expected `string` but received `number`",
+        },
+      ],
+    },
+    {
+      name: "provide range for an unknown key error",
+      mode: MODES.JSON,
+      doc: '{"foo": "example", "bar": 123}',
+      errors: [
+        {
+          from: 19,
+          to: 24,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "not handle invalid json",
+      mode: MODES.JSON,
+      doc: '{"foo": "example" "bar": 123}',
+      errors: [],
+    },
+    {
+      name: "provide range for invalid multiline json",
+      mode: MODES.JSON,
+      doc: `{
         "foo": "example",
     "bar": "something else"
   }`,
-      [[32, 37, "Additional property <code>bar</code> is not allowed"]]
-    );
-  });
-  it("should provide formatted error message when required fields are missing", () => {
-    expectErrors(
-      `{
+      errors: [
+        {
+          from: 32,
+          to: 37,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "provide formatted error message when required fields are missing",
+      mode: MODES.JSON,
+      doc: `{
         "foo": "example",
         "object": {}
   }`,
-      [
-        [
-          46,
-          48,
-          "The required property <code>foo</code> is missing at <code>object</code>",
-        ],
-      ],
-      testSchema2
-    );
-  });
-  it("should provide formatted error message for oneOf fields with more than 2 items", () => {
-    expectErrors(
-      `{
+      errors: [
+        {
+          from: 46,
+          to: 48,
+          message: "The required property `foo` is missing at `object`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with more than 2 items",
+      mode: MODES.JSON,
+      doc: `{
         "foo": "example",
         "object": { "foo": "true" },
     "oneOfEg": 123
   }`,
-      [
-        [
-          80,
-          83,
-          "Expected one of <code>string</code>, <code>array</code>, or <code>boolean</code>",
-        ],
-      ],
-      testSchema2
-    );
-  });
-  it("should provide formatted error message for oneOf fields with less than 2 items", () => {
-    expectErrors(
-      `{
+      errors: [
+        {
+          from: 80,
+          to: 83,
+          message: "Expected one of `string`, `array`, or `boolean`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with less than 2 items",
+      mode: MODES.JSON,
+      doc: `{
         "foo": "example",
         "object": { "foo": "true" },
     "oneOfEg2": 123
   }`,
-      [[81, 84, "Expected one of <code>string</code> or <code>array</code>"]],
-      testSchema2
+      errors: [
+        {
+          from: 81,
+          to: 84,
+          message: "Expected one of `string` or `array`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    // JSON5
+    {
+      name: "provide range for a value error",
+      mode: MODES.JSON5,
+      doc: "{foo: 123}",
+      errors: [
+        {
+          from: 6,
+          to: 9,
+          message: "Expected `string` but received `number`",
+        },
+      ],
+    },
+    {
+      name: "provide range for an unknown key error",
+      mode: MODES.JSON5,
+      doc: "{foo: 'example', bar: 123}",
+      errors: [
+        {
+          from: 17,
+          to: 20,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "not handle invalid json",
+      mode: MODES.JSON5,
+      doc: "{foo: 'example' 'bar': 123}",
+      errors: [],
+    },
+    {
+      name: "provide range for invalid multiline json",
+      mode: MODES.JSON5,
+      doc: `{
+        foo: 'example',
+    bar: 'something else'
+  }`,
+      errors: [
+        {
+          from: 30,
+          to: 33,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "provide formatted error message when required fields are missing",
+      mode: MODES.JSON5,
+      doc: `{
+        foo: 'example',
+        object: {}
+  }`,
+      errors: [
+        {
+          from: 42,
+          to: 44,
+          message: "The required property `foo` is missing at `object`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with more than 2 items",
+      mode: MODES.JSON5,
+      doc: `{
+        foo: 'example',
+        object: { foo: 'true' },
+    oneOfEg: 123
+  }`,
+      errors: [
+        {
+          from: 72,
+          to: 75,
+          message: "Expected one of `string`, `array`, or `boolean`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with less than 2 items",
+      mode: MODES.JSON5,
+      doc: `{
+        foo: 'example',
+        object: { foo: 'true' },
+    oneOfEg2: 123
+  }`,
+      errors: [
+        {
+          from: 73,
+          to: 76,
+          message: "Expected one of `string` or `array`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    // YAML
+    {
+      name: "provide range for a value error",
+      mode: MODES.YAML,
+      doc: "foo: 123",
+      errors: [
+        {
+          from: 5,
+          to: 8,
+          message: "Expected `string` but received `number`",
+        },
+      ],
+    },
+    {
+      name: "provide range for an unknown key error",
+      mode: MODES.YAML,
+      doc: "foo: example\nbar: 123",
+      errors: [
+        {
+          from: 13,
+          to: 16,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "not handle invalid yaml",
+      mode: MODES.YAML,
+      doc: "foo: example\n- - -bar: 123",
+      errors: [],
+    },
+    {
+      name: "provide range for invalid multiline yaml",
+      mode: MODES.YAML,
+      doc: `foo: example
+bar: something else
+  `,
+      errors: [
+        {
+          from: 13,
+          to: 16,
+          message: "Additional property `bar` is not allowed",
+        },
+      ],
+    },
+    {
+      name: "provide formatted error message when required fields are missing",
+      mode: MODES.YAML,
+      doc: `foo: example
+object: {}
+  `,
+      errors: [
+        {
+          from: 13,
+          to: 19,
+          message: "The required property `foo` is missing at `object`",
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with more than 2 items",
+      mode: MODES.YAML,
+      doc: `foo: example
+object: { foo: true }
+oneOfEg: 123
+  `,
+      errors: [
+        {
+          from: 28,
+          message: "Expected `string` but received `boolean`",
+          to: 32,
+        },
+        {
+          from: 44,
+          message: "Expected one of `string`, `array`, or `boolean`",
+          to: 47,
+        },
+      ],
+      schema: testSchema2,
+    },
+    {
+      name: "provide formatted error message for oneOf fields with less than 2 items",
+      mode: MODES.YAML,
+      doc: `foo: example
+object: { foo: true }
+oneOfEg2: 123
+  `,
+      errors: [
+        {
+          from: 28,
+          message: "Expected `string` but received `boolean`",
+          to: 32,
+        },
+        {
+          from: 45,
+          message: "Expected one of `string` or `array`",
+          to: 48,
+        },
+      ],
+      schema: testSchema2,
+    },
+  ])("$name (mode: $mode)", ({ doc, mode, errors, schema }) => {
+    expectErrors(
+      doc,
+      errors.map((error) => [error.from, error.to, error.message]),
+      mode,
+      schema
     );
   });
 });
diff --git a/src/constants.ts b/src/constants.ts
index cc9d8af..58ea668 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -9,9 +9,34 @@ export const TOKENS = {
   PROPERTY: "Property",
   PROPERTY_NAME: "PropertyName",
   PROPERTY_COLON: "PropertyColon", // used in json5 grammar
+  ITEM: "Item", // used in yaml grammar
   JSON_TEXT: "JsonText",
   INVALID: "⚠",
+} as const;
+
+// TODO: To ensure that the YAML tokens are always mapped correctly,
+// we should change the TOKENS values to some other values and also create
+// mappings for the JSON tokens, which will force us to update all the token mappings whenever there is a change.
+export const YAML_TOKENS_MAPPING: Record<
+  string,
+  (typeof TOKENS)[keyof typeof TOKENS]
+> = {
+  Pair: TOKENS.PROPERTY,
+  Key: TOKENS.PROPERTY_NAME,
+  BlockSequence: TOKENS.ARRAY,
+  BlockMapping: TOKENS.OBJECT,
+  QuotedLiteral: TOKENS.STRING,
+  Literal: TOKENS.STRING, // best guess
+  Stream: TOKENS.JSON_TEXT,
+  Document: TOKENS.OBJECT,
 };
+export const JSON5_TOKENS_MAPPING: Record<
+  string,
+  (typeof TOKENS)[keyof typeof TOKENS]
+> = {
+  File: TOKENS.JSON_TEXT,
+};
+
 export const PRIMITIVE_TYPES = [
   TOKENS.STRING,
   TOKENS.NUMBER,
@@ -19,4 +44,10 @@ export const PRIMITIVE_TYPES = [
   TOKENS.FALSE,
   TOKENS.NULL,
 ];
-export const COMPLEX_TYPES = [TOKENS.OBJECT, TOKENS.ARRAY];
+export const COMPLEX_TYPES = [TOKENS.OBJECT, TOKENS.ARRAY, TOKENS.ITEM];
+
+export const MODES = {
+  JSON5: "json5",
+  JSON: "json4",
+  YAML: "yaml",
+} as const;
diff --git a/src/json-completion.ts b/src/json-completion.ts
index 737a785..d3f142f 100644
--- a/src/json-completion.ts
+++ b/src/json-completion.ts
@@ -16,21 +16,20 @@ import {
   isPrimitiveValueNode,
   stripSurroundingQuotes,
   getNodeAtPosition,
+  getClosestNode,
+  getMatchingChildrenNodes,
+  getMatchingChildNode,
+  getChildrenNodes,
+  surroundingDoubleQuotesToSingle,
 } from "./utils/node.js";
 import { getJSONSchema } from "./state.js";
 import { Draft07, isJsonError } from "json-schema-library";
-import { jsonPointerForPosition } from "./utils/jsonPointers.js";
-import { TOKENS } from "./constants.js";
-
-function json5PropertyInsertSnippet(rawWord: string, value: string) {
-  if (rawWord.startsWith('"')) {
-    return `"${value}"`;
-  }
-  if (rawWord.startsWith("'")) {
-    return `'${value}'`;
-  }
-  return value;
-}
+import {
+  jsonPointerForPosition,
+  resolveTokenName,
+} from "./utils/jsonPointers.js";
+import { MODES, TOKENS } from "./constants.js";
+import { JSONMode } from "./types.js";
 
 class CompletionCollector {
   completions = new Map<string, Completion>();
@@ -48,13 +47,16 @@ class CompletionCollector {
   }
 }
 
-type JSONCompletionOptions = {
-  mode?: "json" | "json5";
-};
+export interface JSONCompletionOptions {
+  mode?: JSONMode;
+}
 
 export class JSONCompletion {
   private schema: JSONSchema7 | null = null;
-  constructor(private opts: JSONCompletionOptions) {}
+  private mode: JSONMode = MODES.JSON;
+  constructor(private opts: JSONCompletionOptions) {
+    this.mode = opts.mode ?? MODES.JSON;
+  }
   public doComplete(ctx: CompletionContext) {
     this.schema = getJSONSchema(ctx.state)!;
     if (!this.schema) {
@@ -80,16 +82,24 @@ export class JSONCompletion {
 
     // Only show completions if we are filling out a word or right after the starting quote, or if explicitly requested
     if (
-      !(isPrimitiveValueNode(node) || isPropertyNameNode(node)) &&
+      !(
+        isPrimitiveValueNode(node, this.mode) ||
+        isPropertyNameNode(node, this.mode)
+      ) &&
       !ctx.explicit
     ) {
+      debug.log("xxx", "no completions for non-word/primitive", node);
       return result;
     }
 
     const currentWord = getWord(ctx.state.doc, node);
     const rawWord = getWord(ctx.state.doc, node, false);
     // Calculate overwrite range
-    if (node && (isPrimitiveValueNode(node) || isPropertyNameNode(node))) {
+    if (
+      node &&
+      (isPrimitiveValueNode(node, this.mode) ||
+        isPropertyNameNode(node, this.mode))
+    ) {
       result.from = node.from;
       result.to = node.to;
     } else {
@@ -121,37 +131,70 @@ export class JSONCompletion {
 
     let addValue = true;
 
-    if (isPropertyNameNode(node)) {
+    const closestPropertyNameNode = getClosestNode(
+      node,
+      TOKENS.PROPERTY_NAME,
+      this.mode
+    );
+    // if we are inside a property name node, we need to get the parent property name node
+    // The only reason we would be inside a property name node is if the current node is invalid or a literal/primitive node
+    if (closestPropertyNameNode) {
+      debug.log(
+        "xxx",
+        "closestPropertyNameNode",
+        closestPropertyNameNode,
+        "node",
+        node
+      );
+      node = closestPropertyNameNode;
+    }
+    if (isPropertyNameNode(node, this.mode)) {
+      debug.log("xxx", "isPropertyNameNode", node);
       const parent = node.parent;
       if (parent) {
         // get value node from parent
-        const valueNode = getChildValueNode(parent);
+        const valueNode = getChildValueNode(parent, this.mode);
         addValue =
           !valueNode ||
           (valueNode.name === TOKENS.INVALID &&
-            valueNode.from - valueNode.to === 0);
-        debug.log("xxx", "addValue", addValue, getChildValueNode(parent), node);
+            valueNode.from - valueNode.to === 0) ||
+          // TODO: Verify this doesn't break anything else
+          (valueNode.parent
+            ? getChildrenNodes(valueNode.parent).length <= 1
+            : false);
+        debug.log(
+          "xxx",
+          "addValue",
+          addValue,
+          getChildValueNode(parent, this.mode),
+          node
+        );
         // find object node
-        node =
-          [parent, parent.parent].find((p) => {
-            if (p?.name === TOKENS.OBJECT) {
-              return true;
-            }
-            return false;
-          }) ?? null;
+        node = getClosestNode(parent, TOKENS.OBJECT, this.mode) ?? null;
       }
     }
 
-    debug.log("xxx", node, currentWord, ctx);
+    debug.log(
+      "xxx",
+      node,
+      currentWord,
+      ctx,
+      "node at pos",
+      getNodeAtPosition(ctx.state, ctx.pos)
+    );
 
     // proposals for properties
     if (
       node &&
-      (node.name === TOKENS.OBJECT || node.name === TOKENS.JSON_TEXT) &&
-      isPropertyNameNode(getNodeAtPosition(ctx.state, ctx.pos))
+      [TOKENS.OBJECT, TOKENS.JSON_TEXT].includes(
+        resolveTokenName(node.name, this.mode) as any
+      ) &&
+      (isPropertyNameNode(getNodeAtPosition(ctx.state, ctx.pos), this.mode) ||
+        closestPropertyNameNode)
     ) {
       // don't suggest keys when the cursor is just before the opening curly brace
       if (node.from === ctx.pos) {
+        debug.log("xxx", "no completions for just before opening brace");
         return result;
       }
 
@@ -208,10 +251,17 @@ export class JSONCompletion {
     rawWord: string
   ) {
     // don't suggest properties that are already present
-    const properties = node.getChildren(TOKENS.PROPERTY);
+    const properties = getMatchingChildrenNodes(
+      node,
+      TOKENS.PROPERTY,
+      this.mode
+    );
     debug.log("xxx", "getPropertyCompletions", node, ctx, properties);
     properties.forEach((p) => {
-      const key = getWord(ctx.state.doc, p.getChild(TOKENS.PROPERTY_NAME));
+      const key = getWord(
+        ctx.state.doc,
+        getMatchingChildNode(p, TOKENS.PROPERTY_NAME, this.mode)
+      );
       collector.reserve(stripSurroundingQuotes(key));
     });
 
@@ -300,10 +350,8 @@ export class JSONCompletion {
       ? this.expandSchemaProperty(propertySchema, this.schema!)
       : propertySchema;
 
-    const isJSON5 = this.opts?.mode === "json5";
-    let resultText = isJSON5
-      ? json5PropertyInsertSnippet(rawWord, key)
-      : `"${key}"`;
+    let resultText = this.getInsertTextForPropertyName(key, rawWord);
+
     if (!addValue) {
       return resultText;
     }
@@ -361,10 +409,20 @@ export class JSONCompletion {
               value = "#{}";
               break;
             case "string":
-              value = isJSON5 ? "'#{}'" : '"#{}"';
+              value = this.getInsertTextForString("");
               break;
             case "object":
-              value = "{#{}}";
+              switch (this.mode) {
+                case MODES.JSON5:
+                  value = "{#{}}";
+                  break;
+                case MODES.YAML:
+                  value = "#{}";
+                  break;
+                default:
+                  value = "{#{}}";
+                  break;
+              }
               break;
             case "array":
               value = "[#{}]";
@@ -398,7 +456,45 @@ export class JSONCompletion {
 
     return resultText + value;
   }
+  private getInsertTextForPropertyName(key: string, rawWord: string) {
+    switch (this.mode) {
+      case MODES.JSON5: {
+        if (rawWord.startsWith('"')) {
+          return `"${key}"`;
+        }
+        if (rawWord.startsWith("'")) {
+          return `'${key}'`;
+        }
+        return key;
+      }
+      case MODES.YAML: {
+        if (rawWord.startsWith('"')) {
+          return `"${key}"`;
+        }
+        if (rawWord.startsWith("'")) {
+          return `'${key}'`;
+        }
+        return key;
+      }
+      default:
+        return `"${key}"`;
+    }
+  }
+  private getInsertTextForString(value: string, prf = "#") {
+    switch (this.mode) {
+      case MODES.JSON5:
+        return `'${prf}{${value}}'`;
+        break;
+      case MODES.YAML:
+        return `${prf}{${value}}`;
+        break;
+      default:
+        return `"${prf}{${value}}"`;
+        break;
+    }
+  }
 
+  // TODO: Is this actually working?
   private getInsertTextForGuessedValue(
     value: any,
     separatorAfter = ""
@@ -413,7 +509,7 @@ export class JSONCompletion {
         let snippetValue = JSON.stringify(value);
         snippetValue = snippetValue.substr(1, snippetValue.length - 2); // remove quotes
         snippetValue = this.getInsertTextForPlainText(snippetValue); // escape \ and }
-        return '"${' + snippetValue + '}"' + separatorAfter;
+        return this.getInsertTextForString(snippetValue, "$") + separatorAfter;
       }
       case "number":
       case "boolean":
@@ -450,7 +546,7 @@ export class JSONCompletion {
 
     debug.log("xxx", "getValueCompletions", node, ctx);
 
-    if (node && isPrimitiveValueNode(node)) {
+    if (node && isPrimitiveValueNode(node, this.mode)) {
       valueNode = node;
       node = node.parent;
     }
@@ -460,8 +556,12 @@ export class JSONCompletion {
       return;
     }
 
-    if (node.name === TOKENS.PROPERTY) {
-      const keyNode = node.getChild(TOKENS.PROPERTY_NAME);
+    if (resolveTokenName(node.name, this.mode) === TOKENS.PROPERTY) {
+      const keyNode = getMatchingChildNode(
+        node,
+        TOKENS.PROPERTY_NAME,
+        this.mode
+      );
       if (keyNode) {
         parentKey = getWord(ctx.state.doc, keyNode);
         node = node.parent;
@@ -469,7 +569,11 @@ export class JSONCompletion {
     }
 
     debug.log("xxx", "node", node, "parentKey", parentKey);
-    if (node && (parentKey !== undefined || node.name === TOKENS.ARRAY)) {
+    if (
+      node &&
+      (parentKey !== undefined ||
+        resolveTokenName(node.name, this.mode) === TOKENS.ARRAY)
+    ) {
       // Get matching schemas
       const schemas = this.getSchemas(schema, ctx);
       for (const s of schemas) {
@@ -477,7 +581,10 @@ export class JSONCompletion {
           return;
         }
 
-        if (node.name === TOKENS.ARRAY && s.items) {
+        if (
+          resolveTokenName(node.name, this.mode) === TOKENS.ARRAY &&
+          s.items
+        ) {
           let c = collector;
           if (s.uniqueItems) {
             c = {
@@ -496,7 +603,11 @@ export class JSONCompletion {
             let arrayIndex = 0;
             if (valueNode) {
               // get index of next node in array
-              const foundIdx = findNodeIndexInArrayNode(node, valueNode);
+              const foundIdx = findNodeIndexInArrayNode(
+                node,
+                valueNode,
+                this.mode
+              );
 
               if (foundIdx >= 0) {
                 arrayIndex = foundIdx;
@@ -593,7 +704,7 @@ export class JSONCompletion {
       }
       const completionItem: Completion = {
         type: type?.toString(),
-        label: this.getLabelForValue(value),
+        ...this.getAppliedValue(value),
         detail: "Default value",
       };
       collector.add(completionItem);
@@ -609,7 +720,7 @@ export class JSONCompletion {
         }
         collector.add({
           type: type?.toString(),
-          label: this.getLabelForValue(value),
+          ...this.getAppliedValue(value),
         });
         hasProposals = true;
       });
@@ -631,7 +742,7 @@ export class JSONCompletion {
     if (typeof schema.const !== "undefined") {
       collector.add({
         type: schema.type?.toString(),
-        label: this.getLabelForValue(schema.const),
+        ...this.getAppliedValue(schema.const),
 
         info: schema.description,
       });
@@ -642,7 +753,7 @@ export class JSONCompletion {
         const enm = schema.enum[i];
         collector.add({
           type: schema.type?.toString(),
-          label: this.getLabelForValue(enm),
+          ...this.getAppliedValue(enm),
           info: schema.description,
         });
       }
@@ -686,7 +797,7 @@ export class JSONCompletion {
     ctx: CompletionContext
   ): JSONSchema7Definition[] {
     const draft = new Draft07(this.schema!);
-    let pointer = jsonPointerForPosition(ctx.state, ctx.pos);
+    let pointer = jsonPointerForPosition(ctx.state, ctx.pos, -1, this.mode);
     let subSchema = draft.getSchema({ pointer });
     if (isJsonError(subSchema)) {
       subSchema = subSchema.data?.schema;
@@ -774,8 +885,25 @@ export class JSONCompletion {
     return curReference;
   }
 
-  private getLabelForValue(value: any): string {
-    return JSON.stringify(value);
+  private getAppliedValue(value: any): { label: string; apply: string } {
+    const stripped = stripSurroundingQuotes(JSON.stringify(value));
+    switch (this.mode) {
+      case MODES.JSON5:
+        return {
+          label: stripped,
+          apply: surroundingDoubleQuotesToSingle(JSON.stringify(value)),
+        };
+      case MODES.YAML:
+        return {
+          label: stripped,
+          apply: stripped,
+        };
+      default:
+        return {
+          label: stripped,
+          apply: JSON.stringify(value),
+        };
+    }
   }
 
   private getValueFromLabel(value: any): string {
@@ -811,16 +939,3 @@ export function jsonCompletion(opts: JSONCompletionOptions = {}) {
     return completion.doComplete(ctx);
   };
 }
-
-/**
- * provides a JSON schema enabled autocomplete extension for codemirror and json5
- * @group Codemirror Extensions
- */
-export function json5Completion(
-  opts: Omit<JSONCompletionOptions, "mode"> = {}
-) {
-  const completion = new JSONCompletion({ ...opts, mode: "json5" });
-  return function jsonDoCompletion(ctx: CompletionContext) {
-    return completion.doComplete(ctx);
-  };
-}
diff --git a/src/json-hover.ts b/src/json-hover.ts
index eafe0a5..7db548c 100644
--- a/src/json-hover.ts
+++ b/src/json-hover.ts
@@ -9,9 +9,11 @@ import {
 import { jsonPointerForPosition } from "./utils/jsonPointers.js";
 import { joinWithOr } from "./utils/formatting.js";
 import { debug } from "./utils/debug.js";
-import { Side } from "./types.js";
+import { JSONMode, Side } from "./types.js";
 import { el } from "./utils/dom.js";
 import { getJSONSchema } from "./state.js";
+import { MODES } from "./constants.js";
+import { renderMarkdown } from "./utils/markdown.js";
 
 export type CursorData = { schema?: JsonSchema; pointer: string };
 
@@ -20,6 +22,7 @@ export type FoundCursorData = Required<CursorData>;
 export type HoverTexts = { message: string; typeInfo: string };
 
 export type HoverOptions = {
+  mode?: JSONMode;
   /**
    * Generate the text to display in the hover tooltip
    */
@@ -60,11 +63,13 @@ function formatComplexType(
 
 export class JSONHover {
   private schema: Draft | null = null;
+  private mode: JSONMode = MODES.JSON;
   public constructor(private opts?: HoverOptions) {
     this.opts = {
       parser: JSON.parse,
       ...this.opts,
     };
+    this.mode = this.opts?.mode ?? MODES.JSON;
   }
   public getDataForCursor(
     view: EditorView,
@@ -79,7 +84,7 @@ export class JSONHover {
     }
     this.schema = new Draft04(schema);
 
-    const pointer = jsonPointerForPosition(view.state, pos, side);
+    const pointer = jsonPointerForPosition(view.state, pos, side, this.mode);
 
     let data = undefined;
     // TODO: use the AST tree to return the right hand, data so that we don't have to parse the doc
@@ -116,27 +121,25 @@ export class JSONHover {
           text: message,
         }),
         el("div", { class: "cm6-json-schema-hover--code-wrapper" }, [
-          typeInfo.includes("<code>")
-            ? el("div", {
-                class: "cm6-json-schema-hover--code",
-                inner: typeInfo,
-              })
-            : el("code", {
-                class: "cm6-json-schema-hover--code",
-                text: typeInfo,
-              }),
+          el("div", {
+            class: "cm6-json-schema-hover--code",
+            inner: renderMarkdown(typeInfo),
+          }),
         ]),
       ]);
     }
     return el("div", { class: "cm6-json-schema-hover" }, [
       el("div", { class: "cm6-json-schema-hover--code-wrapper" }, [
-        el("code", { class: "cm6-json-schema-hover--code", text: typeInfo }),
+        el("code", {
+          class: "cm6-json-schema-hover--code",
+          inner: renderMarkdown(typeInfo),
+        }),
       ]),
     ]);
   }
 
   public getHoverTexts(data: FoundCursorData, draft: Draft): HoverTexts {
-    let typeInfo = null;
+    let typeInfo = "";
     let message = null;
 
     const { schema } = data;
@@ -155,13 +158,13 @@ export class JSONHover {
         : schema.type;
     }
     if (schema.enum) {
-      typeInfo = `<code>enum</code>: ${joinWithOr(schema.enum)}`;
+      typeInfo = `\`enum\`: ${joinWithOr(schema.enum)}`;
     }
     if (schema.format) {
-      typeInfo += ` <code>format</code>: ${schema.format}`;
+      typeInfo += `\`format\`: ${schema.format}`;
     }
     if (schema.pattern) {
-      typeInfo += ` <code>pattern</code>: ${schema.pattern}`;
+      typeInfo += `\`pattern\`: ${schema.pattern}`;
     }
     if (schema.description) {
       message = schema.description;
@@ -179,6 +182,7 @@ export class JSONHover {
       end = pos;
     try {
       const cursorData = this.getDataForCursor(view, pos, side);
+      debug.log("cursorData", cursorData);
       // if we don't have a (sub)schema, we can't show anything
       if (!cursorData?.schema) return null;
 
diff --git a/src/json-validation.ts b/src/json-validation.ts
index 7dcd25e..f8242c6 100644
--- a/src/json-validation.ts
+++ b/src/json-validation.ts
@@ -4,11 +4,25 @@ import { Draft04, type Draft, type JsonError } from "json-schema-library";
 
 import { getJSONSchema, schemaStateField } from "./state.js";
 import { joinWithOr } from "./utils/formatting.js";
-import { JSONPointerData } from "./types.js";
+import { JSONMode, JSONPointerData } from "./types.js";
 import { parseJSONDocumentState } from "./utils/parseJSONDocument.js";
 import { RequiredPick } from "./types.js";
 import { el } from "./utils/dom.js";
-
+import { renderMarkdown } from "./utils/markdown.js";
+import { MODES } from "./constants.js";
+import { parseYAMLDocumentState } from "./utils/parse-yaml-document.js";
+import { parseJSON5DocumentState } from "./utils/parseJSON5Document.js";
+
+const getDefaultParser = (mode: JSONMode): typeof parseJSONDocumentState => {
+  switch (mode) {
+    case MODES.JSON:
+      return parseJSONDocumentState;
+    case MODES.JSON5:
+      return parseJSON5DocumentState;
+    case MODES.YAML:
+      return parseYAMLDocumentState;
+  }
+};
 // return an object path that matches with the json-source-map pointer
 const getErrorPath = (error: JsonError): string => {
   // if a pointer is present, return without #
@@ -23,10 +37,11 @@ const getErrorPath = (error: JsonError): string => {
   return "";
 };
 
-export type JSONValidationOptions = {
+export interface JSONValidationOptions {
+  mode?: JSONMode;
   formatError?: (error: JsonError) => string;
   jsonParser?: typeof parseJSONDocumentState;
-};
+}
 
 type JSONValidationSettings = RequiredPick<JSONValidationOptions, "jsonParser">;
 
@@ -59,12 +74,11 @@ const positionalErrors = [
 export class JSONValidation {
   private schema: Draft | null = null;
 
-  private options: JSONValidationSettings;
-  public constructor(options?: JSONValidationOptions) {
-    this.options = {
-      jsonParser: parseJSONDocumentState,
-      ...options,
-    };
+  private mode: JSONMode = MODES.JSON;
+  private parser: typeof parseJSONDocumentState = parseJSONDocumentState;
+  public constructor(private options?: JSONValidationOptions) {
+    this.mode = this.options?.mode ?? MODES.JSON;
+    this.parser = this.options?.jsonParser ?? getDefaultParser(this.mode);
 
     // TODO: support other versions of json schema.
     // most standard schemas are draft 4 for some reason, probably
@@ -87,19 +101,17 @@ export class JSONValidation {
       )}`;
     }
     if (error.code === "type-error") {
-      return `Expected <code>${
+      return `Expected \`${
         error?.data?.expected && Array.isArray(error?.data?.expected)
           ? joinWithOr(error?.data?.expected)
           : error?.data?.expected
-      }</code> but received <code>${error?.data?.received}</code>`;
+      }\` but received \`${error?.data?.received}\``;
     }
     const message = error.message
       // don't mention root object
       .replaceAll("in `#` ", "")
       .replaceAll("/", ".")
-      .replaceAll("#.", "")
-      // replace backticks with <code> tags
-      .replaceAll(/`([^`]*)`/gm, "<code>$1</code>");
+      .replaceAll("#.", "");
     return message;
   };
 
@@ -117,7 +129,7 @@ export class JSONValidation {
     // ignore blank json strings
     if (!text || text.trim().length < 3) return [];
 
-    const json = this.options.jsonParser(view.state);
+    const json = this.parser(view.state);
 
     let errors: JsonError[] = [];
     try {
@@ -160,12 +172,10 @@ export class JSONValidation {
           acc.push({
             from,
             to,
-            // TODO: create a domnode and replace `` with <code></code>
-            // renderMessage: () => error.message,
             message: errorString,
             renderMessage: () => {
               const dom = el("div", {});
-              dom.innerHTML = errorString;
+              dom.innerHTML = renderMarkdown(errorString);
               return dom;
             },
             severity: "error",
diff --git a/src/json5.ts b/src/json5.ts
deleted file mode 100644
index 8695360..0000000
--- a/src/json5.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// json5
-export { json5SchemaLinter } from "./json5-validation.js";
-export { json5SchemaHover } from "./json5-hover.js";
-export { json5Completion } from "./json-completion.js";
-
-/**
- * @group Bundled Codemirror Extensions
- */
-export { json5Schema } from "./json5-bundled.js";
-
-export * from "./utils/parseJSON5Document.js";
diff --git a/src/json5-bundled.ts b/src/json5/bundled.ts
similarity index 71%
rename from src/json5-bundled.ts
rename to src/json5/bundled.ts
index ca29549..67bcf44 100644
--- a/src/json5-bundled.ts
+++ b/src/json5/bundled.ts
@@ -1,13 +1,13 @@
 import { JSONSchema7 } from "json-schema";
 import { json5, json5Language, json5ParseLinter } from "codemirror-json5";
 import { hoverTooltip } from "@codemirror/view";
-import { json5Completion } from "./json-completion.js";
-import { json5SchemaLinter } from "./json5-validation.js";
-import { json5SchemaHover } from "./json5-hover.js";
+import { json5Completion } from "./completion.js";
+import { json5SchemaLinter } from "./validation.js";
+import { json5SchemaHover } from "./hover.js";
 
 import { linter } from "@codemirror/lint";
-import { stateExtensions } from "./state.js";
-import { handleRefresh } from "./json-validation.js";
+import { handleRefresh } from "../json-validation.js";
+import { stateExtensions } from "../state.js";
 
 /**
  * Full featured cm6 extension for json5, including `codemirror-json5`
diff --git a/src/json5/completion.ts b/src/json5/completion.ts
new file mode 100644
index 0000000..cd78ec1
--- /dev/null
+++ b/src/json5/completion.ts
@@ -0,0 +1,16 @@
+import { CompletionContext } from "@codemirror/autocomplete";
+import { MODES } from "../constants";
+import { JSONCompletion, JSONCompletionOptions } from "../json-completion";
+
+/**
+ * provides a JSON schema enabled autocomplete extension for codemirror and json5
+ * @group Codemirror Extensions
+ */
+export function json5Completion(
+  opts: Omit<JSONCompletionOptions, "mode"> = {}
+) {
+  const completion = new JSONCompletion({ ...opts, mode: MODES.JSON5 });
+  return function jsonDoCompletion(ctx: CompletionContext) {
+    return completion.doComplete(ctx);
+  };
+}
diff --git a/src/json5-hover.ts b/src/json5/hover.ts
similarity index 75%
rename from src/json5-hover.ts
rename to src/json5/hover.ts
index 1bb3a73..50022d4 100644
--- a/src/json5-hover.ts
+++ b/src/json5/hover.ts
@@ -1,8 +1,8 @@
 import { type EditorView } from "@codemirror/view";
-import { type HoverOptions, JSONHover } from "./json-hover.js";
-import { type JSONSchema7 } from "json-schema";
+import { type HoverOptions, JSONHover } from "../json-hover.js";
 import json5 from "json5";
-import { Side } from "./types.js";
+import { Side } from "../types.js";
+import { MODES } from "../constants.js";
 
 export type JSON5HoverOptions = Exclude<HoverOptions, "mode">;
 
@@ -14,6 +14,7 @@ export function json5SchemaHover(options?: JSON5HoverOptions) {
   const hover = new JSONHover({
     ...options,
     parser: json5.parse,
+    mode: MODES.JSON5,
   });
   return async function jsonDoHover(view: EditorView, pos: number, side: Side) {
     return hover.doHover(view, pos, side);
diff --git a/src/json5/index.ts b/src/json5/index.ts
new file mode 100644
index 0000000..3a93718
--- /dev/null
+++ b/src/json5/index.ts
@@ -0,0 +1,11 @@
+// json5
+export { json5SchemaLinter } from "./validation.js";
+export { json5SchemaHover } from "./hover.js";
+export { json5Completion } from "./completion.js";
+
+/**
+ * @group Bundled Codemirror Extensions
+ */
+export { json5Schema } from "./bundled.js";
+
+export * from "../utils/parseJSON5Document.js";
diff --git a/src/json5-validation.ts b/src/json5/validation.ts
similarity index 73%
rename from src/json5-validation.ts
rename to src/json5/validation.ts
index c47445c..1beb742 100644
--- a/src/json5-validation.ts
+++ b/src/json5/validation.ts
@@ -2,8 +2,9 @@ import { EditorView } from "@codemirror/view";
 import {
   JSONValidation,
   type JSONValidationOptions,
-} from "./json-validation.js";
-import { parseJSON5DocumentState } from "./utils/parseJSON5Document.js";
+} from "../json-validation.js";
+import { parseJSON5DocumentState } from "../utils/parseJSON5Document.js";
+import { MODES } from "../constants.js";
 
 /**
  * Instantiates a JSONValidation instance with the JSON5 mode
@@ -12,6 +13,7 @@ import { parseJSON5DocumentState } from "./utils/parseJSON5Document.js";
 export function json5SchemaLinter(options?: JSONValidationOptions) {
   const validation = new JSONValidation({
     jsonParser: parseJSON5DocumentState,
+    mode: MODES.JSON5,
     ...options,
   });
   return (view: EditorView) => {
diff --git a/src/types.ts b/src/types.ts
index 27b5fef..26161e3 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,3 +1,5 @@
+import { MODES } from "./constants";
+
 export type RequiredPick<T, F extends keyof T> = Omit<T, F> &
   Required<Pick<T, F>>;
 
@@ -19,3 +21,4 @@ export type JSONPointersMap = Map<
   string,
   JSONPointerData | JSONPartialPointerData
 >;
+export type JSONMode = (typeof MODES)[keyof typeof MODES];
diff --git a/src/utils/__tests__/jsonPointers.spec.ts b/src/utils/__tests__/jsonPointers.spec.ts
index a0ff1ff..c419149 100644
--- a/src/utils/__tests__/jsonPointers.spec.ts
+++ b/src/utils/__tests__/jsonPointers.spec.ts
@@ -1,125 +1,291 @@
 import { describe, it, expect } from "vitest";
-import { json } from "@codemirror/lang-json";
-import { json5 } from "codemirror-json5";
 
 import { getJsonPointers, jsonPointerForPosition } from "../jsonPointers.js";
 import { EditorState } from "@codemirror/state";
-
-const getPointer = (jsonString: string, pos: number) => {
-  const state = EditorState.create({
-    doc: jsonString,
-    extensions: [json()],
-  });
-  return jsonPointerForPosition(state, pos, 1);
-};
-
-const getJSON5Pointer = (jsonString: string, pos: number) => {
-  const state = EditorState.create({ doc: jsonString, extensions: [json5()] });
-  return jsonPointerForPosition(state, pos, 1);
-};
+import { MODES } from "../../constants.js";
+import { getExtensions } from "../../__tests__/__helpers__/index.js";
 
 describe("jsonPointerForPosition", () => {
-  it("should return full pointer path for a position", () => {
-    expect(getPointer('{"object": { "foo": true }, "bar": 123}', 14)).toEqual(
-      "/object/foo"
-    );
-  });
-  it("should return full pointer path for a position for associative array", () => {
-    expect(
-      getPointer('[{"object": [{ "foo": true }], "bar": 123}]', 16)
-    ).toEqual("/0/object/0/foo");
-  });
-  it("should return full pointer path for a position for a deep associative array", () => {
-    expect(
-      getPointer(
-        '[{"object": [{ "foo": { "example": true } }], "bar": 123}]',
-        27
-      )
-    ).toEqual("/0/object/0/foo/example");
-  });
-});
-
-describe("jsonPointerForPosition for json5", () => {
-  it("should return full pointer path for a position", () => {
-    expect(
-      getJSON5Pointer('{"object": { "foo": true }, "bar": 123}', 14)
-    ).toEqual("/object/foo");
-  });
-  it("should return full pointer path for a position for associative array", () => {
-    expect(
-      getJSON5Pointer(`[{"object": [{ foo: true }], 'bar': 123}]`, 16)
-    ).toEqual("/0/object/0/foo");
-  });
-  it("should return full pointer path for a position for a deep associative array", () => {
-    expect(
-      getJSON5Pointer(
-        '[{"object": [{ "foo": { example: true } }], "bar": 123}]',
-        25
-      )
-    ).toEqual("/0/object/0/foo/example");
-  });
+  it.each([
+    {
+      name: "simple",
+      doc: '{"object": { "foo": true }, "bar": 123}',
+      pos: 14,
+      expected: "/object/foo",
+      mode: MODES.JSON,
+    },
+    {
+      name: "associative array",
+      doc: '[{"object": [{ "foo": true }], "bar": 123}]',
+      pos: 16,
+      expected: "/0/object/0/foo",
+      mode: MODES.JSON,
+    },
+    {
+      name: "deep associative array",
+      doc: '[{"object": [{ "foo": { "example": true } }], "bar": 123}]',
+      pos: 27,
+      expected: "/0/object/0/foo/example",
+      mode: MODES.JSON,
+    },
+    {
+      name: "simple - json5",
+      doc: '{"object": { "foo": true }, "bar": 123}',
+      pos: 14,
+      expected: "/object/foo",
+      mode: MODES.JSON5,
+    },
+    {
+      name: "associative array - json5",
+      doc: '[{"object": [{ "foo": true }], "bar": 123}]',
+      pos: 16,
+      expected: "/0/object/0/foo",
+      mode: MODES.JSON5,
+    },
+    {
+      name: "deep associative array - json5",
+      doc: '[{"object": [{ "foo": { example: true } }], "bar": 123}]',
+      pos: 25,
+      expected: "/0/object/0/foo/example",
+      mode: MODES.JSON5,
+    },
+    // ...
+    {
+      name: "simple - yaml",
+      doc: `---
+object:
+  foo: true
+bar: 123
+`,
+      pos: 14,
+      expected: "/object/foo",
+      mode: MODES.YAML,
+    },
+    {
+      name: "associative array - yaml",
+      doc: `---
+- object:
+    - foo: true
+  bar: 123
+`,
+      pos: 20,
+      expected: "/0/object/0/foo",
+      mode: MODES.YAML,
+    },
+    {
+      name: "deep associative array - yaml",
+      doc: `---
+- object:
+    - foo:
+        example: true
+  bar: 123
+`,
+      pos: 34,
+      expected: "/0/object/0/foo/example",
+      mode: MODES.YAML,
+    },
+  ])(
+    "should return full pointer path for a position for $name, mode: $mode",
+    ({ doc, mode, pos, expected }) => {
+      const state = EditorState.create({
+        doc,
+        extensions: [getExtensions(mode)],
+      });
+      const pointer = jsonPointerForPosition(state, pos, 1, mode);
+      expect(pointer).toEqual(expected);
+    }
+  );
 });
 
 describe("getJsonPointers", () => {
-  it("should return a map of all pointers for a document", () => {
-    const state = EditorState.create({
+  it.each([
+    {
       doc: '{"object": { "foo": true }, "bar": 123, "baz": [1,2,3], "boop": [{"foo": true}]}',
-      extensions: [json()],
-    });
-    const pointers = getJsonPointers(state);
-    expect(pointers.get("/object/foo")).toEqual({
-      keyFrom: 13,
-      keyTo: 18,
-      valueFrom: 20,
-      valueTo: 24,
-    });
-    expect(pointers.get("/bar")).toEqual({
-      keyFrom: 28,
-      keyTo: 33,
-      valueFrom: 35,
-      valueTo: 38,
-    });
-    expect(pointers.get("/baz")).toEqual({
-      keyFrom: 40,
-      keyTo: 45,
-      valueFrom: 47,
-      valueTo: 54,
-    });
-    expect(pointers.get("/boop/0")).toEqual({
-      keyFrom: 65,
-      keyTo: 78,
-      valueFrom: 78,
-      valueTo: 79,
-    });
-    // TODO: return pointers for all array indexes, not just objects
-    // expect(pointers.get("/baz/0")).toEqual({
-    //   keyFrom: 40,
-    //   keyTo: 45,
-    //   valueFrom: 47,
-    //   valueTo: 55,
-    // });
-  });
-});
-
-describe("getJsonPointers for json5", () => {
-  it("should return a map of all pointers for a json5 document", () => {
-    const state = EditorState.create({
-      doc: '{"object": { foo: true }, bar: 123}',
-      extensions: [json5()],
-    });
-
-    const pointers = getJsonPointers(state, "json5");
-    expect(pointers.get("/object/foo")).toEqual({
-      keyFrom: 13,
-      keyTo: 16,
-      valueFrom: 18,
-      valueTo: 22,
-    });
-    expect(pointers.get("/bar")).toEqual({
-      keyFrom: 26,
-      keyTo: 29,
-      valueFrom: 31,
-      valueTo: 34,
-    });
-  });
+      mode: MODES.JSON,
+      expected: {
+        "": {
+          keyFrom: 0,
+          keyTo: 80,
+        },
+        "/bar": {
+          keyFrom: 28,
+          keyTo: 33,
+          valueFrom: 35,
+          valueTo: 38,
+        },
+        "/baz": {
+          keyFrom: 40,
+          keyTo: 45,
+          valueFrom: 47,
+          valueTo: 54,
+        },
+        // TODO: return pointers for all array indexes, not just objects
+        // "/baz/0": {
+        //   keyFrom: 40,
+        //   keyTo: 45,
+        //   valueFrom: 47,
+        //   valueTo: 55,
+        // },
+        "/boop": {
+          keyFrom: 56,
+          keyTo: 62,
+          valueFrom: 64,
+          valueTo: 79,
+        },
+        "/boop/0": {
+          keyFrom: 65,
+          keyTo: 78,
+          // TODO: These look erroneous. There is no key-value pair for array items
+          valueFrom: 78,
+          valueTo: 79,
+        },
+        "/boop/0/foo": {
+          keyFrom: 66,
+          keyTo: 71,
+          valueFrom: 73,
+          valueTo: 77,
+        },
+        "/object": {
+          keyFrom: 11,
+          keyTo: 26,
+        },
+        "/object/foo": {
+          keyFrom: 13,
+          keyTo: 18,
+          valueFrom: 20,
+          valueTo: 24,
+        },
+      },
+    },
+    {
+      doc: `{"object": { foo: true }, bar: 123, 'baz': [1,2,3], boop: [{foo: true}]}`,
+      mode: MODES.JSON5,
+      expected: {
+        "": {
+          keyFrom: 0,
+          keyTo: 72,
+        },
+        "/bar": {
+          keyFrom: 26,
+          keyTo: 29,
+          valueFrom: 31,
+          valueTo: 34,
+        },
+        "/baz": {
+          keyFrom: 36,
+          keyTo: 41,
+          valueFrom: 43,
+          valueTo: 50,
+        },
+        // TODO: return pointers for all array indexes, not just objects
+        // "/baz/0": {
+        //   keyFrom: 40,
+        //   keyTo: 45,
+        //   valueFrom: 47,
+        //   valueTo: 55,
+        // },
+        "/boop": {
+          keyFrom: 52,
+          keyTo: 56,
+          valueFrom: 58,
+          valueTo: 71,
+        },
+        "/boop/0": {
+          keyFrom: 59,
+          keyTo: 70,
+        },
+        "/boop/0/foo": {
+          keyFrom: 60,
+          keyTo: 63,
+          valueFrom: 65,
+          valueTo: 69,
+        },
+        "/object": {
+          keyFrom: 11,
+          keyTo: 24,
+        },
+        "/object/foo": {
+          keyFrom: 13,
+          keyTo: 16,
+          valueFrom: 18,
+          valueTo: 22,
+        },
+      },
+    },
+    {
+      doc: `---
+object:
+  foo: true
+bar: 123
+baz:
+  - 1
+  - 2
+  - 3
+boop:
+  - foo: true
+`,
+      mode: MODES.YAML,
+      expected: {
+        "": {
+          keyFrom: 4,
+          keyTo: 75,
+        },
+        "/bar": {
+          keyFrom: 24,
+          keyTo: 27,
+          valueFrom: 29,
+          valueTo: 32,
+        },
+        "/baz": {
+          keyFrom: 33,
+          keyTo: 36,
+          valueFrom: 40,
+          valueTo: 55,
+        },
+        // TODO: return pointers for all array indexes, not just objects
+        // "/baz/0": {
+        //   keyFrom: 40,
+        //   keyTo: 45,
+        //   valueFrom: 47,
+        //   valueTo: 55,
+        // },
+        "/boop": {
+          keyFrom: 56,
+          keyTo: 60,
+          valueFrom: 64,
+          valueTo: 75,
+        },
+        "/boop/0": {
+          keyFrom: 66,
+          keyTo: 75,
+        },
+        "/boop/0/foo": {
+          keyFrom: 66,
+          keyTo: 69,
+          valueFrom: 71,
+          valueTo: 75,
+        },
+        "/object": {
+          keyFrom: 14,
+          keyTo: 23,
+        },
+        "/object/foo": {
+          keyFrom: 14,
+          keyTo: 17,
+          valueFrom: 19,
+          valueTo: 23,
+        },
+      },
+    },
+  ])(
+    "should return a map of all pointers for a document (mode: $mode)",
+    ({ doc, mode, expected }) => {
+      const state = EditorState.create({
+        doc,
+        extensions: [getExtensions(mode)],
+      });
+      const pointers = getJsonPointers(state, mode);
+      expect(Object.fromEntries(pointers.entries())).toEqual(expected);
+    }
+  );
 });
diff --git a/src/utils/__tests__/node.spec.ts b/src/utils/__tests__/node.spec.ts
new file mode 100644
index 0000000..cd3edd3
--- /dev/null
+++ b/src/utils/__tests__/node.spec.ts
@@ -0,0 +1,183 @@
+import { describe, expect, it } from "vitest";
+import { JSONMode } from "../../types";
+import { MODES } from "../../constants";
+import { EditorState } from "@codemirror/state";
+import { getNodeAtPosition } from "../node";
+import { getExtensions } from "../../__tests__/__helpers__";
+
+// complex data structure for testing. Keep these in sync.
+const testJsonData = `
+{
+  "bog": {
+    "array": [
+      {
+        "foo": true
+      },
+      {
+        "bar": 123
+      }
+    ]
+  },
+  "bar": 123,
+  "baz": [1, 2, 3]
+}
+`;
+
+const testJson5Data = `
+{
+  bog: {
+    array: [
+      {
+        'foo': true
+      },
+      {
+        'bar': 123
+      }
+    ]
+  },
+  'bar': 123,
+  'baz': [1, 2, 3]
+}
+`;
+
+const testYamlData = `---
+bog:
+  array:
+    - foo: true
+    - bar: 123
+bar: 123
+baz: [1, 2, 3]
+`;
+
+const getTestData = (mode: JSONMode) => {
+  switch (mode) {
+    case MODES.JSON:
+      return testJsonData;
+    case MODES.JSON5:
+      return testJson5Data;
+    case MODES.YAML:
+      return testYamlData;
+  }
+};
+
+describe("getNodeAtPosition", () => {
+  it.each([
+    {
+      mode: MODES.JSON,
+      pos: 1,
+      expectedName: "JsonText",
+    },
+    {
+      mode: MODES.JSON,
+      pos: 6,
+      expectedName: "PropertyName",
+    },
+    {
+      mode: MODES.JSON,
+      pos: 13,
+      expectedName: "{",
+    },
+    {
+      mode: MODES.JSON,
+      pos: 28,
+      expectedName: "[",
+    },
+    {
+      mode: MODES.JSON,
+      pos: 53,
+      expectedName: "True",
+    },
+    {
+      mode: MODES.JSON,
+      pos: 121,
+      expectedName: "Property",
+    },
+    // JSON5
+    {
+      mode: MODES.JSON5,
+      pos: 1,
+      expectedName: "File",
+    },
+    {
+      mode: MODES.JSON5,
+      pos: 6,
+      expectedName: "PropertyName",
+    },
+    {
+      mode: MODES.JSON5,
+      pos: 11,
+      expectedName: "{",
+    },
+    {
+      mode: MODES.JSON5,
+      pos: 24,
+      expectedName: "[",
+    },
+    {
+      mode: MODES.JSON5,
+      pos: 49,
+      expectedName: "True",
+    },
+    {
+      mode: MODES.JSON5,
+      pos: 85,
+      expectedName: "Property",
+    },
+    // YAML
+    {
+      mode: MODES.YAML,
+      pos: 1,
+      expectedName: "DirectiveEnd",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 4,
+      expectedName: "Document",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 5,
+      expectedName: "Literal",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 11,
+      expectedName: "Pair",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 16,
+      expectedName: "Literal",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 22,
+      expectedName: "Pair",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 30,
+      expectedName: "Literal",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 38,
+      expectedName: "BlockSequence",
+    },
+    {
+      mode: MODES.YAML,
+      pos: 54,
+      expectedName: "Pair",
+    },
+  ])(
+    "should return node at position $pos (mode: $mode)",
+    ({ mode, expectedName, pos }) => {
+      const state = EditorState.create({
+        doc: getTestData(mode),
+        extensions: [getExtensions(mode)],
+      });
+      const node = getNodeAtPosition(state, pos);
+      expect(node.name).toBe(expectedName);
+    }
+  );
+});
diff --git a/src/utils/__tests__/parse-yaml-document.spec.ts b/src/utils/__tests__/parse-yaml-document.spec.ts
new file mode 100644
index 0000000..ba41f50
--- /dev/null
+++ b/src/utils/__tests__/parse-yaml-document.spec.ts
@@ -0,0 +1,24 @@
+import { it, describe, expect } from "vitest";
+
+import { yaml } from "@codemirror/lang-yaml";
+import { parseYAMLDocumentState } from "../parse-yaml-document.js";
+import { EditorState } from "@codemirror/state";
+
+const testDoc = `---
+object:
+  foo: true
+bar: 123`;
+
+describe("parseYAMLDocumentState", () => {
+  it("should return a map of all pointers for a json4 document", () => {
+    const state = EditorState.create({ doc: testDoc, extensions: [yaml()] });
+    const doc = parseYAMLDocumentState(state);
+    expect(doc.data).toEqual({ object: { foo: true }, bar: 123 });
+    expect(Array.from(doc.pointers.keys())).toEqual([
+      "",
+      "/object",
+      "/object/foo",
+      "/bar",
+    ]);
+  });
+});
diff --git a/src/utils/debug.ts b/src/utils/debug.ts
index 8fe5f0d..4e00c25 100644
--- a/src/utils/debug.ts
+++ b/src/utils/debug.ts
@@ -5,4 +5,10 @@ export const debug = {
     }
     console.log(...args);
   },
+  warn: (...args: any[]) => {
+    if (process.env.NODE_ENV !== "development") {
+      return;
+    }
+    console.warn(...args);
+  },
 };
diff --git a/src/utils/dom.ts b/src/utils/dom.ts
index b7def98..9e154e3 100644
--- a/src/utils/dom.ts
+++ b/src/utils/dom.ts
@@ -1,11 +1,3 @@
-// export function el(tagName: string, className?: string) {
-//   const e = document.createElement(tagName);
-//   if (className) {
-//     e.classList.add(className);
-//   }
-//   return e;
-// }
-
 type Attributes = "class" | "text" | "id" | "role" | "aria-label" | "inner";
 
 export function el(
diff --git a/src/utils/formatting.ts b/src/utils/formatting.ts
index c492c2f..2dbeb18 100644
--- a/src/utils/formatting.ts
+++ b/src/utils/formatting.ts
@@ -3,7 +3,7 @@
 export const joinWithOr = (arr: string[], getPath?: (err: any) => any) => {
   const needsComma = arr.length > 2;
   let data = arr.map((err: any, i: number) => {
-    const result = `<code>` + (getPath ? getPath(err) : err) + `</code>`;
+    const result = `\`` + (getPath ? getPath(err) : err) + `\``;
     if (i === arr.length - 1) return "or " + result;
     return result;
   });
diff --git a/src/utils/jsonPointers.ts b/src/utils/jsonPointers.ts
index 7ee6187..ad8703f 100644
--- a/src/utils/jsonPointers.ts
+++ b/src/utils/jsonPointers.ts
@@ -1,20 +1,43 @@
 import { syntaxTree } from "@codemirror/language";
 import { EditorState, Text } from "@codemirror/state";
 import { SyntaxNode, SyntaxNodeRef } from "@lezer/common";
-import { JSONPointersMap, Side } from "../types.js";
-import { TOKENS } from "../constants.js";
-import { findNodeIndexInArrayNode, getWord, isValueNode } from "./node.js";
+import { JSONMode, JSONPointersMap, Side } from "../types.js";
+import {
+  JSON5_TOKENS_MAPPING,
+  MODES,
+  TOKENS,
+  YAML_TOKENS_MAPPING,
+} from "../constants.js";
+import {
+  findNodeIndexInArrayNode,
+  getMatchingChildNode,
+  getWord,
+  isValueNode,
+} from "./node.js";
 
-export type JSONMode = "json4" | "json5";
+export const resolveTokenName = (nodeName: string, mode: JSONMode) => {
+  switch (mode) {
+    case MODES.YAML:
+      return YAML_TOKENS_MAPPING[nodeName] ?? nodeName;
+    case MODES.JSON5:
+      return JSON5_TOKENS_MAPPING[nodeName] ?? nodeName;
+    default:
+      return nodeName;
+  }
+};
 
 // adapted from https://discuss.codemirror.net/t/json-pointer-at-cursor-seeking-implementation-critique/4793/3
 // this could be useful for other things later!
-export function getJsonPointerAt(docText: Text, node: SyntaxNode): string {
+export function getJsonPointerAt(
+  docText: Text,
+  node: SyntaxNode,
+  mode: JSONMode
+): string {
   const path: string[] = [];
   for (let n: SyntaxNode | null = node; n?.parent; n = n.parent) {
-    switch (n.parent.name) {
+    switch (resolveTokenName(n.parent.name, mode)) {
       case TOKENS.PROPERTY: {
-        const name = n.parent.getChild(TOKENS.PROPERTY_NAME);
+        const name = getMatchingChildNode(n.parent, TOKENS.PROPERTY_NAME, mode);
         if (name) {
           path.unshift(
             getWord(docText, name).replace(/[/~]/g, (v: string) =>
@@ -25,8 +48,8 @@ export function getJsonPointerAt(docText: Text, node: SyntaxNode): string {
         break;
       }
       case TOKENS.ARRAY: {
-        if (isValueNode(n)) {
-          const index = findNodeIndexInArrayNode(n.parent, n);
+        if (isValueNode(n, mode)) {
+          const index = findNodeIndexInArrayNode(n.parent, n, mode);
           path.unshift(`${index}`);
         }
         break;
@@ -45,9 +68,14 @@ export function getJsonPointerAt(docText: Text, node: SyntaxNode): string {
 export const jsonPointerForPosition = (
   state: EditorState,
   pos: number,
-  side: Side = -1
+  side: Side = -1,
+  mode: JSONMode
 ) => {
-  return getJsonPointerAt(state.doc, syntaxTree(state).resolve(pos, side));
+  return getJsonPointerAt(
+    state.doc,
+    syntaxTree(state).resolve(pos, side),
+    mode
+  );
 };
 
 /**
@@ -56,14 +84,18 @@ export const jsonPointerForPosition = (
  */
 export const getJsonPointers = (
   state: EditorState,
-  mode: JSONMode = "json4"
+  mode: JSONMode
 ): JSONPointersMap => {
-  const json = syntaxTree(state);
+  const tree = syntaxTree(state);
   const pointers: JSONPointersMap = new Map();
-  json.iterate({
+  tree.iterate({
     enter: (type: SyntaxNodeRef) => {
-      if (type.name === "PropertyName" || type.name === "Object") {
-        const pointer = getJsonPointerAt(state.doc, type.node);
+      if (
+        [TOKENS.PROPERTY_NAME, TOKENS.OBJECT].includes(
+          resolveTokenName(type.name, mode) as any
+        )
+      ) {
+        const pointer = getJsonPointerAt(state.doc, type.node, mode);
 
         const { from: keyFrom, to: keyTo } = type.node;
         // if there's no value, we can't get the valueFrom/to
@@ -71,8 +103,9 @@ export const getJsonPointers = (
           pointers.set(pointer, { keyFrom, keyTo });
           return true;
         }
+        // TODO: Make this generic enough to avoid mode-specific checks
         const nextNode =
-          mode === "json4"
+          mode === MODES.JSON
             ? type.node?.nextSibling?.node
             : type.node?.nextSibling?.node?.nextSibling?.node;
         if (!nextNode) {
diff --git a/src/utils/markdown.ts b/src/utils/markdown.ts
new file mode 100644
index 0000000..01ea0a8
--- /dev/null
+++ b/src/utils/markdown.ts
@@ -0,0 +1,4 @@
+import markdownit from "markdown-it";
+export function renderMarkdown(markdown: string) {
+  return markdownit().renderInline(markdown);
+}
diff --git a/src/utils/node.ts b/src/utils/node.ts
index 8db32fc..4081785 100644
--- a/src/utils/node.ts
+++ b/src/utils/node.ts
@@ -1,8 +1,9 @@
 import { SyntaxNode } from "@lezer/common";
-import { COMPLEX_TYPES, TOKENS, PRIMITIVE_TYPES } from "../constants.js";
+import { COMPLEX_TYPES, TOKENS, PRIMITIVE_TYPES, MODES } from "../constants.js";
 import { EditorState, Text } from "@codemirror/state";
 import { syntaxTree } from "@codemirror/language";
-import { Side } from "../types.js";
+import { JSONMode, Side } from "../types.js";
+import { resolveTokenName } from "./jsonPointers.js";
 
 export const getNodeAtPosition = (
   state: EditorState,
@@ -15,6 +16,9 @@ export const getNodeAtPosition = (
 export const stripSurroundingQuotes = (str: string) => {
   return str.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
 };
+export const surroundingDoubleQuotesToSingle = (str: string) => {
+  return str.replace(/^"(.*)"$/, "'$1'");
+};
 
 export const getWord = (
   doc: Text,
@@ -25,35 +29,45 @@ export const getWord = (
   return stripQuotes ? stripSurroundingQuotes(word) : word;
 };
 
-export const isInvalidValueNode = (node: SyntaxNode) => {
+export const isInvalidValueNode = (node: SyntaxNode, mode: JSONMode) => {
   return (
-    node.name === TOKENS.INVALID &&
-    (node.prevSibling?.name === TOKENS.PROPERTY_NAME ||
-      node.prevSibling?.name === TOKENS.PROPERTY_COLON)
+    resolveTokenName(node.name, mode) === TOKENS.INVALID &&
+    (resolveTokenName(node.prevSibling?.name ?? "", mode) ===
+      TOKENS.PROPERTY_NAME ||
+      resolveTokenName(node.prevSibling?.name ?? "", mode) ===
+        TOKENS.PROPERTY_COLON)
   );
 };
 
-export const isPrimitiveValueNode = (node: SyntaxNode) => {
-  return PRIMITIVE_TYPES.includes(node.name) || isInvalidValueNode(node);
+export const isPrimitiveValueNode = (node: SyntaxNode, mode: JSONMode) => {
+  return (
+    PRIMITIVE_TYPES.includes(resolveTokenName(node.name, mode) as any) ||
+    isInvalidValueNode(node, mode)
+  );
 };
 
-export const isValueNode = (node: SyntaxNode) => {
+export const isValueNode = (node: SyntaxNode, mode: JSONMode) => {
   return (
-    [...PRIMITIVE_TYPES, ...COMPLEX_TYPES].includes(node.name) ||
-    isInvalidValueNode(node)
+    [...PRIMITIVE_TYPES, ...COMPLEX_TYPES].includes(
+      resolveTokenName(node.name, mode) as any
+    ) || isInvalidValueNode(node, mode)
   );
 };
 
-export const isPropertyNameNode = (node: SyntaxNode) => {
+export const isPropertyNameNode = (node: SyntaxNode, mode: JSONMode) => {
   return (
-    node.name === TOKENS.PROPERTY_NAME ||
-    (node.name === TOKENS.INVALID &&
-      (node.prevSibling?.name === TOKENS.PROPERTY ||
-        node.prevSibling?.name === "{"))
+    resolveTokenName(node.name, mode) === TOKENS.PROPERTY_NAME ||
+    (resolveTokenName(node.name, mode) === TOKENS.INVALID &&
+      (resolveTokenName(node.prevSibling?.name ?? "", mode) ===
+        TOKENS.PROPERTY ||
+        resolveTokenName(node.prevSibling?.name ?? "", mode) === "{")) ||
+    // TODO: Can we make this work without checking for the mode?
+    (mode === MODES.YAML &&
+      resolveTokenName(node.parent?.name ?? "", mode) === TOKENS.OBJECT)
   );
 };
 
-const getChildrenNodes = (node: SyntaxNode) => {
+export const getChildrenNodes = (node: SyntaxNode) => {
   const children = [];
   let child = node.firstChild;
   while (child) {
@@ -66,20 +80,62 @@ const getChildrenNodes = (node: SyntaxNode) => {
   return children;
 };
 
-export const getChildValueNode = (node: SyntaxNode) => {
-  return getChildrenNodes(node).find((n) => isPrimitiveValueNode(n));
+export const getMatchingChildrenNodes = (
+  node: SyntaxNode,
+  nodeName: string,
+  mode: JSONMode
+) => {
+  return getChildrenNodes(node).filter(
+    (n) => resolveTokenName(n.name, mode) === nodeName
+  );
+};
+
+export const getMatchingChildNode = (
+  node: SyntaxNode,
+  nodeName: string,
+  mode: JSONMode
+) => {
+  return (
+    getChildrenNodes(node).find(
+      (n) => resolveTokenName(n.name, mode) === nodeName
+    ) ?? null
+  );
+};
+
+export const getChildValueNode = (node: SyntaxNode, mode: JSONMode) => {
+  return getChildrenNodes(node).find((n) => isPrimitiveValueNode(n, mode));
 };
 
-const getArrayNodeChildren = (node: SyntaxNode) => {
+const getArrayNodeChildren = (node: SyntaxNode, mode: JSONMode) => {
   return getChildrenNodes(node).filter(
-    (n) => PRIMITIVE_TYPES.includes(n.name) || COMPLEX_TYPES.includes(n.name)
+    (n) =>
+      PRIMITIVE_TYPES.includes(resolveTokenName(n.name, mode) as any) ||
+      COMPLEX_TYPES.includes(resolveTokenName(n.name, mode) as any)
   );
 };
 export const findNodeIndexInArrayNode = (
   arrayNode: SyntaxNode,
-  valueNode: SyntaxNode
+  valueNode: SyntaxNode,
+  mode: JSONMode
 ) => {
-  return getArrayNodeChildren(arrayNode).findIndex(
+  return getArrayNodeChildren(arrayNode, mode).findIndex(
     (nd) => nd.from === valueNode.from && nd.to === valueNode.to
   );
 };
+
+export const getClosestNode = (
+  node: SyntaxNode,
+  nodeName: string,
+  mode: JSONMode,
+  depth = Infinity
+) => {
+  let n: SyntaxNode | null = node;
+  while (n && depth > 0) {
+    if (resolveTokenName(n.name, mode) === nodeName) {
+      return n;
+    }
+    n = n.parent;
+    depth--;
+  }
+  return null;
+};
diff --git a/src/utils/parse-yaml-document.ts b/src/utils/parse-yaml-document.ts
new file mode 100644
index 0000000..e6bc3d7
--- /dev/null
+++ b/src/utils/parse-yaml-document.ts
@@ -0,0 +1,23 @@
+/**
+ * Mimics the behavior of `json-source-map`'s `parseJSONDocument` function using codemirror EditorState... for YAML
+ */
+
+import { yaml } from "@codemirror/lang-yaml";
+import YAML from "yaml";
+import { EditorState } from "@codemirror/state";
+import { getJsonPointers } from "./jsonPointers.js";
+import { MODES } from "../constants.js";
+
+/**
+ * Return parsed data and YAML pointers for a given codemirror EditorState
+ * @group Utilities
+ */
+export function parseYAMLDocumentState(state: EditorState) {
+  let data = null;
+  try {
+    data = YAML.parse(state.doc.toString());
+    // return pointers regardless of whether YAML.parse succeeds
+  } catch {}
+  const pointers = getJsonPointers(state, MODES.YAML);
+  return { data, pointers };
+}
diff --git a/src/utils/parseJSON5Document.ts b/src/utils/parseJSON5Document.ts
index e3cc1ac..89bd03f 100644
--- a/src/utils/parseJSON5Document.ts
+++ b/src/utils/parseJSON5Document.ts
@@ -6,6 +6,7 @@ import { json5 as json5mode } from "codemirror-json5";
 import json5 from "json5";
 import { EditorState } from "@codemirror/state";
 import { getJsonPointers } from "./jsonPointers.js";
+import { MODES } from "../constants.js";
 
 /**
  * Return parsed data and json5 pointers for a given codemirror EditorState
@@ -17,7 +18,7 @@ export function parseJSON5DocumentState(state: EditorState) {
     data = json5.parse(state.doc.toString());
     // return pointers regardless of whether JSON.parse succeeds
   } catch {}
-  const pointers = getJsonPointers(state, "json5");
+  const pointers = getJsonPointers(state, MODES.JSON5);
   return { data, pointers };
 }
 
diff --git a/src/utils/parseJSONDocument.ts b/src/utils/parseJSONDocument.ts
index 39f068a..1df0794 100644
--- a/src/utils/parseJSONDocument.ts
+++ b/src/utils/parseJSONDocument.ts
@@ -1,6 +1,7 @@
 import { json } from "@codemirror/lang-json";
 import { EditorState } from "@codemirror/state";
 import { getJsonPointers } from "./jsonPointers.js";
+import { MODES } from "../constants.js";
 
 /**
  * Return parsed data and json pointers for a given codemirror EditorState
@@ -12,7 +13,7 @@ export function parseJSONDocumentState(state: EditorState) {
     data = JSON.parse(state.doc.toString());
     // return pointers regardless of whether JSON.parse succeeds
   } catch {}
-  const pointers = getJsonPointers(state, "json4");
+  const pointers = getJsonPointers(state, MODES.JSON);
   return { data, pointers };
 }
 
diff --git a/src/yaml/bundled.ts b/src/yaml/bundled.ts
new file mode 100644
index 0000000..558c5c7
--- /dev/null
+++ b/src/yaml/bundled.ts
@@ -0,0 +1,28 @@
+import { JSONSchema7 } from "json-schema";
+import { yaml, yamlLanguage } from "@codemirror/lang-yaml";
+import { hoverTooltip } from "@codemirror/view";
+import { handleRefresh } from "../json-validation.js";
+import { stateExtensions } from "../state.js";
+
+import { linter } from "@codemirror/lint";
+import { yamlSchemaLinter } from "./validation.js";
+import { yamlCompletion } from "./completion.js";
+import { yamlSchemaHover } from "./hover.js";
+
+/**
+ * Full featured cm6 extension for json, including `@codemirror/lang-json`
+ * @group Bundled Codemirror Extensions
+ */
+export function yamlSchema(schema?: JSONSchema7) {
+  return [
+    yaml(),
+    linter(yamlSchemaLinter(), {
+      needsRefresh: handleRefresh,
+    }),
+    yamlLanguage.data.of({
+      autocomplete: yamlCompletion(),
+    }),
+    hoverTooltip(yamlSchemaHover()),
+    stateExtensions(schema),
+  ];
+}
diff --git a/src/yaml/completion.ts b/src/yaml/completion.ts
new file mode 100644
index 0000000..b9ce9eb
--- /dev/null
+++ b/src/yaml/completion.ts
@@ -0,0 +1,14 @@
+import { CompletionContext } from "@codemirror/autocomplete";
+import { MODES } from "../constants";
+import { JSONCompletion, JSONCompletionOptions } from "../json-completion";
+
+/**
+ * provides a JSON schema enabled autocomplete extension for codemirror and yaml
+ * @group Codemirror Extensions
+ */
+export function yamlCompletion(opts: Omit<JSONCompletionOptions, "mode"> = {}) {
+  const completion = new JSONCompletion({ ...opts, mode: MODES.YAML });
+  return function jsonDoCompletion(ctx: CompletionContext) {
+    return completion.doComplete(ctx);
+  };
+}
diff --git a/src/yaml/hover.ts b/src/yaml/hover.ts
new file mode 100644
index 0000000..08a84af
--- /dev/null
+++ b/src/yaml/hover.ts
@@ -0,0 +1,22 @@
+import { type EditorView } from "@codemirror/view";
+import { type HoverOptions, JSONHover } from "../json-hover.js";
+import YAML from "yaml";
+import { Side } from "../types.js";
+import { MODES } from "../constants.js";
+
+export type YAMLHoverOptions = Exclude<HoverOptions, "mode">;
+
+/**
+ * Instantiates a JSONHover instance with the YAML mode
+ * @group Codemirror Extensions
+ */
+export function yamlSchemaHover(options?: YAMLHoverOptions) {
+  const hover = new JSONHover({
+    ...options,
+    parser: YAML.parse,
+    mode: MODES.YAML,
+  });
+  return async function jsonDoHover(view: EditorView, pos: number, side: Side) {
+    return hover.doHover(view, pos, side);
+  };
+}
diff --git a/src/yaml/index.ts b/src/yaml/index.ts
new file mode 100644
index 0000000..74b1488
--- /dev/null
+++ b/src/yaml/index.ts
@@ -0,0 +1,11 @@
+// yaml
+export { yamlSchemaLinter } from "./validation.js";
+export { yamlSchemaHover } from "./hover.js";
+export { yamlCompletion } from "./completion.js";
+
+/**
+ * @group Bundled Codemirror Extensions
+ */
+export { yamlSchema } from "./bundled.js";
+
+export * from "../utils/parseJSON5Document.js";
diff --git a/src/yaml/validation.ts b/src/yaml/validation.ts
new file mode 100644
index 0000000..f3ba0fa
--- /dev/null
+++ b/src/yaml/validation.ts
@@ -0,0 +1,22 @@
+import { EditorView } from "@codemirror/view";
+import {
+  JSONValidation,
+  type JSONValidationOptions,
+} from "../json-validation.js";
+import { parseYAMLDocumentState } from "../utils/parse-yaml-document.js";
+import { MODES } from "../constants.js";
+
+/**
+ * Instantiates a JSONValidation instance with the YAML mode
+ * @group Codemirror Extensions
+ */
+export function yamlSchemaLinter(options?: JSONValidationOptions) {
+  const validation = new JSONValidation({
+    jsonParser: parseYAMLDocumentState,
+    mode: MODES.YAML,
+    ...options,
+  });
+  return (view: EditorView) => {
+    return validation.doValidation(view);
+  };
+}