@player-lang/json-language-service 0.0.2-next.0

package/dist/index.legacy-esm.js

@@ -0,0 +1,2249 @@
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/index.ts
+import { format as formatJSON } from "jsonc-parser";
+import {
+  AsyncParallelHook,
+  SyncBailHook,
+  SyncHook,
+  SyncWaterfallHook
+} from "tapable-ts";
+import {
+  CompletionList,
+  Range as Range4,
+  TextEdit as TextEdit2,
+  CodeActionKind
+} from "vscode-languageserver-types";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/asset-wrapper-array-plugin.ts
+import { DiagnosticSeverity as DiagnosticSeverity2 } from "vscode-languageserver-types";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/index.ts
+import { getNodeValue as getJSONNodeValue } from "jsonc-parser";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/utils.ts
+function isPropertyNode(node) {
+  return node?.type === "property";
+}
+function isObjectNode(node) {
+  return node?.type === "object";
+}
+function isKeyNode(node) {
+  return isPropertyNode(node?.parent) && node?.parent.keyNode === node;
+}
+function isValueNode(node) {
+  return isPropertyNode(node?.parent) && node?.parent.valueNode === node;
+}
+function isViewNode(node) {
+  return node?.type === "view";
+}
+function isStateNode(node) {
+  return node?.type === "state";
+}
+function isFlowNode(node) {
+  return node?.type === "flow";
+}
+function isNavigationNode(node) {
+  return node?.type === "navigation";
+}
+function getValForKey(node, key) {
+  const prop = node.properties.find((k) => k.keyNode.value === key);
+  return prop?.valueNode?.jsonNode.value;
+}
+function getPropForValNode(node) {
+  if (isValueNode(node) && isPropertyNode(node?.parent)) {
+    return node?.parent.keyNode.value;
+  }
+}
+function getViewNode(node) {
+  if (node.parent) {
+    if (node.parent.type === "view") {
+      return node.parent;
+    }
+    return getViewNode(node.parent);
+  }
+  if (node.type === "asset") {
+    return node;
+  }
+}
+function getContentNode(node) {
+  if (node.type === "content") {
+    return node;
+  }
+  return node.parent ? getContentNode(node.parent) : void 0;
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/document.ts
+import { parseTree, findNodeAtOffset } from "jsonc-parser";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/types.ts
+var ASTNodeImpl = class {
+  parent;
+  jsonNode;
+  constructor(jsonNode, parent) {
+    this.jsonNode = jsonNode;
+    this.parent = parent;
+  }
+};
+var StringASTNodeImpl = class extends ASTNodeImpl {
+  type = "string";
+  value;
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+};
+var NumberASTNodeImpl = class extends ASTNodeImpl {
+  type = "number";
+  value;
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+};
+var BooleanASTNodeImpl = class extends ASTNodeImpl {
+  type = "boolean";
+  value;
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+};
+var NullASTNodeImpl = class extends ASTNodeImpl {
+  type = "null";
+  value = null;
+};
+var PropertyASTNodeImpl = class extends ASTNodeImpl {
+  type = "property";
+  keyNode;
+  valueNode;
+  constructor(jsonNode, parent, keyNode) {
+    super(jsonNode, parent);
+    this.keyNode = keyNode;
+  }
+  get children() {
+    return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+  }
+};
+var ViewASTNodeImpl = class extends ASTNodeImpl {
+  type = "view";
+  properties = [];
+  id = void 0;
+  viewType = void 0;
+  get children() {
+    return this.properties;
+  }
+};
+var ContentASTNodeImpl = class extends ASTNodeImpl {
+  type = "content";
+  properties = [];
+  views = void 0;
+  navigation = void 0;
+  get children() {
+    return this.properties;
+  }
+};
+var NavigationASTNodeImpl = class extends ASTNodeImpl {
+  type = "navigation";
+  properties = [];
+  begin = void 0;
+  flows = [];
+  get children() {
+    return this.properties;
+  }
+};
+var FlowASTNodeImpl = class extends ASTNodeImpl {
+  type = "flow";
+  properties = [];
+  start = void 0;
+  states = [];
+  get children() {
+    return this.properties;
+  }
+};
+var FlowStateASTNodeImpl = class extends ASTNodeImpl {
+  type = "state";
+  properties = [];
+  stateType = void 0;
+  get children() {
+    return this.properties;
+  }
+};
+var AssetASTNodeImpl = class extends ASTNodeImpl {
+  type = "asset";
+  properties = [];
+  id = void 0;
+  assetType = void 0;
+  get children() {
+    return this.properties;
+  }
+};
+var ArrayASTNodeImpl = class extends ASTNodeImpl {
+  type = "array";
+  items = [];
+  get children() {
+    return this.items;
+  }
+};
+var ObjectASTNodeImpl = class extends ASTNodeImpl {
+  type = "object";
+  properties = [];
+  get children() {
+    return this.properties;
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/jsonParseErrors.ts
+import { printParseErrorCode } from "jsonc-parser";
+import {
+  Diagnostic,
+  Range,
+  DiagnosticSeverity
+} from "vscode-languageserver-types";
+function prettyPrintParseErrorCode(code) {
+  switch (code) {
+    case 6 /* CommaExpected */:
+      return `Expected comma`;
+    case 5 /* ColonExpected */:
+      return `Expected colon`;
+    case 3 /* PropertyNameExpected */:
+      return `Expected property name`;
+    case 4 /* ValueExpected */:
+      return `Expected value`;
+    case 7 /* CloseBraceExpected */:
+      return `Expected }`;
+    case 9 /* EndOfFileExpected */:
+      return `Expected end of file`;
+    case 8 /* CloseBracketExpected */:
+      return `Expected ]`;
+    case 12 /* UnexpectedEndOfString */:
+      return `Expected "`;
+    default:
+      return printParseErrorCode(code);
+  }
+}
+function convertErrorsToDiags(document, errors) {
+  return errors.map((parseError) => {
+    return Diagnostic.create(
+      Range.create(
+        document.positionAt(parseError.offset),
+        document.positionAt(parseError.offset + parseError.length)
+      ),
+      prettyPrintParseErrorCode(parseError.error),
+      DiagnosticSeverity.Error
+    );
+  });
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/document.ts
+function isStringProperty(node) {
+  return node.valueNode?.type === "string";
+}
+var PlayerContent = class {
+  root;
+  syntaxErrors;
+  jsonNodeToNode;
+  constructor(root, errors, jsonToNodeMap) {
+    this.root = root;
+    this.jsonNodeToNode = jsonToNodeMap;
+    this.syntaxErrors = errors;
+  }
+  getNodeFromOffset(offset) {
+    const jsonNode = findNodeAtOffset(this.root.jsonNode, offset);
+    if (!jsonNode) {
+      return;
+    }
+    if (this.jsonNodeToNode.has(jsonNode)) {
+      return this.jsonNodeToNode.get(jsonNode);
+    }
+    const parentNode = jsonNode.parent;
+    if (this.jsonNodeToNode.has(parentNode)) {
+      return this.jsonNodeToNode.get(parentNode);
+    }
+    const grandparentNode = parentNode.parent;
+    if (this.jsonNodeToNode.has(grandparentNode)) {
+      return this.jsonNodeToNode.get(grandparentNode);
+    }
+    const greatGrandparentNode = grandparentNode.parent;
+    if (this.jsonNodeToNode.has(greatGrandparentNode)) {
+      return this.jsonNodeToNode.get(greatGrandparentNode);
+    }
+  }
+};
+var ObjType = /* @__PURE__ */ ((ObjType2) => {
+  ObjType2[ObjType2["FLOW"] = 0] = "FLOW";
+  ObjType2[ObjType2["ASSET"] = 1] = "ASSET";
+  ObjType2[ObjType2["ASSET_WRAPPER"] = 2] = "ASSET_WRAPPER";
+  ObjType2[ObjType2["UNKNOWN"] = 3] = "UNKNOWN";
+  return ObjType2;
+})(ObjType || {});
+function identify(node) {
+  if (node === void 0 || node.type !== "object") {
+    return 3 /* UNKNOWN */;
+  }
+  const knownProps = node.children?.reduce((props, childNode) => {
+    if (childNode.type === "property" && childNode.children) {
+      const [key] = childNode.children;
+      props.add(key.value);
+    }
+    return props;
+  }, /* @__PURE__ */ new Set());
+  if (knownProps?.has("type")) {
+    return 1 /* ASSET */;
+  }
+  return 0 /* FLOW */;
+}
+function parse(document) {
+  const errors = [];
+  const jsonToNode = /* @__PURE__ */ new Map();
+  const root = parseTree(document.getText(), errors, {
+    disallowComments: true
+  });
+  const diags = convertErrorsToDiags(document, errors);
+  function parseAsset(node, parent) {
+    const assetNode = new AssetASTNodeImpl(node, parent);
+    node.children?.forEach((prop) => {
+      if (prop.type === "property" && prop.children?.length) {
+        const [key, val] = prop.children;
+        const keyNode = new StringASTNodeImpl(key);
+        const property = new PropertyASTNodeImpl(prop, assetNode, keyNode);
+        property.keyNode = new StringASTNodeImpl(key, property);
+        property.valueNode = parseUnknownNode(val, property);
+        if (key.value === "id" && isStringProperty(property)) {
+          assetNode.id = property;
+        } else if (key.value === "type" && isStringProperty(property)) {
+          assetNode.assetType = property;
+        }
+        assetNode.properties.push(property);
+        jsonToNode.set(prop, property);
+        jsonToNode.set(key, property.keyNode);
+        if (property.valueNode) {
+          jsonToNode.set(val, property.valueNode);
+        }
+      }
+    });
+    return assetNode;
+  }
+  function parseUnknownNode(node, parent) {
+    switch (node?.type) {
+      case "string": {
+        const newNode = new StringASTNodeImpl(node, parent);
+        jsonToNode.set(node, newNode);
+        return newNode;
+      }
+      case "null": {
+        const newNode = new NullASTNodeImpl(node, parent);
+        jsonToNode.set(node, newNode);
+        return newNode;
+      }
+      case "boolean": {
+        const newNode = new BooleanASTNodeImpl(node, parent);
+        jsonToNode.set(node, newNode);
+        return newNode;
+      }
+      case "number": {
+        const newNode = new NumberASTNodeImpl(node, parent);
+        jsonToNode.set(node, newNode);
+        return newNode;
+      }
+      case "array": {
+        const arr = new ArrayASTNodeImpl(node, parent);
+        node.children?.forEach((arrChild) => {
+          const child = parseUnknownNode(arrChild, arr);
+          if (child) {
+            jsonToNode.set(arrChild, child);
+            arr.items.push(child);
+          }
+        });
+        jsonToNode.set(node, arr);
+        return arr;
+      }
+      case "object": {
+        const obj = new ObjectASTNodeImpl(node, parent);
+        jsonToNode.set(node, obj);
+        node.children?.forEach((prop) => {
+          if (prop.type === "property" && prop.children?.length) {
+            const [key, val] = prop.children;
+            const keyNode = new StringASTNodeImpl(key);
+            const propNode = new PropertyASTNodeImpl(prop, obj, keyNode);
+            propNode.keyNode = new StringASTNodeImpl(key, propNode);
+            if (val) {
+              if (keyNode.value === "asset") {
+                propNode.valueNode = parseAsset(val, propNode);
+              } else {
+                propNode.valueNode = parseUnknownNode(val, propNode);
+              }
+            }
+            jsonToNode.set(prop, propNode);
+            jsonToNode.set(key, propNode.keyNode);
+            if (propNode.valueNode) {
+              jsonToNode.set(val, propNode.valueNode);
+            }
+            obj.properties.push(propNode);
+          }
+        });
+        return obj;
+      }
+      default:
+    }
+  }
+  function parseView(node, parent) {
+    const viewNode = new ViewASTNodeImpl(node, parent);
+    node.children?.forEach((prop) => {
+      if (prop.type === "property" && (prop.children?.length ?? 0) > 0) {
+        const [key, val] = prop.children ?? [];
+        const keyNode = new StringASTNodeImpl(key);
+        const property = new PropertyASTNodeImpl(prop, viewNode, keyNode);
+        property.keyNode = new StringASTNodeImpl(key, property);
+        if (val) {
+          property.valueNode = parseUnknownNode(val, property);
+          if (key.value === "id" && isStringProperty(property)) {
+            viewNode.id = property;
+          } else if (key.value === "type" && isStringProperty(property)) {
+            viewNode.viewType = property;
+          }
+        }
+        jsonToNode.set(prop, property);
+        jsonToNode.set(key, property.keyNode);
+        if (property.valueNode) {
+          jsonToNode.set(val, property.valueNode);
+        }
+        viewNode.properties.push(property);
+      }
+    });
+    jsonToNode.set(node, viewNode);
+    return viewNode;
+  }
+  function parseFlowState(node, parent) {
+    const state = new FlowStateASTNodeImpl(node, parent);
+    jsonToNode.set(node, state);
+    if (node.type === "object") {
+      node.children?.forEach((prop) => {
+        if (prop.type === "property" && prop.children?.length) {
+          const [key, val] = prop.children;
+          const keyNode = new StringASTNodeImpl(key);
+          const property = new PropertyASTNodeImpl(prop, state, keyNode);
+          property.keyNode = new StringASTNodeImpl(key, property);
+          if (key.value === "state_type" && val?.type === "string") {
+            property.valueNode = parseUnknownNode(val, property);
+            state.stateType = property;
+          } else {
+            property.valueNode = parseUnknownNode(val, property);
+          }
+          jsonToNode.set(prop, property);
+          jsonToNode.set(key, property.keyNode);
+          if (property.valueNode) {
+            jsonToNode.set(val, property.valueNode);
+          }
+          state.properties.push(property);
+        }
+      });
+    }
+    return state;
+  }
+  function parseFlow(node, parent) {
+    const flow = new FlowASTNodeImpl(node, parent);
+    jsonToNode.set(node, flow);
+    if (node.type === "object") {
+      node.children?.forEach((prop) => {
+        if (prop.type === "property" && prop.children?.length) {
+          const [key, val] = prop.children;
+          const keyNode = new StringASTNodeImpl(key);
+          const property = new PropertyASTNodeImpl(prop, flow, keyNode);
+          property.keyNode = new StringASTNodeImpl(key, property);
+          if (key.value === "startState" && val?.type === "string") {
+            property.valueNode = parseUnknownNode(val, property);
+            flow.start = property;
+          } else if (val?.type === "object" && property.keyNode.value !== "onStart" && property.keyNode.value !== "onEnd") {
+            property.valueNode = parseFlowState(val, property);
+            flow.states.push(property);
+          } else {
+            property.valueNode = parseUnknownNode(val, property);
+          }
+          jsonToNode.set(prop, property);
+          jsonToNode.set(key, property.keyNode);
+          if (property.valueNode) {
+            jsonToNode.set(val, property.valueNode);
+          }
+          flow.properties.push(property);
+        }
+      });
+    }
+    return flow;
+  }
+  function parseNavigation(node, parent) {
+    const navNode = new NavigationASTNodeImpl(node, parent);
+    jsonToNode.set(node, navNode);
+    if (node.type === "object") {
+      node.children?.forEach((prop) => {
+        if (prop.type === "property" && prop.children?.length) {
+          const [key, val] = prop.children;
+          const keyNode = new StringASTNodeImpl(key);
+          const property = new PropertyASTNodeImpl(prop, navNode, keyNode);
+          property.keyNode = new StringASTNodeImpl(key, property);
+          if (key.value === "BEGIN" && val?.type === "string") {
+            property.valueNode = parseUnknownNode(val, property);
+            navNode.begin = property;
+          } else if (val?.type === "object") {
+            property.valueNode = parseFlow(val, property);
+            navNode.flows.push(property);
+          }
+          jsonToNode.set(prop, property);
+          jsonToNode.set(key, property.keyNode);
+          if (property.valueNode) {
+            jsonToNode.set(val, property.valueNode);
+          }
+          navNode.properties.push(property);
+        }
+      });
+    }
+    return navNode;
+  }
+  function parseContent(node) {
+    const contentNode = new ContentASTNodeImpl(node, void 0);
+    if (node.type === "object") {
+      node.children?.forEach((childProp) => {
+        if (childProp.type === "property" && childProp.children?.length) {
+          const [key, val] = childProp.children;
+          const keyNode = new StringASTNodeImpl(key);
+          const property = new PropertyASTNodeImpl(
+            childProp,
+            contentNode,
+            keyNode
+          );
+          property.keyNode = new StringASTNodeImpl(key, property);
+          if (key.value === "views" && val?.type === "array") {
+            const views = new ArrayASTNodeImpl(val, property);
+            val.children?.forEach((view) => {
+              const parsedV = parseView(view, views);
+              jsonToNode.set(view, parsedV);
+              views.items.push(parsedV);
+            });
+            property.valueNode = views;
+            contentNode.views = property;
+          } else if (key.value === "navigation" && val) {
+            const nav = parseNavigation(val, property);
+            contentNode.navigation = property;
+            property.valueNode = nav;
+          } else if (val) {
+            property.valueNode = parseUnknownNode(val, property);
+          }
+          jsonToNode.set(childProp, property);
+          jsonToNode.set(key, property.keyNode);
+          if (property.valueNode) {
+            jsonToNode.set(val, property.valueNode);
+          }
+          contentNode.properties.push(property);
+        }
+      });
+    }
+    jsonToNode.set(node, contentNode);
+    return contentNode;
+  }
+  let rootASTNode = {
+    type: "empty",
+    value: void 0,
+    jsonNode: root
+  };
+  const objType = identify(root);
+  switch (objType) {
+    case 1 /* ASSET */:
+      rootASTNode = parseAsset(root);
+      break;
+    case 0 /* FLOW */:
+      rootASTNode = parseContent(root);
+      break;
+    default:
+      break;
+  }
+  return new PlayerContent(rootASTNode, diags, jsonToNode);
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/edits.ts
+import { TextEdit, Range as Range2 } from "vscode-languageserver-types";
+function replaceString(node, newText) {
+  return {
+    type: "replace",
+    node,
+    value: newText
+  };
+}
+function toRange(document, node) {
+  return Range2.create(
+    document.positionAt(node.jsonNode.offset),
+    document.positionAt(node.jsonNode.offset + node.jsonNode.length)
+  );
+}
+function toTextEdit(document, edit) {
+  switch (edit.type) {
+    case "replace":
+      return TextEdit.replace(toRange(document, edit.node), edit.value);
+    default:
+      throw new Error("Dont know how to convert this to a TextEdit");
+  }
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/parser/index.ts
+async function walk(node, visitor) {
+  const queue = [node];
+  let stop = false;
+  while (queue.length > 0 && !stop) {
+    const nodeToVisit = queue.shift();
+    if (nodeToVisit?.children) {
+      queue.push(...nodeToVisit.children);
+    }
+    stop = nodeToVisit ? await visitor(nodeToVisit) : true;
+  }
+}
+function getNodeValue(node) {
+  return getJSONNodeValue(node.jsonNode);
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/utils.ts
+import { Range as Range3, Location } from "vscode-languageserver-types";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import detectIndent from "detect-indent";
+var typeToVisitorMap = {
+  string: "StringNode",
+  number: "NumberNode",
+  boolean: "BooleanNode",
+  array: "ArrayNode",
+  null: "NullNode",
+  empty: "EmptyNode",
+  property: "PropertyNode",
+  object: "ObjectNode",
+  asset: "AssetNode",
+  view: "ViewNode",
+  content: "ContentNode",
+  navigation: "NavigationNode",
+  flow: "FlowNode",
+  state: "FlowStateNode"
+};
+function containsRange(source, range) {
+  const { start, end } = range;
+  const { start: srcStart, end: srcEnd } = source;
+  return start.line === srcStart.line && end.line === srcEnd.line && start.character >= srcStart.character && end.character <= srcEnd.character;
+}
+function toTextDocument(str) {
+  return TextDocument.create("foo", "json", 1, str);
+}
+function isKnownRootType(document) {
+  const { type } = document.root;
+  return type === "view" || type === "asset" || type === "content";
+}
+function isValueCompletion(node) {
+  return node.parent?.type === "property" && node.parent.valueNode === node;
+}
+function isPropertyCompletion(node) {
+  return node.parent?.type === "property" && node.parent.keyNode === node;
+}
+function getProperty(obj, name) {
+  if ("properties" in obj) {
+    return obj.properties.find(
+      (p) => p.keyNode.value === name
+    );
+  }
+}
+function getLSLocationOfNode(document, node) {
+  const nodeRange = Range3.create(
+    document.positionAt(node.jsonNode.offset),
+    document.positionAt(node.jsonNode.offset + node.jsonNode.length)
+  );
+  return Location.create(document.uri, nodeRange);
+}
+function getDepth(node) {
+  if (!node.parent) {
+    return 0;
+  }
+  if (node.type === "property") {
+    return getDepth(node.parent);
+  }
+  return 1 + getDepth(node.parent);
+}
+function formatLikeNode(document, originalNode, replacement) {
+  const { indent } = detectIndent(document.getText());
+  const depth = getDepth(originalNode);
+  return JSON.stringify(replacement, null, indent).split("\n").map((l, index) => index === 0 ? l : `${indent.repeat(depth)}${l}`).join("\n");
+}
+function mapFlowStateToType(flowType) {
+  let flowXLR;
+  switch (flowType) {
+    case "VIEW":
+      flowXLR = "NavigationFlowViewState";
+      break;
+    case "END":
+      flowXLR = "NavigationFlowEndState";
+      break;
+    case "ACTION":
+      flowXLR = "NavigationFlowActionState";
+      break;
+    case "EXTERNAL":
+      flowXLR = "NavigationFlowExternalState";
+      break;
+    case "FLOW":
+      flowXLR = "NavigationFlowFlowState";
+      break;
+    default:
+      break;
+  }
+  return flowXLR;
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/asset-wrapper-array-plugin.ts
+var isInView = (node) => {
+  if (node.type === "view") {
+    return true;
+  }
+  if (!node.parent) {
+    return false;
+  }
+  return isInView(node.parent);
+};
+var checkTypesForAssetWrapper = (nodes) => {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type === "object" && node.title?.includes("AssetWrapper")) {
+      return true;
+    } else if (node.type === "or") {
+      return checkTypesForAssetWrapper(node.or);
+    } else if (node.type === "and") {
+      return checkTypesForAssetWrapper(node.and);
+    }
+  }
+  return false;
+};
+var checkSwitchCase = (node) => {
+  return node.value === "staticSwitch" || node.value === "dynamicSwitch";
+};
+var AssetWrapperArrayPlugin = class {
+  name = "asset-wrapper-to-array";
+  apply(service) {
+    service.hooks.validate.tap(
+      this.name,
+      async (documentInfo, validationContext) => {
+        validationContext.useASTVisitor({
+          ArrayNode: async (arrayNode) => {
+            if (!isInView(arrayNode)) {
+              return;
+            }
+            const xlrInfo = service.XLRService.getTypeInfoAtPosition(arrayNode);
+            if (!xlrInfo) return;
+            const isAssetWrapper = checkTypesForAssetWrapper(xlrInfo.nodes);
+            const parentNode = arrayNode.parent;
+            if (parentNode?.type !== "property") {
+              return;
+            }
+            const targetLabel = parentNode.keyNode;
+            const isSwitchCase = checkSwitchCase(targetLabel);
+            if (isAssetWrapper && !isSwitchCase) {
+              let newAsset = {
+                asset: {
+                  id: "",
+                  type: "collection",
+                  values: getNodeValue(arrayNode)
+                }
+              };
+              if (arrayNode.children.length === 1) {
+                newAsset = getNodeValue(arrayNode.children[0]);
+              }
+              validationContext.addViolation({
+                node: targetLabel,
+                severity: DiagnosticSeverity2.Error,
+                message: `Implicit Array -> "collection" assets is not supported.`,
+                fix: () => {
+                  return {
+                    name: `Convert to ${arrayNode.children.length > 0 ? "collection" : "asset"}`,
+                    edit: {
+                      type: "replace",
+                      node: arrayNode,
+                      value: formatLikeNode(
+                        documentInfo.document,
+                        arrayNode,
+                        newAsset
+                      )
+                    }
+                  };
+                }
+              });
+            }
+          }
+        });
+      }
+    );
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/binding-schema-plugin.ts
+import { CompletionItemKind } from "vscode-languageserver-types";
+function getBindingInfo(ctx) {
+  const info = {
+    bindingToSchemaType: /* @__PURE__ */ new Map(),
+    typeToNode: /* @__PURE__ */ new Map()
+  };
+  if (ctx.PlayerContent.root.type !== "content") {
+    return info;
+  }
+  const schemaRoot = ctx.PlayerContent.root.properties?.find(
+    (child) => child.keyNode.value === "schema"
+  );
+  if (!schemaRoot || schemaRoot.valueNode?.type !== "object") {
+    return info;
+  }
+  const schemaTypeQueue = [
+    {
+      currentPath: "",
+      typeToVisit: "ROOT",
+      visited: /* @__PURE__ */ new Set()
+    }
+  ];
+  while (schemaTypeQueue.length > 0) {
+    const next = schemaTypeQueue.shift();
+    if (!next) {
+      break;
+    }
+    if (next.visited.has(next.typeToVisit)) {
+      continue;
+    }
+    const visited = new Set(...next.visited, next.typeToVisit);
+    const { currentPath, typeToVisit } = next;
+    const typeNode = schemaRoot.valueNode.properties.find(
+      (child) => child.keyNode.value === typeToVisit
+    );
+    if (!typeNode || typeNode.valueNode?.type !== "object") {
+      continue;
+    }
+    info.typeToNode.set(typeToVisit, { type: typeToVisit, typeNode });
+    typeNode.valueNode.properties.forEach((prop) => {
+      const nextPath = [currentPath, prop.keyNode.value].join(
+        currentPath === "" ? "" : "."
+      );
+      info.bindingToSchemaType.set(nextPath, {
+        binding: nextPath,
+        typeName: typeToVisit,
+        key: prop.keyNode.value
+      });
+      if (prop.valueNode?.type === "object") {
+        const nestedTypeName = prop.valueNode.properties.find(
+          (c) => c.keyNode.value === "type"
+        );
+        if (nestedTypeName && nestedTypeName.valueNode?.type === "string") {
+          schemaTypeQueue.push({
+            currentPath: nextPath,
+            typeToVisit: nestedTypeName.valueNode.value,
+            visited
+          });
+        }
+      }
+    });
+  }
+  return info;
+}
+var checkTypesForBinding = (nodes) => {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type === "string" && node.name === "Binding") return true;
+    if (node.type === "or") return checkTypesForBinding(node.or);
+    if (node.type === "and") return checkTypesForBinding(node.and);
+  }
+  return false;
+};
+function isBindingPropertyAssignment(ctx) {
+  if (ctx.node.type !== "string" || ctx.node.parent?.type !== "property") {
+    return false;
+  }
+  if (checkTypesForBinding(ctx.XLR?.nodes ?? [])) {
+    return true;
+  }
+  return false;
+}
+function getLocationForBindingTypeDefinition(ctx, schemaInfo) {
+  if (!isBindingPropertyAssignment(ctx)) {
+    return;
+  }
+  const existingBindingValue = ctx.node.value;
+  const info = schemaInfo.bindingToSchemaType.get(existingBindingValue);
+  if (!info) {
+    return;
+  }
+  const nodeLocation = schemaInfo.typeToNode.get(info.typeName);
+  if (!nodeLocation || nodeLocation.typeNode.valueNode?.type !== "object") {
+    return;
+  }
+  const prop = getProperty(nodeLocation.typeNode.valueNode, info.key);
+  if (!prop) {
+    return;
+  }
+  return getLSLocationOfNode(ctx.document, prop);
+}
+function getLocationForSchemaType(ctx, schemaInfo) {
+  if (isValueCompletion(ctx.node)) {
+    if (ctx.node.parent?.type === "property" && ctx.node.type === "string" && ctx.node.parent.keyNode.value === "type") {
+      const typeName = ctx.node.value;
+      const node = schemaInfo.typeToNode.get(typeName);
+      if (!node) {
+        return;
+      }
+      const schemaPropNode = getContentNode(ctx.node)?.properties.find(
+        (p) => p.keyNode.value === "schema"
+      );
+      if (schemaPropNode?.valueNode?.type !== "object") {
+        return;
+      }
+      const schemaTypeNode = schemaPropNode.valueNode.properties.find(
+        (p) => p.keyNode.value === typeName
+      );
+      if (schemaTypeNode !== node.typeNode) {
+        return;
+      }
+      return getLSLocationOfNode(ctx.document, node.typeNode);
+    }
+  }
+}
+var SchemaInfoPlugin = class {
+  name = "view-node";
+  apply(service) {
+    let schemaInfo;
+    service.hooks.onDocumentUpdate.tap(this.name, (ctx) => {
+      schemaInfo = getBindingInfo(ctx);
+    });
+    service.hooks.complete.tap(this.name, async (ctx, completionCtx) => {
+      if (!isBindingPropertyAssignment(ctx)) {
+        return;
+      }
+      const existingBindingValue = ctx.node.value;
+      const bindings = Array.from(
+        schemaInfo?.bindingToSchemaType.keys() ?? []
+      ).filter((k) => k.startsWith(existingBindingValue));
+      bindings.forEach((b) => {
+        completionCtx.addCompletionItem({
+          kind: CompletionItemKind.Value,
+          label: b.substring(existingBindingValue.length)
+        });
+      });
+    });
+    service.hooks.definition.tap(this.name, (ctx) => {
+      if (!schemaInfo) {
+        return;
+      }
+      return getLocationForSchemaType(ctx, schemaInfo) || getLocationForBindingTypeDefinition(ctx, schemaInfo);
+    });
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/xlr-plugin.ts
+import {
+  CompletionItemKind as CompletionItemKind2,
+  DiagnosticSeverity as DiagnosticSeverity3,
+  MarkupKind
+} from "vscode-languageserver-types";
+function isError(issue) {
+  return issue.severity === DiagnosticSeverity3.Error;
+}
+var findErrorNode = (rootNode, nodeToFind) => {
+  const children = [rootNode];
+  while (children.length > 0) {
+    const child = children.pop();
+    if (child.jsonNode === nodeToFind) {
+      return child;
+    }
+    if (child.children) {
+      children.push(...child.children);
+    }
+  }
+  return rootNode;
+};
+var translateSeverity = (severity) => {
+  return severity;
+};
+function createValidationVisitor(ctx, sdk) {
+  const nodesWithErrors = /* @__PURE__ */ new Set();
+  return {
+    AssetNode: (assetNode) => {
+      let expectedType = assetNode.assetType?.valueNode?.value;
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: assetNode,
+          message: `Warning - Asset Type ${assetNode.assetType?.valueNode?.value} was not loaded into Validator definitions`,
+          severity: DiagnosticSeverity3.Error
+        });
+        expectedType = "Asset";
+      }
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        assetNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
+          ctx.addViolation({
+            node: findErrorNode(assetNode, issue.node),
+            message: isError(issue) ? `Asset Validation Error - ${issue.type}: ${issue.message}` : issue.message,
+            severity: translateSeverity(issue.severity)
+          });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
+        }
+      });
+    },
+    ViewNode: (viewNode) => {
+      let expectedType = viewNode.viewType?.valueNode?.value;
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: viewNode,
+          message: `Warning - View Type ${viewNode.viewType?.valueNode?.value} was not loaded into Validator definitions`,
+          severity: DiagnosticSeverity3.Error
+        });
+        expectedType = "View";
+      }
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        viewNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
+          ctx.addViolation({
+            node: findErrorNode(viewNode, issue.node),
+            message: isError(issue) ? `View Validation Error - ${issue.type}: ${issue.message}` : issue.message,
+            severity: translateSeverity(issue.severity)
+          });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
+        }
+      });
+    },
+    ContentNode: (contentNode) => {
+      const flowType = sdk.getType("Flow");
+      if (!flowType) {
+        throw new Error(
+          "Flow is not a registered type, can't validate content. Did you load a version of the base Player types?"
+        );
+      }
+      const assetType = sdk.getType("Asset");
+      if (!assetType) {
+        throw new Error(
+          "Asset is not a registered type, can't validate content. Did you load a version of the base Player types?"
+        );
+      }
+      if (flowType.type === "object" && flowType.properties.views?.node.type === "array") {
+        flowType.properties.views.node.elementType = assetType;
+      }
+      const validationIssues = sdk.validateByType(
+        flowType,
+        contentNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(contentNode, issue.node),
+            message: `Content Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity3.Error
+          });
+        }
+      });
+    },
+    NavigationNode: (navigationNode) => {
+      const expectedType = "Navigation";
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        navigationNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(navigationNode, issue.node),
+            message: `Navigation Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity3.Error
+          });
+        }
+      });
+    },
+    FlowNode: (flowNode) => {
+      const expectedType = "NavigationFlow";
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        flowNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(flowNode, issue.node),
+            message: `Navigation Flow Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity3.Error
+          });
+        }
+      });
+    },
+    FlowStateNode: (flowStateNode) => {
+      const flowxlr = mapFlowStateToType(
+        flowStateNode.stateType?.valueNode?.value
+      );
+      if (flowxlr) {
+        const validationIssues = sdk.validateByName(
+          flowxlr,
+          flowStateNode.jsonNode
+        );
+        validationIssues.forEach((issue) => {
+          if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+            nodesWithErrors.add(issue.node);
+            ctx.addViolation({
+              node: findErrorNode(flowStateNode, issue.node),
+              message: `Navigation Node Validation Error - ${issue.type}: ${issue.message}`,
+              severity: DiagnosticSeverity3.Error
+            });
+          }
+        });
+      } else {
+        ctx.addViolation({
+          node: flowStateNode,
+          message: "Unknown Flow Type, valid options are: VIEW, END, ACTION, EXTERNAL, FLOW",
+          severity: DiagnosticSeverity3.Error
+        });
+      }
+    }
+  };
+}
+function getObjectCompletions(authoredNode, potentialTypes) {
+  const completions = [];
+  const presentKeys = /* @__PURE__ */ new Set();
+  if (authoredNode.properties) {
+    authoredNode.properties.forEach(
+      (propertyNode) => presentKeys.add(propertyNode.keyNode.value)
+    );
+  }
+  potentialTypes.forEach((node) => {
+    if (node.type === "object") {
+      Object.keys(node.properties).forEach((prop) => {
+        if (!presentKeys.has(prop)) {
+          completions.push({
+            label: prop,
+            documentation: node.properties[prop].node.description ?? node.properties[prop].node.title,
+            kind: CompletionItemKind2.Property
+          });
+        }
+      });
+    } else if (node.type === "and") {
+      completions.push(...getObjectCompletions(authoredNode, node.and));
+    } else if (node.type === "or") {
+      completions.push(...getObjectCompletions(authoredNode, node.or));
+    }
+  });
+  return completions;
+}
+function getPropertyCompletions(propertyName, potentialTypes) {
+  const completions = [];
+  potentialTypes.forEach((nodeType) => {
+    if (nodeType.type === "object") {
+      const propertyNode = nodeType.properties[propertyName]?.node;
+      if (propertyNode && propertyNode.type === "string" && propertyNode.const) {
+        completions.push({
+          label: propertyNode.const,
+          kind: CompletionItemKind2.Value
+        });
+      }
+    }
+  });
+  return completions;
+}
+function complete(ctx) {
+  if (ctx.XLR?.nearestObjects) {
+    if (ctx.node.type === "string" && ctx.node?.parent?.type === "property") {
+      return getPropertyCompletions(
+        ctx.node.parent.keyNode.value,
+        ctx.XLR.nearestObjects
+      );
+    }
+    return getObjectCompletions(ctx.node, ctx.XLR.nearestObjects);
+  }
+  return [];
+}
+function hover(ctx) {
+  if (ctx.XLR && ctx.node.type === "string") {
+    const docStrings = [];
+    const prop = ctx.node.value;
+    ctx.XLR.nearestObjects.forEach((typeNode) => {
+      const docString = typeNode.properties[prop]?.node?.description ?? typeNode.properties[prop]?.node?.title ?? void 0;
+      if (docString) {
+        docStrings.push(docString);
+      }
+    });
+    if (docStrings.length > 1) {
+      return {
+        contents: {
+          kind: MarkupKind.PlainText,
+          value: "Docs unavailable - More than one type could exist at this location"
+        }
+      };
+    }
+    return {
+      contents: {
+        kind: MarkupKind.PlainText,
+        value: docStrings[0] ?? "Error getting docs"
+      }
+    };
+  }
+}
+var XLRPlugin = class {
+  name = "xlr-plugin";
+  apply(service) {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(
+        createValidationVisitor(validation, service.XLRService.XLRSDK)
+      );
+    });
+    service.hooks.complete.tap(this.name, async (ctx, completion) => {
+      complete(ctx).map((i) => completion.addCompletionItem(i));
+    });
+    service.hooks.hover.tap(this.name, (ctx) => {
+      return hover(ctx);
+    });
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/duplicate-id-plugin.ts
+import { DiagnosticSeverity as DiagnosticSeverity4 } from "vscode-languageserver-types";
+var checkParentTemplate = (node, depth = 0) => {
+  if (node.parent) {
+    if (isPropertyNode(node.parent) && node.parent.keyNode.value === "template") {
+      depth += 1;
+      return checkParentTemplate(node.parent, depth);
+    }
+    return checkParentTemplate(node.parent, depth);
+  }
+  return depth;
+};
+var generateID = (node) => {
+  if (!node || node.type === "view") {
+    return "";
+  }
+  const prefix = generateID(node.parent);
+  let current = "";
+  if (node.type === "property") {
+    current = node.keyNode.value;
+  } else if (node.type === "asset" && node.assetType?.valueNode?.value) {
+    current = node.assetType.valueNode?.value;
+  }
+  return [prefix, current].filter(Boolean).join("-");
+};
+var createViolation = (node) => {
+  const valueNode = node.id?.valueNode;
+  if (!valueNode) {
+    return;
+  }
+  return {
+    node: valueNode,
+    severity: DiagnosticSeverity4.Error,
+    message: `The id "${node.id?.valueNode?.value}" is already in use in this view.`,
+    fix: () => {
+      return {
+        name: "Generate new ID",
+        edit: replaceString(valueNode, `"${generateID(node)}"`)
+      };
+    }
+  };
+};
+var createValidationVisitor2 = (ctx) => {
+  const viewInfo = /* @__PURE__ */ new Map();
+  return {
+    AssetNode: (assetNode) => {
+      const view = getViewNode(assetNode);
+      if (!view) {
+        throw new Error(
+          "Asset found but not within a view. Something is wrong"
+        );
+      }
+      const assetID = assetNode.id;
+      if (!assetID || !assetID.valueNode?.value) {
+        return;
+      }
+      const id = assetID.valueNode?.value;
+      if (!viewInfo.has(view)) {
+        viewInfo.set(view, /* @__PURE__ */ new Map());
+      }
+      const assetIDMap = viewInfo.get(view);
+      const idInfo = assetIDMap?.get(id);
+      const templateDepth = checkParentTemplate(assetNode);
+      if (templateDepth > 0) {
+        const expectedIndexElements = [];
+        for (let i = 0; i < templateDepth; i++) {
+          expectedIndexElements.push(`_index${i === 0 ? "" : i}_`);
+        }
+        const missingIndexSegments = expectedIndexElements.filter(
+          (e) => !id.includes(e)
+        );
+        if (missingIndexSegments.length !== 0) {
+          ctx.addViolation({
+            node: assetNode,
+            severity: DiagnosticSeverity4.Error,
+            message: `The id for this templated elements is missing the following index segments: ${missingIndexSegments.join(
+              ", "
+            )}`
+          });
+        }
+      }
+      if (idInfo) {
+        if (!idInfo.handled) {
+          const origViolation = createViolation(idInfo.original);
+          if (origViolation) {
+            ctx.addViolation(origViolation);
+          }
+          idInfo.handled = true;
+        }
+        const assetViolation = createViolation(assetNode);
+        if (assetViolation) {
+          ctx.addViolation(assetViolation);
+        }
+      } else {
+        assetIDMap?.set(id, { original: assetNode, handled: false });
+      }
+    }
+  };
+};
+var DuplicateIDPlugin = class {
+  name = "duplicate-id";
+  apply(service) {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(createValidationVisitor2(validation));
+    });
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/missing-asset-wrapper-plugin.ts
+import { DiagnosticSeverity as DiagnosticSeverity5 } from "vscode-languageserver-types";
+var getObjectTarget = (node) => {
+  if (isObjectNode(node)) {
+    return node;
+  }
+  if (isKeyNode(node) && isPropertyNode(node.parent) && isObjectNode(node.parent.valueNode)) {
+    return node.parent.valueNode;
+  }
+};
+var MissingAssetWrapperPlugin = class {
+  name = "missing-asset-wrapper";
+  apply(languageService) {
+    languageService.hooks.onValidateEnd.tap(
+      this.name,
+      (diagnostics, { addFixableViolation, documentContext }) => {
+        let filteredDiags = diagnostics;
+        const expectedAssetDiags = diagnostics.filter(
+          (d) => d.message.includes(
+            `Does not match any of the expected types for type: 'AssetWrapperOrSwitch'`
+          ) || d.message.startsWith("Expected property: asset")
+        );
+        expectedAssetDiags.forEach((d) => {
+          const originalNode = documentContext.PlayerContent.getNodeFromOffset(
+            documentContext.document.offsetAt(d.range.start)
+          );
+          const objectNode = getObjectTarget(originalNode);
+          if (objectNode && originalNode) {
+            const associatedDiags = filteredDiags.filter((nestedDiag) => {
+              const diagNode = documentContext.PlayerContent.getNodeFromOffset(
+                documentContext.document.offsetAt(nestedDiag.range.start)
+              );
+              return objectNode.properties.some((p) => p.keyNode === diagNode);
+            });
+            addFixableViolation(d, {
+              node: originalNode,
+              message: d.message,
+              severity: d.severity ?? DiagnosticSeverity5.Error,
+              fix: () => ({
+                name: `Wrap in "asset"`,
+                edit: {
+                  type: "replace",
+                  node: objectNode,
+                  value: formatLikeNode(documentContext.document, objectNode, {
+                    asset: getNodeValue(objectNode)
+                  })
+                }
+              })
+            });
+            filteredDiags = filteredDiags.filter(
+              (filteredD) => !associatedDiags.includes(filteredD)
+            );
+          }
+        });
+        return filteredDiags;
+      }
+    );
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/nav-state-plugin.ts
+import {
+  CompletionItemKind as CompletionItemKind3,
+  DiagnosticSeverity as DiagnosticSeverity6
+} from "vscode-languageserver-types";
+var createValidationVisitor3 = (ctx) => {
+  const validTransitions = /* @__PURE__ */ new Map();
+  return {
+    FlowNode: (flowNode) => {
+      const flowNodeId = flowNode.parent?.keyNode.value;
+      flowNode.states.forEach((p) => {
+        if (!validTransitions.has(flowNodeId)) {
+          validTransitions.set(flowNodeId, /* @__PURE__ */ new Set());
+        }
+        validTransitions.get(flowNodeId)?.add(p.keyNode.value);
+      });
+    },
+    FlowStateNode: (flowState) => {
+      const transitions = flowState.properties.find(
+        (p) => p.keyNode.value === "transitions"
+      );
+      let flowNode = flowState.parent;
+      while (flowNode && !isFlowNode(flowNode)) {
+        flowNode = flowNode?.parent;
+      }
+      const flowNodeId = flowNode?.parent?.keyNode.value;
+      transitions?.valueNode?.children?.forEach((transitionObjects) => {
+        if (transitionObjects.type === "property" && transitionObjects.valueNode?.type === "string") {
+          if (!validTransitions.get(flowNodeId)?.has(transitionObjects.valueNode.value)) {
+            ctx.addViolation({
+              node: transitionObjects.valueNode,
+              severity: DiagnosticSeverity6.Error,
+              message: `Node "${transitionObjects.valueNode.value}" not found`
+            });
+          }
+        }
+      });
+    }
+  };
+};
+var isTransitionValue = (node) => {
+  return node.type === "string" && isPropertyNode(node.parent) && node.parent.parent?.type === "object" && isPropertyNode(node.parent.parent.parent) && node.parent.parent.parent.keyNode.value === "transitions" && isStateNode(node.parent.parent.parent.parent) && isPropertyNode(node.parent.parent.parent.parent.parent) && isFlowNode(node.parent.parent.parent.parent.parent.parent);
+};
+var getFlowNode = (node) => {
+  if (isFlowNode(node)) {
+    return node;
+  }
+  if (node.parent) {
+    return getFlowNode(node.parent);
+  }
+};
+var NavStatePlugin = class {
+  name = "nav-state";
+  apply(service) {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(createValidationVisitor3(validation));
+    });
+    service.hooks.complete.tap(this.name, async (ctx, completionCtx) => {
+      if (!isValueCompletion(ctx.node)) {
+        return;
+      }
+      if (isTransitionValue(ctx.node)) {
+        const flowNode = getFlowNode(ctx.node);
+        flowNode?.states.forEach((p) => {
+          completionCtx.addCompletionItem({
+            kind: CompletionItemKind3.Value,
+            label: p.keyNode.value
+          });
+        });
+      }
+    });
+    service.hooks.definition.tap(this.name, (ctx) => {
+      if (!isValueCompletion(ctx.node)) {
+        return;
+      }
+      if (ctx.node.type === "string" && isTransitionValue(ctx.node)) {
+        const flowNode = getFlowNode(ctx.node);
+        const { value } = ctx.node;
+        const flowProp = flowNode?.states.find(
+          (n) => n.keyNode.value === value
+        );
+        if (flowProp) {
+          return getLSLocationOfNode(ctx.document, flowProp.keyNode);
+        }
+      }
+    });
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/plugins/view-node-plugin.ts
+import {
+  CompletionItemKind as CompletionItemKind4,
+  DiagnosticSeverity as DiagnosticSeverity7
+} from "vscode-languageserver-types";
+var createValidationVisitor4 = (ctx, viewInfo) => {
+  return {
+    FlowStateNode: (flowState) => {
+      if (flowState.stateType?.valueNode?.value === "VIEW") {
+        const refNode = getProperty(flowState, "ref");
+        if (!refNode || refNode.valueNode?.type !== "string") {
+          return;
+        }
+        const refID = refNode.valueNode.value;
+        if (viewInfo.views.has(refID)) {
+          return;
+        }
+        ctx.addViolation({
+          node: refNode.valueNode,
+          message: `View with id: ${refID} does not exist.`,
+          severity: DiagnosticSeverity7.Error
+        });
+      }
+    },
+    ViewNode: (viewNode) => {
+      if (viewNode.id && viewNode.id.valueNode?.value !== void 0) {
+        if (!viewInfo.nodes.get(viewNode.id.valueNode?.value)) {
+          ctx.addViolation({
+            node: viewNode.id.valueNode,
+            message: `View is not reachable`,
+            severity: DiagnosticSeverity7.Warning
+          });
+        }
+      }
+    }
+  };
+};
+var getViewInfo = (ctx) => {
+  const views = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Map();
+  const { root } = ctx.PlayerContent;
+  if (root.type === "content") {
+    root.views?.valueNode?.children.forEach((c) => {
+      if (isViewNode(c) && c.id?.valueNode) {
+        views.set(c.id.valueNode.value, {
+          id: c.id.valueNode.value,
+          idProp: c.id
+        });
+      }
+    });
+    root.navigation?.valueNode?.flows.forEach((flow) => {
+      flow.valueNode?.states?.forEach((state) => {
+        if (state.valueNode?.stateType?.valueNode?.value === "VIEW") {
+          const ref = state.valueNode.properties.find(
+            (p) => p.keyNode.value === "ref"
+          );
+          if (ref?.valueNode?.type === "string") {
+            const refVal = ref.valueNode.value;
+            nodes.set(refVal, {
+              id: refVal,
+              refProp: ref
+            });
+          }
+        }
+      });
+    });
+  }
+  return {
+    views,
+    nodes
+  };
+};
+var ViewNodePlugin = class {
+  name = "view-node";
+  apply(service) {
+    let viewInfo;
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      if (!viewInfo) {
+        return;
+      }
+      validation.useASTVisitor(createValidationVisitor4(validation, viewInfo));
+    });
+    service.hooks.onDocumentUpdate.tap(this.name, (ctx) => {
+      viewInfo = getViewInfo(ctx);
+    });
+    service.hooks.complete.tap(this.name, async (ctx, completionCtx) => {
+      if (!isValueCompletion(ctx.node)) {
+        return;
+      }
+      if (ctx.node.type === "string" && isPropertyNode(ctx.node.parent) && isStateNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "ref") {
+        Array.from(viewInfo?.views.keys() ?? []).forEach((vID) => {
+          completionCtx.addCompletionItem({
+            kind: CompletionItemKind4.Value,
+            label: vID
+          });
+        });
+      } else if (ctx.node.type === "string" && isPropertyNode(ctx.node.parent) && isViewNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "id") {
+        Array.from(viewInfo?.nodes.keys() ?? []).forEach((vID) => {
+          completionCtx.addCompletionItem({
+            kind: CompletionItemKind4.Value,
+            label: vID
+          });
+        });
+      }
+    });
+    service.hooks.definition.tap(this.name, (ctx) => {
+      if (!isValueCompletion(ctx.node)) {
+        return;
+      }
+      if (ctx.node.type === "string" && isPropertyNode(ctx.node.parent)) {
+        if (isViewNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "id") {
+          const { value } = ctx.node;
+          const stateNode = viewInfo?.nodes.get(value);
+          if (stateNode) {
+            return getLSLocationOfNode(ctx.document, stateNode.refProp);
+          }
+        } else if (isStateNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "ref") {
+          const { value } = ctx.node;
+          const viewNode = viewInfo?.views.get(value);
+          if (viewNode) {
+            return getLSLocationOfNode(ctx.document, viewNode.idProp);
+          }
+        }
+      }
+    });
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/xlr/transforms.ts
+import { simpleTransformGenerator } from "@xlr-lib/xlr-sdk";
+import { isPrimitiveTypeNode } from "@xlr-lib/xlr-utils";
+var applyCommonProps = (node, capability) => {
+  return simpleTransformGenerator("object", ["Assets", "Views"], (xlrNode) => {
+    if (!xlrNode.properties.applicability) {
+      xlrNode.properties.applicability = {
+        required: false,
+        node: {
+          type: "or",
+          name: "Applicability",
+          description: "Evaluate the given expression (or boolean) and if falsy, remove this node from the tree. This is re-computed for each change in the data-model",
+          or: [
+            {
+              type: "boolean"
+            },
+            {
+              type: "ref",
+              ref: "Expression"
+            }
+          ]
+        }
+      };
+    }
+    if (!xlrNode.properties._comment) {
+      xlrNode.properties._comment = {
+        required: false,
+        node: {
+          description: "Adds a comment for the given node",
+          type: "string"
+        }
+      };
+    }
+    return xlrNode;
+  })(node, capability);
+};
+var applyAssetWrapperOrSwitch = (node, capability) => {
+  return simpleTransformGenerator("ref", ["Assets", "Views"], (xlrNode) => {
+    if (xlrNode.ref.includes("AssetWrapper")) {
+      return {
+        ...xlrNode,
+        ref: xlrNode.ref.replace("AssetWrapper", "AssetWrapperOrSwitch")
+      };
+    }
+    return xlrNode;
+  })(node, capability);
+};
+var applyValueRefs = (node, capability) => {
+  return simpleTransformGenerator(
+    "object",
+    ["Assets", "Views"],
+    (inputNode) => {
+      const xlrNode = { ...inputNode };
+      for (const key in xlrNode.properties) {
+        if (key === "id") {
+          continue;
+        }
+        const value = xlrNode.properties[key];
+        if (value.node.type === "or") {
+          value.node.or.push({
+            type: "ref",
+            ref: "ExpressionRef"
+          });
+          value.node.or.push({
+            type: "ref",
+            ref: "BindingRef"
+          });
+        } else if (isPrimitiveTypeNode(value.node)) {
+          const newUnionType = {
+            type: "or",
+            description: value.node.description,
+            or: [
+              value.node,
+              {
+                type: "ref",
+                ref: "ExpressionRef"
+              },
+              {
+                type: "ref",
+                ref: "BindingRef"
+              }
+            ]
+          };
+          value.node = newUnionType;
+        }
+      }
+      return xlrNode;
+    }
+  )(node, capability);
+};
+var applyTemplateProperty = (node, capability) => {
+  return simpleTransformGenerator(
+    "object",
+    ["Assets", "Views"],
+    (inputNode) => {
+      const templateTypes = [];
+      const xlrNode = { ...inputNode };
+      for (const key in xlrNode.properties) {
+        const value = xlrNode.properties[key];
+        if (value.node.type === "array") {
+          value.required = false;
+          templateTypes.push({
+            type: "ref",
+            ref: `Template<${value.node.elementType.type === "ref" ? value.node.elementType.ref : value.node.elementType.name}, "${key}">`,
+            genericArguments: [
+              value.node.elementType,
+              {
+                type: "string",
+                const: key
+              }
+            ]
+          });
+        }
+      }
+      if (templateTypes.length > 0) {
+        const templateType = {
+          type: "array",
+          elementType: templateTypes.length > 1 ? { type: "or", or: templateTypes } : templateTypes[0],
+          description: "A list of templates to process for this node"
+        };
+        xlrNode.properties.template = {
+          required: false,
+          node: templateType
+        };
+      }
+      return xlrNode;
+    }
+  )(node, capability);
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/constants.ts
+var PLUGINS = [
+  new DuplicateIDPlugin(),
+  new ViewNodePlugin(),
+  new SchemaInfoPlugin(),
+  new AssetWrapperArrayPlugin(),
+  new NavStatePlugin(),
+  new MissingAssetWrapperPlugin(),
+  new XLRPlugin()
+];
+var DEFAULT_FILTERS = {
+  typeFilter: "Transformed"
+};
+var TRANSFORM_FUNCTIONS = [
+  applyAssetWrapperOrSwitch,
+  applyValueRefs,
+  applyCommonProps,
+  applyTemplateProperty
+];
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/xlr/registry.ts
+import { BasicXLRRegistry } from "@xlr-lib/xlr-sdk";
+var PlayerXLRRegistry = class extends BasicXLRRegistry {
+  /** Keeps the mapping of how a type is referenced by Player to the underlying XLR */
+  registrationMap;
+  constructor() {
+    super();
+    this.registrationMap = /* @__PURE__ */ new Map();
+  }
+  get(id) {
+    const realNames = this.registrationMap.get(id);
+    if (realNames === void 0) {
+      return void 0;
+    }
+    if (Array.isArray(realNames)) {
+      return {
+        name: `${id}PartialMatchType`,
+        source: "registry.ts",
+        type: "or",
+        or: realNames.map(
+          (partialMatchID) => super.get(partialMatchID)
+        )
+      };
+    }
+    return super.get(realNames);
+  }
+  add(type, plugin, capability) {
+    let registeredName = type.name;
+    if ((capability === "Assets" || capability === "Views") && type.type === "object" && type.extends?.genericArguments?.[0]?.type === "string" && type.extends?.genericArguments?.[0]?.const) {
+      this.registrationMap.set(registeredName, type.name);
+      registeredName = type.extends.genericArguments[0].const;
+    }
+    if (this.registrationMap.has(registeredName)) {
+      const current = this.registrationMap.get(registeredName);
+      if (Array.isArray(current)) {
+        current.push(registeredName);
+      } else {
+        this.registrationMap.set(registeredName, [current, type.name]);
+      }
+    } else {
+      this.registrationMap.set(registeredName, type.name);
+    }
+    super.add(type, plugin, capability);
+  }
+  has(id) {
+    return this.registrationMap.has(id);
+  }
+  list(filterArgs) {
+    return super.list(filterArgs);
+  }
+  info(id) {
+    const realNames = this.registrationMap.get(id);
+    if (realNames === void 0) {
+      return void 0;
+    }
+    if (Array.isArray(realNames)) {
+      const metaDataArrays = realNames.map((name) => super.info(name));
+      const firstElement = metaDataArrays[0];
+      const equal = metaDataArrays.every(
+        (metaData) => metaData?.plugin === firstElement?.plugin && metaData?.capability === firstElement?.capability
+      );
+      if (equal) {
+        return firstElement;
+      }
+      throw Error(
+        `Error: can't determine accurate info for type ${id} as it is provided by multiple plugins/capabilities`
+      );
+    }
+    return super.info(realNames);
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/xlr/service.ts
+import { XLRSDK } from "@xlr-lib/xlr-sdk";
+var XLRService = class {
+  baseTypes = [
+    "asset",
+    "view",
+    "flow",
+    "content",
+    "navigation",
+    "state"
+  ];
+  XLRSDK;
+  constructor() {
+    this.XLRSDK = new XLRSDK(new PlayerXLRRegistry());
+  }
+  walker(n, path) {
+    if (this.baseTypes.indexOf(n.type) > -1) {
+      if (n.type === "asset") {
+        const name = this.XLRSDK.hasType(n.assetType?.valueNode?.value ?? "") ? n.assetType?.valueNode?.value : "Asset";
+        return {
+          name,
+          path
+        };
+      }
+      if (n.type === "view") {
+        const name = this.XLRSDK.hasType(n.viewType?.valueNode?.value ?? "") ? n.viewType?.valueNode?.value : "View";
+        return { name, path };
+      }
+      if (n.type === "state") {
+        if (n.stateType?.valueNode?.value) {
+          const flowStateType = mapFlowStateToType(
+            n.stateType?.valueNode?.value
+          );
+          if (flowStateType) {
+            return { name: flowStateType, path };
+          }
+        }
+      }
+      if (n.type === "content") {
+        return { name: "Flow", path };
+      }
+      if (n.type === "flow") {
+        return { name: "NavigationFlow", path };
+      }
+      if (n.type === "navigation") {
+        return { name: "Navigation", path };
+      }
+    }
+    if (n.parent) {
+      path.push(n.parent);
+      return this.walker(n.parent, path);
+    }
+    return void 0;
+  }
+  getTypeInfoAtPosition(node) {
+    if (!node) return;
+    const pointer = node;
+    const xlrInfo = this.walker(pointer, []);
+    if (!xlrInfo) return;
+    const activeNode = this.XLRSDK.getType(xlrInfo.name);
+    if (!activeNode) return;
+    let nearestObjectTypes = [activeNode];
+    let pointers = [];
+    if (activeNode.type === "and") {
+      pointers = activeNode.and;
+    } else if (activeNode.type === "or") {
+      pointers = activeNode.or;
+    } else {
+      pointers = [activeNode];
+    }
+    for (const pathSegment of xlrInfo.path.reverse()) {
+      const newPointers = [];
+      for (let nodePointer of pointers) {
+        let newNode;
+        if (nodePointer.type === "ref") {
+          if (this.XLRSDK.hasType(nodePointer.ref)) {
+            nodePointer = this.XLRSDK.getType(nodePointer.ref);
+          } else {
+            continue;
+          }
+        }
+        if (pathSegment.type === "property" && nodePointer.type === "object") {
+          if (nodePointer?.properties[pathSegment.keyNode.value]) {
+            newNode = nodePointer?.properties[pathSegment.keyNode.value]?.node;
+          } else if (nodePointer?.additionalProperties) {
+            const adNode = nodePointer?.additionalProperties;
+            if (typeof adNode !== "boolean") {
+              newNode = adNode;
+            }
+          }
+        } else if (pathSegment.type === "object" || this.baseTypes.indexOf(pathSegment.type) !== -1) {
+          newNode = nodePointer;
+        } else if (pathSegment.type === "array") {
+          newNode = nodePointer.elementType;
+        }
+        if (!newNode) {
+          continue;
+        } else if (newNode.type === "or") {
+          newPointers.push(...newNode.or);
+        } else if (newNode.type === "and") {
+          newPointers.push(...newNode.and);
+        } else if (newNode.type === "ref" && this.XLRSDK.hasType(newNode.ref)) {
+          newPointers.push(this.XLRSDK.getType(newNode.ref));
+        } else {
+          newPointers.push(newNode);
+        }
+      }
+      if (newPointers.filter((n) => n).length === 0) {
+        break;
+      }
+      const newObjectTypes = newPointers.filter(
+        (n) => n.type === "object"
+      );
+      if (newObjectTypes.length > 0) {
+        nearestObjectTypes = newObjectTypes;
+      }
+      pointers = newPointers;
+    }
+    return {
+      name: xlrInfo.name,
+      nodes: pointers,
+      nearestObjects: nearestObjectTypes
+    };
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/types.ts
+var LOG_TYPES = ["debug", "info", "warn", "error"];
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/lsp/json-language-service/src/index.ts
+var PlayerLanguageService = class {
+  XLRService;
+  parseCache = /* @__PURE__ */ new Map();
+  fixableViolationsForDocument = /* @__PURE__ */ new Map();
+  hooks = {
+    onDocumentUpdate: new SyncHook(),
+    validate: new AsyncParallelHook(),
+    onValidateEnd: new SyncWaterfallHook(),
+    complete: new AsyncParallelHook(),
+    hover: new SyncBailHook(),
+    definition: new SyncBailHook()
+  };
+  constructor(config) {
+    this.XLRService = new XLRService();
+    PLUGINS.forEach((p) => p.apply(this));
+    config?.plugins?.forEach((p) => p.apply(this));
+  }
+  parseTextDocument(document) {
+    if (!this.parseCache.has(document.uri)) {
+      const parsed = parse(document);
+      this.parseCache.set(document.uri, { version: document.version, parsed });
+      return parsed;
+    }
+    const cached = this.parseCache.get(document.uri);
+    if (!cached || cached.version < document.version) {
+      this.parseCache.delete(document.uri);
+      return this.parseTextDocument(document);
+    }
+    return cached.parsed;
+  }
+  async updateSource(document) {
+    const parsed = this.parseTextDocument(document);
+    const documentContext = {
+      log: {
+        debug: console.log,
+        info: console.log,
+        warn: console.warn,
+        error: console.error
+      },
+      document,
+      PlayerContent: parsed
+    };
+    const ctx = {
+      ...documentContext
+    };
+    this.hooks.onDocumentUpdate.call(ctx);
+    return ctx;
+  }
+  async getJSONPositionInfo(ctx, position) {
+    const { document, PlayerContent: PlayerContent2 } = ctx;
+    const node = PlayerContent2.getNodeFromOffset(document.offsetAt(position));
+    return {
+      node
+    };
+  }
+  async updateSourceWithPosition(document, position) {
+    const ctx = await this.updateSource(document);
+    const { node } = await this.getJSONPositionInfo(ctx, position);
+    const XLRInfo = this.XLRService.getTypeInfoAtPosition(node);
+    if (!node || !XLRInfo) {
+      return void 0;
+    }
+    return {
+      ...ctx,
+      node,
+      position,
+      XLR: XLRInfo
+    };
+  }
+  onClose(document) {
+    this.fixableViolationsForDocument.delete(document.uri);
+    this.parseCache.delete(document.uri);
+  }
+  async formatTextDocument(document, options, range) {
+    const formattingOptions = {
+      tabSize: options.tabSize,
+      insertSpaces: options.insertSpaces
+    };
+    let formatRange;
+    if (range) {
+      const startOffset = document.offsetAt(range.start);
+      formatRange = {
+        offset: startOffset,
+        length: document.offsetAt(range.end) - startOffset
+      };
+    }
+    return formatJSON(document.getText(), formatRange, formattingOptions).map(
+      (edit) => {
+        return TextEdit2.replace(
+          Range4.create(
+            document.positionAt(edit.offset),
+            document.positionAt(edit.offset + edit.length)
+          ),
+          edit.content
+        );
+      }
+    );
+  }
+  async validateTextDocument(document) {
+    const ctx = await this.updateSource(document);
+    this.fixableViolationsForDocument.delete(document.uri);
+    if (!isKnownRootType(ctx.PlayerContent)) {
+      return;
+    }
+    const diagnostics = [...ctx.PlayerContent.syntaxErrors];
+    const astVisitors = [];
+    const addFixableViolation = (diagnostic, violation) => {
+      if (!this.fixableViolationsForDocument.has(document.uri)) {
+        this.fixableViolationsForDocument.set(document.uri, /* @__PURE__ */ new Map());
+      }
+      const fixableDiags = this.fixableViolationsForDocument.get(document.uri);
+      fixableDiags?.set(diagnostic, violation);
+    };
+    if (ctx.PlayerContent.root) {
+      const validationContext = {
+        addViolation: (violation) => {
+          const { message, node, severity, fix } = violation;
+          const range = toRange(document, node);
+          const diagnostic = {
+            message,
+            severity,
+            range
+          };
+          if (fix) {
+            addFixableViolation(diagnostic, violation);
+          }
+          diagnostics.push(diagnostic);
+        },
+        useASTVisitor: (visitor) => {
+          astVisitors.push(visitor);
+        },
+        addDiagnostic(d) {
+          diagnostics.push(d);
+        }
+      };
+      await this.hooks.validate.call(ctx, validationContext);
+      await walk(ctx.PlayerContent.root, async (node) => {
+        const visitorProp = typeToVisitorMap[node.type];
+        astVisitors.forEach(async (visitor) => {
+          try {
+            await visitor[visitorProp]?.(node);
+          } catch (e) {
+            ctx.log?.error(
+              `Error running rules for ${visitorProp}: ${e.message}, Stack ${e.stack}`
+            );
+          }
+        });
+        return false;
+      });
+    }
+    return this.hooks.onValidateEnd.call(diagnostics, {
+      documentContext: ctx,
+      addFixableViolation
+    });
+  }
+  async getCompletionsAtPosition(document, position) {
+    const ctxWithPos = await this.updateSourceWithPosition(document, position);
+    if (!ctxWithPos) {
+      return CompletionList.create();
+    }
+    const completionItems = [];
+    const completionContext = {
+      addCompletionItem: (i) => {
+        completionItems.push(i);
+      }
+    };
+    await this.hooks.complete.call(ctxWithPos, completionContext);
+    return CompletionList.create(completionItems);
+  }
+  async resolveCompletionItem(completionItem) {
+    return completionItem;
+  }
+  async getHoverInfoAtPosition(document, position) {
+    const context = await this.updateSourceWithPosition(document, position);
+    if (!context) {
+      return void 0;
+    }
+    return this.hooks.hover.call(context);
+  }
+  async getCodeActionsInRange(document, context) {
+    const diagsForDocument = this.fixableViolationsForDocument.get(
+      document.uri
+    );
+    if (!diagsForDocument || diagsForDocument.size === 0 || context.diagnostics.length === 0) {
+      return [];
+    }
+    const actions = [];
+    diagsForDocument.forEach((violation, diagnostic) => {
+      const matching = context.diagnostics.find(
+        (diag) => containsRange(diagnostic.range, diag.range)
+      );
+      const fixedAction = violation.fix?.();
+      if (!matching || !fixedAction) {
+        return;
+      }
+      actions.push({
+        title: fixedAction.name,
+        kind: CodeActionKind.QuickFix,
+        edit: {
+          changes: {
+            [document.uri]: [toTextEdit(document, fixedAction.edit)]
+          }
+        }
+      });
+    });
+    return actions;
+  }
+  async getDefinitionAtPosition(document, position) {
+    const context = await this.updateSourceWithPosition(document, position);
+    if (!context) {
+      return void 0;
+    }
+    return this.hooks.definition.call(context);
+  }
+  addXLRTransforms(transforms) {
+    Object.entries(transforms).forEach(
+      ([name, fn]) => this.XLRService.XLRSDK.addTransformFunction(name, fn)
+    );
+  }
+  addLSPPlugin(plugin) {
+    plugin.apply(this);
+  }
+  async setAssetTypes(typeFiles) {
+    typeFiles.forEach((file) => {
+      if (file.includes("types")) {
+        this.XLRService.XLRSDK.loadDefinitionsFromDisk(file, {});
+      } else {
+        this.XLRService.XLRSDK.loadDefinitionsFromDisk(
+          file,
+          DEFAULT_FILTERS,
+          TRANSFORM_FUNCTIONS
+        );
+      }
+    });
+  }
+  async setAssetTypesFromModule(manifest) {
+    await Promise.allSettled(
+      manifest.map((m) => {
+        if (m.capabilities["Types"]?.length) {
+          return this.XLRService.XLRSDK.loadDefinitionsFromModule(m);
+        } else {
+          return this.XLRService.XLRSDK.loadDefinitionsFromModule(
+            m,
+            DEFAULT_FILTERS,
+            TRANSFORM_FUNCTIONS
+          );
+        }
+      })
+    );
+  }
+};
+export {
+  ASTNodeImpl,
+  ArrayASTNodeImpl,
+  AssetASTNodeImpl,
+  BooleanASTNodeImpl,
+  ContentASTNodeImpl,
+  DEFAULT_FILTERS,
+  FlowASTNodeImpl,
+  FlowStateASTNodeImpl,
+  LOG_TYPES,
+  NavigationASTNodeImpl,
+  NullASTNodeImpl,
+  NumberASTNodeImpl,
+  ObjType,
+  ObjectASTNodeImpl,
+  PLUGINS,
+  PlayerContent,
+  PlayerLanguageService,
+  PlayerXLRRegistry,
+  PropertyASTNodeImpl,
+  StringASTNodeImpl,
+  TRANSFORM_FUNCTIONS,
+  ViewASTNodeImpl,
+  XLRService,
+  applyAssetWrapperOrSwitch,
+  applyCommonProps,
+  applyTemplateProperty,
+  applyValueRefs,
+  containsRange,
+  formatLikeNode,
+  getContentNode,
+  getLSLocationOfNode,
+  getNodeValue,
+  getPropForValNode,
+  getProperty,
+  getValForKey,
+  getViewNode,
+  isFlowNode,
+  isKeyNode,
+  isKnownRootType,
+  isNavigationNode,
+  isObjectNode,
+  isPropertyCompletion,
+  isPropertyNode,
+  isStateNode,
+  isValueCompletion,
+  isValueNode,
+  isViewNode,
+  mapFlowStateToType,
+  parse,
+  replaceString,
+  toRange,
+  toTextDocument,
+  toTextEdit,
+  typeToVisitorMap,
+  walk
+};
+//# sourceMappingURL=index.mjs.map