modern-monaco 0.2.1 → 0.3.0

package/dist/lsp/json/worker.mjs

@@ -1157,7 +1157,7 @@ function format2(documentText, range, options) {
   return format(documentText, range, options);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/objects.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/objects.js
 function equals(one, other) {
   if (one === other) {
     return true;
@@ -1222,7 +1222,7 @@ function isObject(val) {
   return typeof val === "object" && val !== null && !Array.isArray(val);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/strings.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/strings.js
 function startsWith(haystack, needle) {
   if (haystack.length < needle.length) {
     return false;
@@ -2679,7 +2679,7 @@ function getWellformedEdit(textEdit) {
   return textEdit;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageTypes.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageTypes.js
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["Undefined"] = 0] = "Undefined";
@@ -3113,7 +3113,7 @@ function format3(template, values) {
   return template.replace(_format2Regexp, (match, group) => values[group] ?? match);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/parser/jsonParser.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/parser/jsonParser.js
 var formats = {
   "color-hex": { errorMessage: t("Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."), pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/ },
   "date-time": { errorMessage: t("String is not a RFC3339 date-time."), pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i },
@@ -4353,7 +4353,7 @@ function parse3(textDocument, config) {
   return new JSONDocument(_root, problems, commentRanges);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/json.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/json.js
 function stringifyObject(obj, indent, stringifyLiteral) {
   if (obj !== null && typeof obj === "object") {
     const newIndent = indent + "	";
@@ -4392,7 +4392,7 @@ function stringifyObject(obj, indent, stringifyLiteral) {
   return stringifyLiteral(obj);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonCompletion.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonCompletion.js
 var valueCommitCharacters = [",", "}", "]"];
 var propertyCommitCharacters = [":"];
 var JSONCompletion = class {
@@ -4629,6 +4629,11 @@ var JSONCompletion = class {
               propertyNameCompletionItem(schemaPropertyNames.enum[i], enumDescription, enumDetails, enumSortText);
             }
           }
+          if (schemaPropertyNames.examples) {
+            for (let i = 0; i < schemaPropertyNames.examples.length; i++) {
+              propertyNameCompletionItem(schemaPropertyNames.examples[i], void 0, void 0, void 0);
+            }
+          }
           if (schemaPropertyNames.const) {
             propertyNameCompletionItem(schemaPropertyNames.const, void 0, schemaPropertyNames.completionDetail, schemaPropertyNames.suggestSortText);
           }
@@ -5321,7 +5326,7 @@ var JSONCompletion = class {
   }
 };
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonHover.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonHover.js
 var JSONHover = class {
   constructor(schemaService, contributions = [], promiseConstructor) {
     this.schemaService = schemaService;
@@ -5361,58 +5366,54 @@ var JSONHover = class {
       }
     }
     return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
-      if (schema && node) {
-        const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
-        let title = void 0;
-        let markdownDescription = void 0;
-        let markdownEnumValueDescription = void 0, enumValue = void 0;
-        matchingSchemas.every((s) => {
-          if (s.node === node && !s.inverted && s.schema) {
-            title = title || s.schema.title;
-            markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown(s.schema.description);
-            if (s.schema.enum) {
-              const idx = s.schema.enum.indexOf(getNodeValue3(node));
-              if (s.schema.markdownEnumDescriptions) {
-                markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
-              } else if (s.schema.enumDescriptions) {
-                markdownEnumValueDescription = toMarkdown(s.schema.enumDescriptions[idx]);
-              }
-              if (markdownEnumValueDescription) {
-                enumValue = s.schema.enum[idx];
-                if (typeof enumValue !== "string") {
-                  enumValue = JSON.stringify(enumValue);
-                }
-              }
+      if (!schema) {
+        return null;
+      }
+      let title = void 0;
+      let markdownDescription = void 0;
+      let markdownEnumValueDescription = void 0, enumValue = void 0;
+      const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset).filter((s) => s.node === node && !s.inverted).map((s) => s.schema);
+      for (const schema2 of matchingSchemas) {
+        title = title || schema2.title;
+        markdownDescription = markdownDescription || schema2.markdownDescription || toMarkdown(schema2.description);
+        if (schema2.enum) {
+          const idx = schema2.enum.indexOf(getNodeValue3(node));
+          if (schema2.markdownEnumDescriptions) {
+            markdownEnumValueDescription = schema2.markdownEnumDescriptions[idx];
+          } else if (schema2.enumDescriptions) {
+            markdownEnumValueDescription = toMarkdown(schema2.enumDescriptions[idx]);
+          }
+          if (markdownEnumValueDescription) {
+            enumValue = schema2.enum[idx];
+            if (typeof enumValue !== "string") {
+              enumValue = JSON.stringify(enumValue);
             }
           }
-          return true;
-        });
-        let result = "";
-        if (title) {
-          result = toMarkdown(title);
         }
-        if (markdownDescription) {
-          if (result.length > 0) {
-            result += "\n\n";
-          }
-          result += markdownDescription;
+      }
+      let result = "";
+      if (title) {
+        result = toMarkdown(title);
+      }
+      if (markdownDescription) {
+        if (result.length > 0) {
+          result += "\n\n";
         }
-        if (markdownEnumValueDescription) {
-          if (result.length > 0) {
-            result += "\n\n";
-          }
-          result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
+        result += markdownDescription;
+      }
+      if (markdownEnumValueDescription) {
+        if (result.length > 0) {
+          result += "\n\n";
         }
-        return createHover([result]);
+        result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
       }
-      return null;
+      return createHover([result]);
     });
   }
 };
 function toMarkdown(plain) {
   if (plain) {
-    const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, "$1\n\n$3");
-    return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
+    return plain.trim().replace(/[\\`*_{}[\]()<>#+\-.!]/g, "\\$&").replace(/([ \t]+)/g, (_match, g1) => "&nbsp;".repeat(g1.length)).replace(/\n/g, "\\\n");
   }
   return void 0;
 }
@@ -5423,7 +5424,7 @@ function toMarkdownCodeBlock(content) {
   return content;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonValidation.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonValidation.js
 var JSONValidation = class {
   constructor(jsonSchemaService, promiseConstructor) {
     this.jsonSchemaService = jsonSchemaService;
@@ -5568,7 +5569,7 @@ function toDiagnosticSeverity(severityLevel) {
   return void 0;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/colors.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/colors.js
 var Digit0 = 48;
 var Digit9 = 57;
 var A = 65;
@@ -5626,7 +5627,7 @@ function colorFromHex(text) {
   return void 0;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonDocumentSymbols.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonDocumentSymbols.js
 var JSONDocumentSymbols = class {
   constructor(schemaService) {
     this.schemaService = schemaService;
@@ -5878,7 +5879,596 @@ function getName(node) {
   return getNodeValue3(node) || t("<empty>");
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/configuration.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/schemas/draft-2019-09-flat.js
+var draft_2019_09_flat_default = {
+  $id: "https://json-schema.org/draft/2019-09/schema",
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  title: "(Flattened static) Core and Validation specifications meta-schema",
+  type: [
+    "object",
+    "boolean"
+  ],
+  properties: {
+    definitions: {
+      $comment: "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    dependencies: {
+      $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+      type: "object",
+      additionalProperties: {
+        anyOf: [
+          {
+            $ref: "#"
+          },
+          {
+            $ref: "#/$defs/stringArray"
+          }
+        ]
+      }
+    },
+    $id: {
+      type: "string",
+      format: "uri-reference",
+      $comment: "Non-empty fragments not allowed.",
+      pattern: "^[^#]*#?$"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    $anchor: {
+      type: "string",
+      pattern: "^[A-Za-z][-A-Za-z0-9.:_]*$"
+    },
+    $ref: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $recursiveAnchor: {
+      type: "boolean",
+      default: false
+    },
+    $vocabulary: {
+      type: "object",
+      propertyNames: {
+        type: "string",
+        format: "uri"
+      },
+      additionalProperties: {
+        type: "boolean"
+      }
+    },
+    $comment: {
+      type: "string"
+    },
+    $defs: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    additionalItems: {
+      $ref: "#"
+    },
+    unevaluatedItems: {
+      $ref: "#"
+    },
+    items: {
+      anyOf: [
+        {
+          $ref: "#"
+        },
+        {
+          $ref: "#/$defs/schemaArray"
+        }
+      ]
+    },
+    contains: {
+      $ref: "#"
+    },
+    additionalProperties: {
+      $ref: "#"
+    },
+    unevaluatedProperties: {
+      $ref: "#"
+    },
+    properties: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      propertyNames: {
+        format: "regex"
+      },
+      default: {}
+    },
+    dependentSchemas: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      }
+    },
+    propertyNames: {
+      $ref: "#"
+    },
+    if: {
+      $ref: "#"
+    },
+    then: {
+      $ref: "#"
+    },
+    else: {
+      $ref: "#"
+    },
+    allOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    anyOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    oneOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    not: {
+      $ref: "#"
+    },
+    multipleOf: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    maximum: {
+      type: "number"
+    },
+    exclusiveMaximum: {
+      type: "number"
+    },
+    minimum: {
+      type: "number"
+    },
+    exclusiveMinimum: {
+      type: "number"
+    },
+    maxLength: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minLength: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    pattern: {
+      type: "string",
+      format: "regex"
+    },
+    maxItems: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minItems: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    uniqueItems: {
+      type: "boolean",
+      default: false
+    },
+    maxContains: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minContains: {
+      $ref: "#/$defs/nonNegativeInteger",
+      default: 1
+    },
+    maxProperties: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minProperties: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    required: {
+      $ref: "#/$defs/stringArray"
+    },
+    dependentRequired: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/stringArray"
+      }
+    },
+    const: true,
+    enum: {
+      type: "array",
+      items: true
+    },
+    type: {
+      anyOf: [
+        {
+          $ref: "#/$defs/simpleTypes"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/simpleTypes"
+          },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    default: true,
+    deprecated: {
+      type: "boolean",
+      default: false
+    },
+    readOnly: {
+      type: "boolean",
+      default: false
+    },
+    writeOnly: {
+      type: "boolean",
+      default: false
+    },
+    examples: {
+      type: "array",
+      items: true
+    },
+    format: {
+      type: "string"
+    },
+    contentMediaType: {
+      type: "string"
+    },
+    contentEncoding: {
+      type: "string"
+    },
+    contentSchema: {
+      $ref: "#"
+    }
+  },
+  $defs: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: {
+        $ref: "#"
+      }
+    },
+    nonNegativeInteger: {
+      type: "integer",
+      minimum: 0
+    },
+    nonNegativeIntegerDefault0: {
+      $ref: "#/$defs/nonNegativeInteger",
+      default: 0
+    },
+    simpleTypes: {
+      enum: [
+        "array",
+        "boolean",
+        "integer",
+        "null",
+        "number",
+        "object",
+        "string"
+      ]
+    },
+    stringArray: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      uniqueItems: true,
+      default: []
+    }
+  }
+};
+
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/schemas/draft-2020-12-flat.js
+var draft_2020_12_flat_default = {
+  $id: "https://json-schema.org/draft/2020-12/schema",
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "(Flattened static) Core and Validation specifications meta-schema",
+  type: [
+    "object",
+    "boolean"
+  ],
+  properties: {
+    definitions: {
+      $comment: "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    dependencies: {
+      $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+      type: "object",
+      additionalProperties: {
+        anyOf: [
+          {
+            $ref: "#"
+          },
+          {
+            $ref: "#/$defs/stringArray"
+          }
+        ]
+      }
+    },
+    $id: {
+      type: "string",
+      format: "uri-reference",
+      $comment: "Non-empty fragments not allowed.",
+      pattern: "^[^#]*#?$"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    $anchor: {
+      type: "string",
+      pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+    },
+    $ref: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $dynamicRef: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $vocabulary: {
+      type: "object",
+      propertyNames: {
+        type: "string",
+        format: "uri"
+      },
+      additionalProperties: {
+        type: "boolean"
+      }
+    },
+    $comment: {
+      type: "string"
+    },
+    $defs: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    prefixItems: {
+      $ref: "#/$defs/schemaArray"
+    },
+    items: {
+      $ref: "#"
+    },
+    contains: {
+      $ref: "#"
+    },
+    additionalProperties: {
+      $ref: "#"
+    },
+    properties: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      },
+      propertyNames: {
+        format: "regex"
+      },
+      default: {}
+    },
+    dependentSchemas: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#"
+      }
+    },
+    propertyNames: {
+      $ref: "#"
+    },
+    if: {
+      $ref: "#"
+    },
+    then: {
+      $ref: "#"
+    },
+    else: {
+      $ref: "#"
+    },
+    allOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    anyOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    oneOf: {
+      $ref: "#/$defs/schemaArray"
+    },
+    not: {
+      $ref: "#"
+    },
+    unevaluatedItems: {
+      $ref: "#"
+    },
+    unevaluatedProperties: {
+      $ref: "#"
+    },
+    multipleOf: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    maximum: {
+      type: "number"
+    },
+    exclusiveMaximum: {
+      type: "number"
+    },
+    minimum: {
+      type: "number"
+    },
+    exclusiveMinimum: {
+      type: "number"
+    },
+    maxLength: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minLength: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    pattern: {
+      type: "string",
+      format: "regex"
+    },
+    maxItems: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minItems: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    uniqueItems: {
+      type: "boolean",
+      default: false
+    },
+    maxContains: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minContains: {
+      $ref: "#/$defs/nonNegativeInteger",
+      default: 1
+    },
+    maxProperties: {
+      $ref: "#/$defs/nonNegativeInteger"
+    },
+    minProperties: {
+      $ref: "#/$defs/nonNegativeIntegerDefault0"
+    },
+    required: {
+      $ref: "#/$defs/stringArray"
+    },
+    dependentRequired: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/stringArray"
+      }
+    },
+    const: true,
+    enum: {
+      type: "array",
+      items: true
+    },
+    type: {
+      anyOf: [
+        {
+          $ref: "#/$defs/simpleTypes"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/simpleTypes"
+          },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    default: true,
+    deprecated: {
+      type: "boolean",
+      default: false
+    },
+    readOnly: {
+      type: "boolean",
+      default: false
+    },
+    writeOnly: {
+      type: "boolean",
+      default: false
+    },
+    examples: {
+      type: "array",
+      items: true
+    },
+    format: {
+      type: "string"
+    },
+    contentMediaType: {
+      type: "string"
+    },
+    contentEncoding: {
+      type: "string"
+    },
+    contentSchema: {
+      $ref: "#"
+    }
+  },
+  $defs: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: {
+        $ref: "#"
+      }
+    },
+    nonNegativeInteger: {
+      type: "integer",
+      minimum: 0
+    },
+    nonNegativeIntegerDefault0: {
+      $ref: "#/$defs/nonNegativeInteger",
+      default: 0
+    },
+    simpleTypes: {
+      enum: [
+        "array",
+        "boolean",
+        "integer",
+        "null",
+        "number",
+        "object",
+        "string"
+      ]
+    },
+    stringArray: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      uniqueItems: true,
+      default: []
+    }
+  }
+};
+
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/configuration.js
 var schemaContributions = {
   schemaAssociations: [],
   schemas: {
@@ -6329,7 +6919,9 @@ var schemaContributions = {
         "not": { "$ref": "#" }
       },
       "default": true
-    }
+    },
+    "https://json-schema.org/draft/2020-12/schema": draft_2020_12_flat_default,
+    "https://json-schema.org/draft/2019-09/schema": draft_2019_09_flat_default
   }
 };
 var descriptions = {
@@ -6394,7 +6986,7 @@ for (const schemaName in schemaContributions.schemas) {
   }
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/glob.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/glob.js
 function createRegex(glob, opts) {
   if (typeof glob !== "string") {
     throw new TypeError("Expected a string");
@@ -6485,7 +7077,7 @@ function createRegex(glob, opts) {
   return new RegExp(reStr, flags);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonSchemaService.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonSchemaService.js
 var BANG = "!";
 var PATH_SEP = "/";
 var FilePatternAssociation = class {
@@ -7046,7 +7638,7 @@ function toDisplayString(url) {
   return url;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonFolding.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonFolding.js
 function getFoldingRanges(document, context) {
   const ranges = [];
   const nestingLevels = [];
@@ -7160,7 +7752,7 @@ function getFoldingRanges(document, context) {
   return result;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonSelectionRanges.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonSelectionRanges.js
 function getSelectionRanges(document, positions, doc) {
   function getSelectionRange(position) {
     let offset = document.offsetAt(position);
@@ -7220,7 +7812,7 @@ function getSelectionRanges(document, positions, doc) {
   return positions.map(getSelectionRange);
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/format.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/format.js
 function format4(documentToFormat, formattingOptions, formattingRange) {
   let range = void 0;
   if (formattingRange) {
@@ -7240,7 +7832,7 @@ function format4(documentToFormat, formattingOptions, formattingRange) {
   });
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/propertyTree.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/propertyTree.js
 var Container;
 (function(Container2) {
   Container2[Container2["Object"] = 0] = "Object";
@@ -7309,7 +7901,7 @@ function binarySearchOnPropertyArray(propertyTreeArray, propertyTree, compare_fn
   return -m - 1;
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/utils/sort.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/utils/sort.js
 function sort(documentToSort, formattingOptions) {
   const options = {
     ...formattingOptions,
@@ -7575,7 +8167,7 @@ var SortingRange = class {
   }
 };
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/services/jsonLinks.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/services/jsonLinks.js
 function findLinks(document, doc) {
   const links = [];
   doc.visit((node) => {
@@ -7643,7 +8235,7 @@ function unescape(str) {
   return str.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 
-// node_modules/.pnpm/vscode-json-languageservice@5.6.1/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageService.js
+// node_modules/.pnpm/vscode-json-languageservice@5.6.3/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageService.js
 function getLanguageService(params) {
   const promise = params.promiseConstructor || Promise;
   const jsonSchemaService = new JSONSchemaService(params.schemaRequestService, params.workspaceContext, promise);
@@ -7682,21 +8274,36 @@ function getLanguageService(params) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createData, _createLanguageDocument) {
-    this._ctx = _ctx;
-    this._createData = _createData;
-    this._createLanguageDocument = _createLanguageDocument;
-  }
-  #documentCache = /* @__PURE__ */ new Map();
+  #ctx;
   #fs;
+  #documentCache = /* @__PURE__ */ new Map();
+  #createLanguageDocument;
+  constructor(ctx, createData, createLanguageDocument) {
+    this.#ctx = ctx;
+    if (createData.fs) {
+      const dirs = /* @__PURE__ */ new Set(["/"]);
+      this.#fs = new Map(createData.fs.map((path) => {
+        const dir = path.slice(0, path.lastIndexOf("/"));
+        if (dir) {
+          dirs.add(dir);
+        }
+        return ["file://" + path, 1];
+      }));
+      for (const dir of dirs) {
+        this.#fs.set("file://" + dir, 2);
+      }
+      createData.fs.length = 0;
+    }
+    this.#createLanguageDocument = createLanguageDocument;
+  }
   get hasFileSystemProvider() {
-    return !!this._createData.workspace;
+    return !!this.#fs;
   }
   get host() {
-    return this._ctx.host;
+    return this.#ctx.host;
   }
   getMirrorModels() {
-    return this._ctx.getMirrorModels();
+    return this.#ctx.getMirrorModels();
   }
   hasModel(fileName) {
     const models = this.getMirrorModels();
@@ -7737,10 +8344,10 @@ var WorkerBase = class {
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
-    if (!this._createLanguageDocument) {
+    if (!this.#createLanguageDocument) {
       throw new Error("createLanguageDocument is not provided");
     }
-    const languageDocument = this._createLanguageDocument(document);
+    const languageDocument = this.#createLanguageDocument(document);
     this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
@@ -7751,10 +8358,12 @@ var WorkerBase = class {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
-            if (type === 2) {
-              entries.push([name, 2 /* Directory */]);
-            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
-              entries.push([name, 1 /* File */]);
+            if (type === 1) {
+              if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+                entries.push([name, 1]);
+              }
+            } else if (type === 2) {
+              entries.push([name, 2]);
             }
           }
         }
@@ -7763,8 +8372,8 @@ var WorkerBase = class {
     return entries;
   }
   getFileSystemProvider() {
-    if (this.hasFileSystemProvider) {
-      const host = this._ctx.host;
+    if (this.#fs) {
+      const host = this.#ctx.host;
       return {
         readDirectory: (uri) => {
           return Promise.resolve(this.readDir(uri));
@@ -7781,29 +8390,27 @@ var WorkerBase = class {
   }
   // resolveReference implementes the `DocumentContext` interface
   resolveReference(ref, baseUrl) {
-    const url = new URL(ref, baseUrl);
-    const href = url.href;
-    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+    const { protocol, pathname, href } = new URL(ref, baseUrl);
+    if (protocol === "file:" && pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
       return void 0;
     }
     return href;
   }
   // #region methods used by the host
-  async removeDocumentCache(uri) {
+  async releaseDocument(uri) {
     this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
-    const url = "file://" + path;
-    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
+    const fs = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
-        entries.set(url, type);
+        fs.set(path, type);
       }
     } else if (kind === "remove") {
-      if (entries.get(url) === 1 /* File */) {
-        this.#documentCache.delete(url);
+      if (fs.get(path) === 1) {
+        this.#documentCache.delete(path);
       }
-      entries.delete(url);
+      fs.delete(path);
     }
   }
   // #endregion