From c6944518e72aef0a2b81952dff6bc0114b8c6be0 Mon Sep 17 00:00:00 2001
From: Samuel <samuelimolo4real@gmail.com>
Date: Fri, 23 Feb 2024 03:16:00 +0100
Subject: [PATCH] Added YAML support (#85)

Closes #84

- Added YAML support
- Also updated the DOM rendering bits to use markdown instead of setting
the HTML directly, which is a safer approach
- Also slightly improved the demo UI (it didn't look good with black
text on black background)
- Also added a bunch of tests

To support YAML (and potentially other formats), I updated the logic to
"resolve" tokens before using them. This is important since the [YAML
grammar/tokens](https://github.com/lezer-parser/yaml/blob/main/src/yaml.grammar)
is different from the [JSON
grammar/tokens](https://github.com/lezer-parser/json/blob/main/src/json.grammar)
(which is very similar to the [JSON5
grammar](https://github.com/dimfeld/lezer-json5/blob/master/src/json5.grammar)).
So we map the tokens from the different grammars to the equivalent token
in the "base" grammar (currently this is the JSON grammar tokens but I
think we can/should map to some other arbitrary token set which will
force us to properly implement the mappings, otherwise additional
changes made may work in JSON mode but without proper testing, may not
work in YAML mode, if the mappings were not added).
---
 .changeset/silly-oranges-worry.md             |   5 +
 dev/index.html                                |  10 +
 dev/index.ts                                  |  18 +-
 dev/sample-text.ts                            |   9 +
 package.json                                  |  20 +-
 pnpm-lock.yaml                                | 112 ++-
 src/__tests__/__helpers__/completion.ts       |  21 +-
 src/__tests__/__helpers__/index.ts            |  17 +
 src/__tests__/json-completion.spec.ts         | 764 +++++++++++-------
 src/__tests__/json-hover.spec.ts              | 216 +++--
 src/__tests__/json-validation.spec.ts         | 354 ++++++--
 src/constants.ts                              |  33 +-
 src/json-completion.ts                        | 249 ++++--
 src/json-hover.ts                             |  36 +-
 src/json-validation.ts                        |  48 +-
 src/json5.ts                                  |  11 -
 src/{json5-bundled.ts => json5/bundled.ts}    |  10 +-
 src/json5/completion.ts                       |  16 +
 src/{json5-hover.ts => json5/hover.ts}        |   7 +-
 src/json5/index.ts                            |  11 +
 .../validation.ts}                            |   6 +-
 src/types.ts                                  |   3 +
 src/utils/__tests__/jsonPointers.spec.ts      | 394 ++++++---
 src/utils/__tests__/node.spec.ts              | 183 +++++
 .../__tests__/parse-yaml-document.spec.ts     |  24 +
 src/utils/debug.ts                            |   6 +
 src/utils/dom.ts                              |   8 -
 src/utils/formatting.ts                       |   2 +-
 src/utils/jsonPointers.ts                     |  67 +-
 src/utils/markdown.ts                         |   4 +
 src/utils/node.ts                             | 102 ++-
 src/utils/parse-yaml-document.ts              |  23 +
 src/utils/parseJSON5Document.ts               |   3 +-
 src/utils/parseJSONDocument.ts                |   3 +-
 src/yaml/bundled.ts                           |  28 +
 src/yaml/completion.ts                        |  14 +
 src/yaml/hover.ts                             |  22 +
 src/yaml/index.ts                             |  11 +
 src/yaml/validation.ts                        |  22 +
 39 files changed, 2164 insertions(+), 728 deletions(-)
 create mode 100644 .changeset/silly-oranges-worry.md
 create mode 100644 src/__tests__/__helpers__/index.ts
 delete mode 100644 src/json5.ts
 rename src/{json5-bundled.ts => json5/bundled.ts} (71%)
 create mode 100644 src/json5/completion.ts
 rename src/{json5-hover.ts => json5/hover.ts} (75%)
 create mode 100644 src/json5/index.ts
 rename src/{json5-validation.ts => json5/validation.ts} (73%)
 create mode 100644 src/utils/__tests__/node.spec.ts
 create mode 100644 src/utils/__tests__/parse-yaml-document.spec.ts
 create mode 100644 src/utils/markdown.ts
 create mode 100644 src/utils/parse-yaml-document.ts
 create mode 100644 src/yaml/bundled.ts
 create mode 100644 src/yaml/completion.ts
 create mode 100644 src/yaml/hover.ts
 create mode 100644 src/yaml/index.ts
 create mode 100644 src/yaml/validation.ts

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);
+  };
+}